recallnest 3.0.1 → 4.0.0

package/src/memory-lint.ts

@@ -185,7 +185,7 @@ function groupEntries(entries: MemoryEntry[]): Map<string, MemoryEntry[]> {
 // Check 1: Contradictions
 // ---------------------------------------------------------------------------
 
-function findContradictions(entries: MemoryEntry[]): LintFinding[] {
+export function findContradictions(entries: MemoryEntry[]): LintFinding[] {
   const findings: LintFinding[] = [];
 
   // Only check merge-type categories where contradictions are meaningful

package/src/memory-output.ts

@@ -8,6 +8,7 @@ import { parseNarrative } from "./narrative-schema.js";
 import { getConfidence, getConfidenceMetadata } from "./confidence-tracker.js";
 import { estimateTokens } from "./context-collapse-renderer.js";
 import { evaluateEntryFreshness, createFreshnessCache } from "./freshness.js";
+import { fullTextScoreThreshold, searchFirstScreen } from "./env-config.js";
 
 interface MemoryMetadata {
   source?: string;
@@ -115,6 +116,49 @@ function formatSessionImages(result: RetrievalResult): string | null {
   return `${parts.join(", ")} in this session · read sess=${sess}`;
 }
 
+interface DistilledSource {
+  /** 原会话日期（`date:` 标签），不是写入日——批量回填的行两者能差出半年。 */
+  date: string | null;
+  /** 写入时存在行上的原文 anchor；可能是当时助手说的，不一定是用户的话。 */
+  text: string;
+}
+
+/**
+ * 批量提炼行（pivot-apply 从历史会话回填，2026-08-04/05 共 1,516 条）：表里那句是转述，不是原话。
+ *
+ * 这批提炼句没逐条核对过——2026-09-11 抽 20 条对照各自存的原文，8 条有实质走样（丢限定词、
+ * 一次性要求记成长期规则、把当时助手的话记成用户偏好……）。原文 anchor 本来就存在行上，
+ * 读取时亮出来，比事后清洗存量便宜，也能罩住以后同一条路写进来的行。
+ *
+ * 只认 pivot-apply 标签：当场记录（manual / agent）的 anchor 语义不同，不在这里出。
+ * 不是批量行时返回 null，调用方据此什么都不输出——不给别的记忆添噪音。
+ */
+function getDistilledSource(result: RetrievalResult): DistilledSource | null {
+  const meta = parseMetadata(result.entry);
+  const tags = Array.isArray(meta.tags) ? meta.tags.map(String) : [];
+  if (!tags.includes("pivot-apply")) return null;
+  const dateTag = tags.find((tag) => tag.startsWith("date:"));
+  return {
+    date: dateTag ? dateTag.slice("date:".length) : null,
+    text: typeof meta.anchor === "string" ? meta.anchor : "",
+  };
+}
+
+const DISTILLED_ORIGIN_MAX_LEN = 160;
+
+// 措辞用英文，与 prov / imgs / fresh 行保持一致（这个输出面是英文的）。
+const DISTILLED_NOTE =
+  "rows with an orig line were batch-distilled from old sessions: the snippet is a paraphrase, " +
+  "orig is the source text (it may be the assistant's words, not the user's) — trust orig";
+
+function formatDistilledOrigin(source: DistilledSource): string {
+  const when = source.date ? `(${source.date} session) ` : "";
+  const text = source.text
+    ? cleanSnippet(source.text, DISTILLED_ORIGIN_MAX_LEN)
+    : "(source text missing)";
+  return `${when}${text}`;
+}
+
 function getProvenanceSummary(result: RetrievalResult): string {
   const provenance = extractMemoryProvenance({
     scope: result.entry.scope,
@@ -205,6 +249,7 @@ function getRetrievalPath(result: RetrievalResult): string {
   if (result.sources.vector) parts.push("vector");
   if (result.sources.bm25) parts.push("bm25");
   if (result.sources.reranked) parts.push("reranked");
+  if (result.sources.trigger) parts.push("trigger");
   if (result.sources.narrativeSibling) parts.push("narrative");
   return parts.join("+") || "direct";
 }
@@ -256,8 +301,12 @@ function pickBestSnippet(query: string, text: string): string {
  * adaptive 专用 query-aware snippet：取匹配词周围窗口（而非整句/开头），保证匹配证据可见。
  * 解决 pickBestSnippet 的两个退化（Codex 审点4 C 版 P2）：① 短缩写 query（如 "CI"）
  * extractTerms 提取不到词 → 退回开头；② 匹配在超长句/log 行后段 → cleanSnippet 从头截断丢匹配。
- * 只给 adaptive 用，不改 pickBestSnippet（避免影响 normal/explain 的既有行为）。
+ * adaptive 档与默认第一屏（`formatFullTextResults` 里超预算降级的那条路）共用；旧表格（legacy）与 explain
+ * 走的是 pickBestSnippet，不经这里。
  */
+const ADAPTIVE_SNIPPET_BEFORE = 60;
+const ADAPTIVE_SNIPPET_AFTER = 180;
+
 function adaptiveSnippet(query: string, text: string): string {
   const clean = text.replace(/\s+/g, " ").trim();
   const lower = clean.toLowerCase();
@@ -285,10 +334,8 @@ function adaptiveSnippet(query: string, text: string): string {
   }
   if (matchIdx < 0) return pickBestSnippet(query, text); // 完全无匹配 → 退回整句最佳
 
-  const WINDOW_BEFORE = 60;
-  const WINDOW_AFTER = 180;
-  const start = Math.max(0, matchIdx - WINDOW_BEFORE);
-  const end = Math.min(clean.length, matchIdx + WINDOW_AFTER);
+  const start = Math.max(0, matchIdx - ADAPTIVE_SNIPPET_BEFORE);
+  const end = Math.min(clean.length, matchIdx + ADAPTIVE_SNIPPET_AFTER);
   let snip = clean.slice(start, end).trim();
   if (start > 0) snip = "…" + snip;
   if (end < clean.length) snip = snip + "…";
@@ -336,6 +383,12 @@ function buildWhyMatched(query: string, result: RetrievalResult): string {
     reasons.push("reranked");
   }
 
+  if (result.sources.trigger) {
+    // T-Mem：说清是哪句预演问法把它捞出来的（只在 explain 露面，不进 context）
+    const t = result.sources.trigger;
+    reasons.push(`trigger「${t.text}」cos=${t.cosine.toFixed(2)}${t.admittedBy === "soft" ? ` overlap=${(t.overlap ?? 0).toFixed(2)}` : ""}`);
+  }
+
   if (matchedTerms.length > 0) {
     reasons.push(`terms:${matchedTerms.slice(0, 3).join(",")}`);
   }
@@ -384,14 +437,25 @@ export function formatBriefResults(
 ): string {
   if (results.length === 0) return "No results found.";
   const freshnessCache = createFreshnessCache();
-  const lines = [`Query: ${context.query}`, `Hits: ${results.length}`, ""];
+  // brief 只标不附原文：它就是为省 token 选的档，原文会让它长一倍。
+  const distilled = results.map(getDistilledSource);
+  const lines = [
+    `Query: ${context.query}`,
+    `Hits: ${results.length}`,
+    ...(distilled.some(Boolean)
+      ? ["Note: [distilled] rows paraphrase old sessions — use detail_level=normal to see the source text"]
+      : []),
+    "",
+  ];
   for (let i = 0; i < results.length; i++) {
     const r = results[i];
     const excerpt = extractBriefExcerpt(r);
+    const orig = distilled[i] ?? null;
+    const distilledTag = orig ? ` [distilled${orig.date ? `, ${orig.date} session` : ""}]` : "";
     // Freshness suffix: only for memories that declared dependsOn (opt-in, cheap check).
     const fresh = evaluateEntryFreshness(r.entry.metadata, freshnessCache);
     const freshTag = fresh ? ` [fresh:${fresh}]` : "";
-    lines.push(`#${i + 1} ${r.entry.id.slice(0, 8)} ${(r.score * 100).toFixed(1)}% — ${excerpt}${freshTag}`);
+    lines.push(`#${i + 1} ${r.entry.id.slice(0, 8)} ${(r.score * 100).toFixed(1)}% — ${excerpt}${distilledTag}${freshTag}`);
   }
   return lines.join("\n");
 }
@@ -403,10 +467,12 @@ export function formatFullResults(
   if (results.length === 0) return "No results found.";
 
   const freshnessCache = createFreshnessCache();
+  const distilled = results.map(getDistilledSource);
   const lines = [
     `Query   : ${context.query}`,
     `Profile : ${context.profile}`,
     `Hits    : ${results.length}`,
+    ...(distilled.some(Boolean) ? [`Note    : ${DISTILLED_NOTE}`] : []),
     "",
     "#  ID       Score Category     Tier       Source  Date       Age   Retrieval Path       File / Snippet",
     "-- -------- ----- ------------ ---------- ------- ---------- ----- -------------------- --------------",
@@ -418,6 +484,8 @@ export function formatFullResults(
     lines.push(`   prov : ${getProvenanceSummary(results[i])}`);
     const imgs = formatSessionImages(results[i]);
     if (imgs) lines.push(`   imgs : ${imgs}`);
+    const orig = distilled[i] ?? null;
+    if (orig) lines.push(`   orig : ${formatDistilledOrigin(orig)}`);
     // Full mode: append metadata details
     const meta = parseMetadata(results[i].entry);
     const evolution = typeof meta.evolutionStatus === "string" ? meta.evolutionStatus : "-";
@@ -448,17 +516,23 @@ export function formatFullResults(
   return lines.join("\n");
 }
 
-export function formatSearchResults(
+/**
+ * 2026-10-05 之前的默认第一屏：表格 + 每条 120 字片段。函数体一个字没动，只是改了名。
+ * 现在只在 `RECALLNEST_SEARCH_FIRST_SCREEN=legacy` 时由 `formatSearchResults` 走到（退回开关）。
+ */
+export function formatLegacyTableResults(
   results: RetrievalResult[],
   context: RenderContext,
 ): string {
   if (results.length === 0) return "No results found.";
 
   const freshnessCache = createFreshnessCache();
+  const distilled = results.map(getDistilledSource);
   const lines = [
     `Query   : ${context.query}`,
     `Profile : ${context.profile}`,
     `Hits    : ${results.length}`,
+    ...(distilled.some(Boolean) ? [`Note    : ${DISTILLED_NOTE}`] : []),
     "",
     "#  ID       Score Category     Tier       Source  Date       Age   Retrieval Path       File / Snippet",
     "-- -------- ----- ------------ ---------- ------- ---------- ----- -------------------- --------------",
@@ -470,6 +544,8 @@ export function formatSearchResults(
     lines.push(`   prov : ${getProvenanceSummary(results[i])}`);
     const imgs = formatSessionImages(results[i]);
     if (imgs) lines.push(`   imgs : ${imgs}`);
+    const orig = distilled[i] ?? null;
+    if (orig) lines.push(`   orig : ${formatDistilledOrigin(orig)}`);
     // Freshness: only shown for memories that declared dependsOn (opt-in, cheap check).
     const fresh = evaluateEntryFreshness(results[i].entry.metadata, freshnessCache);
     if (fresh) lines.push(`   fresh: ${fresh}`);
@@ -479,7 +555,182 @@ export function formatSearchResults(
 }
 
 const ADAPTIVE_TOKEN_BUDGET = 8000;
-const ADAPTIVE_FULL_SCORE = 0.85;
+
+/**
+ * 默认第一屏单条正文的封顶（按码点数）。
+ *
+ * 线是照库里的实际长度定的（2026-10-05 只读快照，138,501 条活跃记忆）：手写与提炼条目最长 2,278、
+ * 会话切片最长 2,077、记忆文件切片最长 1,523，都在线下，永远给全文；会被截的只有项目文档的大切片
+ * （`project:` 7,797 条，中位 2,401、最长 3,990）。封顶防的是一条长文档排第一时把后面几条的预算吃光。
+ */
+const FIRST_SCREEN_ENTRY_CAP = 2400;
+
+const DISTILLED_NOTE_FULLTEXT =
+  "entries with an orig line are batch-distilled paraphrases of old sessions; " +
+  "orig is the source text (it may be the assistant's words, not the user's) — trust orig";
+
+/**
+ * 条目行末尾的出处：有会话编号就给 `sess=前 8 位`（imgs 行、Deja 回查用的都是它）；文件名只在它不是
+ * 会话编号的重复时才给——Claude Code 的会话文件叫 `<会话编号>.jsonl`、Codex 的叫 `rollout-<时间>-<会话编号>.jsonl`，
+ * 再写一遍每条白占四五十个字。
+ */
+function getOriginLabel(result: RetrievalResult): string[] {
+  const meta = parseMetadata(result.entry);
+  const sessionId = typeof meta.sessionId === "string" ? meta.sessionId : "";
+  const file = getFileLabel(result);
+  const parts: string[] = [];
+  if (sessionId) parts.push(`sess=${sessionId.slice(0, 8)}`);
+  // 要整段会话编号对上才算重复：只对上前 8 位的可能是另有内容的文件名。
+  const repeatsSession = sessionId !== "" && file.endsWith(`${sessionId}.jsonl`);
+  if (file !== "-" && !repeatsSession) parts.push(file);
+  return parts;
+}
+
+const LONE_SURROGATE = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g;
+
+/**
+ * adaptiveSnippet / cleanSnippet 按 UTF-16 下标切，窗口边上可能留下半个代理对。
+ * 默认第一屏这条路上把落单的那半个去掉；那两个函数本身不动（adaptive、legacy、explain 的输出不变）。
+ */
+function dropLoneSurrogates(text: string): string {
+  return text.replace(LONE_SURROGATE, "");
+}
+
+/** 片段里属于原文的字数：去掉片段函数在两头补的省略号。 */
+function snippetSourceChars(snippet: string): number {
+  return Array.from(snippet.replace(/^…/, "").replace(/(…|\.\.\.)$/, "")).length;
+}
+
+/** 按码点取开头一段，不把代理对切成两半。`total` 是整条的码点数。 */
+function headByCodePoints(text: string, max: number): { head: string; total: number; truncated: boolean } {
+  const points = Array.from(text);
+  if (points.length <= max) return { head: text, total: points.length, truncated: false };
+  return { head: points.slice(0, max).join(""), total: points.length, truncated: true };
+}
+
+/**
+ * 默认第一屏（2026-10-05 起）：按名次给正文全文。
+ *
+ * 为什么不沿用 120 字片段：同一批 48 条真实查询、同一份命中，三位读者盲判「只看这一屏就够」，
+ * 表格 + 120 字是 1 条、全文是 18 条；旧默认屏里正文只占 23%，5 条全文合计的中位字数反而比它短。
+ * 为什么不按分数给（adaptive 的做法）：分数是融合排序分，只表示这一批里的相对位置，排第一的中位
+ * 只有 0.64，43 条非空查询里 31 条一条全文都拿不到。所以这里只看名次，不看分数。
+ *
+ * 规则：
+ *   - 按传入顺序（handler 已排好）逐条给正文；单条超过 FIRST_SCREEN_ENTRY_CAP 只给开头那一段。
+ *   - 给全文的额度是 ADAPTIVE_TOKEN_BUDGET（与 adaptive 同一个数，正文与 orig 行一起算）。放不下的条目降成
+ *     匹配词周围的片段，后面更短的条目放得下仍给全文。
+ *   - 每条命中都列出来，不因预算整条消失——这一点有意不照 adaptive（它超预算会停并报 omitted）。
+ *     所以 8000 是「给全文给到哪为止」的线，不是整屏的硬顶：片段、以及整条不比片段窗口（240 字）长的短条目
+ *     不受它拦，整屏最多超出「剩下每条一个片段」（limit ≤ 20；20 条都是 2400 个汉字时约 12,000）。
+ *     先给所有条目预留片段再分全文的做法试算过：尾部的片段会把排第一的长条目挤成片段，和「按名次给」相反。
+ *   - search_memory 的 related-scope 附栏各调一次本函数，各有一份额度。
+ *   - 缩短过的条目各带一行说明：共多少字、给了多少、用哪个编号展开。顶上 Text 行报整屏的全文 / 截断 / 片段条数。
+ *   - 元数据每条一行。旧表格里的 Tier 与 Retrieval Path 两列不再出，会话文件名换成 `sess=前 8 位`；
+ *     这三样 detail_level=full 里还有。
+ *   - imgs / orig / fresh 三种附加行照旧。
+ */
+export function formatFullTextResults(
+  results: RetrievalResult[],
+  context: RenderContext,
+): string {
+  if (results.length === 0) return "No results found.";
+
+  const freshnessCache = createFreshnessCache();
+  const blocks: string[] = [];
+  let tokensUsed = 0;
+  let fullCount = 0;
+  let cappedCount = 0;
+  let snippetCount = 0;
+  let anyOrig = false;
+
+  for (let i = 0; i < results.length; i++) {
+    const r = results[i];
+    const id = r.entry.id.slice(0, 8);
+    // 展开提示给完整编号：8 位前缀在库里有撞的（2026-10-05 快照 138,502 行里 2 组），撞了 memory_drill_down 取不回来。
+    const drillHint = `memory_drill_down ${r.entry.id} for the full text`;
+    const capped = headByCodePoints(r.entry.text, FIRST_SCREEN_ENTRY_CAP);
+    const orig = getDistilledSource(r);
+    const origLine = orig ? `   orig : ${dropLoneSurrogates(formatDistilledOrigin(orig))}` : "";
+    const origTokens = origLine ? estimateTokens(origLine) : 0;
+
+    let text = capped.head;
+    let cutNote = capped.truncated
+      ? `   … [truncated: showing ${FIRST_SCREEN_ENTRY_CAP} of ${capped.total} chars · ${drillHint}]`
+      : "";
+    let tokens = estimateTokens(text) + origTokens;
+    // 整条不比一个片段窗口长的条目不降级：降了也省不下字，只会多出一行「给了片段」的说明。
+    const worthSnipping = capped.total > ADAPTIVE_SNIPPET_BEFORE + ADAPTIVE_SNIPPET_AFTER;
+    if (worthSnipping && tokensUsed + tokens > ADAPTIVE_TOKEN_BUDGET) {
+      text = dropLoneSurrogates(adaptiveSnippet(context.query, r.entry.text));
+      cutNote = `   [snippet: token budget reached · showing ${snippetSourceChars(text)} of ${capped.total} chars · ${drillHint}]`;
+      tokens = estimateTokens(text) + origTokens;
+      snippetCount++;
+    } else if (capped.truncated) {
+      cappedCount++;
+    } else {
+      fullCount++;
+    }
+    tokensUsed += tokens;
+
+    const prov = getProvenanceSummary(r);
+    const header = [
+      id,
+      `${(r.score * 100).toFixed(1)}%`,
+      `${getDateLabel(r.entry.timestamp)} (${formatAgeLabel(r.entry.timestamp)})`,
+      getCategoryLabel(r),
+      getSourceLabel(r),
+      ...(prov !== "-" ? [prov] : []),
+      ...getOriginLabel(r),
+    ].join(" · ");
+    blocks.push(`[${i + 1}] ${header}`);
+    // fresh 管的是「这条还能不能照着用」，放在正文前面；只有声明过 dependsOn 的记忆才有（opt-in）。
+    const fresh = evaluateEntryFreshness(r.entry.metadata, freshnessCache);
+    if (fresh) blocks.push(`   fresh: ${fresh}`);
+    blocks.push(text);
+    if (cutNote) blocks.push(cutNote);
+    if (origLine) {
+      blocks.push(origLine);
+      anyOrig = true;
+    }
+    const imgs = formatSessionImages(r);
+    if (imgs) blocks.push(`   imgs : ${imgs}`);
+    blocks.push("");
+  }
+  // 去掉自己加的最后一个块间空行；不对整份输出 trimEnd，否则最后一条正文自己的结尾空白也会被吃掉。
+  blocks.pop();
+
+  // 全部给全的时候这一行只报条数；有缩短的才把封顶与预算写出来。
+  const shortened = cappedCount + snippetCount > 0;
+  const breakdown = [
+    `${fullCount} in full`,
+    ...(cappedCount > 0 ? [`${cappedCount} capped (${FIRST_SCREEN_ENTRY_CAP}-char cap)`] : []),
+    ...(snippetCount > 0 ? [`${snippetCount} snippet (${ADAPTIVE_TOKEN_BUDGET}-token budget)`] : []),
+  ].join(", ") + (shortened ? " — shortened entries say how much is shown" : "");
+  const lines = [
+    `Query   : ${context.query}`,
+    `Profile : ${context.profile}`,
+    `Hits    : ${results.length}`,
+    `Text    : ${breakdown}`,
+    ...(anyOrig ? [`Note    : ${DISTILLED_NOTE_FULLTEXT}`] : []),
+    "",
+    ...blocks,
+  ];
+  return lines.join("\n");
+}
+
+/**
+ * search_memory 默认档（detail_level=normal）、命令行 `search`、本地 UI 共用的入口。
+ * 默认出全文那一版；`RECALLNEST_SEARCH_FIRST_SCREEN=legacy` 退回表格 + 120 字片段。
+ */
+export function formatSearchResults(
+  results: RetrievalResult[],
+  context: RenderContext,
+): string {
+  return searchFirstScreen() === "legacy"
+    ? formatLegacyTableResults(results, context)
+    : formatFullTextResults(results, context);
+}
 
 /**
  * P-fidelity (点4): adaptive 保真度渲染 — 借鉴 RepoPrompt CE「保真度阶梯」的内核
@@ -489,7 +740,7 @@ const ADAPTIVE_FULL_SCORE = 0.85;
  * collapse 的 l0 floor / 按 score 重排 / query-agnostic fallback 都是为 resume 场景定制，
  * 搬到 search 连续撞三个 P2（隐藏过滤 / 覆盖 highlight 排序 / 丢失匹配证据）。search 的语义
  * 不同——结果是"为什么这条命中"，必须 query-aware；故第一版自实现两档：
- *   - 高相关（score ≥ 0.85）→ 全文
+ *   - 高相关（score ≥ fullTextScoreThreshold()：legacy 0.85，bounded 流行度下 0.80）→ 全文
  *   - 其余 → query-aware snippet（pickBestSnippet，显示匹配证据）
  * 按 handler 传入顺序（normal=score / highlight=contextual）依次填入 token 预算，超预算时
  * 全文降级 snippet、snippet 仍超则停止（剩余计入 omitted）。完整三档保真度阶梯（每条记忆预存
@@ -504,21 +755,27 @@ export function formatCollapsedResults(
   const rendered: string[] = [];
   let tokensUsed = 0;
   let shown = 0;
+  let anyOrigShown = false;
+  const fullScore = fullTextScoreThreshold();
 
   // 保留传入顺序（不重排）：handler 已按 normal=score / highlight=contextual 排好。
   for (const r of results) {
-    const isFull = r.score >= ADAPTIVE_FULL_SCORE;
+    const isFull = r.score >= fullScore;
     let level = isFull ? "FULL" : "SNIP";
     // query-aware：snippet 取匹配词周围窗口、显示匹配证据（search 是"为什么命中"）。
     let text = isFull ? r.entry.text : adaptiveSnippet(context.query, r.entry.text);
-    let tokens = estimateTokens(text);
+    // 批量提炼行附原文。它同样占预算，和正文一起算，别让原文把预算悄悄撑破。
+    const orig = getDistilledSource(r);
+    const origLine = orig ? `orig: ${formatDistilledOrigin(orig)}` : "";
+    const origTokens = origLine ? estimateTokens(origLine) : 0;
+    let tokens = estimateTokens(text) + origTokens;
 
     if (tokensUsed + tokens > ADAPTIVE_TOKEN_BUDGET) {
       if (isFull) {
         // 全文超预算 → 降级为 query-aware snippet
         text = adaptiveSnippet(context.query, r.entry.text);
         level = "SNIP";
-        tokens = estimateTokens(text);
+        tokens = estimateTokens(text) + origTokens;
       }
       if (tokensUsed + tokens > ADAPTIVE_TOKEN_BUDGET) break; // snippet 仍超 → 停止，剩余计入 omitted
     }
@@ -530,6 +787,10 @@ export function formatCollapsedResults(
     const scorePct = `${(r.score * 100).toFixed(0)}%`;
     rendered.push(`[${level}] ${id}  ${scorePct}  ${getCategoryLabel(r)}  ${getSourceLabel(r)}`);
     rendered.push(text);
+    if (origLine) {
+      rendered.push(origLine);
+      anyOrigShown = true;
+    }
     rendered.push("");
   }
 
@@ -537,8 +798,9 @@ export function formatCollapsedResults(
   const lines = [
     `Query   : ${context.query}`,
     `Profile : ${context.profile}`,
-    `Mode    : adaptive — full text for score ≥ ${ADAPTIVE_FULL_SCORE}, query-aware snippet otherwise, ${ADAPTIVE_TOKEN_BUDGET}-token budget`,
+    `Mode    : adaptive — full text for score ≥ ${fullScore}, query-aware snippet otherwise, ${ADAPTIVE_TOKEN_BUDGET}-token budget`,
     `Shown   : ${shown} of ${results.length}${omitted > 0 ? ` (${omitted} omitted: token budget)` : ""}`,
+    ...(anyOrigShown ? [`Note    : ${DISTILLED_NOTE}`] : []),
     "",
     ...rendered,
   ];