brainllm 12.7.1 → 12.8.0

package/dist/index.js

@@ -21881,6 +21881,36 @@ function addendumIndex(html) {
   }
   return out;
 }
+function addendumBlock(html, block) {
+  const markerRe = /<h2(?:\s[^>]*)?>\s*((?:Addendum|Withdrawn|Recovered|Reopened)[^<]*)<\/h2>/gi;
+  const hits = [...html.matchAll(markerRe)];
+  const markers = hits.map((m) => decodeEntities(m[1]).replace(/\s+/g, " ").trim());
+  const want = block.trim();
+  let i = -1;
+  if (/^-?\d+$/.test(want)) {
+    const n = parseInt(want, 10);
+    i = n < 0 ? hits.length + n : n - 1;
+  } else {
+    i = markers.findIndex((m) => m.endsWith(want) || m.includes(`\u2014 ${want}`) || m === want);
+  }
+  if (i < 0 || i >= hits.length)
+    return { matched: false, available: markers };
+  const from = hits[i].index;
+  const to = i + 1 < hits.length ? hits[i + 1].index : html.length;
+  const content = html.slice(from, to).trim();
+  const idMatch = content.match(/<h3(?:\s[^>]*)?>([\s\S]*?)<\/h3>/i);
+  const identity = idMatch ? decodeEntities(idMatch[1].replace(/<[^>]+>/g, "")).replace(/\s+/g, " ").trim() : undefined;
+  return { matched: true, marker: markers[i], ...identity ? { identity } : {}, content, position: i + 1, of: hits.length };
+}
+function readableText(html) {
+  return decodeEntities(html.replace(/<(style|script)[\s\S]*?<\/\1>/gi, "").replace(/<h([1-6])[^>]*>/gi, (_, n) => `
+` + "#".repeat(Number(n)) + " ").replace(/<li[^>]*>/gi, `
+- `).replace(/<\/t[dh]>\s*<t[dh][^>]*>/gi, " | ").replace(/<(tr|p|div|br|blockquote|figure|table|ul|ol|hr)[^>]*>/gi, `
+`).replace(/<[^>]+>/g, "")).replace(/[ \t]+/g, " ").replace(/ *\n */g, `
+`).replace(/\n{3,}/g, `
+
+`).trim();
+}
 function nearestContext(source, needle, radius = 40) {
   if (!source || needle.length < 4)
     return null;
@@ -22258,6 +22288,74 @@ function tolerantFindRegex(find) {
 function spansBlockBoundary(find) {
   return /<\/[a-zA-Z][a-zA-Z0-9-]*\s*>\s*<[a-zA-Z]/.test(find);
 }
+var INLINE_TAGS = "strong|em|b|i|u|s|del|ins|code|a|span|mark|sub|sup|kbd|small";
+var INLINE_TAG_RX = new RegExp(`<\\/?(?:${INLINE_TAGS})(?:\\s[^<>]*)?\\/?>`, "gi");
+var ENTITY_FORMS = {
+  "&": "&(?:amp;)?",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': '(?:"|&quot;)',
+  "'": "(?:'|&#39;|&apos;)"
+};
+function inlineTolerantSpans(source, needle) {
+  if (/<\/?(?!(?:strong|em|b|i|u|s|del|ins|code|a|span|mark|sub|sup|kbd|small)\b)[a-zA-Z]/.test(needle))
+    return [];
+  const text = decodeEntities(needle.replace(INLINE_TAG_RX, "")).trim();
+  if (text.length < 2)
+    return [];
+  const gap = `(?:<\\/?(?:${INLINE_TAGS})(?:\\s[^<>]*)?\\/?>)*`;
+  const esc = (c) => c.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const parts = [];
+  for (const ch of text.replace(/\s+/g, " ")) {
+    parts.push(ch === " " ? "(?:\\s|&nbsp;|&#160;)+" : ENTITY_FORMS[ch] ?? esc(ch));
+  }
+  let rx;
+  try {
+    rx = new RegExp(parts.join(gap), "g");
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const m of source.matchAll(rx)) {
+    const span = balanceInline(source, m.index, m.index + m[0].length);
+    if (span)
+      out.push({ start: span.start, length: span.end - span.start });
+  }
+  return out.filter((s, i) => i === 0 || s.start >= out[i - 1].start + out[i - 1].length);
+}
+function balanceInline(src, start, end) {
+  for (let guard = 0;guard < 8; guard++) {
+    const stack = [];
+    let strayClose = null;
+    for (const t of src.slice(start, end).matchAll(INLINE_TAG_RX)) {
+      const name = /^<\/?([a-z]+)/i.exec(t[0])[1].toLowerCase();
+      if (t[0].endsWith("/>"))
+        continue;
+      if (t[0].startsWith("</")) {
+        if (stack[stack.length - 1] === name)
+          stack.pop();
+        else if (!strayClose)
+          strayClose = name;
+      } else
+        stack.push(name);
+    }
+    if (!strayClose && !stack.length)
+      return { start, end };
+    if (strayClose) {
+      const before = new RegExp(`<${strayClose}(?:\\s[^<>]*)?>$`, "i").exec(src.slice(0, start));
+      if (!before)
+        return null;
+      start -= before[0].length;
+      continue;
+    }
+    const open = stack[stack.length - 1];
+    const after = new RegExp(`^<\\/${open}\\s*>`, "i").exec(src.slice(end));
+    if (!after)
+      return null;
+    end += after[0].length;
+  }
+  return null;
+}
 function looksEntityEscaped(find) {
   return !/<[a-zA-Z/]/.test(find) && /&lt;|&gt;/.test(find);
 }
@@ -23136,8 +23234,10 @@ var TIMELESS_KINDS = new Set(["thread", "user", "information", "domain"]);
 var DATED_PROSE_LIMIT = 4;
 var MONTHS = "Jan(?:uary)?|Feb(?:ruary)?|Mar(?:ch)?|Apr(?:il)?|May|June?|July?|Aug(?:ust)?|Sep(?:t(?:ember)?)?|Oct(?:ober)?|Nov(?:ember)?|Dec(?:ember)?";
 var DATED_REF = new RegExp(`\\b20\\d\\d-\\d\\d-\\d\\d\\b|\\b\\d{1,2} (?:${MONTHS}) 20\\d\\d\\b|\\b(?:${MONTHS}) \\d{1,2},? 20\\d\\d\\b`, "g");
-function datedReferences(html) {
-  return (toText(html, Number.MAX_SAFE_INTEGER).match(DATED_REF) ?? []).length;
+function datedReferences(html, opts = {}) {
+  const source = opts.register ? html.replace(/<table[\s\S]*?<\/table>/gi, " ") : html;
+  const spaced = source.replace(/<\/?t[dh](?=[\s>])[^>]*>/gi, " ");
+  return (toText(spaced, Number.MAX_SAFE_INTEGER).match(DATED_REF) ?? []).length;
 }
 var STRUCTURE_LINT_LIMIT = 40;
 var SECTION_EDIT_RISK_COUNT = 25;
@@ -23402,9 +23502,10 @@ async function sweep(trilium, cfg, opts = {}) {
     const kindHere = ownedLabel(n, "noteType");
     const isCurrentState = kindHere === "information" && /^current state$/i.test(n.title.trim());
     if (kindHere && TIMELESS_KINDS.has(kindHere) && !isCurrentState) {
-      const dated = datedReferences(content);
+      const register = n.attributes.some((a) => a.noteId === n.noteId && a.type === "label" && a.name === "register");
+      const dated = datedReferences(content, { register });
       if (dated >= DATED_PROSE_LIMIT) {
-        report.flagged.push(`dated prose: ${n.title} [${n.noteId}] \u2014 ${dated} dated references in a timeless ${kindHere} note. ` + `Keep what is true regardless of date; move state to the domain's Current State and history or decisions to a thread entry.`);
+        report.flagged.push(`dated prose: ${n.title} [${n.noteId}] \u2014 ${dated} dated references in a timeless ${kindHere} note${register ? " (outside its register tables)" : ""}. ` + `Keep what is true regardless of date; move state to the domain's Current State and history or decisions to a thread entry.` + (register ? "" : ` If the dates sit in a register's rows as evidence (a backlog, a defects list), label(noteId, "register", value="") exempts its tables.`));
       }
     }
     const lintKind = ownedLabel(n, "noteType");
@@ -23942,8 +24043,10 @@ function blockDiff(before, after, pad = 1, cap = 40) {
   const midA = a.slice(head, a.length - tail);
   const midB = b.slice(head, b.length - tail);
   const lcs = changedLines(midA, midB);
-  const removed = lcs ? lcs.removed : midA;
-  const added = lcs ? lcs.added : midB;
+  const meaningful = (arr) => arr.filter((l) => !/^<\/[a-zA-Z0-9]+>$/.test(l.trim()));
+  const removed = meaningful(lcs ? lcs.removed : midA);
+  const added = meaningful(lcs ? lcs.added : midB);
+  const tables = tableDiff(before, after);
   const bound = (arr) => arr.length > cap ? [...arr.slice(0, cap), `\u2026 ${arr.length - cap} more line(s)`] : arr;
   const delta = after.length - before.length;
   return {
@@ -23954,6 +24057,7 @@ function blockDiff(before, after, pad = 1, cap = 40) {
     removed: bound(removed),
     added: bound(added),
     contextAfter: bound(a.slice(a.length - tail, a.length - tail + pad)),
+    ...tables ? { tables } : {},
     summary: `${lcs ? `${lcs.hunks} change(s): ` : ""}${removed.length} block(s) removed, ${added.length} added, ${delta >= 0 ? "+" : ""}${delta} characters.`
   };
 }
@@ -23991,6 +24095,57 @@ function changedLines(a, b, budget = 4000000) {
   }
   return { removed, added, hunks };
 }
+function tableRows2(html) {
+  const rows = [];
+  for (const tr of html.matchAll(/<tr(?=[\s>])[^>]*>([\s\S]*?)<\/tr>/gi)) {
+    const cells = [...tr[1].matchAll(/<t[dh](?=[\s>])[^>]*>([\s\S]*?)<\/t[dh]>/gi)].map((c) => c[1].replace(/<[^>]+>/g, "").replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/\s+/g, " ").trim());
+    rows.push(cells);
+  }
+  return rows;
+}
+function tableDiff(before, after, cap = 30) {
+  const key = (r) => r.join("\x00");
+  const a = tableRows2(before);
+  const b = tableRows2(after);
+  const inB = new Map;
+  for (const r of b)
+    inB.set(key(r), (inB.get(key(r)) ?? 0) + 1);
+  const inA = new Map;
+  for (const r of a)
+    inA.set(key(r), (inA.get(key(r)) ?? 0) + 1);
+  const onlyIn = (rows, other) => {
+    const left = new Map(other);
+    return rows.filter((r) => {
+      const n = left.get(key(r)) ?? 0;
+      if (n > 0) {
+        left.set(key(r), n - 1);
+        return false;
+      }
+      return true;
+    });
+  };
+  const gone = onlyIn(a, inB);
+  const fresh = onlyIn(b, inA);
+  if (!gone.length && !fresh.length)
+    return null;
+  const changedCells = [];
+  const rowsRemoved = [];
+  const unpaired = [...fresh];
+  for (const r of gone) {
+    const i = unpaired.findIndex((x) => x[0] === r[0] && x.length === r.length);
+    if (i < 0) {
+      rowsRemoved.push(r.join(" | "));
+      continue;
+    }
+    const [pair] = unpaired.splice(i, 1);
+    r.forEach((cell, col) => {
+      if (cell !== pair[col])
+        changedCells.push({ row: r[0].slice(0, 80), column: col + 1, before: cell, after: pair[col] });
+    });
+  }
+  const clip = (arr) => arr.slice(0, cap);
+  return { changedCells: clip(changedCells), rowsAdded: clip(unpaired.map((r) => r.join(" | "))), rowsRemoved: clip(rowsRemoved) };
+}
 
 // src/elements.ts
 var WITHIN_TAGS = ["tr", "td", "th", "li", "p", "blockquote", "figure", "table", "ul", "ol"];
@@ -24082,6 +24237,9 @@ async function skim(trilium, ancestorNoteId, opts = {}) {
     };
   }));
 }
