brainllm 12.9.0 → 13.0.0

package/dist/index.js

@@ -22143,11 +22143,12 @@ var TAG_ATTRIBUTES = {
   img: new Set(["src", "alt", "width", "height", "loading"]),
   th: new Set(["colspan", "rowspan", "scope", "headers"]),
   td: new Set(["colspan", "rowspan", "headers"]),
-  code: new Set(["class"]),
+  code: new Set(["class", "spellcheck"]),
   pre: new Set(["class"]),
   span: new Set(["class"]),
   mark: new Set(["class"]),
-  ol: new Set(["start", "reversed", "type"])
+  ol: new Set(["start", "reversed", "type"]),
+  li: new Set(["data-list-item-id"])
 };
 function safeHtmlUrl(value) {
   const decoded = decodeEntities(value).replace(/[\u0000\u0001-\u001f\u007f]/g, "").trim();
@@ -22807,26 +22808,35 @@ function unbalancedTags(html) {
 }
 function tableShapeIssues(html) {
   const issues = [];
-  const cellSpan = (attrs) => Number(/colspan\s*=\s*"?(\d+)/i.exec(attrs ?? "")?.[1] ?? 1);
+  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: cellSpan(c[2]),
+      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);
-    for (const cells of rows.slice(1)) {
-      const label = (cells[0]?.text ?? "").slice(0, 60) || "(empty row)";
-      const count = cells.reduce((sum, c) => sum + c.span, 0);
-      if (count !== width) {
-        issues.push(`row "${label}" has ${count} cell(s), its header has ${width}`);
-        continue;
-      }
-      const piped = cells.find((c) => (c.text.match(/\s\|\s/g)?.length ?? 0) >= Math.max(1, width - 2) && width > 1);
-      if (piped && cells.filter((c) => c.text).length < width) {
-        issues.push(`row "${label}" carries pipe-separated values inside one cell \u2014 send each value as its own <td>`);
+    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;
@@ -22933,6 +22943,108 @@ function upsertTableRow(html, heading, key, cells) {
     created: !matchedRow
   };
 }
+function findTable(html, heading) {
+  let scope = html;
+  let scopeStart = 0;
+  if (heading !== undefined) {
+    const section = locateSection(html, heading);
+    if (!section)
+      return null;
+    scope = html.slice(section.contentStart, section.end);
+    scopeStart = section.contentStart;
+  }
+  const tableMatch = /<table[^>]*>[\s\S]*?<\/table>/i.exec(scope);
+  if (!tableMatch)
+    return null;
+  const tbodyMatch = /<tbody[^>]*>([\s\S]*?)<\/tbody>/i.exec(tableMatch[0]);
+  if (!tbodyMatch)
+    return null;
+  const firstRow = /<tr[^>]*>([\s\S]*?)<\/tr>/i.exec(tableMatch[0]);
+  if (!firstRow)
+    return null;
+  const columns = [...firstRow[1].matchAll(/<t[hd](?=[\s>/])([^>]*)>/gi)].reduce((sum, c) => sum + Number(/colspan\s*=\s*"?(\d+)/i.exec(c[1] ?? "")?.[1] ?? 1), 0);
+  if (!columns)
+    return null;
+  const tbodyInner = tbodyMatch[1];
+  const tbodyInnerStart = scopeStart + tableMatch.index + tbodyMatch.index + tbodyMatch[0].indexOf(">") + 1;
+  const insertAt = tbodyInnerStart + tbodyInner.length;
+  let placeholder;
+  const rowRe = /<tr[^>]*>[\s\S]*?<\/tr>/gi;
+  let m;
+  while ((m = rowRe.exec(tbodyInner)) !== null) {
+    const first = /<td[^>]*>([\s\S]*?)<\/td>/i.exec(m[0]);
+    const text = first ? decodeEntities(first[1].replace(/<[^>]+>/g, "")).replace(/\s+/g, " ").trim().toLowerCase() : "";
+    if (text === "" || text === "\u2014 none yet \u2014") {
+      placeholder = { start: tbodyInnerStart + m.index, end: tbodyInnerStart + m.index + m[0].length };
+      break;
+    }
+  }
+  return { insertAt, columns, ...placeholder ? { placeholder } : {} };
+}
+function appendRowToTable(html, spot, cells) {
+  const row = `<tr>${cells.map((c) => `<td>${c}</td>`).join("")}</tr>`;
+  const at = spot.placeholder ?? { start: spot.insertAt, end: spot.insertAt };
+  return html.slice(0, at.start) + row + html.slice(at.end);
+}
+function fitRowCells(cells, columns) {
+  if (columns <= 0 || cells.length > columns)
+    return null;
+  return [...cells, ...Array.from({ length: columns - cells.length }, () => "")];
+}
+function rowCells(row) {
+  return [...row.matchAll(/<(t[hd])(?=[\s>/])[^>]*>([\s\S]*?)<\/\1>/gi)].map((m) => m[2].trim());
+}
+function nearestKey(requested, available) {
+  const clean = (s) => decodeEntities(s).replace(/\s+/g, " ").trim();
+  const req = clean(requested);
+  if (!req)
+    return null;
+  const wordSet = (s) => new Set(s.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter(Boolean));
+  const reqWords = wordSet(req);
+  let best = null;
+  const rank = (c) => c.reason === "compound" ? [0, c.distance] : [1, c.distance];
+  for (const key of available) {
+    const cand = clean(key);
+    if (!cand || cand.toLowerCase() === req.toLowerCase())
+      continue;
+    let hit = null;
+    const candWords = wordSet(cand);
+    const small = reqWords.size <= candWords.size ? reqWords : candWords;
+    const large = reqWords.size <= candWords.size ? candWords : reqWords;
+    if (small.size) {
+      let extra = 0;
+      let subset = true;
+      for (const w of small)
+        if (!large.has(w)) {
+          subset = false;
+          break;
+        }
+      if (subset) {
+        for (const w of large)
+          if (!small.has(w))
+            extra++;
+        if (extra <= 2)
+          hit = { distance: extra, reason: "compound" };
+      }
+    }
+    if (!hit) {
+      const d = editDistance(req, cand);
+      if (d > 0 && d <= Math.max(2, Math.floor(req.length / 5)))
+        hit = { distance: d, reason: "typo" };
+    }
+    if (!hit)
+      continue;
+    if (!best) {
+      best = { key, ...hit };
+      continue;
+    }
+    const [r1, d1] = rank(hit);
+    const [r2, d2] = rank(best);
+    if (r1 < r2 || r1 === r2 && d1 < d2)
+      best = { key, ...hit };
+  }
+  return best;
+}
 
 // src/templates.ts
 var RESOLUTION_ANCHOR = "<h2>Resolution</h2>";
@@ -23382,6 +23494,9 @@ function isoDaysAgo(days) {
 function reviewKey(n) {
   return n.blobId ?? n.dateModified;
 }
+function isAcknowledged(n) {
+  return ownedLabel(n, "reviewed") === reviewKey(n);
+}
 var TIMELESS_KINDS = new Set(["thread", "user", "information", "domain"]);
 var DATED_PROSE_LIMIT = 4;
 var MONTHS = "Jan(?:uary)?|Feb(?:ruary)?|Mar(?:ch)?|Apr(?:il)?|May|June?|July?|Aug(?:ust)?|Sep(?:t(?:ember)?)?|Oct(?:ober)?|Nov(?:ember)?|Dec(?:ember)?";
@@ -23420,7 +23535,7 @@ async function sweep(trilium, cfg, opts = {}) {
   const inScope = (n) => !domainSlug || n.attributes.some((a) => isOwnedAttribute(n, a) && a.type === "label" && a.name === "domain" && a.value === domainSlug);
   let suppressed = 0;
   const acknowledged = (n) => {
-    if (ownedLabel(n, "reviewed") !== reviewKey(n))
+    if (!isAcknowledged(n))
       return false;
     suppressed++;
     return true;
@@ -24839,6 +24954,94 @@ function applyFindEdit(source, needle, replacement, index) {
   const inline = inlineTolerantSpans(source, needle);
   return inline.length ? spans(inline, "inline-tolerant") : null;
 }
+var CHANGES_CAP = 25;
+var boundPreview = (s, max = 1600) => s.length <= max ? s : `${s.slice(0, max)}\u2026 (${s.length - max} more characters)`;
+function capChanges(changes, cap = CHANGES_CAP) {
+  if (changes.length <= cap)
+    return { changes };
+  return { changes: changes.slice(0, cap), changesTruncated: { shown: cap, total: changes.length } };
+}
+function sectionTableRows(html) {
+  const table = /<table[^>]*>[\s\S]*?<\/table>/i.exec(html)?.[0];
+  if (!table)
+    return;
+  const tbody = /<tbody[^>]*>([\s\S]*?)<\/tbody>/i.exec(table)?.[1];
+  const scope = tbody ?? table.replace(/<thead[^>]*>[\s\S]*?<\/thead>/gi, "");
+  return (scope.match(/<tr[^>]*>/gi) ?? []).length;
+}
+var RECALL_STRATEGIES = ["label", "title", "text", "fuzzy", "ordered", "regex"];
+function dominantStrategy(contributions) {
+  let best = null;
+  let bestWeight = 0;
+  for (const s of RECALL_STRATEGIES) {
+    const w = contributions.get(s) ?? 0;
+    if (w > bestWeight) {
+      bestWeight = w;
+      best = s;
+    }
+  }
+  return best;
+}
+function passageAround(text, index, length) {
+  const from = Math.max(0, index - 80);
+  const to = Math.min(text.length, index + length + 80);
+  return `${from > 0 ? "\u2026" : ""}${text.slice(from, to).replace(/\s+/g, " ").trim()}${to < text.length ? "\u2026" : ""}`;
+}
+function tokenPassage(text, tokens) {
+  const lower = text.toLowerCase();
+  let best = null;
+  for (const t of tokens) {
+    const idx = lower.indexOf(t.toLowerCase());
+    if (idx < 0)
+      continue;
+    if (!best || t.length > best.length)
+      best = { index: idx, length: t.length };
+  }
+  return best ? passageAround(text, best.index, best.length) : null;
+}
+function withinModifiedWindow(modified, since, until) {
+  const day = modified.slice(0, 10);
+  const dayOk = /^\d{4}-\d{2}-\d{2}$/.test(day);
+  const isDay = (v) => /^\d{4}-\d{2}-\d{2}$/.test(v);
+  const ms = Date.parse(modified.replace(" ", "T"));
+  if (since) {
+    if (isDay(since)) {
+      if (dayOk && day < since)
+        return false;
+    } else {
+      const s = Date.parse(since);
+      if (Number.isFinite(s) && Number.isFinite(ms) && ms < s)
+        return false;
+    }
+  }
+  if (until) {
+    if (isDay(until)) {
+      if (dayOk && day > until)
+        return false;
+    } else {
+      const u = Date.parse(until);
+      if (Number.isFinite(u) && Number.isFinite(ms) && ms > u)
+        return false;
+    }
+  }
+  return true;
+}
+function capWarning(saturated) {
+  const names = [...new Set(saturated)].sort();
+  if (!names.length)
+    return null;
+  return `The backend returned its 30-candidate cap on the ${names.join(", ")} ${names.length === 1 ? "strategy" : "strategies"}, so further matches may exist \u2014 narrow with domain= or kinds=, or use consistency() for an exhaustive scan.`;
+}
+var SEARCH_FAILURE_NOTE = "One or more backend search queries failed \u2014 this is a backend failure (Trilium unreachable, or its search index busy), NOT a verdict that nothing matched. Retry the call, and do not conclude from this receipt that the content is unstored.";
+async function markWithRetry(mark) {
+  for (let attempt = 1;attempt <= 2; attempt++) {
+    try {
+      await mark();
+      return true;
+    } catch {}
+  }
+  return false;
+}
 var err = (code, detail, hint) => txt3({ error: code, detail, ...hint ? { hint } : {} });
 var labelOf2 = (n, name) => n.attributes.find((a) => isOwnedAttribute(n, a) && a.type === "label" && a.name === name)?.value;
 var hasLabel = (n, name) => n.attributes.some((a) => isOwnedAttribute(n, a) && a.type === "label" && a.name === name);
@@ -24875,6 +25078,7 @@ function registerTools(server, trilium, brainRef) {
   const REQUIRED_PRECLOSE_STEPS = ["session", "addendum", "maintain", "remarks", "diary"];
   const LIGHT_PRECLOSE_STEPS = ["session", "remarks", "diary"];
   let wroteSinceClose = false;
+  let writeMarkPending = null;
   const gateNote = async (date) => {
     const cfg = b();
     if (!cfg.memory.sessions)
@@ -24919,6 +25123,16 @@ function registerTools(server, trilium, brainRef) {
     preCloseSteps.set(step, next);
     preCloseSeq = next;
   };
+  const markWriteStep = async () => {
+    const ok = await markWithRetry(() => markStep("write"));
+    writeMarkPending = ok ? null : 'the "write" gate mark could not be recorded durably (Trilium label write failed twice)';
+    return ok;
+  };
+  const stampSessionScope = async (date, scope) => {
+    const noteId = await ensureGateNote(date);
+    if (noteId)
+      await trilium.updateLabelValue(noteId, "scope", scope).catch(() => null);
+  };
   const readGate = async (date) => {
     const noteId = await gateNote(date);
     if (!noteId)
@@ -25000,6 +25214,7 @@ function registerTools(server, trilium, brainRef) {
   async function appendThreadEntry(threadId, block, d) {
     const found = await trilium.searchNotes(`#noteType=threadEntry #created='${d}'`, { ancestorNoteId: threadId, fastSearch: true, limit: 1 });
     const time = localNowTime();
+    const marker = `Addendum \u2014 ${time}`;
     if (found.results[0]) {
       const noteId = found.results[0].noteId;
       const current = fixRecordHeader(await trilium.getNoteContent(noteId), "threadEntry", d).html;
@@ -25009,17 +25224,17 @@ function registerTools(server, trilium, brainRef) {
       if (incoming && blocks.some((b) => norm(b) === incoming))
         return { noteId, action: "already_written" };
       await trilium.createRevision(noteId);
-      await trilium.updateNoteContent(noteId, safeAppend(current, `<h2>Addendum \u2014 ${time}</h2>`, block));
+      await trilium.updateNoteContent(noteId, safeAppend(current, `<h2>${marker}</h2>`, block));
       await trilium.updateLabelValue(noteId, "updated", d);
-      return { noteId, action: "appended" };
+      return { noteId, action: "appended", marker };
     }
-    const created = await trilium.createNote(threadId, `[${d}]`, contentFor("threadEntry", { date: d, body: `<h2>Addendum \u2014 ${time}</h2>
+    const created = await trilium.createNote(threadId, `[${d}]`, contentFor("threadEntry", { date: d, body: `<h2>${marker}</h2>
 ${block}` }));
     const noteId = created.note.noteId;
     await trilium.addLabel(noteId, "noteType", "threadEntry");
     await trilium.addLabel(noteId, "created", d);
     await ensureIcon(trilium, noteId);
-    return { noteId, action: "created" };
+    return { noteId, action: "created", marker };
   }
   function collectionAppendRefusal(book) {
     return err("collection_thread", `"${book.title}" is a collection thread \u2014 it holds one titled entry per item, not dated appends.`, `Add an entry: remember(kind="threadEntry", thread="${book.noteId}", title, body). Change one: revise(<entry id>, section=/find=/mode=\u2026) \u2014 memory("${book.noteId}") lists them.`);
@@ -25074,7 +25289,8 @@ ${block}` }));
           sessionNoteId = digest.todaySession.id;
           const content = await trilium.getNoteContent(sessionNoteId).catch(() => "");
           sessionPreview = toText(content, 200);
-          newDay = !/<h2(?:\s[^>]*)?>\s*Addendum/i.test(content);
+          const note = await trilium.getNote(sessionNoteId).catch(() => null);
+          newDay = note ? !hasLabel(note, "interactive") : !/<h2(?:\s[^>]*)?>\s*Addendum/i.test(content);
         } else {
           sessionNoteId = await ensureGateNote(todayStr);
           newDay = true;
@@ -25082,6 +25298,7 @@ ${block}` }));
       } catch {}
     }
     let changesSinceLastSession = [];
+    let changesTruncated;
     if (digest.lastSession && cfg.root) {
       const sinceDate = digest.lastSession.date;
       try {
@@ -25093,12 +25310,14 @@ ${block}` }));
             deduped.set(h.noteId, h);
           }
         }
-        changesSinceLastSession = [...deduped.values()].slice(0, 25).map((h) => ({
+        const capped = capChanges([...deduped.values()].map((h) => ({
           id: h.noteId,
           title: h.current_title,
           changed: h.date.slice(0, 10),
           ...h.current_isDeleted ? { deleted: true } : {}
-        }));
+        })));
+        changesSinceLastSession = capped.changes;
+        changesTruncated = capped.changesTruncated;
       } catch {}
     }
     return txt3({
@@ -25112,6 +25331,7 @@ ${block}` }));
       dormantThreads: digest.reviewQueue.length ? { note: "These threads went dormant from inactivity. Mention them if relevant; revise() or resolve() to act.", items: digest.reviewQueue } : [],
       lastSession: digest.lastSession ?? null,
       changesSinceLastSession: changesSinceLastSession.length ? changesSinceLastSession : undefined,
+      ...changesTruncated ? { changesTruncated } : {},
       ...newDay ? { newDay: true, newDayHint: "First session of the day \u2014 call day() for the sweep payload (previous session + log + changes in one call)." } : {},
       ...(depth ?? "digest") === "digest" ? { depthHint: 'Preferences and protocols came back IN FULL \u2014 the two needed whole to orient from the first message. Biography, goals and responsibilities are section headings + preview; pull one with master(which) / llm(which), or a single section with their section= parameter. start(depth="full") serves all five inline.' } : {},
       hygiene: { scanned: hygiene.scanned, fixed: hygiene.fixed.length, transitions: hygiene.transitions, flagged: hygiene.flagged, ...hygiene.suppressed ? { suppressed: hygiene.suppressed } : {} }
@@ -25119,22 +25339,42 @@ ${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. 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().`, {
+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(). continuing=true is a second session on a day already closed \u2014 verified against the day's addendum, it returns the short continuation receipt (no singleton review or audit) while still recording the session step.`, {
     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")`),
+    continuing: booleanType().optional().describe("A second session on a day already closed \u2014 verified against today's addendum, returns the short continuation receipt (no singleton review). Refused on the day's first session."),
     light: booleanType().optional().describe("Deprecated \u2014 light is now the default; accepted for compatibility and ignored")
-  }, async ({ date, full, scope }) => {
+  }, async ({ date, full, scope, continuing }) => {
     const d = checkedDate(date);
     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")) {
+    let continued = false;
+    if (continuing) {
+      const prior = await trilium.searchNotes(`#noteType=session #created='${d}'`, { ancestorNoteId: cfg.memory.sessions, fastSearch: true, limit: 1 });
+      const priorContent = prior.results[0] ? await trilium.getNoteContent(prior.results[0].noteId).catch(() => "") : "";
+      continued = /<h2(?:\s[^>]*)?>\s*Addendum/i.test(priorContent);
+      if (!continued) {
+        return err("not_a_continuation", `continuing=true needs a session note for ${d} that already carries an addendum \u2014 there is none, so this is the day's first session.`, "Run the full pre-close protocol: session() \u2192 addendum() \u2192 maintain() \u2192 remarks() \u2192 diary() \u2192 close().");
+      }
+    }
+    const writeGate = await readGate(d);
+    let gateNote;
+    if (wroteSinceClose && !writeGate.has("write")) {
+      if (await markWriteStep())
+        writeGate.set("write", 1);
+      else
+        gateNote = writeMarkPending ?? "the durable write gate could not be repaired";
+    }
+    if (!(writeGate.has("write") || wroteSinceClose)) {
       await markStep("session", d);
+      await stampSessionScope(d, scope ?? "interactive");
       return txt3({
         date: d,
+        ...continued ? { continuing: true } : {},
         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.",
+        note: "Light close \u2014 strictly because no content was written this session: 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.",
@@ -25142,6 +25382,49 @@ The close sequence next[] lays out: singleton updates from the session, then add
         ]
       });
     }
+    const diaryEntryOfToday = async () => {
+      if (!cfg.llm.diary)
+        return null;
+      const diarySearch = await trilium.searchNotes(`#noteType=diary #created='${d}'`, { ancestorNoteId: cfg.llm.diary, fastSearch: true, limit: 1 }).catch(() => ({ results: [] }));
+      if (!diarySearch.results[0])
+        return null;
+      const id = diarySearch.results[0].noteId;
+      const content = await trilium.getNoteContent(id).catch(() => "");
+      return full ? { id, content } : { id, blocks: (content.match(/<h2(?:\s[^>]*)?>\s*Addendum/gi) ?? []).length, size: content.length };
+    };
+    const pendingAddendumCount = async () => {
+      try {
+        const r = await trilium.searchNotes("#noteType note.content *=* 'Addendum'", { ancestorNoteId: cfg.root, fastSearch: false, limit: 40 });
+        const candidates = r.results.filter((n) => {
+          const kind = labelOf2(n, "noteType");
+          return kind && !["session", "diary", "log", "threadEntry", "thread"].includes(kind);
+        });
+        const contents = await Promise.all(candidates.map((n) => trilium.getNoteContent(n.noteId).catch(() => "")));
+        return contents.filter(hasAddendumMarker).length;
+      } catch {
+        return null;
+      }
+    };
+    if (continued) {
+      const hygiene = await sweep(trilium, cfg, { deep: false, dryRun: false }).catch(() => null);
+      const pendingAddendums = await pendingAddendumCount();
+      await markStep("session", d);
+      await stampSessionScope(d, scope ?? "interactive");
+      return txt3({
+        date: d,
+        continuing: true,
+        note: "Continuing session \u2014 the singleton review and audit already ran with the day's first close, so this receipt carries only what the next close needs. If this stretch changed a singleton, revise() it before close() all the same.",
+        diary: await diaryEntryOfToday(),
+        maintenance: hygiene ? { scanned: hygiene.scanned, fixed: hygiene.fixed.length, transitions: hygiene.transitions, flagged: hygiene.flagged, ...hygiene.suppressed ? { suppressed: hygiene.suppressed } : {} } : "skipped",
+        pending: { addendums: pendingAddendums === null ? "unknown" : pendingAddendums },
+        next: [
+          pendingAddendums === 0 ? "Call addendum() \u2014 0 notes currently carry addendum markers, so this should come back clean; the call still satisfies the gate." : pendingAddendums === null ? "Call addendum() \u2014 fold what this stretch's work left behind." : `Call addendum() \u2014 ${pendingAddendums} note(s) carry addendum markers; fold each into its section.`,
+          "Call maintain() \u2014 the same hygiene pass as any session.",
+          "Call remarks(), then diary() \u2014 the cues, then this stretch's record.",
+          "Call close(continuing=true) \u2014 commit this stretch's log; the day's first close already carried the full sequence."
+        ]
+      });
+    }
     const fetchSingleton = async (id) => {
       if (!full) {
         const note = await trilium.getNote(id);
@@ -25163,24 +25446,9 @@ The close sequence next[] lays out: singleton updates from the session, then add
       fetchSingleton(cfg.llm.protocols),
       cfg.llm.selfcorrection ? fetchSingleton(cfg.llm.selfcorrection) : Promise.resolve(null)
     ]);
-    let diaryEntry = null;
-    if (cfg.llm.diary) {
-      const diarySearch = await trilium.searchNotes(`#noteType=diary #created='${d}'`, { ancestorNoteId: cfg.llm.diary, fastSearch: true, limit: 1 }).catch(() => ({ results: [] }));
-      if (diarySearch.results[0]) {
-        const id = diarySearch.results[0].noteId;
-        const content = await trilium.getNoteContent(id).catch(() => "");
-        diaryEntry = full ? { id, content } : { id, blocks: (content.match(/<h2(?:\s[^>]*)?>\s*Addendum/gi) ?? []).length, size: content.length };
-      }
-    }
+    const diaryEntry = await diaryEntryOfToday();
     const hygiene = await sweep(trilium, cfg, { deep: false, dryRun: false }).catch(() => null);
-    const pendingAddendums = await trilium.searchNotes("#noteType note.content *=* 'Addendum'", { ancestorNoteId: cfg.root, fastSearch: false, limit: 40 }).then(async (r) => {
-      const candidates = r.results.filter((n) => {
-        const kind = labelOf2(n, "noteType");
-        return kind && !["session", "diary", "log", "threadEntry", "thread"].includes(kind);
-      });
-      const contents = await Promise.all(candidates.map((n) => trilium.getNoteContent(n.noteId).catch(() => "")));
-      return contents.filter(hasAddendumMarker).length;
-    }).catch(() => null);
+    const pendingAddendums = await pendingAddendumCount();
     const singletonStubs = {
       biography,
       goals,
@@ -25203,11 +25471,13 @@ The close sequence next[] lays out: singleton updates from the session, then add
       singletonsWrittenToday: touchedToday.length ? touchedToday : "none"
     };
     await markStep("session", d);
+    await stampSessionScope(d, scope ?? "interactive");
     const scoped = scope === "agent";
     return txt3({
       date: d,
       ...scoped ? { scope: "agent" } : {},
-      ...!full ? { mode: "light", note: "Singleton content and the diary body are omitted (default) \u2014 fetch via master()/llm() only where lastModified indicates a revision is needed; start() already served all singletons in full, and diary() needs only the id." } : {},
+      ...!full ? { singletons: "stubs", note: "Singleton content and the diary body are omitted (default) \u2014 fetch via master()/llm() only where lastModified indicates a revision is needed; start() already served all singletons in full, and diary() needs only the id. This is stub mode, not a light close: 'light' means only that no content was written this session." } : {},
+      ...gateNote ? { gateNote } : {},
       master: { biography, goals, preferences },
       llm: { responsibilities, protocols, ...selfcorrection ? { selfcorrection } : {} },
       diary: diaryEntry,
@@ -25246,6 +25516,7 @@ The close sequence next[] lays out: singleton updates from the session, then add
     if (!(await readGate(localToday())).has("write")) {
       return txt3({
         closeMode: "light",
+        note: "Light close \u2014 strictly because no content was written this session: addendum() and maintain() are not required and nothing is audited. The full cues return the moment any content is written.",
         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()."]
       });
@@ -25293,7 +25564,9 @@ The close sequence next[] lays out: singleton updates from the session, then add
       }
     }
     const gate = await readGate(gateDate);
-    const light = !gate.has("write");
+    if (wroteSinceClose && !gate.has("write") && await markWriteStep())
+      gate.set("write", 1);
+    const light = !(gate.has("write") || wroteSinceClose);
     const required = light ? LIGHT_PRECLOSE_STEPS : REQUIRED_PRECLOSE_STEPS;
     const missing = continued ? [] : required.filter((step) => !gate.has(step));
     if (missing.length && !force) {
@@ -25382,6 +25655,10 @@ ${contentBlock}` }));
       }
     }
     await clearGate(d);
+    const closeScope = await trilium.getNote(noteId).then((n) => labelOf2(n, "scope")).catch(() => null);
+    if (closeScope === "interactive") {
+      await trilium.updateLabelValue(noteId, "interactive", localNowTime()).catch(() => null);
+    }
     return txt3({
       action,
       noteId,
@@ -25394,6 +25671,7 @@ ${contentBlock}` }));
       ...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" } : {},
+      ...writeMarkPending ? { gateNote: writeMarkPending } : {},
       ...missing.length || !orderOk ? { bypassed: [...missing, ...!orderOk ? ["ordering(session\u2192remarks\u2192diary)"] : []] } : {},
       ...warnings.length ? { sanitized: warnings } : {}
     });
@@ -25527,7 +25805,7 @@ ${html}` }));
   });
   server.tool("remember", `Store something the moment it matters; the server owns placement, labels and dedup.
 
-Kinds: biography | goals | preferences | responsibilities | protocols (singletons, upsert) \xB7 thread (goal= required to create; shape="collection" for a titled-entry thread; appends need identity=) \xB7 threadEntry (a titled entry in a collection thread: thread= + title) \xB7 user (knowledge about the user) \xB7 information (domain= + title) \xB7 sources (domain=; revision=[\u2026] upserts rows).
+Kinds: biography | goals | preferences | responsibilities | protocols (singletons, upsert) \xB7 thread (goal= required to create; shape="collection" for a titled-entry thread; appends need identity=) \xB7 threadEntry (a titled entry in a collection thread: thread= + title) \xB7 user (knowledge about the user) \xB7 information (domain= + title) \xB7 sources (domain=; revision=[\u2026] upserts rows; dryRun=true previews rows and near-duplicate keys without writing).
 
 Collection kinds dedup by title \u2014 mustCreate=true refuses instead of adopting an existing note, and check action= on the receipt. connect=[{relation, toNoteId}] wires relations in the same call. diary/session/log/claim/domain have dedicated paths.`, {
     kind: enumType(Kinds).describe("What kind of memory this is"),
@@ -25548,17 +25826,20 @@ Collection kinds dedup by title \u2014 mustCreate=true refuses instead of adopti
     mandate: booleanType().optional().describe("kind=information: flag the note as a standing brief a session must follow (#mandate)"),
     mustCreate: booleanType().optional().describe("Refuse instead of adopting a note that already has this title"),
     strict: booleanType().optional().describe("Refuse the write when the body needs structural repair (unclosed tags, <br> runs) instead of accepting the repaired form"),
+    dryRun: booleanType().optional().describe('kind="sources": preview which Revision rows would be added or updated \u2014 and which body groups would merge \u2014 without writing anything. The way to check a new source key before it lands; default false (the call writes), so re-run without dryRun to apply'),
     connect: arrayType(objectType({
       relation: enumType(RelationTypes),
       toNoteId: stringType()
     })).optional().describe("Relations to wire from this note in the same call \u2014 same semantics as connect() (idempotent, worksWith wired both ways)"),
     icon: stringType().optional().describe('Display icon \u2014 a boxicons class ("bx bx-brain") or a bare name ("brain"); normalized server-side'),
     date: stringType().optional().describe("ISO date override (default: today)")
-  }, async ({ kind, title, body, goal, shape, thread, identity, domain, revision, topics, supersedes, mandate, mustCreate, strict, connect: connectRels, icon, date }) => {
+  }, async ({ kind, title, body, goal, shape, thread, identity, domain, revision, topics, supersedes, mandate, mustCreate, strict, dryRun, connect: connectRels, icon, date }) => {
     const refuseAdoption = (existingId, existingTitle, where) => err("already_exists", `A ${kind} note titled "${existingTitle}" already exists ${where} [${existingId}] \u2014 mustCreate=true refuses to adopt it.`, `Read it first with ${kind === "thread" ? "memory" : "knowledge"}(${existingId}). To add to it deliberately, re-run without mustCreate, or use revise(${existingId}, \u2026). To keep both, pick a title that distinguishes them.`);
     const opts = { domain, topics, date, ...mandate ? { mandate: true } : {} };
     const d = checkedDate(date);
     const { html, warnings: sanitizeWarnings } = renderBody(body ?? "");
+    if (dryRun !== undefined && kind !== "sources")
+      return err("conflicting_params", 'dryRun= applies only to remember(kind="sources"); nothing was written.', "For other kinds, read first (or use maintain(dryRun=true) for hygiene) and then write without dryRun.");
     if (strict) {
       const repairs = repairedStructure(sanitizeWarnings);
       if (repairs.length) {
@@ -25601,6 +25882,20 @@ Collection kinds dedup by title \u2014 mustCreate=true refuses instead of adopti
       return wiredEdges;
     };
     const ORPHAN_HINT = "Unconnected \u2014 wire a real relation now with connect() (or pass connect=[{relation, toNoteId}] on remember) so this note doesn't surface as an orphan in maintain(deep=true).";
+    const sourceKeyHints = (added, existing) => {
+      const pairs = [];
+      for (const a of added) {
+        const near = nearestKey(a, existing);
+        if (near)
+          pairs.push({ added: a, near });
+      }
+      if (!pairs.length)
+        return null;
+      return {
+        didYouMean: pairs[0].near.key,
+        didYouMeanNote: `${pairs.map((p) => `"${p.added}" \u2192 "${p.near.key}"`).join("; ")}. New Revision row(s) sit beside an existing source whose key is close \u2014 if one was meant to update that source, its key must match it exactly.`
+      };
+    };
     if (isSingleton(kind)) {
       const id = kindHome(b(), kind);
       if (!id)
@@ -25614,6 +25909,48 @@ Collection kinds dedup by title \u2014 mustCreate=true refuses instead of adopti
     if (kind === "sources") {
       if (!domain)
         return err("missing_param", 'kind="sources" requires a domain.', 'Call remember(kind="sources", domain="<domain name>", body="...")');
+      if (dryRun) {
+        const slug = slugify(domain) || "general";
+        const domRes = await trilium.searchNotes(`#noteType=domain #domain='${escapeQueryValue(slug)}'`, { ancestorNoteId: b().knowledge.domains, fastSearch: true, limit: 1 }).catch(() => ({ results: [] }));
+        const domainNote = domRes.results[0];
+        const srcRes = domainNote ? await trilium.searchNotes("#noteType=sources", { ancestorNoteId: domainNote.noteId, fastSearch: true, limit: 1 }).catch(() => ({ results: [] })) : { results: [] };
+        const display = domainNote?.title ?? domain.replace(/\s+/g, " ").trim();
+        const preview = { ok: true, action: "dry_run", dryRun: true, kind, date: d, domain: display };
+        const sidPreview = srcRes.results[0]?.noteId;
+        if (!domainNote)
+          preview.wouldCreate = `domain "${display}" and its canonical Sources note`;
+        else if (!sidPreview)
+          preview.wouldCreate = `${domainNote.title} \u2192 Sources note`;
+        else {
+          const content = await trilium.getNoteContent(sidPreview);
+          const existingKeys = tableRows(content, "Revision").map((cells) => cells[0]).filter(Boolean);
+          const previewChanges = [];
+          const previewAdded = [];
+          let sim = content;
+          for (const row of revision ?? []) {
+            const result = upsertTableRow(sim, "Revision", row.source, [row.marker, row.date ?? d]);
+            if (result.matched || result.created) {
+              sim = result.html;
+              previewChanges.push(`${result.matched ? "would update" : "would add"}: ${row.source}`);
+              if (!result.matched)
+                previewAdded.push(row.source);
+            }
+          }
+          if (previewChanges.length)
+            preview.revision = previewChanges;
+          if (html && toText(html, 50) && !content.includes(html)) {
+            const merged = mergeUnderSection(content, html, "Sources");
+            preview.body = `would merge into the Sources section${merged.mergedInto.length ? `: ${merged.mergedInto.join(", ")}` : ""}${merged.appended.length ? `; new group(s): ${merged.appended.join(", ")}` : ""}`;
+          }
+          const hints = sourceKeyHints(previewAdded, existingKeys);
+          if (hints) {
+            preview.didYouMean = hints.didYouMean;
+            preview.didYouMeanNote = hints.didYouMeanNote;
+          }
+        }
+        preview.next = "Nothing was written. Re-run without dryRun (or with dryRun=false) to apply exactly this.";
+        return txt3(preview);
+      }
       const { domainId, domainTitle, createdDomain, sourcesId } = await resolveDomain(trilium, b(), domain);
       const found = sourcesId ? { results: [] } : await trilium.searchNotes("#noteType=sources", { ancestorNoteId: domainId, fastSearch: true, limit: 1 }).catch(() => ({ results: [] }));
       let sid = sourcesId ?? found.results[0]?.noteId;
@@ -25639,8 +25976,11 @@ Collection kinds dedup by title \u2014 mustCreate=true refuses instead of adopti
         }
       }
       const revisionChanges = [];
+      const addedKeys = [];
+      let existingKeys = [];
       if (sid && revision?.length) {
         let current = await trilium.getNoteContent(sid);
+        existingKeys = tableRows(current, "Revision").map((cells) => cells[0]).filter(Boolean);
         let changed = false;
         for (const row of revision) {
           const result = upsertTableRow(current, "Revision", row.source, [row.marker, row.date ?? d]);
@@ -25648,6 +25988,8 @@ Collection kinds dedup by title \u2014 mustCreate=true refuses instead of adopti
             current = result.html;
             changed = true;
             revisionChanges.push(`${result.matched ? "updated" : "added"}: ${row.source}`);
+            if (!result.matched)
+              addedKeys.push(row.source);
           }
         }
         if (changed) {
@@ -25667,6 +26009,7 @@ Collection kinds dedup by title \u2014 mustCreate=true refuses instead of adopti
       const placeholderLeft = hasPlaceholderRow(finalHtml, "Revision");
       const bodyWritten = !!html && !!toText(html, 50);
       const looseProse = bodyWritten && !createdDomain && !/<(?:ul|ol|li|h[34]|table)\b/i.test(html);
+      const keyHints = sourceKeyHints(addedKeys, existingKeys);
       return txt3({
         action: wrote ? "maintained" : "already_written",
         noteId: sid,
@@ -25678,6 +26021,7 @@ Collection kinds dedup by title \u2014 mustCreate=true refuses instead of adopti
         ...sourceMerge,
         ...revisionKeys.length ? { revisionRows: revisionKeys.length } : {},
         ...revisionChanges.some((c) => c.startsWith("added:")) && revisionKeys.length ? { revisionKeys, revisionKeysNote: "A new Revision row was added. If it was meant to update an existing source, its key must match one of these exactly." } : {},
+        ...keyHints ? { didYouMean: keyHints.didYouMean, didYouMeanNote: keyHints.didYouMeanNote } : {},
         ...placeholderLeft ? { structureHint: "The Revision table still holds only its placeholder row. Every source marked \u2705 was verified by someone \u2014 record that with revision=[{source, marker, date}] so the table says so too; marker dates live there, never inline." } : {},
         ...looseProse ? { placementHint: "The body was appended to the Sources section as a loose block, which is rarely what a maintained source list wants. Fold it into the existing entries with revise(noteId, find=\u2026) \u2014 or pass list markup so it joins the list structurally." } : {},
         ...connected.length ? { connected } : {},
@@ -25783,6 +26127,7 @@ ${html}` : html;
       if (kind === "thread") {
         if (isCollectionThread(existing))
           return collectionAppendRefusal(existing);
+        const runHeading = leadingIdentityText(block);
         const entry = await appendThreadEntry(existing.noteId, block, d);
         if (entry.action === "already_written") {
           return txt3({ action: "already_written", noteId: existing.noteId, entryId: entry.noteId, kind, title: existing.title });
@@ -25797,7 +26142,7 @@ ${html}` : html;
         const connected = await wireRequested(existing.noteId);
         const iconSet = await applyIcon(existing.noteId, icon);
         const relations = relationSnippet(existing);
-        return txt3({ action: "updated", noteId: existing.noteId, entryId: entry.noteId, entryAction: entry.action, entry: `today's [${d}] entry in this thread; revise(entryId) edits it`, kind, title: existing.title, ...connected.length ? { connected } : {}, ...iconSet ? { icon: iconSet } : {}, ...relations ? { relations } : {}, ...sanitizeWarnings.length ? { sanitized: sanitizeWarnings } : {} });
+        return txt3({ action: "updated", noteId: existing.noteId, entryId: entry.noteId, entryAction: entry.action, ...entry.marker ? { entryMarker: entry.marker } : {}, ...runHeading ? { runHeading } : {}, entry: `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))
@@ -25861,7 +26206,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). 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.`, {
+  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. since=/until= (ISO dates) keep only notes last modified inside the window \u2014 ordered, ranked, regex and fuzzy paths all honour them. Every hit names matchedBy (label, title, text, ordered, fuzzy, regex) and the top hits carry evidence \u2014 the matched passage; a label hit quotes its label, a title hit its title, regex hits carry evidence on every hit. 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"),
@@ -25871,8 +26216,10 @@ ${block}`), d);
     orderDirection: enumType(["asc", "desc"]).optional().describe("asc | desc (default: desc for dates, asc for title)"),
     fastSearch: booleanType().optional().describe("Title/label only \u2014 faster, skips full-text body scan"),
     regex: stringType().optional().describe("Regular expression matched against note bodies (Trilium %= operator). Takes precedence over the keyword strategies; escape backslashes."),
-    fuzzy: booleanType().optional().describe("Force the fuzzy pass on (default: automatic when exact strategies return few results) or off")
-  }, async ({ query, kinds, domain, includeArchived, limit, orderBy, orderDirection, fastSearch, regex, fuzzy }) => {
+    fuzzy: booleanType().optional().describe("Force the fuzzy pass on (default: automatic when exact strategies return few results) or off"),
+    since: stringType().optional().describe("Only notes last modified on or after this ISO date (YYYY-MM-DD covers that whole day; a full ISO timestamp compares exactly)"),
+    until: stringType().optional().describe("Only notes last modified on or before this ISO date (inclusive; a date-only bound covers that whole day)")
+  }, async ({ query, kinds, domain, includeArchived, limit, orderBy, orderDirection, fastSearch, regex, fuzzy, since, until }) => {
     const cfg = b();
     const max = limit ?? 10;
     const fast = fastSearch ?? false;
@@ -25880,13 +26227,26 @@ ${block}`), d);
     const tokens = queryTokens(query);
     const domSlug = domain ? slugify(domain) : null;
     const kindSet = kinds?.length ? new Set(kinds) : null;
-    const run = (q, useFast = false, ord) => trilium.searchNotes(q, {
+    for (const [name, value] of [["since", since], ["until", until]]) {
+      if (value !== undefined && Number.isNaN(Date.parse(value)))
+        return err("invalid_param", `${name}="${value}" is not an ISO date.`, `Use YYYY-MM-DD (covers that whole day) or a full ISO timestamp, e.g. ${name}=2026-10-01.`);
+    }
+    let strategyErrors = 0;
+    const saturated = new Set;
+    const run = (q, useFast = false, strategy, ord) => trilium.searchNotes(q, {
       ancestorNoteId: cfg.root,
       limit: 30,
       fastSearch: useFast,
       includeArchivedNotes: includeArchived ?? false,
       ...ord ?? {}
-    }).then((r) => r.results).catch(() => []);
+    }).then((r) => {
+      if (strategy && r.results.length >= 30)
+        saturated.add(strategy);
+      return r.results;
+    }).catch(() => {
+      strategyErrors++;
+      return [];
+    });
     const filterNote = (note) => {
       const k = labelOf2(note, "noteType");
       if (!k)
@@ -25895,9 +26255,25 @@ ${block}`), d);
         return false;
       if (domSlug && labelOf2(note, "domain") !== domSlug)
         return false;
+      if (!withinModifiedWindow(note.dateModified, since, until))
+        return false;
       return true;
     };
-    const buildResult = async (note, i) => {
+    const evidenceFor = (note, content, matchedBy) => {
+      if (matchedBy === "label") {
+        const parts = [
+          labelOf2(note, "topic") === slug ? `#topic=${slug}` : null,
+          labelOf2(note, "domain") === slug ? `#domain=${slug}` : null
+        ].filter(Boolean);
+        return parts.length ? parts.join(" ") : null;
+      }
+      if (matchedBy === "title" || matchedBy === "fuzzy")
+        return note.title.length > 200 ? `${note.title.slice(0, 199)}\u2026` : note.title;
+      if (matchedBy === "regex")
+        return null;
+      return tokenPassage(toText(content, 1e5), tokens);
+    };
+    const buildResult = async (note, i, matchedBy) => {
       const relations = relationSnippet(note);
       const base = {
         id: note.noteId,
@@ -25906,11 +26282,13 @@ ${block}`), d);
         status: labelOf2(note, "status"),
         updated: note.dateModified.slice(0, 10),
         ...hasLabel(note, "archived") ? { archived: true } : {},
-        ...relations ? { relations } : {}
+        ...relations ? { relations } : {},
+        ...matchedBy ? { matchedBy } : {}
       };
       if (i < 3) {
         const content = await trilium.getNoteContent(note.noteId).catch(() => "");
-        return { ...base, snippet: toText(content, 280) };
+        const evidence = matchedBy ? evidenceFor(note, content, matchedBy) : null;
+        return { ...base, snippet: toText(content, 280), ...evidence ? { evidence } : {} };
       }
       return base;
     };
@@ -25933,11 +26311,7 @@ ${block}`), d);
       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" : ""}`;
+        return m ? passageAround(text, m.index, m[0].length) : "";
       };
       for (const n of candidates) {
         if (confirmed.length >= max)
@@ -25962,49 +26336,60 @@ ${block}`), d);
       }
       const results = await Promise.all(confirmed.map(async ({ note, evidence }, i) => {
         const { snippet: _snippet, ...base } = await buildResult(note, i);
-        return { ...base, ...evidence ? { evidence } : {} };
+        return { ...base, ...evidence ? { evidence } : {}, matchedBy: "regex" };
       }));
+      const failed = strategyErrors > 0 && results.length === 0;
       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
+        failed ? SEARCH_FAILURE_NOTE : null,
+        results.length === 0 && !failed ? "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 && !failed && 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);
       return txt3({
         mode: "regex",
         pattern: regex,
         results,
+        ...failed ? { searchFailed: true } : {},
         ...notes.length ? { note: notes.join(" ") } : {}
       });
     }
     if (orderBy) {
       const ord = { orderBy, orderDirection: orderDirection ?? (orderBy === "title" ? "asc" : "desc") };
       const q = query.trim() ? escapeQueryValue(query) : "#noteType";
-      const notes = await run(q, fast, ord);
+      const notes = await run(q, fast, "ordered", ord);
       const filtered = notes.filter(filterNote).slice(0, max);
-      const results = await Promise.all(filtered.map(buildResult));
-      return txt3({ results, ...results.length === 0 ? noMatch : {} });
+      const results = await Promise.all(filtered.map((n, i) => buildResult(n, i, "ordered")));
+      const failed = strategyErrors > 0 && results.length === 0;
+      const notices = [capWarning(saturated), results.length === 0 ? failed ? SEARCH_FAILURE_NOTE : noMatch.note : null].filter(Boolean);
+      return txt3({
+        results,
+        ...failed ? { searchFailed: true } : {},
+        ...notices.length ? { note: notices.join(" ") } : {}
+      });
     }
     const scores = new Map;
-    const add = (notes, weight) => {
+    const add = (notes, weight, strategy) => {
       for (const n of notes) {
         const entry = scores.get(n.noteId);
-        if (entry)
+        if (entry) {
           entry.score += weight;
-        else
-          scores.set(n.noteId, { note: n, score: weight });
+          entry.by.set(strategy, (entry.by.get(strategy) ?? 0) + weight);
+        } else {
+          scores.set(n.noteId, { note: n, score: weight, by: new Map([[strategy, weight]]) });
+        }
       }
     };
     const [byLabel, byTitleRaw, byText] = await Promise.all([
-      slug.length >= 3 ? run(`#topic='${slug}' OR #domain='${slug}'`, true) : Promise.resolve([]),
-      tokens.length ? run(tokens.map((t) => `note.title *=* '${escapeQueryValue(t)}'`).join(" OR "), fast || undefined) : Promise.resolve([]),
-      fast ? Promise.resolve([]) : run(escapeQueryValue(query))
+      slug.length >= 3 ? run(`#topic='${slug}' OR #domain='${slug}'`, true, "label") : Promise.resolve([]),
+      tokens.length ? run(tokens.map((t) => `note.title *=* '${escapeQueryValue(t)}'`).join(" OR "), fast || undefined, "title") : Promise.resolve([]),
+      fast ? Promise.resolve([]) : run(escapeQueryValue(query), false, "text")
     ]);
-    add(byLabel, 3);
-    add(byText, 1);
+    add(byLabel, 3, "label");
+    add(byText, 1, "text");
     const queryKey = titleKey(query);
     for (const n of byTitleRaw) {
       const lowerTitle = n.title.toLowerCase();
@@ -26017,18 +26402,18 @@ ${block}`), d);
         weight += 8;
       else if (queryKey.startsWith(noteKey) || noteKey.startsWith(queryKey))
         weight += 4;
-      add([n], weight);
+      add([n], weight, "title");
     }
     const EXACT_ENOUGH = 5;
     const fuzzyTokens = tokens.filter((t) => t.length >= 3);
     const wantFuzzy = fuzzy ?? (scores.size < EXACT_ENOUGH && fuzzyTokens.length > 0);
     const fuzzyIds = new Set;
     if (wantFuzzy && fuzzyTokens.length) {
-      const byFuzzy = await run(fuzzyTokens.map((t) => `note.title ~* '${escapeQueryValue(t)}'`).join(" OR "), fast);
+      const byFuzzy = await run(fuzzyTokens.map((t) => `note.title ~* '${escapeQueryValue(t)}'`).join(" OR "), fast, "fuzzy");
       for (const n of byFuzzy)
         if (!scores.has(n.noteId))
           fuzzyIds.add(n.noteId);
-      add(byFuzzy, 0.5);
+      add(byFuzzy, 0.5, "fuzzy");
     }
     const now = Date.now();
     const recency = (n) => {
@@ -26036,15 +26421,23 @@ ${block}`), d);
       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);
+    const results = await Promise.all(ranked.map(async ({ note, by }, i) => {
+      const row = await buildResult(note, i, dominantStrategy(by));
       return fuzzyIds.has(note.noteId) ? { ...row, fuzzy: true } : row;
     }));
     const fuzzyCount = results.filter((r) => ("fuzzy" in r)).length;
+    const failed = strategyErrors > 0 && results.length === 0;
+    const notices = [
+      capWarning(saturated),
+      failed ? SEARCH_FAILURE_NOTE : null,
+      strategyErrors > 0 && results.length > 0 ? `${strategyErrors} of the ranking queries failed at the backend \u2014 these results come from the strategies that responded, so the ranking may be partial.` : null,
+      results.length === 0 && !failed ? noMatch.note : null
+    ].filter(Boolean);
     return txt3({
       results,
       ...fuzzyCount ? { fuzzyMatches: `${fuzzyCount} result(s) came from the fuzzy pass (marked fuzzy: true) \u2014 treat them as leads to verify, not as answers.` } : {},
-      ...results.length === 0 ? noMatch : {}
+      ...failed ? { searchFailed: true } : {},
+      ...notices.length ? { note: notices.join(" ") } : {}
     });
   });
   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.`, {
@@ -26101,7 +26494,7 @@ ${block}`), d);
         groups[kind] = [];
       const relations = relationSnippet(n);
       const idle = idleSince(n.dateModified);
