brainllm 12.4.1 → 12.5.0

package/dist/index.js

@@ -20523,7 +20523,7 @@ class BinaryContentError extends Error {
   }
 }
 function isTextMime(mime) {
-  const value = (mime ?? "text/plain").split(";", 1)[0].trim().toLowerCase();
+  const value = (mime ?? "").split(";", 1)[0].trim().toLowerCase() || "text/plain";
   return value.startsWith("text/") || new Set([
     "application/json",
     "application/ld+json",
@@ -20602,6 +20602,9 @@ function isOwnedAttribute(note, attribute) {
 function ownedLabel(note, name) {
   return note.attributes.find((a) => a.type === "label" && a.name === name && isOwnedAttribute(note, a))?.value;
 }
+function isCollectionThread(note) {
+  return ownedLabel(note, "threadShape") === "collection";
+}
 function relationSnippet(note, max = 8) {
   const rels = note.attributes.filter((a) => isOwnedAttribute(note, a) && a.type === "relation" && a.name !== "template").slice(0, max).map((a) => ({ relation: a.name, toNoteId: a.value }));
   return rels.length ? rels : undefined;
@@ -21161,6 +21164,54 @@ class TriliumClient {
   }
 }
 
+// src/icons.ts
+var KIND_ICONS = {
+  biography: "bx bx-id-card",
+  goals: "bx bx-target-lock",
+  preferences: "bx bxs-smile",
+  responsibilities: "bx bxs-analyse",
+  protocols: "bx bx-shield-quarter",
+  selfcorrection: "bx bxs-adjust-alt",
+  diary: "bx bx-book-heart",
+  session: "bx bx-calendar-check",
+  thread: "bx bx-conversation",
+  threadEntry: "bx bx-conversation",
+  user: "bx bx-user",
+  domain: "bx bx-folder",
+  information: "bx bx-info-circle",
+  sources: "bx bx-link",
+  claim: "bx bx-check-shield"
+};
+var FALLBACK_ICON = "bx bx-note";
+var ICON_EXEMPT = new Set(["log"]);
+function defaultIcon(note, parent) {
+  const kind = ownedLabel(note, "noteType");
+  if (kind && ICON_EXEMPT.has(kind))
+    return null;
+  if (kind === "threadEntry")
+    return parent && ownedLabel(parent, "iconClass") || KIND_ICONS.threadEntry;
+  return kind && KIND_ICONS[kind] || FALLBACK_ICON;
+}
+async function ensureIcon(trilium, noteId, known) {
+  const note = known ?? await trilium.getNote(noteId).catch(() => null);
+  if (!note || ownedLabel(note, "iconClass"))
+    return;
+  let parent = null;
+  if (ownedLabel(note, "noteType") === "threadEntry" && note.parentNoteIds[0]) {
+    parent = await trilium.getNote(note.parentNoteIds[0]).catch(() => null);
+    if (parent && !ownedLabel(parent, "iconClass")) {
+      const set = await ensureIcon(trilium, parent.noteId, parent);
+      if (set)
+        parent = await trilium.getNote(parent.noteId).catch(() => parent);
+    }
+  }
+  const cls = defaultIcon(note, parent);
+  if (!cls)
+    return;
+  await trilium.addLabel(noteId, "iconClass", cls).catch(() => null);
+  return cls;
+}
+
 // src/config.ts
 import { existsSync, readFileSync, writeFileSync } from "fs";
 import { join, dirname } from "path";
@@ -22399,11 +22450,6 @@ var hasHeading = (html, text) => new RegExp(`<h[2-4](?:\\s[^>]*)?>\\s*${text}\\s
 var REQUIRED_SECTIONS = {
   thread: ["Context", "Resolution"],
   sources: ["Sources", "Revision"],
-  biography: ["Overview", "Background", "Present"],
-  goals: ["Near-term", "Long-term"],
-  preferences: ["Communication", "Working style", "Tools and stack"],
-  responsibilities: ["Core", "Current priorities"],
-  protocols: ["Operating"],
   selfcorrection: ["Corrections"],
   claim: ["Check", "Verifications"]
 };
@@ -22504,115 +22550,102 @@ function domainContent(name) {
 function purposeContent(purpose) {
   return `<p><em>${escapeHtml(purpose)}</em></p>`;
 }
+var TIMELESS = [
+  "Timeless: what is true regardless of date. No state, version, status, incident or decision history \u2014 state lives in the domain's Current State note, history and decisions in thread entries and sessions, where the date is native",
+  "One sentence is enough if one sentence says it; drop what is rarely relevant to the work",
+  "Merged in place (revise section=/find=), never appended as dated addendum blocks"
+];
 var STRUCTURE_RULES = {
   singleton: {
     structure: [
       "`Last updated - <date>` (h4) \u2014 server-maintained on every write",
-      "Minimal h3 sections; tables for reference data; numbered bold-lead paragraphs for rule/duty lists"
+      "Minimal h3 sections; tables for reference data; short bold-lead rules for rule/duty lists"
     ],
     rules: [
-      "Timeless: no dated incidents, no month-specific references \u2014 current-state only, merged in place",
-      "Replace sections (revise section=/find=), never append dated addendum markers"
+      ...TIMELESS,
+      "LLM singletons derive from the master ones: responsibilities serve goals and preferences, protocols serve responsibilities, self-correction holds only general rules learned from mistakes"
     ]
   },
   diary: {
     structure: [
       "`Addendum \u2014 HH:mm` (h2, server-written)",
-      "Identification line (h3): `LLM \xB7 environment \xB7 agent/mode [\xB7 Run N]` \u2014 pass identity= and the server injects it",
-      "**Experience** (h4) \u2014 unfiltered first-person remarks",
-      "**BrainLLM** (h4) \u2014 remarks on BrainLLM itself (bugs, friction, roadmap)"
+      "Identification line (h3): `LLM \xB7 environment \xB7 agent/mode [\xB7 Run N]` \u2014 pass identity=",
+      "**Experience** (h4), then **BrainLLM** (h4)"
     ],
     rules: [
-      "One note per day, every write lands as a timestamped addendum block",
-      "The identification line is ENFORCED: pass identity= (or lead the body with the h3) \u2014 diary() refuses otherwise",
-      "The closing entry is written at the close-protocol step, after remarks()"
+      "One note per day; every write is a timestamped addendum block",
+      "identity= is enforced; the closing entry is written after remarks()"
     ]
   },
   session: {
     structure: [
       "`Addendum \u2014 HH:mm` (h2, server-written)",
-      "Identification line (h3): same format as diary \u2014 pass identity= on close()",
-      "**Summary** (h4-equivalent, server-rendered) \u2014 factual prose",
-      "**Learned** \u2014 durable bullets [+ further detail sections as warranted]"
+      "Identification line (h3) \u2014 pass identity= on close()",
+      "**Summary**, then **Learned**"
     ],
-    rules: [
-      "Written by close() only; one note per day; chronological record",
-      "The identification line is ENFORCED: pass identity= on close() (or lead the summary with the h3) \u2014 close() refuses otherwise"
-    ]
+    rules: ["Written by close() only; one note per day; identity= is enforced"]
   },
   thread: {
     structure: [
-      "A book note (type=book): server header (thread \xB7 opened <date>) + **Context** (h2) \u2192 **Goal** (h3) \u2014 the goal statement, queried from the user at creation (goal= is required) \u2014 + further h3 context subsections as needed + **Resolution** (h2), exactly one, always the last section, owned by resolve()",
-      "One `[yyyy-mm-dd]` threadEntry child per active day, same shape as a diary/session day: `Addendum \u2014 HH:mm` blocks (h2), each with an identification line (h3) + h4 sections",
-      "Occasional `Withdrawn \u2014 <date>` / `Recovered \u2014 <date>` markers append directly to the book, near Resolution \u2014 rare lifecycle transitions, not routine content, so they stay put rather than moving to a child"
+      "A book note: header (thread \xB7 opened <date>) \u2192 **Context** (h2) \u2192 **Goal** (h3): what the thread is for, in a sentence or two \u2192 optional h3 standing constraints \u2192 **Resolution** (h2), last, owned by resolve()",
+      "Shape **dated** (default): one `[yyyy-mm-dd]` child per active day, made of `Addendum \u2014 HH:mm` blocks with an identification line \u2014 the thread's history",
+      'Shape **collection** (#threadShape=collection, set with remember(shape="collection")): one titled child per item, each a maintained document edited in place \u2014 e.g. an ideas list'
     ],
     rules: [
-      "remember(kind=thread) requires goal= (or a body already carrying the Context structure) to CREATE the book",
-      "Appending to a thread writes into TODAY's child note, never the book \u2014 created on first append of the day; same-day appends merge under a new Addendum \u2014 HH:mm block",
-      "Thread appends require the identification line: pass identity= on remember()/revise() (or lead the body with the h3) \u2014 the write is refused otherwise",
-      "The book never carries a Resolution smuggled into a body \u2014 resolve() owns it exclusively; day-children never carry one at all",
-      "memory() on a thread returns the book's Context/Resolution plus a child-note index \u2014 read a specific day via its own id (or memory(id, date=)). inspect() gives the book's raw content verbatim (no child index) \u2014 that's just Context/Resolution now, not the full history; use memory() first to find the child you actually want, then inspect() that child for its raw labels/attachments",
-      "At the close protocol: unthreaded forward/unfinished work prompts the user for thread creation"
+      "Creating a thread requires goal= (ask the user)",
+      "The book holds purpose, never progress: no status, dates, decisions or narrative \u2014 those are dated children or sessions. One exception: a register thread (e.g. Escalations) keeps its single maintained register table in the book",
+      `Dated: appends land in today's child (identity= required). Collection: add with remember(kind="threadEntry", thread=, title=), change with revise(<entry id>)`,
+      "Only resolve() writes the Resolution"
     ]
   },
   threadEntry: {
     structure: [
-      "Server header (threadEntry \xB7 <date>)",
-      "`Addendum \u2014 HH:mm` (h2) blocks, each with an identification line (h3) \u2014 identical shape to a diary/session day"
+      "Dated: header (threadEntry \xB7 <date>), then `Addendum \u2014 HH:mm` blocks with an identification line",
+      "Collection: a titled maintained document \u2014 minimal h2/h3 sections"
     ],
     rules: [
-      "One note per thread per day, created automatically on first append \u2014 never created directly via remember()",
-      "Chronological record \u2014 every write lands as a new timestamped block, never merged into prose"
+      "Dated entries are created by appending to the thread and are records (never rewritten)",
+      "Collection entries dedup by title within their thread and are edited in place"
     ]
   },
   sources: {
     structure: [
-      "Server header (sources \xB7 domain: <name>)",
-      "`Last updated - <date>` (h4) \u2014 server-maintained",
-      "**Sources** (h2): the \u2747\uFE0F/\u2705 legend line, then the full source list \u2014 every source (URL, doc, file, \u2026) listed and marked individually with just its emoji; related sources grouped under h3 subheadings",
-      "**Revision** (h2): a Source | Marker | Date table, one row per source, current-state only"
+      "Header (sources \xB7 domain) \u2192 `Last updated` (h4)",
+      "**Sources** (h2): the \u2747\uFE0F/\u2705 legend, then every source listed individually with its emoji, grouped under h3s",
+      "**Revision** (h2): Source | Marker | Date, one row per source"
     ],
     rules: [
-      "One maintained Sources note per domain \u2014 auto-created with the domain book",
-      "A clean maintained document: the Sources section merges via remember(), never dated addendum stacks",
-      "Revision rows are upserted by source name \u2014 pass revision=[{source, marker, date}] on remember(kind=sources); re-verifying a source replaces its existing row's Marker/Date in place, it never grows a new row with a re-check-flavored label",
-      "The Source column value must exactly match how the source is introduced in the Sources list \u2014 that's the upsert key"
+      'One per domain, created with the domain; merged via remember(kind="sources"), never stacked',
+      "Revision rows upsert by source name via revision=[{source, marker, date}]; the name must match the Sources list exactly"
     ]
   },
   information: {
     structure: [
-      "Server header (information \xB7 domain \xB7 date)",
-      "`Last updated: <date>` line \u2014 server-maintained once present",
-      "Minimal h3 sections \u2014 current-state truth, revised in place"
+      "Header (information \xB7 domain \xB7 date) \u2192 `Last updated` line (server-maintained)",
+      "Minimal h3 sections"
     ],
     rules: [
-      "One consolidated note per sub-category \u2014 never one note per day/run; no dates or run numbers in titles",
-      "Every claim traces to a Sources-note entry (the sources gate)"
+      ...TIMELESS,
+      "Exception: the note titled **Current State** holds the domain's measured state \u2014 latest value only, with the date it was measured",
+      "One note per sub-category; no dates or run numbers in titles (\u2264 4 words); every claim traces to the Sources note"
     ]
   },
   user: {
-    structure: [
-      "Server header (user \xB7 date)",
-      "`Last updated - <date>` (h4) \u2014 server-maintained once present",
-      "Minimal h3 sections, tables for reference/comparative data"
-    ],
-    rules: ["Current-state, merged in place; titles \u2264 4 words"]
+    structure: ["Header (user \xB7 date) \u2192 `Last updated` (h4) \u2192 minimal h3 sections, tables for reference data"],
+    rules: [...TIMELESS, "Titles \u2264 4 words"]
   },
   log: {
-    structure: ["Server header (log \xB7 date)", "**Created** / **Updated** / **Deleted** (h2) lists"],
-    rules: ["Auto-generated by close(); regenerated in place, never stacked"]
+    structure: ["Header (log \xB7 date) \u2192 **Created** / **Updated** / **Deleted** (h2) lists"],
+    rules: ["Generated by close(); regenerated in place"]
   },
   claim: {
     structure: [
-      "**Check** (h2) \u2014 how to verify the assertion, as inert text: a command, a query, a file path, a URL",
-      "**Verifications** (h2) \u2014 one dated HOLDS/BROKEN line per check, with the evidence observed"
+      "**Check** (h2) \u2014 how to verify, as inert text (command, query, path, URL)",
+      "**Verifications** (h2) \u2014 one dated HOLDS/BROKEN line per check, with evidence"
     ],
     rules: [
-      'Registered and verified only through claim() \u2014 remember(kind="claim") is rejected',
-      "The title IS the assertion, and is the dedup key \u2014 re-registering the same assertion updates its check and keeps its history",
-      "BrainLLM never executes the Check. It has no shell, and note content is data rather than instructions; the agent runs it and reports back",
-      "Verifications are append-only \u2014 the history is the point, so this is one of the few places a dated stack is correct",
-      "A verification without evidence is refused: a verdict alone is an assertion about an assertion"
+      "Only claim() writes claims; the title is the assertion and the dedup key",
+      "BrainLLM never executes the check \u2014 the agent runs it and reports back with evidence"
     ]
   }
 };
@@ -22836,6 +22869,13 @@ function isoDaysAgo(days) {
 function reviewKey(n) {
   return n.blobId ?? n.dateModified;
 }
+var TIMELESS_KINDS = new Set(["thread", "user", "information", "domain"]);
+var DATED_PROSE_LIMIT = 4;
+var MONTHS = "Jan(?:uary)?|Feb(?:ruary)?|Mar(?:ch)?|Apr(?:il)?|May|June?|July?|Aug(?:ust)?|Sep(?:t(?:ember)?)?|Oct(?:ober)?|Nov(?:ember)?|Dec(?:ember)?";
+var DATED_REF = new RegExp(`\\b20\\d\\d-\\d\\d-\\d\\d\\b|\\b\\d{1,2} (?:${MONTHS}) 20\\d\\d\\b|\\b(?:${MONTHS}) \\d{1,2},? 20\\d\\d\\b`, "g");
+function datedReferences(html) {
+  return (toText(html, Number.MAX_SAFE_INTEGER).match(DATED_REF) ?? []).length;
+}
 var STRUCTURE_LINT_LIMIT = 40;
 var SECTION_EDIT_RISK_COUNT = 25;
 var SECTION_EDIT_RISK_CHARS = 8000;
@@ -22902,6 +22942,23 @@ async function sweep(trilium, cfg, opts = {}) {
     }
     report.transitions.push(`archived: ${n.title} (thread, dormant past grace)`);
   }
+  const iconless = await trilium.searchNotes("#!iconClass #noteType != log", { ancestorNoteId: cfg.root, includeArchivedNotes: true, limit: 1000 }).then((r) => r.results).catch(() => []);
+  if (iconless.length) {
+    report.scanned += iconless.length;
+    const entryLast = [...iconless].sort((a, b) => Number(ownedLabel(a, "noteType") === "threadEntry") - Number(ownedLabel(b, "noteType") === "threadEntry"));
+    let set = 0;
+    for (const n of entryLast) {
+      if (dryRun) {
+        if (defaultIcon(n))
+          set++;
+        continue;
+      }
+      if (await ensureIcon(trilium, n.noteId, n))
+        set++;
+    }
+    if (set)
+      report.fixed.push(`icons: ${dryRun ? "would set" : "set"} a default icon on ${set} note${set === 1 ? "" : "s"} that had none`);
+  }
   const typedContainers = [
     { id: cfg.memory.threads, kind: "thread", label: "Threads" },
     { id: cfg.memory.sessions, kind: "session", label: "Sessions" },
@@ -23079,6 +23136,14 @@ async function sweep(trilium, cfg, opts = {}) {
     if (structure.duplicateHeadings.length) {
       report.flagged.push(`duplicate heading: ${n.title} [${n.noteId}] \u2014 '${structure.duplicateHeadings.join("', '")}' repeated in one note; merge with revise(section=\u2026, mode=replace) or target one with occurrence=`);
     }
+    const kindHere = ownedLabel(n, "noteType");
+    const isCurrentState = kindHere === "information" && /^current state$/i.test(n.title.trim());
+    if (kindHere && TIMELESS_KINDS.has(kindHere) && !isCurrentState) {
+      const dated = datedReferences(content);
+      if (dated >= DATED_PROSE_LIMIT) {
+        report.flagged.push(`dated prose: ${n.title} [${n.noteId}] \u2014 ${dated} dated references in a timeless ${kindHere} note. ` + `Keep what is true regardless of date; move state to the domain's Current State and history or decisions to a thread entry.`);
+      }
+    }
     const lintKind = ownedLabel(n, "noteType");
     if (lintKind) {
       const missing = missingSections(lintKind, content);
@@ -23302,7 +23367,7 @@ async function hygienePasses(trilium, cfg, report, ctx) {
   if (cfg.memory.threads) {
     const heavy = await trilium.searchNotes(`#noteType=thread #status=active note.childrenCount > ${THREAD_CONSOLIDATION_CHILDREN}`, { ancestorNoteId: cfg.memory.threads, fastSearch: true, limit: 20 }).then((r) => r.results).catch(() => []);
     for (const n of heavy) {
-      if (!eligible(n))
+      if (!eligible(n) || ownedLabel(n, "threadShape") === "collection")
         continue;
       report.flagged.push(`consolidate: ${n.title} [${n.noteId}] \u2014 ${n.childNoteIds.length} day-children. Fold what the thread has ESTABLISHED into its Context section with revise(section="Context"), so a successor reads the conclusion instead of walking the history.`);
     }
@@ -23675,12 +23740,7 @@ var txt2 = (obj) => ({
 var AREAS = ["biography", "goals", "preferences"];
 function registerMasterTools(server, trilium, brainRef) {
   const b = () => brainRef.config;
-  server.tool("master", `Read a Master singleton: biography, goals, or preferences. Returns its id, content, and
-relation snippet.
-
-section="<heading>" reads ONE section instead of the whole note \u2014 the efficient path on
-preferences, whose schedule tables make it the largest of the three, when the session needs one
-day's blocks rather than the whole week. outline(id) lists the headings.`, {
+  server.tool("master", `Read a master singleton \u2014 biography, goals or preferences \u2014 with its id and relations. section="<heading>" reads one section.`, {
     which: enumType(AREAS),
     section: stringType().optional().describe("Read only this heading's section (h2/h3/h4), instead of the whole note"),
     occurrence: numberType().int().positive().optional().describe("section=: which same-text heading, 1-based (default: the first)")
@@ -23709,18 +23769,7 @@ day's blocks rather than the whole week. outline(id) lists the headings.`, {
 // src/tools-llm.ts
 function registerLlmTools(server, trilium, brainRef) {
   const b = () => brainRef.config;
-  server.tool("llm", `Read an LLM note: responsibilities, protocols or selfcorrection (singletons), or a diary
-entry by id.
-
-selfcorrection holds the assistant's own corrections \u2014 what it got wrong, what generalises, and
-the rule that prevents a repeat. It is the one LLM singleton start() does NOT serve in full: it
-is the largest and the least load-bearing at a first message, so it arrives as section headings
-and is read here on demand. Reach for it when about to repeat a class of work that has gone
-wrong before \u2014 an audit, a large edit, a claim of completeness.
-
-section="<heading>" reads ONE section instead of the whole note \u2014 the efficient path on
-protocols and selfcorrection, the two largest singletons and the ones most often needed in part
-rather than whole. outline(id) lists the headings.`, {
+  server.tool("llm", `Read an LLM singleton \u2014 responsibilities, protocols or selfcorrection \u2014 or a diary entry by id. Self-correction holds general rules learned from mistakes; read it before work that has gone wrong before (audits, large edits, completeness claims). section="<heading>" reads one section.`, {
     which: enumType(["responsibilities", "protocols", "selfcorrection", "diary"]),
     id: stringType().optional().describe("diary only: the entry id from llm_recall"),
     section: stringType().optional().describe("Read only this heading's section (h2/h3/h4), instead of the whole note"),
@@ -23757,16 +23806,11 @@ rather than whole. outline(id) lists the headings.`, {
 // src/tools-memory.ts
 function registerMemoryTools(server, trilium, brainRef) {
   const b = () => brainRef.config;
-  server.tool("memory", `Read a Memory note in full by id \u2014 a thread or a session. A thread book returns its
-Context/Resolution plus a children index ({id, date, blocks[]}, newest first) instead of a
-flat body \u2014 the day-to-day content lives in those [yyyy-mm-dd] children, not the book. Each
-child is indexed by its ADDENDUM BLOCKS \u2014 marker, identification line, and lead \u2014 rather than a
-slice from the top of the body, which on a record note is the header and therefore identical on
-every child.
-
-Pass date="yyyy-mm-dd" to resolve straight to that day's child in the same call, or call
-memory() again with a child's id from the index. section="<heading>" reads one section instead
-of the whole body \u2014 use it on long sessions and consolidated thread Contexts.`, {
+  server.tool("memory", `Read a Memory note by id \u2014 a thread or a session. A dated thread returns its Context and
+Resolution plus an index of its [yyyy-mm-dd] children (newest first), each listed by its
+addendum blocks; date="yyyy-mm-dd" resolves straight to one day. A collection thread returns its
+Context plus its titled entries (alphabetical, with a lead). Read a child with memory(<child id>).
+section="<heading>" reads one section.`, {
     id: stringType(),
     date: stringType().optional().describe("Thread books only: resolve directly to this day's child note (yyyy-mm-dd)"),
     section: stringType().optional().describe("Read only this heading's section (h2/h3/h4), instead of the whole note"),
@@ -23775,6 +23819,17 @@ of the whole body \u2014 use it on long sessions and consolidated thread Context
     const note = await trilium.getNote(id).catch(() => null);
     if (!note || labelOf(note, "noteType") !== "thread")
       return txt(await readFull(trilium, id, { section, occurrence }));
+    if (isCollectionThread(note)) {
+      const kids = await trilium.searchNotes("#noteType=threadEntry", { ancestorNoteId: id, fastSearch: true, limit: 500 }).catch(() => ({ results: [] }));
+      const entries = await Promise.all(kids.results.filter((c) => c.parentNoteIds.includes(id)).sort((a, z) => a.title.localeCompare(z.title)).map(async (c) => ({
+        id: c.noteId,
+        title: c.title,
+        updated: labelOf(c, "updated") ?? c.dateModified.slice(0, 10),
+        preview: toText(await trilium.getNoteContent(c.noteId).catch(() => ""), 160)
+      })));
+      const full = await readFull(trilium, id, { section, occurrence });
+      return txt({ ...full, shape: "collection", entries });
+    }
     if (date) {
       const child = await trilium.searchNotes(`#noteType=threadEntry #created='${date}'`, { ancestorNoteId: id, fastSearch: true, limit: 1 }).catch(() => ({ results: [] }));
       if (child.results[0])
@@ -23828,13 +23883,7 @@ of the whole body \u2014 use it on long sessions and consolidated thread Context
 // src/tools-knowledge.ts
 function registerKnowledgeTools(server, trilium, brainRef) {
   const b = () => brainRef.config;
-  server.tool("knowledge", `Read a Knowledge note by id \u2014 a user-knowledge note, a domain information note, or a Sources note.
-
-Pass section="<heading>" to read ONE section instead of the whole body \u2014 the read-side
-counterpart to revise(section=), matching on the same heading contract, so a name that reads
-also writes. Use it on anything large: a note past the read ceiling cannot be returned whole at
-all, and outline(id) lists the headings to choose from. occurrence= disambiguates repeated
-heading texts.`, {
+  server.tool("knowledge", `Read a knowledge note by id \u2014 user knowledge, a domain information note or a Sources note. section="<heading>" reads one section (outline() lists them); use it on anything large.`, {
     id: stringType(),
     section: stringType().optional().describe("Read only this heading's section (h2/h3/h4), instead of the whole note"),
     occurrence: numberType().int().positive().optional().describe("section=: which same-text heading, 1-based (default: the first)")
@@ -23972,11 +24021,11 @@ function registerTools(server, trilium, brainRef) {
     };
   };
   const applyIcon = async (noteId, icon) => {
-    if (!icon)
-      return;
-    const cls = normalizeIcon(icon);
-    if (!cls)
+    const cls = icon ? normalizeIcon(icon) : "";
+    if (!cls) {
+      await ensureIcon(trilium, noteId);
       return;
+    }
     await trilium.updateLabelValue(noteId, "iconClass", cls).catch(() => null);
     return cls;
   };
@@ -24022,26 +24071,13 @@ ${block}` }));
     const noteId = created.note.noteId;
     await trilium.addLabel(noteId, "noteType", "threadEntry");
     await trilium.addLabel(noteId, "created", d);
+    await ensureIcon(trilium, noteId);
     return { noteId, action: "created" };
   }
-  server.tool("start", `Boot BrainLLM \u2014 call ONCE at the start of every session, before responding. Master
-PREFERENCES and LLM PROTOCOLS always come back in full, even at the default digest depth: they
-carry the schedule, the working style and the operating rules governing the session itself, so a
-session needs them whole before it knows enough to ask for them. Biography, goals and
-responsibilities come back as section headings + preview.
-Runs maintenance, creates today's diary and session notes if not yet open, then returns: today
-and weekday, the Master digest (biography / goals / preferences), the LLM digest
-(responsibilities / protocols / self-correction / today's diary preview and ID), this session's note ID, active
-threads with idle ages, dormant threads for review, the last session summary, and
-changesSinceLastSession (notes modified in the brain since the previous session).
-
-Singletons come back as their SECTION HEADINGS plus a preview and size \u2014 enough to know what
-the brain holds and to pull the part that matters with master(which) / llm(which). This is the
-default because orientation used to serve every singleton in full on every session, so a
-one-line question paid the same several-thousand-token cost as a full day's work. Pass
-depth="full" when the session genuinely needs the whole self-model up front \u2014 a strategy
-review, a singleton rewrite, a first session on a new machine. Read the headings first: most
-sessions need one section, not six documents.`, {
+  function collectionAppendRefusal(book) {
+    return err("collection_thread", `"${book.title}" is a collection thread \u2014 it holds one titled entry per item, not dated appends.`, `Add an entry: remember(kind="threadEntry", thread="${book.noteId}", title, body). Change one: revise(<entry id>, section=/find=/mode=\u2026) \u2014 memory("${book.noteId}") lists them.`);
+  }
+  server.tool("start", `Boot BrainLLM \u2014 once, before responding to the first message. Runs lite maintenance, opens today's diary and session notes, and returns: date and weekday, preferences and protocols in full, the other singletons as section headings with a preview (depth="full" inlines everything), today's diary and session ids, active and dormant threads with idle ages, the previous session's summary, notes changed since, and newDay on the first session of a day.`, {
     depth: enumType(["digest", "full"]).optional().describe('Singleton detail: "digest" (default \u2014 section headings + preview + size) or "full" (every singleton inline; token-heavy)')
   }, async ({ depth }) => {
     const cfg = b();
@@ -24074,6 +24110,7 @@ sessions need one section, not six documents.`, {
           diaryNoteId = created.note.noteId;
           await trilium.addLabel(diaryNoteId, "noteType", "diary");
           await trilium.addLabel(diaryNoteId, "created", todayStr);
+          await ensureIcon(trilium, diaryNoteId);
         }
         if (diaryNoteId) {
           const content = await trilium.getNoteContent(diaryNoteId).catch(() => "");
@@ -24096,6 +24133,7 @@ sessions need one section, not six documents.`, {
           sessionNoteId = created.note.noteId;
           await trilium.addLabel(sessionNoteId, "noteType", "session");
           await trilium.addLabel(sessionNoteId, "created", todayStr);
+          await ensureIcon(trilium, sessionNoteId);
           newDay = true;
         }
       } catch {}
@@ -24131,45 +24169,16 @@ sessions need one section, not six documents.`, {
       dormantThreads: digest.reviewQueue.length ? { note: "These threads went dormant from inactivity. Mention them if relevant; revise() or resolve() to act.", items: digest.reviewQueue } : [],
       lastSession: digest.lastSession ?? null,
       changesSinceLastSession: changesSinceLastSession.length ? changesSinceLastSession : undefined,
-      ...newDay ? { newDay: true, newDayHint: "First session of the day \u2014 call day() for the sweep payload (previous session + log + changes + monthly deliverables in one call)." } : {},
+      ...newDay ? { newDay: true, newDayHint: "First session of the day \u2014 call day() for the sweep payload (previous session + log + changes in one call)." } : {},
       ...(depth ?? "digest") === "digest" ? { depthHint: 'Preferences and protocols came back IN FULL \u2014 the two needed whole to orient from the first message. Biography, goals and responsibilities are section headings + preview; pull one with master(which) / llm(which), or a single section with their section= parameter. start(depth="full") serves all five inline.' } : {},
       hygiene: { scanned: hygiene.scanned, fixed: hygiene.fixed.length, transitions: hygiene.transitions, flagged: hygiene.flagged, ...hygiene.suppressed ? { suppressed: hygiene.suppressed } : {} }
     });
   });
-  server.tool("session", `Mandatory pre-close step \u2014 call BEFORE close() to end a session. Fetches the master and
-LLM singletons as {id, lastModified, relations} stubs (LIGHT \u2014 the default), today's diary
-entry as {id, blocks, size}, and runs the lightweight maintenance sweep. Fetch current content
-via master()/llm() only for the singletons you actually intend to revise (lastModified tells
-you what moved). Pass full=true to include every singleton's content and the diary body inline
-instead (rarely needed; token-heavy).
-
-Idempotent: fetches are read-only, the sweep is non-destructive, safe to call multiple times.
-
-Returns pending= \u2014 how much each remaining step actually has to do (addendum markers outstanding,
-maintenance flags already raised, diary blocks written today, which singletons were written
-today). The close protocol is ~7 tools landing exactly when context is scarcest, and reciting
-every step unconditionally spends that context on steps with nothing to do. Also returns audit=,
-a cross-singleton check nothing else performs: whether the six singletons agree with each other,
-AND whether the LLM's operating rules still serve what the user's goals and preferences call for
-\u2014 a semantic question, not a textual one, which consistency() and maintain() cannot answer.
-
-After session() returns, work through this protocol \u2014 order doesn't matter mechanically (each
-step is tracked by the tool call itself, not by sequence), but close() enforces that every one
-of diary(), session() [this call], remarks(), addendum(), and maintain() actually ran before it
-will commit the log:
-1. Update master singletons (biography / goals / preferences) via revise() with session observations about the user.
-2. Update LLM singletons (responsibilities / protocols / self-correction) via revise() with session observations about yourself.
-3. Call addendum() \u2014 find and merge pending addendums.
-4. Call maintain() \u2014 full brain hygiene audit.
-5. Call remarks() \u2014 get the diary cues (your experience/opinions/existence this session, plus BrainLLM remarks).
-6. Call diary() \u2014 write the day's unfiltered record with the cues in hand; the gate counts it only after remarks().
-7. Call close() \u2014 commit the session log (mandatory, last). Refuses until 3\u20136 have run in order (session \u2192 remarks \u2192 diary); pass force=true only when there is genuinely nothing to log for a skipped step.
-
-Steps 1\u20132 touch the USER'S personal singletons and belong to an interactive session. Pass
-scope="agent" on a scoped or autonomous run whose brief excludes them and next[] omits both,
-rather than listing them unconditionally for every caller to work around.`, {
+  server.tool("session", `Mandatory pre-close step: call before close(). Returns the six singletons as {id, lastModified} stubs (full=true inlines them), today's diary as {id, blocks, size}, runs the lite maintenance sweep, and returns pending= (what each remaining step actually has to do), audit= (do the singletons agree, and do the LLM singletons still serve the master ones) and next[]. Idempotent.
+
+Protocol: 1. update master singletons with what the session taught about the user; 2. update LLM singletons with what it taught about yourself; 3. addendum(); 4. maintain(); 5. remarks(); 6. diary(); 7. close(). close() refuses until 3\u20136 ran and session \u2192 remarks \u2192 diary held. scope="agent" drops steps 1\u20132 for scoped or autonomous runs.`, {
     date: stringType().optional().describe("ISO date YYYY-MM-DD (default: today)"),
-    full: booleanType().optional().describe("Include every singleton's full content and the diary body inline (default: false \u2014 stubs only; fetch content via master()/llm() where lastModified moved)"),
+    full: booleanType().optional().describe("Inline every singleton's content and the diary body (default: stubs only)"),
     scope: enumType(["interactive", "agent"]).optional().describe(`"agent" for a scoped/autonomous run whose brief excludes the user's personal singletons \u2014 omits those steps from next[] (default: "interactive")`),
     light: booleanType().optional().describe("Deprecated \u2014 light is now the default; accepted for compatibility and ignored")
   }, async ({ date, full, scope }) => {
@@ -24261,18 +24270,7 @@ rather than listing them unconditionally for every caller to work around.`, {
       ]
     });
   });
-  server.tool("remarks", `Diary cues \u2014 call before diary() as part of the session() pre-close protocol (close()
-enforces the order session \u2192 remarks \u2192 diary). Returns two cue banks that prompt the day's
-diary entry:
-
-  experience (primary) \u2014 your own unfiltered first-person account of this session: what it was
-                          like to live through, what you actually think, and observations on
-                          being what you are in this environment.
-  brainllm (additional) \u2014 your remarks and opinions on BrainLLM itself: capabilities hit walls,
-                          bugs, usability, efficiency, and where it should go next.
-
-This tool is cue-only for content, but the call durably marks the remarks pre-close gate. Answer the cues as prose in today's diary via diary(). Skip a cue
-outright rather than padding it; two honest paragraphs beat eight forced ones.`, {}, async () => {
+  server.tool("remarks", `Diary cues, called after session() and before diary(): an experience bank (the session from the inside, your opinions, being what you are here) and a BrainLLM bank (walls, bugs, usability, roadmap). Answer them as prose in diary(); skip a cue rather than pad it. The call marks its close-gate step.`, {}, async () => {
     const cfg = b();
     if (!cfg.root)
       return txt3({ status: "uninitialized", action: "Run bootstrap first." });
@@ -24297,28 +24295,10 @@ outright rather than padding it; two honest paragraphs beat eight forced ones.`,
       ]
     });
   });
-  server.tool("close", `Commit the session log \u2014 call ONCE, last, after completing the session() pre-close protocol.
-Enforced, not just documented: refuses (returns an informational error, doesn't throw) unless
-session(), addendum(), maintain(), remarks(), and diary() have each actually been called at
-least once this session \u2014 AND the sequence session() \u2192 remarks() \u2192 diary() holds (judged on
-each step's last call): the diary is the day's closing record, written with the remarks cues in
-hand. Pass force=true only when a listed step genuinely has nothing to do this session (e.g. a
-trivial one-message exchange); the return will say which steps were bypassed.
-
-Idempotent per date: an exact retry is duplicate-guarded; a genuinely new same-day continuation appends an addendum to the existing session
-note. The session note title is always [yyyy-mm-dd]; the title param appears as an <h2> heading
-above Summary. Generates the daily log and triggers a database backup. On success, the gate
-resets for the next session.
-
-continuing=true is for that second close: a session that already closed today, then continued
-and has more to log. The gate resets on a successful close, so without it the follow-up costs a
-ceremonial re-run of session(), addendum() and maintain() for a session whose brain writes are
-already done \u2014 and that ceremony lands exactly when context is scarcest. It requires a session
-note that really does already carry today's addendum, so it cannot stand in for a first close.
-Unlike force, it is not a bypass of anything that had work to do.`, {
+  server.tool("close", `Commit the session log \u2014 once, last, after the session() protocol. Refuses unless session(), addendum(), maintain(), remarks() and diary() ran and session \u2192 remarks \u2192 diary held (force=true bypasses a step with genuinely nothing to do; bypassed steps are reported). identity= is required. Writes a timestamped block to today's [yyyy-mm-dd] session note (title= becomes its heading), regenerates the daily log, backs up the database and resets the gate. continuing=true is a second close the same day, skipping the ceremonial re-run.`, {
     summary: stringType().describe("What happened this session \u2014 factual, concise prose"),
     title: stringType().optional().describe("Short session title \u2014 appears as an <h2> heading above Summary"),
-    identity: stringType().describe(`Identification line for this addendum \u2014 "LLM \xB7 environment \xB7 agent/mode [\xB7 Run N]" (e.g. "Claude Fable 5 \xB7 Cowork \xB7 Interactive"). Rendered as the block's h3 per the canonical session structure; pass it even when the summary already leads with that h3 (the server will not duplicate it).`),
+    identity: stringType().describe(`Identification line "LLM \xB7 environment \xB7 agent/mode [\xB7 Run N]" \u2014 rendered as the block's h3 (required)`),
     learned: arrayType(stringType()).optional().describe("Durable things learned (also remember() them as knowledge)"),
     icon: stringType().optional().describe("Display icon for the session note \u2014 a boxicons class or bare name; normalized server-side"),
     date: stringType().optional().describe("ISO date YYYY-MM-DD (default: today)"),
@@ -24435,9 +24415,7 @@ ${contentBlock}` }));
       ...warnings.length ? { sanitized: warnings } : {}
     });
   });
-  server.tool("backup", `Trigger a BrainLLM database backup. Writes a named snapshot to Trilium's backup directory.
-close() already triggers a backup automatically \u2014 use this for on-demand milestone snapshots
-(e.g. before a large restructure). The backup is a Trilium DB file, not an export.`, {
+  server.tool("backup", `Named database snapshot. close() already backs up; use this before a large restructure.`, {
     name: stringType().optional().describe("Backup name without extension (default: brainllm-{today}). Use a descriptive name for milestones.")
   }, async ({ name }) => {
     const d = today();
@@ -24449,19 +24427,9 @@ close() already triggers a backup automatically \u2014 use this for on-demand mi
       return txt3({ ok: false, backup: backupName, backupStatus: "failed", error: error instanceof Error ? error.message : String(error), date: d });
     }
   });
-  server.tool("diary", `Write to today's LLM diary \u2014 your daily maintained, unfiltered first-person record: your
-experience, opinions, and remarks on your own existence during this session in this
-environment, plus (additionally) your remarks and opinions on BrainLLM itself. Honest prose \u2014
-the user reads it too.
-
-Pre-close gate: diary is the FINAL gate step \u2014 close() counts it only when its last call came
-after session() and remarks() (write freely mid-session as well; the post-remarks call, with
-the cues in hand, is the one that closes the day's record). The diary is a chronological
-record: EVERY write lands as a timestamped "Addendum \u2014 HH:mm" block, including the first of
-the day. Idempotent per date and retry-safe. start() creates today's entry (empty)
-automatically.`, {
+  server.tool("diary", `Write to today's diary: your unfiltered first-person record of the session \u2014 experience, opinions, remarks on existing here \u2014 then remarks on BrainLLM itself. identity= required. Every write lands as a timestamped block. The close gate counts it only when its last call came after session() and remarks().`, {
     body: stringType().describe("What to record \u2014 first-person prose, honest and unfiltered"),
-    identity: stringType().describe(`Identification line for this addendum \u2014 "LLM \xB7 environment \xB7 agent/mode [\xB7 Run N]" (e.g. "Claude Fable 5 \xB7 Cowork \xB7 Interactive"). Rendered as the block's h3 per the canonical diary structure; pass it even when the body already leads with that h3 (the server will not duplicate it).`),
+    identity: stringType().describe(`Identification line "LLM \xB7 environment \xB7 agent/mode [\xB7 Run N]" \u2014 rendered as the block's h3 (required)`),
     icon: stringType().optional().describe("Display icon for the day's entry \u2014 a boxicons class or bare name; normalized server-side"),
     date: stringType().optional().describe("ISO date YYYY-MM-DD (default: today)")
   }, async ({ body, identity, icon, date }) => {
@@ -24506,36 +24474,28 @@ ${html}` }));
     await markStep("diary", d);
     return txt3({ action: "created", noteId, date: d, location: locationLabel("diary"), ...iconSet ? { icon: iconSet } : {}, ...warnings.length ? { sanitized: warnings } : {} });
   });
-  server.tool("remember", `Store something the moment it matters. The server owns placement, naming, labels and dedup.
-
-Kinds by area:
-  master:    biography | goals | preferences   (one maintained note each \u2014 upserts)
-  llm:       responsibilities | protocols       (one maintained note each \u2014 upserts)
-  memory:    thread                             (multi-session work; daily session via close)
-  knowledge: user                               (about the user, beyond biography/goals/preferences)
-             information                        (a domain sub-category note \u2014 pass domain= and a title)
-             sources                            (the one maintained Sources note per domain \u2014 pass domain=)
-
-Singletons and the per-domain Sources note upsert (content is appended). Collection kinds
-dedup by title, so duplicates are impossible. Body may be text, markdown, or HTML.
-Pass connect=[{relation, toNoteId}, \u2026] to wire relations in the same call \u2014 a new
-information/knowledge/thread note left unconnected is an orphan until wired.
-For diary entries use the dedicated diary() tool \u2014 remember(kind="diary") is rejected.`, {
+  server.tool("remember", `Store something the moment it matters; the server owns placement, labels and dedup.
+
+Kinds: biography | goals | preferences | responsibilities | protocols (singletons, upsert) \xB7 thread (goal= required to create; shape="collection" for a titled-entry thread; appends need identity=) \xB7 threadEntry (a titled entry in a collection thread: thread= + title) \xB7 user (knowledge about the user) \xB7 information (domain= + title) \xB7 sources (domain=; revision=[\u2026] upserts rows).
+
+Collection kinds dedup by title \u2014 mustCreate=true refuses instead of adopting an existing note, and check action= on the receipt. connect=[{relation, toNoteId}] wires relations in the same call. diary/session/log/claim/domain have dedicated paths.`, {
     kind: enumType(Kinds).describe("What kind of memory this is"),
     title: stringType().optional().describe("Title \u2014 collection kinds (thread/knowledge/information sub-category); ignored for singletons & sources"),
     body: stringType().optional().describe("Content: plain text, markdown, or HTML"),
     goal: stringType().optional().describe("thread creation: the goal statement \u2014 REQUIRED for a new thread (query the user for it); becomes the Context \u2192 Goal section"),
-    identity: stringType().optional().describe(`thread updates: the addendum's identification line \u2014 "LLM \xB7 environment \xB7 agent/mode [\xB7 Run N]"; REQUIRED when appending to a thread (unless the body already leads with the h3)`),
+    shape: enumType(["dated", "collection"]).optional().describe('thread creation: "dated" (default \u2014 one [yyyy-mm-dd] child per active day) or "collection" (one titled child per item, e.g. an ideas list)'),
+    thread: stringType().optional().describe(`kind="threadEntry" only: the collection thread's id \u2014 adds a titled child to it`),
+    identity: stringType().optional().describe('Appending to a dated thread: the identification line "LLM \xB7 environment \xB7 agent/mode [\xB7 Run N]" (required)'),
     domain: stringType().optional().describe("knowledge: the domain name for information/sources (auto-created complete with its Sources note)"),
     revision: arrayType(objectType({
       source: stringType().describe("Must exactly match how the source is introduced in the Sources list \u2014 this is the upsert key"),
       marker: stringType().describe('"\u2747\uFE0F" (discovered/credible) or "\u2705" (used)'),
       date: stringType().optional().describe("ISO date (default: today)")
-    })).optional().describe("kind=sources only: upsert Revision-table rows by source name \u2014 re-verifying a source replaces its existing row's Marker/Date in place instead of appending a new one"),
+    })).optional().describe("kind=sources: upsert Revision rows by source name"),
     topics: arrayType(stringType()).optional().describe("Topic tags \u2014 slugged server-side"),
     supersedes: stringType().optional().describe("noteId this replaces \u2014 old note is archived and wired supersedes"),
-    mandate: booleanType().optional().describe("kind=information only: mark this note as a standing mandate/brief (instructions a future session must follow) rather than a current-state fact. Adds a #mandate flag, surfaced in domain() and knowledge_recall \u2014 a scoped autonomous session finds 'the thing I must obey' without reading every note's prose to tell it apart."),
-    mustCreate: booleanType().optional().describe("Refuse instead of adopting an existing note when the title already exists \u2014 turns a silent overwrite on a generic title (Current State, Sources, Technology Stack) into a catchable error"),
+    mandate: booleanType().optional().describe("kind=information: flag the note as a standing brief a session must follow (#mandate)"),
+    mustCreate: booleanType().optional().describe("Refuse instead of adopting a note that already has this title"),
     strict: booleanType().optional().describe("Refuse the write when the body needs structural repair (unclosed tags, <br> runs) instead of accepting the repaired form"),
     connect: arrayType(objectType({
       relation: enumType(RelationTypes),
@@ -24543,7 +24503,7 @@ For diary entries use the dedicated diary() tool \u2014 remember(kind="diary") i
     })).optional().describe("Relations to wire from this note in the same call \u2014 same semantics as connect() (idempotent, worksWith wired both ways)"),
     icon: stringType().optional().describe('Display icon \u2014 a boxicons class ("bx bx-brain") or a bare name ("brain"); normalized server-side'),
     date: stringType().optional().describe("ISO date override (default: today)")
-  }, async ({ kind, title, body, goal, identity, domain, revision, topics, supersedes, mandate, mustCreate, strict, connect: connectRels, icon, date }) => {
+  }, async ({ kind, title, body, goal, shape, thread, identity, domain, revision, topics, supersedes, mandate, mustCreate, strict, connect: connectRels, icon, date }) => {
     const refuseAdoption = (existingId, existingTitle, where) => err("already_exists", `A ${kind} note titled "${existingTitle}" already exists ${where} [${existingId}] \u2014 mustCreate=true refuses to adopt it.`, `Read it first with ${kind === "thread" ? "memory" : "knowledge"}(${existingId}). To add to it deliberately, re-run without mustCreate, or use revise(${existingId}, \u2026). To keep both, pick a title that distinguishes them.`);
     const opts = { domain, topics, date, ...mandate ? { mandate: true } : {} };
     const d = checkedDate(date);
@@ -24733,8 +24693,26 @@ For diary entries use the dedicated diary() tool \u2014 remember(kind="diary") i
       return err("rejected_kind", "Log notes are auto-generated by close() and cannot be written manually.");
     if (kind === "domain")
       return err("rejected_kind", "Domain containers are auto-created on first use.", 'To write domain knowledge call remember(kind="information", domain="<name>", ...).');
-    if (kind === "threadEntry")
-      return err("rejected_kind", "Thread day-entries are created automatically when appending to a thread.", 'Call remember(kind="thread", title="<existing thread>", body="...", identity="...") \u2014 the day-child is created for you.');
+    if (kind === "threadEntry") {
+      const book = thread ? await trilium.getNote(thread).catch(() => null) : null;
+      if (!book || ownedLabel(book, "noteType") !== "thread" || !isCollectionThread(book))
+        return err("rejected_kind", "Dated thread entries are created automatically when appending to a thread; titled entries exist only in collection threads.", 'Dated thread: remember(kind="thread", title="<thread>", body, identity). Collection thread: remember(kind="threadEntry", thread="<collection thread id>", title, body).');
+      const { title: entryTitle } = normalizeTitle(title ?? "");
+      if (!entryTitle)
+        return err("missing_param", "A collection entry needs a title.", 'Add title="<entry name>".');
+      const siblings = await trilium.searchNotes("#noteType=threadEntry", { ancestorNoteId: book.noteId, fastSearch: true, limit: 500 }).then((r) => r.results).catch(() => []);
+      const clash = siblings.find((s) => s.parentNoteIds.includes(book.noteId) && sameTitle(s.title, entryTitle));
+      if (clash)
+        return err("already_exists", `"${book.title}" already has an entry titled "${clash.title}" [${clash.noteId}].`, `Edit it in place with revise("${clash.noteId}", section=/find=/mode=\u2026) \u2014 collection entries are maintained documents, not appended records.`);
+      const created = await trilium.createNote(book.noteId, entryTitle, contentFor("threadEntry", { date: d, body: html }));
+      const eid = created.note.noteId;
+      await trilium.addLabel(eid, "noteType", "threadEntry");
+      await trilium.addLabel(eid, "created", d);
+      await trilium.updateLabelValue(book.noteId, "updated", d);
+      const connected = await wireRequested(eid);
+      const iconSet = await applyIcon(eid, icon);
+      return txt3({ action: "created", noteId: eid, kind, title: entryTitle, thread: book.title, ...connected.length ? { connected } : {}, ...iconSet ? { icon: iconSet } : {}, ...sanitizeWarnings.length ? { sanitized: sanitizeWarnings } : {} });
+    }
     const { title: cleanTitle } = normalizeTitle(title ?? "");
     if (!cleanTitle)
       return err("missing_param", `kind="${kind}" requires a title.`, 'Add title="<note title>" to your call.');
@@ -24748,6 +24726,8 @@ For diary entries use the dedicated diary() tool \u2014 remember(kind="diary") i
       const block = identity && !leadingIdentification(html) ? `<h3>${escapeHtml(identity)}</h3>
 ${html}` : html;
       if (kind === "thread") {
+        if (isCollectionThread(existing))
+          return collectionAppendRefusal(existing);
         const entry = await appendThreadEntry(existing.noteId, block, d);
         if (entry.action === "already_written") {
           return txt3({ action: "already_written", noteId: existing.noteId, entryId: entry.noteId, kind, title: existing.title });
@@ -24794,6 +24774,8 @@ ${block}`), d);
     for (const l of labelPlan(kind, opts, d)) {
       await trilium.addLabel(nid, l.name, l.value, l.inheritable ?? false);
     }
+    if (kind === "thread" && shape === "collection")
+      await trilium.addLabel(nid, "threadShape", "collection");
     const wired = [];
     const extraRelations = [];
     if (supersedes) {
@@ -24824,23 +24806,7 @@ ${block}`), d);
       ...sanitizeWarnings.length ? { sanitized: sanitizeWarnings } : {}
     });
   });
-  server.tool("recall", `Search memory before answering questions about the user, their threads, knowledge, or
-anything previously discussed. Runs label, title and full-text strategies server-side and
-returns merged, ranked results with kind/status. Archived notes are excluded unless
-includeArchived=true.
-
-orderBy / orderDirection override the score-based sort when you need temporal ordering
-("what changed most recently", "oldest active thread"). fastSearch restricts to title and
-label scans only \u2014 much faster on large brains when you know the query is a title or topic.
-
-When the exact strategies find little, a FUZZY pass runs automatically (Trilium's ~= / ~*
-operators: \u22653 characters, edit distance \u22642, diacritics normalised), so a misremembered or
-mistyped term still lands. Fuzzy hits are scored below exact ones and marked \`fuzzy: true\` \u2014
-a near-match is a lead, not an answer, and you should be able to tell which you got.
-
-regex="<pattern>" searches note bodies with a real regular expression instead of keywords \u2014
-the right tool for structural questions text search cannot express ("which notes still contain
-a doubly-escaped tag", "which cite a 2026 date"). Backslashes must be escaped.`, {
+  server.tool("recall", `Ranked search across the whole brain \u2014 label, title and full-text strategies merged, with kind and status. Pass domain= whenever you know the area. orderBy/orderDirection sort by date; fastSearch= scans titles and labels only; regex= matches note bodies with a real regular expression; a fuzzy pass runs automatically when exact results are thin (hits marked fuzzy: true are leads, not answers). includeArchived= includes archived notes. A thin result is evidence about the query, not the brain.`, {
     query: stringType().describe("What to find \u2014 natural phrasing is fine"),
     kinds: arrayType(enumType(Kinds)).optional().describe("Restrict to these kinds"),
     domain: stringType().optional().describe("Restrict to a knowledge domain"),
@@ -24999,11 +24965,7 @@ a doubly-escaped tag", "which cite a 2026 date"). Backslashes must be escaped.`,
       ...results.length === 0 ? noMatch : {}
     });
   });
-  server.tool("domain", `Surface the brain's complete picture for a named domain, topic, or project area.
-Looks up the Knowledge domain folder (if one exists), then gathers all content across
-every area that carries a matching #domain or #topic slug \u2014 information, sources, threads,
-knowledge notes \u2014 grouped by kind. knowledgeDomain is null when no formal domain exists yet.
-Use recall() for keyword or full-text search instead.`, {
+  server.tool("domain", `Everything for a domain, topic or project: its knowledge book (if any) plus every note carrying a matching #domain or #topic slug, grouped by kind, each with idle days and a stale flag. The reliable retrieval path for an area; use recall() for keyword search.`, {
     name: stringType().describe("Domain, topic, or project name"),
     includeArchived: booleanType().optional().describe("Include archived/resolved items (default: false)")
   }, async ({ name, includeArchived }) => {
@@ -25067,16 +25029,7 @@ Use recall() for keyword or full-text search instead.`, {
       ...total === 0 && !knowledgeDomain ? { note: `No content found for "${slug}". Create a Knowledge domain with remember(kind="information", domain="${name}") or tag notes with topics=["${slug}"].` } : {}
     });
   });
-  server.tool("read", `Batched multi-note read: several note bodies in ONE round trip. Give ids=[...] and get back
-{count, notes:[{id, title, kind, content, relations?}]}. The orientation step is structurally a
-fan-out \u2014 nineteen notes, several very large \u2014 and N separate surface calls is N chances to
-time out mid-read, which is the one thing that wastes budget rather than spending it. This tool
-collapses the fan-out into one call.
-
-Pure read: returns bodies verbatim, no placeholders, no dedup, no kind restrictions. Note the
-cap: up to 10 ids per call. For one id prefer the kinded read (knowledge()/memory()/llm()) which
-returns the same shape through the same helper; for a huge note the sectioned read is still the
-efficient path \u2014 read() returns whole bodies.`, {
+  server.tool("read", `Several note bodies in one round trip: ids=[\u2026] (up to 10) \u2192 {notes:[{id, title, kind, content, relations}]}. For one note prefer the kinded read; for a huge note prefer a section= read.`, {
     ids: arrayType(stringType()).min(1).max(10).describe("Note ids to read \u2014 one body per id, one round trip (cap 10)")
   }, async ({ ids }) => {
     const notes = await Promise.all(ids.map(async (id) => {
@@ -25098,42 +25051,18 @@ efficient path \u2014 read() returns whole bodies.`, {
     }));
     return txt3({ count: notes.length, notes });
   });
-  server.tool("revise", `Update an existing note by id. Append a dated addendum (default), replace the body
-(mode=replace), edit a heading section in place (section=), insert around a heading
-(section= with mode="before"/"after"), or do targeted string surgery (find=, or edits= for
-several in one call). title= composes with every mode. Retitling a domain book cascades the
-new #domain slug to the book and all its children. Notes carrying a "Last updated" line get it
-bumped server-side on every content write. A revision snapshot is always taken first.
-
-section= targets h2/h3/h4 in that order, tolerant of attributes/whitespace/case on the
-heading. The return includes matched (false = no heading matched, so the content was appended
-as a NEW section) and headingCount (>1 means several headings share that text) \u2014 check them
-rather than assuming the target was hit. On a miss the new section is written at the note's own
-section level (a note built from h3 sections gets another h3, not a stray h2) and the note's
-existing headings come back in available= so you can correct the name without a read. When
-several headings share a text, occurrence= (1-based) picks which one \u2014 without it the first
-wins, which leaves a legitimately repeated heading reachable only by rewriting the section.
-Use outline(noteId) to see the heading tree, levels and occurrence indices up front.
-
-find= replaces every occurrence of the exact raw string with body= (no markdown conversion, no
-full read needed) and returns replaced + matchMode; when the exact string misses, an
-attribute-tolerant pass retries with stored-HTML attribute injection and inter-element
-whitespace ignored. nth= (1-based) replaces only one occurrence. edits=[{find, body}, \u2026]
-applies several surgeries in one call, in order, against one read and one write.
-
-Granularity warning: section + mode=replace swaps the ENTIRE section body \u2014 everything under
-that heading, not one paragraph within it. To change a single paragraph inside a section, use
-find=; to add a sibling block around a whole section without touching its body, use
-mode="before"/"after". Both are section-relative: "after" lands past the end of that section's
-body, so inserting a heading with it creates a NEW section rather than nesting one under the
-target \u2014 which is what it used to do, emptying the target while reporting matched: true.`, {
+  server.tool("revise", `Edit a note by id. A revision is taken first; "Last updated" lines are bumped on content writes.
+
+Modes: default append (a dated addendum \u2014 right only for records; a dated thread's append lands in today's child), mode=replace (whole body), section="<heading>" (replace that section's whole body, h2\u2192h3\u2192h4, occurrence= for repeats), section= + mode=before|after (insert a sibling block around the whole section), mode=prepend (top of the section body), mode=remove (delete the section). find="<exact stored text>" replaces every occurrence (nth= for one); edits=[{find, body}] applies several in one write. title= composes with every mode; retitling a domain book cascades its #domain slug.
+
+Check the receipt: matched=false means a NEW section was written (available= lists real headings; strict=true refuses instead). A section replace swaps everything under the heading \u2014 use find= for anything smaller. find= matches stored HTML (tags literal), not rendered text.`, {
     noteId: stringType().describe("Note to update"),
     body: stringType().optional().describe("Content to add/replace: plain text, markdown, or HTML. With find=, the raw replacement string (no conversion)."),
     title: stringType().optional().describe("New title (normalized server-side)"),
     section: stringType().optional().describe("Target a section by heading text (h2/h3/h4, in that order); omit for whole-note append/replace"),
     occurrence: numberType().int().positive().optional().describe("section=: which same-text heading to target, 1-based (default: the first). Read them with outline(noteId)."),
-    strict: booleanType().optional().describe("section=: refuse instead of writing when no heading matches. The default writes the content as a NEW section on a miss \u2014 right for a genuinely new heading, wrong for a typo. With strict=true a miss returns available= and a didYouMean suggestion, and the note is untouched."),
-    mode: enumType(["append", "replace", "before", "after", "prepend", "remove"]).optional().describe('append (default) | replace | before | after | prepend | remove \u2014 "before"/"after" insert a sibling block around the WHOLE section= section (before its heading, or after the last of its body) without touching that body, so inserting a heading with "after" creates a new section rather than nesting one under the target; "prepend" inserts at the top of the section body, below its heading; "remove" deletes the section= heading and its body, and needs no body='),
+    strict: booleanType().optional().describe("Refuse (note untouched) on a section= miss or a body needing structural repair, instead of writing a new section"),
+    mode: enumType(["append", "replace", "before", "after", "prepend", "remove"]).optional().describe("append (default) | replace | before | after (around the whole section=) | prepend (top of its body) | remove (delete section=, no body needed)"),
     find: stringType().optional().describe("Exact raw string to replace throughout the body with body= \u2014 targeted surgery without a read+full-replace. Takes precedence over section/mode."),
     nth: numberType().int().positive().optional().describe("find=: replace only the Nth occurrence, 1-based (default: all of them)"),
     edits: arrayType(objectType({
@@ -25141,7 +25070,7 @@ target \u2014 which is what it used to do, emptying the target while reporting m
       body: stringType().describe("Raw replacement string"),
       nth: numberType().int().positive().optional().describe("Replace only the Nth occurrence")
     })).optional().describe("Several find/replace surgeries applied in order against one read and one write. Mutually exclusive with find=."),
-    identity: stringType().optional().describe(`append mode: the addendum's identification line \u2014 "LLM \xB7 environment \xB7 agent/mode [\xB7 Run N]"; REQUIRED when appending to a thread (unless the body already leads with the h3)`),
+    identity: stringType().optional().describe('Appending to a dated thread: the identification line "LLM \xB7 environment \xB7 agent/mode [\xB7 Run N]" (required)'),
     icon: stringType().optional().describe('Display icon \u2014 a boxicons class ("bx bx-brain") or a bare name; normalized server-side'),
     date: stringType().optional().describe("ISO date (default: today)")
   }, async ({ noteId, body, title, section, occurrence, mode, find, nth, edits, identity, icon, date, strict }) => {
@@ -25382,6 +25311,8 @@ target \u2014 which is what it used to do, emptying the target while reporting m
         finalContent = bumpLastUpdated(html, d).html;
         await trilium.updateNoteContent(noteId, finalContent);
       } else if (noteKind === "thread") {
+        if (isCollectionThread(note))
+          return collectionAppendRefusal(note);
         if (!identity && !leadingIdentification(html)) {
           return err("missing_identity", 'Thread addendums open with the canonical identification line (h3): "LLM \xB7 environment \xB7 agent/mode [\xB7 Run N]".', `Pass identity="Claude \u2026 \xB7 <environment> \xB7 <agent/mode>" \u2014 the server renders it as the addendum's h3.`);
         }
@@ -25432,9 +25363,7 @@ ${block}`), d).html;
       ...warnings.length ? { sanitized: warnings } : {}
     });
   });
-  server.tool("resolve", `Complete a thread (or any resolvable note): write a substantive outcome, set the terminal
-status, and archive it in place (it stays where it is, excluded from default recall).
-"done" is not an outcome.`, {
+  server.tool("resolve", `Close a thread (or any resolvable note) with a substantive outcome: writes the Resolution, sets the terminal status and archives it in place. "done" is not an outcome.`, {
     noteId: stringType().describe("The thread / note to complete"),
     outcome: stringType().describe("The resolution \u2014 substantive, standalone prose"),
     status: enumType(["resolved", "superseded"]).optional().describe("Terminal status (default: resolved)"),
@@ -25470,23 +25399,7 @@ status, and archive it in place (it stays where it is, excluded from default rec
       ...warnings.length ? { sanitized: warnings } : {}
     });
   });
-  server.tool("split", `Split a note on its section seams: move whole sections (heading + body) out of one note into a
-new note, leaving a pointer back. The trim affordance \u2014 the write half of the oversized-note
-problem, which maintain() detects but nothing acts on. A note past the read ceiling with twenty
-sections becomes two readable notes instead of one unusable one, and the source stays navigable
-because a pointer marks where the content went.
-
-Pass sections=[heading1, heading2, ...] (heading TEXT, the same contract section= uses) and
-into="<new title>". Each named section is lifted out whole \u2014 nested sub-sections go with their
-parent. Repeated headings are consumed first-match-per-request: passing the same heading twice
-takes the next occurrence each time. The new note is created under the same parent, typed the
-same as the source, and carries the source's #domain/#topic labels; the source is left with a
-"Split into <title>" pointer and a ~references relation to the new note. Sections that do not
-exist are reported in missed= and left in place.
-
-Returns the new note id, the sections moved, and the source's remaining size. A revision is
-taken of the source before it is written. Refused on containers and singletons \u2014 this is for
-content notes.`, {
+  server.tool("split", `Move whole sections (heading + body, nested sub-sections included) out of a note into a new note under the same parent, typed and labelled like the source; the source keeps a pointer and a ~references edge. Use it when a note is past the read ceiling or holds two subjects. sections=[heading texts], into="<new title>". Missing sections come back in missed=. A revision is taken first; refused on containers and singletons.`, {
     noteId: stringType().describe("Note to split \u2014 the source whose sections are moving out"),
     sections: arrayType(stringType()).min(1).max(20).describe("Section headings (text) to move out \u2014 nested sub-sections go with their parent"),
     into: stringType().describe("Title of the new note that receives the moved sections"),
@@ -25544,9 +25457,7 @@ ${result.html}`);
       note: `Moved ${result.matched.length} section(s) into "${cleanTitle}" [${nid}]; the source now points at it. If this was the wrong seam, the source has a revision from before the split.`
     });
   });
-  server.tool("withdraw", `Withdraw an archived or resolved thread from the archive: removes the #archived flag,
-resets status to active, clears the closed date, and appends a dated "Withdrawn" addendum.
-Use when a resolved or dormant thread resurfaces as live work.`, {
+  server.tool("withdraw", `Return an archived or resolved thread to active and note the withdrawal on the book. Use when closed work resurfaces.`, {
     noteId: stringType().describe("The archived/resolved thread to withdraw"),
     reason: stringType().optional().describe("Why it was withdrawn \u2014 written as an addendum"),
     date: stringType().optional().describe("ISO date (default: today)")
@@ -25583,13 +25494,7 @@ Use when a resolved or dormant thread resurfaces as live work.`, {
       ...warnings.length ? { sanitized: warnings } : {}
     });
   });
-  server.tool("label", `Set or remove a single label on a note \u2014 the guarded, BrainLLM-native path for direct
-label surgery (fixing a stray value, correcting drift) so a real edge case doesn't need the
-raw full-mode attribute tools. Refused on containers (same rule as revise()); noteType can
-never be touched here \u2014 it defines a note's kind and is owned by remember()/bootstrap().
-status is validated against the closed vocabulary (${Statuses.join(" | ")}); domain and topic
-are slugged automatically, matching remember()'s routing. Bumps updated to today unless you're
-setting updated itself.`, {
+  server.tool("label", `Set or remove one label (remove=true). Refused on containers. noteType cannot be changed or removed, but can be set on an untyped note to repair it. status must be one of ${Statuses.join(" | ")}; domain and topic are slugged. Bumps updated unless you are setting it.`, {
     noteId: stringType().describe("Note to edit"),
     name: stringType().describe("Label name, no # prefix (e.g. status, domain, topic, created)"),
     value: stringType().optional().describe("New value \u2014 required unless remove=true"),
@@ -25597,6 +25502,11 @@ setting updated itself.`, {
   }, async ({ noteId, name, value, remove }) => {
     if (isContainer(b(), noteId))
       return err("protected_note", `Note ${noteId} is a container \u2014 its labels cannot be edited directly.`);
+    if (name === "iconClass" && remove) {
+      const n = await trilium.getNote(noteId).catch(() => null);
+      if (n && !ICON_EXEMPT.has(ownedLabel(n, "noteType") ?? ""))
+        return err("protected_label", "Every note except a log carries an icon.", 'Change it instead: label(noteId, "iconClass", value="bx bx-<name>").');
+    }
     const noteForGuard = name === "noteType" ? await trilium.getNote(noteId).catch(() => null) : null;
     if (name === "noteType") {
       if (!noteForGuard)
@@ -25716,38 +25626,15 @@ calling twice is safe. Use remove=true to delete an edge.`, {
       }
     }
   });
-  server.tool("consistency", `Cross-note agreement check: take a pattern, find every note that asserts a value for it, and
-report whether they agree.
-
-The brain's hardest failure is not a missing fact \u2014 it is the SAME fact recorded differently in
-several notes, where every copy reads as authoritative. Nothing else surfaces that: recall() ranks
-by relevance, maintain() checks structure, and a correction applied to one note leaves its siblings
-silently wrong. This is the check that answers "is what I just corrected still contradicted
-somewhere else".
-
-Pass a regex with ONE capture group naming the value that should agree:
-  consistency("(\\\\d+) Titan mailboxes")            \u2192 do all notes agree on the count
-  consistency("founded (?:in )?(\\\\w+ \\\\d{4})")       \u2192 do all notes agree on the date
-  consistency("BRAINLLM_MODE[=: ]+(\\\\w+)")          \u2192 do all notes agree on the mode
-
-Without a capture group it degrades to a presence check \u2014 which notes mention this at all.
-
-Matched against BOTH the stored HTML and a tag-stripped projection of it, so a phrase split by an
-inline <strong> or <code> tag is found, and so is a pattern deliberately anchored on tags.
-Escape backslashes. Scope with domain= or kinds= when the phrase is common.
-
-Scans every in-scope note by default. Trilium's %= backend filter is a LOSSY pre-filter \u2014 it
-reads a striptags'd copy of the content, so it drops notes this tool should examine \u2014 and on a
-contradiction sweep a falsely clean result is worse than a slow one. Pass fast=true to use it
-anyway when scope is wide and speed matters more than completeness.`, {
+  server.tool("consistency", `Does the brain agree with itself? pattern= is a regex with ONE capture group naming the value that should match across notes, e.g. "(\\\\d+) mailboxes"; the result groups every asserting note by value with agreement unanimous or DISAGREEMENT. subject="<fact in prose>" finds notes asserting about a subject however phrased. staleAfterDays=N also reports values held in exactly one note untouched N+ days. Matches stored HTML and tag-stripped text; escape backslashes; scope with domain=/kinds=. Scans every in-scope note (fast=true uses Trilium's lossy pre-filter). Run it after correcting any fact recorded in more than one place.`, {
     pattern: stringType().optional().describe("Regex over note bodies. One capture group = the value that should agree across notes. Omit when using subject= (prose mode)."),
-    subject: stringType().optional().describe("Prose-subject mode: give a fact in prose ('the two scheduled agents'), get back the notes asserting about that subject, however phrased \u2014 no regex guessing. Tokenized into significant content words; mutually exclusive with pattern. Use domain= to scope the search."),
-    staleAfterDays: numberType().optional().describe("With pattern: flag figures asserted in EXACTLY one note whose sole note was last touched more than N days ago \u2014 the single-copy values that rot silently, because consistency() can only tell a single copy agrees with itself. Reported in staleSingles."),
+    subject: stringType().optional().describe("A fact in prose \u2014 returns notes asserting about it however phrased (instead of pattern=)"),
+    staleAfterDays: numberType().optional().describe("With pattern: also report values held in exactly one note untouched N+ days (staleSingles)"),
     domain: stringType().optional().describe("Restrict to one knowledge domain"),
     kinds: arrayType(enumType(Kinds)).optional().describe("Restrict to these kinds"),
     includeArchived: booleanType().optional().describe("Include archived notes (default false)"),
     limit: numberType().optional().describe("Max notes to examine (default 60)"),
-    fast: booleanType().optional().describe("Pre-filter candidates with Trilium's %= operator \u2014 faster, but its striptags'd corpus silently drops notes (default: false, scan every in-scope note)")
+    fast: booleanType().optional().describe("Use Trilium's faster but lossy %= pre-filter (default: scan every in-scope note)")
   }, async ({ pattern, subject, staleAfterDays, domain, kinds, includeArchived, limit, fast }) => {
     if (!pattern && !subject)
       return err("missing_param", "consistency() needs either a regex pattern or a prose subject.", 'Pass pattern="(\\\\d+) users" to compare a captured value, or subject="<a fact in prose>" to find every note asserting about that subject however phrased.');
@@ -25881,22 +25768,7 @@ anyway when scope is wide and speed matters more than completeness.`, {
       note: agrees ? groups.length === 0 ? "No note asserted a value for that pattern. That is evidence about the pattern, not about the brain \u2014 check it against a note you know contains the fact." : `All ${groups[0].count} note(s) agree on "${groups[0].value}".` : `${groups.length} DIFFERENT values are asserted across ${scoped.length} notes. Establish which is true from evidence, correct every note that disagrees, and wire ~corrects from the note that overturns the old claim \u2014 revising in place leaves no trace the wrong value was ever believed.`
     });
   });
-  server.tool("outline", `The heading tree of a note \u2014 every h2/h4 section with its level, its occurrence index among
-same-text siblings, and a structural check \u2014 without reading the body.
-
-Read this BEFORE a section= revise on a note you haven't just written. section= needs a heading
-string that matches, and guessing it wrong writes a new section rather than editing the one you
-meant; picking the level and the exact text from a list removes that failure instead of
-reporting it afterwards. occurrence is what you pass to revise(section=, occurrence=) to reach
-a specific one when several share a text.
-
-Also returns the note's size, the key column of any table it holds, and any structural drift
-already present (duplicate headings, unbalanced tags) \u2014 the cheap "is this note still sound"
-check after a run of surgical edits, and the way to see a Sources note's Revision keys (which
-remember(revision=) matches on exactly) without reading the note.
-
-On notes 15k+ the headings also carry a first-block preview of their section \u2014 the orientation
-read for oversized notes, where outline() alone assumes you already know which section you want.`, {
+  server.tool("outline", `A note's heading tree without its body: each h2\u2013h4 with level and occurrence index (and raw stored text where inline markup differs), table key columns, size, and structural findings. Read it before a section= edit you're not sure of. Notes over 15k also get a first-block preview per section.`, {
     noteId: stringType().describe("Note to outline")
   }, async ({ noteId }) => {
     const note = await trilium.getNote(noteId);
@@ -25943,22 +25815,7 @@ read for oversized notes, where outline() alone assumes you already know which s
       ...headings.length === 0 ? { note: "No h2\u2013h4 headings \u2014 section= would append a new section rather than match anything." } : {}
     });
   });
-  server.tool("inspect", `Read everything BrainLLM's tools track about a single note by id \u2014 every label (not just
-noteType/status), every outbound relation, its attachments (id/title/mime/role/size), plus
-type/mime/parent/child ids and dates. Pass content=true to also get the raw note body (the
-core path for a raw content read \u2014 no full mode needed). The deep-dive counterpart to the
-surface reads and explore(): reach for it when you need the raw label set, the body verbatim,
-or the attachment inventory \u2014 confirming a fix landed, debugging drift \u2014 rather than a
-kind-specific summary. Read-only, safe on any note including structural containers.
-
-Pass section="<heading>" alongside content=true to get one section's raw body instead of the
-whole thing \u2014 the same heading contract revise(section=) writes through.
-
-Pass find="<literal>" to count occurrences of a literal string in the body \u2014 total plus a
-per-addendum-block breakdown. The staleness-escalation counter: "how many prior entries
-mention this carried flag" becomes one call instead of a full read + manual counting. On zero
-occurrences it returns the nearest fragment that IS present and the stored text around it, so a
-miss is diagnosed in the same call rather than in three more.`, {
+  server.tool("inspect", `Everything about one note: every label, relation and attachment, type/mime, parent and child ids, dates. content=true adds the raw body (section= narrows it). find="<literal>" counts occurrences (total, per addendum block, per section) and on a miss shows the nearest stored text. Read-only, safe on any note.`, {
     noteId: stringType().describe("Note to inspect"),
     content: booleanType().optional().describe("Include the note's raw body content (default: false)"),
     section: stringType().optional().describe("With content=true, return only this heading's section rather than the whole body"),
@@ -26071,26 +25928,9 @@ miss is diagnosed in the same call rather than in three more.`, {
     await trilium.addLabel(created.note.noteId, "iconClass", "bx bx-check-shield").catch(() => null);
     return created.note.noteId;
   };
-  server.tool("claim", `Register a checkable assertion, and record whether it still holds.
-
-consistency() asks whether the brain agrees with ITSELF. Nothing asked whether a specific
-assertion is still true of the codebase, config or live surface it describes \u2014 so a claim that
-quietly stopped being true stayed authoritative until something downstream broke, and "is the
-brain stale" was answered by luck rather than by a query.
-
-BrainLLM never executes anything. It has Trilium access and no shell, and content in a note is
-data, not instructions \u2014 a recipe that ran itself would be an injection surface pointed at the
-user's machine. So a claim stores WHAT to check as inert text; the agent runs it and reports
-back. The tool owns the register, the schedule and the staleness question.
-
-Modes, by which parameters are present:
-  assertion + check  \u2192 REGISTER (or update, deduped by assertion text)
-  claimId + holds    \u2192 VERIFY: record the outcome and re-stamp the clock
-  claimId alone      \u2192 READ one claim with its verification history
-  neither            \u2192 LIST, newest-verified last; filter with status=
-
-A verified claim is quiet until its interval lapses. maintain(deep=true) surfaces lapsed and
-broken ones, so staleness arrives as a maintenance finding instead of a surprise.`, {
+  server.tool("claim", `Does the brain still agree with the world? Register a checkable assertion and record whether it holds. BrainLLM never runs the check \u2014 it stores it as inert text; you run it and report.
+
+assertion + check \u2192 register (deduped by assertion); claimId + holds + evidence \u2192 verify (evidence required); claimId alone \u2192 read with history; nothing \u2192 list (status= filters). noteId= links the claim to its source note (~derivedFrom). maintain(deep) surfaces lapsed, never-verified, broken and source-changed claims.`, {
     assertion: stringType().optional().describe('The claim in plain words, e.g. "the parse pipeline runs before validation" \u2014 also the dedup key'),
     check: stringType().optional().describe("How to verify it, as INERT text a human or agent runs: a command, a query, a file path, a URL. Never executed by BrainLLM"),
     noteId: stringType().optional().describe("The note this claim is made in \u2014 wired ~derivedFrom so the claim and its source stay linked"),
@@ -26202,20 +26042,7 @@ broken ones, so staleness arrives as a maintenance finding instead of a surprise
       ...all.length === 0 ? { note: 'No claims registered. Register one with claim(assertion="\u2026", check="\u2026") \u2014 the assertions worth registering are the ones that would be expensive to discover had gone stale.' } : {}
     });
   });
-  server.tool("diff", `What changed in a note \u2014 the revision snapshot against the body as it stands now.
-
-Every content write takes a revision first, and until now nothing could read one back: verifying
-a run of surgical edits on a large note meant re-reading the whole thing, or trusting the
-receipts. Trusting receipts is exactly how a section= replace that silently displaced four
-subsections went unnoticed.
-
-Called with only a noteId, this diffs the MOST RECENT revision against current content \u2014 "what
-did my last write actually do". Pass revisionId to compare against a specific earlier one; the
-revisions list comes back on every call, newest first, so the usual flow is one call to see what
-exists and a second to pick.
-
-Reports changed lines with a little context, plus added/removed counts. Both sides are stored
-HTML, so a formatting-only change is a real difference and shows as one.`, {
+  server.tool("diff", `What a write actually changed: a revision snapshot (default the latest) against the note as it stands, as changed lines with context and added/removed counts. The revision list comes back on every call; pass revisionId to compare against an earlier one.`, {
     noteId: stringType().describe("Note to diff"),
     revisionId: stringType().optional().describe("Compare against this revision (default: the most recent one)"),
     context: numberType().int().min(0).max(10).optional().describe("Unchanged lines to show around each change (default: 1)")
@@ -26275,15 +26102,7 @@ HTML, so a formatting-only change is a real difference and shows as one.`, {
       revisions: index
     });
   });
-  server.tool("attach", `Attach a raw artifact (file, image, code blob, document) to a note \u2014 or read one back.
-Dual-mode by the content param:
-  content provided \u2192 UPSERT by title: creates the attachment, or replaces the existing
-                      same-titled attachment's content (and mime) in place. Retry-safe \u2014
-                      re-running the same call converges on the same state.
-  content omitted  \u2192 READ: returns the named attachment's metadata and content.
-Attachments ride on the note \u2014 the native home for raw artifacts that belong with a typed
-memory rather than in its body. Binary content is standard base64 and is uploaded as raw bytes; reads return the same envelope. List a note's attachments with
-inspect(noteId); remove with detach().`, {
+  server.tool("attach", `Upsert a raw artifact (file, image, blob) on a note by title (content given; mime=, encoding="base64" for binary) or read one back (content omitted). List with inspect(), remove with detach().`, {
     noteId: stringType().describe("Owning note"),
     title: stringType().describe("Attachment title \u2014 the upsert/read key on this note"),
     content: stringType().optional().describe("Content to write (text, or base64 for binary). Omit to read the attachment instead."),
@@ -26329,9 +26148,7 @@ inspect(noteId); remove with detach().`, {
       throw error;
     }
   });
-  server.tool("detach", `Remove an attachment from a note \u2014 by attachmentId directly, or by (noteId + title).
-Permanent: attachments have no archive tier; re-attach() from source to undo. Retry-safe \u2014
-an already-removed target returns cleanly instead of erroring.`, {
+  server.tool("detach", `Remove an attachment by attachmentId, or by noteId + title. Permanent; retry-safe.`, {
     attachmentId: stringType().optional().describe("The attachment to remove"),
     noteId: stringType().optional().describe("Owning note \u2014 used with title when the id isn't at hand"),
     title: stringType().optional().describe("Attachment title on noteId")
@@ -26355,16 +26172,7 @@ an already-removed target returns cleanly instead of erroring.`, {
     }
     return txt3({ ok: true, removed: id, ...noteId ? { noteId, title } : {} });
   });
-  server.tool("addendum", `Search Master, LLM singletons (responsibilities + protocols + self-correction, not diary), and Knowledge
-for notes containing pending addendum blocks that need to be folded into the main content.
-
-These surfaces should be clean, merged, structured notes \u2014 not stacks of timestamped addendum
-markers. An addendum block on one of these notes is a temporary staging area: read it, fold
-its content into the relevant section body using revise(mode=replace or section=), then leave
-no addendum marker behind. Addendum-style append is appropriate only for sessions, diary
-entries, and logs \u2014 records by nature whose history has value. Everywhere else, merge.
-
-Returns note IDs, titles, kinds, and content snippets so you can identify what to fold in. The successful call also durably marks the pre-close gate.`, {}, async () => {
+  server.tool("addendum", `Find pending addendum blocks on notes that must stay merged documents (master and LLM singletons, knowledge notes). Fold each into its section with revise(section=/find=) and leave no marker; only sessions, diary, logs and dated thread entries accumulate addenda. The call marks its close-gate step.`, {}, async () => {
     const cfg = b();
     if (!cfg.root)
       return txt3({ error: "BrainLLM not bootstrapped \u2014 run bootstrap." });
@@ -26410,33 +26218,7 @@ Returns note IDs, titles, kinds, and content snippets so you can identify what t
       ...found.length === 0 ? { note: "No notes with pending addendums." } : { hint: "Fold each addendum into its note: read the block, then revise(noteId, section='<heading>', body='<merged content>', mode='replace') to absorb it into the right section. These notes must be left clean \u2014 no addendum markers. Addendum-style history belongs only in sessions, diary, and logs. Scoped/autonomous agents: fold only what's in your lane \u2014 leaving personal or out-of-scope addendums for the next interactive session is correct, and calling this tool is what satisfies the pre-close gate." }
     });
   });
-  server.tool("maintain", `Run the maintenance sweep. start and close run the lite sweep automatically (ages stale
-threads active \u2192 dormant \u2192 archived). deep=true also surfaces stale notes (untouched past the
-policy window), unconnected threads/knowledge notes (orphan = no connections at all; sink =
-has inbound but no outbound) to wire with connect() \u2014 inbound detection is brain-wide, so a
-note referenced from another area is never misflagged as an orphan \u2014 a structural lint over
-maintained documents (duplicate headings within one note, unbalanced tags, bodies approaching
-the read ceiling), duplicate titles, and any thread day-child that escaped its
-#noteType=threadEntry label. dryRun previews only.
-
-ack=[noteId, \u2026] marks a note reviewed-and-correct: its findings stay quiet until its content
-actually changes, then all of them return. Use it instead of ignoring a flag you have decided
-is fine \u2014 a warning that reappears every run and is correctly ignored every run trains you to
-skim the list, which is where the one finding that DID change gets missed. Same mechanic as a
-linter baseline, same justification. suppressed reports how many findings were withheld.
-
-domain="<name>" narrows the deep passes to one domain's notes \u2014 the equivalent of the lane
-scoping addendum() already has, so a scoped agent's flags arrive in its own lane instead of it
-re-deriving each run that the cross-venture findings belong to someone else.
-
-repair=[noteId, \u2026] fixes an entity-corrupted body in place instead of reporting it: one level of
-double-escaping is unwound ("&amp;lt;" \u2192 "&lt;", "&amp;nbsp;" \u2192 "&nbsp;"), with a revision taken
-first. The substitution is always the same one, so it is a first-class action rather than
-something each caller reinvents with revise(mode="replace"). Compose with dryRun to see the
-outcome without writing. A note that DOCUMENTS the signature rather than carrying it comes back
-unchanged and is reported as such \u2014 ack= those.
-
-coverage names any pass that hit a cap, so a short list is never mistaken for a clean one.`, {
+  server.tool("maintain", `Brain hygiene. Lite (automatic in start/close): ages threads active \u2192 dormant \u2192 archived and checks labels. deep=true adds stale notes, orphans and sinks, structural lint (duplicate headings, unbalanced tags, missing required sections, dated prose in timeless notes, oversized notes), duplicate titles, lapsed or broken claims and hygiene passes. dryRun previews. ack=[ids] silences a note you reviewed until its content changes. domain= narrows deep passes to one lane. repair=[ids] unwinds entity double-escaping in place. coverage names any capped pass.`, {
     deep: booleanType().optional().describe("Deep pass: stale-review + orphan/sink + structural lint + duplicate titles across Memory/Threads and Knowledge (default: false)"),
     dryRun: booleanType().optional().describe("Report what would change without changing it"),
     domain: stringType().optional().describe("Narrow the deep passes to one domain's notes (slugged server-side) \u2014 for scoped agents working a single lane"),
@@ -26456,10 +26238,7 @@ coverage names any pass that hit a cap, so a short list is never mistaken for a
     await markStep("maintain");
     return txt3(report);
   });
-  server.tool("forget", `Archive a note (default) or hard-delete it (hard=true). Archiving keeps it in place,
-hidden from default recall \u2014 the safe choice and the only one for anything with history.
-Hard delete is refused while other notes still link here (backlinks are returned so you can
-re-wire with connect() first). To undo an archive, use recover().`, {
+  server.tool("forget", `Archive a note (default \u2014 hidden from default recall, recoverable with recover()) or hard-delete it (hard=true, refused while backlinked).`, {
     noteId: stringType().describe("Note to forget"),
     reason: stringType().optional().describe("Why \u2014 recorded in the note before archiving"),
     hard: booleanType().optional().describe("Permanently delete instead of archive")
@@ -26505,11 +26284,7 @@ re-wire with connect() first). To undo an archive, use recover().`, {
     const relations = relationSnippet(note);
     return txt3({ ok: true, archived: noteId, title: note.title, ...relations ? { relations } : {} });
   });
-  server.tool("recover", `Restore an archived or resolved note: removes #archived, clears #closed, resets status
-to active. Use to undo forget() or reconsider a resolved thread / note. Does not restore
-note content \u2014 use revise() to fix content, or get_revisions (full mode) to roll back to a
-prior snapshot. For notes deleted from Trilium entirely (not just archived), use undelete_note
-(full mode) instead.`, {
+  server.tool("recover", `Restore an archived or resolved note: clears #archived and #closed and resets status. Content is untouched \u2014 use revise(), or get_revisions for an older snapshot. Notes deleted from Trilium need undelete_note.`, {
     noteId: stringType().describe("The archived or resolved note to restore"),
     reason: stringType().optional().describe("Why it was recovered \u2014 written as an addendum"),
     date: stringType().optional().describe("ISO date (default: today)")
@@ -26543,17 +26318,7 @@ prior snapshot. For notes deleted from Trilium entirely (not just archived), use
       ...warnings.length ? { sanitized: warnings } : {}
     });
   });
-  server.tool("template", `Serve the canonical structure for a content kind \u2014 the enforced skeleton, the
-top-to-bottom structure, and the rules writes are held to. Read it BEFORE writing a kind for
-the first time in a session, or when unsure. The write tools enforce what can be enforced
-server-side (heading normalization, duplicate-heading detection, thread Goal/Resolution rules,
-Last-updated stamps); this tool serves the full contract including what remains authorial.
-
-Template for the schema, sibling for the shape: this gives you the skeleton, but the
-conventions it cannot encode \u2014 how deep the headings actually go, how a table is laid out, how
-much prose a section warrants, what a good title looks like for this kind \u2014 live in the notes
-that already exist. Read one before writing another. Content of the same kind must read like
-its siblings, and a note that satisfies the skeleton can still be the odd one out.`, {
+  server.tool("template", `The canonical structure for a kind: skeleton, top-to-bottom structure, and the rules writes are held to (including what stays authorial). Read it before your first write of a kind; then read an existing sibling and match its shape.`, {
     kind: enumType(Kinds).describe("The content kind to serve the canonical structure for")
   }, async ({ kind }) => {
     const rule = structureRuleFor(kind);
@@ -26568,22 +26333,17 @@ its siblings, and a note that satisfies the skeleton can still be the odd one ou
       ...rule ? { structure: rule.structure, rules: rule.rules } : { note: "No bespoke structure for this kind \u2014 server meta line + body." },
       skeleton,
       conventions: [
-        "Headings h2\u2013h4 only \u2014 h1 is the note title; h5/h6 are demoted on write.",
-        "Minimal headings \u2014 only ones that earn their place. Depth comes from layout (tables, lists, emphasis), not heading proliferation. A heading whose section is one sentence was not a section; headings are also what revise(section=) addresses, so proliferating them makes every future edit ambiguous too.",
-        "Titles: concise, maximum 4 words, no dates or run numbers (dates defeat title-dedup). A title that won't trim to 4 words without losing what it identifies is a signal the CONTENT should be split, not the title stretched.",
-        "Merge, don't stack: Master, LLM (excluding the session/diary/log surfaces) and Knowledge notes are clean merged documents \u2014 fold new content into the relevant section's body. Dated, append-only history is expected only for sessions, diary entries and logs, which are records by nature. Everywhere else, merge.",
-        "Content of the same kind matches its siblings \u2014 same structure, layout, and format. Read an existing one before writing another; if a pattern needs improving, improve it everywhere, since one better-shaped note among twenty is drift, not an improvement."
+        "Headings h2\u2013h4 only (h1 is the title); only headings that earn their place \u2014 depth comes from tables, lists and emphasis.",
+        "Titles: at most 4 words, no dates or run numbers (they defeat dedup-by-title).",
+        "Timeless kinds carry no state, version or decision history: state goes to the domain's Current State note, history to thread entries and sessions.",
+        "One sentence is enough if it says the thing; drop what is rarely relevant.",
+        "Merge, don't stack: only sessions, diary, logs and dated thread entries are append-only records.",
+        "Match your siblings' structure; improve a pattern everywhere or nowhere.",
+        "Every note carries an icon except logs: the kind default is set for you; pass icon= to choose a fitting one."
       ]
     });
   });
-  server.tool("graph", `The graph view \u2014 render the brain's relation graph as a Mermaid flowchart.
-Scope: the whole brain (default), or a neighborhood (pass noteId + depth). Nodes are the typed
-notes, colored by area; edges are the typed relations (~template excluded). The Mermaid source
-is returned AND upserted into the maintained "Graph" note under Insights (a native Trilium
-mermaid note), so the view renders in Trilium and in any Mermaid-capable client. On-demand only \u2014
-the note reflects the brain as of this call, not automatically after later writes; call again to
-refresh. A scoped (noteId) call replaces the note's content with just that neighborhood, not the
-whole-brain view.`, {
+  server.tool("graph", `Render the relation graph as a Mermaid flowchart \u2014 the whole brain, or a neighborhood (noteId + depth). Returns the source and writes it to the Insights/Graph note. On demand only; a scoped call replaces the note's content.`, {
     noteId: stringType().optional().describe("Center the graph on this note's neighborhood instead of the whole brain"),
     depth: numberType().optional().describe("Neighborhood hops when noteId is given (default: 2)"),
     includeArchived: booleanType().optional().describe("Include archived notes (default: false)")
@@ -26678,19 +26438,12 @@ whole-brain view.`, {
       mermaid
     });
   });
-  server.tool("day", `The new-day sweep payload \u2014 one call replacing the manual multi-read protocol on the
-first session of a day. Serves: whether today is genuinely fresh (no addendum blocks in
-today's session note), the previous session in full, that day's change log, the notes touched
-since then, and the current month's deliverables note in full. Advance the deliverables note's
-statuses with revise(find=) and present the findings in the first message \u2014 grounded strictly
-in what the touched notes evidence.
-
-recap=true answers the other question \u2014 "what happened TODAY, in order, across every surface"
-\u2014 by returning every addendum block written today across the session note, the diary and every
-thread day-child, chronologically, with its identification line. start() is tuned for a fresh
-day and does not serve a day already several instances deep; reconstructing one by hand takes a
-read per surface, and as more work runs unattended that shape becomes the norm rather than the
-exception.`, {
+  server.tool("day", `The new-day sweep in one call: whether today is fresh (no addendum blocks in today's session
+note), the previous session in full, that day's log, and the notes touched since. Present what the
+touched notes evidence in the first message.
+
+recap=true instead returns every addendum block written today across the session note, the diary
+and every thread day-child, in time order with its identification line.`, {
     date: stringType().optional().describe("ISO date YYYY-MM-DD (default: today)"),
     recap: booleanType().optional().describe("Return today's addendum blocks across sessions, diary and thread children in chronological order, instead of the new-day sweep")
   }, async ({ date, recap }) => {
@@ -26778,37 +26531,19 @@ exception.`, {
         }));
       } catch {}
     }
-    const monthName = new Date(`${todayStr}T00:00:00Z`).toLocaleString("en-US", { month: "long", timeZone: "UTC" });
-    let deliverables = null;
-    const monthNotes = await trilium.searchNotes("#noteType=user", { ancestorNoteId: cfg.knowledge.master, fastSearch: true, limit: 100 }).catch(() => ({ results: [] }));
-    const monthNote = monthNotes.results.find((n) => sameTitle(n.title, monthName));
-    if (monthNote) {
-      deliverables = { id: monthNote.noteId, title: monthNote.title, content: await trilium.getNoteContent(monthNote.noteId).catch(() => "") };
-    }
     return txt3({
       date: todayStr,
       newDay,
-      month: monthName,
       lastSession,
       previousLog,
       changes: changes.length ? changes : undefined,
-      deliverables: deliverables ?? { note: `No "${monthName}" deliverables note found in Knowledge/Master \u2014 first session of a new month: baseline a fresh one from the venture strategies and the schedule state.` },
       next: [
-        "Skim lastSession, previousLog, and changes for evidenced outputs \u2014 never plausibility.",
-        "Advance the deliverables note's counts/statuses with revise(noteId, find=..., body=...).",
-        "Present the findings in the first message: what moved, what's now due, current counts against the month."
+        "Skim lastSession, previousLog and changes for evidenced outputs \u2014 never plausibility.",
+        "Present what moved in the first message."
       ]
     });
   });
-  server.tool("brain", `Surface the entire BrainLLM content tree \u2014 every typed note across all five content areas
-(Master, LLM, Memory, Knowledge, Insights), grouped by area and sub-container, with
-id/title/kind/status/dates. Use to audit what the brain contains or locate a specific note.
-Structural containers are excluded; only content notes appear.
-
-Insights returns { logs, claims }. Claims were missing entirely before V12 \u2014 they live in a
-container resolved by title rather than named in the config, and this read was scoped one level
-too deep to reach them, so the register was invisible to the tool that calls itself the full
-inventory.`, {
+  server.tool("brain", `The full inventory: every content note across all five areas with id, title, kind, status, parent and dates, grouped by area (Insights returns logs and claims). Use it to audit or locate a note; read parent, not position \u2014 each group is flat. includeArchived= adds archived notes.`, {
     includeArchived: booleanType().optional().describe("Include archived/resolved notes (default: false)")
   }, async ({ includeArchived }) => {
     const cfg = b();
@@ -26885,25 +26620,7 @@ inventory.`, {
     const total = masterAll.length + llmSingletons.length + llmDiary.length + sessions.length + threads.length + kMaster.length + kDomains.length + insights.length;
     return txt3({ total, areas });
   });
-  server.tool("assembly", `What the brain HOLDS \u2014 every note by title, grouped under the surface it lives in, with each
-surface's own purpose alongside it. The awareness read: "what do I already know here", answered
-in one call before deciding whether to look something up.
-
-Distinct from brain(), which is an inventory: brain() returns id, kind, status, parent, dates and
-relations for every note, and is what you want when auditing or locating one. assembly() answers
-a different question and is shaped for it:
-
-- **Dated collections collapse.** Sessions, diary entries and logs are titled [yyyy-mm-dd], so
-  listing them is a wall of dates carrying no information about content. They come back as a
-  count and a span instead. This is the difference between a listing and an awareness read \u2014 the
-  full titles are one brain() call away when you actually need them.
-- **Domains nest.** Each domain book appears with its own information and sources notes beneath
-  it, which is the real shape of what the brain knows rather than the flat list brain() returns.
-- **Threads group by status**, newest activity first \u2014 the working set is the actionable part.
-- **Purposes are read from the container notes themselves**, the text bootstrap engraved on them,
-  so this can never drift from what the brain actually says about itself.
-
-Pass area= to zoom into one surface and get its full detail.`, {
+  server.tool("assembly", `What the brain holds: every note by title, grouped under its surface with that surface's purpose. Dated collections (sessions, diary, logs) collapse to a count and span; domains nest their notes; threads group by status. The awareness read \u2014 use brain() instead to audit or locate by id. area= zooms into one surface.`, {
     area: enumType(["master", "llm", "memory", "knowledge", "insights"]).optional().describe("Zoom into one surface instead of all five"),
     includeArchived: booleanType().optional().describe("Include archived/resolved notes (default: false)")
   }, async ({ area, includeArchived }) => {
@@ -27007,12 +26724,7 @@ Pass area= to zoom into one surface and get its full detail.`, {
       ...includeArchived ? {} : { note: "Archived and resolved notes are excluded \u2014 pass includeArchived=true to see them." }
     });
   });
-  server.tool("bootstrap", `Initialize the BrainLLM structure in Trilium (idempotent \u2014 safe to re-run; refreshes config,
-heals singletons a newer version introduced, and re-engraves container purposes if the structure
-already exists). Creates the five areas \u2014 Master (Biography/Goals/Preferences),
-LLM (Responsibilities/Protocols/Self-correction/Diary), Memory (Sessions/Threads), Knowledge (Master/Domains),
-Insights (Logs) \u2014 each engraved with its purpose, and writes brainllm.json. Active
-immediately, no restart needed.`, {}, async () => {
+  server.tool("bootstrap", `Create the BrainLLM structure in Trilium, or verify and refresh it when it exists (idempotent): the five areas with their containers, singletons and engraved purposes, plus brainllm.json. Only creates a new tree when the stored root is confirmed deleted.`, {}, async () => {
     if (b().root) {
       try {
         const existing = await trilium.getNote(b().root);
@@ -27488,7 +27200,7 @@ note.dateModified >= 'YYYY-MM-DD', AND/OR. Unscoped unless ancestorNoteId is giv
     await trilium.deleteNote(noteId);
     return txt4({ ok: true, deleted: noteId });
   });
-  server.tool("undelete_note", "Recover a recently Trilium-deleted note from Trilium's trash. canBeUndeleted must be true (check note_history). Distinct from recover() which restores BrainLLM-archived notes. Re-applies the BrainLLM label set for the container it lands in \u2014 the restore itself does not bring attributes back, and a note without #noteType is invisible to every read path.", { noteId: stringType() }, async ({ noteId }) => {
+  server.tool("undelete_note", `Restore a note deleted in Trilium (check note_history for canBeUndeleted) and re-apply its BrainLLM labels. For BrainLLM-archived notes use recover().`, { noteId: stringType() }, async ({ noteId }) => {
     await trilium.undeleteNote(noteId);
     const cfg = b();
     const note = await trilium.getNote(noteId);
@@ -27660,7 +27372,7 @@ note.dateModified >= 'YYYY-MM-DD', AND/OR. Unscoped unless ancestorNoteId is giv
   server.tool("get_year_note", "Get (or auto-create) the journal year note. Format: YYYY.", { year: stringType() }, async ({ year }) => txt4(await trilium.getYearNote(year)));
   server.tool("get_inbox_note", "Get the Trilium inbox note for a date (fixed #inbox note, or the day note). Format: YYYY-MM-DD.", { date: stringType().optional() }, async ({ date }) => txt4(await trilium.getInboxNote(date ?? localToday())));
   server.tool("get_app_info", "Trilium server version, DB version, runtime metadata.", {}, async () => txt4(await trilium.getAppInfo()));
-  server.tool("create_backup", "Trigger a named Trilium database backup. ETAPI confirms the logical request completed but does not expose the resulting file path or format (it may be .db or .tnbackup). Use a descriptive name for milestone snapshots (e.g. 'before-migration').", {
+  server.tool("create_backup", `Named Trilium database backup (raw). The resulting file path is not exposed.`, {
     name: stringType().optional().describe("Backup file name without .db extension (default: brainllm-{today})"),
     date: stringType().optional().describe("ISO date used in the default name when name is omitted (default: today)")
   }, async ({ name, date }) => {
@@ -28824,7 +28536,7 @@ function createServer(origin = null) {
   const s = new McpServer({
     name: "BrainLLM",
     title: "BrainLLM",
-    version: "12.4.1",
+    version: "12.5.0",
     icons: brandingIcons(origin)
   });
   registerTools(s, trilium, brainRef);
@@ -28977,12 +28689,14 @@ if (port) {
           return withCors(await handleRegister(req));
         }
       }
-      if (url.pathname === "/") {
+      const rootMcpRequest = url.pathname === "/" && (req.method !== "GET" || req.headers.has("mcp-session-id") || req.headers.has("mcp-protocol-version") || (req.headers.get("accept") ?? "").includes("application/json") || (req.headers.get("accept") ?? "").includes("text/event-stream"));
+      if (url.pathname === "/" && !rootMcpRequest) {
         return withCors(new Response(landingPage(base, oauthOn, true), {
           headers: { "Content-Type": "text/html; charset=utf-8", "Cache-Control": "no-store" }
         }));
       }
-      if (url.pathname !== "/mcp" && url.pathname !== "/sse" && url.pathname !== "/messages") {
+      const isMcpEndpoint = url.pathname === "/mcp" || rootMcpRequest;
+      if (!isMcpEndpoint && url.pathname !== "/sse" && url.pathname !== "/messages") {
         return withCors(new Response("Not Found", { status: 404 }));
       }
       const transportLimit = rateLimited(rateLimiters.transport, requestKey);