ultimate-brain 0.3.1 → 0.4.0

package/dist/commands/views.js

@@ -3,36 +3,50 @@ import { serializeNewFile } from "../lib/frontmatter.js";
 import { generateId } from "../lib/ids.js";
 import { compareCodePoints } from "../lib/notes.js";
 import { formatDate, formatTimestamp } from "../lib/time.js";
-import { deriveView, generatedBlockRange, projectViewPath } from "../lib/views.js";
+import { areaBriefPath, deriveView, generatedBlockRange, projectViewPath } from "../lib/views.js";
 import { Workspace } from "../lib/workspace.js";
-/** `brain views [--project <id>] [--check]` (spec/cli.md §5.9). */
+/** `brain views [--project <id> | --area <id>] [--check]` (spec/cli.md §5.9). */
 export const viewsCommand = {
     name: "views",
-    usage: "brain views [--project <id>] [--check] [--json]",
-    summary: "Regenerate project briefs and decision logs while preserving user blocks.",
-    options: { project: "string", check: "boolean" },
+    usage: "brain views [--project <id> | --area <id>] [--check] [--json]",
+    summary: "Regenerate project briefs, decision logs and area briefs while preserving user blocks.",
+    options: { project: "string", area: "string", check: "boolean" },
     maxPositionals: 0,
     needsBrain: true,
     async run({ args, brain, now }) {
         const workspace = await Workspace.open(brain);
         const requested = args.options.project;
-        let projects = workspace.notes.filter((note) => note.type === "project");
+        const requestedArea = args.options.area;
+        if (requested !== undefined && requestedArea !== undefined)
+            throw new BrainError("USAGE", "Use --project or --area, not both");
+        let projects = requestedArea === undefined ? workspace.notes.filter((note) => note.type === "project") : [];
+        let areas = requested === undefined ? workspace.notes.filter((note) => note.type === "area") : [];
         if (requested !== undefined) {
             const project = workspace.get(requested);
             if (project?.type !== "project")
                 throw new BrainError("UNKNOWN_ID", `No project with id ${requested}`);
             projects = [project];
         }
+        if (requestedArea !== undefined) {
+            const area = workspace.get(requestedArea);
+            if (area?.type !== "area")
+                throw new BrainError("UNKNOWN_ID", `No area with id ${requestedArea}`);
+            areas = [area];
+        }
         projects.sort((left, right) => compareCodePoints(left.path, right.path));
+        areas.sort((left, right) => compareCodePoints(left.path, right.path));
+        const targets = [
+            ...projects.flatMap((project) => ["brief", "decision_log"].map((kind) => ({ owner: project, kind, path: projectViewPath(project, kind) }))),
+            ...areas.map((area) => ({ owner: area, kind: "area_brief", path: areaBriefPath(area) })),
+        ];
         const written = [];
         const created = [];
         const unchanged = [];
         const errors = [];
         const ids = workspace.ids();
         const check = args.options.check === true;
-        for (const project of projects) {
-            for (const kind of ["brief", "decision_log"]) {
-                const path = projectViewPath(project, kind);
+        for (const { owner: project, kind, path } of targets) {
+            {
                 const existing = workspace.notes.find((note) => note.path === path);
                 const derived = deriveView(project, kind, workspace.notes);
                 if (existing === undefined && workspace.exists(path)) {
@@ -48,7 +62,8 @@ export const viewsCommand = {
                     }
                     continue;
                 }
-                const range = existing.type === "view" && existing.attributes.project === project.id && existing.attributes.view_kind === kind
+                const owned = kind === "area_brief" ? existing.attributes.area === project.id : existing.attributes.project === project.id;
+                const range = existing.type === "view" && owned && existing.attributes.view_kind === kind
                     ? generatedBlockRange(existing.body)
                     : undefined;
                 if (range === undefined) {
@@ -86,20 +101,20 @@ export const viewsCommand = {
         errors.sort((left, right) => compareCodePoints(left.path, right.path));
         const exitCode = errors.length > 0 || (check && (written.length > 0 || created.length > 0)) ? 1 : 0;
         return {
-            data: { projects: projects.length, written, created, unchanged, errors, check },
+            data: { projects: projects.length, areas: areas.length, written, created, unchanged, errors, check },
             exitCode,
             human: errors.length > 0 ? `${errors.map((error) => `${error.path}: ${error.reason}`).join("\n")}\n` : "Views are current.\n",
         };
     },
 };
-function newViewAttributes(id, project, kind, generatedFrom, now) {
-    const suffix = kind === "brief" ? "brief" : "decision log";
+function newViewAttributes(id, owner, kind, generatedFrom, now) {
+    const suffix = kind === "decision_log" ? "decision log" : "brief";
     return {
         id,
         type: "view",
-        title: `${String(project.attributes.title)} — ${suffix}`,
+        title: `${String(owner.attributes.title)} — ${suffix}`,
         view_kind: kind,
-        project: project.id,
+        ...(kind === "area_brief" ? { area: owner.id } : { project: owner.id }),
         generated_from: generatedFrom,
         generated_at: formatTimestamp(now),
         created: formatDate(now),

package/dist/lib/apply.js

@@ -6,7 +6,7 @@ import { stageNewItem } 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"]);
+export const EDITABLE = new Set(["update_fact", "contradiction", "add_to_note", "answer"]);
 /** 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. */
@@ -60,8 +60,8 @@ export function parseApplyInput(input) {
             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) || typeof entry.field !== "string" || !Object.hasOwn(entry, "value"))))
-            problems.push({ pointer: `${pointer}/exclude`, message: "must be a list of {field, value} pairs" });
+        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 (!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")
@@ -193,11 +193,23 @@ function applyDecision(workspace, input, today, recordOnly) {
         throw new ItemFailure("EDIT_NOT_ALLOWED", `edit is not allowed on a ${String(p.kind)} proposal (spec/schema.md §11.1)`);
     }
     if (decision.exclude !== undefined) {
-        if (decision.action !== "approve" || p.kind !== "add_link")
-            throw new ItemFailure("INPUT_INVALID", "exclude is only allowed on an approved add_link proposal");
-        const links = proposalLinks(p);
-        if (decision.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");
+        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 (p.kind === "add_link") {
+            if (decision.exclude.some((excluded) => excluded.target !== undefined || isNoteExclude(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))))
+                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))))
+                throw new ItemFailure("EXCLUDE_UNKNOWN", "exclude contains an entry that is not in the proposal");
+        }
     }
     const action = decision.action === incoming.action ? undefined : decision.action;
     p.decision = decision;
@@ -210,11 +222,19 @@ function applyDecision(workspace, input, today, recordOnly) {
     if (decision.action === "reject") {
         p.status = "closed";
         workspace.save(proposal.path, document);
-        return { result: "closed", action };
+        // 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;
+        return { result: "closed", action, ...(notes === undefined ? {} : { notes }) };
     }
     const D = decision.decided_at.slice(0, 10);
     const V = decision.action === "edit" ? decision.value : undefined;
-    const stale = applyKind(workspace, p, proposal.path, V, D, today, decision.exclude ?? []);
+    if (p.kind === "review_notes") {
+        const notes = reviewNotes(workspace, p, "approve", decision.exclude ?? [], today);
+        p.status = "applied";
+        workspace.save(proposal.path, document);
+        return { result: "applied", action, notes };
+    }
+    const stale = applyKind(workspace, p, proposal.path, V, D, today, (decision.exclude ?? []));
     if (stale !== null) {
         p.status = "closed";
         p.closed_reason = "stale";
@@ -276,6 +296,10 @@ function applyKind(workspace, p, proposalPath, V, D, today, exclude = []) {
         case "merge":
             merge(workspace, target, existing(workspace, String(p.merge_into)), today);
             return null;
+        case "answer":
+            // edit: your Note is the answer, as text; otherwise the note that holds it, else the sentence.
+            a.answer = V !== undefined ? String(V) : p.answer_note ?? p.answer;
+            break;
         default:
             throw new ItemFailure("INVALID_RESULT", `Unknown proposal kind ${kind}`);
     }
@@ -283,6 +307,55 @@ function applyKind(workspace, p, proposalPath, V, D, today, exclude = []) {
     workspace.save(target.path, document);
     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`.
+ */
+function reviewNotes(workspace, p, action, exclude, today) {
+    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);
+        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);
+            document.attributes.lifecycle = next;
+            document.attributes.updated = today;
+            workspace.save(note.path, document);
+            results.push({ id, result: action === "approve" ? "reviewed" : "archived", lifecycle: next });
+        }
+    }
+    if (action === "approve") {
+        for (const link of reviewLinks(p)) {
+            if (exclude.some((entry) => sameLink(link, entry)))
+                continue;
+            const target = existing(workspace, String(link.target));
+            const document = workspace.edit(target);
+            const values = list(document.attributes[String(link.field)]);
+            if (values.some((value) => isDeepStrictEqual(value, link.value)))
+                continue;
+            document.attributes[String(link.field)] = [...values, link.value];
+            document.attributes.updated = today;
+            workspace.save(target.path, document);
+        }
+    }
+    return results;
+}
+function reviewLinks(proposal) {
+    return list(proposal.links).filter(isRecord).map((link) => ({ target: link.target, field: link.field, value: link.value }));
+}
+function sameLink(link, entry) {
+    return entry.target === link.target && entry.field === link.field && isDeepStrictEqual(entry.value, link.value);
+}
+function isNoteExclude(entry) {
+    return typeof entry.note === "string" && 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 }));

package/dist/lib/errors.js

@@ -12,6 +12,9 @@ export const EXIT_CODES = {
     UNKNOWN_ID: 4,
     ID_IN_USE: 4,
     BEFORE_MISMATCH: 4,
+    REPO_NOT_FOUND: 4,
+    REPO_IS_BRAIN: 4,
+    REPO_COMMIT_UNKNOWN: 4,
     TARGET_NOT_EMPTY: 5,
     ALREADY_A_BRAIN: 5,
     OUTSIDE_ROOT: 5,

package/dist/lib/frontmatter.js

@@ -16,13 +16,15 @@ const TYPE_FIELDS = {
     meeting: ["date", "attendees", "source", "decisions", "questions", "tasks"],
     decision: ["date", "assessment", "decided_in", "deciders", "valid_from", "valid_until"],
     question: ["kind", "raised_in", "answer"],
-    source: ["source_key", "kind", "file_name", "converter", "content_hash", "captured", "origin_edited"],
-    view: ["view_kind", "project", "generated_from", "generated_at"],
+    source: ["source_key", "kind", "file_name", "converter", "content_hash", "captured", "origin_edited", "repo", "repo_path", "commit", "attached_to"],
+    view: ["view_kind", "project", "area", "projects", "question", "asked_in", "generated_from", "generated_at"],
     memory: ["scope", "areas", "projects", "stacks", "confidence", "origin"],
 };
+/** A source's system fields, last and in this order (spec/cli.md §3.6.5). */
+const SOURCE_SYSTEM = ["notion_text", "notion_parts", "notion_text_requested", "notion", "last_synced", "notion_published", "tasks"];
 /** Proposal key order: the spec/schema.md §11 example, then its table. */
 const PROPOSAL_ORDER = [
-    "id", "type", "title", "created", "updated", "kind", "target", "field", "before", "after", "from",
+    "id", "type", "title", "created", "updated", "kind", "target", "field", "links", "notes", "answer", "answer_note", "before", "after", "from",
     "content", "note", "supersedes", "merge_into", "why", "source", "status", "decision", "closed_reason",
     "notion", "notion_published",
 ];
@@ -30,7 +32,10 @@ const PROPOSAL_ORDER = [
 function keyOrder(type) {
     const keys = type === "proposal"
         ? PROPOSAL_ORDER
-        : [...KNOWLEDGE_HEAD, ...(TYPE_FIELDS[String(type)] ?? []), ...KNOWLEDGE_TAIL];
+        : type === "source"
+            // Sources: `digest` right after `summary`, and the system fields last (spec/cli.md §3.6.5).
+            ? [...KNOWLEDGE_HEAD, "digest", ...TYPE_FIELDS.source, ...KNOWLEDGE_TAIL.filter((key) => !SOURCE_SYSTEM.includes(key)), ...SOURCE_SYSTEM]
+            : [...KNOWLEDGE_HEAD, ...(TYPE_FIELDS[String(type)] ?? []), ...KNOWLEDGE_TAIL];
     const ranks = new Map();
     for (const key of keys)
         if (!ranks.has(key))

package/dist/lib/lint.js

@@ -4,6 +4,7 @@ import { join, posix } from "node:path";
 import { installedProduct } from "./skills.js";
 import { buildIndex } from "./index-builder.js";
 import { compareCodePoints } from "./notes.js";
+import { rangesProblem, splitParts } from "./parts.js";
 import { sourceFolder } from "./paths.js";
 import { describeErrors, loadSchemas } from "./schemas.js";
 import { deriveView, generatedBlockRange } from "./views.js";
@@ -12,8 +13,13 @@ const ID = /^(area|gol|prj|per|org|mtg|dec|que|con|src|mem|prp|vw)-[0-9abcdefghj
 const REFERENCE_KEYS = new Set([
     "area", "goal", "client", "org", "projects", "people", "attendees", "decided_in", "raised_in", "deciders",
     "source", "sources", "decisions", "questions", "answer", "target", "supersedes", "merge_into", "project",
-    "generated_from", "facts",
+    "generated_from", "facts", "notes", "answer_note", "links", "attached_to",
 ]);
+/** Where each kind of view must live (spec/schema.md §2, 0041, 0043). */
+const VIEW_FOLDERS = {
+    area_brief: /^areas\/briefs\/[^/]+\.md$/,
+    report: /^reports\/\d{4}-\d{2}-\d{2}-[^/]+\.md$/,
+};
 /** Where each type must live (spec/schema.md §2). */
 const FOLDERS = {
     area: /^areas\/[^/]+\.md$/,
@@ -61,6 +67,14 @@ export function lintBrain(input) {
         if (others.length > 0)
             add("error", "id-duplicate", note.path, lineOfKey(note, "id"), note.id, `${note.id} is also used by ${others.join(", ")}`);
     }
+    // Every review_notes proposal listing each note id (rule review-notes, 0041).
+    const reviewedBy = new Map();
+    for (const note of input.notes) {
+        if (note.type !== "proposal" || note.attributes.kind !== "review_notes")
+            continue;
+        for (const id of new Set(list(note.attributes.notes).map(String)))
+            reviewedBy.set(id, [...(reviewedBy.get(id) ?? []), note.id]);
+    }
     const onDisk = caseSensitiveExists(input.root);
     const exists = (path) => input.pendingPaths?.has(path) === true || onDisk(path);
     for (const note of input.notes) {
@@ -75,7 +89,7 @@ export function lintBrain(input) {
         }
         if (!ID.test(note.id))
             err("id-format", lineOfKey(note, "id"), `"${note.id}" is not <prefix>-<8 chars> with a schema prefix`);
-        const folder = FOLDERS[note.type];
+        const folder = note.type === "view" ? VIEW_FOLDERS[String(a.view_kind)] ?? FOLDERS.view : FOLDERS[note.type];
         const correctFolder = note.type === "source"
             ? new RegExp(`^sources/${sourceFolder(a.source_key)}/\\d{4}-\\d{2}-\\d{2}-[^/]+\\.md$`)
             : folder;
@@ -130,10 +144,10 @@ export function lintBrain(input) {
             if (typeof source === "string" && byId.get(source)?.type === "view")
                 err("view-cited", lineOfKey(note, "sources"), `${source} is a derived view and can't be evidence`);
         }
-        if (note.type === "view" && (a.view_kind === "brief" || a.view_kind === "decision_log")) {
-            const project = byId.get(String(a.project));
+        if (note.type === "view" && (a.view_kind === "brief" || a.view_kind === "decision_log" || a.view_kind === "area_brief")) {
+            const project = byId.get(String(a.view_kind === "area_brief" ? a.area : a.project));
             const range = generatedBlockRange(note.body);
-            if (project?.type === "project" && range !== undefined) {
+            if (project?.type === (a.view_kind === "area_brief" ? "area" : "project") && range !== undefined) {
                 const derived = deriveView(project, a.view_kind, input.notes);
                 const generatedFrom = Array.isArray(a.generated_from) ? a.generated_from : [];
                 if (note.body.slice(range.start, range.end) !== derived.generatedBlock || !sameStringList(generatedFrom, derived.generatedFrom)) {
@@ -199,6 +213,21 @@ export function lintBrain(input) {
             if (problem !== null)
                 err("proposal-status", lineOfKey(note, "status"), problem);
         }
+        if (note.type === "proposal" && a.kind === "review_notes") {
+            for (const id of list(a.notes)) {
+                const listed = byId.get(String(id));
+                if (listed !== undefined && !KNOWLEDGE.has(listed.type))
+                    err("review-notes", lineOfKey(note, "notes"), `${String(id)} is a ${listed.type}, not a knowledge note`);
+                const others = (reviewedBy.get(String(id)) ?? []).filter((other) => other !== note.id);
+                if (others.length > 0)
+                    err("review-notes", lineOfKey(note, "notes"), `${String(id)} is also listed by ${others.join(", ")}`);
+            }
+        }
+        if (note.type === "source" && Array.isArray(a.notion_parts)) {
+            const problem = rangesProblem(a.notion_parts, splitParts(note.body).parts.length);
+            if (problem !== null)
+                err("notion-parts", lineOfKey(note, "notion_parts"), problem);
+        }
         // Quality warnings
         if (KNOWLEDGE.has(note.type)) {
             if (typeof a.summary === "string" && a.summary.length > 200)

package/dist/lib/note-new.js

@@ -3,6 +3,7 @@ import { BrainError } from "./errors.js";
 import { serializeNewFile } from "./frontmatter.js";
 import { generateId, TYPE_PREFIX } from "./ids.js";
 import { assertNoProblems, escapePointer, isRecord, unknownKeys } from "./input.js";
+import { rangesProblem, splitParts } from "./parts.js";
 import { newNotePath } from "./paths.js";
 import { formatDate, formatTimestamp } from "./time.js";
 const ITEM_KEYS = ["type", "id", "title", "file_date", "frontmatter", "body"];
@@ -50,6 +51,17 @@ export function checkNoteInput(value, pointer, withId = true) {
             if (forbidden.includes(key))
                 at(`frontmatter/${escapePointer(key)}`, "is set by the CLI");
         }
+        if (value.type === "source") {
+            // Order, overlap and the part count are not in the JSON Schema (spec/cli.md §5.5).
+            if (value.frontmatter.notion_text_requested !== undefined)
+                at("frontmatter/notion_text_requested", "is set by brain source full-text");
+            const parts = value.frontmatter.notion_parts;
+            if (Array.isArray(parts) && typeof value.body === "string") {
+                const problem = rangesProblem(parts, splitParts(value.body).parts.length);
+                if (problem !== null)
+                    at("frontmatter/notion_parts", problem);
+            }
+        }
     }
     return problems;
 }
@@ -71,6 +83,31 @@ export function stageNotes(workspace, items, pointerOf, options) {
     });
     if (clashes.length > 0)
         throw new BrainError("ID_IN_USE", `${clashes[0].pointer} ${clashes[0].message}`, clashes);
+    // attached_to names a source that exists, or comes earlier in the batch, and isn't attached itself (spec/cli.md §5.5, 0042).
+    const parents = [];
+    items.forEach((item, index) => {
+        const parent = item.type === "source" ? item.frontmatter.attached_to : undefined;
+        if (parent === undefined)
+            return;
+        const existingParent = workspace.get(String(parent));
+        const earlier = items.slice(0, index).find((candidate) => candidate.id === parent);
+        const type = existingParent?.type ?? earlier?.type;
+        const attached = existingParent !== undefined ? existingParent.attributes.attached_to : earlier?.frontmatter.attached_to;
+        const problem = type === undefined ? `${String(parent)} is not an existing source or one earlier in the batch`
+            : type !== "source" ? `${String(parent)} is a ${type}, not a source`
+                : attached !== undefined ? `${String(parent)} is attached to ${String(attached)} itself; attach to that source instead`
+                    : undefined;
+        if (problem !== undefined)
+            parents.push({ pointer: `${pointerOf(index)}/frontmatter/attached_to`, message: problem });
+    });
+    // A repo file names a linked repo of brain.json (0042).
+    const repoNames = new Set(Array.isArray(workspace.config.repos) ? workspace.config.repos.filter(isRecord).map((repo) => repo.name) : []);
+    items.forEach((item, index) => {
+        const repo = item.type === "source" ? item.frontmatter.repo : undefined;
+        if (repo !== undefined && !repoNames.has(repo))
+            parents.push({ pointer: `${pointerOf(index)}/frontmatter/repo`, message: `${String(repo)} is not a linked repo in brain.json repos` });
+    });
+    assertNoProblems(parents);
     const today = formatDate(options.now);
     const taken = new Set([...existing, ...seen]);
     const result = { created: [], skipped: [], pointers: new Map() };
@@ -91,6 +128,13 @@ export function stageNotes(workspace, items, pointerOf, options) {
             }
             attributes.content_hash = hash;
             attributes.captured ??= formatTimestamp(options.now);
+            // The kind sets whether the Inbox row shows the text (0043): full for email and chat.
+            if (attributes.notion_text === undefined && attributes.attached_to === undefined) {
+                if (attributes.kind === "email" || attributes.kind === "chat")
+                    attributes.notion_text = "full";
+                else if (attributes.kind === "document" || attributes.kind === "note")
+                    attributes.notion_text = "digest";
+            }
         }
         const id = item.id ?? generateId(TYPE_PREFIX[item.type], taken);
         taken.add(id);

package/dist/lib/notes.js

@@ -9,6 +9,7 @@ export const NOTE_FOLDERS = [
     "archive",
     "knowledge",
     "sources",
+    "reports",
     "memories",
     "_proposals",
 ];

package/dist/lib/parts.js

@@ -0,0 +1,82 @@
+const SLIDE = /^<!-- Slide number: \d+ -->$/;
+const HEADING = /^(#{1,6}) /;
+const FENCE = /^\s{0,3}(`{3,}|~{3,})/;
+/**
+ * Split a body into parts: slides when it has a slide marker, else the ATX headings outside
+ * fenced code at the smallest level present, else one part holding the whole body.
+ */
+export function splitParts(body) {
+    const lines = body.split(/(?<=\n)/);
+    const bare = (line) => line.replace(/\n$/, "");
+    const slides = lines.some((line) => SLIDE.test(bare(line)));
+    let starts;
+    if (slides) {
+        starts = lines.flatMap((line, index) => (SLIDE.test(bare(line)) ? [index] : []));
+    }
+    else {
+        const headings = [];
+        let fence;
+        lines.forEach((line, index) => {
+            const open = FENCE.exec(line)?.[1];
+            if (fence !== undefined) {
+                if (open !== undefined && open[0] === fence[0] && open.length >= fence.length && bare(line).trim() === open)
+                    fence = undefined;
+                return;
+            }
+            if (open !== undefined) {
+                fence = open;
+                return;
+            }
+            const level = HEADING.exec(line)?.[1]?.length;
+            if (level !== undefined)
+                headings.push({ index, level });
+        });
+        const smallest = Math.min(...headings.map(({ level }) => level));
+        starts = headings.filter(({ level }) => level === smallest).map(({ index }) => index);
+    }
+    if (starts.length === 0)
+        return { kind: "sections", preamble: "", parts: [body] };
+    const parts = starts.map((start, i) => lines.slice(start, starts[i + 1] ?? lines.length).join(""));
+    return { kind: slides ? "slides" : "sections", preamble: lines.slice(0, starts[0]).join(""), parts };
+}
+/** Why a `notion_parts` list is invalid for a body of `count` parts, or null when it is valid. */
+export function rangesProblem(ranges, count) {
+    if (ranges.length === 0)
+        return "must list at least one part";
+    let previous = 0;
+    for (const range of ranges) {
+        const match = typeof range === "string" ? /^([1-9]\d*)(?:-([1-9]\d*))?$/.exec(range) : null;
+        if (match === null)
+            return `"${String(range)}" is not a part number or a range n-m`;
+        const from = Number(match[1]);
+        const to = match[2] === undefined ? from : Number(match[2]);
+        if (match[2] !== undefined && from >= to)
+            return `"${range}" must run from a lower to a higher part`;
+        if (from <= previous)
+            return `"${range}" is out of order or overlaps the range before it`;
+        if (count !== undefined && to > count)
+            return `"${range}" is above the body's ${count} part${count === 1 ? "" : "s"}`;
+        previous = to;
+    }
+    return null;
+}
+/** The 1-based part numbers a valid range list names, ascending. */
+export function selectedParts(ranges) {
+    return ranges.flatMap((range) => {
+        const [from, to = from] = range.split("-").map(Number);
+        return Array.from({ length: to - from + 1 }, (_, i) => from + i);
+    });
+}
+/**
+ * The "Full text" section of a source (spec/cli.md §5.14.4): the preamble, then the chosen
+ * parts in order; a partial choice starts with a line naming it (`*Slides 3–9 of 12*`).
+ */
+export function fullText(body, ranges) {
+    const { kind, preamble, parts } = splitParts(body);
+    const chosen = ranges === null ? parts : selectedParts(ranges).map((n) => parts[n - 1]);
+    const text = `${preamble}${chosen.join("")}`;
+    if (ranges === null)
+        return text;
+    const label = `*${kind === "slides" ? "Slides" : "Sections"} ${ranges.map((range) => range.replace("-", "–")).join(", ")} of ${parts.length}*`;
+    return `${label}\n\n${text}`;
+}