omp-vcc 0.1.6 → 0.1.7

package/extensions/main.ts

@@ -24,7 +24,7 @@ import { searchEntriesDetailed, getTouchedFiles } from "./vcc-core/core/search-e
 import { formatRecallOutput, formatTouchedOutput } from "./vcc-core/core/format-recall";
 import { getActiveLineageEntryIds } from "./vcc-core/core/lineage";
 import { normalizeRecallScope, normalizeRecallMode, parseRecallScope } from "./vcc-core/core/recall-scope";
-import { parseDrillDown, expandEntryFile } from "./vcc-core/core/drill-down";
+import { parseDrillDown, expandEntryFile, parseEntryRef, expandEntry } from "./vcc-core/core/drill-down";
 import { buildPiVccCustomInstructions, parseKeepAndPrompt } from "./vcc-core/core/compact-args";
 
 // Build omp sentinel instructions; keep pi sentinel for backward compat in hook
@@ -93,6 +93,25 @@ export default function (pi: ExtensionAPI): void {
 
       const q = p.query?.trim();
 
+      if (q && parseEntryRef(q)) {
+        const ref = parseEntryRef(q);
+        if (!ref) {
+          return { content: [{ type: "text", text: "Invalid entry ref query." }], details: undefined };
+        }
+        if (lineageEntryIds) {
+          const { rendered } = loadAllMessages(sessionFile, false, lineageEntryIds);
+          const exists = rendered.some((m) => m.index === ref.index);
+          if (!exists) {
+            return {
+              content: [{ type: "text", text: `Cannot expand indices outside active lineage: ${ref.index}. Use scope:'all' to reach other branches.` }],
+              details: undefined,
+            };
+          }
+        }
+        const text = expandEntry(sessionFile, ref.index, ref.full, ref.offset, ref.limit);
+        return { content: [{ type: "text", text }], details: undefined };
+      }
+
       if (q && parseDrillDown(q)) {
         const parsed = parseDrillDown(q);
         if (!parsed) {
@@ -153,7 +172,7 @@ export default function (pi: ExtensionAPI): void {
         const pageResults = hits.slice(start, start + PAGE_SIZE);
         const header = totalPages > 1 ? `Page ${page}/${totalPages} (${hits.length} total matches${scopeSuffix}${truncationNote})` : `${hits.length} matches${scopeSuffix}${truncationNote}`;
         const footer = page < totalPages ? `\n--- Use page:${page + 1}${scope === "all" ? " with scope:'all'" : ""} for more results ---` : "";
-        const output = formatRecallOutput(pageResults, q, header) + footer;
+        const output = formatRecallOutput(pageResults, q, header, { truncated, totalBeforeCap }) + footer;
         return { content: [{ type: "text", text: output }], details: undefined };
       }
       const output = (scope === "all" ? "Scope: all\n\n" : "") + formatRecallOutput(msgs.slice(-DEFAULT_RECENT), q);
@@ -277,7 +296,7 @@ export default function (pi: ExtensionAPI): void {
       const pageResults = hits.slice(start, start + PAGE_SIZE);
       const header = totalPages > 1 ? `Page ${page}/${totalPages} (${hits.length} total matches${scopeSuffix}${truncationNote})` : `${hits.length} matches${scopeSuffix}${truncationNote}`;
       const footer = page < totalPages ? `\n--- /vcc-recall ${query}${scopeArg} page:${page + 1} ---` : "";
-      const output = formatRecallOutput(pageResults, query, header) + footer;
+      const output = formatRecallOutput(pageResults, query, header, { truncated, totalBeforeCap }) + footer;
       try { piAny.sendMessage?.({ customType: "vcc-recall", content: output, display: true }, { triggerTurn: false }); } catch {}
       try { c.ui.notify(`vcc_recall: ${hits.length} hits`, "info"); } catch {}
     },
@@ -316,7 +335,7 @@ export default function (pi: ExtensionAPI): void {
       const pageResults = hits.slice(start, start + PAGE_SIZE);
       const header = totalPages > 1 ? `Page ${page}/${totalPages} (${hits.length} total matches${scopeSuffix}${truncationNote})` : `${hits.length} matches${scopeSuffix}${truncationNote}`;
       const footer = page < totalPages ? `\n--- /pi-vcc-recall ${query}${scopeArg} page:${page + 1} ---` : "";
-      const output = formatRecallOutput(pageResults, query, header) + footer;
+      const output = formatRecallOutput(pageResults, query, header, { truncated, totalBeforeCap }) + footer;
 
       try { piAny.sendMessage?.({ customType: "vcc-recall", content: output, display: true }, { triggerTurn: false }); } catch {}
     },

package/extensions/vcc-core/core/bayesian-probability.ts

@@ -0,0 +1,93 @@
+// @ts-nocheck
+//
+// Minimal port of the Bayesian probability transform from Cognica's
+// `bayesian-bm25-js` (Apache-2.0), itself the reference implementation of
+// Jeong 2026a "Bayesian BM25: A Probabilistic Framework for Hybrid Text and
+// Vector Search" (DOI 10.5281/zenodo.18414940).
+//
+// Only the score→probability pipeline is ported: sigmoid likelihood (Eq. 20),
+// term-frequency prior (Eq. 25), document-length prior (Eq. 26), composite
+// prior (Eq. 27), and the Bayesian posterior without base-rate correction
+// (Eq. 22). Deliberately NOT ported: the BM25 scorer itself (this repo keeps
+// its own BM25-lite), parameter fitting, online updates, multi-signal fusion,
+// vector calibration, and WAND bounds — none has a consumer here. If a ported
+// formula ever contradicts the paper, the paper wins.
+//
+// Converts unbounded BM25 scores into calibrated P(relevance) in [0,1] so a
+// single ABSOLUTE cutoff behaves consistently across sessions of different
+// sizes — the relative-floor heuristic this replaces existed only because raw
+// BM25 magnitudes are not comparable across corpora.
+
+/** Clamp floor/ceiling for probabilities (upstream EPSILON). */
+const EPSILON = 1e-10;
+
+/** Clamp `p` into [EPSILON, 1 - EPSILON]. */
+export const clampProbability = (p: number): number =>
+  Math.max(EPSILON, Math.min(1.0 - EPSILON, p));
+
+/** Numerically stable sigmoid (upstream branch: avoids exp overflow). */
+export const sigmoid = (x: number): number => {
+  if (x >= 0) return 1.0 / (1.0 + Math.exp(-x));
+  const expX = Math.exp(x);
+  return expX / (1.0 + expX);
+};
+
+/** Sigmoid likelihood of relevance given a BM25 score (Eq. 20):
+ *  sigma(alpha * (score - beta)). */
+export const scoreLikelihood = (score: number, alpha: number, beta: number): number =>
+  sigmoid(alpha * (score - beta));
+
+/** Term-frequency prior (Eq. 25): 0.2 + 0.7 * min(1, tf / 10). */
+export const tfPrior = (tf: number): number =>
+  0.2 + 0.7 * Math.min(1.0, tf / 10.0);
+
+/** Document-length normalisation prior (Eq. 26): peaks at half the average
+ *  document length, decaying for very short or very long documents. */
+export const normPrior = (docLenRatio: number): number =>
+  0.3 + 0.6 * (1.0 - Math.min(1.0, Math.abs(docLenRatio - 0.5) * 2.0));
+
+/** Composite prior (Eq. 27): clamp(0.7 * P_tf + 0.3 * P_norm, 0.1, 0.9).
+ *  Note the bounds are plain 0.1/0.9, not `clampProbability`. */
+export const compositePrior = (tf: number, docLenRatio: number): number =>
+  Math.max(0.1, Math.min(0.9, 0.7 * tfPrior(tf) + 0.3 * normPrior(docLenRatio)));
+
+/** Bayesian posterior without base-rate correction (Eq. 22, first step):
+ *  L*p / (L*p + (1-L)*(1-p)). Base rate stays null: its estimators need
+ *  pseudo-query sampling over a corpus with relevance labels, which a live
+ *  recall query cannot provide. */
+export const posterior = (likelihood: number, prior: number): number => {
+  const numerator = likelihood * prior;
+  return clampProbability(numerator / (numerator + (1.0 - likelihood) * (1.0 - prior)));
+};
+
+/** Full pipeline: BM25 score -> calibrated P(relevance).
+ *
+ *  Likelihood from the score, composite prior from tf and doc-length ratio,
+ *  combined by the Bayesian posterior. This is a per-document aggregate
+ *  transform (total score, total tf), an approximation of per-term posterior
+ *  fusion — sufficient for a noise gate, not a ranking signal. */
+export const scoreToProbability = (
+  score: number,
+  tf: number,
+  docLenRatio: number,
+  alpha: number,
+  beta: number,
+): number =>
+  posterior(scoreLikelihood(score, alpha, beta), compositePrior(tf, docLenRatio));
+
+/** Estimate sigmoid midpoint/shift from the query's own nonzero BM25 scores:
+ *  beta = median, alpha = 1/std (std = 0 -> alpha = 1.0). Mirrors
+ *  `BayesianBM25Scorer._estimateParameters` without its seeded pseudo-query
+ *  sampling step — deterministic, one O(n log n) pass over scores already
+ *  computed. Returns null when there is nothing to calibrate. */
+export const estimateLikelihoodParams = (scores: number[]): { alpha: number; beta: number } | null => {
+  const nonzero = scores.filter((s) => s > 0);
+  if (nonzero.length === 0) return null;
+  const sorted = [...nonzero].sort((a, b) => a - b);
+  const mid = Math.floor(sorted.length / 2);
+  const beta = sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
+  const mean = nonzero.reduce((a, b) => a + b, 0) / nonzero.length;
+  const variance = nonzero.reduce((a, b) => a + (b - mean) ** 2, 0) / nonzero.length;
+  const std = Math.sqrt(variance);
+  return { alpha: std > 0 ? 1.0 / std : 1.0, beta };
+};

package/extensions/vcc-core/core/brief.ts

@@ -237,6 +237,20 @@ const toolOneLiner = (name: string, args: Record<string, unknown>): string => {
   return `* ${name}`;
 };
 
+/**
+ * Source index of the result for the tool_call at `from`: the first following
+ * tool_result block with the same tool name, stopping at the next
+ * tool_call/user boundary. Null when the call has no visible result.
+ */
+const findToolResultIndex = (blocks: NormalizedBlock[], from: number, name: string): number | null => {
+  for (let i = from + 1; i < blocks.length; i++) {
+    const n = blocks[i];
+    if (n.kind === "tool_result" && n.name === name) return n.sourceIndex ?? null;
+    if (n.kind === "tool_call" || n.kind === "user") break;
+  }
+  return null;
+};
+
 export interface BriefLine {
   /** Section header like "[user]" or "[assistant]" */
   header: string;
@@ -310,32 +324,47 @@ export const buildBriefSections = (blocks: NormalizedBlock[]): BriefLine[] => {
       case "tool_call": {
         // Skip malformed tool calls from streaming providers (empty name / fragmented args).
         if (!b.name || b.name.trim() === "") break;
-        const ref = b.sourceIndex != null ? ` (#${b.sourceIndex})` : "";
+        const resultIdx = findToolResultIndex(blocks, blockIndex, b.name);
+        const ref = b.sourceIndex != null
+          ? (resultIdx != null ? ` (#${b.sourceIndex}, result #${resultIdx})` : ` (#${b.sourceIndex})`)
+          : (resultIdx != null ? ` (result #${resultIdx})` : "");
         const summary = toolOneLiner(b.name, b.args) + ref;
         push("[assistant]", summary);
         break;
       }
+      case "thinking":
+        // Searchable via recall, elided from the brief (reference lower_brief parity).
+        break;
       case "tool_result":
         // Tool result bodies are intentionally omitted from compact briefs.
         break;
     }
   }
 
-  // Collapse consecutive identical tool lines (same text, different #ref)
+  // Collapse consecutive identical tool lines (same text, different refs).
+  // Ref tokens are `#N` (call) or `result #N`; a merge accumulates tokens in
+  // order and sums repeat counts, e.g. `* Read "a" (#1, result #2)` followed
+  // by `* Read "a" (#3, result #4)` becomes
+  // `* Read "a" (#1, result #2, #3, result #4) x2`.
+  const isRefToken = (t: string): boolean => /^#\d+$/.test(t) || /^result #\d+$/.test(t);
+  const splitToolLine = (line: string): { base: string; refs: string[]; count: number } | null => {
+    const m = line.match(/^(.*?) \(([^()]*)\)(?: x(\d+))?$/);
+    if (!m) return null;
+    const refs = m[2].split(",").map((s) => s.trim()).filter(Boolean);
+    if (refs.length === 0 || !refs.every(isRefToken)) return null;
+    return { base: m[1], refs, count: m[3] ? parseInt(m[3]) : 1 };
+  };
   for (const sec of sections) {
     if (sec.header !== "[assistant]") continue;
     const out: string[] = [];
     for (const line of sec.lines) {
       if (!line.startsWith("* ")) { out.push(line); continue; }
-      const ref = line.match(/\(#(\d+)\)$/)?.[1] ?? "";
-      const base = ref ? line.slice(0, -(ref.length + 3)).trimEnd() : line;
-      const last = out.length > 0 ? out[out.length - 1] : "";
-      const m = last.match(/^(.*) \((#[\d, #]+)\) x(\d+)$/);
-      if (m && m[1] === base) {
-        out[out.length - 1] = `${base} (${m[2]}, #${ref}) x${parseInt(m[3]) + 1}`;
-      } else if (last.match(/\(#\d+\)$/) && last.replace(/\s*\(#\d+\)$/, "") === base) {
-        const prevRef = last.match(/\(#(\d+)\)$/)?.[1];
-        out[out.length - 1] = `${base} (#${prevRef}, #${ref}) x2`;
+      const cur = splitToolLine(line);
+      const last = out.length > 0 ? splitToolLine(out[out.length - 1]) : null;
+      if (cur && last && cur.base === last.base) {
+        const refs = [...last.refs];
+        for (const r of cur.refs) if (!refs.includes(r)) refs.push(r);
+        out[out.length - 1] = `${cur.base} (${refs.join(", ")}) x${last.count + cur.count}`;
       } else {
         out.push(line);
       }

package/extensions/vcc-core/core/content.ts

@@ -50,6 +50,17 @@ export const textParts = (content: Message["content"]): string[] => {
 export const textOf = (content: Message["content"]): string =>
   textParts(content).join("\n");
 
+export const thinkingParts = (content: Message["content"]): string[] => {
+  if (!content || typeof content === "string") return [];
+  return content
+    .filter((part) => part.type === "thinking")
+    .map((part) => (part.thinking ?? part.text ?? "") as string)
+    .filter((t) => typeof t === "string" && t.length > 0);
+};
+
+export const thinkingOf = (content: Message["content"]): string =>
+  thinkingParts(content).join("\n");
+
 /**
  * Check if tool call arguments contain content-bearing data.
  *

package/extensions/vcc-core/core/drill-down.ts

@@ -296,4 +296,89 @@ Use #${entryIndex}:<more-specific-path> to drill into a specific file.`;
   }
 
   return formatToolCallContent(matched[0], entryIndex, { full, offset, limit });
+}
+
+// ── Bare entry refs: #N, #N:full, #N:offset, #N:offset:limit ────────────────
+
+/**
+ * Pattern: #N, #N:full, #N:offset, or #N:offset:limit — full entry text.
+ * Checked BEFORE parseDrillDown in dispatch: a purely numeric path segment
+ * (`#42:30`) reads as entry 42 at line offset 30, consistent with the
+ * trailing-number-means-offset convention of #N:path:offset.
+ */
+const ENTRYREF_PATTERN = /^#(\d+)(?::(full|\d+(?::\d+)?))?$/;
+
+/**
+ * Parse a bare entry ref like #42, #42:full, #42:30, or #42:30:20.
+ * Returns null unless the whole query is the ref pattern (same ^$ anchoring
+ * contract as parseDrillDown).
+ */
+export function parseEntryRef(query: string): {
+  index: number;
+  full: boolean;
+  offset?: number;
+  limit?: number;
+} | null {
+  const match = query.match(ENTRYREF_PATTERN);
+  if (!match) return null;
+  const index = parseInt(match[1], 10);
+  const suffix = match[2];
+  if (suffix === "full") return { index, full: true, offset: undefined, limit: undefined };
+  if (suffix !== undefined) {
+    const parts = suffix.split(":");
+    const offset = parseInt(parts[0], 10);
+    const limit = parts[1] !== undefined ? parseInt(parts[1], 10) : undefined;
+    if (!Number.isNaN(offset)) return { index, full: false, offset, limit };
+  }
+  return { index, full: false, offset: undefined, limit: undefined };
+}
+
+const ENTRY_PREVIEW_LIMIT = 30;
+
+/**
+ * Expand a bare entry ref (#N) to the entry's full rendered text — the
+ * inline-architecture counterpart of resolving a brief pointer into the
+ * lossless full view. The :full body is the renderMessage(msg, N, true)
+ * summary verbatim; the default preview and offset/limit windows mirror
+ * formatToolCallContent's contract (30-line preview, "Lines X-Y (of Z)").
+ */
+export function expandEntry(
+  sessionFile: string,
+  entryIndex: number,
+  full = false,
+  offset?: number,
+  limit?: number,
+): string {
+  const { rendered } = loadAllMessages(sessionFile, true);
+  if (entryIndex < 0 || entryIndex >= rendered.length) {
+    return `Entry #${entryIndex} not found in session history.`;
+  }
+  const e = rendered[entryIndex];
+  const header = `#${entryIndex} [${e.role}]`;
+  const body = e.summary;
+  if (full) return `${header}\n\n${body}`;
+  const allLines = body.split("\n");
+  const totalLines = allLines.length;
+  if (offset !== undefined) {
+    const startLine = Math.max(0, offset);
+    const maxLines = limit ?? ENTRY_PREVIEW_LIMIT;
+    const endLine = Math.min(startLine + maxLines, totalLines);
+    const visible = allLines.slice(startLine, endLine);
+    const displayStart = startLine + 1; // 1-indexed for user display
+    if (visible.length === 0) {
+      return `Offset ${startLine} is beyond entry length ${totalLines}. Use #${entryIndex} for the first ${ENTRY_PREVIEW_LIMIT} lines.`;
+    }
+    let result = `${header}\nLines ${displayStart}-${endLine} (of ${totalLines}):\n\n${visible.join("\n")}`;
+    if (endLine < totalLines) {
+      result += `\n\n--- Use #${entryIndex}:${endLine} or #${entryIndex}:${endLine}:${maxLines} for next ${maxLines} lines, #${entryIndex}:full for complete ---`;
+    } else if (offset > 0) {
+      result += `\n\n(End of entry)`;
+    }
+    return result;
+  }
+  if (totalLines > ENTRY_PREVIEW_LIMIT) {
+    const preview = allLines.slice(0, ENTRY_PREVIEW_LIMIT).join("\n");
+    return `${header}\n\n${preview}\n\n...(${totalLines - ENTRY_PREVIEW_LIMIT} more lines — use #${entryIndex}:full for complete content, or #${entryIndex}:${ENTRY_PREVIEW_LIMIT} for next ${ENTRY_PREVIEW_LIMIT} lines)`;
+  }
+  return `${header}\n\n${body}`;
 }

package/extensions/vcc-core/core/format-recall.ts

@@ -78,6 +78,7 @@ export const formatRecallOutput = (
   entries: SearchHit[],
   query?: string,
   headerOverride?: string,
+  opts?: { truncated?: boolean; totalBeforeCap?: number },
 ): string => {
   if (entries.length === 0) {
     return query
@@ -97,5 +98,12 @@ export const formatRecallOutput = (
     return `#${e.index} [${e.role}]${fileSuffix} ${body}`;
   });
 
-  return `${header}\n\n${lines.join("\n\n")}`;
+  const body = `${header}\n\n${lines.join("\n\n")}`;
+  // Every hit ref resolves: #N expands the full entry (see expandEntry in
+  // drill-down.ts). Surface the hint when results are capped or clipped.
+  const clipped = entries.some((e) => e.snippet?.includes("...("));
+  if (opts?.truncated || clipped) {
+    return `${body}\n\n--- Use #N for full entry text ---`;
+  }
+  return body;
 };

package/extensions/vcc-core/core/normalize.ts

@@ -45,6 +45,9 @@ const normalizeOne = (msg: Message, msgIndex: number): NormalizedBlock[] => {
     for (const part of msg.content) {
       if (part.type === "text") {
         blocks.push({ kind: "assistant", text: sanitize(part.text), sourceIndex: msgIndex });
+      } else if (part.type === "thinking") {
+        const thinkingText = sanitize(part.text ?? part.thinking ?? "");
+        if (thinkingText) blocks.push({ kind: "thinking", text: thinkingText, sourceIndex: msgIndex });
       } else if (part.type === "toolCall") {
         blocks.push({
           kind: "tool_call",

package/extensions/vcc-core/core/render-entries.ts

@@ -1,6 +1,6 @@
 // @ts-nocheck
 import type { Message } from "@oh-my-pi/pi-ai";
-import { clip, textOf } from "./content";
+import { clip, textOf, thinkingOf } from "./content";
 import { summarizeToolArgs } from "./tool-args";
 import { extractPath } from "./tool-args";
 
@@ -45,9 +45,13 @@ export const renderMessage = (msg: Message, index: number, full = false): Render
     const text = full ? `$ ${cmd}\n${out}` : clip(`$ ${cmd}\n${out}`, 300);
     return { index, role: "bash", summary: text };
   }
+  const thinking = thinkingOf(msg.content);
   const text = full ? textOf(msg.content) : clip(textOf(msg.content), 300);
   const tools = toolCalls(msg.content);
   const files = extractFilesFromContent(msg.content);
+  if (!text && !tools && thinking) {
+    return { index, role: "thinking", summary: full ? thinking : clip(thinking, 300) };
+  }
   const summary = tools ? `${tools}\n${text}` : text;
   return { index, role: "assistant", summary, ...(files.length > 0 && { files }) };
 };

package/extensions/vcc-core/core/search-entries.ts

@@ -1,13 +1,16 @@
 // @ts-nocheck
 import type { Message } from "@oh-my-pi/pi-ai";
 import type { RenderedEntry } from "./render-entries";
-import { textOf, isContentBearing, extractToolCallText, extractToolCallArgsText, clip } from "./content";
+import { textOf, thinkingOf, isContentBearing, extractToolCallText, extractToolCallArgsText, clip } from "./content";
+import { scoreToProbability, estimateLikelihoodParams } from "./bayesian-probability.ts";
 
 export interface SearchHit extends RenderedEntry {
   /** Context snippet around the first matched term (only when query provided) */
   snippet?: string;
   /** Number of query terms matched (for ranking) */
   matchCount?: number;
+  /** Calibrated P(relevance) from the Bayesian transform (BM25 path only) */
+  probability?: number;
 }
 
 /**
@@ -18,7 +21,7 @@ export interface SearchHit extends RenderedEntry {
 export interface SearchResult {
   hits: SearchHit[];
   /** Genuine matches found before the hard cap was applied (after any
-   *  relative-floor noise filtering). May exceed `hits.length`. */
+   *  posterior-gate noise filtering). May exceed `hits.length`. */
   totalBeforeCap: number;
   /** True when the hard cap discarded matches (`totalBeforeCap > hits.length`). */
   truncated: boolean;
@@ -194,24 +197,30 @@ const buildBM25Context = (docs: string[], terms: string[], checkBudget: () => vo
   return { n, avgDl: totalLen / Math.max(n, 1), df };
 };
 
-/** BM25 score for a single doc against query terms. */
-const bm25Score = (doc: string, terms: string[], ctx: BM25Context): number => {
+/** BM25 score for a single doc against query terms, plus the calibration
+ *  inputs the Bayesian posterior needs: total term frequency across terms,
+ *  distinct normalized matched terms (coverage parity), and the doc-length
+ *  ratio. Same pass — no re-scanning. */
+const bm25Score = (doc: string, terms: string[], ctx: BM25Context): { score: number; tf: number; distinctTerms: number; docLenRatio: number } => {
   const dl = doc.split(/\s+/).length;
   let score = 0;
+  let totalTf = 0;
+  const seenTerms = new Set<string>();
 
   for (const t of terms) {
-    const tf = termFreq(doc, safeRegex(t));
-    if (tf === 0) continue;
+    const termTf = termFreq(doc, safeRegex(t));
+    if (termTf === 0) continue;
+    totalTf += termTf;
+    seenTerms.add(t.toLowerCase());
 
     const docFreq = ctx.df.get(t) ?? 0;
     // IDF: log((N - df + 0.5) / (df + 0.5) + 1)
     const idf = Math.log((ctx.n - docFreq + 0.5) / (docFreq + 0.5) + 1);
-    // TF saturation with length normalization
-    const tfNorm = (tf * (BM25_K + 1)) / (tf + BM25_K * (1 - BM25_B + BM25_B * dl / ctx.avgDl));
+    const tfNorm = (termTf * (BM25_K + 1)) / (termTf + BM25_K * (1 - BM25_B + BM25_B * dl / ctx.avgDl));
     score += idf * tfNorm;
   }
 
-  return score;
+  return { score, tf: totalTf, distinctTerms: seenTerms.size, docLenRatio: ctx.avgDl > 0 ? dl / ctx.avgDl : 1 };
 };
 
 /** Line-based snippet: ±contextLines around first regex match. */
@@ -300,8 +309,9 @@ const fullText = (msg: Message): string => {
     return "";
   }
   const text = textOf(msg.content);
+  const thinking = thinkingOf(msg.content);
   const argsText = toolCallArgsText(msg.content);
-  return argsText ? `${text}\n${argsText}` : text;
+  return [text, thinking, argsText].filter(Boolean).join("\n");
 };
 
 /**
@@ -358,63 +368,57 @@ export function getTouchedFiles(
 }
 
 /**
- * Relative BM25 noise floor for MULTI-TERM natural-language queries only:
- * after sorting by score, drop hits scoring below this fraction of the top
- * score. Relative (not absolute) because BM25 magnitudes vary with corpus
- * size and document length, so a fixed score threshold would behave
- * inconsistently across short vs. long sessions.
+ * Absolute Bayesian posterior floor for MULTI-TERM natural-language queries
+ * only: after sorting by BM25 score, drop hits whose calibrated P(relevance)
+ * is below this threshold. Absolute (not relative) because the posterior
+ * already normalizes away corpus size and document length — that is the
+ * point of the score→probability transform (`bayesian-probability.ts`).
+ * Raw BM25 magnitudes vary across sessions, so no fixed score threshold
+ * behaves consistently; posteriors are comparable, which is also what the
+ * cross-session merge needs.
  *
  * Applied only when the query has >=2 DISTINCT effective terms after
  * stopword filtering and case/duplicate normalization (see the
- * `effectiveTermCount >= 2` gate below `searchEntriesDetailed` uses before
- * calling `applyRelativeFloor`). Distinct, not raw count: "auth auth" or
- * "Auth AUTH" is semantically a single-term query and must bypass the floor
+ * `effectiveTermCount >= 2` gate `searchEntriesDetailed` uses before calling
+ * `applyProbabilityFloor`). Distinct, not raw count: "auth auth" or
+ * "Auth AUTH" is semantically a single-term query and must bypass the gate
  * like any other single term — repeating or casing a word doesn't turn it
- * into the multi-term OR-tail noise this floor targets. The normalization is
+ * into the multi-term OR-tail noise this gate targets. The normalization is
  * gate-only; it doesn't change `terms` or the BM25 scoring itself, which
  * already matches case-insensitively. For a genuine single term, every hit's
  * occurrence already satisfies the whole query — its BM25 score differences
  * reflect term frequency and document length, not multi-term OR-tail noise,
  * so filtering by it there risks real matches for no corresponding noise
- * reduction. Evidence below confirmed this rather than assuming it.
+ * reduction. (The bypass is structural, pinned by the single-term tests in
+ * `tests/search-entries.test.ts`; a seeded bench of 540 trials against the
+ * prior relative floor — old module resurrected from git, planted relevant
+ * docs in OR-tail noise — confirmed 1.0 planted recall for both filters with
+ * strictly less noise kept under the new gate, and top-1 == ungated in all
+ * 540 trials. See `docs/bayesian-recall-gate.md` §Evidence.)
  *
- * Evidence (scripts/benchmark-recall-quality.ts, run through this exact
- * production function via its `tuning` override — not a duplicate scoring
- * implementation). Two independent runs against real session corpora (23
- * sessions/161 queries and 31 sessions/222 queries; exact counts vary with
- * whatever real sessions are available locally, so both are reported rather
- * than treating one as a fixed target):
- *   - floor=0.20 on multi-term queries: median result count 49→23 (run 1,
- *     n=69) and 60.5→23.5 (run 2, n=98); p90 142.8→81 and 126.2→75.3.
- *     Zero-hit count stayed 0 in both runs, top-1 never changed (0/69,
- *     0/98). Top-5 membership shifted in 5/69 (7%) and 5/98 (5%).
- *   - floor=0.10 was too weak to "meaningfully" remove the tail (multi-term
- *     median only 49→39 / 60.5→42); floor=0.25 removed more but roughly
- *     doubled the multi-term top-5 disruption (8/69, run 1) for little extra
- *     median gain over 0.20. 0.20 is the least aggressive setting that
- *     meaningfully thinned the tail.
- *   - Single-term queries with the floor gated off: every floor candidate
- *     (0, 0.10, 0.20, 0.25) produced byte-identical results — 0/92 and
- *     0/124 top-5 changes in both runs, confirming the gate is a true no-op
- *     rather than an untested assumption. Before this gate existed, applying
- *     0.20 unconditionally still changed single-term top-5 in a small but
- *     non-zero fraction of queries (1/140 in this repo's own rerun, 1/124 in
- *     an independent reviewer rerun) for negligible median movement — real
- *     false-negative risk for no real noise benefit, which is why the gate
- *     exists.
+ * The top-scoring hit always survives by construction:
+ * `applyProbabilityFloor` keeps the first entry unconditionally, so a
+ * non-empty scored[] can never be filtered to zero even if a tuning
+ * override raises the threshold above the top hit's posterior. (Note
+ * posterior(L, p) = p at L = 0.5, so a top likelihood >= 0.5 alone does
+ * NOT imply posterior >= 0.5 — the unconditional keep-first is the real
+ * guarantee, not the calibration.)
  *
- * The top-scoring hit always survives by construction, independent of the
- * evidence above: its own score always satisfies `score >= topScore * floor`
- * for any floor <= 1, so a non-empty scored[] can never be filtered to zero.
+ * Coverage parity is the second survival rule (see `applyProbabilityFloor`):
+ * a doc matching as many distinct query terms as the best hit survives even
+ * when its posterior sits below the cutoff. Without this, a uniformly good
+ * result set — every doc matches every term, all posteriors lukewarm under
+ * median-anchored calibration — would collapse to the top hit alone, worse
+ * than the relative floor this gate replaces.
  */
-const BM25_RELATIVE_FLOOR = 0.2;
+const BAYESIAN_PROBABILITY_FLOOR = 0.5;
 
 /**
  * Hard cap on total SEARCH results, applied to both the natural-language
- * (post-floor) and regex result paths so pagination stays bounded regardless
+ * (post-gate) and regex result paths so pagination stays bounded regardless
  * of how noisy or broad a query is.
  *
- * Evidence (same bench/corpora as BM25_RELATIVE_FLOOR, floor disabled to
+ * Evidence (same bench/corpora as the tail gate, gate disabled to
  * isolate the cap's effect; run 1 = 161 queries, run 2 = 222 queries):
  * uncapped result counts ranged up to 380 (median 32 / 29.5, p90 119 /
  * 115.9). cap=50 sits ABOVE the corpus's own median in both runs but BELOW
@@ -423,36 +427,40 @@ const BM25_RELATIVE_FLOOR = 0.2;
  * truncated by it, versus 90/161 (56%) and 124/222 (56%) for cap=25, which
  * would also clip plenty of unremarkable ~30-match queries well under what
  * "noisy" implies. cap=50 also bounds the worst case (380) down by 87%.
- * Combined with the floor (production policy: floor=0.20 multi-term-only,
- * cap=50, vs. no filtering at all): 0 zero-hit regressions and 0 top-1
- * changes in both runs; top-5 changed in 5/161 (3%) and 5/222 (2%); median
- * result count 32→18 and 29.5→20; p90 119→50 and 115.9→50.
+ * Those runs measured the prior relative floor (0.20 multi-term-only); the
+ * cap applies post-gate either way, so the basis stands unchanged. Under the
+ * new absolute gate a seeded 540-trial bench likewise shows 0 zero-hit
+ * regressions and top-1 == ungated in all 540 trials.
  */
 const SEARCH_RESULT_CAP = 50;
-
 /**
- * Tuning overrides for `searchEntriesDetailed`. Exists only so the offline
- * bench (scripts/benchmark-recall-quality.ts) and targeted tests can
- * exercise the real scoring/capping pipeline against candidate constants —
- * production call sites (`searchEntries`, the recall tool) never pass this
- * and always get `BM25_RELATIVE_FLOOR`/`SEARCH_RESULT_CAP`.
+ * Tuning overrides for `searchEntriesDetailed`. Exists only so targeted
+ * tests can exercise the real scoring/capping pipeline against candidate
+ * constants — production call sites (`searchEntries`, the recall tool)
+ * never pass this and always get `BAYESIAN_PROBABILITY_FLOOR`/`SEARCH_RESULT_CAP`.
  */
 export interface SearchTuning {
-  relativeFloor?: number;
+  probabilityFloor?: number;
   cap?: number;
 }
 
-/** Drop scored hits below `floor` of the top score. The top hit's own score
- *  always passes (score >= score * floor for floor <= 1), so this can never
- *  turn a non-empty `scored` into an empty result. */
-const applyRelativeFloor = (
-  scored: Array<{ hit: SearchHit; score: number }>,
+/** Drop scored hits that are BOTH below the absolute posterior `floor` AND
+ *  cover fewer distinct query terms than the best hit (`coverage < maxCoverage`).
+ *  Either disjunct keeps a hit: high posterior (absolute relevance) or full
+ *  query coverage — a doc matching every term is never OR-tail, even in a
+ *  lukewarm homogeneous corpus where median-anchored calibration puts every
+ *  posterior below the cutoff. The top hit (index 0, highest BM25 score)
+ *  always passes unconditionally, so this can never turn a non-empty
+ *  `scored` into an empty result. Sort stays by raw BM25 score, never by
+ *  posterior: the composite prior varies per doc, so posterior order can
+ *  differ from BM25 order, and rank assertions pin BM25 order. */
+const applyProbabilityFloor = (
+  scored: Array<{ hit: SearchHit; score: number; probability: number; distinctTerms: number }>,
   floor: number,
-): Array<{ hit: SearchHit; score: number }> => {
+  maxCoverage: number,
+): Array<{ hit: SearchHit; score: number; probability: number; distinctTerms: number }> => {
   if (scored.length === 0) return scored;
-  const topScore = scored[0].score;
-  if (topScore <= 0) return scored;
-  return scored.filter((s) => s.score >= topScore * floor);
+  return scored.filter((s, i) => i === 0 || s.probability >= floor || s.distinctTerms >= maxCoverage);
 };
 
 /**
@@ -487,7 +495,7 @@ export const searchEntriesDetailed = (
 ): SearchResult => {
   if (!query?.trim()) return { hits: entries, totalBeforeCap: entries.length, truncated: false };
 
-  const relativeFloor = tuning?.relativeFloor ?? BM25_RELATIVE_FLOOR;
+  const probabilityFloor = tuning?.probabilityFloor ?? BAYESIAN_PROBABILITY_FLOOR;
   const cap = tuning?.cap ?? SEARCH_RESULT_CAP;
   const rawQuery = query.trim();
   const checkBudget = startBudget();
@@ -501,8 +509,8 @@ export const searchEntriesDetailed = (
   // versus 1.1% for term search. Mode detection must never silently lose
   // results, so an empty regex result falls through to term search below.
   //
-  // No relative-floor filtering here: regex matches are boolean (matched or
-  // not), there's no score to be relative to. Only the hard cap applies.
+  // No posterior-gate filtering here: regex matches are boolean (matched or
+  // not), there's no probability to threshold. Only the hard cap applies.
   if (looksLikeRegex(rawQuery)) {
     const regex = safeRegex(rawQuery);
     const hits: SearchHit[] = [];
@@ -538,35 +546,54 @@ export const searchEntriesDetailed = (
 
   const ctx = buildBM25Context(docs, terms, checkBudget);
 
-  const scored: Array<{ hit: SearchHit; score: number }> = [];
+  const scored: Array<{ hit: SearchHit; score: number; tf: number; distinctTerms: number; docLenRatio: number }> = [];
   for (let i = 0; i < entries.length; i++) {
     checkBudget();
     const e = entries[i];
     const hay = docs[i];
     const mc = countMatches(hay, terms);
     if (mc === 0) continue;
-    const score = bm25Score(hay, terms, ctx);
+    const { score, tf, distinctTerms, docLenRatio } = bm25Score(hay, terms, ctx);
     const text = messages[i] ? fullText(messages[i]) : e.summary;
     const snip = lineSnippet(text, snipRe);
     scored.push({
       hit: { ...e, snippet: snip, matchCount: mc },
       score,
+      tf,
+      distinctTerms,
+      docLenRatio,
     });
   }
 
-  // Sort by BM25 score desc, then drop the noisy long tail relative to the
-  // top score (multi-term queries only — see BM25_RELATIVE_FLOOR), then
+  // Calibrate: sigmoid midpoint/shift from this query's own score spread,
+  // then one posterior per doc. The per-doc single transform is an
+  // approximation of per-term posterior fusion — sufficient for a noise
+  // gate, never used for ranking (the sort key below stays raw BM25).
+  const params = estimateLikelihoodParams(scored.map((s) => s.score)) ?? { alpha: 1, beta: 0 };
+  const calibrated = scored.map((s) => ({
+    ...s,
+    probability: scoreToProbability(s.score, s.tf, s.docLenRatio, params.alpha, params.beta),
+  }));
+  for (const s of calibrated) s.hit.probability = s.probability;
+  // Coverage parity bar: the most distinct query terms any hit matches. Docs
+  // covering the query as fully as the best doc are never tail, even when
+  // their posterior sits below the absolute cutoff (homogeneous corpora).
+  let maxCoverage = 0;
+  for (const s of calibrated) if (s.distinctTerms > maxCoverage) maxCoverage = s.distinctTerms;
+
+  // Sort by BM25 score desc, then drop the noisy low-probability tail
+  // (multi-term queries only — see BAYESIAN_PROBABILITY_FLOOR), then
   // apply the hard cap.
-  scored.sort((a, b) => b.score - a.score);
+  calibrated.sort((a, b) => b.score - a.score);
   // Gate on DISTINCT normalized terms, not raw term count: "auth auth" or
   // "Auth AUTH" is semantically a single-term query and must bypass the
-  // floor like any other single term — repeating/casing a word doesn't turn
-  // it into the multi-term OR-tail noise this floor targets. This is a
+  // gate like any other single term — repeating or casing a word doesn't
+  // turn it into the multi-term OR-tail noise this gate targets. This is a
   // gate-only normalization; it does not change `terms` itself or the BM25
   // scoring above, which already matches case-insensitively.
   const effectiveTermCount = new Set(terms.map((t) => t.toLowerCase())).size;
-  const floored = effectiveTermCount >= 2 ? applyRelativeFloor(scored, relativeFloor) : scored;
-  return capHits(floored.map((s) => s.hit), cap);
+  const gated = effectiveTermCount >= 2 ? applyProbabilityFloor(calibrated, probabilityFloor, maxCoverage) : calibrated;
+  return capHits(gated.map((s) => s.hit), cap);
 };
 
 export const searchEntries = (

package/extensions/vcc-core/core/token-estimate.ts

@@ -99,3 +99,80 @@ export const estimateMessageContentTokens = (
   content: unknown,
   charsPerToken = DEFAULT_CHARS_PER_TOKEN,
 ): number => estimateTokensFromChars(estimateMessageContentChars(content), charsPerToken);
+
+export interface UsageStats {
+  messageCount: number;
+  byRole: Record<string, number>;
+  toolCallCount: number;
+  models: string[];
+  /** Wall-clock span (ms) from message timestamps, null when unavailable. */
+  spanMs: number | null;
+  inputChars: number;
+  outputChars: number;
+  inputTokensEst: number;
+  outputTokensEst: number;
+  /** Summed provider usage counters when messages carry them. */
+  usageTotals: { input: number; output: number; cacheRead: number; cacheWrite: number };
+  calibration: TokenEstimateCalibration;
+}
+
+/**
+ * Reference `_collect_stats` equivalent for the debug snapshot: per-compaction
+ * usage/timing/model block. Assistant content counts as output; user text,
+ * tool results, and bash executions count as input. Calibrates chars/token
+ * against summed provider usage when present, heuristic fallback otherwise.
+ */
+export const collectUsageStats = (messages: any[]): UsageStats => {
+  const byRole: Record<string, number> = {};
+  const models = new Set<string>();
+  let toolCallCount = 0;
+  let inputChars = 0;
+  let outputChars = 0;
+  let minTs = Infinity;
+  let maxTs = -Infinity;
+  const usageTotals = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+  let sawUsage = false;
+  for (const m of messages ?? []) {
+    const role = typeof m?.role === "string" ? m.role : "unknown";
+    byRole[role] = (byRole[role] ?? 0) + 1;
+    if (typeof m?.model === "string" && m.model) models.add(m.model);
+    if (typeof m?.timestamp === "number" && Number.isFinite(m.timestamp)) {
+      if (m.timestamp < minTs) minTs = m.timestamp;
+      if (m.timestamp > maxTs) maxTs = m.timestamp;
+    }
+    const u = m?.usage;
+    if (u && typeof u === "object") {
+      sawUsage = true;
+      for (const k of ["input", "output", "cacheRead", "cacheWrite"] as const) {
+        if (typeof u[k] === "number" && Number.isFinite(u[k])) usageTotals[k] += u[k];
+      }
+    }
+    if (role === "assistant") {
+      outputChars += estimateMessageContentChars(m?.content);
+      if (Array.isArray(m?.content)) {
+        for (const part of m.content) if (part?.type === "toolCall") toolCallCount++;
+      }
+    } else if (role === "bashExecution") {
+      inputChars += (typeof m?.command === "string" ? m.command.length : 0) + 1
+        + (typeof m?.output === "string" ? m.output.length : 0);
+    } else {
+      inputChars += estimateMessageContentChars(m?.content);
+    }
+  }
+  const totalChars = inputChars + outputChars;
+  const sourceTokens = sawUsage ? usageTotals.input + usageTotals.output : undefined;
+  const calibration = calibrateCharsPerToken(totalChars, sourceTokens);
+  return {
+    messageCount: messages?.length ?? 0,
+    byRole,
+    toolCallCount,
+    models: [...models],
+    spanMs: minTs <= maxTs ? maxTs - minTs : null,
+    inputChars,
+    outputChars,
+    inputTokensEst: estimateTokensFromChars(inputChars, calibration.charsPerToken),
+    outputTokensEst: estimateTokensFromChars(outputChars, calibration.charsPerToken),
+    usageTotals,
+    calibration,
+  };
+};

package/extensions/vcc-core/hook.ts

@@ -5,7 +5,7 @@ import { writeFileSync } from "fs";
 import { compileRanked } from "./core/summarize";
 import { buildPiVccCustomInstructions, parseKeepAndPrompt, PI_VCC_COMPACT_INSTRUCTION } from "./core/compact-args";
 import { loadSettings, type PiVccSettings } from "./core/settings";
-import { calibrateCharsPerToken, estimateMessageContentChars, estimateMessageContentTokens, estimateTokensFromChars } from "./core/token-estimate";
+import { calibrateCharsPerToken, estimateMessageContentChars, estimateMessageContentTokens, estimateTokensFromChars, collectUsageStats } from "./core/token-estimate";
 import type { PiVccCompactionDetails } from "./details";
 import type { CompactionReason } from "./types";
 import { loadAllMessages as _loadAllMessages } from "./core/load-messages";
@@ -13,7 +13,7 @@ import { searchEntriesDetailed as _searchEntriesDetailed, getTouchedFiles as _ge
 import { formatRecallOutput as _formatRecallOutput, formatTouchedOutput as _formatTouchedOutput } from "./core/format-recall";
 import { getActiveLineageEntryIds as _getActiveLineageEntryIds } from "./core/lineage";
 import { normalizeRecallScope as _normalizeRecallScope, normalizeRecallMode as _normalizeRecallMode, parseRecallScope as _parseRecallScope } from "./core/recall-scope";
-import { parseDrillDown as _parseDrillDown, expandEntryFile as _expandEntryFile } from "./core/drill-down";
+import { parseDrillDown as _parseDrillDown, expandEntryFile as _expandEntryFile, parseEntryRef as _parseEntryRef, expandEntry as _expandEntry } from "./core/drill-down";
 
 // convertToLlm shim: try host export, fallback to identity (preserves AgentMessage for omp compileRanked)
 let convertToLlm: (messages: any[]) => any[] = (m) => m;
@@ -972,6 +972,7 @@ export const registerBeforeCompactHook = (pi: ExtensionAPI) => {
       messagesPreviewHead: agentMessages.slice(0, 3).map((m: any) => ({ role: m.role, preview: previewContent(m.content) })),
       messagesPreviewTail: agentMessages.slice(-3).map((m: any) => ({ role: m.role, preview: previewContent(m.content) })),
       convertedMessages: messages.length,
+      usage: collectUsageStats(agentMessages),
       firstKeptEntryId,
       cutWindow,
       tokensBefore,
@@ -1130,6 +1131,17 @@ export const registerRecallTool = (pi: any) => {
       const scope = _normalizeRecallScope(params.scope === "active" ? "lineage" : params.scope);
       const lineageEntryIds = scope === "lineage" ? _getActiveLineageEntryIds(ctx.sessionManager) : undefined;
       const q = params.query?.trim();
+      if (q && _parseEntryRef(q)) {
+        const ref = _parseEntryRef(q)!;
+        if (lineageEntryIds) {
+          const { rendered } = _loadAllMessages(sessionFile, false, lineageEntryIds);
+          if (!rendered.some((m) => m.index === ref.index)) {
+            return { content: [{ type: "text", text: `Cannot expand indices outside active lineage: ${ref.index}. Use scope:'all' to reach other branches.` }] };
+          }
+        }
+        const text = _expandEntry(sessionFile, ref.index, ref.full, ref.offset, ref.limit);
+        return { content: [{ type: "text", text }] };
+      }
       if (q && _parseDrillDown(q)) {
         const parsed = _parseDrillDown(q)!;
         if (lineageEntryIds) {
@@ -1174,7 +1186,7 @@ export const registerRecallTool = (pi: any) => {
         const pageResults = hits.slice(start, start + PAGE_SIZE);
         const header = totalPages > 1 ? `Page ${page}/${totalPages} (${hits.length} total matches${scopeSuffix}${truncationNote})` : `${hits.length} matches${scopeSuffix}${truncationNote}`;
         const footer = page < totalPages ? `\n--- Use page:${page + 1}${scope === "all" ? " with scope:'all'" : ""} for more results ---` : "";
-        const output = _formatRecallOutput(pageResults, q, header) + footer;
+        const output = _formatRecallOutput(pageResults, q, header, { truncated, totalBeforeCap }) + footer;
         return { content: [{ type: "text", text: output }] };
       }
       const output = (scope === "all" ? "Scope: all\n\n" : "") + _formatRecallOutput(msgs.slice(-DEFAULT_RECENT), q);
@@ -1225,7 +1237,7 @@ export const registerVccRecallCommand = (pi: any) => {
       const pageResults = hits.slice(start, start + PAGE_SIZE);
       const header = totalPages > 1 ? `Page ${page}/${totalPages} (${hits.length} total matches${scopeSuffix}${truncationNote})` : `${hits.length} matches${scopeSuffix}${truncationNote}`;
       const footer = page < totalPages ? `\n--- /pi-vcc-recall ${query}${scopeArg} page:${page + 1} ---` : "";
-      const output = _formatRecallOutput(pageResults, query, header) + footer;
+      const output = _formatRecallOutput(pageResults, query, header, { truncated, totalBeforeCap }) + footer;
       try { pi.sendMessage?.({ customType: "vcc-recall", content: output, display: true }, { triggerTurn: false }); } catch {}
     },
   });

package/extensions/vcc-core/types.ts

@@ -12,6 +12,7 @@ export interface FileOps {
 export type NormalizedBlock =
   | { kind: "user"; text: string; sourceIndex?: number }
   | { kind: "assistant"; text: string; sourceIndex?: number }
+  | { kind: "thinking"; text: string; sourceIndex?: number }
   | { kind: "tool_call"; name: string; args: Record<string, unknown>; sourceIndex?: number }
   | { kind: "tool_result"; name: string; text: string; sourceIndex?: number }
   | { kind: "bash"; command: string; output: string; exitCode: number | undefined; sourceIndex?: number };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omp-vcc",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "type": "module",
   "description": "Algorithmic VCC compaction for omp - fast lossless no-LLM",
   "author": "Zhu Lin <zhulin@czl.my>",