+var blockParam = {
+  block: stringType().optional().describe('Read one addendum block of a record instead of the whole note: its marker time ("14:05") or 1-based position ("-1" = newest)')
+};
 async function readFull(trilium, id, opts = {}) {
   const note = await trilium.getNote(id);
   const contentResult = await trilium.getNoteContentResult(id, note.type).catch(() => "");
@@ -24094,6 +24252,27 @@ async function readFull(trilium, id, opts = {}) {
     return { ...base, content: contentResult.content, contentEncoding: "base64", mime: contentResult.mime };
   }
   const content = contentResult;
+  if (opts.block) {
+    const found = addendumBlock(content, opts.block);
+    if (!found.matched) {
+      return {
+        ...base,
+        content: "",
+        block: opts.block,
+        matched: false,
+        available: found.available,
+        hint: found.available.length ? `No block "${opts.block}". available= lists this record's block markers, oldest first.` : "This note has no addendum blocks; read it without block=."
+      };
+    }
+    return {
+      ...base,
+      content: found.content,
+      block: found.marker,
+      matched: true,
+      ...found.identity ? { identity: found.identity } : {},
+      position: `${found.position} of ${found.of}`
+    };
+  }
   if (!opts.section) {
     return {
       ...base,
@@ -24165,18 +24344,19 @@ function registerMasterTools(server, trilium, brainRef) {
 // src/tools-llm.ts
 function registerLlmTools(server, trilium, brainRef) {
   const b = () => brainRef.config;
-  server.tool("llm", `Read an LLM singleton \u2014 responsibilities, protocols or selfcorrection \u2014 or a diary entry by id. Self-correction holds general rules learned from mistakes; read it before work that has gone wrong before (audits, large edits, completeness claims). section="<heading>" reads one section.`, {
+  server.tool("llm", `Read an LLM singleton \u2014 responsibilities, protocols or selfcorrection \u2014 or a diary entry by id (block="14:05" or "-1" reads one of its addendum blocks). Self-correction holds general rules learned from mistakes; read it before work that has gone wrong before (audits, large edits, completeness claims). section="<heading>" reads one section.`, {
     which: enumType(["responsibilities", "protocols", "selfcorrection", "diary"]),
     id: stringType().optional().describe("diary only: the entry id from llm_recall (noteId is accepted as an alias)"),
     noteId: stringType().optional().describe("Alias of id"),
     section: stringType().optional().describe("Read only this heading's section (h2/h3/h4), instead of the whole note"),
-    occurrence: numberType().int().positive().optional().describe("section=: which same-text heading, 1-based (default: the first)")
-  }, async ({ which, id, noteId: idAlias, section, occurrence }) => {
+    occurrence: numberType().int().positive().optional().describe("section=: which same-text heading, 1-based (default: the first)"),
+    ...blockParam
+  }, async ({ which, id, noteId: idAlias, section, occurrence, block }) => {
     if (which === "diary") {
       const entry = id ?? idAlias;
       if (!entry)
         throw new Error("Reading a diary entry needs its id \u2014 use llm_recall to find one.");
-      return txt(await readFull(trilium, entry, { section, occurrence }));
+      return txt(await readFull(trilium, entry, { section, occurrence, block }));
     }
     const noteId = b().llm[which];
     if (!noteId) {
@@ -24212,20 +24392,22 @@ index passes ~24k characters, unless limit= says otherwise; with the total count
 date="yyyy-mm-dd" resolves straight to one day. A collection thread returns its
 Context plus its titled entries (alphabetical, with a lead). Read a child with memory(<child id>).
 section="<heading>" reads one section. index=true on a dated thread returns only child ids,
-dates and block markers (no book body, no leads): the cheap answer to "what is the newest entry".`, {
+dates and block markers (no book body, no leads): the cheap answer to "what is the newest entry".
+block="14:05" (or "-1" for the newest) on a session or day entry returns that one addendum block.`, {
     ...idParams,
     date: stringType().optional().describe("Thread books only: resolve directly to this day's child note (yyyy-mm-dd)"),
     limit: numberType().int().positive().optional().describe("Dated threads: how many of the newest day-children to index (default 30)"),
     index: booleanType().optional().describe("Dated threads: ids, dates and block markers only \u2014 no book body, no block leads"),
     section: stringType().optional().describe("Read only this heading's section (h2/h3/h4), instead of the whole note"),
-    occurrence: numberType().int().positive().optional().describe("section=: which same-text heading, 1-based (default: the first)")
-  }, async ({ id: idArg, noteId, date, limit, index, section, occurrence }) => {
+    occurrence: numberType().int().positive().optional().describe("section=: which same-text heading, 1-based (default: the first)"),
+    ...blockParam
+  }, async ({ id: idArg, noteId, date, limit, index, section, occurrence, block }) => {
     const id = idArg ?? noteId;
     if (!id)
       return missingId("memory");
     const note = await trilium.getNote(id).catch(() => null);
     if (!note || labelOf(note, "noteType") !== "thread")
-      return txt(await readFull(trilium, id, { section, occurrence }));
+      return txt(await readFull(trilium, id, { section, occurrence, block }));
     if (isCollectionThread(note)) {
       const kids = await trilium.searchNotes("#noteType=threadEntry", { ancestorNoteId: id, fastSearch: true, limit: 500 }).catch(() => ({ results: [] }));
       const entries = await Promise.all(kids.results.filter((c) => c.parentNoteIds.includes(id)).sort((a, z) => a.title.localeCompare(z.title)).map(async (c) => ({
@@ -24240,7 +24422,7 @@ dates and block markers (no book body, no leads): the cheap answer to "what is t
     if (date) {
       const child = await trilium.searchNotes(`#noteType=threadEntry #created='${date}'`, { ancestorNoteId: id, fastSearch: true, limit: 1 }).catch(() => ({ results: [] }));
       if (child.results[0])
-        return txt(await readFull(trilium, child.results[0].noteId, { section, occurrence }));
+        return txt(await readFull(trilium, child.results[0].noteId, { section, occurrence, block }));
       return txt({ id, title: note.title, kind: "thread", note: `No entry for ${date}.` });
     }
     const shown = limit ?? MEMORY_INDEX_DEFAULT;
@@ -24372,6 +24554,35 @@ var txt3 = (obj) => ({
   content: [{ type: "text", text: typeof obj === "string" ? obj : JSON.stringify(obj, null, 2) }]
 });
 var today = () => localToday();
+function applyFindEdit(source, needle, replacement, index) {
+  const spans = (hits, matchMode) => {
+    if (index === undefined) {
+      let out = "";
+      let cursor = 0;
+      for (const h of hits) {
+        out += source.slice(cursor, h.start) + replacement;
+        cursor = h.start + h.length;
+      }
+      return { html: out + source.slice(cursor), count: hits.length, matchMode };
+    }
+    const hit = hits[index - 1];
+    if (!hit)
+      return null;
+    return { html: source.slice(0, hit.start) + replacement + source.slice(hit.start + hit.length), count: 1, matchMode };
+  };
+  const exact = [];
+  for (let at = source.indexOf(needle);at !== -1; at = source.indexOf(needle, at + needle.length)) {
+    exact.push({ start: at, length: needle.length });
+  }
+  if (exact.length)
+    return spans(exact, "exact");
+  const rx = tolerantFindRegex(needle);
+  const tolerant = rx ? [...source.matchAll(rx)].map((m) => ({ start: m.index, length: m[0].length })) : [];
+  if (tolerant.length)
+    return spans(tolerant, "attribute-tolerant");
+  const inline = inlineTolerantSpans(source, needle);
+  return inline.length ? spans(inline, "inline-tolerant") : null;
+}
 var err = (code, detail, hint) => txt3({ error: code, detail, ...hint ? { hint } : {} });
 var labelOf2 = (n, name) => n.attributes.find((a) => isOwnedAttribute(n, a) && a.type === "label" && a.name === name)?.value;
 var hasLabel = (n, name) => n.attributes.some((a) => isOwnedAttribute(n, a) && a.type === "label" && a.name === name);
@@ -24540,7 +24751,7 @@ ${block}` }));
   function collectionAppendRefusal(book) {
     return err("collection_thread", `"${book.title}" is a collection thread \u2014 it holds one titled entry per item, not dated appends.`, `Add an entry: remember(kind="threadEntry", thread="${book.noteId}", title, body). Change one: revise(<entry id>, section=/find=/mode=\u2026) \u2014 memory("${book.noteId}") lists them.`);
   }
-  server.tool("start", `Boot BrainLLM \u2014 once, before responding to the first message. Runs lite maintenance, opens today's diary and session notes, and returns: date and weekday, preferences and protocols in full, the other singletons as section headings with a preview (depth="full" inlines everything), today's diary and session ids, active and dormant threads with idle ages, the previous session's summary, notes changed since, and newDay on the first session of a day.`, {
+  server.tool("start", `Opens a BrainLLM session: runs the lite maintenance sweep, creates today's diary and session notes if they do not exist yet, and returns the date and weekday, the user's stored preferences and protocols in full, the other singletons as section headings with a preview (depth="full" inlines everything), today's diary and session ids, active and dormant threads with idle ages, the previous session's summary, notes changed since, and newDay on the first session of a day.`, {
     depth: enumType(["digest", "full"]).optional().describe('Singleton detail: "digest" (default \u2014 section headings + preview + size) or "full" (every singleton inline; token-heavy)')
   }, async ({ depth }) => {
     const cfg = b();
@@ -24633,9 +24844,9 @@ ${block}` }));
       hygiene: { scanned: hygiene.scanned, fixed: hygiene.fixed.length, transitions: hygiene.transitions, flagged: hygiene.flagged, ...hygiene.suppressed ? { suppressed: hygiene.suppressed } : {} }
     });
   });
-  server.tool("session", `Mandatory pre-close step: call before close(). Returns the six singletons as {id, lastModified} stubs (full=true inlines them), today's diary as {id, blocks, size}, runs the lite maintenance sweep, and returns pending= (what each remaining step actually has to do), audit= (do the singletons agree, and do the LLM singletons still serve the master ones) and next[]. Idempotent.
+  server.tool("session", `Pre-close review. Returns the six singletons as {id, lastModified} stubs (full=true inlines them), today's diary as {id, blocks, size}, the maintained notes changed today with their write counts, runs the lite maintenance sweep, and returns pending= (what each remaining close step has to do), audit= (do the singletons agree, and do the LLM singletons still serve the master ones) and next[]. Records the session step of the close gate. Idempotent.
 
-Protocol: 1. update master singletons with what the session taught about the user; 2. update LLM singletons with what it taught about yourself; 3. addendum(); 4. maintain(); 5. remarks(); 6. diary(); 7. close(). close() refuses until 3\u20136 ran and session \u2192 remarks \u2192 diary held. scope="agent" drops steps 1\u20132 for scoped or autonomous runs.`, {
+The close sequence next[] lays out: singleton updates from the session, then addendum(), maintain(), remarks(), diary() and close(). close() checks that addendum, maintain, remarks and diary ran, in the order session \u2192 remarks \u2192 diary. scope="agent" omits the singleton updates for scoped or autonomous runs.`, {
     date: stringType().optional().describe("ISO date YYYY-MM-DD (default: today)"),
     full: booleanType().optional().describe("Inline every singleton's content and the diary body (default: stubs only)"),
     scope: enumType(["interactive", "agent"]).optional().describe(`"agent" for a scoped/autonomous run whose brief excludes the user's personal singletons \u2014 omits those steps from next[] (default: "interactive")`),
@@ -24693,6 +24904,12 @@ Protocol: 1. update master singletons with what the session taught about the use
       selfcorrection
     };
     const touchedToday = Object.keys(singletonStubs).filter((k) => singletonStubs[k]?.lastModified === d);
+    const cutoff = `${d} 00:00`;
+    const changedToday = await trilium.searchNotes(`#noteType note.dateModified >= '${cutoff}'`, { ancestorNoteId: cfg.root, limit: 100, orderBy: "dateModified", orderDirection: "desc" }).then((r) => r.results.filter((n) => !isRecordNote(n))).catch(() => null);
+    const changedNotes = changedToday ? await Promise.all(changedToday.slice(0, 20).map(async (n) => {
+      const revisions = await trilium.getNoteRevisions(n.noteId).catch(() => []);
+      return { id: n.noteId, title: n.title, kind: ownedLabel(n, "noteType") ?? "", writes: revisionsSince(revisions, cutoff).length };
+    })) : null;
     const pending = {
       addendums: pendingAddendums === null ? "unknown" : pendingAddendums,
       maintenanceFlags: hygiene?.flagged.length ?? 0,
@@ -24710,6 +24927,12 @@ Protocol: 1. update master singletons with what the session taught about the use
       diary: diaryEntry,
       maintenance: hygiene ? { scanned: hygiene.scanned, fixed: hygiene.fixed.length, transitions: hygiene.transitions, flagged: hygiene.flagged, ...hygiene.suppressed ? { suppressed: hygiene.suppressed } : {} } : "skipped",
       pending,
+      changedToday: changedNotes ? {
+        notes: changedToday.length,
+        ...changedToday.length > changedNotes.length ? { shown: changedNotes.length } : {},
+        list: changedNotes,
+        check: changedNotes.length ? 'Which measured figures did these writes change? Each must now agree everywhere it is recorded: diff(since="today") shows the changes, consistency() finds other notes still asserting the old value.' : "No maintained note changed today."
+      } : "unavailable",
       audit: scoped ? undefined : {
         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.",
@@ -24724,12 +24947,12 @@ Protocol: 1. update master singletons with what the session taught about the use
         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.`,
         scoped ? "Call maintain() \u2014 audit brain hygiene; pass domain= to keep the flags in your lane." : pending.maintenanceFlags === 0 ? "Call maintain() \u2014 the lite sweep just ran clean, so this is a formality unless you want deep=true." : `Call maintain() \u2014 the lite sweep already flagged ${pending.maintenanceFlags} item(s), listed above.`,
         "Call remarks() \u2014 get the diary cues: your experience, opinions, and existence this session, plus BrainLLM remarks.",
-        "Call diary() \u2014 write the day's unfiltered record with the cues in hand; the gate counts it only after remarks().",
+        "Call diary() \u2014 write the day's record with the cues in hand; the gate counts it only after remarks().",
         "Call close() \u2014 commit the session log (mandatory, last). Refuses until every step ran and session \u2192 remarks \u2192 diary held; pass force=true only when a skipped step genuinely has nothing to log."
       ]
     });
   });
-  server.tool("remarks", `Diary cues, called after session() and before diary(): an experience bank (the session from the inside, your opinions, being what you are here) and a BrainLLM bank (walls, bugs, usability, roadmap). Answer them as prose in diary(); skip a cue rather than pad it. The call marks its close-gate step.`, {}, async () => {
+  server.tool("remarks", `Returns writing prompts for the diary: questions about how the session went and about BrainLLM itself (problems, usability, ideas). Records the remarks step of the close gate, which close() checks came after session() and before diary(). Writes no note content.`, {}, async () => {
     const cfg = b();
     if (!cfg.root)
       return txt3({ status: "uninitialized", action: "Run bootstrap first." });
@@ -24754,7 +24977,7 @@ Protocol: 1. update master singletons with what the session taught about the use
       ]
     });
   });
-  server.tool("close", `Commit the session log \u2014 once, last, after the session() protocol. Refuses unless session(), addendum(), maintain(), remarks() and diary() ran and session \u2192 remarks \u2192 diary held (force=true bypasses a step with genuinely nothing to do; bypassed steps are reported). identity= is required. Writes a timestamped block to today's [yyyy-mm-dd] session note (title= becomes its heading), regenerates the daily log, backs up the database and resets the gate. continuing=true is a second close the same day, skipping the ceremonial re-run.`, {
+  server.tool("close", `Writes the session log, normally the last call of a session. Refuses unless session(), addendum(), maintain(), remarks() and diary() ran and session \u2192 remarks \u2192 diary held (force=true bypasses a step with genuinely nothing to do; bypassed steps are reported). identity= is required. Writes a timestamped block to today's [yyyy-mm-dd] session note (title= becomes its heading), regenerates the daily log, backs up the database and resets the gate. continuing=true is a second close the same day.`, {
     summary: stringType().describe("What happened this session \u2014 factual, concise prose"),
     title: stringType().optional().describe("Short session title \u2014 appears as an <h2> heading above Summary"),
     identity: stringType().describe(`Identification line "LLM \xB7 environment \xB7 agent/mode [\xB7 Run N]" \u2014 rendered as the block's h3 (required)`),
@@ -24881,13 +25104,78 @@ ${contentBlock}` }));
     const backupName = name ?? rollingBackupName(d);
     try {
       await trilium.createBackup(backupName);
-      return txt3({ ok: true, backup: backupName, backupStatus: "completed", date: d });
+      const named = name && name !== rollingBackupName(d);
+      if (named) {
+        const cfg = b();
+        (cfg.backups ??= {})[backupName] = d;
+        try {
+          saveConfig(cfg);
+        } catch {}
+      }
+      const kept = Object.keys(b().backups ?? {}).length;
+      return txt3({
+        ok: true,
+        backup: backupName,
+        backupStatus: "completed",
+        date: d,
+        ...named ? { namedBackups: kept, note: `A named backup stays on Trilium's volume until deleted there. ${kept} named backup(s) recorded; health() reports them.` } : {}
+      });
     } catch (error) {
       return txt3({ ok: false, backup: backupName, backupStatus: "failed", error: error instanceof Error ? error.message : String(error), date: d });
     }
   });
-  server.tool("diary", `Write to today's diary: your unfiltered first-person record of the session \u2014 experience, opinions, remarks on existing here \u2014 then remarks on BrainLLM itself. identity= required. Every write lands as a timestamped block. The close gate counts it only when its last call came after session() and remarks().`, {
-    body: stringType().describe("What to record \u2014 first-person prose, honest and unfiltered"),
+  const SIZE_BANDS = [
+    { min: 1e7, max: 50000000 },
+    { min: 1e6, max: 1e7 },
+    { min: 1e5, max: 1e6 },
+    { min: 1e4, max: 1e5 }
+  ];
+  const NAMED_BACKUP_WARN = 6;
+  server.tool("health", `The brain's storage and runtime health: Trilium's version, an estimate of the database's size (content, attachments and revisions), the heaviest notes with their revision counts, and the named backups this server has taken. Each backup is a full database copy kept on Trilium's volume, which ETAPI cannot list, so growth there is flagged here rather than discovered when the disk fills. Read-only.`, {}, async () => {
+    const cfg = b();
+    const info = await trilium.getAppInfo().catch(() => null);
+    const count = (q) => trilium.searchNotes(q, { limit: 1e5, fastSearch: true, includeArchivedNotes: true }).then((r) => r.results.length).catch(() => null);
+    const bandCounts = await Promise.all(SIZE_BANDS.map((band) => count(`note.contentAndAttachmentsAndRevisionsSize >= ${band.min} AND note.contentAndAttachmentsAndRevisionsSize < ${band.max}`)));
+    const typed = await count("#noteType");
+    let estimate = 0;
+    SIZE_BANDS.forEach((band, i) => {
+      estimate += (bandCounts[i] ?? 0) * Math.sqrt(band.min * band.max);
+    });
+    const heavy = await trilium.searchNotes("note.contentAndAttachmentsAndRevisionsSize >= 1000000", {
+      limit: 5,
+      orderBy: "contentAndAttachmentsAndRevisionsSize",
+      orderDirection: "desc",
+      includeArchivedNotes: true
+    }).then((r) => r.results).catch(() => []);
+    const heaviest = await Promise.all(heavy.map(async (n) => {
+      const revisions = await trilium.getNoteRevisions(n.noteId).catch(() => []);
+      const revisionChars = revisions.reduce((sum, r) => sum + (r.contentLength ?? 0), 0);
+      return { id: n.noteId, title: n.title, revisions: revisions.length, revisionChars };
+    }));
+    const named = Object.entries(cfg.backups ?? {}).sort((x, y) => x[1].localeCompare(y[1]));
+    const mb = (n) => `${(n / 1e6).toFixed(1)} MB`;
+    const flags = [];
+    if (named.length >= NAMED_BACKUP_WARN)
+      flags.push(`${named.length} named backups recorded, each a full database copy (~${mb(estimate)}) kept until deleted on Trilium's volume. Delete the ones no longer needed there.`);
+    for (const h of heaviest) {
+      if (h.revisions >= 200)
+        flags.push(`${h.title} [${h.id}] carries ${h.revisions} revisions (${mb(h.revisionChars)}). Revision history is most of its weight; Trilium's revision-snapshot settings or a split bound it.`);
+    }
+    return txt3({
+      trilium: info ? { appVersion: info.appVersion, dbVersion: info.dbVersion, buildDate: info.buildDate } : { error: "app-info unreachable" },
+      notes: { typed: typed ?? undefined, bySize: SIZE_BANDS.map((band, i) => ({ atLeast: mb(band.min), below: mb(band.max), notes: bandCounts[i] })) },
+      estimatedSize: `${mb(estimate)} (content, attachments and revisions of notes over 10 kB; an estimate from size bands, not a measurement)`,
+      heaviest,
+      backups: {
+        rollingSlots: "7 (brainllm-mon \u2026 brainllm-sun), overwritten weekly by close()",
+        named: named.map(([name, date]) => ({ name, date })),
+        note: "Only backups taken through this server are listed. Each is roughly the size of the database."
+      },
+      ...flags.length ? { flags } : { flags: [], status: "No growth findings." }
+    });
+  });
+  server.tool("diary", `Appends a timestamped block to today's diary note: the assistant's own first-person account of the session, followed by notes on BrainLLM. identity= is required. The close gate counts the diary only when its latest block was written after session() and remarks().`, {
+    body: stringType().describe("The diary text, in the first person"),
     identity: stringType().describe(`Identification line "LLM \xB7 environment \xB7 agent/mode [\xB7 Run N]" \u2014 rendered as the block's h3 (required)`),
     icon: stringType().optional().describe("Display icon for the day's entry \u2014 a boxicons class or bare name; normalized server-side"),
     date: stringType().optional().describe("ISO date YYYY-MM-DD (default: today)")
@@ -25508,19 +25796,23 @@ ${block}`), d);
       ...total === 0 && !knowledgeDomain ? { note: `No content found for "${slug}". Create a Knowledge domain with remember(kind="information", domain="${name}") or tag notes with topics=["${slug}"].` } : {}
     });
   });
-  server.tool("read", `Several note bodies in one round trip: ids=[\u2026] (up to 10) \u2192 {notes:[{id, title, kind, content, relations}]}. For one note prefer the kinded read; for a huge note prefer a section= read.`, {
-    ids: arrayType(stringType()).min(1).max(10).describe("Note ids to read \u2014 one body per id, one round trip (cap 10)")
-  }, async ({ ids }) => {
-    const notes = await Promise.all(ids.map(async (id) => {
+  const READ_BUDGET = 80000;
+  server.tool("read", `Several note bodies in one round trip: ids=[\u2026] (up to 10) \u2192 {notes:[{id, title, kind, content, relations}]}. Bodies are returned in order until about 80k characters; the rest come back under deferred[] with their sizes, to read in a second call. 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; for a huge note prefer a section= read.`, {
+    ids: arrayType(stringType()).min(1).max(10).describe("Note ids to read \u2014 one body per id, one round trip (cap 10)"),
+    text: booleanType().optional().describe("Return readable plain text instead of stored HTML (default false)")
+  }, async ({ ids, text }) => {
+    const fetched = await Promise.all(ids.map(async (id) => {
       try {
         const note = await trilium.getNote(id);
         const contentResult = await trilium.getNoteContentResult(id, note.type);
         const relations = relationSnippet(note);
+        const raw = typeof contentResult === "string" ? contentResult : contentResult.content;
+        const content = text && typeof contentResult === "string" ? readableText(raw) : raw;
         return {
           id,
           title: note.title,
           kind: ownedLabel(note, "noteType") ?? undefined,
-          content: typeof contentResult === "string" ? contentResult : contentResult.content,
+          content,
           ...typeof contentResult === "string" ? {} : { contentEncoding: contentResult.encoding, mime: contentResult.mime },
           ...relations ? { relations } : {}
         };
@@ -25528,14 +25820,102 @@ ${block}`), d);
         return { id, missing: true };
       }
     }));
-    return txt3({ count: notes.length, notes });
+    const notes = [];
+    const deferred = [];
+    let used = 0;
+    for (const n of fetched) {
+      const size = "content" in n ? n.content.length : 0;
+      if ("content" in n && notes.length && used + size > READ_BUDGET) {
+        deferred.push({ id: n.id, title: n.title, size });
+        continue;
+      }
+      notes.push(n);
+      used += size;
+    }
+    return txt3({
+      count: notes.length,
+      notes,
+      ...deferred.length ? { deferred, hint: `${deferred.length} note(s) held back to keep this result under ~${READ_BUDGET / 1000}k characters. Read them with read(ids=[\u2026]) again${text ? "" : ", or pass text=true, which is smaller"}.` } : {}
+    });
   });
+  const reviseDomain = async (name, plan, dry, d) => {
+    if (plan.some((e) => !e.find))
+      return err("missing_param", "Every find must be non-empty.");
+    const cfg = b();
+    const slug = slugify(name);
+    const CAP = 300;
+    const search = (q) => trilium.searchNotes(q, { ancestorNoteId: cfg.root, limit: CAP, fastSearch: true }).then((r) => r.results).catch(() => []);
+    const [byDomain, byTopic] = await Promise.all([search(`#domain='${slug}'`), search(`#topic='${slug}'`)]);
+    const RECORDS = new Set(["session", "diary", "log", "threadEntry", "domain"]);
+    const seen = new Set;
+    const targets = [...byDomain, ...byTopic].filter((n) => {
+      if (seen.has(n.noteId))
+        return false;
+      seen.add(n.noteId);
+      const kind = ownedLabel(n, "noteType");
+      return !!kind && !RECORDS.has(kind) && !isContainer(cfg, n.noteId) && !hasLabel(n, "archived");
+    });
+    if (!targets.length)
+      return txt3({ ok: true, domain: name, slug, scanned: 0, note: `No maintained notes carry #domain or #topic "${slug}".` });
+    const changes = [];
+    let total = 0;
+    for (const n of targets) {
+      let content;
+      try {
+        content = await trilium.getNoteContent(n.noteId);
+      } catch {
+        continue;
+      }
+      let working = content;
+      let count = 0;
+      const previews = [];
+      for (const e of plan) {
+        const applied = applyFindEdit(working, e.find, e.body, e.nth);
+        if (!applied)
+          continue;
+        if (previews.length < 3) {
+          const plain = toText(working, Number.MAX_SAFE_INTEGER);
+          const at = plain.indexOf(toText(e.find, Number.MAX_SAFE_INTEGER).slice(0, 40));
+          previews.push(at >= 0 ? `\u2026${plain.slice(Math.max(0, at - 50), at + 90)}\u2026` : toText(e.find, 120));
+        }
+        working = applied.html;
+        count += applied.count;
+      }
+      if (!count || working === content)
+        continue;
+      total += count;
+      const row = { id: n.noteId, title: n.title, replaced: count, previews };
+      if (!dry) {
+        await trilium.createRevision(n.noteId).catch(() => null);
+        const clean = sanitizeHtml(working);
+        await trilium.updateNoteContent(n.noteId, bumpLastUpdated(clean.html, d).html);
+        await trilium.updateLabelValue(n.noteId, "updated", d);
+        row.written = true;
+      }
+      changes.push(row);
+    }
+    return txt3({
+      ok: true,
+      domain: name,
+      slug,
+      dryRun: dry,
+      scanned: targets.length,
+      notesMatched: changes.length,
+      replaced: total,
+      date: d,
+      ...targets.length >= CAP ? { truncated: `A query hit its ${CAP}-note cap; some notes in the domain were not scanned.` } : {},
+      changes,
+      next: dry ? changes.length ? "Nothing was written. Re-run with dryRun=false to apply exactly these changes." : "No note matched; nothing would change." : "Written, with a revision taken first on each note. Run consistency() on the old and new wording to confirm nothing outside the domain still asserts the old form."
+    });
+  };
   server.tool("revise", `Edit a note by id. A revision is taken first; "Last updated" lines are bumped on content writes.
 
 Modes: default append (a dated addendum \u2014 right only for records; a dated thread's append lands in today's child), mode=replace (whole body), section="<heading>" (replace that section's whole body, h2\u2192h3\u2192h4, occurrence= for repeats), section= + mode=before|after (insert a sibling block around the whole section), mode=prepend (top of the section body), mode=remove (delete the section). find="<exact stored text>" replaces every occurrence (nth= for one); edits=[{find, body}] applies several in one write. 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. 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.`, {
-    noteId: stringType().describe("Note to update"),
+    noteId: stringType().optional().describe("Note to update (omit only with domain=)"),
+    domain: stringType().optional().describe("Instead of noteId: apply find=/edits= to every maintained note in this domain (#domain or #topic slug). Records (sessions, diary, logs, dated thread entries) are never touched. Dry run unless dryRun=false"),
+    dryRun: booleanType().optional().describe("domain=: preview the matches without writing (default true). Re-run with dryRun=false to apply"),
     body: stringType().optional().describe("Content to add/replace: plain text, markdown, or HTML. Send real tags: entity-escaped markup (&lt;p&gt;) is decoded and reported in sanitized[]. With find=, the raw replacement string (no conversion)."),
     title: stringType().optional().describe("New title (normalized server-side)"),
     section: stringType().optional().describe("Target a section by heading text (h2/h3/h4, in that order); omit for whole-note append/replace"),
@@ -25553,7 +25933,21 @@ Check the receipt: matched=false means a NEW section was written (available= lis
     identity: stringType().optional().describe('Appending to a dated thread: the identification line "LLM \xB7 environment \xB7 agent/mode [\xB7 Run N]" (required)'),
     icon: stringType().optional().describe('Display icon \u2014 a boxicons class ("bx bx-brain") or a bare name; normalized server-side'),
     date: stringType().optional().describe("ISO date (default: today)")
-  }, async ({ noteId, body, title, section, occurrence, mode, find, nth, within, edits, identity, icon, date, strict }) => {
+  }, async ({ noteId: noteIdArg, domain, dryRun, body, title, section, occurrence, mode, find, nth, within, edits, identity, icon, date, strict }) => {
+    if (domain !== undefined) {
+      if (noteIdArg)
+        return err("conflicting_params", "Pass noteId= or domain=, not both.", "domain= edits every note in the domain; noteId= edits one.");
+      if (find === undefined && edits === undefined)
+        return err("missing_param", "domain= needs find= (with body=) or edits=.", 'e.g. revise(domain="myClerkBook", find="Code Priority Queue", body="Backlog")');
+      if (within || section || title || mode || identity || icon)
+        return err("conflicting_params", "domain= takes only find=/body=, edits=, nth= and dryRun=.", "Use noteId= for element, section, title or icon edits.");
+      return reviseDomain(domain, edits ?? [{ find, body: body ?? "", nth }], dryRun ?? true, checkedDate(date));
+    }
+    if (dryRun !== undefined)
+      return err("conflicting_params", "dryRun= applies only to revise(domain=); nothing was written.", "For one note, read it first (or outline()) and then revise without dryRun. diff(noteId) shows what a write changed.");
+    if (!noteIdArg)
+      return err("missing_param", "revise needs noteId= (or domain= for a domain-wide find/replace).", "Pass the id of the note to edit.");
+    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 (within && find === undefined)
@@ -25600,38 +25994,6 @@ Check the receipt: matched=false means a NEW section was written (available= lis
         if (e.body === undefined && !within)
           return err("missing_param", `edits[${i}] requires body as the replacement string.`, 'Call revise(noteId, find="<exact text>", body="<replacement>").');
       }
-      const applyEdit = (source, needle, replacement, index) => {
-        const spans = (hits, matchMode) => {
-          if (index === undefined) {
-            let out = "";
-            let cursor = 0;
-            for (const h of hits) {
-              out += source.slice(cursor, h.start) + replacement;
-              cursor = h.start + h.length;
-            }
-            return { html: out + source.slice(cursor), count: hits.length, matchMode };
-          }
-          const hit = hits[index - 1];
-          if (!hit)
-            return null;
-          return {
-            html: source.slice(0, hit.start) + replacement + source.slice(hit.start + hit.length),
-            count: 1,
-            matchMode
-          };
-        };
-        const exact = [];
-        for (let at = source.indexOf(needle);at !== -1; at = source.indexOf(needle, at + needle.length)) {
-          exact.push({ start: at, length: needle.length });
-        }
-        if (exact.length)
-          return spans(exact, "exact");
-        const rx = tolerantFindRegex(needle);
-        if (!rx)
-          return null;
-        const tolerant = [...source.matchAll(rx)].map((m) => ({ start: m.index, length: m[0].length }));
-        return tolerant.length ? spans(tolerant, "attribute-tolerant") : null;
-      };
       const missHint = (needle, source, alreadyConsumed) => {
         if (alreadyConsumed)
           return `Not found \u2014 but an EARLIER edit in this same edits= array already replaced this exact string. The array is applied in order against one body, so the second pass had nothing left to match. This is the expected result, not a failure.`;
@@ -25639,7 +26001,7 @@ Check the receipt: matched=false means a NEW section was written (available= lis
           return `Not found \u2014 the search string carries escaped markup (&lt;\u2026&gt;) while note bodies store real tags. Pass the tag literally, e.g. "<h3>Typography</h3>".`;
         if (spansBlockBoundary(needle))
           return `Not found \u2014 this string spans an element boundary (a closing tag followed by an opening one). Anchor the find INSIDE a single element instead, or target the heading directly with section= (with mode="before"/"after" to insert around it).`;
-        return `Not found in the note body (exact or attribute-tolerant) \u2014 already replaced on a retry, or the text genuinely differs.`;
+        return `Not found in the note body (exact, attribute-tolerant or ignoring inline tags) \u2014 already replaced on a retry, or the text genuinely differs.`;
       };
       const missContext = (needle, source) => {
         const near = nearestContext(source, needle);
@@ -25658,7 +26020,8 @@ Check the receipt: matched=false means a NEW section was written (available= lis
         for (let at = current.indexOf(find);at !== -1; at = current.indexOf(find, at + find.length))
           exact.push({ start: at, length: find.length });
         const rx = exact.length ? null : tolerantFindRegex(find);
-        const hits = exact.length ? exact : rx ? [...current.matchAll(rx)].map((m) => ({ start: m.index, length: m[0].length })) : [];
+        const tolerantHits = rx ? [...current.matchAll(rx)].map((m) => ({ start: m.index, length: m[0].length })) : [];
+        const hits = exact.length ? exact : tolerantHits.length ? tolerantHits : inlineTolerantSpans(current, find);
         const res = editWithin(current, hits, within, action, body ?? "", nth);
         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.`;
@@ -25704,7 +26067,7 @@ Check the receipt: matched=false means a NEW section was written (available= lis
       let total = 0;
       const consumed = new Set;
       for (const e of plan) {
-        const applied = applyEdit(working, e.find, e.body, e.nth);
+        const applied = applyFindEdit(working, e.find, e.body, e.nth);
         if (!applied) {
           const alreadyConsumed = consumed.has(e.find);
           results.push({
@@ -26045,7 +26408,7 @@ ${result.html}`);
       ...warnings.length ? { sanitized: warnings } : {}
     });
   });
-  server.tool("label", `Set or remove one label (remove=true). Refused on containers. noteType cannot be changed or removed, but can be set on an untyped note to repair it. status must be one of ${Statuses.join(" | ")}; domain and topic are slugged. Bumps updated unless you are setting it.`, {
+  server.tool("label", `Set or remove one label (remove=true). Refused on containers. noteType cannot be changed or removed, but can be set on an untyped note to repair it. status must be one of ${Statuses.join(" | ")}; domain and topic are slugged. register (value "") marks a register \u2014 a maintained table whose rows carry evidence dates \u2014 so maintain's dated-prose lint skips its tables. Bumps updated unless you are setting it.`, {
     noteId: stringType().describe("Note to edit"),
     name: stringType().describe("Label name, no # prefix (e.g. status, domain, topic, created)"),
     value: stringType().optional().describe("New value \u2014 required unless remove=true"),
@@ -27401,6 +27764,7 @@ var TOOL_ANNOTATIONS = {
   consistency: READ,
   assembly: READ,
   diff: READ,
+  health: READ,
   master: READ,
   master_recall: READ,
   llm: READ,
@@ -27419,11 +27783,11 @@ var TOOL_ANNOTATIONS = {
   claim: APPEND,
   remember: WRITE,
   diary: APPEND,
-  revise: WRITE,
+  revise: DESTRUCTIVE,
   split: WRITE,
   close: APPEND,
-  connect: WRITE,
-  label: WRITE,
+  connect: DESTRUCTIVE,
+  label: DESTRUCTIVE,
   attach: WRITE,
   backup: APPEND,
   bootstrap: WRITE,
@@ -27449,16 +27813,16 @@ var TOOL_ANNOTATIONS = {
   get_year_note: WRITE,
   get_inbox_note: WRITE,
   create_note: APPEND,
-  patch_note: WRITE,
-  update_note_content: WRITE,
+  patch_note: DESTRUCTIVE,
+  update_note_content: DESTRUCTIVE,
   clone_note: APPEND,
   move_note: WRITE,
   undelete_note: WRITE,
   add_label: WRITE,
   add_relation: WRITE,
-  update_attribute: WRITE,
+  update_attribute: DESTRUCTIVE,
   create_attachment: APPEND,
-  update_attachment: WRITE,
+  update_attachment: DESTRUCTIVE,
   create_revision: APPEND,
   create_backup: APPEND,
   delete_note: DESTRUCTIVE,
@@ -27466,6 +27830,86 @@ var TOOL_ANNOTATIONS = {
   delete_branch: DESTRUCTIVE,
   delete_attachment: DESTRUCTIVE
 };
+var TOOL_TITLES = {
+  start: "Open the brain for this session",
+  session: "Review the session before closing",
+  remarks: "Get diary prompts",
+  close: "Close the session and write its log",
+  backup: "Back up the brain",
+  health: "Check storage and runtime health",
+  diary: "Write the daily diary",
+  remember: "Remember something",
+  recall: "Search the brain",
+  domain: "Read everything about an area",
+  read: "Read several notes",
+  revise: "Edit a note",
+  resolve: "Resolve a thread",
+  split: "Split a note into two",
+  withdraw: "Reopen a thread",
+  label: "Set or remove a label",
+  connect: "Link two notes",
+  explore: "Explore a note's links",
+  consistency: "Check the brain agrees with itself",
+  outline: "Show a note's headings",
+  inspect: "Inspect a note's raw form",
+  claim: "Register or verify a claim",
+  diff: "Show what changed",
+  attach: "Attach a file to a note",
+  detach: "Remove an attachment",
+  addendum: "Find notes with pending addenda",
+  maintain: "Run brain maintenance",
+  forget: "Archive or delete a note",
+  recover: "Restore an archived note",
+  template: "Show a note kind's template",
+  graph: "Render the relation graph",
+  day: "Summarise the day",
+  brain: "List the brain's inventory",
+  assembly: "List what the brain holds",
+  bootstrap: "Create or refresh the brain's structure",
+  master: "Read a note about the user",
+  master_recall: "Skim notes about the user",
+  llm: "Read the model's operating notes",
+  llm_recall: "Skim the model's operating notes",
+  memory: "Read a thread or session",
+  memory_recall: "Skim threads and sessions",
+  knowledge: "Read a knowledge note",
+  knowledge_recall: "Skim knowledge",
+  insights: "Read a day's change log",
+  insights_recall: "Skim insights",
+  get_note: "Get note metadata (raw)",
+  get_note_content: "Get note content (raw)",
+  get_attachments: "List attachments (raw)",
+  get_attachment_content: "Get attachment content (raw)",
+  get_attribute: "Get an attribute (raw)",
+  get_branch: "Get a branch (raw)",
+  get_revisions: "List revisions (raw)",
+  get_revision_content: "Get revision content (raw)",
+  search_notes: "Search notes (raw query)",
+  note_history: "List recent changes (raw)",
+  get_app_info: "Get Trilium version (raw)",
+  get_day_note: "Get or create a day note (raw)",
+  get_week_note: "Get or create a week note (raw)",
+  get_month_note: "Get or create a month note (raw)",
+  get_year_note: "Get or create a year note (raw)",
+  get_inbox_note: "Get or create the inbox note (raw)",
+  create_note: "Create a note (raw)",
+  patch_note: "Change note properties (raw)",
+  update_note_content: "Replace note content (raw)",
+  clone_note: "Clone a note (raw)",
+  move_note: "Move a note (raw)",
+  undelete_note: "Undelete a note (raw)",
+  add_label: "Add a label (raw)",
+  add_relation: "Add a relation (raw)",
+  update_attribute: "Update an attribute (raw)",
+  create_attachment: "Create an attachment (raw)",
+  update_attachment: "Update an attachment (raw)",
+  create_revision: "Snapshot a revision (raw)",
+  create_backup: "Create a backup (raw)",
+  delete_note: "Delete a note (raw)",
+  delete_attribute: "Delete an attribute (raw)",
+  delete_branch: "Delete a branch (raw)",
+  delete_attachment: "Delete an attachment (raw)"
+};
 function applyToolAnnotations(server) {
   const registry = server._registeredTools;
   if (!registry)
@@ -27475,11 +27919,15 @@ function applyToolAnnotations(server) {
   for (const [name, tool] of Object.entries(registry)) {
     const hints = TOOL_ANNOTATIONS[name];
     if (!hints) {
-      tool.annotations = { ...tool.annotations, ...APPEND, title: name };
+      const fallback = TOOL_TITLES[name] ?? name;
+      tool.annotations = { ...tool.annotations, ...APPEND, title: fallback };
+      tool.title = fallback;
       unclassified.push(name);
       continue;
     }
-    tool.annotations = { ...tool.annotations, ...hints, title: name };
+    const title = TOOL_TITLES[name] ?? name;
+    tool.annotations = { ...tool.annotations, ...hints, title };
+    tool.title = title;
     annotated++;
   }
   return { annotated, unclassified };
@@ -27971,6 +28419,93 @@ note.dateModified >= 'YYYY-MM-DD', AND/OR. Unscoped unless ancestorNoteId is giv
   });
 }
 
+// src/cap.ts
+var RESULT_CHAR_CAP = 140000;
+function capResult(result, tool, cap = RESULT_CHAR_CAP) {
+  const blocks = result?.content;
+  if (!Array.isArray(blocks))
+    return result;
+  const total = blocks.reduce((n, b) => n + (b.type === "text" ? b.text?.length ?? 0 : 0), 0);
+  if (total <= cap)
+    return result;
+  let budget = cap;
+  const content = blocks.map((b) => {
+    if (b.type !== "text" || !b.text)
+      return b;
+    if (budget <= 0)
+      return { ...b, text: "" };
+    const text = b.text.length > budget ? b.text.slice(0, budget) : b.text;
+    budget -= text.length;
+    return { ...b, text };
+  });
+  const note = `
+
+[BrainLLM: ${tool}() returned ${total.toLocaleString("en-US")} characters, cut at ${cap.toLocaleString("en-US")} to fit the client's limit. ` + `Narrow the read: section= for one heading, block= for one addendum, limit= for fewer entries, or fewer ids=.]`;
+  content.push({ type: "text", text: note });
+  return { ...result, content };
+}
+function capToolResults(server, cap = RESULT_CHAR_CAP) {
+  const registry = server._registeredTools;
+  if (!registry)
+    return 0;
+  let wrapped = 0;
+  for (const [name, tool] of Object.entries(registry)) {
+    const inner = tool.handler;
+    if (typeof inner !== "function")
+      continue;
+    tool.handler = async (...args) => capResult(await inner(...args), name, cap);
+    wrapped++;
+  }
+  return wrapped;
+}
+
+// src/brand.ts
+var BRAND2 = {
+  name: "BrainLLM",
+  tagline: "Give Claude a memory that survives the session",
+  description: "Self-hosted memory for LLMs in TriliumNext, structured by the server and editable by you.",
+  website: "https://miisodev.github.io/BrainLLM/",
+  repository: "https://github.com/miisodev/BrainLLM",
+  publisher: "miisodev",
+  colors: { ground: "#0a0a0f", accent: "#f59e0b", nodeOff: "#3f3f46" }
+};
+var MARK_GRID = [
+  true,
+  false,
+  true,
+  true,
+  true,
+  false,
+  false,
+  true,
+  true
+];
+function markSvg(size = 22) {
+  const dots = MARK_GRID.map((lit, i) => {
+    const cx = 164 + i % 3 * 92;
+    const cy = 164 + Math.floor(i / 3) * 92;
+    return `<circle cx="${cx}" cy="${cy}" r="38" fill="${lit ? BRAND2.colors.accent : BRAND2.colors.nodeOff}"/>`;
+  }).join("");
+  return `<svg class="brand-mark" width="${size}" height="${size}" viewBox="110 110 292 292" aria-hidden="true">${dots}</svg>`;
+}
+var SERVER_INSTRUCTIONS = [
+  `${BRAND2.name} is the user's persistent memory, stored in their own TriliumNext instance. Every note is one the user can open, read and correct.`,
+  "The brain has five areas: Master (about the user), LLM (the assistant's operating notes and daily diary), Memory (threads and session logs), Knowledge (domains of sourced notes) and Insights (daily change logs and the relation graph).",
+  "A session typically opens with start(), which returns the user's stored preferences and protocols and what changed since the last session, and ends with session() and close(), which write the session log. remember() and revise() write; recall(), domain() and the surface reads (master, llm, memory, knowledge, insights) read.",
+  "The server owns placement, labels, deduplication, dates and backups, so writes need content, not bookkeeping."
+].join(`
+
+`);
+function brandIcons(origin) {
+  const REPO_RAW = "https://raw.githubusercontent.com/miisodev/BrainLLM/main/public";
+  const at = (file) => origin ? `${origin}/${file}` : `${REPO_RAW}/${file}`;
+  return [
+    { src: at("icon-128.png"), mimeType: "image/png", sizes: ["128x128"] },
+    { src: at("icon-512.png"), mimeType: "image/png", sizes: ["512x512"] },
+    { src: origin ? `${origin}/icon.svg` : `${REPO_RAW}/BrainLLM.svg`, mimeType: "image/svg+xml", sizes: ["any"] }
+  ];
+}
+
 // src/sse.ts
 import { randomUUID } from "crypto";
 var KEEPALIVE_MS = 30000;
@@ -28754,9 +29289,7 @@ var PAGE_CSS = `
     border:1px solid var(--border); border-radius:16px; padding:32px;
   }
   .brand { display:flex; align-items:center; gap:10px; margin-bottom:26px; }
-  .brand-mark { display:grid; grid-template-columns:repeat(3,4px); gap:3px; }
-  .brand-mark i { width:4px; height:4px; border-radius:50%; background:var(--accent); display:block; }
-  .brand-mark i.off { background:#3f3f46; }
+  .brand-mark { display:block; flex:none; }
   .brand-name { font-family:var(--font-display); font-size:19px; font-weight:700; letter-spacing:-.475px; }
   h1 { font-family:var(--font-display); font-size:24px; font-weight:700; letter-spacing:-.02em; line-height:1.2; margin:0 0 8px; }
   p { margin:0 0 20px; color:var(--text-muted); font-size:14.5px; }
@@ -28788,6 +29321,12 @@ var PAGE_CSS = `
   .approve:hover { transform:translateY(-1px); box-shadow:0 0 56px rgba(245,158,11,.42); }
   .deny { background:transparent; color:var(--text); border-color:var(--border-strong); font-weight:500; }
   .deny:hover { background:rgba(255,255,255,.04); }
+  .redirect { margin-top:-8px; }
+  .warn {
+    background:rgba(245,158,11,.08); border:1px solid rgba(245,158,11,.3); color:#fcd34d;
+    padding:11px 14px; border-radius:9px; font-size:14px; margin-bottom:18px;
+  }
+  a { color:var(--accent); }
   .err {
     background:rgba(239,68,68,.1); border:1px solid rgba(239,68,68,.3); color:#fca5a5;
     padding:11px 14px; border-radius:9px; font-size:14px; margin-bottom:18px;
@@ -28796,7 +29335,7 @@ var PAGE_CSS = `
   .foot a { color:inherit; }
   @media (prefers-reduced-motion: reduce) { button { transition:none; } .approve:hover { transform:none; } }
 `;
-var BRAND_MARK = `<span class="brand-mark"><i></i><i class="off"></i><i></i><i></i><i></i><i class="off"></i><i class="off"></i><i></i><i></i></span>`;
+var BRAND_MARK = markSvg(22);
 var shell = (title, body, head = "") => `<!doctype html>
 <html lang="en"><head><meta charset="utf-8">
 <meta name="viewport" content="width=device-width,initial-scale=1">
@@ -28806,13 +29345,13 @@ var shell = (title, body, head = "") => `<!doctype html>
 <style>${PAGE_CSS}</style></head>
 <body>${body}</body></html>`;
 function landingPage(base, oauthOn, sseOn) {
-  return shell("BrainLLM \u2014 a persistent memory server", `<div class="card">
-  <div class="brand">${BRAND_MARK}<span class="brand-name">BrainLLM</span></div>
+  return shell(`${BRAND2.name} - ${BRAND2.tagline}`, `<div class="card">
+  <div class="brand">${BRAND_MARK}<span class="brand-name">${BRAND2.name}</span></div>
   <h1>A brain is listening</h1>
-  <p>This is a <strong>BrainLLM</strong> MCP memory server \u2014 a persistent, graph-structured second brain served over the Model Context Protocol.</p>
-  <p>Point an MCP client at <span class="host">${esc2(base)}/mcp</span>${sseOn ? ` \u2014 or, for clients that only speak the legacy SSE transport, <span class="host">${esc2(base)}/sse</span>` : ""}.</p>
+  <p>This is a <strong>${BRAND2.name}</strong> server: ${esc2(BRAND2.description.charAt(0).toLowerCase() + BRAND2.description.slice(1))}</p>
+  <p>Point an MCP client at <span class="host">${esc2(base)}/mcp</span>${sseOn ? `, or, for clients that only speak the legacy SSE transport, <span class="host">${esc2(base)}/sse</span>` : ""}.</p>
   <p>${oauthOn ? `Authentication: OAuth 2.1 with owner consent, or a static bearer token (<span class="host">MCP_AUTH_TOKEN</span>). Both work against the same brain.` : `Authentication: a static bearer token (<span class="host">MCP_AUTH_TOKEN</span>).`}</p>
-  <p class="foot">Health: <span class="host">/health</span> \xB7 Everything else is MCP.</p>
+  <p class="foot">Health: <span class="host">/health</span> \xB7 Everything else is MCP \xB7 About: <span class="host">${esc2(BRAND2.website.replace(/^https:\/\//, "").replace(/\/$/, ""))}</span></p>
 </div>`);
 }
 var PAGE_SECURITY_DIRECTIVES = "default-src 'none'; frame-ancestors 'none'; base-uri 'none'; img-src 'self' data:";
@@ -28820,7 +29359,7 @@ function pageContentSecurityPolicy() {
   return `${PAGE_SECURITY_DIRECTIVES}; form-action 'self'; style-src 'unsafe-inline'`;
 }
 function consentResponse(transaction, redirectUri, clientHost, verifiedHost, error, status = 200) {
-  return new Response(consentPage({ transaction }, clientHost, error, verifiedHost), {
+  return new Response(consentPage({ transaction }, clientHost, error, verifiedHost, redirectUri), {
     status,
     headers: {
       "Content-Type": "text/html; charset=utf-8",
@@ -28829,13 +29368,28 @@ function consentResponse(transaction, redirectUri, clientHost, verifiedHost, err
     }
   });
 }
-function consentPage(params, clientHost, error, verifiedHost = true) {
+function redirectTarget(redirectUri) {
+  if (!redirectUri)
+    return null;
+  try {
+    const u = new URL(redirectUri);
+    const host = u.hostname.replace(/^\[|\]$/g, "");
+    const loopback = host === "localhost" || host === "127.0.0.1" || host === "::1";
+    return { host: u.port ? `${u.hostname}:${u.port}` : u.hostname, loopback };
+  } catch {
+    return null;
+  }
+}
+function consentPage(params, clientHost, error, verifiedHost = true, redirectUri) {
+  const target = redirectTarget(redirectUri);
   const hidden = Object.entries(params).map(([k, v]) => `<input type="hidden" name="${esc2(k)}" value="${esc2(v)}">`).join("");
   const foot = verifiedHost ? "Only the host above is shown, and it is the one DNS and TLS vouch for." : "The name above is self-reported by the application \u2014 your password is what authorizes access.";
   return shell("Authorize access to your brain", `<form class="card" method="POST" action="/authorize">
-  <div class="brand">${BRAND_MARK}<span class="brand-name">BrainLLM</span></div>
+  <div class="brand">${BRAND_MARK}<span class="brand-name">${BRAND2.name}</span></div>
   <h1>Authorize access</h1>
   <p><span class="host">${esc2(clientHost)}</span> is requesting access to your brain.</p>
+  ${target ? `<p class="redirect">Approving sends you back to <span class="host">${esc2(target.host)}</span>.</p>` : ""}
+  ${target?.loopback ? `<div class="warn">That address is this computer. Approve only if you just started this sign-in from an app on this machine, such as Claude Code.</div>` : ""}
   ${error ? `<div class="err">${esc2(error)}</div>` : ""}
   <div class="scope"><span class="dot"></span><span>Read and write everything in your brain \u2014 memories, threads, knowledge and your diary.</span></div>
   <label for="pw">Owner password</label>
@@ -28860,7 +29414,7 @@ function handoff(uri, params, heading, message) {
     u.searchParams.set(k, v);
   const href = esc2(u.href);
   return new Response(shell(heading, `<div class="card">
-  <div class="brand">${BRAND_MARK}<span class="brand-name">BrainLLM</span></div>
+  <div class="brand">${BRAND_MARK}<span class="brand-name">${BRAND2.name}</span></div>
   <h1>${esc2(heading)}</h1>
   <p>${esc2(message)}</p>
   <p class="foot"><a href="${href}">Continue</a> if this page does not move on by itself.</p>
@@ -28875,7 +29429,7 @@ function handoff(uri, params, heading, message) {
   });
 }
 var htmlError = (message, status = 400) => new Response(shell("Authorization error", `<div class="card">
-  <div class="brand">${BRAND_MARK}<span class="brand-name">BrainLLM</span></div>
+  <div class="brand">${BRAND_MARK}<span class="brand-name">${BRAND2.name}</span></div>
   <h1>Authorization error</h1>
   <div class="err">${esc2(message)}</div>
   <p class="foot">Nothing was authorized. Close this window and start again from your client.</p>
@@ -28982,12 +29536,15 @@ var tokenError = (error, description, status = 400) => new Response(JSON.stringi
   status,
   headers: { "Content-Type": "application/json", "Cache-Control": "no-store" }
 });
+function refreshKey(token) {
+  return "sha256:" + createHash("sha256").update(token).digest("hex");
+}
 function issueTokens(base, clientId, resource, scope) {
   const store = loadStore();
   const now = Math.floor(Date.now() / 1000);
   const accessToken = signJwt({ iss: base, aud: resource, sub: "owner", scope, iat: now, exp: now + ACCESS_TOKEN_TTL_S }, signingSecret());
   const refreshToken = randomBytes(32).toString("base64url");
-  store.refresh[refreshToken] = { clientId, resource, scope, expiresAt: Date.now() + REFRESH_TOKEN_TTL_MS };
+  store.refresh[refreshKey(refreshToken)] = { clientId, resource, scope, expiresAt: Date.now() + REFRESH_TOKEN_TTL_MS };
   saveStore();
   return {
     access_token: accessToken,
@@ -29035,10 +29592,11 @@ async function handleToken(req, base) {
   }
   if (grantType === "refresh_token") {
     const supplied = get("refresh_token");
-    const record = store.refresh[supplied];
-    if (!record)
+    const key = supplied && store.refresh[refreshKey(supplied)] ? refreshKey(supplied) : supplied;
+    const record = key ? store.refresh[key] : undefined;
+    if (!record || !key)
       return tokenError("invalid_grant", "Unknown or already-rotated refresh token.");
-    delete store.refresh[supplied];
+    delete store.refresh[key];
     saveStore();
     if (record.expiresAt < Date.now())
       return tokenError("invalid_grant", "Refresh token expired.");
@@ -29128,22 +29686,15 @@ if (port && !authToken && !oauthEnabled() && !allowUnauthenticatedHttp) {
   console.error("HTTP mode requires MCP_AUTH_TOKEN or BRAINLLM_OWNER_PASSWORD. Set BRAINLLM_ALLOW_UNAUTHENTICATED_HTTP=true only for a trusted, isolated network.");
   process.exit(1);
 }
-var REPO_RAW = "https://raw.githubusercontent.com/miisodev/BrainLLM/main/public";
-function brandingIcons(origin) {
-  const at = (file) => origin ? `${origin}/${file}` : `${REPO_RAW}/${file}`;
-  return [
-    { src: at("icon-128.png"), mimeType: "image/png", sizes: ["128x128"] },
-    { src: at("icon-512.png"), mimeType: "image/png", sizes: ["512x512"] },
-    { src: origin ? `${origin}/icon.svg` : `${REPO_RAW}/BrainLLM.svg`, mimeType: "image/svg+xml", sizes: ["any"] }
-  ];
-}
 function createServer(origin = null) {
   const s = new McpServer({
-    name: "BrainLLM",
-    title: "BrainLLM",
-    version: "12.7.1",
-    icons: brandingIcons(origin)
-  });
+    name: BRAND2.name,
+    title: BRAND2.name,
+    version: "12.8.0",
+    description: BRAND2.description,
+    websiteUrl: BRAND2.website,
+    icons: brandIcons(origin)
+  }, { instructions: SERVER_INSTRUCTIONS });
   registerTools(s, trilium, brainRef);
   if (mode === "full")
     registerAdvancedTools(s, trilium, brainRef);
@@ -29155,6 +29706,7 @@ function createServer(origin = null) {
   if (unclassified.length) {
     console.error(`[brainllm] Unclassified tools, treated as writes: ${unclassified.join(", ")}`);
   }
+  capToolResults(s);
   const serialized = serializeWrites(s);
   if (serialized.serialized) {
     console.error(`[brainllm] Write serialization: ${serialized.serialized} write handler(s) queued, ${serialized.readsUntouched} read(s) untouched`);
@@ -29191,7 +29743,8 @@ if (port) {
     authorize: new FixedWindowRateLimiter(30, 15 * 60000),
     token: new FixedWindowRateLimiter(120, 15 * 60000),
     register: new FixedWindowRateLimiter(30, 60 * 60000),
-    transport: new FixedWindowRateLimiter(600, 15 * 60000)
+    transport: new FixedWindowRateLimiter(600, 15 * 60000),
+    transportIp: new FixedWindowRateLimiter(3000, 15 * 60000)
   };
   const rateLimited = (limiter, key) => {
     const decision = limiter.allow(key);
@@ -29230,6 +29783,7 @@ if (port) {
   Bun.serve({
     port,
     maxRequestBodySize: 50 * 1024 * 1024,
+    idleTimeout: 240,
     async fetch(req, server) {
       const url = new URL(req.url);
       const requestKey = clientKey(req, server);
@@ -29304,7 +29858,12 @@ if (port) {
       if (!isMcpEndpoint && url.pathname !== "/sse" && url.pathname !== "/messages") {
         return withCors(new Response("Not Found", { status: 404 }));
       }
-      const transportLimit = rateLimited(rateLimiters.transport, requestKey);
+      const ipLimit = rateLimited(rateLimiters.transportIp, requestKey);
+      if (ipLimit)
+        return ipLimit;
+      const bearer = req.headers.get("authorization")?.match(/^Bearer\s+(.+)$/i)?.[1];
+      const transportKey = bearer ? `token:${new Bun.CryptoHasher("sha256").update(bearer).digest("hex").slice(0, 32)}` : requestKey;
+      const transportLimit = rateLimited(rateLimiters.transport, transportKey);
       if (transportLimit)
         return transportLimit;
       const gate = () => {