brainllm 12.8.0 → 12.9.1

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(`
 `);
@@ -21978,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, "\\'");
 }
@@ -22171,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, "");
@@ -22288,19 +22373,44 @@ 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;",
-  '"': '(?:"|&quot;)',
-  "'": "(?:'|&#39;|&apos;)"
+  '"': 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, "")).trim();
+  const text = decodeEntities(needle.replace(INLINE_TAG_RX, "")).replace(/\\(["'])/g, "$1").trim();
   if (text.length < 2)
     return [];
   const gap = `(?:<\\/?(?:${INLINE_TAGS})(?:\\s[^<>]*)?\\/?>)*`;
@@ -22379,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;
@@ -22680,11 +22805,47 @@ function unbalancedTags(html) {
   }
   return [...new Set(stack)];
 }
+function tableShapeIssues(html) {
+  const issues = [];
+  const spanOf = (attrs, name) => Number(new RegExp(`${name}\\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: spanOf(c[2], "colspan"),
+      rows: spanOf(c[2], "rowspan"),
+      text: decodeEntities(c[3].replace(/<[^>]+>/g, "")).trim()
+    })));
+    if (rows.length < 2)
+      continue;
+    const width = rows[0].reduce((sum, c) => sum + c.span, 0);
+    let spanning = [];
+    for (const [i, cells] of rows.entries()) {
+      const inherited = spanning.reduce((sum, s) => sum + s.columns, 0);
+      if (i > 0) {
+        const label = (cells[0]?.text ?? "").slice(0, 60) || "(empty row)";
+        const count = cells.reduce((sum, c) => sum + c.span, 0) + inherited;
+        if (count !== width) {
+          issues.push(`row "${label}" has ${count} cell(s), its header has ${width}`);
+        } else {
+          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>`);
+          }
+        }
+      }
+      spanning = [
+        ...spanning.map((s) => ({ ...s, rowsLeft: s.rowsLeft - 1 })).filter((s) => s.rowsLeft > 0),
+        ...cells.filter((c) => c.rows > 1).map((c) => ({ columns: c.span, rowsLeft: c.rows - 1 }))
+      ];
+    }
+  }
+  return issues;
+}
 var LARGE_NOTE_CHARS = 40000;
 function structureReport(html) {
   return {
     duplicateHeadings: duplicateHeadings(html),
     unbalancedTags: unbalancedTags(html),
+    tableShape: tableShapeIssues(html),
     size: html.length
   };
 }
@@ -23518,6 +23679,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;
@@ -23590,13 +23754,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++) {
@@ -23613,10 +23779,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.`));
             }
           }
         }
@@ -24016,6 +24191,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);
@@ -24617,6 +24882,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)
@@ -24675,6 +24942,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) => {
@@ -24684,16 +24952,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) {
@@ -24846,7 +25128,7 @@ ${block}` }));
   });
   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.
 
-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.`, {
+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")`),
@@ -24856,6 +25138,19 @@ The close sequence next[] lays out: singleton updates from the session, then add
     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);
@@ -24957,6 +25252,13 @@ The close sequence next[] lays out: singleton updates from the session, then add
     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: [
@@ -24977,7 +25279,7 @@ The close sequence next[] lays out: singleton updates from the session, then add
       ]
     });
   });
-  server.tool("close", `Writes the session log, normally the last call of a session. Refuses unless session(), addendum(), maintain(), remarks() and diary() ran and session \u2192 remarks \u2192 diary held (force=true bypasses a step with genuinely nothing to do; bypassed steps are reported). identity= is required. Writes a timestamped block to today's [yyyy-mm-dd] session note (title= becomes its heading), regenerates the daily log, backs up the database and resets the gate. continuing=true is a second close the same day.`, {
+  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)`),
@@ -25000,9 +25302,11 @@ The close sequence next[] lays out: singleton updates from the session, then add
       }
     }
     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");
@@ -25018,6 +25322,9 @@ The close sequence next[] lays out: singleton updates from the session, then add
     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>
@@ -25072,6 +25379,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) {
@@ -25093,6 +25401,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 } : {}
     });
@@ -25190,6 +25500,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 });
@@ -25372,7 +25685,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 } : {},
@@ -25470,6 +25784,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") {
@@ -25489,7 +25806,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))
@@ -25553,7 +25870,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"),
@@ -25616,10 +25933,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;
@@ -25629,18 +25957,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);
@@ -25701,7 +26039,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;
@@ -25713,10 +26056,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;
@@ -25743,6 +26087,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) {
@@ -25766,7 +26123,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) => {
@@ -25910,7 +26268,7 @@ ${block}`), d);
   };
   server.tool("revise", `Edit a note by id. A revision is taken first; "Last updated" lines are bumped on content writes.
 
-Modes: default append (a dated addendum \u2014 right only for records; a dated thread's append lands in today's child), mode=replace (whole body), section="<heading>" (replace that section's whole body, h2\u2192h3\u2192h4, occurrence= for repeats), section= + mode=before|after (insert a sibling block around the whole section), mode=prepend (top of the section body), mode=remove (delete the section). find="<exact stored text>" replaces 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().optional().describe("Note to update (omit only with domain=)"),
@@ -25925,6 +26283,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"),
@@ -25933,7 +26295,9 @@ 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: noteIdArg, domain, dryRun, 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.");
@@ -25997,11 +26361,16 @@ Check the receipt: matched=false means a NEW section was written (available= lis
       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, attribute-tolerant or ignoring inline tags) \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);
@@ -26021,7 +26390,9 @@ Check the receipt: matched=false means a NEW section was written (available= lis
           exact.push({ start: at, length: find.length });
         const rx = exact.length ? null : tolerantFindRegex(find);
         const tolerantHits = rx ? [...current.matchAll(rx)].map((m) => ({ start: m.index, length: m[0].length })) : [];
-        const hits = exact.length ? exact : tolerantHits.length ? tolerantHits : inlineTolerantSpans(current, find);
+        const 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.`;
@@ -26039,6 +26410,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);
@@ -26049,16 +26440,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 } : {}
         });
       }
@@ -26138,6 +26545,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 } : {}
       });
     }
@@ -26230,6 +26638,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);
@@ -26268,7 +26679,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),
@@ -26540,8 +26951,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"),
@@ -26550,146 +26963,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")
@@ -26738,7 +27180,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"),
@@ -26811,11 +27253,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." } : {}
       };
@@ -27166,7 +27636,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"),
@@ -27180,6 +27650,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());
     }
@@ -27743,6 +28222,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
@@ -28083,10 +28593,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;
@@ -28613,7 +29137,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
@@ -29537,7 +30061,7 @@ var tokenError = (error, description, status = 400) => new Response(JSON.stringi
   headers: { "Content-Type": "application/json", "Cache-Control": "no-store" }
 });
 function refreshKey(token) {
-  return "sha256:" + createHash("sha256").update(token).digest("hex");
+  return "sha256:" + createHash2("sha256").update(token).digest("hex");
 }
 function issueTokens(base, clientId, resource, scope) {
   const store = loadStore();
@@ -29583,7 +30107,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)), {
@@ -29690,7 +30214,7 @@ function createServer(origin = null) {
   const s = new McpServer({
     name: BRAND2.name,
     title: BRAND2.name,
-    version: "12.8.0",
+    version: "12.9.1",
     description: BRAND2.description,
     websiteUrl: BRAND2.website,
     icons: brandIcons(origin)