-      const stale = !RECORD_ROWS.has(kind) && idle >= staleAfter && !hasLabel(n, "archived");
+      const stale = !RECORD_ROWS.has(kind) && idle >= staleAfter && !hasLabel(n, "archived") && !isAcknowledged(n);
       if (stale)
         staleCount++;
       groups[kind].push({
@@ -26146,21 +26539,49 @@ ${block}`), d);
     });
   });
   const READ_BUDGET = 80000;
-  server.tool("read", `Several note bodies in one round trip: ids=[\u2026] (up to 10) \u2192 {notes:[{id, title, kind, content, relations}]}. Bodies are returned in order until about 80k characters; the rest come back under deferred[] with their sizes, to read in a second call. text=true returns readable plain text with the markup removed (headings, list items and table rows kept), smaller and easier to read \u2014 right for orienting, not for building a find= anchor. For one note prefer the kinded read; for a huge note prefer a section= read.`, {
+  server.tool("read", `Several note bodies in one round trip: ids=[\u2026] (up to 10) \u2192 {notes:[{id, title, kind, chars, content, relations}]}. Every entry carries chars, the size of that note's body in characters, so follow-up reads can be planned from this response alone. Bodies are returned in order until about 80k characters; the rest come back under deferred[] with their sizes, to read in a second call. section="<heading>" reads one section of each note instead of its whole body (h2\u2192h3\u2192h4 by heading text, occurrence= among repeats) \u2014 the cheap read of a huge note; a section holding a table also reports tableRows, its row count. text=true returns readable plain text with the markup removed (headings, list items and table rows kept), smaller and easier to read \u2014 right for orienting, not for building a find= anchor. For one note prefer the kinded read.`, {
     ids: arrayType(stringType()).min(1).max(10).describe("Note ids to read \u2014 one body per id, one round trip (cap 10)"),
-    text: booleanType().optional().describe("Return readable plain text instead of stored HTML (default false)")
-  }, async ({ ids, text }) => {
+    section: stringType().optional().describe("Read only this heading's section of each note (h2/h3/h4, same matching as the singletons' section=) instead of each whole body \u2014 the cheap read of a huge note; a miss returns the note's real headings under available[]"),
+    occurrence: numberType().int().positive().optional().describe("section=: which same-text heading, 1-based (default: the first)"),
+    text: booleanType().optional().describe("Return readable plain text instead of stored HTML (default false; with section=, the section only)")
+  }, async ({ ids, text, section, occurrence }) => {
     const fetched = await Promise.all(ids.map(async (id) => {
       try {
         const note = await trilium.getNote(id);
         const contentResult = await trilium.getNoteContentResult(id, note.type);
         const relations = relationSnippet(note);
         const raw = typeof contentResult === "string" ? contentResult : contentResult.content;
+        const identity = { id, title: note.title, kind: ownedLabel(note, "noteType") ?? undefined, chars: raw.length };
+        if (section && typeof contentResult !== "string") {
+          return { ...identity, content: "", section, matched: false, hint: "Binary content cannot be sectioned as text; read it without section=." };
+        }
+        if (section) {
+          const found = getSection(raw, section, occurrence ?? 1);
+          if (!found.matched) {
+            return {
+              ...identity,
+              content: "",
+              section,
+              matched: false,
+              available: found.available,
+              hint: `No "${section}" heading at h2/h3/h4. available= lists the note's real heading texts \u2014 re-target from there rather than falling back to a whole-note read.`
+            };
+          }
+          const tableRows = sectionTableRows(found.content);
+          return {
+            ...identity,
+            content: text ? readableText(found.content) : found.content,
+            section,
+            matched: true,
+            ...found.headingCount && found.headingCount > 1 ? { headingCount: found.headingCount, ...occurrence ? {} : { hint: `${found.headingCount} headings share that text \u2014 this is the FIRST. Pass occurrence= (1-${found.headingCount}) to read another.` } } : {},
+            ...tableRows !== undefined ? { tableRows } : {},
+            ...found.subsections?.length ? { subsections: found.subsections } : {},
+            ...relations ? { relations } : {}
+          };
+        }
         const content = text && typeof contentResult === "string" ? readableText(raw) : raw;
         return {
-          id,
-          title: note.title,
-          kind: ownedLabel(note, "noteType") ?? undefined,
+          ...identity,
           content,
           ...typeof contentResult === "string" ? {} : { contentEncoding: contentResult.encoding, mime: contentResult.mime },
           ...relations ? { relations } : {}
@@ -26184,7 +26605,7 @@ ${block}`), d);
     return txt3({
       count: notes.length,
       notes,
-      ...deferred.length ? { deferred, hint: `${deferred.length} note(s) held back to keep this result under ~${READ_BUDGET / 1000}k characters. Read them with read(ids=[\u2026]) again${text ? "" : ", or pass text=true, which is smaller"}.` } : {}
+      ...deferred.length ? { deferred, hint: `${deferred.length} note(s) held back to keep this result under ~${READ_BUDGET / 1000}k characters. Read them with read(ids=[\u2026]) again${text ? "" : ", or pass text=true, which is smaller"}; a huge one is cheapest one section at a time with section=.` } : {}
     });
   });
   const reviseDomain = async (name, plan, dry, d) => {
@@ -26259,12 +26680,12 @@ ${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. 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.
+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. dryRun=true with within= previews the change first \u2014 the element's full visible text and byte size, and for remove/replace the before/after shape \u2014 with nothing written and no revision taken. Keep anchors short; quotes match in any form, and within= also matches an element by its visible text ("Phase 2 | Claude | Open" for a row). append={table, row} adds one row to the table under that heading with no anchor to locate first \u2014 pipes are cell boundaries, a lone placeholder row is replaced, and append= composes with nothing else. closure= with within="tr" and mode="remove" closes a register row in one call: {thread, body} removes the row and appends the closure (quoting it) to that thread's entry for today (needs identity=); {note} moves the removed row into another register note's table, shaped to it instead of into a thread. "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.`, {
+Check the receipt: matched=false means a NEW section was written (available= lists real headings; strict=true refuses instead). A section replace swaps everything under the heading \u2014 use find= for anything smaller. find= matches stored HTML (tags literal), not rendered text, and is taken literally: a Windows path's backslash is one backslash, never doubled. A find= or within= anchor that matches nothing always names the cause in hint=, and a miss shows the stored text nearby when part of the anchor is still there (matchedUpTo= / storedNearby=).`, {
     noteId: stringType().optional().describe("Note to update (omit only with domain=)"),
     domain: stringType().optional().describe("Instead of noteId: apply find=/edits= to every maintained note in this domain (#domain or #topic slug). Records (sessions, diary, logs, dated thread entries) are never touched. Dry run unless dryRun=false"),
-    dryRun: booleanType().optional().describe("domain=: preview the matches without writing (default true). Re-run with dryRun=false to apply"),
+    dryRun: booleanType().optional().describe("domain= or within=: preview what would change, write nothing, take no revision (domain= defaults to true; within= previews only when true). Re-run with dryRun=false to apply"),
     body: stringType().optional().describe("Content to add/replace: plain text, markdown, or HTML. Send real tags: entity-escaped markup (&lt;p&gt;) is decoded and reported in sanitized[]. With find=, the raw replacement string (no conversion)."),
     title: stringType().optional().describe("New title (normalized server-side)"),
     section: stringType().optional().describe("Target a section by heading text (h2/h3/h4, in that order); omit for whole-note append/replace"),
@@ -26273,11 +26694,17 @@ Check the receipt: matched=false means a NEW section was written (available= lis
     mode: enumType(["append", "replace", "before", "after", "prepend", "remove"]).optional().describe("append (default) | replace | before | after (around the whole section=) | prepend (top of its body) | remove (delete section=, no body needed)"),
     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'),
+    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. dryRun=true previews it first'),
     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`),
+      thread: stringType().optional().describe('Thread variant: the dated thread to record the closure in: its id or title (e.g. "Escalations") \u2014 together with body='),
+      body: stringType().optional().describe("Thread variant: the closure prose: what settled it, who ruled, and where its durable substance went"),
+      note: stringType().optional().describe("Register variant: the register note (id or exact title) whose table receives the closed row \u2014 the row moves there instead of into a thread entry"),
+      table: stringType().optional().describe("Register variant: the heading of the table in that note (default: its first table)")
+    }).optional().describe(`With within= and mode="remove": close a register row in one call. {thread, body} appends the closure to that thread's entry for today, quoting the removed row \u2014 needs identity=. {note} moves the removed row into another register note's table instead, shaped to that table. Run consistency() afterwards on any fact the row asserted elsewhere`),
+    append: objectType({
+      table: stringType().describe("The heading (h2/h3/h4) of the table that receives the row"),
+      row: stringType().describe('One row, cells separated by "|" \u2014 e.g. "Item | Owner | Open"')
+    }).optional().describe('Append one row to the table under append.table without first locating an anchor row \u2014 pipes are cell boundaries, one <td> per cell (plain text, escaped server-side). A lone placeholder row is replaced. e.g. append={table: "Backlog", row: "Ship v13 | Claude | 2026-10-15"}'),
     edits: arrayType(objectType({
       find: stringType().describe("Exact raw string to replace"),
       body: stringType().describe("Raw replacement string"),
@@ -26286,20 +26713,30 @@ 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, 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")');
+  }, async ({ noteId: noteIdArg, domain, dryRun, body, title, section, occurrence, mode, find, nth, within, closure, append, edits, identity, icon, date, strict }) => {
+    if (closure) {
+      if (!(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 (closure.thread !== undefined === (closure.note !== undefined))
+        return err("conflicting_params", "closure= targets exactly one of a thread or a register note: pass {thread, body} or {note}.", 'e.g. closure={thread: "Escalations", body: "Closed on \u2026"} or closure={note: "Decisions", table: "Decisions"}');
+      if (closure.thread !== undefined && closure.body === undefined)
+        return err("missing_param", "closure={thread}= records the closure as prose and needs body=.", 'Pass body="<what settled it, who ruled, and where its durable substance went>".');
+      if (closure.note !== undefined && closure.body !== undefined)
+        return err("conflicting_params", "closure.body= belongs to the {thread} variant; {note} moves the row itself and appends no prose.", "Drop body=, or target a thread instead.");
+      if (closure.note === undefined && closure.table !== undefined)
+        return err("conflicting_params", "closure.table= names a table inside closure.note= and takes no effect without it.", 'Pass closure={note: "<register>", table: "<heading>"}, or drop table=.');
+    }
     if (domain !== undefined) {
       if (noteIdArg)
         return err("conflicting_params", "Pass noteId= or domain=, not both.", "domain= edits every note in the domain; noteId= edits one.");
       if (find === undefined && edits === undefined)
         return err("missing_param", "domain= needs find= (with body=) or edits=.", 'e.g. revise(domain="myClerkBook", find="Code Priority Queue", body="Backlog")');
-      if (within || section || title || mode || identity || icon)
+      if (within || section || title || mode || identity || icon || append)
         return err("conflicting_params", "domain= takes only find=/body=, edits=, nth= and dryRun=.", "Use noteId= for element, section, title or icon edits.");
       return reviseDomain(domain, edits ?? [{ find, body: body ?? "", nth }], dryRun ?? true, checkedDate(date));
     }
-    if (dryRun !== undefined)
-      return err("conflicting_params", "dryRun= applies only to revise(domain=); nothing was written.", "For one note, read it first (or outline()) and then revise without dryRun. diff(noteId) shows what a write changed.");
+    if (dryRun !== undefined && !within)
+      return err("conflicting_params", "dryRun= applies only to revise(domain=) and revise(within=); nothing was written.", "For one note, read it first (or outline()) and then revise without dryRun. diff(noteId) shows what a write changed.");
     if (!noteIdArg)
       return err("missing_param", "revise needs noteId= (or domain= for a domain-wide find/replace).", "Pass the id of the note to edit.");
     const noteId = noteIdArg;
@@ -26307,6 +26744,12 @@ Check the receipt: matched=false means a NEW section was written (available= lis
       return err("protected_note", `Note ${noteId} is a container \u2014 its content cannot be edited directly.`, "Use remember() to write to singletons, or specify a content note id.");
     if (within && find === undefined)
       return err("missing_param", "within= needs find= as its anchor.", 'Pass a short text unique to the element, e.g. revise(noteId, find="Phase 2", within="tr", body="<tr>\u2026</tr>").');
+    if (append) {
+      if (body !== undefined || find !== undefined || edits !== undefined || section !== undefined || within !== undefined || mode !== undefined || closure !== undefined)
+        return err("conflicting_params", "append= is a one-call row append and combines with none of body=/find=/edits=/section=/within=/mode=/closure=.", 'e.g. revise(noteId, append={table: "Backlog", row: "Ship v13 | Claude | 2026-10-15"}).');
+      if (!append.table.trim() || !append.row.split("|").some((c) => c.trim()))
+        return err("missing_param", 'append needs a table heading and one row of cells separated by "|".', 'e.g. append={table: "Backlog", row: "Ship v13 | Claude | 2026-10-15"}.');
+    }
     const d = checkedDate(date);
     const note = await trilium.getNote(noteId);
     const noteKind = labelOf2(note, "noteType");
@@ -26337,6 +26780,40 @@ Check the receipt: matched=false means a NEW section was written (available= lis
       }
       return { retitled: cleanTitle, cascaded };
     };
+    if (append) {
+      const cells = append.row.split("|").map((c) => c.trim());
+      const current = await trilium.getNoteContent(noteId);
+      const spot = findTable(current, append.table);
+      if (!spot) {
+        const section = getSection(current, append.table);
+        const available = section.available ?? [];
+        const near = !section.matched && available.length ? nearestHeading(append.table, available) : null;
+        const suggestion = near && near.distance <= Math.max(2, Math.floor(append.table.length / 5)) ? near : null;
+        return err("table_not_found", section.matched ? `"${append.table}" holds no table with a <tbody> to append to \u2014 nothing was written.` : `No "${append.table}" heading (h2/h3/h4) with a table under it \u2014 nothing was written.`, section.matched ? `Point append.table at the heading a table already sits under, or write the table's skeleton first (mode="append" with a <table> body).` : `Available headings: ${available.length ? available.join(" \xB7 ") : "(none)"}${suggestion ? ` \u2014 did you mean "${suggestion.heading}"?` : "."} outline(noteId) lists them.`);
+      }
+      await trilium.createRevision(noteId).catch(() => null);
+      const stamped = bumpLastUpdated(appendRowToTable(current, spot, cells.map((c) => escapeHtml(c))), d);
+      await trilium.updateNoteContent(noteId, stamped.html);
+      const titledAppend = await applyTitle();
+      const iconAppend = await applyIcon(noteId, icon);
+      await trilium.updateLabelValue(noteId, "updated", d);
+      if (labelOf2(note, "status") === "dormant")
+        await trilium.updateLabelValue(noteId, "status", "active");
+      const relsAppend = relationSnippet(note);
+      return txt3({
+        ok: true,
+        noteId,
+        mode: `append-row:${append.table}`,
+        date: d,
+        row: cells.join(" | "),
+        cells: cells.length,
+        ...titledAppend.retitled ? { retitled: titledAppend.retitled } : {},
+        ...iconAppend ? { icon: iconAppend } : {},
+        ...relsAppend ? { relations: relsAppend } : {},
+        ...structuralFindings(noteKind, stamped.html),
+        ...stamped.bumped ? { lastUpdated: "bumped to today \u2014 the line is server-owned" } : {}
+      });
+    }
     if (find !== undefined || edits !== undefined) {
       if (find !== undefined && edits !== undefined)
         return err("conflicting_params", "Pass either find= or edits=, not both.", "Fold the single find/body pair into the edits array.");
@@ -26395,31 +26872,89 @@ Check the receipt: matched=false means a NEW section was written (available= lis
             date: d,
             reason: res.reason,
             hint,
+            ...dryRun === true ? { dryRun: true } : {},
             ...res.elements ? { elements: res.elements } : {},
             ...res.reason === "no_match" ? missContext(find, current) : {}
           });
         }
-        if (res.html === current)
+        if (res.html === current && dryRun !== true)
           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 = "";
+        let closureTarget = null;
+        let closureCells = [];
+        let closurePadded = 0;
         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>
+          if (closure.note !== undefined) {
+            const ref = closure.note;
+            let target = /^[A-Za-z0-9]{12}$/.test(ref) ? await trilium.getNote(ref).catch(() => null) : null;
+            if (!target) {
+              const hits = await trilium.searchNotes(`note.title = '${escapeQueryValue(ref)}'`, { fastSearch: true, limit: 10 }).catch(() => ({ results: [] }));
+              const exact = hits.results.filter((n) => titleKey(n.title) === titleKey(ref));
+              if (exact.length > 1)
+                return err("ambiguous", `closure.note "${ref}" matches ${exact.length} notes \u2014 nothing was written.`, `Pass the note's id: ${exact.slice(0, 5).map((n) => `${n.title} [${n.noteId}]`).join(" \xB7 ")}`);
+              target = exact[0] ?? null;
+            }
+            if (!target)
+              return err("not_found", `closure.note "${ref}" is not a note; nothing was written.`, "Pass the register note's id or its exact title.");
+            if (isContainer(b(), target.noteId))
+              return err("protected_note", `closure.note "${target.title}" is a container \u2014 its content cannot be edited directly.`, "Target a register note (a maintained table).");
+            if (isRecordNote(target))
+              return err("record_note", `closure.note "${target.title}" is a record \u2014 records are never rewritten.`, "Use the {thread, body} variant for prose closures, or target the register that should hold the row.");
+            const targetContent = await trilium.getNoteContent(target.noteId);
+            const spot = findTable(targetContent, closure.table);
+            if (!spot)
+              return err("no_table", `closure.note "${target.title}" ${closure.table ? `has no table under "${closure.table}"` : "holds no table with a <tbody> to append to"} \u2014 nothing was written.`, closure.table ? "Pass the heading of the table that should receive the row (outline its headings first)." : 'Pass table="<heading>" to name the table, or give the note a table to receive the row.');
+            const removedCells = rowCells(res.element);
+            const fitted = fitRowCells(removedCells, spot.columns);
+            if (!fitted)
+              return err("row_shape", `The row has ${removedCells.length} cell(s) and "${target.title}"'s table has ${spot.columns} column(s): appending it would drop data, so nothing was written.`, "Reshape the row first (revise its cells), or target a register whose table matches the row.");
+            closureTarget = { note: target, ...closure.table !== undefined ? { heading: closure.table } : {}, content: targetContent, spot };
+            closureCells = fitted;
+            closurePadded = fitted.length - removedCells.length;
+          } else {
+            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>
+            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}`;
+          }
+        }
+        if (dryRun === true) {
+          const elementText = toText(res.element, 1200);
+          const fullText = toText(res.element, Number.MAX_SAFE_INTEGER);
+          const unchanged = res.html === current;
+          return txt3({
+            ok: true,
+            noteId,
+            mode: `within:${within}:${action}`,
+            dryRun: true,
+            date: d,
+            element: {
+              tag: within,
+              text: elementText,
+              bytes: Buffer.byteLength(res.element, "utf8"),
+              ...elementText.length < fullText.length ? { textTruncated: true } : {}
+            },
+            ...unchanged ? { unchanged: true, note: "body= equals the element it would replace, so a real run would write nothing and take no revision \u2014 this is the element as it stands." } : {
+              ...action === "remove" ? { before: boundPreview(res.element), after: "(removed \u2014 the surrounding content closes up)" } : action === "replace" ? { before: boundPreview(res.element), after: boundPreview(body ?? "") } : { inserts: { position: action, body: boundPreview(body ?? "") } },
+              ...closureThread ? { closure: { threadId: closureThread.noteId, thread: closureThread.title, wouldAppend: toText(closureBlock, 300) } } : {},
+              ...closureTarget ? { closure: { noteId: closureTarget.note.noteId, note: closureTarget.note.title, table: closureTarget.heading ?? "(first table)", row: closureCells.map((c) => toText(c, 80)).join(" | "), action: "would-append", ...closurePadded ? { padded: `${closurePadded} empty cell(s) added so the row matches the table's shape` } : {} } } : {}
+            },
+            matchedElements: res.matches,
+            next: "Nothing was written and no revision was taken. Re-run with dryRun=false to apply exactly this change."
+          });
         }
         await trilium.createRevision(noteId).catch(() => null);
         const withinResult = sanitizeHtml(res.html);
@@ -26437,14 +26972,47 @@ ${closureHtml}`;
           await trilium.updateLabelValue(closureThread.noteId, "updated", d);
           if (labelOf2(closureThread, "status") === "dormant")
             await trilium.updateLabelValue(closureThread.noteId, "status", "active");
+          const closureHeading = leadingIdentityText(closureBlock);
           closureReceipt = {
             threadId: closureThread.noteId,
             thread: closureThread.title,
             entryId: entry.noteId,
             action: entry.action,
+            ...entry.marker ? { entryMarker: entry.marker } : {},
+            ...closureHeading ? { runHeading: closureHeading } : {},
             next: "Run consistency() on any fact the closed row asserted elsewhere, so no stale sentence survives it."
           };
         }
+        if (closureTarget) {
+          const sameNote = closureTarget.note.noteId === noteId;
+          const base = sameNote ? await trilium.getNoteContent(noteId) : closureTarget.content;
+          const targetSpot = sameNote ? findTable(base, closureTarget.heading) : closureTarget.spot;
+          if (targetSpot) {
+            await trilium.createRevision(closureTarget.note.noteId).catch(() => null);
+            const regStamped = bumpLastUpdated(appendRowToTable(base, targetSpot, closureCells), d);
+            await trilium.updateNoteContent(closureTarget.note.noteId, regStamped.html);
+            await trilium.updateLabelValue(closureTarget.note.noteId, "updated", d);
+            if (labelOf2(closureTarget.note, "status") === "dormant")
+              await trilium.updateLabelValue(closureTarget.note.noteId, "status", "active");
+            const marked = hasLabel(closureTarget.note, "register") || ownedLabel(closureTarget.note, "noteType") === "thread";
+            closureReceipt = {
+              noteId: closureTarget.note.noteId,
+              note: closureTarget.note.title,
+              table: closureTarget.heading ?? "(first table)",
+              row: closureCells.map((c) => toText(c, 80)).join(" | "),
+              action: "appended",
+              ...closurePadded ? { padded: `${closurePadded} empty cell(s) added so the row matches the table's shape` } : {},
+              ...marked ? {} : { registerHint: `The target is not marked #register \u2014 label(noteId, "register", value="") exempts its table's evidence dates from maintain's dated-prose lint.` }
+            };
+          } else {
+            closureReceipt = {
+              noteId: closureTarget.note.noteId,
+              note: closureTarget.note.title,
+              action: "missed",
+              hint: "The row was removed, but the table could no longer be found in the target note \u2014 nothing was appended there. The source note has a revision from before the removal."
+            };
+          }
+        }
         return txt3({
           ok: true,
           noteId,
@@ -26468,11 +27036,12 @@ ${closureHtml}`;
         const applied = applyFindEdit(working, e.find, e.body, e.nth);
         if (!applied) {
           const alreadyConsumed = consumed.has(e.find);
+          const nthOvershot = !alreadyConsumed && e.nth !== undefined && working.includes(e.find);
           results.push({
             find: e.find,
             replaced: 0,
-            hint: missHint(e.find, current, alreadyConsumed),
-            ...alreadyConsumed ? {} : missContext(e.find, working)
+            hint: nthOvershot ? `nth=${e.nth} is past the last occurrence of this text, so nothing was replaced. The text itself is present \u2014 check how many occurrences exist, then re-target, or omit nth= to replace every one.` : missHint(e.find, current, alreadyConsumed),
+            ...alreadyConsumed || nthOvershot ? {} : missContext(e.find, working)
           });
           continue;
         }
@@ -26488,7 +27057,7 @@ ${closureHtml}`;
           mode: edits ? "edits" : "find-replace",
           replaced: 0,
           date: d,
-          ...edits ? { results } : {
+          ...edits ? { results, hint: `None of the ${plan.length} edit(s) matched anything \u2014 see results[].hint for the cause of each; nothing was written.` } : {
             hint: results[0].hint,
             ...results[0].matchedUpTo ? { matchedUpTo: results[0].matchedUpTo } : {},
             ...results[0].storedNearby ? { storedNearby: results[0].storedNearby } : {}
@@ -26584,6 +27153,7 @@ ${closureHtml}`;
     let finalContent = null;
     let sectionMiss = {};
     let threadEntryResult = null;
+    let threadRunHeading = null;
     if (body) {
       const sanitized = renderBody(body);
       const html = sanitized.html;
@@ -26634,6 +27204,7 @@ ${closureHtml}`;
           return badIdentity;
         const block = identity && !leadingIdentification(html) ? `<h3>${escapeHtml(identity)}</h3>
 ${html}` : html;
+        threadRunHeading = leadingIdentityText(block);
         threadEntryResult = await appendThreadEntry(noteId, block, d);
         if (threadEntryResult.action === "already_written") {
           return txt3({ ok: true, noteId, mode: "already_written", entryId: threadEntryResult.noteId, date: d });
@@ -26670,7 +27241,7 @@ ${block}`), d).html;
       } : {},
       ...sectionMiss,
       ...sectionHint ? { hint: sectionHint } : {},
-      ...threadEntryResult ? { entryId: threadEntryResult.noteId, entryAction: threadEntryResult.action, entry: `today's [${d}] entry in this thread; revise(entryId) edits it` } : {},
+      ...threadEntryResult ? { entryId: threadEntryResult.noteId, entryAction: threadEntryResult.action, ...threadEntryResult.marker ? { entryMarker: threadEntryResult.marker } : {}, ...threadRunHeading ? { runHeading: threadRunHeading } : {}, 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),
@@ -26942,7 +27513,7 @@ 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). 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.`, {
+  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. Multiple values co-asserted within one note \u2014 two true figures in one cell \u2014 are that note's compound fact, not a contradiction; only values no note asserts together flag as a 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)'),
@@ -27047,6 +27618,7 @@ calling twice is safe. Use remove=true to delete an edge.`, {
         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 noteValues = new Map;
       const byValue = new Map;
       const noCapture = [];
       let hasCaptureGroup = false;
@@ -27079,15 +27651,19 @@ calling twice is safe. Use remove=true to delete an edge.`, {
         const seen = new Set;
         for (const value of [...raw.values, ...projected.values]) {
           hasCaptureGroup = true;
-          if (seen.has(value))
-            continue;
           seen.add(value);
+        }
+        if (seen.size)
+          noteValues.set(n.noteId, { stub, values: seen });
+        if ((raw.matched || projected.matched) && !seen.size)
+          noCapture.push(stub);
+      }
+      for (const { stub, values } of noteValues.values()) {
+        for (const value of values) {
           if (!byValue.has(value))
             byValue.set(value, []);
           byValue.get(value).push(stub);
         }
-        if ((raw.matched || projected.matched) && !seen.size)
-          noCapture.push(stub);
       }
       if (!hasCaptureGroup) {
         return txt3({
@@ -27103,7 +27679,18 @@ calling twice is safe. Use remove=true to delete an edge.`, {
       }
       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;
+      const valueNotes = [...byValue.values()];
+      let crossNoteConflict = false;
+      for (let i = 0;i < valueNotes.length && !crossNoteConflict; i++) {
+        const ids = new Set(valueNotes[i].map((s) => s.id));
+        for (let j = i + 1;j < valueNotes.length; j++) {
+          if (!valueNotes[j].some((s) => ids.has(s.id))) {
+            crossNoteConflict = true;
+            break;
+          }
+        }
+      }
+      const agrees = !crossNoteConflict;
       return txt3({
         mode: "consistency",
         pattern,
@@ -27120,7 +27707,7 @@ calling twice is safe. Use remove=true to delete an edge.`, {
         ...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.`
+        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." : groups.length === 1 ? `All ${groups[0].count} note(s) agree on "${groups[0].value}".` : `${groups.length} different values were captured, but every pair of them is asserted together inside a single note \u2014 one note's compound fact (two true figures in one cell), not a contradiction. Re-measure if any value should be the only one.` : `${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.`
       });
     }
   });
@@ -27314,7 +27901,7 @@ calling twice is safe. Use remove=true to delete an edge.`, {
   };
   server.tool("claim", `Does the brain still agree with the world? Register a checkable assertion and record whether it holds. BrainLLM never runs the check \u2014 it stores it as inert text; you run it and report.
 
-assertion + check \u2192 register (deduped by assertion); claimId + holds + evidence \u2192 verify (evidence required); claimId alone \u2192 read with history; nothing \u2192 list (status= filters). noteId= links the claim to its source note (~derivedFrom). maintain(deep) surfaces lapsed, never-verified, broken and source-changed claims.`, {
+assertion + check \u2192 register (deduped by assertion); claimId + holds + evidence \u2192 verify (evidence required); claimId + holds + evidence + retire \u2192 verify and archive in one call; claimId alone \u2192 read with history; nothing \u2192 list (status= filters). noteId= links the claim to its source note (~derivedFrom). maintain(deep) surfaces lapsed, never-verified, broken and source-changed claims.`, {
     assertion: stringType().optional().describe('The claim in plain words, e.g. "the parse pipeline runs before validation" \u2014 also the dedup key'),
     check: stringType().optional().describe("How to verify it, as INERT text a human or agent runs: a command, a query, a file path, a URL. Never executed by BrainLLM"),
     noteId: stringType().optional().describe("The note this claim is made in \u2014 wired ~derivedFrom so the claim and its source stay linked"),
@@ -27323,7 +27910,7 @@ assertion + check \u2192 register (deduped by assertion); claimId + holds + evid
     holds: booleanType().optional().describe("With claimId: did the check pass? false marks the claim broken and surfaces it in maintain()"),
     evidence: stringType().optional().describe("With holds: what you actually observed \u2014 the output, the count, the response. A verification without evidence is an assertion about an assertion"),
     status: enumType(["holding", "broken", "lapsed", "all"]).optional().describe("List filter (default: all)"),
-    retire: booleanType().optional().describe("With claimId: archive this claim \u2014 the thing it described is gone")
+    retire: booleanType().optional().describe("With claimId: archive this claim \u2014 the thing it described is gone. On the same call as holds= and evidence=: record that final verification (e.g. the failure) and archive it in one call")
   }, async ({ assertion, check, noteId, intervalDays, claimId, holds, evidence, status, retire }) => {
     const cfg = b();
     if (!cfg.root)
@@ -27349,7 +27936,7 @@ assertion + check \u2192 register (deduped by assertion); claimId + holds + evid
       const note = await trilium.getNote(claimId).catch(() => null);
       if (!note || labelOf2(note, "noteType") !== "claim")
         return err("not_found", `${claimId} is not a claim.`, "List them with claim() and no arguments.");
-      if (retire) {
+      if (retire && holds === undefined) {
         await trilium.addLabel(claimId, "archived", "").catch(() => null);
         return txt3({ ok: true, claimId, action: "retired", assertion: note.title });
       }
@@ -27367,11 +27954,14 @@ assertion + check \u2192 register (deduped by assertion); claimId + holds + evid
       await trilium.updateLabelValue(claimId, "verified", d).catch(() => null);
       await trilium.updateLabelValue(claimId, "claimState", holds ? "holding" : "broken").catch(() => null);
       await trilium.updateLabelValue(claimId, "updated", d).catch(() => null);
+      if (retire)
+        await trilium.addLabel(claimId, "archived", "").catch(() => null);
       const refreshed = await trilium.getNote(claimId).catch(() => note);
       return txt3({
         ok: true,
         action: holds ? "verified" : "marked-broken",
         ...row(refreshed),
+        ...retire ? { retired: true, note: "The verification was recorded and the claim archived in this one call \u2014 its history stays in the Verifications section, and the register no longer lists it." } : {},
         ...holds ? {} : { hint: "This claim is now BROKEN. Correct every note that asserts it \u2014 consistency() will find the others \u2014 then re-verify. A broken claim left in the register is a known-wrong fact with a timestamp on it." }
       });
     }
@@ -27912,7 +28502,8 @@ and every thread day-child, in time order with its identification line.`, {
     const todaySess = await trilium.searchNotes(`#noteType=session #created='${todayStr}'`, { ancestorNoteId: cfg.memory.sessions, fastSearch: true, limit: 1 }).catch(() => ({ results: [] }));
     if (todaySess.results[0]) {
       const content = await trilium.getNoteContent(todaySess.results[0].noteId).catch(() => "");
-      newDay = !/<h2(?:\s[^>]*)?>\s*Addendum/i.test(content);
+      const note = await trilium.getNote(todaySess.results[0].noteId).catch(() => null);
+      newDay = note ? !hasLabel(note, "interactive") : !/<h2(?:\s[^>]*)?>\s*Addendum/i.test(content);
     }
     const sessions = await trilium.searchNotes("#noteType=session", {
       ancestorNoteId: cfg.memory.sessions,
@@ -27932,6 +28523,7 @@ and every thread day-child, in time order with its identification line.`, {
         previousLog = { id: log.results[0].noteId, content: await trilium.getNoteContent(log.results[0].noteId).catch(() => "") };
     }
     let changes = [];
+    let changesTruncated;
     if (lastSession) {
       try {
         const history = await trilium.getNoteHistory(cfg.root);
@@ -27941,12 +28533,14 @@ and every thread day-child, in time order with its identification line.`, {
           if (!prevEntry || h.current_isDeleted && !prevEntry.current_isDeleted)
             deduped.set(h.noteId, h);
         }
-        changes = [...deduped.values()].slice(0, 25).map((h) => ({
+        const capped = capChanges([...deduped.values()].map((h) => ({
           id: h.noteId,
           title: h.current_title,
           changed: h.date.slice(0, 10),
           ...h.current_isDeleted ? { deleted: true } : {}
-        }));
+        })));
+        changes = capped.changes;
+        changesTruncated = capped.changesTruncated;
       } catch {}
     }
     return txt3({
@@ -27955,6 +28549,7 @@ and every thread day-child, in time order with its identification line.`, {
       lastSession,
       previousLog,
       changes: changes.length ? changes : undefined,
+      ...changesTruncated ? { changesTruncated } : {},
       next: [
         "Skim lastSession, previousLog and changes for evidenced outputs \u2014 never plausibility.",
         "Present what moved in the first message."
@@ -28222,8 +28817,8 @@ and every thread day-child, in time order with its identification line.`, {
     tool.handler = async (...args) => {
       const result = await inner(...args);
       if (!wroteSinceClose && wroteContent(result)) {
-        await markStep("write").catch(() => null);
         wroteSinceClose = true;
+        await markWriteStep();
       }
       return result;
     };
@@ -28236,7 +28831,7 @@ function wroteContent(result) {
     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")
+    if (r.error || r.ok === false || r.unchanged === true || r.action === "already_written" || r.mode === "already_written" || r.dryRun === true)
       return false;
     if (r.replaced === 0 && !r.closure)
       return false;
@@ -30205,7 +30800,7 @@ function createServer(origin = null) {
   const s = new McpServer({
     name: BRAND2.name,
     title: BRAND2.name,
-    version: "12.9.0",
+    version: "13.0.0",
     description: BRAND2.description,
     websiteUrl: BRAND2.website,
     icons: brandIcons(origin)