brainllm 13.1.1 → 13.2.0

package/README.md

@@ -10,7 +10,7 @@ Self-hosted memory for LLMs in [TriliumNext Notes](https://github.com/TriliumNex
 
 [**Site**](https://miisodev.github.io/BrainLLM/) · [Connect to Claude](https://miisodev.github.io/BrainLLM/connect.html) · [How it works](https://miisodev.github.io/BrainLLM/how-it-works.html) · [Docs](https://miisodev.github.io/BrainLLM/docs.html) · [Privacy](https://miisodev.github.io/BrainLLM/privacy.html)
 
-[![Version](https://img.shields.io/badge/version-13.1.1-f59e0b?style=flat-square)](https://github.com/miisodev/BrainLLM/releases)
+[![Version](https://img.shields.io/badge/version-13.2.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,6 +60,7 @@ Placement, naming, labels, deduplication, relation bookkeeping, lifecycle aging,
 - **A distinct connector identity** — hosted instances advertise BrainLLM and their own origin, with same-origin PNG/SVG icons, explicit page favicon links and a real multi-size ICO. The canonical mark is shared across the connector, consent pages and public assets.
 - **Preview changes and measure coverage** — `revise(noteId, edits=[…], dryRun=true)` shows sequential match counts and sanitized before/after content with no revision, labels or gate writes. Revision failures stop content overwrites. `consistency()` reports read failures and scan coverage; case-insensitive comparisons retain spelling variants without false conflicts. Incomplete scans cannot establish absence or unanimity.
 - **Registers close in one call** — `revise(find, within="tr", mode="remove", closure={thread, body})` removes a register row and records its closure in that thread's entry for the day, `closure={note, table?, row?}` moves a row into an explicitly selected register table; destination cells must match the table's shape. Destination-first ordering preserves recoverability, and `moves=[{find, row?}]` batches closures with preflight and per-row progress, and `append={table, row}` adds a row with no anchor to find; `within=` also accepts a row as a reader sees it (`"Phase 2 | Claude | Open"`), and a table row whose cells disagree with its header is flagged at write time and by `maintain(deep)`.
+- **Bulk edits and lighter receipts** — `revise(find, within="tr", mode="remove", all=true)` removes every row an anchor sits in, in one write and previewable with `dryRun=true`; `remember(kind="sources", revision=[{source, from}])` renames a Sources key when a source moves instead of adding a second row; a dated-thread append returns `previousRun`, its author's previous block and run number; `read(ids, sizes=true)` plans a bulk read from sizes and section sizes alone; and `diff(since="today", summaryOnly=true)` lists what changed without the lines.
 - **Records you can prove** — sessions, diary entries and dated thread entries are append-only, and now verifiably so: every `close()` seals its day's records into a digest chained to the previous day's, and `maintain(deep)` reports any sealed record that was rewritten afterwards. Appends stay legal; edits to history do not go unnoticed.
 
 ---

package/SECURITY.md

@@ -6,8 +6,8 @@ Security fixes ship on the latest release line. Older versions may remain useful
 
 | Version | Supported |
 |---|---|
-| 13.1.x | ✅ |
-| 12.9.x and earlier | ❌ |
+| 13.2.x | ✅ |
+| 13.1.x and earlier | ❌ |
 
 ## Reporting a vulnerability
 

package/dist/index.js

@@ -20815,6 +20815,15 @@ class McpServer {
     this._promptHandlersInitialized = false;
     this.server = new Server(serverInfo, options);
     this._maxToolInputElements = resolveMaxToolInputElements(options?.maxToolInputElements);
+    if (options?.capabilities?.tools) {
+      this.setToolRequestHandlers();
+    }
+    if (options?.capabilities?.resources) {
+      this.setResourceRequestHandlers();
+    }
+    if (options?.capabilities?.prompts) {
+      this.setPromptRequestHandlers();
+    }
   }
   get experimental() {
     if (!this._experimental) {
@@ -24522,6 +24531,24 @@ function leadingIdentityText(html) {
   const m = /^(?:\s|<p>(?:\s|&nbsp;)*<\/p>)*<h3(?:\s[^>]*)?>([\s\S]*?)<\/h3>/i.exec(html);
   return m ? decodeEntities(m[1].replace(/<[^>]+>/g, "")).trim() : null;
 }
+function identityAuthor(text) {
+  const parts = text.split("\xB7").map((p) => p.replace(/\s+/g, " ").trim().toLowerCase()).filter(Boolean);
+  if (parts.length && /^run\s+\d+\b/.test(parts[parts.length - 1]))
+    parts.pop();
+  return parts.join(" \xB7 ");
+}
+function identityRun(text) {
+  const m = /\u00B7\s*run\s+(\d+)\b[^\u00B7]*$/i.exec(text);
+  return m ? Number(m[1]) : null;
+}
+function identityHeadings(html) {
+  const out = [];
+  const rx = /<h2>Addendum \u2014 \d{2}:\d{2}<\/h2>\s*<h3(?:\s[^>]*)?>([\s\S]*?)<\/h3>/gi;
+  let m;
+  while ((m = rx.exec(html)) !== null)
+    out.push(decodeEntities(m[1].replace(/<[^>]+>/g, "")).trim());
+  return out;
+}
 function identityProblem(text) {
   const line = text.trim();
   if (/[\r\n]/.test(line))
@@ -24912,7 +24939,7 @@ function hasPlaceholderRow(html, heading) {
   const rows = tableRows(html, heading);
   return rows.length > 0 && rows.every((cells) => PLACEHOLDER_CELL.test(cells[0] ?? ""));
 }
-function upsertTableRow(html, heading, key, cells) {
+function upsertTableRow(html, heading, key, cells, renameFrom) {
   const noop = { html, matched: false, created: false };
   const escapedHeading = heading.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
   let headingEnd = -1;
@@ -24943,7 +24970,7 @@ function upsertTableRow(html, heading, key, cells) {
     const m = /<td[^>]*>([\s\S]*?)<\/td>/i.exec(row);
     return m ? decodeEntities(m[1].replace(/<[^>]+>/g, "")).replace(/\s+/g, " ").trim().toLowerCase() : "";
   };
-  const keyNorm = decodeEntities(key).replace(/\s+/g, " ").trim().toLowerCase();
+  const keyNorm = decodeEntities(renameFrom ?? key).replace(/\s+/g, " ").trim().toLowerCase();
   const rowRe = /<tr[^>]*>[\s\S]*?<\/tr>/gi;
   let matchedRow = null;
   let placeholderRow = null;
@@ -24958,6 +24985,8 @@ function upsertTableRow(html, heading, key, cells) {
     if (!placeholderRow && (text === "" || text === "\u2014 none yet \u2014"))
       placeholderRow = span;
   }
+  if (renameFrom !== undefined && !matchedRow)
+    return noop;
   const newRow = `<tr>${[key, ...cells].map((c) => `<td>${escapeHtml(c)}</td>`).join("")}</tr>`;
   const target = matchedRow ?? placeholderRow;
   const newTbody = target ? tbody.slice(0, target.start) + newRow + tbody.slice(target.end) : tbody + newRow;
@@ -26565,7 +26594,7 @@ function containingElement(html, tag, from, to) {
   }
   return best;
 }
-function editWithin(html, hits, tag, action, body, nth) {
+function editWithin(html, hits, tag, action, body, nth, all = false) {
   if (!hits.length)
     return { ok: false, reason: "no_match", matches: 0 };
   const seen = new Map;
@@ -26578,6 +26607,14 @@ function editWithin(html, hits, tag, action, body, nth) {
   if (!elements.length)
     return { ok: false, reason: "no_element", matches: hits.length };
   const preview = (s) => html.slice(s.start, Math.min(s.end, s.start + 160));
+  if (all) {
+    const outer = elements.filter((e) => !elements.some((o) => o !== e && o.start <= e.start && o.end >= e.end));
+    let out = html;
+    for (const t of [...outer].reverse()) {
+      out = action === "replace" ? out.slice(0, t.start) + body + out.slice(t.end) : action === "remove" ? out.slice(0, t.start) + out.slice(t.end) : action === "before" ? out.slice(0, t.start) + body + out.slice(t.start) : out.slice(0, t.end) + body + out.slice(t.end);
+    }
+    return { ok: true, html: out, element: html.slice(outer[0].start, outer[0].end), matches: outer.length, elements: outer.map((e) => html.slice(e.start, e.end)) };
+  }
   let target;
   if (nth !== undefined)
     target = elements[nth - 1];
@@ -26589,6 +26626,19 @@ function editWithin(html, hits, tag, action, body, nth) {
   const out = action === "replace" ? html.slice(0, target.start) + body + html.slice(target.end) : action === "remove" ? html.slice(0, target.start) + html.slice(target.end) : action === "before" ? html.slice(0, target.start) + body + html.slice(target.start) : html.slice(0, target.end) + body + html.slice(target.end);
   return { ok: true, html: out, element: el, matches: elements.length };
 }
+function pipeParagraphHint(html, hits, tag) {
+  if (tag !== "tr" && tag !== "td" && tag !== "th")
+    return null;
+  for (const h of hits) {
+    const p = containingElement(html, "p", h.start, h.start + h.length);
+    if (!p)
+      continue;
+    const text = html.slice(p.start, p.end).replace(/<[^>]+>/g, "");
+    if ((text.match(/\|/g) ?? []).length >= 2)
+      return `The anchor sits in a paragraph written with "|" separators, which is text, not a table row. Use within="p" to act on that line (mode="after" adds a sibling line), or convert the roster to a real table.`;
+  }
+  return null;
+}
 
 // src/tools-surface.ts
 var txt = (obj) => ({
@@ -26976,6 +27026,8 @@ function applyFindEdit(source, needle, replacement, index) {
   return inline.length ? spans(inline, "inline-tolerant") : null;
 }
 var CHANGES_CAP = 25;
+var SOURCE_KEYS_ECHO = 30;
+var PREVIOUS_RUN_DAYS = 7;
 var boundPreview = (s, max = 1600) => s.length <= max ? s : `${s.slice(0, max)}\u2026 (${s.length - max} more characters)`;
 function capChanges(changes, cap = CHANGES_CAP) {
   if (changes.length <= cap)
@@ -27234,6 +27286,7 @@ function registerTools(server, trilium, brainRef) {
   }
   async function appendThreadEntry(threadId, block, d) {
     const found = await trilium.searchNotes(`#noteType=threadEntry #created='${d}'`, { ancestorNoteId: threadId, fastSearch: true, limit: 1 });
+    const incomingIdentity = leadingIdentityText(block);
     const time = localNowTime();
     const marker = `Addendum \u2014 ${time}`;
     if (found.results[0]) {
@@ -27247,7 +27300,8 @@ function registerTools(server, trilium, brainRef) {
       await trilium.createRevision(noteId);
       await trilium.updateNoteContent(noteId, safeAppend(current, `<h2>${marker}</h2>`, block));
       await trilium.updateLabelValue(noteId, "updated", d);
-      return { noteId, action: "appended", marker };
+      const previousRun = incomingIdentity ? await previousSameAuthor(threadId, incomingIdentity, current, d) : undefined;
+      return { noteId, action: "appended", marker, ...previousRun ? { previousRun } : {} };
     }
     const created = await trilium.createNote(threadId, `[${d}]`, contentFor("threadEntry", { date: d, body: `<h2>${marker}</h2>
 ${block}` }));
@@ -27255,7 +27309,33 @@ ${block}` }));
     await trilium.addLabel(noteId, "noteType", "threadEntry");
     await trilium.addLabel(noteId, "created", d);
     await ensureIcon(trilium, noteId);
-    return { noteId, action: "created", marker };
+    const previousRun = incomingIdentity ? await previousSameAuthor(threadId, incomingIdentity, "", d) : undefined;
+    return { noteId, action: "created", marker, ...previousRun ? { previousRun } : {} };
+  }
+  async function previousSameAuthor(threadId, identity, todayBefore, d) {
+    const author = identityAuthor(identity);
+    const pick = (html, date) => {
+      const heading = identityHeadings(html).reverse().find((h) => identityAuthor(h) === author);
+      if (!heading)
+        return;
+      const run = identityRun(heading);
+      return { heading, date, ...run !== null ? { run } : {} };
+    };
+    const today = pick(todayBefore, d);
+    if (today || identityRun(identity) === null)
+      return today;
+    try {
+      const entries = await trilium.searchNotes("#noteType=threadEntry", { ancestorNoteId: threadId, fastSearch: true, limit: 500 });
+      const earlier = entries.results.filter((n) => n.parentNoteIds.includes(threadId)).map((n) => ({ n, date: ownedLabel(n, "created") ?? "" })).filter((e) => e.date && e.date < d).sort((a, b) => b.date.localeCompare(a.date)).slice(0, PREVIOUS_RUN_DAYS);
+      for (const e of earlier) {
+        const found = pick(await trilium.getNoteContent(e.n.noteId), e.date);
+        if (found)
+          return found;
+      }
+    } catch {
+      return;
+    }
+    return;
   }
   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.`);
@@ -27826,7 +27906,7 @@ ${html}` }));
   });
   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; dryRun=true previews rows and near-duplicate keys without writing).
+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, revision[].from= renames one when a source moves; dryRun=true previews rows, body placement and near-duplicate keys without writing).
 
 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: _enum(Kinds).describe("What kind of memory this is"),
@@ -27840,8 +27920,9 @@ Collection kinds dedup by title \u2014 mustCreate=true refuses instead of adopti
     revision: array(object2({
       source: string2().describe("Must exactly match how the source is introduced in the Sources list \u2014 this is the upsert key"),
       marker: string2().describe('"\u2747\uFE0F" (discovered/credible) or "\u2705" (used)'),
-      date: string2().optional().describe("ISO date (default: today)")
-    })).optional().describe("kind=sources: upsert Revision rows by source name"),
+      date: string2().optional().describe("ISO date (default: today)"),
+      from: string2().optional().describe("Rename: the row's current key. The row keyed from= is rekeyed to source= (marker and date updated) instead of a new row being added; refused when source= already has a row")
+    })).optional().describe("kind=sources: upsert Revision rows by source name; from= renames a row when a source moves"),
     topics: array(string2()).optional().describe("Topic tags \u2014 slugged server-side"),
     supersedes: string2().optional().describe("noteId this replaces \u2014 old note is archived and wired supersedes"),
     mandate: boolean2().optional().describe("kind=information: flag the note as a standing brief a session must follow (#mandate)"),
@@ -27917,6 +27998,39 @@ Collection kinds dedup by title \u2014 mustCreate=true refuses instead of adopti
         didYouMeanNote: `${pairs.map((p) => `"${p.added}" \u2192 "${p.near.key}"`).join("; ")}. New Revision row(s) sit beside an existing source whose key is close \u2014 if one was meant to update that source, its key must match it exactly.`
       };
     };
+    const planRevision = (content) => {
+      let html = content;
+      const changes = [];
+      const added = [];
+      const refused = [];
+      const norm = (k) => k.replace(/\s+/g, " ").trim().toLowerCase();
+      for (const row of revision ?? []) {
+        const keys = tableRows(html, "Revision").map((cells) => cells[0] ?? "");
+        if (row.from !== undefined && norm(row.from) !== norm(row.source)) {
+          if (keys.some((k) => norm(k) === norm(row.source))) {
+            refused.push(`rename "${row.from}" \u2192 "${row.source}": "${row.source}" already has a row \u2014 update that one, or remove one of the two rows first`);
+            continue;
+          }
+          const result = upsertTableRow(html, "Revision", row.source, [row.marker, row.date ?? d], row.from);
+          if (!result.matched) {
+            refused.push(`rename "${row.from}" \u2192 "${row.source}": no Revision row is keyed "${row.from}"`);
+            continue;
+          }
+          html = result.html;
+          changes.push(`renamed: ${row.from} \u2192 ${row.source}`);
+          continue;
+        }
+        const result = upsertTableRow(html, "Revision", row.source, [row.marker, row.date ?? d]);
+        if (result.matched || result.created) {
+          html = result.html;
+          changes.push(`${result.matched ? "updated" : "added"}: ${row.source}`);
+          if (!result.matched)
+            added.push(row.source);
+        }
+      }
+      return { html, changes, added, refused };
+    };
+    const isLooseProse = (h) => !/<(?:ul|ol|li|h[34]|table)\b/i.test(h);
     if (isSingleton(kind)) {
       const id = kindHome(b(), kind);
       if (!id)
@@ -27945,25 +28059,18 @@ Collection kinds dedup by title \u2014 mustCreate=true refuses instead of adopti
         else {
           const content = await trilium.getNoteContent(sidPreview);
           const existingKeys = tableRows(content, "Revision").map((cells) => cells[0]).filter(Boolean);
-          const previewChanges = [];
-          const previewAdded = [];
-          let sim = content;
-          for (const row of revision ?? []) {
-            const result = upsertTableRow(sim, "Revision", row.source, [row.marker, row.date ?? d]);
-            if (result.matched || result.created) {
-              sim = result.html;
-              previewChanges.push(`${result.matched ? "would update" : "would add"}: ${row.source}`);
-              if (!result.matched)
-                previewAdded.push(row.source);
-            }
-          }
-          if (previewChanges.length)
-            preview.revision = previewChanges;
+          const plan = planRevision(content);
+          if (plan.changes.length)
+            preview.revision = plan.changes.map((c) => `would ${c.replace(/^(\w+):/, (_, v) => `${{ updated: "update", added: "add", renamed: "rename" }[v] ?? v}:`)}`);
+          if (plan.refused.length)
+            preview.refused = plan.refused;
           if (html && toText(html, 50) && !content.includes(html)) {
             const merged = mergeUnderSection(content, html, "Sources");
             preview.body = `would merge into the Sources section${merged.mergedInto.length ? `: ${merged.mergedInto.join(", ")}` : ""}${merged.appended.length ? `; new group(s): ${merged.appended.join(", ")}` : ""}`;
+            if (isLooseProse(html))
+              preview.placementHint = "This body has no list or group markup, so it would land as a loose block under Sources. Pass it as list items (or under an existing h3 group) to join the list structurally.";
           }
-          const hints = sourceKeyHints(previewAdded, existingKeys);
+          const hints = sourceKeyHints(plan.added, existingKeys);
           if (hints) {
             preview.didYouMean = hints.didYouMean;
             preview.didYouMeanNote = hints.didYouMeanNote;
@@ -27996,26 +28103,20 @@ Collection kinds dedup by title \u2014 mustCreate=true refuses instead of adopti
           wrote = true;
         }
       }
-      const revisionChanges = [];
-      const addedKeys = [];
+      let revisionChanges = [];
+      let addedKeys = [];
+      let refusedRows = [];
       let existingKeys = [];
       if (sid && revision?.length) {
-        let current = await trilium.getNoteContent(sid);
-        existingKeys = tableRows(current, "Revision").map((cells) => cells[0]).filter(Boolean);
-        let changed = false;
-        for (const row of revision) {
-          const result = upsertTableRow(current, "Revision", row.source, [row.marker, row.date ?? d]);
-          if (result.matched || result.created) {
-            current = result.html;
-            changed = true;
-            revisionChanges.push(`${result.matched ? "updated" : "added"}: ${row.source}`);
-            if (!result.matched)
-              addedKeys.push(row.source);
-          }
-        }
-        if (changed) {
+        const before = await trilium.getNoteContent(sid);
+        existingKeys = tableRows(before, "Revision").map((cells) => cells[0]).filter(Boolean);
+        const plan = planRevision(before);
+        revisionChanges = plan.changes;
+        addedKeys = plan.added;
+        refusedRows = plan.refused;
+        if (plan.changes.length) {
           await trilium.createRevision(sid);
-          const stamped = bumpLastUpdated(current, d);
+          const stamped = bumpLastUpdated(plan.html, d);
           await trilium.updateNoteContent(sid, stamped.html);
           await trilium.updateLabelValue(sid, "updated", d);
           wrote = true;
@@ -28029,7 +28130,7 @@ Collection kinds dedup by title \u2014 mustCreate=true refuses instead of adopti
       const revisionKeys = tableRows(finalHtml, "Revision").map((cells) => cells[0]).filter(Boolean);
       const placeholderLeft = hasPlaceholderRow(finalHtml, "Revision");
       const bodyWritten = !!html && !!toText(html, 50);
-      const looseProse = bodyWritten && !createdDomain && !/<(?:ul|ol|li|h[34]|table)\b/i.test(html);
+      const looseProse = bodyWritten && !createdDomain && isLooseProse(html);
       const keyHints = sourceKeyHints(addedKeys, existingKeys);
       return txt3({
         action: wrote ? "maintained" : "already_written",
@@ -28039,9 +28140,10 @@ Collection kinds dedup by title \u2014 mustCreate=true refuses instead of adopti
         location: locationLabel(kind, domainTitle),
         ...createdDomain ? { createdDomain: domainTitle } : {},
         ...revisionChanges.length ? { revision: revisionChanges } : {},
+        ...refusedRows.length ? { refused: refusedRows } : {},
         ...sourceMerge,
         ...revisionKeys.length ? { revisionRows: revisionKeys.length } : {},
-        ...revisionChanges.some((c) => c.startsWith("added:")) && revisionKeys.length ? { revisionKeys, revisionKeysNote: "A new Revision row was added. If it was meant to update an existing source, its key must match one of these exactly." } : {},
+        ...addedKeys.length && revisionKeys.length && revisionKeys.length <= SOURCE_KEYS_ECHO ? { revisionKeys, revisionKeysNote: "A new Revision row was added. If it was meant to update an existing source, its key must match one of these exactly." } : addedKeys.length && revisionKeys.length ? { revisionKeysNote: `A new Revision row was added beside ${revisionKeys.length - addedKeys.length} existing keys (too many to echo). ${keyHints ? "didYouMean names the nearest existing key." : "No existing key is close to it."} Preview a new key with dryRun=true, and rename a moved source with revision=[{source, from}].` } : {},
         ...keyHints ? { didYouMean: keyHints.didYouMean, didYouMeanNote: keyHints.didYouMeanNote } : {},
         ...placeholderLeft ? { structureHint: "The Revision table still holds only its placeholder row. Every source marked \u2705 was verified by someone \u2014 record that with revision=[{source, marker, date}] so the table says so too; marker dates live there, never inline." } : {},
         ...looseProse ? { placementHint: "The body was appended to the Sources section as a loose block, which is rarely what a maintained source list wants. Fold it into the existing entries with revise(noteId, find=\u2026) \u2014 or pass list markup so it joins the list structurally." } : {},
@@ -28163,7 +28265,7 @@ ${html}` : html;
         const connected = await wireRequested(existing.noteId);
         const iconSet = await applyIcon(existing.noteId, icon);
         const relations = relationSnippet(existing);
-        return txt3({ action: "updated", noteId: existing.noteId, entryId: entry.noteId, entryAction: entry.action, ...entry.marker ? { entryMarker: entry.marker } : {}, ...runHeading ? { runHeading } : {}, entry: `today's [${d}] entry in this thread; revise(entryId) edits it`, kind, title: existing.title, ...connected.length ? { connected } : {}, ...iconSet ? { icon: iconSet } : {}, ...relations ? { relations } : {}, ...sanitizeWarnings.length ? { sanitized: sanitizeWarnings } : {} });
+        return txt3({ action: "updated", noteId: existing.noteId, entryId: entry.noteId, entryAction: entry.action, ...entry.marker ? { entryMarker: entry.marker } : {}, ...runHeading ? { runHeading } : {}, ...entry.previousRun ? { previousRun: entry.previousRun } : {}, entry: `today's [${d}] entry in this thread; revise(entryId) edits it`, kind, title: existing.title, ...connected.length ? { connected } : {}, ...iconSet ? { icon: iconSet } : {}, ...relations ? { relations } : {}, ...sanitizeWarnings.length ? { sanitized: sanitizeWarnings } : {} });
       }
       const current = await trilium.getNoteContent(existing.noteId);
       if (isDuplicateAppend(current, block))
@@ -28560,12 +28662,15 @@ ${block}`), d);
     });
   });
   const READ_BUDGET = 80000;
-  server.tool("read", `Several note bodies in one round trip: ids=[\u2026] (up to 10) \u2192 {notes:[{id, title, kind, chars, content, relations}]}. Every entry carries chars, the size of that note's body in characters, so follow-up reads can be planned from this response alone. Bodies are returned in order until about 80k characters; the rest come back under deferred[] with their sizes, to read in a second call. section="<heading>" reads one section of each note instead of its whole body (h2\u2192h3\u2192h4 by heading text, occurrence= among repeats) \u2014 the cheap read of a huge note; a section holding a table also reports tableRows, its row count. text=true returns readable plain text with the markup removed (headings, list items and table rows kept), smaller and easier to read \u2014 right for orienting, not for building a find= anchor. For one note prefer the kinded read.`, {
+  server.tool("read", `Several note bodies in one round trip: ids=[\u2026] (up to 10) \u2192 {notes:[{id, title, kind, chars, content, relations}]}. Every entry carries chars, the size of that note's body in characters, so follow-up reads can be planned from this response alone. Bodies are returned in order until about 80k characters; the rest come back under deferred[] with their sizes, to read in a second call. section="<heading>" reads one section of each note instead of its whole body (h2\u2192h3\u2192h4 by heading text, occurrence= among repeats) \u2014 the cheap read of a huge note; a section holding a table also reports tableRows, its row count. text=true returns readable plain text with the markup removed (headings, list items and table rows kept), smaller and easier to read \u2014 right for orienting, not for building a find= anchor. sizes=true returns no bodies at all: each note's chars and its h2\u2013h4 headings with their section sizes, so a bulk read can be planned before it is made. For one note prefer the kinded read.`, {
     ids: array(string2()).min(1).max(10).describe("Note ids to read \u2014 one body per id, one round trip (cap 10)"),
     section: string2().optional().describe("Read only this heading's section of each note (h2/h3/h4, same matching as the singletons' section=) instead of each whole body \u2014 the cheap read of a huge note; a miss returns the note's real headings under available[]"),
     occurrence: number2().int().positive().optional().describe("section=: which same-text heading, 1-based (default: the first)"),
-    text: boolean2().optional().describe("Return readable plain text instead of stored HTML (default false; with section=, the section only)")
-  }, async ({ ids, text, section, occurrence }) => {
+    text: boolean2().optional().describe("Return readable plain text instead of stored HTML (default false; with section=, the section only)"),
+    sizes: boolean2().optional().describe("Return sizes only \u2014 chars and each h2\u2013h4 heading with its section's size \u2014 and no bodies: plan a read that would otherwise overflow")
+  }, async ({ ids, text, section, occurrence, sizes }) => {
+    if (sizes && (section !== undefined || text !== undefined))
+      return err("conflicting_params", "sizes=true returns no bodies, so section= and text= do not apply.", "Read the sizes first, then read(ids, section=\u2026) or read(ids, text=true) for the bodies you need.");
     const fetched = await Promise.all(ids.map(async (id) => {
       try {
         const note = await trilium.getNote(id);
@@ -28573,6 +28678,10 @@ ${block}`), d);
         const relations = relationSnippet(note);
         const raw = typeof contentResult === "string" ? contentResult : contentResult.content;
         const identity = { id, title: note.title, kind: ownedLabel(note, "noteType") ?? undefined, chars: raw.length };
+        if (sizes) {
+          const flat = typeof contentResult === "string" ? headingOutline(raw).filter((h) => !/^Last updated\b/i.test(h.text)).map((h) => ({ heading: h.text, level: h.level, chars: getSection(raw, h.text, h.occurrence).content.length })) : [];
+          return { ...identity, sizesOnly: true, ...flat.length ? { headings: flat.slice(0, 60) } : {}, ...flat.length > 60 ? { headingsShown: 60 } : {} };
+        }
         if (section && typeof contentResult !== "string") {
           return { ...identity, content: "", section, matched: false, hint: "Binary content cannot be sectioned as text; read it without section=." };
         }
@@ -28701,7 +28810,7 @@ ${block}`), d);
   };
   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 the matched span; it is not an insertion anchor. Use within= with mode=before/after for element insertion, or section= with mode=prepend/before/after for section insertion. It replaces every occurrence (nth= for one); edits=[{find, body}] applies several in one write. find= + within="tr" (or li, p, td, \u2026) acts on the element containing a short anchor: replace it, insert a row before/after it, or remove it, so a table row never needs its full stored markup. within= names the element acted on: within="tr" replaces the whole row (body is a full <tr>\u2026</tr>), within="td" one cell (body is a <td>\u2026</td>), and a plain find= inside a cell replaces only that text. dryRun=true with find=, edits=, within= or moves= previews the change first \u2014 the element's full visible text and byte size, and for remove/replace the before/after shape \u2014 with nothing written and no revision taken. Keep anchors short; quotes match in any form, and within= also matches an element by its visible text ("Phase 2 | Claude | Open" for a row). append={table, row} adds one row to the table under that heading with no anchor to locate first \u2014 pipes are cell boundaries, a lone placeholder row is replaced, and append= composes with nothing else. closure= with within="tr" and mode="remove" closes a register row in one call: {thread, body} removes the row and appends the closure (quoting it) to that thread's entry for today (needs identity=); {note, table?, row?} moves a row into another register. Destination cells must match exactly; row= supplies explicit plain-text cells. Ambiguous tables are refused. Destination content is written before source removal, and same-note moves use one write. Partial failures report recovery instructions; exact destination rows and identical thread blocks are deduplicated on retry. moves=[{find, nth?, row?}] batches closures to one target, preflights every row, and stops with per-row progress on failure. "Last updated" lines are server-owned: every content write bumps them, so never find= on one. A replacement equal to its match writes nothing and reports unchanged. title= composes with every mode; retitling a domain book cascades its #domain slug.
+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 the matched span; it is not an insertion anchor. Use within= with mode=before/after for element insertion, or section= with mode=prepend/before/after for section insertion. It replaces every occurrence (nth= for one); edits=[{find, body}] applies several in one write. find= + within="tr" (or li, p, td, \u2026) acts on the element containing a short anchor: replace it, insert a row before/after it, or remove it, so a table row never needs its full stored markup; all=true acts on every element the anchor sits in (preview with dryRun=true). within= names the element acted on: within="tr" replaces the whole row (body is a full <tr>\u2026</tr>), within="td" one cell (body is a <td>\u2026</td>), and a plain find= inside a cell replaces only that text. dryRun=true with find=, edits=, within= or moves= previews the change first \u2014 the element's full visible text and byte size, and for remove/replace the before/after shape \u2014 with nothing written and no revision taken. Keep anchors short; quotes match in any form, and within= also matches an element by its visible text ("Phase 2 | Claude | Open" for a row). append={table, row} adds one row to the table under that heading with no anchor to locate first \u2014 pipes are cell boundaries, a lone placeholder row is replaced, and append= composes with nothing else. closure= with within="tr" and mode="remove" closes a register row in one call: {thread, body} removes the row and appends the closure (quoting it) to that thread's entry for today (needs identity=); {note, table?, row?} moves a row into another register. Destination cells must match exactly; row= supplies explicit plain-text cells. Ambiguous tables are refused. Destination content is written before source removal, and same-note moves use one write. Partial failures report recovery instructions; exact destination rows and identical thread blocks are deduplicated on retry. moves=[{find, nth?, row?}] batches closures to one target, preflights every row, and stops with per-row progress on failure. "Last updated" lines are server-owned: every content write bumps them, so never find= on one. A replacement equal to its match writes nothing and reports unchanged. 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, and is taken literally: a Windows path's backslash is one backslash, never doubled. A find= or within= anchor that matches nothing always names the cause in hint=, and a miss shows the stored text nearby when part of the anchor is still there (matchedUpTo= / storedNearby=).`, {
     noteId: string2().optional().describe("Note to update (omit only with domain=)"),
@@ -28716,6 +28825,7 @@ Check the receipt: matched=false means a NEW section was written (available= lis
     find: string2().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: number2().int().positive().optional().describe("find=: replace only the Nth occurrence, 1-based (default: all of them). With within=: the Nth containing element"),
     within: _enum(WITHIN_TAGS).optional().describe('With find=: act on the <tag> element that contains the find text (a short unique anchor) \u2014 mode="replace" (default) swaps it for body=, "before"/"after" insert body= as a sibling (add a table row), "remove" deletes it. dryRun=true previews it first'),
+    all: boolean2().optional().describe("With within=: act on EVERY element containing the anchor instead of refusing an anchor found in several (e.g. remove every Revision row naming a retired source). Preview with dryRun=true first; does not combine with nth= or closure="),
     closure: object2({
       thread: string2().optional().describe('Thread variant: the dated thread to record the closure in: its id or title (e.g. "Escalations") \u2014 together with body='),
       body: string2().optional().describe("Thread variant: the closure prose: what settled it, who ruled, and where its durable substance went"),
@@ -28740,9 +28850,9 @@ Check the receipt: matched=false means a NEW section was written (available= lis
     identity: string2().optional().describe('Appending to a dated thread: the identification line "LLM \xB7 environment \xB7 agent/mode [\xB7 Run N]" (required)'),
     icon: string2().optional().describe('Display icon \u2014 a boxicons class ("bx bx-brain") or a bare name; normalized server-side'),
     date: string2().optional().describe("ISO date (default: today)")
-  }, async function reviseNote({ noteId: noteIdArg, domain, dryRun, body, title, section, occurrence, mode, find, nth, within, closure, append, edits, moves, identity, icon, date, strict }) {
+  }, async function reviseNote({ noteId: noteIdArg, domain, dryRun, body, title, section, occurrence, mode, find, nth, within, all, closure, append, edits, moves, identity, icon, date, strict }) {
     if (moves) {
-      if (!noteIdArg || domain || !closure || within !== "tr" || mode !== "remove" || find !== undefined || edits !== undefined || append || section || body !== undefined || title || icon || nth !== undefined)
+      if (!noteIdArg || domain || !closure || within !== "tr" || mode !== "remove" || find !== undefined || edits !== undefined || append || section || body !== undefined || title || icon || nth !== undefined || all !== undefined)
         return err("conflicting_params", "moves= needs noteId, within=tr, mode=remove and closure; it cannot combine with other edit operations.", "Supply one unique find anchor and optional destination row per move.");
       const results = [];
       const elements = new Set;
@@ -28765,7 +28875,8 @@ Check the receipt: matched=false means a NEW section was written (available= lis
         edits: undefined,
         moves: undefined,
         icon: undefined,
-        strict: undefined
+        strict: undefined,
+        all: undefined
       });
       for (const move of moves) {
         const r = JSON.parse((await one(move, true)).content[0].text);
@@ -28822,6 +28933,10 @@ Check the receipt: matched=false means a NEW section was written (available= lis
     const noteId = noteIdArg;
     if (isContainer(b(), noteId))
       return err("protected_note", `Note ${noteId} is a container \u2014 its content cannot be edited directly.`, "Use remember() to write to singletons, or specify a content note id.");
+    if (all !== undefined && !within)
+      return err("conflicting_params", "all= applies to within=; nothing was written.", 'e.g. revise(noteId, find="<anchor>", within="tr", mode="remove", all=true, dryRun=true). A plain find= already replaces every occurrence.');
+    if (all && (nth !== undefined || closure || moves))
+      return err("conflicting_params", "all=true acts on every matching element, so it does not combine with nth=, closure= or moves=; nothing was written.", "Drop all= to target one element, or drop nth=/closure= to act on all of them.");
     if (within && find === undefined)
       return err("missing_param", "within= needs find= as its anchor.", 'Pass a short text unique to the element, e.g. revise(noteId, find="Phase 2", within="tr", body="<tr>\u2026</tr>").');
     if (append) {
@@ -28941,9 +29056,9 @@ Check the receipt: matched=false means a NEW section was written (available= lis
         const inlineHits = exact.length || tolerantHits.length ? [] : inlineTolerantSpans(current, find);
         const visibleHits = exact.length || tolerantHits.length || inlineHits.length ? [] : visibleTextSpans(current, find, within);
         const hits = exact.length ? exact : tolerantHits.length ? tolerantHits : inlineHits.length ? inlineHits : visibleHits;
-        const res = editWithin(current, hits, within, action, body ?? "", nth);
+        const res = editWithin(current, hits, within, action, body ?? "", nth, all === true);
         if (!res.ok) {
-          const hint = res.reason === "no_match" ? missHint(find, current, false) : res.reason === "no_element" ? `The anchor matched ${res.matches} time(s), but never inside a <${within}>. Check the tag, or drop within= to edit the text itself.` : `The anchor sits in ${res.matches} different <${within}> elements. Lengthen it until it is unique, or pass nth= (1-based, in document order) \u2014 elements[] previews them.`;
+          const hint = res.reason === "no_match" ? missHint(find, current, false) : res.reason === "no_element" ? `The anchor matched ${res.matches} time(s), but never inside a <${within}>. ${pipeParagraphHint(current, hits, within) ?? "Check the tag, or drop within= to edit the text itself."}` : `The anchor sits in ${res.matches} different <${within}> elements. Lengthen it until it is unique, pass nth= (1-based, in document order), or all=true to act on every one \u2014 elements[] previews them.`;
           return txt3({
             ok: false,
             noteId,
@@ -29037,6 +29152,7 @@ ${closureHtml}`;
               ...closureTarget ? { closure: { noteId: closureTarget.note.noteId, note: closureTarget.note.title, table: closureTarget.heading ?? "(first table)", row: closureCells.map((c) => toText(c, 80)).join(" | "), action: "would-append" } } : {}
             },
             matchedElements: res.matches,
+            ...all && res.elements ? { elements: res.elements.slice(0, 20).map((e) => toText(e, 160)), ...res.elements.length > 20 ? { elementsShown: 20 } : {} } : {},
             next: "Nothing was written and no revision was taken. Re-run with dryRun=false to apply exactly this change."
           });
         }
@@ -29056,7 +29172,8 @@ ${closureHtml}`;
               entryId: entry.noteId,
               action: entry.action,
               ...entry.marker ? { entryMarker: entry.marker } : {},
-              runHeading: leadingIdentityText(closureBlock)
+              runHeading: leadingIdentityText(closureBlock),
+              ...entry.previousRun ? { previousRun: entry.previousRun } : {}
             };
             await trilium.updateLabelValue(closureThread.noteId, "updated", d);
           }
@@ -29129,7 +29246,7 @@ ${closureHtml}`;
           noteId,
           mode: `within:${within}:${action}`,
           date: d,
-          element: toText(res.element, 200),
+          ...all ? { elements: res.matches } : { element: toText(res.element, 200) },
           ...closureReceipt ? { closure: closureReceipt } : {},
           ...titledWithin.retitled ? { retitled: titledWithin.retitled } : {},
           ...iconWithin ? { icon: iconWithin } : {},
@@ -29373,7 +29490,7 @@ ${block}`), d).html;
       } : {},
       ...sectionMiss,
       ...sectionHint ? { hint: sectionHint } : {},
-      ...threadEntryResult ? { entryId: threadEntryResult.noteId, entryAction: threadEntryResult.action, ...threadEntryResult.marker ? { entryMarker: threadEntryResult.marker } : {}, ...threadRunHeading ? { runHeading: threadRunHeading } : {}, entry: `today's [${d}] entry in this thread; revise(entryId) edits it` } : {},
+      ...threadEntryResult ? { entryId: threadEntryResult.noteId, entryAction: threadEntryResult.action, ...threadEntryResult.marker ? { entryMarker: threadEntryResult.marker } : {}, ...threadRunHeading ? { runHeading: threadRunHeading } : {}, ...threadEntryResult.previousRun ? { previousRun: threadEntryResult.previousRun } : {}, entry: `today's [${d}] entry in this thread; revise(entryId) edits it` } : {},
       ...titled.retitled ? { retitled: titled.retitled } : {},
       ...titled.cascaded ? { domainCascade: `#domain updated on ${titled.cascaded} descendant note(s)` } : {},
       ...structuralFindings(noteKind, finalContent),
@@ -30179,15 +30296,18 @@ assertion + check \u2192 register (deduped by assertion); claimId + holds + evid
       ...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 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. since="today" (or a date, or "YYYY-MM-DD HH:mm") reviews everything changed since then in one call: with noteId, that note's net change across all its writes since; without, every maintained note changed since, each diffed against its state before the first of those writes. Run it before close to check today's corrections agree with each other.`, {
+  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. since="today" (or a date, or "YYYY-MM-DD HH:mm") reviews everything changed since then in one call: with noteId, that note's net change across all its writes since; without, every maintained note changed since, each diffed against its state before the first of those writes; summaryOnly=true lists those notes with their write counts and sizes and no changed lines, the cheap sweep for a recap. Run it before close to check today's corrections agree with each other.`, {
     noteId: string2().optional().describe("Note to diff (omit with since= to review every note changed since then)"),
     revisionId: string2().optional().describe("Compare against this revision (default: the most recent one)"),
     since: string2().optional().describe('"today", a date (YYYY-MM-DD) or a local datetime (YYYY-MM-DD HH:mm): the net change since then, across all writes'),
     includeRecords: boolean2().optional().describe("since= without noteId: also list records (sessions, diary, logs, dated thread entries), which only ever gain addenda (default false)"),
     limit: number2().int().min(1).max(50).optional().describe("since= without noteId: max notes to diff (default 25)"),
-    context: number2().int().min(0).max(10).optional().describe("Unchanged lines to show around each change (default: 1)")
-  }, async ({ noteId, revisionId, since, includeRecords, limit, context }) => {
+    context: number2().int().min(0).max(10).optional().describe("Unchanged lines to show around each change (default: 1)"),
+    summaryOnly: boolean2().optional().describe("since= without noteId: list each changed note with writes, chars and sizeChange (characters gained or lost), without the changed lines")
+  }, async ({ noteId, revisionId, since, includeRecords, limit, context, summaryOnly }) => {
     const pad = context ?? 1;
+    if (summaryOnly !== undefined && (since === undefined || noteId !== undefined))
+      return err("conflicting_params", "summaryOnly= applies to since= without noteId.", 'e.g. diff(since="today", summaryOnly=true, includeRecords=true); diff one note with noteId= for its lines.');
     if (since !== undefined) {
       const cutoff = sinceCutoff(since);
       if (!cutoff)
@@ -30216,6 +30336,10 @@ assertion + check \u2192 register (deduped by assertion); claimId + holds + evid
           continue;
         }
         const [before, after] = await Promise.all([trilium.getRevisionContent(first.revisionId), trilium.getNoteContent(n.noteId)]);
+        if (summaryOnly) {
+          notes.push({ ...stub, writes: revisionsSince(revisions, cutoff).length, chars: after.length, sizeChange: after.length - before.length, ...before === after ? { identical: true } : {} });
+          continue;
+        }
         const d = blockDiff(before, after, pad, 12);
         notes.push({ ...stub, writes: revisionsSince(revisions, cutoff).length, ...d.identical ? { identical: true } : { summary: d.summary, removed: d.removed, added: d.added } });
       }
@@ -32982,7 +33106,7 @@ function createServer(origin = null) {
   const s = new McpServer({
     name: BRAND2.name,
     title: BRAND2.name,
-    version: "13.1.1",
+    version: "13.2.0",
     description: BRAND2.description,
     websiteUrl: origin ?? BRAND2.website,
     icons: brandIcons(origin)

package/manifest.json

@@ -2,7 +2,7 @@
   "manifest_version": "0.3",
   "name": "brainllm",
   "display_name": "BrainLLM",
-  "version": "13.1.1",
+  "version": "13.2.0",
   "description": "Self-hosted memory for LLMs in TriliumNext, structured by the server and editable by you.",
   "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": "13.1.1",
+  "version": "13.2.0",
   "mcpName": "io.github.miisodev/brainllm",
   "description": "Self-hosted memory for LLMs in TriliumNext, structured by the server and editable by you.",
   "author": "Kevin Miiso Novo <miisodev@gmail.com>",
@@ -62,11 +62,11 @@
     "prepublishOnly": "bun run build"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.32.0",
+    "@modelcontextprotocol/sdk": "^1.32.2",
     "zod": "^4.6.6"
   },
   "devDependencies": {
-    "@types/bun": "latest",
+    "@types/bun": "^1.4.4",
     "ajv": "^8.20.0",
     "ajv-formats": "^3.0.1",
     "sharp": "^0.35.5",

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": "Self-hosted memory for LLMs in TriliumNext, structured by the server and editable by you.",
-  "version": "13.1.1",
+  "version": "13.2.0",
   "websiteUrl": "https://miisodev.github.io/BrainLLM/",
   "repository": {
     "url": "https://github.com/miisodev/BrainLLM",
@@ -12,7 +12,7 @@
     {
       "registryType": "npm",
       "identifier": "brainllm",
-"version": "13.1.1",
+"version": "13.2.0",
       "transport": {
         "type": "stdio"
       },

package/skills/brainllm/SKILL.md

@@ -95,7 +95,7 @@ worth keeping?
 | skim a surface | `<surface>_recall` |
 | everything about an area | `domain(name)` — the reliable path; reach here first. `outline=true` adds every maintained note's headings and size, for planning a multi-note rewrite |
 | search | `recall(query, domain=…)` — scope it; `since=`/`until=` keep only notes last modified inside the window (date-only bounds cover whole days); every hit names `matchedBy` (`label`/`title`/`text`/`fuzzy`/`ordered`/`regex`) and the top hits carry the `evidence` passage; `regex=` for structure, evidenced on every hit (records included; `kinds=` narrows); fuzzy hits are leads; recent notes rank slightly higher. A receipt that saturated a strategy's 30-candidate cap says so; `searchFailed: true` is a backend failure, never a "nothing matched" verdict — retry |
-| several bodies at once | `read(ids=[…])` (≤ 10). Every entry carries `chars` (the full stored size, even when a section is returned); `section=` (+ `occurrence=`) reads one heading's body from each note — a table section reports `tableRows`, and a miss follows the singleton miss shape (`missing: true` for an unknown id; `available[]` lists the real headings for a section miss). Bodies stop at ~80k characters; the rest come back in `deferred[]` for a second call. `text=true` returns readable plain text for orienting (not for building a `find=` anchor) |
+| several bodies at once | `read(ids=[…])` (≤ 10). Every entry carries `chars` (the full stored size, even when a section is returned); `section=` (+ `occurrence=`) reads one heading's body from each note — a table section reports `tableRows`, and a miss follows the singleton miss shape (`missing: true` for an unknown id; `available[]` lists the real headings for a section miss). Bodies stop at ~80k characters; the rest come back in `deferred[]` for a second call. `text=true` returns readable plain text for orienting (not for building a `find=` anchor). `sizes=true` returns no bodies, only each note's `chars` and its headings with their section sizes: plan a bulk read before it overflows |
 | storage and growth | `health()` — Trilium version, estimated database size, heaviest notes and their revisions, named backups |
 | what the brain holds | `assembly(area?)` — titles by surface with purposes |
 | inventory / locate by id | `brain()` — read `parent`, not position |
@@ -120,7 +120,7 @@ Every read that can be large takes `section=` — `read(ids)` too, across each n
 | the session log | `close(summary, identity, title?, learned?)` |
 
 - **Dedup is by title.** Generic titles (Current State, Sources) exist in many domains — pass `mustCreate=true` when you mean to create, and read `action` on every receipt.
-- **Sources preview before they land.** `remember(kind="sources", …, revision=)` takes `dryRun=true`, which previews each Revision row addition/update without writing; a new key near an existing one returns `didYouMean` (with `didYouMeanNote`) on the dry run and on the real call, so a qualifier added to a name updates its row instead of creating a second one.
+- **Sources preview before they land.** `remember(kind="sources", …, revision=)` takes `dryRun=true`, which previews each Revision row addition/update without writing; a new key near an existing one returns `didYouMean` (with `didYouMeanNote`) on the dry run and on the real call, so a qualifier added to a name updates its row instead of creating a second one. When a source moves or is renamed, `revision=[{source: "<new>", from: "<old>", marker}]` rekeys its row instead of adding one (refused when `<new>` already has a row). The dry run also previews where a `body=` lands and warns before loose prose joins the list.
 - **Wire at creation:** `connect=[{relation, toNoteId}]` on the same call. An unconnected note is an orphan until wired.
 - **Identity line** (`"LLM · environment · agent/mode [· Run N]"`) is required on diary, close and dated thread appends. It is checked on write: at least three `·`-separated parts, one line, no draft text — a malformed one is refused with nothing written.
 - **Every note carries an icon except logs.** The server sets the kind default at creation (a thread entry takes its thread's icon) and the sweep backfills any missing; `icon=` picks a better one (boxicons class or bare name). Removing an icon is refused.
@@ -151,17 +151,18 @@ Read `template(kind)` before your first write of a kind, then read a sibling.
 | `find="<text>"` | replace every occurrence (`nth=` for one) — exact first, then through re-serialized tags, then ignoring inline formatting (`matchMode` says which) |
 | `edits=[{find, body}]` | several surgeries in one read and one write |
 | `find="<short anchor>"` + `within="tr"` | act on the element containing the anchor: replace it (default), `mode="before"/"after"` to insert a row beside it, `mode="remove"` to delete it (`li`, `p`, `td` … too). `within` names what is replaced: `"tr"` takes a whole `<tr>…</tr>` body, `"td"` one `<td>…</td>`; a plain `find=` inside a cell replaces only that text |
+| `within=` + `all=true` | act on **every** element the anchor sits in (remove every Revision row naming a retired source, in one write) instead of refusing an ambiguous anchor; preview with `dryRun=true`, which lists them. Does not combine with `nth=` or `closure=` |
 | `within=` + `dryRun=true` | preview the element first: its full visible extent and byte size, plus the before/after shape (for a `closure=`, what would be appended or moved) — nothing written, no revision. `find=` and `edits=` also support `dryRun=true` using the same replacement and sanitizer path; metadata changes cannot be combined with a preview. `domain=` previews by default. Unsupported preview modes are refused |
 | `within="tr"` + `mode="remove"` + `closure=` | close a register row in one call: `{thread, body}` sends the row, quoted, into that thread's entry for today (needs `identity=`); `{note, table?, row?}` moves the row into another register. Column counts must match exactly; `row=["cell", …]` provides explicitly shaped plain-text destination cells. Name `table` when several tables exist. Destination content lands before source removal; same-note moves use one write. On a partial failure, read both notes before retrying; exact destination rows and identical dated blocks are deduplicated. Run `consistency()` after on any fact the row asserted |
 | `append={table, row}` | append one row to the table under that heading with no anchor to locate first — pipes are cell boundaries, a lone placeholder row is replaced; composes with nothing else |
 | `moves=[{find, nth?, row?}]` + `within="tr"`, `mode="remove"`, `closure=` | batch row closures to one target; all rows are preflighted, then applied in order. `dryRun=true` previews without writes. Stops on failure with completed and remaining rows; it is not an atomic transaction |
 | `domain="<name>"` + `find=`/`edits=` (no noteId) | the same find/replace across every maintained note in a domain; a dry run listing each match unless `dryRun=false`. Records are never touched |
 
-- **Tables are edited by row.** Anchor on a few words unique to the row and pass `within="tr"`; never copy a whole stored row into `find=`. The row's visible text works too (`"Phase 2 | Claude | Open"`), and quotes match in any form. An anchor in several rows is refused with previews; `nth=` picks one. Write one `<td>` per column — a row whose cells disagree with its header comes back as `tableShape`.
+- **Tables are edited by row.** Anchor on a few words unique to the row and pass `within="tr"`; never copy a whole stored row into `find=`. The row's visible text works too (`"Phase 2 | Claude | Open"`), and quotes match in any form. An anchor in several rows is refused with previews; `nth=` picks one, `all=true` takes them all. A `within="tr"` miss on a line written as `a | b | c` says it is a paragraph, not a row — use `within="p"`. Write one `<td>` per column — a row whose cells disagree with its header comes back as `tableShape`.
 - **"Last updated" lines are server-owned.** Every content write bumps them (the receipt says `lastUpdated`); never `find=` on one.
 - A replacement equal to its match writes nothing and reports `unchanged`.
-- A failed revision snapshot stops the content overwrite. System errors are not success receipts. A revision is taken before every content write; `diff(noteId)` shows what the last write changed, and `diff(since="today")` reviews every note you changed today in one call — run it before closing.
-- **Check the receipt.** `matched: false` means a new section was written — `available[]` lists real headings and `didYouMean` catches typos; `strict=true` refuses instead. `headingCount > 1` means only the first match was touched. `replacedSubsections[]` names nested headings a section replace took with it. A record append (`remember`/`revise`/`closure`) names where it landed: `entryMarker` (the `Addendum — HH:mm` block heading written) and `runHeading` (the identity heading, when the body opened with one).
+- A failed revision snapshot stops the content overwrite. System errors are not success receipts. A revision is taken before every content write; `diff(noteId)` shows what the last write changed, and `diff(since="today")` reviews every note you changed today in one call — run it before closing. `summaryOnly=true` lists the changed notes with write counts and size changes and no lines, the cheap sweep for a recap.
+- **Check the receipt.** `matched: false` means a new section was written — `available[]` lists real headings and `didYouMean` catches typos; `strict=true` refuses instead. `headingCount > 1` means only the first match was touched. `replacedSubsections[]` names nested headings a section replace took with it. A record append (`remember`/`revise`/`closure`) names where it landed: `entryMarker` (the `Addendum — HH:mm` block heading written) and `runHeading` (the identity heading, when the body opened with one); a dated-thread append adds `previousRun`, the same author's previous block (`heading`, `date`, and `run` when it carries `Run N`), so the next run number needs no walk-back read.
 - **`find=` replaces text; it does not insert beside an anchor.** To insert, use `within=` with `mode="before"/"after"`, or `section=` with an insertion mode. **`find=` prefers stored HTML.** Plain text also matches through inline formatting (`<strong>`, `<code>`, `<em>`, entities), so a short anchor rarely needs its markup; a span that opens or closes formatting is widened to keep it balanced. Block tags still match literally; `outline()` gives the `raw` form of headings. On a miss the hint names the cause in every shape: drifted text shows the stored text nearby (`storedNearby`), `nth=` past the last occurrence says so, and an all-miss `edits=` returns a hint per edit.
 - A section replace swaps everything under the heading — use `find=` for anything smaller.
 - **Oversized note (past the read ceiling)?** It usually holds two subjects: `split(noteId, sections=[…], into="<title>")` moves whole sections to a new sibling and leaves a pointer.