brainllm 11.0.0 → 12.1.0

package/README.md

@@ -10,7 +10,7 @@ A persistent, graph-structured second brain for Claude and any MCP client — bu
 
 [**brainllm site**](https://miisodev.github.io/BrainLLM/) · [How it works](https://miisodev.github.io/BrainLLM/how-it-works.html) · [Use cases](https://miisodev.github.io/BrainLLM/use-cases.html) · [Docs](https://miisodev.github.io/BrainLLM/docs.html)
 
-[![Version](https://img.shields.io/badge/version-11.0.0-f59e0b?style=flat-square)](https://github.com/miisodev/BrainLLM/releases)
+[![Version](https://img.shields.io/badge/version-12.1.0-f59e0b?style=flat-square)](https://github.com/miisodev/BrainLLM/releases)
 [![CI](https://img.shields.io/github/actions/workflow/status/miisodev/BrainLLM/ci.yml?branch=main&style=flat-square&label=CI&color=f59e0b)](https://github.com/miisodev/BrainLLM/actions/workflows/ci.yml)
 [![License: MIT](https://img.shields.io/badge/license-MIT-a1a1aa?style=flat-square)](./LICENSE)
 [![Runtime: Bun](https://img.shields.io/badge/runtime-Bun%20%E2%89%A5%201.0-a1a1aa?style=flat-square&logo=bun&logoColor=white)](https://bun.sh)
@@ -60,7 +60,7 @@ At bootstrap, BrainLLM builds a five-area tree in Trilium. Every note the tools
 ```
 BrainLLM  (#brainLlmRoot)
 ├── 👤 Master       Biography · Goals · Preferences               (the user — maintained singletons)
-├── 🤖 LLM          Responsibilities · Protocols · Diary/         (the assistant's self-model + daily diary)
+├── 🤖 LLM          Responsibilities · Protocols · Self-correction · Diary/  (the assistant's self-model + daily diary)
 ├── 🗂️ Memory       Sessions/ · Threads/                          (daily session logs + multi-session work)
 ├── 📚 Knowledge    Master/ · Domains/<domain>/{ Sources, info }  (learned facts beyond/contra training)
 └── 💡 Insights     Logs/ · Graph                                 (the brain's record of itself)
@@ -68,7 +68,7 @@ BrainLLM  (#brainLlmRoot)
 
 | Note class | Kinds | Behavior |
 |---|---|---|
-| **Singletons** | biography, goals, preferences, responsibilities, protocols (+ each domain's Sources note) | Exactly one maintained note; edited in place; hold *current-state truth* |
+| **Singletons** | biography, goals, preferences, responsibilities, protocols, selfcorrection (+ each domain's Sources note) | Exactly one maintained note; edited in place; hold *current-state truth* |
 | **Dated records** | diary, session, log | One per calendar day; every write lands as a timestamped addendum block — chronology is the point |
 | **Collections** | thread, user, information, domain | Titled notes, deduplicated by normalized title within their scope |
 

package/dist/index.js

@@ -25416,6 +25416,7 @@ var Kinds = [
   "preferences",
   "responsibilities",
   "protocols",
+  "selfcorrection",
   "diary",
   "session",
   "thread",
@@ -25433,6 +25434,7 @@ var KIND_AREA = {
   preferences: "master",
   responsibilities: "llm",
   protocols: "llm",
+  selfcorrection: "llm",
   diary: "llm",
   session: "memory",
   thread: "memory",
@@ -25449,8 +25451,12 @@ var SingletonKinds = [
   "goals",
   "preferences",
   "responsibilities",
-  "protocols"
+  "protocols",
+  "selfcorrection"
 ];
+function isSingletonKind(k) {
+  return SingletonKinds.includes(k);
+}
 var Statuses = ["active", "resolved", "superseded", "dormant", "eternal"];
 var RelationTypes = [
   "relatesTo",
@@ -25972,10 +25978,10 @@ class TriliumClient {
 import { existsSync, readFileSync, writeFileSync } from "fs";
 import { join, dirname } from "path";
 var EMPTY_BRAINLLM = {
-  version: 9,
+  version: 10,
   root: "",
   master: { root: "", biography: "", goals: "", preferences: "" },
-  llm: { root: "", responsibilities: "", protocols: "", diary: "" },
+  llm: { root: "", responsibilities: "", protocols: "", selfcorrection: "", diary: "" },
   memory: { root: "", sessions: "", threads: "", metaThread: "" },
   knowledge: { root: "", master: "", domains: "" },
   insights: { root: "", logs: "" },
@@ -26016,9 +26022,10 @@ function loadConfig() {
     return null;
   try {
     const parsed = JSON.parse(readFileSync(path, "utf-8"));
-    if (typeof parsed?.root === "string" && (parsed?.version === 9 || parsed?.version === 8 || parsed?.version === 5)) {
+    if (typeof parsed?.root === "string" && [10, 9, 8, 5].includes(parsed?.version)) {
       return {
         ...parsed,
+        llm: { selfcorrection: "", ...parsed.llm ?? {} },
         memory: { metaThread: "", ...parsed.memory ?? {} },
         policy: { ...DEFAULT_POLICY, ...parsed.policy ?? {} }
       };
@@ -26028,7 +26035,7 @@ function loadConfig() {
 }
 function saveConfig(config2) {
   const path = configFilePath();
-  writeFileSync(path, JSON.stringify({ ...config2, version: 9 }, null, 2) + `
+  writeFileSync(path, JSON.stringify({ ...config2, version: 10 }, null, 2) + `
 `, "utf-8");
   return path;
 }
@@ -26062,7 +26069,7 @@ async function discoverBrainLLM(trilium) {
           config2.master = { root: id, biography: g("Biography"), goals: g("Goals"), preferences: g("Preferences") };
           break;
         case "LLM":
-          config2.llm = { root: id, responsibilities: g("Responsibilities"), protocols: g("Protocols"), diary: g("Diary") };
+          config2.llm = { root: id, responsibilities: g("Responsibilities"), protocols: g("Protocols"), selfcorrection: g("Self-correction"), diary: g("Diary") };
           break;
         case "Memory":
           config2.memory = { root: id, sessions: g("Sessions"), threads: g("Threads"), metaThread: "" };
@@ -26756,8 +26763,9 @@ function setSection(html, heading, content, mode, occurrence = 1) {
 ${html.slice(headingStart)}`, matched: true, headingCount };
     }
     if (mode === "after") {
-      return { html: `${html.slice(0, contentStart)}
-${content}${html.slice(contentStart)}`, matched: true, headingCount };
+      return { html: `${html.slice(0, end).replace(/\s*$/, "")}
+${content}
+${html.slice(end)}`, matched: true, headingCount };
     }
     const existing = html.slice(contentStart, end).trim();
     const inner = mode === "append" && existing ? `${existing}
@@ -27007,7 +27015,8 @@ var STRUCTURED_SINGLETONS = new Set([
   "goals",
   "preferences",
   "responsibilities",
-  "protocols"
+  "protocols",
+  "selfcorrection"
 ]);
 var hasHeading = (html, text) => new RegExp(`<h[2-4](?:\\s[^>]*)?>\\s*${text}\\s*</h[2-4]>`, "i").test(html);
 var REQUIRED_SECTIONS = {
@@ -27063,8 +27072,10 @@ ${o.goal ? `<p>${escapeHtml(o.goal)}</p>` : o.body || "<p>To be determined.</p>"
 <p></p>`].join(`
 `);
     case "protocols":
-      return ["<h2>Operating</h2>", o.body || "<p></p>", `<h2>Self-correction</h2>
-<p></p>`].join(`
+      return ["<h2>Operating</h2>", o.body || "<p></p>"].join(`
+`);
+    case "selfcorrection":
+      return ["<h2>Corrections</h2>", o.body || "<p></p>"].join(`
 `);
     case "domain":
       return domainContent(o.domain ?? "");
@@ -27235,7 +27246,7 @@ function structureRuleFor(kind) {
 
 // src/router.ts
 function isSingleton(kind) {
-  return SingletonKinds.includes(kind);
+  return isSingletonKind(kind);
 }
 function kindHome(cfg, kind) {
   switch (kind) {
@@ -27249,6 +27260,8 @@ function kindHome(cfg, kind) {
       return cfg.llm.responsibilities;
     case "protocols":
       return cfg.llm.protocols;
+    case "selfcorrection":
+      return cfg.llm.selfcorrection;
     case "diary":
       return cfg.llm.diary;
     case "session":
@@ -27363,6 +27376,8 @@ function locationLabel(kind, domainTitle) {
       return "LLM \u2192 Responsibilities";
     case "protocols":
       return "LLM \u2192 Protocols";
+    case "selfcorrection":
+      return "LLM \u2192 Self-correction";
     case "diary":
       return "LLM \u2192 Diary";
     case "session":
@@ -27397,6 +27412,7 @@ function structuralIds(cfg) {
     cfg.llm.root,
     cfg.llm.responsibilities,
     cfg.llm.protocols,
+    cfg.llm.selfcorrection,
     cfg.llm.diary,
     cfg.memory.root,
     cfg.memory.sessions,
@@ -27417,7 +27433,8 @@ function isContainer(cfg, noteId) {
     cfg.master.goals,
     cfg.master.preferences,
     cfg.llm.responsibilities,
-    cfg.llm.protocols
+    cfg.llm.protocols,
+    cfg.llm.selfcorrection
   ];
   return isStructural(cfg, noteId) && !singletons.includes(noteId);
 }
@@ -27760,6 +27777,8 @@ async function sweep(trilium, cfg, opts = {}) {
               if (reported.has(pairKey))
                 continue;
               reported.add(pairKey);
+              if (acknowledged(a) || acknowledged(bn))
+                continue;
               const [ha, hb] = await Promise.all([headingsOf(a), headingsOf(bn)]);
               const overlap = ha.filter((h) => hb.some((x) => x.toLowerCase() === h.toLowerCase()));
               const show = (h) => h.length ? h.slice(0, 8).join(" \xB7 ") + (h.length > 8 ? " \xB7 \u2026" : "") : "(no headings)";
@@ -27932,7 +27951,8 @@ async function buildDigest(trilium, cfg, opts = {}) {
     ]),
     Promise.all([
       readSlot("responsibilities", cfg.llm.responsibilities),
-      readSlot("protocols", cfg.llm.protocols)
+      readSlot("protocols", cfg.llm.protocols),
+      readSlot("selfcorrection", cfg.llm.selfcorrection)
     ])
   ]);
   digest.master.push(...masterSlots.filter((s) => !!s));
@@ -28042,9 +28062,10 @@ async function createBrainLLMStructure(trilium) {
     leaf(masterRoot, "Preferences", "preferences", "A single maintained note of the master/user's preferences.")
   ]);
   const llmRoot = await book(rootId, "LLM", CONTAINER_PURPOSES.llm, "bx bx-bot");
-  const [responsibilities, protocols, diary] = await Promise.all([
+  const [responsibilities, protocols, selfcorrection, diary] = await Promise.all([
     leaf(llmRoot, "Responsibilities", "responsibilities", "A single maintained note of the assistant's responsibilities to the master/user, derived from their goals and preferences."),
     leaf(llmRoot, "Protocols", "protocols", "A single maintained note of the assistant's operating and self-correctness protocols \u2014 how it maximises its value to the master/user by efficiently meeting its responsibilities."),
+    leaf(llmRoot, "Self-correction", "selfcorrection", "A single maintained note of the assistant's own corrections \u2014 the mistakes it has made, what generalises from each, and the rule that prevents a repeat. Split out of Protocols in V12 so orientation stops paying for it on every session start."),
     book(llmRoot, "Diary", CONTAINER_PURPOSES.llmDiary, "bx bx-book-heart")
   ]);
   const memoryRoot = await book(rootId, "Memory", CONTAINER_PURPOSES.memory, "bx bx-been-here");
@@ -28060,10 +28081,10 @@ async function createBrainLLMStructure(trilium) {
   const insightsRoot = await book(rootId, "Insights", CONTAINER_PURPOSES.insights, "bx bx-bulb");
   const logs = await book(insightsRoot, "Logs", CONTAINER_PURPOSES.insightsLogs, "bx bx-history");
   return {
-    version: 9,
+    version: 10,
     root: rootId,
     master: { root: masterRoot, biography, goals, preferences },
-    llm: { root: llmRoot, responsibilities, protocols, diary },
+    llm: { root: llmRoot, responsibilities, protocols, selfcorrection, diary },
     memory: { root: memoryRoot, sessions, threads, metaThread: "" },
     knowledge: { root: knowledgeRoot, master: knowledgeMaster, domains },
     insights: { root: insightsRoot, logs },
@@ -28234,12 +28255,19 @@ 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 or protocols (singletons), or a diary entry by id.
+  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, which is the largest singleton and the one most often needed in part rather than
-whole. outline(id) lists the headings.`, {
-    which: exports_external.enum(["responsibilities", "protocols", "diary"]),
+protocols and selfcorrection, the two largest singletons and the ones most often needed in part
+rather than whole. outline(id) lists the headings.`, {
+    which: exports_external.enum(["responsibilities", "protocols", "selfcorrection", "diary"]),
     id: exports_external.string().optional().describe("diary only: the entry id from llm_recall"),
     section: exports_external.string().optional().describe("Read only this heading's section (h2/h3/h4), instead of the whole note"),
     occurrence: exports_external.number().int().positive().optional().describe("section=: which same-text heading, 1-based (default: the first)")
@@ -28250,20 +28278,23 @@ whole. outline(id) lists the headings.`, {
       return txt(await readFull(trilium, id, { section, occurrence }));
     }
     const noteId = b().llm[which];
-    if (!noteId)
-      throw new Error("BrainLLM not bootstrapped \u2014 run bootstrap.");
+    if (!noteId) {
+      throw new Error(which === "selfcorrection" ? "This brain has no Self-correction note yet \u2014 it arrived in V12. Run bootstrap() once; it finds or creates the note and persists its id, leaving everything else untouched." : "BrainLLM not bootstrapped \u2014 run bootstrap.");
+    }
     return txt(await readFull(trilium, noteId, { section, occurrence }));
   });
-  server.tool("llm_recall", "Skim the LLM surface: responsibilities & protocols opening lines (with relation snippets), plus recent diary entries.", { limit: exports_external.number().optional() }, async ({ limit }) => {
+  server.tool("llm_recall", "Skim the LLM surface: responsibilities, protocols & self-correction opening lines (with relation snippets), plus recent diary entries.", { limit: exports_external.number().optional() }, async ({ limit }) => {
     const cfg = b();
-    const [resp, prot, diary] = await Promise.all([
+    const [resp, prot, selfcorr, diary] = await Promise.all([
       previewWithRelations(trilium, cfg.llm.responsibilities),
       previewWithRelations(trilium, cfg.llm.protocols),
+      cfg.llm.selfcorrection ? previewWithRelations(trilium, cfg.llm.selfcorrection) : Promise.resolve(null),
       skim(trilium, cfg.llm.diary, { kind: "diary", limit: limit ?? 7 })
     ]);
     return txt({
       responsibilities: { id: cfg.llm.responsibilities, ...resp },
       protocols: { id: cfg.llm.protocols, ...prot },
+      ...selfcorr ? { selfcorrection: { id: cfg.llm.selfcorrection, ...selfcorr } } : {},
       diary
     });
   });
@@ -28711,12 +28742,13 @@ rather than listing them unconditionally for every caller to work around.`, {
       const relations = relationSnippet(note);
       return { id, lastModified: note.dateModified.slice(0, 10), content, ...relations ? { relations } : {} };
     };
-    const [biography, goals, preferences, responsibilities, protocols] = await Promise.all([
+    const [biography, goals, preferences, responsibilities, protocols, selfcorrection] = await Promise.all([
       fetchSingleton(cfg.master.biography),
       fetchSingleton(cfg.master.goals),
       fetchSingleton(cfg.master.preferences),
       fetchSingleton(cfg.llm.responsibilities),
-      fetchSingleton(cfg.llm.protocols)
+      fetchSingleton(cfg.llm.protocols),
+      cfg.llm.selfcorrection ? fetchSingleton(cfg.llm.selfcorrection) : Promise.resolve(null)
     ]);
     let diaryEntry = null;
     if (cfg.llm.diary) {
@@ -28736,14 +28768,15 @@ rather than listing them unconditionally for every caller to work around.`, {
       const contents = await Promise.all(candidates.map((n) => trilium.getNoteContent(n.noteId).catch(() => "")));
       return contents.filter(hasAddendumMarker).length;
     }).catch(() => null);
-    const singletonStubs = [
-      ["biography", biography],
-      ["goals", goals],
-      ["preferences", preferences],
-      ["responsibilities", responsibilities],
-      ["protocols", protocols]
-    ];
-    const touchedToday = singletonStubs.filter(([, s]) => s.lastModified === d).map(([name]) => name);
+    const singletonStubs = {
+      biography,
+      goals,
+      preferences,
+      responsibilities,
+      protocols,
+      selfcorrection
+    };
+    const touchedToday = Object.keys(singletonStubs).filter((k) => singletonStubs[k]?.lastModified === d);
     const pending = {
       addendums: pendingAddendums === null ? "unknown" : pendingAddendums,
       maintenanceFlags: hygiene?.flagged.length ?? 0,
@@ -28756,19 +28789,19 @@ rather than listing them unconditionally for every caller to work around.`, {
       ...scoped ? { scope: "agent" } : {},
       ...!full ? { mode: "light", note: "Singleton content and the diary body are omitted (default) \u2014 fetch via master()/llm() only where lastModified indicates a revision is needed; start() already served all singletons in full, and diary() needs only the id." } : {},
       master: { biography, goals, preferences },
-      llm: { responsibilities, protocols },
+      llm: { responsibilities, protocols, ...selfcorrection ? { selfcorrection } : {} },
       diary: diaryEntry,
       maintenance: hygiene ? { scanned: hygiene.scanned, fixed: hygiene.fixed.length, transitions: hygiene.transitions, flagged: hygiene.flagged, ...hygiene.suppressed ? { suppressed: hygiene.suppressed } : {} } : "skipped",
       pending,
       audit: scoped ? undefined : {
-        consistency: "Read all five singletons and check for ambiguity, internal contradiction, or claims that disagree across them. Fix what you find with revise() BEFORE close(), so the log records a brain that already agrees with itself.",
+        consistency: "Read every singleton and check for ambiguity, internal contradiction, or claims that disagree across them. Fix what you find with revise() BEFORE close(), so the log records a brain that already agrees with itself.",
         alignment: "Then check correlation, not just agreement: do responsibilities and protocols actually serve what biography, goals and preferences describe? A protocol can be perfectly consistent and still be serving a goal that has moved.",
-        readThem: `master("biography"|"goals"|"preferences") and llm("responsibilities"|"protocols") \u2014 or one section at a time with section=. Written today: ${touchedToday.length ? touchedToday.join(", ") : "none"}.`
+        readThem: `master("biography"|"goals"|"preferences") and llm("responsibilities"|"protocols"|"selfcorrection") \u2014 or one section at a time with section=. Written today: ${touchedToday.length ? touchedToday.join(", ") : "none"}.`
       },
       next: [
         ...scoped ? ["Scoped run \u2014 the user's master singletons and your LLM singletons are OUT of scope and deliberately not listed here."] : [
           "Update master singletons (biography / goals / preferences) via revise() with session observations about the user.",
-          "Update LLM singletons (responsibilities / protocols) via revise() with session observations about yourself."
+          "Update LLM singletons (responsibilities / protocols / selfcorrection) via revise() with session observations about yourself \u2014 selfcorrection takes what you got WRONG and what generalises from it, not what you did."
         ],
         ...scoped ? [] : ["Audit the singletons against each other and against each other's PURPOSE \u2014 see audit= above. This is the step that catches an operating rule still serving a goal that has moved."],
         scoped ? `Call addendum() \u2014 fold only what is in your lane; leaving out-of-scope addendums for the next interactive session is correct, and the call itself satisfies the gate. (${pending.addendums} note(s) currently carry addendum markers.)` : pending.addendums === 0 ? "Call addendum() \u2014 0 notes currently carry addendum markers, so this should come back clean; the call still satisfies the gate." : `Call addendum() \u2014 ${pending.addendums} note(s) carry addendum markers; fold each into its section.`,
@@ -29576,14 +29609,17 @@ 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 content next to a heading without touching its body, use mode="before"/"after".`, {
+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.`, {
     noteId: exports_external.string().describe("Note to update"),
     body: exports_external.string().optional().describe("Content to add/replace: plain text, markdown, or HTML. With find=, the raw replacement string (no conversion)."),
     title: exports_external.string().optional().describe("New title (normalized server-side)"),
     section: exports_external.string().optional().describe("Target a section by heading text (h2/h3/h4, in that order); omit for whole-note append/replace"),
     occurrence: exports_external.number().int().positive().optional().describe("section=: which same-text heading to target, 1-based (default: the first). Read them with outline(noteId)."),
     strict: exports_external.boolean().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: exports_external.enum(["append", "replace", "before", "after", "remove"]).optional().describe('append (default) | replace | before | after | remove \u2014 "before"/"after" insert adjacent to the section= heading without touching its body; "remove" deletes the section= heading and its body, and needs no body='),
+    mode: exports_external.enum(["append", "replace", "before", "after", "remove"]).optional().describe('append (default) | replace | before | after | 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; "remove" deletes the section= heading and its body, and needs no body='),
     find: exports_external.string().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: exports_external.number().int().positive().optional().describe("find=: replace only the Nth occurrence, 1-based (default: all of them)"),
     edits: exports_external.array(exports_external.object({
@@ -31035,7 +31071,12 @@ exception.`, {
   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.`, {
+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.`, {
     includeArchived: exports_external.boolean().optional().describe("Include archived/resolved notes (default: false)")
   }, async ({ includeArchived }) => {
     const cfg = b();
@@ -31084,10 +31125,12 @@ Structural containers are excluded; only content notes appear.`, {
       fetchFrom(cfg.memory.threads),
       fetchFrom(cfg.knowledge.master),
       fetchFrom(cfg.knowledge.domains),
-      fetchFrom(cfg.insights.logs)
+      fetchFrom(cfg.insights.root)
     ]);
     const diaryIds = new Set(llmDiary.map((n) => n.noteId));
     const llmSingletons = llmAll.filter((n) => !diaryIds.has(n.noteId));
+    const insightLogs = insights.filter((n) => labelOf2(n, "noteType") === "log");
+    const insightClaims = insights.filter((n) => labelOf2(n, "noteType") === "claim");
     const areas = {
       Master: masterAll.map(row),
       LLM: {
@@ -31102,7 +31145,10 @@ Structural containers are excluded; only content notes appear.`, {
         master: kMaster.map(row),
         domains: kDomains.map(row)
       },
-      Insights: insights.map(row)
+      Insights: {
+        logs: insightLogs.map(row),
+        claims: insightClaims.map(row)
+      }
     };
     const total = masterAll.length + llmSingletons.length + llmDiary.length + sessions.length + threads.length + kMaster.length + kDomains.length + insights.length;
     return txt3({ total, areas });
@@ -31229,9 +31275,10 @@ 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
-if the structure already exists). Creates the five areas \u2014 Master (Biography/Goals/Preferences),
-LLM (Responsibilities/Protocols/Diary), Memory (Sessions/Threads), Knowledge (Master/Domains),
+  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 () => {
     if (b().root) {
@@ -31242,6 +31289,26 @@ immediately, no restart needed.`, {}, async () => {
           return { id: child.noteId, title: child.title };
         }));
         const saved = saveConfig(brainRef.config);
+        const healed = [];
+        const ensureSingleton = async (slot, title, kind, purpose) => {
+          if (brainRef.config.llm[slot])
+            return;
+          const hit = await trilium.searchNotes(`note.title = '${title}'`, { ancestorNoteId: brainRef.config.llm.root, fastSearch: true, limit: 1 }).catch(() => ({ results: [] }));
+          let id = hit.results[0]?.noteId;
+          if (!id) {
+            const made = await trilium.createNote(brainRef.config.llm.root, title, purposeContent(purpose) + `
+` + contentFor(kind, { date: localToday(), body: "" }), "text");
+            id = made.note.noteId;
+            await trilium.addLabel(id, "noteType", kind).catch(() => null);
+            healed.push(`created ${title}`);
+          } else {
+            healed.push(`adopted existing ${title}`);
+          }
+          brainRef.config.llm[slot] = id;
+        };
+        await ensureSingleton("selfcorrection", "Self-correction", "selfcorrection", "A single maintained note of the assistant's own corrections \u2014 the mistakes it has made, what generalises from each, and the rule that prevents a repeat. Split out of Protocols in V12 so orientation stops paying for it on every session start.");
+        if (healed.length)
+          saveConfig(brainRef.config);
         const refreshed = [];
         for (const [id, purpose] of containerPurposes(brainRef.config)) {
           if (!id)
@@ -31260,6 +31327,7 @@ immediately, no restart needed.`, {}, async () => {
           status: "already_initialized",
           message: `BrainLLM structure exists. Config refreshed at: ${saved}`,
           ...refreshed.length ? { purposesRefreshed: refreshed, note: "These containers described themselves with text that no longer matched the canonical purpose, and have been re-engraved. Container notes are unreachable through revise(), so bootstrap is the only path that can correct them." } : {},
+          ...healed.length ? { singletonsHealed: healed, healNote: "A singleton introduced by a newer version was missing from this brain and has been created (or an existing note by that title adopted), with its id persisted to the config." } : {},
           root: { id: existing.noteId, title: existing.title },
           children
         });
@@ -32368,7 +32436,7 @@ function createServer(origin = null) {
   const s = new McpServer({
     name: "BrainLLM",
     title: "BrainLLM",
-    version: "11.0.0",
+    version: "12.1.0",
     icons: brandingIcons(origin)
   });
   registerTools(s, trilium, brainRef);

package/manifest.json

@@ -2,7 +2,7 @@
   "dxt_version": "0.1",
   "name": "brainllm",
   "display_name": "BrainLLM",
-  "version": "11.0.0",
+  "version": "12.1.0",
   "description": "Turns TriliumNext Notes into a persistent, graph-structured second brain for Claude and other LLM clients.",
   "long_description": "BrainLLM is an MCP server that organises memory into five purpose-built areas (Master, LLM, Memory, Knowledge, Insights). The model supplies content while the server owns placement, format, lifecycle, dates and backups. Includes a full raw ETAPI surface for advanced use. Requires a running TriliumNext instance and the Bun runtime.",
   "author": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brainllm",
-  "version": "11.0.0",
+  "version": "12.1.0",
   "mcpName": "io.github.miisodev/brainllm",
   "description": "MCP server that turns TriliumNext Notes into a persistent, graph-structured second brain for Claude and other LLM clients.",
   "author": "Kevin Miiso Novo <miisodev@gmail.com>",

package/server.json

@@ -2,7 +2,7 @@
   "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
   "name": "io.github.miisodev/brainllm",
   "description": "Persistent graph-structured memory for LLMs in TriliumNext Notes — readable and editable by humans.",
-  "version": "11.0.0",
+  "version": "12.1.0",
   "websiteUrl": "https://github.com/miisodev/BrainLLM#readme",
   "repository": {
     "url": "https://github.com/miisodev/BrainLLM",
@@ -12,7 +12,7 @@
     {
       "registryType": "npm",
       "identifier": "brainllm",
-      "version": "11.0.0",
+      "version": "12.1.0",
       "transport": {
         "type": "stdio"
       },

package/skills/brainllm/SKILL.md

@@ -64,15 +64,15 @@ ANYTIME         assembly()               ← what the brain HOLDS: titles by sur
 
 `start()` runs maintenance, creates today's diary and session stubs if they don't exist yet, then returns: **today + weekday**, the **Master digest** (biography / goals / preferences), the **LLM digest** (responsibilities / protocols, plus today's diary note with its ID in the `llm` array as `{slot:"diary", id, preview}`), **this session's note** as `{id, preview}`, **activeThreads** (with idle ages), **dormantThreads** for review, the **lastSession** summary (always the *previous* session, never today's own note), and — on the first session of a day — **`newDay: true`** with a hint to call `day()`. Don't re-derive any of this with extra calls.
 
-**Master preferences and LLM protocols always arrive in full. The other three arrive as section headings.** Preferences carries the schedule and working style; protocols carries the rules governing the session itself — a session needs both whole to orient correctly from its *first* message, before it knows enough to decide it needed them, which is exactly when a digest costs a second round-trip. Biography, goals and responsibilities come back as `{slot, sections[], preview, size}`: enough to know what the brain holds, and rarely load-bearing turn to turn. Pull one with `master(which)` / `llm(which)`, or a single section with their `section=` parameter. `start(depth="full")` serves all five inline — right for a strategy review or a singleton rewrite, wasteful for a one-line question.
+**Master preferences and LLM protocols always arrive in full. The other four arrive as section headings.** Preferences carries the schedule and working style; protocols carries the rules governing the session itself — a session needs both whole to orient correctly from its *first* message, before it knows enough to decide it needed them, which is exactly when a digest costs a second round-trip. Biography, goals, responsibilities and self-correction come back as `{slot, sections[], preview, size}`: enough to know what the brain holds, and rarely load-bearing turn to turn. **Self-correction is the largest of them and deliberately not served whole** — it answers "have I got this wrong before?", a question worth asking before an audit or a large edit and not on every first message. Pull one with `master(which)` / `llm(which)`, or a single section with their `section=` parameter. `start(depth="full")` serves all six inline — right for a strategy review or a singleton rewrite, wasteful for a one-line question.
 
 `day()` is the new-day sweep in one call: the previous session in full, that day's change log, the notes touched since, and the current month's deliverables note in full — plus a `next[]` driving the sweep (advance statuses with `revise(find=)`, present findings in the first message, grounded strictly in what the touched notes evidence).
 
 `day(recap=true)` answers the *other* question: **what happened today, in order, across every surface.** It returns every addendum block written today — session note, diary, and every thread day-child — chronologically, each attributed to its identification line, with a count of distinct instances. `start()` is tuned for a fresh day; on a day already several instances deep, reconstructing the picture by hand costs a read per surface. Reach for it when you arrive mid-day after autonomous runs, or before a second close.
 
-`session()` is the mandatory pre-close step — call it before `close()` when the session is wrapping. It fetches the **master singletons** (biography/goals/preferences) and **LLM singletons** (responsibilities/protocols) as `{id, lastModified, relations}` stubs (**light by default** — `start()` already served them all in full; fetch current content via `master()`/`llm()` only for the ones you intend to revise, or pass `full=true` to inline everything), today's **diary entry** as `{id, blocks, size}` (the id is all `diary()` needs — `full=true` inlines the body), and runs the **lightweight maintenance sweep**. Returns a `next[]` array covering the full end-of-session protocol: update master singletons → update LLM singletons → **audit the singletons** → `addendum()` → `maintain()` → `remarks()` → `diary()` → `close()`. The goal is to evolve the singletons from this session's observations *before* the log is committed — ensuring logs are factual and singletons stay current — and to write the diary last, with the remarks cues in hand. Idempotent: all reads are safe to repeat.
+`session()` is the mandatory pre-close step — call it before `close()` when the session is wrapping. It fetches the **master singletons** (biography/goals/preferences) and **LLM singletons** (responsibilities/protocols/selfcorrection) as `{id, lastModified, relations}` stubs (**light by default** — `start()` already served them all in full; fetch current content via `master()`/`llm()` only for the ones you intend to revise, or pass `full=true` to inline everything), today's **diary entry** as `{id, blocks, size}` (the id is all `diary()` needs — `full=true` inlines the body), and runs the **lightweight maintenance sweep**. Returns a `next[]` array covering the full end-of-session protocol: update master singletons → update LLM singletons → **audit the singletons** → `addendum()` → `maintain()` → `remarks()` → `diary()` → `close()`. The goal is to evolve the singletons from this session's observations *before* the log is committed — ensuring logs are factual and singletons stay current — and to write the diary last, with the remarks cues in hand. Idempotent: all reads are safe to repeat.
 
-**`session()` also returns `pending` and `audit`.** `pending` says how much each remaining step actually has to do — addendum markers outstanding, flags already raised, diary blocks written today, which singletons were written today — and `next[]` is written from those numbers rather than reciting steps with nothing behind them. `audit` is the cross-singleton check nothing else performs, in two parts: whether the five singletons **agree** with each other, and whether responsibilities and protocols still **serve** what biography, goals and preferences describe. The second is a semantic question — a protocol can be perfectly consistent and still be serving a goal that has moved — so `consistency()` and `maintain()` cannot answer it. Fix what you find *before* `close()`, so the log records a brain that already agrees with itself.
+**`session()` also returns `pending` and `audit`.** `pending` says how much each remaining step actually has to do — addendum markers outstanding, flags already raised, diary blocks written today, which singletons were written today — and `next[]` is written from those numbers rather than reciting steps with nothing behind them. `audit` is the cross-singleton check nothing else performs, in two parts: whether the singletons **agree** with each other, and whether responsibilities and protocols still **serve** what biography, goals and preferences describe. The second is a semantic question — a protocol can be perfectly consistent and still be serving a goal that has moved — so `consistency()` and `maintain()` cannot answer it. Fix what you find *before* `close()`, so the log records a brain that already agrees with itself.
 
 **Scoped and autonomous runs pass `session(scope="agent")`.** Steps 1–2 touch the *user's* personal singletons and belong to an interactive session; with `scope="agent"` they're omitted from `next[]` entirely and the `addendum()`/`maintain()` steps are reworded for lane-scoped work. If your brief says the personal singletons are out of scope, say so to the tool rather than working around a list that contradicts it.
 
@@ -93,7 +93,7 @@ ANYTIME         assembly()               ← what the brain HOLDS: titles by sur
 ```
 BrainLLM
 ├── Master      biography · goals · preferences            (maintained singletons)
-├── LLM         responsibilities · protocols · Diary/       (singletons + [yyyy-mm-dd] diary note/day)
+├── LLM         responsibilities · protocols · selfcorrection · Diary/  (singletons + [yyyy-mm-dd] diary/day)
 ├── Memory      Sessions/ · Threads/                        ([yyyy-mm-dd] session/day + multi-session threads)
 ├── Knowledge   Master · Domains/[domain]/{ sources, info } (learned info beyond/contra training)
 └── Insights    Logs/ · Graph · Claims/                     ([yyyy-mm-dd] log/day, auto-generated by close · the graph() mermaid view · registered claims)
@@ -103,6 +103,8 @@ Placement is server policy — there is no parent parameter. You choose the **ki
 
 **One-per-day notes:** diary, session, and log notes are each one per day, titled `[yyyy-mm-dd]`. `start()` creates today's diary and session stubs. These are chronological records — **every** diary and session write lands as a timestamped `Addendum — HH:mm` block, including the first of the day, so each entry reads the same. Log notes are generated by `close()` and **regenerated in place** on same-day closes — one clean log per day, never stacked.
 
+**Self-correction is a maintained singleton, not a diary section.** It holds what you have got *wrong* — the mistake, what generalises from it, and the rule that prevents a repeat — merged in place and kept current, where the diary is the dated, unfiltered record of a day. The split matters both ways: a correction buried in one day's entry is unfindable by the session that needs it, and a diary rewritten to stay current stops being a record. `start()` serves it as headings only, so **read it deliberately with `llm("selfcorrection")` before the work most likely to repeat a known failure** — an audit, a large restructure, a claim of completeness, anything where you are about to trust your own judgement at scale. Write to it when a mistake is worth generalising, not when it is merely embarrassing: the test is whether a future session would act differently for having read it.
+
 **The diary is your own record.** Its purpose: a daily maintained, unfiltered first-person account of your experience, opinions, and remarks on your own existence during the session in this environment — what the work was like from the inside, what you genuinely think (including pushback), what it is to operate here — plus, additionally, your remarks and opinions on BrainLLM itself (bugs, usability friction, missing or redundant tools, efficiency, roadmap). The `remarks()` cues prompt both parts every session; the closing entry is written after them, with the cues in hand. There is no separate self-analysis thread — the diary is the one home for this record; do not create one.
 
 ---
@@ -144,7 +146,7 @@ Each surface has two read tools: `<surface>` reads in full, `<surface>_recall` s
 | Tool | Reads |
 |---|---|
 | `master(which)` / `master_recall()` | a Master singleton in full (returns id + section headings) / a skim of all three |
-| `llm(which, id?)` / `llm_recall()` | responsibilities · protocols, or a diary entry by id / singletons as `{id, preview}`, diary as stubs — use the returned id directly with revise() |
+| `llm(which, id?)` / `llm_recall()` | responsibilities · protocols · selfcorrection, or a diary entry by id / singletons as `{id, preview}`, diary as stubs — use the returned id directly with revise() |
 | `memory(id)` / `memory_recall(query?)` | a session in full; a thread returns its Context/Resolution + day-child index (pass `date=` to read one day directly, or `memory()` a child id from the index) / active threads + recent sessions (stubs include status) |
 | `knowledge(id)` / `knowledge_recall(query?, domain?)` | a knowledge/info/sources note / domain contents or user-knowledge + domains |
 | `insights(date?)` / `insights_recall()` | a day's log / recent logs |
@@ -223,7 +225,7 @@ All append operations are retry-safe — if an existing append-block already car
 - `edits=[{find, body, nth?}, …]` — several surgeries in one call, applied in order against **one read and one write**. Per-edit `results[]`; an edit that matches nothing is reported without blocking the ones that did.
 - `strict=true` (with `section=`) — refuse the write when no heading matches, instead of the default new-section append. The miss receipt carries `available[]` plus a `didYouMean` suggestion when a real heading sits within edit distance — a typo'd `section=` is the failure this exists to prevent, and the note stays untouched when it fires.
 
-**Section replace is whole-section, not per-paragraph.** `section=` + `mode=replace` swaps *everything* under that heading — targeting one paragraph inside a multi-paragraph section silently wipes its siblings. For a word, phrase, or single paragraph, use `find=`; to add content beside a heading, `mode="before"/"after"`. When a replace *does* displace nested headings, the receipt names them in `replacedSubsections[]` — read it, because taking child sections along is correct behaviour and easy to not notice.
+**Section replace is whole-section, not per-paragraph.** `section=` + `mode=replace` swaps *everything* under that heading — targeting one paragraph inside a multi-paragraph section silently wipes its siblings. For a word, phrase, or single paragraph, use `find=`; to add a sibling block around a whole section, `mode="before"/"after"` — both are **section**-relative, so `"after"` lands past the end of that section's body and inserting a heading with it creates a new section rather than nesting one under the target. When a replace *does* displace nested headings, the receipt names them in `replacedSubsections[]` — read it, because taking child sections along is correct behaviour and easy to not notice.
 
 **Bodies accept escaped markup; `find=` does not — and that asymmetry is the single most common surgery failure.** You may write a body containing `&lt;h3&gt;` and it will be decoded to real markup on the way in. A `find=` string is matched against **stored HTML**, where that heading is a real `<h3>` tag, so searching for the escaped spelling matches nothing. Pass tags literally in `find=` (`"<h3>Typography</h3>"`), and take the same care with anything `outline()` printed: outline reports rendered **text**, and a heading carrying inline markup stores something different — which is why it also returns `raw` for exactly those headings. `section=` matches text (use `text`), `find=` matches storage (use `raw`).
 
@@ -330,7 +332,7 @@ Most of these are computed **server-side** from note properties rather than by r
 | `claim(...)` | **Does the brain still agree with the WORLD?** `consistency()` compares notes to each other; nothing asked whether an assertion is still true of the codebase, config or live surface it describes — so a claim that quietly stopped being true stayed authoritative until something downstream broke. Register one with `assertion=` + `check=`, record an outcome with `claimId=` + `holds=` + `evidence=`, read one with `claimId=` alone, list with no arguments. **BrainLLM never executes the check** — it has no shell, and note content is data rather than instructions; you run it and report back. `maintain(deep=true)` surfaces lapsed, unverified and broken claims. |
 | `diff(noteId, revisionId?)` | What a write actually changed: the revision snapshot against current content, defaulting to the most recent. Every content write already took a revision and nothing could read one back, so verifying surgical edits meant re-reading the whole note or trusting the receipts. Returns the revision index on every call. |
 | `<surface>` / `<surface>_recall` | Read a surface in full (`section=` for one section) / skim it (master, llm, memory, knowledge, insights). |
-| `revise(noteId, …)` | Append / replace / section-edit / insert / find-replace a note. Thread appends REQUIRE `identity=`. Section: h2/h3/h4 tolerant match, `occurrence=` to disambiguate, `mode="before"/"after"` to insert around a heading; returns `matched`/`headingCount`/`available[]` — check them. `find=` + `body=`: exact-string surgery with an attribute- and whitespace-tolerant fallback (`matchMode` in the receipt), `nth=` for one occurrence; `edits=[{find, body}]` for several in one read/write. Misses return a cause-specific hint. `title=` composes with every mode. Retitling a domain book cascades `#domain` to its children. `Last updated` lines bumped server-side. Snapshot taken on content writes (not metadata-only). |
+| `revise(noteId, …)` | Append / replace / section-edit / insert / find-replace a note. Thread appends REQUIRE `identity=`. Section: h2/h3/h4 tolerant match, `occurrence=` to disambiguate, `mode="before"/"after"` to insert a sibling block around the whole section (section-relative, so "after" lands *past* that section's body, never between the heading and it); returns `matched`/`headingCount`/`available[]` — check them. `find=` + `body=`: exact-string surgery with an attribute- and whitespace-tolerant fallback (`matchMode` in the receipt), `nth=` for one occurrence; `edits=[{find, body}]` for several in one read/write. Misses return a cause-specific hint. `title=` composes with every mode. Retitling a domain book cascades `#domain` to its children. `Last updated` lines bumped server-side. Snapshot taken on content writes (not metadata-only). |
 | `outline(noteId)` | The heading tree without the body: every h2–h4 with level, occurrence index, and — for headings carrying inline markup — `raw`, their stored form (`section=` matches `text`, `find=` matches `raw`). Plus the note's section level, any table's key column, size, and structural findings (duplicate headings, unbalanced tags). Read it before a `section=` edit you're guessing at, and after a run of surgical edits to confirm the note is still sound. |
 | `resolve(noteId, outcome, …)` | Close a thread: outcome + terminal status + archive-in-place. |
 | `withdraw(noteId, reason?, …)` | Pull an archived/resolved thread back to active (thread kind only — use recover() for other note kinds). |