brainllm 12.7.1 → 12.9.0

package/dist/index.js

@@ -17351,6 +17351,9 @@ class Protocol {
       this.setRequestHandler(GetTaskPayloadRequestSchema, async (request, extra) => {
         const handleTaskResult = async () => {
           const taskId = request.params.taskId;
+          if (!await this._taskStore.getTask(taskId, extra.sessionId)) {
+            throw new McpError(ErrorCode.InvalidParams, `Task not found: ${taskId}`);
+          }
           if (this._taskMessageQueue) {
             let queuedMessage;
             while (queuedMessage = await this._taskMessageQueue.dequeue(taskId, extra.sessionId)) {
@@ -17381,12 +17384,12 @@ class Protocol {
             throw new McpError(ErrorCode.InvalidParams, `Task not found: ${taskId}`);
           }
           if (!isTerminal(task.status)) {
-            await this._waitForTaskUpdate(taskId, extra.signal);
+            await this._waitForTaskUpdate(taskId, extra.signal, extra.sessionId);
             return await handleTaskResult();
           }
           if (isTerminal(task.status)) {
             const result = await this._taskStore.getTaskResult(taskId, extra.sessionId);
-            this._clearTaskQueue(taskId);
+            this._clearTaskQueue(taskId, extra.sessionId);
             return {
               ...result,
               _meta: {
@@ -17423,7 +17426,7 @@ class Protocol {
             throw new McpError(ErrorCode.InvalidParams, `Cannot cancel task in terminal status: ${task.status}`);
           }
           await this._taskStore.updateTaskStatus(request.params.taskId, "cancelled", "Client cancelled task execution.", extra.sessionId);
-          this._clearTaskQueue(request.params.taskId);
+          this._clearTaskQueue(request.params.taskId, extra.sessionId);
           const cancelledTask = await this._taskStore.getTask(request.params.taskId, extra.sessionId);
           if (!cancelledTask) {
             throw new McpError(ErrorCode.InvalidParams, `Task not found after cancellation: ${request.params.taskId}`);
@@ -17546,6 +17549,19 @@ class Protocol {
     const handler = this._requestHandlers.get(request.method) ?? this.fallbackRequestHandler;
     const capturedTransport = this._transport;
     const relatedTaskId = request.params?._meta?.[RELATED_TASK_META_KEY]?.taskId;
+    const sessionId = capturedTransport?.sessionId;
+    const store = this._taskStore;
+    let relatedTaskFound = true;
+    let relatedTaskLookup;
+    if (relatedTaskId && store && this._taskMessageQueue && sessionId !== undefined) {
+      relatedTaskFound = false;
+      relatedTaskLookup = (async () => {
+        if (!await store.getTask(relatedTaskId, sessionId)) {
+          throw new McpError(ErrorCode.InvalidParams, `Task not found: ${relatedTaskId}`);
+        }
+        relatedTaskFound = true;
+      })();
+    }
     if (handler === undefined) {
       const errorResponse = {
         jsonrpc: "2.0",
@@ -17555,7 +17571,10 @@ class Protocol {
           message: "Method not found"
         }
       };
-      if (relatedTaskId && this._taskMessageQueue) {
+      if (relatedTaskId && relatedTaskLookup) {
+        const queuedError = { type: "error", message: errorResponse, timestamp: Date.now() };
+        relatedTaskLookup.then(() => this._enqueueTaskMessage(relatedTaskId, queuedError, sessionId), () => capturedTransport?.send(errorResponse)).catch((error) => this._onerror(new Error(`Failed to send an error response: ${error}`)));
+      } else if (relatedTaskId && this._taskMessageQueue) {
         this._enqueueTaskMessage(relatedTaskId, {
           type: "error",
           message: errorResponse,
@@ -17606,7 +17625,10 @@ class Protocol {
       closeSSEStream: extra?.closeSSEStream,
       closeStandaloneSSEStream: extra?.closeStandaloneSSEStream
     };
-    Promise.resolve().then(() => {
+    (relatedTaskLookup ?? Promise.resolve()).then(() => {
+      if (relatedTaskLookup && abortController.signal.aborted) {
+        throw new McpError(ErrorCode.ConnectionClosed, "Request was cancelled");
+      }
       if (taskCreationParams) {
         this.assertTaskHandlerCapability(request.method);
       }
@@ -17641,7 +17663,7 @@ class Protocol {
           ...error["data"] !== undefined && { data: error["data"] }
         }
       };
-      if (relatedTaskId && this._taskMessageQueue) {
+      if (relatedTaskId && this._taskMessageQueue && relatedTaskFound) {
         await this._enqueueTaskMessage(relatedTaskId, {
           type: "error",
           message: errorResponse,
@@ -18029,7 +18051,7 @@ class Protocol {
       throw new Error("Cannot enqueue task message: taskStore and taskMessageQueue are not configured");
     }
     const maxQueueSize = this._options?.maxTaskQueueSize;
-    await this._taskMessageQueue.enqueue(taskId, message, sessionId, maxQueueSize);
+    await this._taskMessageQueue.enqueue(taskId, message, sessionId ?? this._transport?.sessionId, maxQueueSize);
   }
   async _clearTaskQueue(taskId, sessionId) {
     if (this._taskMessageQueue) {
@@ -18048,10 +18070,10 @@ class Protocol {
       }
     }
   }
-  async _waitForTaskUpdate(taskId, signal) {
+  async _waitForTaskUpdate(taskId, signal, sessionId) {
     let interval = this._options?.defaultTaskPollInterval ?? 1000;
     try {
-      const task = await this._taskStore?.getTask(taskId);
+      const task = await this._taskStore?.getTask(taskId, sessionId);
       if (task?.pollInterval) {
         interval = task.pollInterval;
       }
@@ -18718,6 +18740,43 @@ class ExperimentalMcpServerTasks {
   }
 }
 // node_modules/@modelcontextprotocol/sdk/dist/esm/server/mcp.js
+function toolInputElementCount(value, max) {
+  let count = 0;
+  const stack = [value];
+  while (stack.length > 0) {
+    const node = stack.pop();
+    if (node === null || typeof node !== "object")
+      continue;
+    if (Array.isArray(node)) {
+      for (const child of node) {
+        if (++count > max)
+          return count;
+        if (child !== null && typeof child === "object")
+          stack.push(child);
+      }
+    } else {
+      for (const key in node) {
+        if (!Object.prototype.hasOwnProperty.call(node, key))
+          continue;
+        if (++count > max)
+          return count;
+        const child = node[key];
+        if (child !== null && typeof child === "object")
+          stack.push(child);
+      }
+    }
+  }
+  return count;
+}
+function resolveMaxToolInputElements(value) {
+  if (value === undefined || value === Infinity)
+    return;
+  if (typeof value !== "number" || Number.isNaN(value) || value < 1) {
+    throw new RangeError(`maxToolInputElements must be a number of at least 1, or Infinity, got ${String(value)}`);
+  }
+  return value;
+}
+
 class McpServer {
   constructor(serverInfo, options) {
     this._registeredResources = {};
@@ -18729,6 +18788,7 @@ class McpServer {
     this._resourceHandlersInitialized = false;
     this._promptHandlersInitialized = false;
     this.server = new Server(serverInfo, options);
+    this._maxToolInputElements = resolveMaxToolInputElements(options?.maxToolInputElements);
   }
   get experimental() {
     if (!this._experimental) {
@@ -18835,12 +18895,15 @@ class McpServer {
     };
   }
   async validateToolInput(tool, args, toolName) {
+    if (this._maxToolInputElements !== undefined && toolInputElementCount(args, this._maxToolInputElements) > this._maxToolInputElements) {
+      throw new McpError(ErrorCode.InvalidParams, `Invalid arguments for tool ${toolName}: arguments contain more than the maximum of ${this._maxToolInputElements} elements`);
+    }
     if (!tool.inputSchema) {
       return;
     }
     const inputObj = normalizeObjectSchema(tool.inputSchema);
     const schemaToParse = inputObj ?? tool.inputSchema;
-    const parseResult = await safeParseAsync2(schemaToParse, args);
+    const parseResult = await safeParseAsync2(schemaToParse, args ?? {});
     if (!parseResult.success) {
       const error = "error" in parseResult ? parseResult.error : "Unknown error";
       const errorMessage = getParseErrorMessage(error);
@@ -19065,7 +19128,7 @@ class McpServer {
       }
       if (prompt.argsSchema) {
         const argsObj = normalizeObjectSchema(prompt.argsSchema);
-        const parseResult = await safeParseAsync2(argsObj, request.params.arguments);
+        const parseResult = await safeParseAsync2(argsObj, request.params.arguments ?? {});
         if (!parseResult.success) {
           const error = "error" in parseResult ? parseResult.error : "Unknown error";
           const errorMessage = getParseErrorMessage(error);
@@ -21591,6 +21654,16 @@ function looksLikeHtml(body) {
       return true;
   return false;
 }
+function isStructuralTag(name) {
+  const tag = name.toLowerCase();
+  return SAFE_TAGS.has(tag) || BLOCK_ELEMENTS.has(tag);
+}
+function looksLikeStructuralHtml(body) {
+  for (const m of body.matchAll(HTML_TAG))
+    if (isStructuralTag(m[1]))
+      return true;
+  return false;
+}
 var ENCODED_TAG = /&lt;\/?[a-z][a-z0-9-]*(?:\s[^&<>]*?)?\s*\/?&gt;/i;
 function looksLikeEncodedHtml(body) {
   return !looksLikeHtml(body) && ENCODED_TAG.test(body);
@@ -21658,7 +21731,7 @@ function renderMarkup(raw) {
   const body = raw.replace(/\u0000/g, "");
   if (!body.trim())
     return { html: "<p></p>", convertedRuns: 0 };
-  if (looksLikeHtml(body))
+  if (looksLikeStructuralHtml(body))
     return mixedToHtml(body);
   if (looksLikeEncodedHtml(body))
     return { html: decodeEncodedHtml(body), convertedRuns: 0 };
@@ -21747,7 +21820,7 @@ function mixedToHtml(body) {
 }
 function markdownToHtml(body, inlineHtml = false) {
   const kept = [];
-  const source = inlineHtml ? body.replace(HTML_TAG, (tag, name) => isHtmlElement(name) ? `\x00${kept.push(tag) - 1}\x00` : tag) : body;
+  const source = inlineHtml ? body.replace(HTML_TAG, (tag, name) => isStructuralTag(name) ? `\x00${kept.push(tag) - 1}\x00` : tag) : body;
   const lines = source.replace(/\r\n/g, `
 `).split(`
 `);
@@ -21881,6 +21954,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;
@@ -21948,6 +22051,9 @@ function stripTagsWithMap(html) {
 function escapeQueryValue(s) {
   return s.replace(/["\\]/g, " ").replace(/\s+/g, " ").trim();
 }
+function triliumSearchForm(pattern) {
+  return pattern.normalize("NFD").replace(/\p{Diacritic}/gu, (c) => c.charCodeAt(0) < 128 ? c : "");
+}
 function escapeQueryRegex(s) {
   return s.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
 }
@@ -22141,12 +22247,21 @@ function sanitizeHtml(html) {
     n++;
     return "";
   });
-  s = s.replace(/<(script|style|noscript|iframe|form|object|applet|select|textarea|button|template|svg|math|canvas)(\s[^>]*)?>[\s\S]*$/gi, () => {
+  let dropped = 0;
+  s = s.replace(/<(script|style|noscript|iframe)(\s[^>]*)?>[\s\S]*$/gi, (m) => {
     n++;
+    dropped += m.length;
     return "";
   });
   if (n)
-    warnings.push(`Stripped ${n} forbidden element block(s) \u2014 active/content-bearing tags are not allowed`);
+    warnings.push(`Stripped ${n} forbidden element block(s) \u2014 active/content-bearing tags are not allowed${dropped ? ` (${dropped} characters removed with an unclosed code element)` : ""}`);
+  let opened = 0;
+  s = s.replace(/<(form|object|applet|select|textarea|button|template|svg|math|canvas)(\s[^>]*)?>/gi, (m) => {
+    opened++;
+    return escapeHtml(m, false);
+  });
+  if (opened)
+    warnings.push(`Kept ${opened} unclosed forbidden tag(s) as text \u2014 written as a placeholder, nothing after it was removed`);
   const comments = s.match(/<!--[\s\S]*?-->/g)?.length ?? 0;
   if (comments) {
     s = s.replace(/<!--[\s\S]*?-->/g, "");
@@ -22258,6 +22373,99 @@ function tolerantFindRegex(find) {
 function spansBlockBoundary(find) {
   return /<\/[a-zA-Z][a-zA-Z0-9-]*\s*>\s*<[a-zA-Z]/.test(find);
 }
+function closedBlockTag(find) {
+  const m = /<\/(tr|td|th|li|p|blockquote|figure|table|ul|ol)\s*>/i.exec(find);
+  return m ? m[1].toLowerCase() : null;
+}
+function visibleTextSpans(source, needle, tag) {
+  const norm = (s) => decodeEntities(s).replace(/\\(["'])/g, "$1").replace(/[\u201C\u201D]/g, '"').replace(/[\u2018\u2019]/g, "'").replace(/\s*\|\s*/g, " ").replace(/\s+/g, " ").trim().toLowerCase();
+  const want = norm(needle.replace(/<[^>]+>/g, " "));
+  if (want.length < 2)
+    return [];
+  const out = [];
+  const rx = new RegExp(`<${tag}\\b[^>]*>([\\s\\S]*?)<\\/${tag}>`, "gi");
+  for (const m of source.matchAll(rx)) {
+    if (norm(m[1].replace(/<[^>]+>/g, " ")).includes(want)) {
+      const open = /^<[^>]*>/.exec(m[0])[0];
+      out.push({ start: m.index + open.length, length: 0 });
+    }
+  }
+  return out;
+}
+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 DOUBLE_QUOTE = '(?:"|&quot;|&#34;|\u201C|\u201D|&ldquo;|&rdquo;)';
+var SINGLE_QUOTE = "(?:'|&#39;|&apos;|\u2018|\u2019|&lsquo;|&rsquo;)";
+var ENTITY_FORMS = {
+  "&": "&(?:amp;)?",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': DOUBLE_QUOTE,
+  "\u201C": DOUBLE_QUOTE,
+  "\u201D": DOUBLE_QUOTE,
+  "'": SINGLE_QUOTE,
+  "\u2018": SINGLE_QUOTE,
+  "\u2019": SINGLE_QUOTE
+};
+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, "")).replace(/\\(["'])/g, "$1").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);
 }
@@ -22281,11 +22489,26 @@ function bumpLastUpdated(html, date) {
   return { html: html.replace(re, `$1${formatted}`), bumped: true };
 }
 function leadingIdentification(html) {
+  return leadingIdentityText(html)?.includes("\xB7") ?? false;
+}
+function leadingIdentityText(html) {
   const m = /^(?:\s|<p>(?:\s|&nbsp;)*<\/p>)*<h3(?:\s[^>]*)?>([\s\S]*?)<\/h3>/i.exec(html);
-  if (!m)
-    return false;
-  const text = decodeEntities(m[1].replace(/<[^>]+>/g, "")).trim();
-  return text.includes("\xB7");
+  return m ? decodeEntities(m[1].replace(/<[^>]+>/g, "")).trim() : null;
+}
+function identityProblem(text) {
+  const line = text.trim();
+  if (/[\r\n]/.test(line))
+    return "it spans several lines";
+  if (line.length > 160)
+    return `it is ${line.length} characters long (160 at most)`;
+  if (/^addendum\b/i.test(line))
+    return "it is an addendum marker, not an identity";
+  if (/\?/.test(line))
+    return "it carries a question mark, which reads as a draft";
+  const parts = line.split("\xB7").map((p) => p.trim());
+  if (parts.length < 3 || parts.some((p) => !p))
+    return `it has ${parts.filter(Boolean).length} "\xB7"-separated part(s); it needs at least three`;
+  return null;
 }
 function duplicateHeadings(html) {
   const MARKER = /<h2(?:\s[^>]*)?>\s*(?:Addendum|Withdrawn|Recovered|Reopened)\s*(?:\u2014|\u2013|-)[^<]*<\/h2>/gi;
@@ -22582,11 +22805,38 @@ function unbalancedTags(html) {
   }
   return [...new Set(stack)];
 }
+function tableShapeIssues(html) {
+  const issues = [];
+  const cellSpan = (attrs) => Number(/colspan\s*=\s*"?(\d+)/i.exec(attrs ?? "")?.[1] ?? 1);
+  for (const table of html.matchAll(/<table\b[^>]*>([\s\S]*?)<\/table>/gi)) {
+    const rows = [...table[1].matchAll(/<tr\b[^>]*>([\s\S]*?)<\/tr>/gi)].map((r) => [...r[1].matchAll(/<(t[hd])\b([^>]*)>([\s\S]*?)<\/\1>/gi)].map((c) => ({
+      span: cellSpan(c[2]),
+      text: decodeEntities(c[3].replace(/<[^>]+>/g, "")).trim()
+    })));
+    if (rows.length < 2)
+      continue;
+    const width = rows[0].reduce((sum, c) => sum + c.span, 0);
+    for (const cells of rows.slice(1)) {
+      const label = (cells[0]?.text ?? "").slice(0, 60) || "(empty row)";
+      const count = cells.reduce((sum, c) => sum + c.span, 0);
+      if (count !== width) {
+        issues.push(`row "${label}" has ${count} cell(s), its header has ${width}`);
+        continue;
+      }
+      const piped = cells.find((c) => (c.text.match(/\s\|\s/g)?.length ?? 0) >= Math.max(1, width - 2) && width > 1);
+      if (piped && cells.filter((c) => c.text).length < width) {
+        issues.push(`row "${label}" carries pipe-separated values inside one cell \u2014 send each value as its own <td>`);
+      }
+    }
+  }
+  return issues;
+}
 var LARGE_NOTE_CHARS = 40000;
 function structureReport(html) {
   return {
     duplicateHeadings: duplicateHeadings(html),
     unbalancedTags: unbalancedTags(html),
+    tableShape: tableShapeIssues(html),
     size: html.length
   };
 }
@@ -23136,8 +23386,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 +23654,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");
@@ -23417,6 +23670,9 @@ async function sweep(trilium, cfg, opts = {}) {
     if (structure.unbalancedTags.length) {
       report.flagged.push(`unbalanced tags: ${n.title} [${n.noteId}] \u2014 <${structure.unbalancedTags.join(">, <")}> left open; the next write will auto-close them, or fix now with revise(mode=replace)`);
     }
+    if (structure.tableShape.length) {
+      report.flagged.push(`table shape: ${n.title} [${n.noteId}] \u2014 ${structure.tableShape.slice(0, 3).join("; ")}${structure.tableShape.length > 3 ? ` (+${structure.tableShape.length - 3} more)` : ""}. Rewrite the row with one <td> per column: revise(find=<anchor>, within="tr")`);
+    }
     const profile = sectionProfile(content);
     const biggest = profile.largest[0];
     const crowded = profile.count >= SECTION_EDIT_RISK_COUNT;
@@ -23489,13 +23745,15 @@ async function sweep(trilium, cfg, opts = {}) {
           byDomain.get(domSlug).push(n);
         }
         const headingCache = new Map;
-        const headingsOf = async (n) => {
+        const shapeOf = async (n) => {
           if (!headingCache.has(n.noteId)) {
             const content = await trilium.getNoteContent(n.noteId).catch(() => "");
-            headingCache.set(n.noteId, headingOutline(content).filter((h) => h.level <= 3).map((h) => h.text));
+            const words = new Set(content.replace(/<[^>]+>/g, " ").toLowerCase().split(/[^a-z0-9]+/).filter((w) => w.length > 3));
+            headingCache.set(n.noteId, { headings: headingOutline(content).filter((h) => h.level <= 3).map((h) => h.text), words });
           }
           return headingCache.get(n.noteId);
         };
+        const GENERIC_HEADING = /^(last updated\b.*|overview|context|goal|sources|revision|resolution|notes?|summary)$/i;
         for (const [domSlug, notes] of byDomain) {
           const reported = new Set;
           for (let i = 0;i < notes.length; i++) {
@@ -23512,10 +23770,19 @@ async function sweep(trilium, cfg, opts = {}) {
               reported.add(pairKey);
               if (acknowledged(a) || acknowledged(bn))
                 continue;
-              const [ha, hb] = await Promise.all([headingsOf(a), headingsOf(bn)]);
-              const overlap = ha.filter((h) => hb.some((x) => x.toLowerCase() === h.toLowerCase()));
+              const [sa, sb] = await Promise.all([shapeOf(a), shapeOf(bn)]);
+              const ha = sa.headings, hb = sb.headings;
+              const overlap = ha.filter((h) => !GENERIC_HEADING.test(h) && hb.some((x) => x.toLowerCase() === h.toLowerCase()));
+              let common = 0;
+              for (const w of sa.words)
+                if (sb.words.has(w))
+                  common++;
+              const union = sa.words.size + sb.words.size - common;
+              const similarity = union ? common / union : 0;
+              if (!overlap.length && similarity < 0.45)
+                continue;
               const show = (h) => h.length ? h.slice(0, 8).join(" \xB7 ") + (h.length > 8 ? " \xB7 \u2026" : "") : "(no headings)";
-              report.flagged.push(`near-duplicate subject: '${a.title}' [${a.noteId}] and '${bn.title}' [${bn.noteId}] in Domain/${domSlug} ` + `share '${shared.join("', '")}'. Sections \u2014 '${a.title}': ${show(ha)} | '${bn.title}': ${show(hb)}. ` + (overlap.length ? `${overlap.length} heading(s) in common (${overlap.slice(0, 5).join(", ")}), which is what a genuine split subject looks like \u2014 read both, merge into the older one, and forget() the other.` : `No headings in common, so these are most likely distinct notes that happen to share a title word \u2014 maintain(ack=["${a.noteId}"]) to silence this once you have confirmed it.`));
+              report.flagged.push(`near-duplicate subject: '${a.title}' [${a.noteId}] and '${bn.title}' [${bn.noteId}] in Domain/${domSlug} ` + `share '${shared.join("', '")}' and ${Math.round(similarity * 100)}% of their vocabulary. Sections \u2014 '${a.title}': ${show(ha)} | '${bn.title}': ${show(hb)}. ` + (overlap.length ? `${overlap.length} heading(s) in common (${overlap.slice(0, 5).join(", ")}), which is what a genuine split subject looks like \u2014 read both, merge into the older one, and forget() the other.` : `No headings in common, but most of their wording is shared \u2014 read both; if they are distinct, maintain(ack=["${a.noteId}"]) silences this.`));
             }
           }
         }
@@ -23915,6 +24182,96 @@ async function catchUpDeletions(trilium, cfg, today) {
   return { windowDays, coverage: "full", deletionsFound: total, regenerated };
 }
 
+// src/seal.ts
+import { createHash } from "crypto";
+var GENESIS = "genesis";
+function sealText(html) {
+  return decodeEntities(html.replace(/<[^>]+>/g, " ")).replace(/\s+/g, " ").trim();
+}
+function sha(text) {
+  return createHash("sha256").update(text, "utf8").digest("hex");
+}
+function sealRecord(text) {
+  return [text.length, sha(text).slice(0, 16)];
+}
+function dayDigest(prev, date, records) {
+  const canonical = Object.keys(records).sort().map((id) => `${id}:${records[id][0]}:${records[id][1]}`).join(",");
+  return sha(`${prev}
+${date}
+${canonical}`);
+}
+function recordIntact(current, sealed) {
+  if (current.length < sealed[0])
+    return false;
+  return sha(current.slice(0, sealed[0])).slice(0, 16) === sealed[1];
+}
+async function dayRecords(trilium, cfg, date) {
+  const find = (ancestor, kind) => ancestor ? trilium.searchNotes(`#noteType=${kind} #created='${date}'`, { ancestorNoteId: ancestor, fastSearch: true, limit: 200, includeArchivedNotes: true }).then((r) => r.results).catch(() => []) : Promise.resolve([]);
+  const [sessions, diary, entries] = await Promise.all([
+    find(cfg.memory.sessions, "session"),
+    find(cfg.llm.diary, "diary"),
+    find(cfg.memory.threads, "threadEntry")
+  ]);
+  return [...sessions, ...diary, ...entries.filter((n) => n.title.trim() === `[${date}]`)];
+}
+async function sealedLogs(trilium, cfg) {
+  if (!cfg.insights.logs)
+    return [];
+  const res = await trilium.searchNotes("#noteType=log #seal", { ancestorNoteId: cfg.insights.logs, fastSearch: true, limit: 1000, includeArchivedNotes: true }).catch(() => ({ results: [] }));
+  return res.results.filter((n) => ownedLabel(n, "seal")).sort((a, b) => (ownedLabel(a, "created") ?? "").localeCompare(ownedLabel(b, "created") ?? ""));
+}
+async function sealDay(trilium, cfg, date, logNoteId) {
+  const earlier = (await sealedLogs(trilium, cfg)).filter((n) => (ownedLabel(n, "created") ?? "") < date);
+  const prev = earlier.length ? ownedLabel(earlier[earlier.length - 1], "seal") : GENESIS;
+  const records = {};
+  for (const n of await dayRecords(trilium, cfg, date)) {
+    const content = await trilium.getNoteContent(n.noteId).catch(() => "");
+    if (content)
+      records[n.noteId] = sealRecord(sealText(content));
+  }
+  const digest = dayDigest(prev, date, records);
+  await trilium.updateLabelValue(logNoteId, "sealRecords", JSON.stringify(records));
+  await trilium.updateLabelValue(logNoteId, "sealPrev", prev);
+  await trilium.updateLabelValue(logNoteId, "seal", digest);
+  return { date, digest, records: Object.keys(records).length };
+}
+async function verifySeals(trilium, cfg, today, days = 7) {
+  const logs = (await sealedLogs(trilium, cfg)).filter((n) => (ownedLabel(n, "created") ?? "") < today);
+  const findings = [];
+  const window = logs.slice(-days);
+  for (const log of window) {
+    const date = ownedLabel(log, "created") ?? "";
+    const digest = ownedLabel(log, "seal") ?? "";
+    const prev = ownedLabel(log, "sealPrev") ?? "";
+    const i = logs.indexOf(log);
+    const expectedPrev = i > 0 ? ownedLabel(logs[i - 1], "seal") ?? "" : prev;
+    if (prev !== expectedPrev) {
+      findings.push({ date, noteId: log.noteId, problem: `the chain breaks here \u2014 this seal links to ${prev.slice(0, 12)}\u2026, but the previous sealed day's digest is ${expectedPrev.slice(0, 12)}\u2026` });
+    }
+    let records;
+    try {
+      records = JSON.parse(ownedLabel(log, "sealRecords") ?? "{}");
+    } catch {
+      findings.push({ date, noteId: log.noteId, problem: "the sealed record list is unreadable" });
+      continue;
+    }
+    if (dayDigest(prev, date, records) !== digest) {
+      findings.push({ date, noteId: log.noteId, problem: "the sealed record list no longer matches its digest \u2014 the seal labels were edited" });
+    }
+    for (const [noteId, sealed] of Object.entries(records)) {
+      const content = await trilium.getNoteContent(noteId).catch(() => null);
+      if (content === null) {
+        findings.push({ date, noteId, problem: "a sealed record is gone (deleted or unreadable)" });
+        continue;
+      }
+      if (!recordIntact(sealText(content), sealed)) {
+        findings.push({ date, noteId, problem: "a sealed record was changed after its day was sealed \u2014 its sealed text is no longer the start of its body. diff(noteId) and the note's revisions show what changed" });
+      }
+    }
+  }
+  return { checked: window.length, findings };
+}
+
 // src/diffing.ts
 function revisionsSince(revisions, cutoff) {
   return revisions.filter((r) => (r.dateCreated ?? "").slice(0, 16) >= cutoff);
@@ -23942,8 +24299,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 +24313,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 +24351,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 +24493,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 +24508,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 +24600,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 +24648,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 +24678,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 +24810,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);
@@ -24406,6 +24873,8 @@ function registerTools(server, trilium, brainRef) {
   const preCloseSteps = new Map;
   let preCloseSeq = 0;
   const REQUIRED_PRECLOSE_STEPS = ["session", "addendum", "maintain", "remarks", "diary"];
+  const LIGHT_PRECLOSE_STEPS = ["session", "remarks", "diary"];
+  let wroteSinceClose = false;
   const gateNote = async (date) => {
     const cfg = b();
     if (!cfg.memory.sessions)
@@ -24464,6 +24933,7 @@ function registerTools(server, trilium, brainRef) {
     await trilium.updateLabelValue(noteId, "gate", "");
     preCloseSteps.clear();
     preCloseSeq = 0;
+    wroteSinceClose = false;
   };
   const RECORD_KINDS = new Set(["session", "diary", "log", "threadEntry"]);
   const isRecordNote = (n) => {
@@ -24473,16 +24943,30 @@ function registerTools(server, trilium, brainRef) {
     return kind === "threadEntry" && /^\[\d{4}-\d{2}-\d{2}\]$/.test(n.title.trim());
   };
   const structuralFindings = (kind, html) => {
-    if (!html || kind && RECORD_KINDS.has(kind))
+    if (!html)
       return {};
+    const tableShape = tableShapeIssues(html);
+    const shape = tableShape.length ? { tableShape, tableHint: 'A table row disagrees with its header \u2014 rewrite it with one <td> per column (revise(find=<anchor>, within="tr")).' } : {};
+    if (kind && RECORD_KINDS.has(kind))
+      return shape;
     const dupes = duplicateHeadings(html);
     if (!dupes.length)
-      return {};
+      return shape;
     return {
       duplicateHeadings: dupes,
-      structureHint: "The note now carries duplicated section headings \u2014 merge them with revise(section=\u2026, mode=replace), or target one specifically with occurrence=."
+      structureHint: "The note now carries duplicated section headings \u2014 merge them with revise(section=\u2026, mode=replace), or target one specifically with occurrence=.",
+      ...shape
     };
   };
+  const identityRefusal = (identity, html) => {
+    const text = leadingIdentification(html) ? leadingIdentityText(html) : identity;
+    if (!text)
+      return null;
+    const problem = identityProblem(text);
+    if (!problem)
+      return null;
+    return err("malformed_identity", `The identification line "${text.slice(0, 100)}" is malformed: ${problem}. Nothing was written.`, 'Pass identity="LLM \xB7 environment \xB7 agent/mode [\xB7 Run N]", e.g. "Claude Opus 5.5 \xB7 Claude Code \xB7 Interactive".');
+  };
   const applyIcon = async (noteId, icon) => {
     const cls = icon ? normalizeIcon(icon) : "";
     if (!cls) {
@@ -24540,7 +25024,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 +25117,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. A session that wrote no content gets a light close: session() returns only the short next[] (remarks, a one-paragraph diary, close) and close() does not require addendum() or maintain().`, {
     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")`),
@@ -24645,6 +25129,19 @@ Protocol: 1. update master singletons with what the session taught about the use
     const cfg = b();
     if (!cfg.master.root || !cfg.llm.root)
       throw new Error("BrainLLM not bootstrapped \u2014 run bootstrap.");
+    if (!(await readGate(d)).has("write")) {
+      await markStep("session", d);
+      return txt3({
+        date: d,
+        closeMode: "light",
+        note: "No content was written this session, so addendum() and maintain() are not required and there is nothing to audit. If you learned something durable about the user or yourself, revise that singleton first \u2014 that makes it a full close, and session() will say so when re-run.",
+        next: [
+          "Call remarks() \u2014 one short cue for a short session.",
+          "Call diary() \u2014 one short paragraph: what the session was and anything worth the team knowing.",
+          "Call close() \u2014 commit the session log."
+        ]
+      });
+    }
     const fetchSingleton = async (id) => {
       if (!full) {
         const note = await trilium.getNote(id);
@@ -24693,6 +25190,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 +25213,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,16 +25233,23 @@ 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." });
     await markStep("remarks");
+    if (!(await readGate(localToday())).has("write")) {
+      return txt3({
+        closeMode: "light",
+        cue: "One short paragraph, first person: what this session was, how it went, and anything about BrainLLM worth the team knowing. Skip what has nothing real to say.",
+        next: ["Write it via diary(body, identity), then call close()."]
+      });
+    }
     return txt3({
       cues: {
         experience: [
@@ -24754,7 +25270,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; a session that wrote no content (light close) needs only session(), remarks() and diary() (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)`),
@@ -24777,9 +25293,11 @@ Protocol: 1. update master singletons with what the session taught about the use
       }
     }
     const gate = await readGate(gateDate);
-    const missing = continued ? [] : REQUIRED_PRECLOSE_STEPS.filter((step) => !gate.has(step));
+    const light = !gate.has("write");
+    const required = light ? LIGHT_PRECLOSE_STEPS : REQUIRED_PRECLOSE_STEPS;
+    const missing = continued ? [] : required.filter((step) => !gate.has(step));
     if (missing.length && !force) {
-      return err("preclose_incomplete", `close() refused \u2014 these pre-close steps haven't run yet this session: ${missing.join(", ")}.`, `Call ${missing.map((s) => `${s}()`).join(", ")} first, or pass force=true if one of them genuinely has nothing to log.`);
+      return err("preclose_incomplete", `close() refused \u2014 these pre-close steps haven't run yet this session: ${missing.join(", ")}.${light ? " (No content was written this session, so addendum() and maintain() are not required.)" : ""}`, `Call ${missing.map((s) => `${s}()`).join(", ")} first, or pass force=true if one of them genuinely has nothing to log.`);
     }
     const seq = (step) => gate.get(step) ?? 0;
     const orderOk = continued || missing.length > 0 || seq("session") < seq("remarks") && seq("remarks") < seq("diary");
@@ -24795,6 +25313,9 @@ Protocol: 1. update master singletons with what the session taught about the use
     if (!identity && !leadingIdentification(summaryHtml)) {
       return err("missing_identity", 'Session addendums open with the canonical identification line (h3): "LLM \xB7 environment \xB7 agent/mode [\xB7 Run N]".', `Pass identity="Claude \u2026 \xB7 <environment> \xB7 <agent/mode>" on close() \u2014 the server renders it as the block's h3.`);
     }
+    const badIdentity = identityRefusal(identity, summaryHtml);
+    if (badIdentity)
+      return badIdentity;
     const identityBlock = identity && !leadingIdentification(summaryHtml) ? `<h3>${escapeHtml(identity)}</h3>
 ` : "";
     const titleBlock = title ? `<h2>${escapeHtml(title)}</h2>
@@ -24849,6 +25370,7 @@ ${contentBlock}` }));
       if (!hasEdge(logNote, noteId))
         await trilium.addRelation(logReport.noteId, "references", noteId).catch(() => null);
     }
+    const sealReport = logReport?.noteId ? await sealDay(trilium, cfg, d, logReport.noteId).catch(() => null) : null;
     let backupStatus = "disabled";
     let backupName = rollingBackupName(d);
     if (backup !== false) {
@@ -24870,6 +25392,8 @@ ${contentBlock}` }));
       ...caughtUp?.coverage === "unknown" ? { deletionCatchUp: "unknown \u2014 Trilium's deletion history could not be read; the configured catch-up window is not fully verified" } : caughtUp && caughtUp.deletionsFound ? { deletionCatchUp: `${caughtUp.deletionsFound} deletion(s) caught up \u2014 logs regenerated for: ${caughtUp.regenerated.join(", ")}` } : {},
       ...iconSet ? { icon: iconSet } : {},
       ...continued ? { continuing: true } : {},
+      ...sealReport ? { seal: `${sealReport.records} record(s) of ${d} sealed (${sealReport.digest.slice(0, 12)}\u2026), chained to the previous sealed day` } : { seal: "not written \u2014 the day's log note was unavailable" },
+      ...light && !continued ? { closeMode: "light \u2014 no content was written this session, so addendum() and maintain() were not required" } : {},
       ...missing.length || !orderOk ? { bypassed: [...missing, ...!orderOk ? ["ordering(session\u2192remarks\u2192diary)"] : []] } : {},
       ...warnings.length ? { sanitized: warnings } : {}
     });
@@ -24881,13 +25405,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)")
@@ -24902,6 +25491,9 @@ ${contentBlock}` }));
     if (!identity && !leadingIdentification(sanitized.html)) {
       return err("missing_identity", 'Diary addendums open with the canonical identification line (h3): "LLM \xB7 environment \xB7 agent/mode [\xB7 Run N]".', `Pass identity="Claude \u2026 \xB7 <environment> \xB7 <agent/mode>" on diary() \u2014 the server renders it as the block's h3.`);
     }
+    const badIdentity = identityRefusal(identity, sanitized.html);
+    if (badIdentity)
+      return badIdentity;
     const html = identity && !leadingIdentification(sanitized.html) ? `<h3>${escapeHtml(identity)}</h3>
 ${sanitized.html}` : sanitized.html;
     const found = await trilium.searchNotes(`#noteType=diary #created='${d}'`, { ancestorNoteId: parentId, fastSearch: true, limit: 1 });
@@ -25084,7 +25676,8 @@ Collection kinds dedup by title \u2014 mustCreate=true refuses instead of adopti
         ...createdDomain ? { createdDomain: domainTitle } : {},
         ...revisionChanges.length ? { revision: revisionChanges } : {},
         ...sourceMerge,
-        ...revisionKeys.length ? { revisionRows: revisionKeys } : {},
+        ...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." } : {},
         ...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." } : {},
         ...connected.length ? { connected } : {},
@@ -25182,6 +25775,9 @@ Collection kinds dedup by title \u2014 mustCreate=true refuses instead of adopti
       if (kind === "thread" && !identity && !leadingIdentification(html)) {
         return err("missing_identity", 'Thread addendums open with the canonical identification line (h3): "LLM \xB7 environment \xB7 agent/mode [\xB7 Run N]".', `Pass identity="Claude \u2026 \xB7 <environment> \xB7 <agent/mode>" \u2014 the server renders it as the addendum's h3.`);
       }
+      const badIdentity = identityRefusal(identity, html);
+      if (badIdentity)
+        return badIdentity;
       const block = identity && !leadingIdentification(html) ? `<h3>${escapeHtml(identity)}</h3>
 ${html}` : html;
       if (kind === "thread") {
@@ -25201,7 +25797,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, 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: `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))
@@ -25265,7 +25861,7 @@ ${block}`), d);
       ...sanitizeWarnings.length ? { sanitized: sanitizeWarnings } : {}
     });
   });
-  server.tool("recall", `Ranked search across the whole brain \u2014 label, title and full-text strategies merged, with kind and status. Pass domain= whenever you know the area. orderBy/orderDirection sort by date; fastSearch= scans titles and labels only; regex= matches note bodies with a real regular expression; a fuzzy pass runs automatically when exact results are thin (hits marked fuzzy: true are leads, not answers). includeArchived= includes archived notes. A thin result is evidence about the query, not the brain.`, {
+  server.tool("recall", `Ranked search across the whole brain \u2014 label, title and full-text strategies merged, with kind and status. Pass domain= whenever you know the area. orderBy/orderDirection sort by date; fastSearch= scans titles and labels only; regex= matches note bodies with a real regular expression; a fuzzy pass runs automatically when exact results are thin (hits marked fuzzy: true are leads, not answers). Recently changed notes rank slightly higher at equal relevance. Regex hits carry evidence: the matched passage; records are included unless kinds= narrows. includeArchived= includes archived notes. A thin result is evidence about the query, not the brain.`, {
     query: stringType().describe("What to find \u2014 natural phrasing is fine"),
     kinds: arrayType(enumType(Kinds)).optional().describe("Restrict to these kinds"),
     domain: stringType().optional().describe("Restrict to a knowledge domain"),
@@ -25328,10 +25924,21 @@ ${block}`), d);
       } catch (e) {
         return err("invalid_pattern", `Not a valid regular expression: ${e.message}`, "Escape backslashes \u2014 a JSON string needs \\\\d for \\d.");
       }
-      const candidates = (await run(`note.content %= '${escapeQueryRegex(regex)}'`)).filter(filterNote);
+      const backendPattern = triliumSearchForm(regex);
+      const widened = backendPattern !== regex;
+      const candidates = (await run(`note.content %= '${escapeQueryRegex(backendPattern)}'`)).filter(filterNote);
       const confirmed = [];
       let rejected = 0;
       let tagSpanning = 0;
+      let recordHits = 0;
+      const evidenceIn = (text) => {
+        const m = new RegExp(re.source, "i").exec(text);
+        if (!m)
+          return "";
+        const from = Math.max(0, m.index - 80);
+        const to = Math.min(text.length, m.index + m[0].length + 80);
+        return `${from > 0 ? "\u2026" : ""}${text.slice(from, to).replace(/\s+/g, " ").trim()}${to < text.length ? "\u2026" : ""}`;
+      };
       for (const n of candidates) {
         if (confirmed.length >= max)
           break;
@@ -25341,18 +25948,28 @@ ${block}`), d);
           continue;
         }
         const rawHit = re.test(content);
-        const projectedHit = !rawHit && re.test(stripTagsWithMap(content).text);
+        const projected = stripTagsWithMap(content).text;
+        const projectedHit = re.test(projected);
         if (rawHit || projectedHit) {
-          if (projectedHit)
+          if (projectedHit && !rawHit)
             tagSpanning++;
-          confirmed.push(n);
+          const kind = labelOf2(n, "noteType");
+          if (kind === "session" || kind === "diary" || kind === "log" || kind === "threadEntry" && /^\[\d{4}-\d{2}-\d{2}\]$/.test(n.title.trim()))
+            recordHits++;
+          confirmed.push({ note: n, evidence: decodeEntities(projectedHit ? evidenceIn(projected) : evidenceIn(toText(content, 1e5))) });
         } else
           rejected++;
       }
-      const results = await Promise.all(confirmed.map(buildResult));
+      const results = await Promise.all(confirmed.map(async ({ note, evidence }, i) => {
+        const { snippet: _snippet, ...base } = await buildResult(note, i);
+        return { ...base, ...evidence ? { evidence } : {} };
+      }));
       const notes = [
         rejected ? `${rejected} backend candidate(s) did not actually match the pattern and were dropped \u2014 results are verified against the real regex, not just the search index.` : null,
         tagSpanning ? `${tagSpanning} match(es) were found only after stripping markup \u2014 the phrase is split by an inline tag there.` : null,
+        widened ? "Diacritic characters (\xB7, accents) were normalised away for Trilium's pre-filter, which strips them from note text before matching; every result was then verified against your exact pattern." : null,
+        recordHits ? `${recordHits} result(s) are records (sessions, diary, dated thread entries) \u2014 included by default; kinds= narrows to maintained notes.` : null,
+        candidates.length >= 30 && confirmed.length < max ? "The backend returned its 30-candidate cap, so further matches may exist \u2014 narrow with domain= or kinds=, or use consistency() for an exhaustive scan." : null,
         results.length === 0 ? "No bodies matched that pattern, searched both as stored HTML and tag-stripped. Note that Trilium's %= pre-filter reads a striptags'd copy, so a pattern anchored ON tags may never reach verification \u2014 consistency() scans exhaustively if you need certainty." : null,
         results.length === 0 && regex.includes("\\") ? `The pattern reached the server as /${regex}/i. In it, \\d is a digit and \\\\ is one literal backslash (a Windows path separator); a backslash doubled once too often matches a literal backslash instead of escaping. If that is not the pattern you meant, adjust the escaping and retry.` : null
       ].filter(Boolean);
@@ -25413,7 +26030,12 @@ ${block}`), d);
           fuzzyIds.add(n.noteId);
       add(byFuzzy, 0.5);
     }
-    const ranked = [...scores.values()].filter(({ note }) => filterNote(note)).sort((a, b2) => b2.score - a.score || (a.note.dateModified < b2.note.dateModified ? 1 : -1)).slice(0, max);
+    const now = Date.now();
+    const recency = (n) => {
+      const age = Math.max(0, (now - new Date(n.dateModified.replace(" ", "T")).getTime()) / 86400000);
+      return Number.isFinite(age) ? 0.9 * Math.pow(0.5, age / 14) : 0;
+    };
+    const ranked = [...scores.values()].filter(({ note }) => filterNote(note)).map((s) => ({ ...s, rank: s.score + recency(s.note) })).sort((a, b2) => b2.rank - a.rank || (a.note.dateModified < b2.note.dateModified ? 1 : -1)).slice(0, max);
     const results = await Promise.all(ranked.map(async ({ note }, i) => {
       const row = await buildResult(note, i);
       return fuzzyIds.has(note.noteId) ? { ...row, fuzzy: true } : row;
@@ -25425,10 +26047,11 @@ ${block}`), d);
       ...results.length === 0 ? noMatch : {}
     });
   });
-  server.tool("domain", `Everything for a domain, topic or project: its knowledge book (if any) plus every note carrying a matching #domain or #topic slug, grouped by kind, each with idle days and a stale flag. The reliable retrieval path for an area; use recall() for keyword search.`, {
+  server.tool("domain", `Everything for a domain, topic or project: its knowledge book (if any) plus every note carrying a matching #domain or #topic slug, grouped by kind, each with idle days and a stale flag; outline=true adds every maintained note's headings and size. The reliable retrieval path for an area; use recall() for keyword search.`, {
     name: stringType().describe("Domain, topic, or project name"),
-    includeArchived: booleanType().optional().describe("Include archived/resolved items (default: false)")
-  }, async ({ name, includeArchived }) => {
+    includeArchived: booleanType().optional().describe("Include archived/resolved items (default: false)"),
+    outline: booleanType().optional().describe("Also return each maintained note's headings (h2\u2013h4) and size \u2014 plan a multi-note rewrite in one call instead of one outline() per note")
+  }, async ({ name, includeArchived, outline }) => {
     const cfg = b();
     const slug = slugify(name);
     const CAP = 500;
@@ -25455,6 +26078,19 @@ ${block}`), d);
     const staleAfter = cfg.policy.staleAfterDays;
     const idleSince = (iso) => Math.max(0, Math.floor((Date.now() - new Date(iso.replace(" ", "T")).getTime()) / 86400000));
     const RECORD_ROWS = new Set(["session", "diary", "log", "threadEntry"]);
+    const outlines = new Map;
+    if (outline) {
+      await Promise.all(all.filter((n) => {
+        const k = ownedLabel(n, "noteType");
+        return k && k !== "domain" && !RECORD_ROWS.has(k);
+      }).map(async (n) => {
+        const content = await trilium.getNoteContent(n.noteId).catch(() => "");
+        outlines.set(n.noteId, {
+          headings: headingOutline(content).filter((h) => !/^Last updated\b/i.test(h.text)).map((h) => `${"#".repeat(h.level - 1)} ${h.text}`),
+          size: content.length
+        });
+      }));
+    }
     const groups = {};
     let staleCount = 0;
     for (const n of all) {
@@ -25478,7 +26114,8 @@ ${block}`), d);
         ...stale ? { stale: true } : {},
         ...hasLabel(n, "mandate") ? { mandate: true } : {},
         ...hasLabel(n, "archived") ? { archived: true } : {},
-        ...relations ? { relations } : {}
+        ...relations ? { relations } : {},
+        ...outlines.has(n.noteId) ? outlines.get(n.noteId) : {}
       });
     }
     const total = all.filter((n) => {
@@ -25508,19 +26145,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 +26169,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.
+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. 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. 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). closure={thread, body} with within="tr" and mode="remove" closes a register row: the row is removed and the closure appended to that thread's entry for today, in one call. "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.`, {
-    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"),
@@ -25545,6 +26274,10 @@ Check the receipt: matched=false means a NEW section was written (available= lis
     find: stringType().optional().describe("Exact raw string to replace throughout the body with body= \u2014 targeted surgery without a read+full-replace. Takes precedence over section/mode."),
     nth: numberType().int().positive().optional().describe("find=: replace only the Nth occurrence, 1-based (default: all of them). With within=: the Nth containing element"),
     within: enumType(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'),
+    closure: objectType({
+      thread: stringType().describe('The dated thread to record the closure in: its id or title (e.g. "Escalations")'),
+      body: stringType().describe("The closure: what settled it, who ruled, and where its durable substance went")
+    }).optional().describe(`With within= and mode="remove": close a register row in one call. The row is removed and body= is appended to the thread's entry for today, quoting the removed row. Needs identity=. Run consistency() afterwards on any fact the row asserted elsewhere`),
     edits: arrayType(objectType({
       find: stringType().describe("Exact raw string to replace"),
       body: stringType().describe("Raw replacement string"),
@@ -25553,7 +26286,23 @@ 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, closure, edits, identity, icon, date, strict }) => {
+    if (closure && !(within && mode === "remove"))
+      return err("conflicting_params", 'closure= closes a register row and needs within= with mode="remove"; nothing was written.', 'e.g. revise(noteId, find="<row anchor>", within="tr", mode="remove", closure={thread: "Escalations", body: "Closed on \u2026"}, identity="\u2026")');
+    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,46 +26349,19 @@ 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.`;
+        if (/Last updated/i.test(needle))
+          return `Not found \u2014 "Last updated" lines are server-owned and every content write bumps them to today, so this one most likely already moved. Leave it out of find=; the server keeps it current.`;
         if (looksEntityEscaped(needle))
           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.`;
+        const closed = closedBlockTag(needle);
+        if (closed && !within)
+          return `Not found \u2014 the string ends inside a closing </${closed}>, and where the editor stored that tag decides whether it matches. Use within="${closed}" with a short plain-text anchor from inside the element instead: revise(noteId, find="<a few words>", within="${closed}", body="<${closed}>\u2026</${closed}>").`;
+        return `Not found in the note body (exact, attribute-tolerant, ignoring inline tags${within ? `, or by the visible text of a <${within}>` : ""}) \u2014 already replaced on a retry, or the text genuinely differs.${within ? "" : ' To act on a whole table row by its visible text, use within="tr".'}`;
       };
       const missContext = (needle, source) => {
         const near = nearestContext(source, needle);
@@ -25658,7 +26380,10 @@ 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 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);
         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.`;
@@ -25676,6 +26401,26 @@ Check the receipt: matched=false means a NEW section was written (available= lis
         }
         if (res.html === current)
           return txt3({ ok: true, noteId, mode: `within:${within}:${action}`, unchanged: true, date: d, note: "The body equals the element it would replace, so nothing was written and no revision was taken." });
+        let closureThread = null;
+        let closureBlock = "";
+        if (closure) {
+          closureThread = /^[A-Za-z0-9]{12}$/.test(closure.thread) ? await trilium.getNote(closure.thread).catch(() => null) : await findExisting("thread", closure.thread);
+          if (!closureThread || ownedLabel(closureThread, "noteType") !== "thread")
+            return err("not_found", `closure.thread "${closure.thread}" is not a thread; nothing was written.`, `Pass the thread's id or exact title, e.g. "Escalations".`);
+          if (isCollectionThread(closureThread))
+            return collectionAppendRefusal(closureThread);
+          const rendered = renderBody(closure.body).html;
+          const removedText = toText(res.element, 400);
+          const closureHtml = `<p><strong>Closed:</strong> ${escapeHtml(removedText)}</p>
+${rendered}`;
+          if (!identity)
+            return err("missing_identity", "closure= appends to a dated thread, which needs identity=; nothing was written.", 'Pass identity="LLM \xB7 environment \xB7 agent/mode".');
+          const badIdentity = identityRefusal(identity, closureHtml);
+          if (badIdentity)
+            return badIdentity;
+          closureBlock = `<h3>${escapeHtml(identity)}</h3>
+${closureHtml}`;
+        }
         await trilium.createRevision(noteId).catch(() => null);
         const withinResult = sanitizeHtml(res.html);
         const stampedWithin = bumpLastUpdated(withinResult.html, d);
@@ -25686,16 +26431,32 @@ Check the receipt: matched=false means a NEW section was written (available= lis
         if (labelOf2(note, "status") === "dormant")
           await trilium.updateLabelValue(noteId, "status", "active");
         const relsWithin = relationSnippet(note);
+        let closureReceipt = null;
+        if (closureThread) {
+          const entry = await appendThreadEntry(closureThread.noteId, closureBlock, d);
+          await trilium.updateLabelValue(closureThread.noteId, "updated", d);
+          if (labelOf2(closureThread, "status") === "dormant")
+            await trilium.updateLabelValue(closureThread.noteId, "status", "active");
+          closureReceipt = {
+            threadId: closureThread.noteId,
+            thread: closureThread.title,
+            entryId: entry.noteId,
+            action: entry.action,
+            next: "Run consistency() on any fact the closed row asserted elsewhere, so no stale sentence survives it."
+          };
+        }
         return txt3({
           ok: true,
           noteId,
           mode: `within:${within}:${action}`,
           date: d,
           element: toText(res.element, 200),
+          ...closureReceipt ? { closure: closureReceipt } : {},
           ...titledWithin.retitled ? { retitled: titledWithin.retitled } : {},
           ...iconWithin ? { icon: iconWithin } : {},
           ...relsWithin ? { relations: relsWithin } : {},
           ...structuralFindings(noteKind, stampedWithin.html),
+          ...stampedWithin.bumped ? { lastUpdated: "bumped to today \u2014 the line is server-owned" } : {},
           ...withinResult.warnings.length ? { sanitized: withinResult.warnings } : {}
         });
       }
@@ -25704,7 +26465,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({
@@ -25775,6 +26536,7 @@ Check the receipt: matched=false means a NEW section was written (available= lis
         ...iconApplied ? { icon: iconApplied } : {},
         ...rels ? { relations: rels } : {},
         ...structure,
+        ...stamped.bumped ? { lastUpdated: "bumped to today \u2014 the line is server-owned" } : {},
         ...replacedResult.warnings.length ? { sanitized: replacedResult.warnings } : {}
       });
     }
@@ -25867,6 +26629,9 @@ Check the receipt: matched=false means a NEW section was written (available= lis
         if (!identity && !leadingIdentification(html)) {
           return err("missing_identity", 'Thread addendums open with the canonical identification line (h3): "LLM \xB7 environment \xB7 agent/mode [\xB7 Run N]".', `Pass identity="Claude \u2026 \xB7 <environment> \xB7 <agent/mode>" \u2014 the server renders it as the addendum's h3.`);
         }
+        const badIdentity = identityRefusal(identity, html);
+        if (badIdentity)
+          return badIdentity;
         const block = identity && !leadingIdentification(html) ? `<h3>${escapeHtml(identity)}</h3>
 ${html}` : html;
         threadEntryResult = await appendThreadEntry(noteId, block, d);
@@ -25905,7 +26670,7 @@ ${block}`), d).html;
       } : {},
       ...sectionMiss,
       ...sectionHint ? { hint: sectionHint } : {},
-      ...threadEntryResult ? { entryId: threadEntryResult.noteId, entryAction: threadEntryResult.action } : {},
+      ...threadEntryResult ? { entryId: threadEntryResult.noteId, entryAction: threadEntryResult.action, 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),
@@ -26045,7 +26810,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"),
@@ -26177,8 +26942,10 @@ calling twice is safe. Use remove=true to delete an edge.`, {
       }
     }
   });
-  server.tool("consistency", `Does the brain agree with itself? pattern= is a regex with ONE capture group naming the value that should match across notes, e.g. "(\\\\d+) mailboxes"; the result groups every asserting note by value with agreement unanimous or DISAGREEMENT. subject="<fact in prose>" finds notes asserting about a subject however phrased. staleAfterDays=N also reports values held in exactly one note untouched N+ days. Matches stored HTML and tag-stripped text; escape backslashes; scope with domain=/kinds=. Records (sessions, diary, logs, dated thread entries) are skipped by default because they are never rewritten; includeRecords=true or a kinds= naming them brings them back. Scans every in-scope note (fast=true uses Trilium's lossy pre-filter). Run it after correcting any fact recorded in more than one place.`, {
-    pattern: stringType().optional().describe("Regex over note bodies. One capture group = the value that should agree across notes. Omit when using subject= (prose mode)."),
+  server.tool("consistency", `Does the brain agree with itself? pattern= is a regex with ONE capture group naming the value that should match across notes, e.g. "(\\\\d+) mailboxes"; the result groups every asserting note by value with agreement unanimous or DISAGREEMENT. subject="<fact in prose>" finds notes asserting about a subject however phrased. staleAfterDays=N also reports values held in exactly one note untouched N+ days. Matches stored HTML and tag-stripped text; escape backslashes; scope with domain=/kinds=. Records (sessions, diary, logs, dated thread entries) are skipped by default because they are never rewritten; includeRecords=true or a kinds= naming them brings them back. Scans every in-scope note (fast=true uses Trilium's lossy pre-filter). Matching ignores case unless caseSensitive=true (a leading (?i) is accepted). Without a capture group the whole match is the value compared. patterns=[\u2026] checks several facts in one call over one read of each note. Run it after correcting any fact recorded in more than one place.`, {
+    pattern: stringType().optional().describe("Regex over note bodies. One capture group = the value that should agree across notes; with none, the whole match is the value. Omit when using subject= (prose mode)."),
+    patterns: arrayType(stringType()).max(10).optional().describe("Several patterns checked in one call (each reported as its own result, in order); every note is read once"),
+    caseSensitive: booleanType().optional().describe('Match case exactly (default false: "Blueprints" and "blueprints" both match)'),
     subject: stringType().optional().describe("A fact in prose \u2014 returns notes asserting about it however phrased (instead of pattern=)"),
     staleAfterDays: numberType().optional().describe("With pattern: also report values held in exactly one note untouched N+ days (staleSingles)"),
     domain: stringType().optional().describe("Restrict to one knowledge domain"),
@@ -26187,146 +26954,175 @@ calling twice is safe. Use remove=true to delete an edge.`, {
     includeArchived: booleanType().optional().describe("Include archived notes (default false)"),
     limit: numberType().optional().describe("Max notes to examine (default 60)"),
     fast: booleanType().optional().describe("Use Trilium's faster but lossy %= pre-filter (default: scan every in-scope note)")
-  }, async ({ pattern, subject, staleAfterDays, domain, kinds, includeRecords, includeArchived, limit, fast }) => {
-    const wantsRecords = includeRecords === true || (kinds ?? []).some((k) => RECORD_KINDS.has(k));
-    let recordsSkipped = 0;
-    const inScope = (n) => {
-      const kind = ownedLabel(n, "noteType");
-      if (!kind)
-        return false;
-      if (kinds?.length && !kinds.includes(kind))
-        return false;
-      if (!wantsRecords && isRecordNote(n)) {
-        recordsSkipped++;
-        return false;
-      }
-      return true;
+  }, async (args) => {
+    const contentCache = new Map;
+    const contentOf = (id) => {
+      let p = contentCache.get(id);
+      if (!p) {
+        p = trilium.getNoteContent(id).catch(() => "");
+        contentCache.set(id, p);
+      }
+      return p;
     };
-    const recordsNote = () => recordsSkipped ? { recordsSkipped, recordsNote: `${recordsSkipped} record(s) (sessions, diary, logs, dated thread entries) were skipped: they are never rewritten. includeRecords=true matches them too.` } : {};
-    if (!pattern && !subject)
-      return err("missing_param", "consistency() needs either a regex pattern or a prose subject.", 'Pass pattern="(\\\\d+) users" to compare a captured value, or subject="<a fact in prose>" to find every note asserting about that subject however phrased.');
-    if (subject && !pattern) {
+    if (args.patterns?.length) {
+      if (args.pattern || args.subject)
+        return err("conflicting_params", "Pass patterns=[\u2026] alone, not with pattern= or subject=.", "Put every pattern in the patterns array.");
+      const results = [];
+      for (const p of args.patterns) {
+        const r = await checkOne({ ...args, pattern: p, patterns: undefined });
+        results.push(JSON.parse(r.content[0].text));
+      }
+      const disagreeing = results.filter((r) => r.agreement === "DISAGREEMENT").length;
+      return txt3({ mode: "multi", patterns: args.patterns.length, disagreeing, results });
+    }
+    return checkOne(args);
+    async function checkOne({ pattern, subject, staleAfterDays, domain, kinds, includeRecords, includeArchived, limit, fast, caseSensitive }) {
+      const wantsRecords = includeRecords === true || (kinds ?? []).some((k) => RECORD_KINDS.has(k));
+      let recordsSkipped = 0;
+      const inScope = (n) => {
+        const kind = ownedLabel(n, "noteType");
+        if (!kind)
+          return false;
+        if (kinds?.length && !kinds.includes(kind))
+          return false;
+        if (!wantsRecords && isRecordNote(n)) {
+          recordsSkipped++;
+          return false;
+        }
+        return true;
+      };
+      const recordsNote = () => recordsSkipped ? { recordsSkipped, recordsNote: `${recordsSkipped} record(s) (sessions, diary, logs, dated thread entries) were skipped: they are never rewritten. includeRecords=true matches them too.` } : {};
+      if (!pattern && !subject)
+        return err("missing_param", "consistency() needs either a regex pattern or a prose subject.", 'Pass pattern="(\\\\d+) users" to compare a captured value, or subject="<a fact in prose>" to find every note asserting about that subject however phrased.');
+      if (subject && !pattern) {
+        const max = limit ?? 60;
+        const tokens = queryTokens(subject, 8);
+        if (!tokens.length)
+          return err("no_tokens", "The subject produced no significant content words.", 'A subject of all stop-words ("what was it") cannot find anything \u2014 name the thing you re-measured.');
+        const clauses = ["#noteType"];
+        if (domain)
+          clauses.push(`#domain='${slugify(domain)}'`);
+        const notes = await trilium.searchNotes(clauses.join(" AND "), { ancestorNoteId: b().root, limit: wantsRecords ? max : max * 4, includeArchivedNotes: includeArchived ?? false }).then((r) => r.results).catch(() => []);
+        const scoped = notes.filter(inScope).slice(0, max);
+        const threshold = Math.max(1, Math.ceil(tokens.length / 2));
+        const hits = [];
+        for (const n of scoped) {
+          const content = await contentOf(n.noteId);
+          if (!content)
+            continue;
+          const text = stripTagsWithMap(content).text.toLowerCase();
+          const matchedTokens = tokens.filter((t) => text.includes(t));
+          if (matchedTokens.length < threshold)
+            continue;
+          hits.push({ id: n.noteId, title: n.title, kind: ownedLabel(n, "noteType") ?? "", matchedTokens, snippet: toText(content, 200) });
+        }
+        return txt3({
+          mode: "subject",
+          subject,
+          tokens,
+          threshold: `${threshold} of ${tokens.length} token(s)`,
+          notesExamined: scoped.length,
+          notes: hits,
+          total: hits.length,
+          ...domain ? { domain: slugify(domain) } : {},
+          ...recordsNote(),
+          note: hits.length ? `${hits.length} note(s) assert something about "${subject}". Open each to read the claim \u2014 or narrow with domain= / kinds=.` : `No note in scope matched ${threshold}+ of the subject's tokens. That is evidence about the phrasing, not the brain \u2014 this mode is deliberately phrase-agnostic, so if you expected a hit, the fact may not be recorded here at all.`
+        });
+      }
+      if (!pattern)
+        return err("missing_param", "No regex pattern given for consistency.", 'Pass pattern="(\\\\d+) users" \u2014 or subject="<a fact in prose>" for the prose-subject mode.');
+      let re;
+      const inlineInsensitive = /^\(\?i\)/.test(pattern);
+      const source = inlineInsensitive ? pattern.slice(4) : pattern;
+      const flags = caseSensitive && !inlineInsensitive ? "g" : "gi";
+      try {
+        re = new RegExp(source, flags);
+      } catch (e) {
+        return err("invalid_pattern", `Not a valid regular expression: ${e.message}`, "Escape backslashes \u2014 a JSON string needs \\\\d for \\d.");
+      }
+      const groupCount = new RegExp(`${source}|`).exec("").length - 1;
       const max = limit ?? 60;
-      const tokens = queryTokens(subject, 8);
-      if (!tokens.length)
-        return err("no_tokens", "The subject produced no significant content words.", 'A subject of all stop-words ("what was it") cannot find anything \u2014 name the thing you re-measured.');
-      const clauses = ["#noteType"];
+      const clauses = fast ? [`note.content %= '${escapeQueryRegex(pattern)}'`] : ["#noteType"];
       if (domain)
         clauses.push(`#domain='${slugify(domain)}'`);
       const notes = await trilium.searchNotes(clauses.join(" AND "), { ancestorNoteId: b().root, limit: wantsRecords ? max : max * 4, includeArchivedNotes: includeArchived ?? false }).then((r) => r.results).catch(() => []);
       const scoped = notes.filter(inScope).slice(0, max);
-      const threshold = Math.max(1, Math.ceil(tokens.length / 2));
-      const hits = [];
+      const byValue = new Map;
+      const noCapture = [];
+      let hasCaptureGroup = false;
+      const scan = (haystack) => {
+        const values = [];
+        let matched = false;
+        re.lastIndex = 0;
+        let m;
+        while ((m = re.exec(haystack)) !== null) {
+          matched = true;
+          const captured = groupCount === 0 ? m[0] : m.slice(1).find((g) => g !== undefined);
+          if (captured !== undefined && captured !== "")
+            values.push(toText(captured, 120).trim() || captured.trim());
+          if (m[0] === "")
+            re.lastIndex++;
+        }
+        return { values, matched };
+      };
+      let tagSpanning = 0;
+      const idleSince = (iso) => Math.max(0, Math.floor((Date.now() - new Date(iso.replace(" ", "T")).getTime()) / 86400000));
       for (const n of scoped) {
-        const content = await trilium.getNoteContent(n.noteId).catch(() => "");
+        const content = await contentOf(n.noteId);
         if (!content)
           continue;
-        const text = stripTagsWithMap(content).text.toLowerCase();
-        const matchedTokens = tokens.filter((t) => text.includes(t));
-        if (matchedTokens.length < threshold)
-          continue;
-        hits.push({ id: n.noteId, title: n.title, kind: ownedLabel(n, "noteType") ?? "", matchedTokens, snippet: toText(content, 200) });
+        const stub = { id: n.noteId, title: n.title, kind: ownedLabel(n, "noteType") ?? "", idleDays: idleSince(n.dateModified) };
+        const raw = scan(content);
+        const projected = scan(stripTagsWithMap(content).text);
+        if (projected.matched && !raw.matched)
+          tagSpanning++;
+        const seen = new Set;
+        for (const value of [...raw.values, ...projected.values]) {
+          hasCaptureGroup = true;
+          if (seen.has(value))
+            continue;
+          seen.add(value);
+          if (!byValue.has(value))
+            byValue.set(value, []);
+          byValue.get(value).push(stub);
+        }
+        if ((raw.matched || projected.matched) && !seen.size)
+          noCapture.push(stub);
       }
-      return txt3({
-        mode: "subject",
-        subject,
-        tokens,
-        threshold: `${threshold} of ${tokens.length} token(s)`,
-        notesExamined: scoped.length,
-        notes: hits,
-        total: hits.length,
-        ...domain ? { domain: slugify(domain) } : {},
-        ...recordsNote(),
-        note: hits.length ? `${hits.length} note(s) assert something about "${subject}". Open each to read the claim \u2014 or narrow with domain= / kinds=.` : `No note in scope matched ${threshold}+ of the subject's tokens. That is evidence about the phrasing, not the brain \u2014 this mode is deliberately phrase-agnostic, so if you expected a hit, the fact may not be recorded here at all.`
-      });
-    }
-    if (!pattern)
-      return err("missing_param", "No regex pattern given for consistency.", 'Pass pattern="(\\\\d+) users" \u2014 or subject="<a fact in prose>" for the prose-subject mode.');
-    let re;
-    try {
-      re = new RegExp(pattern, "gi");
-    } catch (e) {
-      return err("invalid_pattern", `Not a valid regular expression: ${e.message}`, "Escape backslashes \u2014 a JSON string needs \\\\d for \\d.");
-    }
-    const max = limit ?? 60;
-    const clauses = fast ? [`note.content %= '${escapeQueryRegex(pattern)}'`] : ["#noteType"];
-    if (domain)
-      clauses.push(`#domain='${slugify(domain)}'`);
-    const notes = await trilium.searchNotes(clauses.join(" AND "), { ancestorNoteId: b().root, limit: wantsRecords ? max : max * 4, includeArchivedNotes: includeArchived ?? false }).then((r) => r.results).catch(() => []);
-    const scoped = notes.filter(inScope).slice(0, max);
-    const byValue = new Map;
-    const noCapture = [];
-    let hasCaptureGroup = false;
-    const scan = (haystack) => {
-      const values = [];
-      let matched = false;
-      re.lastIndex = 0;
-      let m;
-      while ((m = re.exec(haystack)) !== null) {
-        matched = true;
-        const captured = m.slice(1).find((g) => g !== undefined);
-        if (captured !== undefined)
-          values.push(toText(captured, 120).trim() || captured.trim());
-        if (m[0] === "")
-          re.lastIndex++;
-      }
-      return { values, matched };
-    };
-    let tagSpanning = 0;
-    const idleSince = (iso) => Math.max(0, Math.floor((Date.now() - new Date(iso.replace(" ", "T")).getTime()) / 86400000));
-    for (const n of scoped) {
-      const content = await trilium.getNoteContent(n.noteId).catch(() => "");
-      if (!content)
-        continue;
-      const stub = { id: n.noteId, title: n.title, kind: ownedLabel(n, "noteType") ?? "", idleDays: idleSince(n.dateModified) };
-      const raw = scan(content);
-      const projected = scan(stripTagsWithMap(content).text);
-      if (projected.matched && !raw.matched)
-        tagSpanning++;
-      const seen = new Set;
-      for (const value of [...raw.values, ...projected.values]) {
-        hasCaptureGroup = true;
-        if (seen.has(value))
-          continue;
-        seen.add(value);
-        if (!byValue.has(value))
-          byValue.set(value, []);
-        byValue.get(value).push(stub);
+      if (!hasCaptureGroup) {
+        return txt3({
+          mode: "presence",
+          pattern,
+          scan: fast ? "fast (%= pre-filter)" : "exhaustive",
+          notesExamined: scoped.length,
+          ...recordsNote(),
+          notes: noCapture,
+          total: noCapture.length,
+          note: noCapture.length === 0 ? `No note body matched that pattern across ${scoped.length} note(s), searched both as stored HTML and tag-stripped.${fast ? " fast=true used Trilium's %= pre-filter, which reads a striptags'd copy and can drop notes \u2014 re-run without it before concluding anything." : " That is evidence about the pattern, not the brain."}` : 'The pattern has no capture group, so this is a presence check only. Add one \u2014 consistency("(\\\\d+) users") \u2014 to compare the values these notes actually assert.'
+        });
       }
-      if ((raw.matched || projected.matched) && !seen.size)
-        noCapture.push(stub);
-    }
-    if (!hasCaptureGroup) {
+      const groups = [...byValue.entries()].map(([value, notes]) => ({ value, count: notes.length, notes })).sort((a, b) => b.count - a.count);
+      const staleSingles = staleAfterDays ? groups.filter((g) => g.count === 1 && g.notes[0].idleDays >= staleAfterDays).map((g) => ({ value: g.value, note: { id: g.notes[0].id, title: g.notes[0].title, kind: g.notes[0].kind }, idleDays: g.notes[0].idleDays })) : [];
+      const agrees = groups.length <= 1;
       return txt3({
-        mode: "presence",
+        mode: "consistency",
         pattern,
+        ...groupCount === 0 ? { valueFrom: "the whole match (the pattern has no capture group)" } : {},
+        ...caseSensitive && !inlineInsensitive ? { caseSensitive: true } : {},
         scan: fast ? "fast (%= pre-filter)" : "exhaustive",
+        ...domain ? { domain: slugify(domain) } : {},
         notesExamined: scoped.length,
         ...recordsNote(),
-        notes: noCapture,
-        total: noCapture.length,
-        note: noCapture.length === 0 ? `No note body matched that pattern across ${scoped.length} note(s), searched both as stored HTML and tag-stripped.${fast ? " fast=true used Trilium's %= pre-filter, which reads a striptags'd copy and can drop notes \u2014 re-run without it before concluding anything." : " That is evidence about the pattern, not the brain."}` : 'The pattern has no capture group, so this is a presence check only. Add one \u2014 consistency("(\\\\d+) users") \u2014 to compare the values these notes actually assert.'
+        ...tagSpanning ? { tagSpanning, tagSpanningNote: `${tagSpanning} note(s) matched only once markup was stripped \u2014 the phrase is split by an inline tag there. Before v10.3 those were invisible.` } : {},
+        distinctValues: groups.length,
+        agreement: groups.length === 0 ? "no-data" : agrees ? "unanimous" : "DISAGREEMENT",
+        groups,
+        ...staleAfterDays ? { staleAfterDays } : {},
+        ...staleSingles.length ? { staleSingles, staleSinglesNote: `${staleSingles.length} figure(s) appear in exactly one note, untouched ${staleAfterDays}d+ \u2014 a single copy cannot disagree with itself, so re-measure these against the world rather than against other notes.` } : {},
+        ...noCapture.length ? { matchedWithoutValue: noCapture } : {},
+        note: agrees ? groups.length === 0 ? "No note asserted a value for that pattern. That is evidence about the pattern, not about the brain \u2014 check it against a note you know contains the fact." : `All ${groups[0].count} note(s) agree on "${groups[0].value}".` : `${groups.length} DIFFERENT values are asserted across ${scoped.length} notes. Establish which is true from evidence, correct every note that disagrees, and wire ~corrects from the note that overturns the old claim \u2014 revising in place leaves no trace the wrong value was ever believed.`
       });
     }
-    const groups = [...byValue.entries()].map(([value, notes]) => ({ value, count: notes.length, notes })).sort((a, b) => b.count - a.count);
-    const staleSingles = staleAfterDays ? groups.filter((g) => g.count === 1 && g.notes[0].idleDays >= staleAfterDays).map((g) => ({ value: g.value, note: { id: g.notes[0].id, title: g.notes[0].title, kind: g.notes[0].kind }, idleDays: g.notes[0].idleDays })) : [];
-    const agrees = groups.length <= 1;
-    return txt3({
-      mode: "consistency",
-      pattern,
-      scan: fast ? "fast (%= pre-filter)" : "exhaustive",
-      ...domain ? { domain: slugify(domain) } : {},
-      notesExamined: scoped.length,
-      ...recordsNote(),
-      ...tagSpanning ? { tagSpanning, tagSpanningNote: `${tagSpanning} note(s) matched only once markup was stripped \u2014 the phrase is split by an inline tag there. Before v10.3 those were invisible.` } : {},
-      distinctValues: groups.length,
-      agreement: groups.length === 0 ? "no-data" : agrees ? "unanimous" : "DISAGREEMENT",
-      groups,
-      ...staleAfterDays ? { staleAfterDays } : {},
-      ...staleSingles.length ? { staleSingles, staleSinglesNote: `${staleSingles.length} figure(s) appear in exactly one note, untouched ${staleAfterDays}d+ \u2014 a single copy cannot disagree with itself, so re-measure these against the world rather than against other notes.` } : {},
-      ...noCapture.length ? { matchedWithoutValue: noCapture } : {},
-      note: agrees ? groups.length === 0 ? "No note asserted a value for that pattern. That is evidence about the pattern, not about the brain \u2014 check it against a note you know contains the fact." : `All ${groups[0].count} note(s) agree on "${groups[0].value}".` : `${groups.length} DIFFERENT values are asserted across ${scoped.length} notes. Establish which is true from evidence, correct every note that disagrees, and wire ~corrects from the note that overturns the old claim \u2014 revising in place leaves no trace the wrong value was ever believed.`
-    });
   });
   server.tool("outline", `A note's heading tree without its body: each h2\u2013h4 with level and occurrence index (and raw stored text where inline markup differs), table key columns, size, and structural findings. Read it before a section= edit you're not sure of. Notes over 15k also get a first-block preview per section.`, {
     noteId: stringType().describe("Note to outline")
@@ -26375,7 +27171,7 @@ calling twice is safe. Use remove=true to delete an edge.`, {
       ...headings.length === 0 ? { note: "No h2\u2013h4 headings \u2014 section= would append a new section rather than match anything." } : {}
     });
   });
-  server.tool("inspect", `Everything about one note: every label, relation and attachment, type/mime, parent and child ids, dates. content=true adds the raw body (section= narrows it). find="<literal>" counts occurrences (total, per addendum block, per section) and on a miss shows the nearest stored text. Read-only, safe on any note.`, {
+  server.tool("inspect", `Everything about one note: every label, relation and attachment, type/mime, parent and child ids, dates. content=true adds the raw body (section= narrows it). find="<literal>" counts occurrences (total, per addendum block, per section), returns the stored element around each one (up to 10: its row, list item or paragraph, ready to anchor a revise), and on a miss shows the nearest stored text. Read-only, safe on any note.`, {
     noteId: stringType().describe("Note to inspect"),
     content: booleanType().optional().describe("Include the note's raw body content (default: false)"),
     section: stringType().optional().describe("With content=true, return only this heading's section rather than the whole body"),
@@ -26448,11 +27244,39 @@ calling twice is safe. Use remove=true to delete an edge.`, {
       }
       const total = countIn(rawBody);
       const near = total === 0 ? nearestContext(rawBody, find) : null;
+      const matches = [];
+      const seenSpans = new Set;
+      for (let at = rawBody.indexOf(find);at !== -1 && matches.length < 10; at = rawBody.indexOf(find, at + Math.max(1, find.length))) {
+        let el = null;
+        let tag = "";
+        for (const t of ["tr", "li", "p", "blockquote", "td"]) {
+          el = containingElement(rawBody, t, at, at + find.length);
+          if (el) {
+            tag = t;
+            break;
+          }
+        }
+        const start = el?.start ?? Math.max(0, at - 120);
+        const end = el?.end ?? Math.min(rawBody.length, at + find.length + 120);
+        if (seenSpans.has(start))
+          continue;
+        seenSpans.add(start);
+        let sectionName = "(head)";
+        for (const h of headings) {
+          if (h.index < at)
+            sectionName = h.text;
+          else
+            break;
+        }
+        const stored = rawBody.slice(start, end);
+        matches.push({ section: sectionName, element: tag || "text", stored: stored.length > 600 ? `${stored.slice(0, 600)}\u2026` : stored });
+      }
       findReport = {
         find,
         total,
         blocks,
         ...sections.length ? { sections } : {},
+        ...matches.length ? { matches } : {},
         ...near ? { matchedUpTo: near.fragment, storedNearby: near.context } : {},
         ...total === 0 && !near ? { hint: "Not present, and no fragment of it is either \u2014 the string is unrelated to this note's content." } : {}
       };
@@ -26803,7 +27627,7 @@ assertion + check \u2192 register (deduped by assertion); claimId + holds + evid
       ...found.length === 0 ? { note: "No notes with pending addendums." } : { hint: "Fold each addendum into its note: read the block, then revise(noteId, section='<heading>', body='<merged content>', mode='replace') to absorb it into the right section. These notes must be left clean \u2014 no addendum markers. Addendum-style history belongs only in sessions, diary, and logs. Scoped/autonomous agents: fold only what's in your lane \u2014 leaving personal or out-of-scope addendums for the next interactive session is correct, and calling this tool is what satisfies the pre-close gate." }
     });
   });
-  server.tool("maintain", `Brain hygiene. Lite (automatic in start/close): ages threads active \u2192 dormant \u2192 archived and checks labels. deep=true adds stale notes, orphans and sinks, structural lint (duplicate headings, unbalanced tags, missing required sections, dated prose in timeless notes, oversized notes), duplicate titles, lapsed or broken claims and hygiene passes. dryRun previews. ack=[ids] silences a note you reviewed until its content changes. domain= narrows deep passes to one lane. repair=[ids] unwinds entity double-escaping in place. coverage names any capped pass: structural lint reads at most 40 notes per run and rotates through the rest day by day, so a whole-brain lint spans several runs.`, {
+  server.tool("maintain", `Brain hygiene. Lite (automatic in start/close): ages threads active \u2192 dormant \u2192 archived and checks labels. deep=true adds stale notes, orphans and sinks, structural lint (duplicate headings, unbalanced tags, missing required sections, dated prose in timeless notes, oversized notes), duplicate titles, lapsed or broken claims, table rows that disagree with their header, record seals (whether any record of the last seven sealed days was rewritten after close() sealed it) and hygiene passes. dryRun previews. ack=[ids] silences a note you reviewed until its content changes. domain= narrows deep passes to one lane. repair=[ids] unwinds entity double-escaping in place. coverage names any capped pass: structural lint reads at most 40 notes per run and rotates through the rest day by day, so a whole-brain lint spans several runs.`, {
     deep: booleanType().optional().describe("Deep pass: stale-review + orphan/sink + structural lint + duplicate titles across Memory/Threads and Knowledge (default: false)"),
     dryRun: booleanType().optional().describe("Report what would change without changing it"),
     domain: stringType().optional().describe("Narrow the deep passes to one domain's notes (slugged server-side) \u2014 for scoped agents working a single lane"),
@@ -26817,6 +27641,15 @@ assertion + check \u2192 register (deduped by assertion); claimId + holds + evid
       ...ack?.length ? { ack } : {},
       ...repair?.length ? { repair } : {}
     });
+    if (deep && !domain) {
+      const seals = await verifySeals(trilium, b(), localToday()).catch(() => null);
+      if (seals) {
+        for (const f of seals.findings) {
+          report.flagged.push(`record seal: ${f.date}${f.noteId ? ` [${f.noteId}]` : ""} \u2014 ${f.problem}. Records are append-only; read the revisions to see whether the change was intended. The finding ages out with the seven-day window.`);
+        }
+        report.seals = seals.checked ? `${seals.checked} sealed day(s) verified, ${seals.findings.length} finding(s)` : "no sealed days yet \u2014 the first close of 12.9.0 seals its day";
+      }
+    }
     if (deep && !dryRun && b().sizes && Object.keys(b().sizes).length) {
       saveConfig(b());
     }
@@ -27380,6 +28213,37 @@ and every thread day-child, in time order with its identification line.`, {
   registerMemoryTools(server, trilium, brainRef);
   registerKnowledgeTools(server, trilium, brainRef);
   registerInsightsTools(server, trilium, brainRef);
+  const registry = server._registeredTools ?? {};
+  for (const name of CONTENT_WRITE_TOOLS) {
+    const tool = registry[name];
+    const inner = tool?.handler;
+    if (!tool || typeof inner !== "function")
+      continue;
+    tool.handler = async (...args) => {
+      const result = await inner(...args);
+      if (!wroteSinceClose && wroteContent(result)) {
+        await markStep("write").catch(() => null);
+        wroteSinceClose = true;
+      }
+      return result;
+    };
+  }
+}
+var CONTENT_WRITE_TOOLS = ["remember", "revise", "split", "resolve", "withdraw", "recover", "forget", "label", "connect", "attach", "detach", "claim"];
+function wroteContent(result) {
+  const text = result?.content?.[0]?.text;
+  if (typeof text !== "string")
+    return true;
+  try {
+    const r = JSON.parse(text);
+    if (r.error || r.ok === false || r.unchanged === true || r.action === "already_written" || r.mode === "already_written")
+      return false;
+    if (r.replaced === 0 && !r.closure)
+      return false;
+    return true;
+  } catch {
+    return true;
+  }
 }
 
 // src/annotations.ts
@@ -27401,6 +28265,7 @@ var TOOL_ANNOTATIONS = {
   consistency: READ,
   assembly: READ,
   diff: READ,
+  health: READ,
   master: READ,
   master_recall: READ,
   llm: READ,
@@ -27419,11 +28284,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 +28314,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 +28331,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 +28420,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 };
@@ -27635,10 +28584,24 @@ var asArray = (v) => {
     return v;
   }
 };
+var asObject = (v) => {
+  if (typeof v !== "string")
+    return v;
+  const t = v.trim();
+  if (!t.startsWith("{"))
+    return v;
+  try {
+    const parsed = JSON.parse(t);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : v;
+  } catch {
+    return v;
+  }
+};
 var COERCERS = {
   ZodBoolean: asBoolean,
   ZodNumber: asNumber,
-  ZodArray: asArray
+  ZodArray: asArray,
+  ZodObject: asObject
 };
 function coerceToolArgs(server) {
   const registry = server._registeredTools;
@@ -27971,6 +28934,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;
@@ -28078,7 +29128,7 @@ data: ${JSON.stringify(message)}
 }
 
 // src/oauth.ts
-import { createHmac, randomBytes, createHash, timingSafeEqual } from "crypto";
+import { createHmac, randomBytes, createHash as createHash2, timingSafeEqual } from "crypto";
 import { existsSync as existsSync2, readFileSync as readFileSync2, statSync, writeFileSync as writeFileSync2 } from "fs";
 
 // src/network-security.ts
@@ -28754,9 +29804,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 +29836,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 +29850,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 +29860,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 +29874,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 +29883,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 +29929,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 +29944,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 +30051,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:" + createHash2("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,
@@ -29026,7 +30098,7 @@ async function handleToken(req, base) {
       return tokenError("invalid_grant", "redirect_uri mismatch.");
     if (!verifier)
       return tokenError("invalid_request", "code_verifier is required.");
-    const computed = createHash("sha256").update(verifier).digest("base64url");
+    const computed = createHash2("sha256").update(verifier).digest("base64url");
     if (computed !== record.codeChallenge)
       return tokenError("invalid_grant", "PKCE verification failed.");
     return new Response(JSON.stringify(issueTokens(base, record.clientId, record.resource, record.scope)), {
@@ -29035,10 +30107,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 +30201,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.9.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 +30221,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 +30258,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 +30298,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 +30373,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 = () => {