pi-blackhole 0.4.2 → 0.4.3

package/src/core/brief.ts

@@ -21,12 +21,18 @@ const isNoiseUser = (text: string): boolean => {
 
 // Unicode-aware word segmentation via Intl.Segmenter with lazy init & fallback
 let _segmenter: Intl.Segmenter | null | undefined = undefined;
-const wordSegments = (text: string): Array<{ segment: string; index: number; isWordLike?: boolean }> => {
+const wordSegments = (
+  text: string,
+): Array<{ segment: string; index: number; isWordLike?: boolean }> => {
   // Available: fast path
   if (_segmenter) return Array.from(_segmenter.segment(text));
   // Fallback already established: don't retry the constructor
   if (_segmenter === null) {
-    const parts: Array<{ segment: string; index: number; isWordLike?: boolean }> = [];
+    const parts: Array<{
+      segment: string;
+      index: number;
+      isWordLike?: boolean;
+    }> = [];
     let idx = 0;
     for (const part of text.split(/(\s+)/)) {
       if (!part) continue;
@@ -41,7 +47,11 @@ const wordSegments = (text: string): Array<{ segment: string; index: number; isW
     return Array.from(_segmenter.segment(text));
   } catch {
     _segmenter = null; // permanently fallback
-    const parts: Array<{ segment: string; index: number; isWordLike?: boolean }> = [];
+    const parts: Array<{
+      segment: string;
+      index: number;
+      isWordLike?: boolean;
+    }> = [];
     let idx = 0;
     for (const part of text.split(/(\s+)/)) {
       if (!part) continue;
@@ -58,19 +68,105 @@ const isWord = (seg: { segment: string; isWordLike?: boolean }): boolean =>
 
 // Common stop words — don't count toward budget
 const STOP_WORDS = new Set([
-  "a", "an", "the", "is", "are", "was", "were", "be", "been", "being",
-  "have", "has", "had", "do", "does", "did", "will", "would", "could",
-  "should", "may", "might", "shall", "can", "need", "must",
-  "to", "of", "in", "for", "on", "with", "at", "by", "from", "as",
-  "into", "through", "during", "before", "after", "above", "below",
-  "between", "under", "over",
-  "and", "but", "or", "nor", "not", "so", "yet", "both", "either",
-  "neither", "each", "every", "all", "any", "few", "more", "most",
-  "other", "some", "such", "no",
-  "that", "this", "these", "those", "it", "its",
-  "i", "me", "my", "we", "our", "you", "your", "he", "him", "his",
-  "she", "her", "they", "them", "their", "who", "which", "what",
-  "if", "then", "than", "when", "where", "how", "just", "also",
+  "a",
+  "an",
+  "the",
+  "is",
+  "are",
+  "was",
+  "were",
+  "be",
+  "been",
+  "being",
+  "have",
+  "has",
+  "had",
+  "do",
+  "does",
+  "did",
+  "will",
+  "would",
+  "could",
+  "should",
+  "may",
+  "might",
+  "shall",
+  "can",
+  "need",
+  "must",
+  "to",
+  "of",
+  "in",
+  "for",
+  "on",
+  "with",
+  "at",
+  "by",
+  "from",
+  "as",
+  "into",
+  "through",
+  "during",
+  "before",
+  "after",
+  "above",
+  "below",
+  "between",
+  "under",
+  "over",
+  "and",
+  "but",
+  "or",
+  "nor",
+  "not",
+  "so",
+  "yet",
+  "both",
+  "either",
+  "neither",
+  "each",
+  "every",
+  "all",
+  "any",
+  "few",
+  "more",
+  "most",
+  "other",
+  "some",
+  "such",
+  "no",
+  "that",
+  "this",
+  "these",
+  "those",
+  "it",
+  "its",
+  "i",
+  "me",
+  "my",
+  "we",
+  "our",
+  "you",
+  "your",
+  "he",
+  "him",
+  "his",
+  "she",
+  "her",
+  "they",
+  "them",
+  "their",
+  "who",
+  "which",
+  "what",
+  "if",
+  "then",
+  "than",
+  "when",
+  "where",
+  "how",
+  "just",
+  "also",
 ]);
 
 const truncateTokens = (text: string, limit: number): string => {
@@ -96,12 +192,17 @@ const truncateTokens = (text: string, limit: number): string => {
 const BASH_CAP = 120;
 // Only strip pure-formatting pipe tails (head/tail for truncation, sort/wc/column for display).
 // awk/python3/node/bun are data-processing commands — their output carries semantic meaning.
-const PIPE_TAIL_RE = /\s*\|\s*(?:head|tail|sort|wc|column|tr|cut|uniq)(?:\s[^|]*)?$/;
+const PIPE_TAIL_RE =
+  /\s*\|\s*(?:head|tail|sort|wc|column|tr|cut|uniq)(?:\s[^|]*)?$/;
 
 /** Semantic compression: strip cd prefix, pipe tail formatting, cap length */
 const compressBash = (raw: string): string => {
   // Flatten multi-line: join lines with semicolons
-  let cmd = raw.split("\n").map(l => l.trim()).filter(Boolean).join("; ");
+  let cmd = raw
+    .split("\n")
+    .map((l) => l.trim())
+    .filter(Boolean)
+    .join("; ");
   // Strip cd <path> && prefix
   cmd = cmd.replace(/^cd\s+\S+\s*&&\s*/, "");
   // Strip pipe tail formatting commands (up to 10 iterations, stop when stable)
@@ -122,9 +223,14 @@ const compressBash = (raw: string): string => {
 // ── tool summary ──
 
 const TOOL_SUMMARY_FIELDS: Record<string, string> = {
-  Read: "file_path", Edit: "file_path", Write: "file_path",
-  read: "path", edit: "path", write: "path",
-  Glob: "pattern", Grep: "pattern",
+  Read: "file_path",
+  Edit: "file_path",
+  Write: "file_path",
+  read: "path",
+  edit: "path",
+  write: "path",
+  Glob: "pattern",
+  Grep: "pattern",
 };
 
 const toolOneLiner = (name: string, args: Record<string, unknown>): string => {
@@ -245,14 +351,21 @@ export const buildBriefSections = (blocks: NormalizedBlock[]): BriefLine[] => {
     if (sec.header !== "[assistant]") continue;
     const out: string[] = [];
     for (const line of sec.lines) {
-      if (!line.startsWith("* ")) { out.push(line); continue; }
+      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) {
+        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`;
       } else {
@@ -304,7 +417,13 @@ export const buildBriefSections = (blocks: NormalizedBlock[]): BriefLine[] => {
     const prevMatch = prev?.header.match(
       /^\[tool_error\]\s+(\S+?)\s*\(((?:#\d+(?:,\s*)?)+)\)(?:\s*x(\d+))?$/,
     );
-    if (prev && prevMatch && prevMatch[1] === tool && prev.lines.length === 1 && prev.lines[0] === body) {
+    if (
+      prev &&
+      prevMatch &&
+      prevMatch[1] === tool &&
+      prev.lines.length === 1 &&
+      prev.lines[0] === body
+    ) {
       const refs = prevMatch[2] + (ref ? `, #${ref}` : "");
       const count = prevMatch[3] ? parseInt(prevMatch[3]) + 1 : 2;
       prev.header = `[tool_error] ${tool} (${refs}) x${count}`;
@@ -322,16 +441,19 @@ export const buildBriefSections = (blocks: NormalizedBlock[]): BriefLine[] => {
  * Stringify BriefLine sections into text format.
  */
 export const stringifyBrief = (sections: BriefLine[]): string => {
-
   // Emit sections -- suppress blank lines between consecutive tool/error summaries
   const out: string[] = [];
   for (let i = 0; i < sections.length; i++) {
     const sec = sections[i];
     if (i > 0) {
       const prev = sections[i - 1];
-      const prevIsToolLike = (prev.header === "[assistant]" && prev.lines.every((l) => l.startsWith("* "))) ||
+      const prevIsToolLike =
+        (prev.header === "[assistant]" &&
+          prev.lines.every((l) => l.startsWith("* "))) ||
         prev.header.startsWith("[tool_error]");
-      const curIsToolLike = (sec.header === "[assistant]" && sec.lines.every((l) => l.startsWith("* "))) ||
+      const curIsToolLike =
+        (sec.header === "[assistant]" &&
+          sec.lines.every((l) => l.startsWith("* "))) ||
         sec.header.startsWith("[tool_error]");
       if (!(prevIsToolLike && curIsToolLike)) {
         out.push("");
@@ -347,11 +469,15 @@ export const stringifyBrief = (sections: BriefLine[]): string => {
 };
 
 /** Parse a text line into a structured TranscriptEntry */
-const parseToolLine = (line: string): { tool: string; cmd?: string; ref?: string; count?: number } | null => {
+const parseToolLine = (
+  line: string,
+): { tool: string; cmd?: string; ref?: string; count?: number } | null => {
   // * bash "cmd" (#5)
   // * bash "cmd" (#1, #3) x2
   // * tilth "query" (#7)
-  const m = line.match(/^\* (\S+)\s*(?:"([^"]*)")?\s*(?:\((#[\d, #]+)\))?\s*(?:x(\d+))?$/);
+  const m = line.match(
+    /^\* (\S+)\s*(?:"([^"]*)")?\s*(?:\((#[\d, #]+)\))?\s*(?:x(\d+))?$/,
+  );
   if (!m) return null;
   return {
     tool: m[1],
@@ -370,7 +496,9 @@ const extractRef = (text: string): { clean: string; ref?: string } => {
 /**
  * Convert BriefLine sections to structured TranscriptEntry array for JSON output.
  */
-export const sectionsToTranscript = (sections: BriefLine[]): TranscriptEntry[] => {
+export const sectionsToTranscript = (
+  sections: BriefLine[],
+): TranscriptEntry[] => {
   const entries: TranscriptEntry[] = [];
 
   for (const sec of sections) {
@@ -394,7 +522,11 @@ export const sectionsToTranscript = (sections: BriefLine[]): TranscriptEntry[] =
           } else {
             // Fallback: unparseable tool line
             const { clean, ref } = extractRef(line.slice(2));
-            entries.push({ role: "assistant", text: clean, ...(ref && { ref }) });
+            entries.push({
+              role: "assistant",
+              text: clean,
+              ...(ref && { ref }),
+            });
           }
         } else {
           const { clean, ref } = extractRef(line);
@@ -403,7 +535,9 @@ export const sectionsToTranscript = (sections: BriefLine[]): TranscriptEntry[] =
       }
     } else if (sec.header.startsWith("[tool_error]")) {
       // [tool_error] bash (#5)
-      const headerMatch = sec.header.match(/^\[tool_error\]\s+(\S+)\s*(?:\(#(\d+)\))?/);
+      const headerMatch = sec.header.match(
+        /^\[tool_error\]\s+(\S+)\s*(?:\(#(\d+)\))?/,
+      );
       const tool = headerMatch?.[1] ?? "unknown";
       const ref = headerMatch?.[2] ? `#${headerMatch[2]}` : undefined;
       for (const line of sec.lines) {

package/src/core/build-sections.ts

@@ -9,7 +9,10 @@ import { clipSentence, firstLine, nonEmptyLines } from "./content";
 import type { SectionData } from "../sections";
 import { extractGoals } from "../extract/goals";
 import { extractFiles } from "../extract/files";
-import { extractPreferences, dedupPreferencesAgainstGoals } from "../extract/preferences";
+import {
+  extractPreferences,
+  dedupPreferencesAgainstGoals,
+} from "../extract/preferences";
 import { extractCommits, formatCommits } from "../extract/commits";
 import { buildBriefSections, stringifyBrief } from "./brief";
 
@@ -39,7 +42,10 @@ const extractOutstandingContext = (blocks: NormalizedBlock[]): string[] => {
         if (/^\s*\(/.test(line)) continue;
         // Require sentence-like start: capital letter, code identifier, or quote
         if (!/^\s*["'`*_]?[A-Z`]/.test(line)) continue;
-        const clipped = b.kind === "user" ? `[user] ${clipSentence(line, 150)}` : clipSentence(line, 150);
+        const clipped =
+          b.kind === "user"
+            ? `[user] ${clipSentence(line, 150)}`
+            : clipSentence(line, 150);
         if (!items.includes(clipped)) items.push(clipped);
         break;
       }

package/src/core/config-env.ts

@@ -0,0 +1,117 @@
+/**
+ * Declarative PI_BLACKHOLE_* environment overrides for the unified config.
+ *
+ * Single source of truth for the env-var surface, shared by:
+ *  - ConfigManager (pi-base/config-manager.ts) — modal + om-off/om-on path
+ *  - loadUnifiedConfig (core/unified-config.ts) — the runtime path
+ *
+ * This guarantees env overrides behave identically everywhere. (Previously
+ * the runtime ignored the declarative map and only applied the passive
+ * trio + compaction/compaction-engine vars.)
+ */
+import { readBooleanEnv, readPositiveIntEnv } from "../pi-base/config.js";
+
+export interface EnvParser {
+  /** Env var name */
+  var: string;
+  /** Custom parse function (receives raw string, returns parsed value) */
+  parse: (raw: string, current: unknown) => unknown;
+}
+
+export type EnvOverride = string | EnvParser;
+
+/**
+ * Apply env overrides onto a config object. Field types are inferred from
+ * the defaults (boolean → truthy parsing, positive integer → int parsing,
+ * anything else → float). Returns a NEW object; input is not mutated.
+ */
+export function applyEnvOverrides<T extends object>(
+  config: T,
+  env: Record<string, EnvOverride>,
+  defaults: Record<string, unknown>,
+): T {
+  const result: Record<string, unknown> = {
+    ...(config as Record<string, unknown>),
+  };
+
+  for (const [key, value] of Object.entries(env)) {
+    if (!value) continue;
+
+    const defaultValue = defaults[key];
+
+    if (typeof value === "string") {
+      if (typeof defaultValue === "boolean") {
+        result[key] = readBooleanEnv(
+          value,
+          (result[key] as boolean) ?? (defaultValue as boolean),
+        );
+      } else if (typeof defaultValue === "number") {
+        if (Number.isInteger(defaultValue) && defaultValue > 0) {
+          result[key] = readPositiveIntEnv(
+            value,
+            (result[key] as number) ?? (defaultValue as number),
+          );
+        } else {
+          // Float — parse and preserve
+          const raw = process.env[value]?.trim();
+          if (raw) {
+            const parsed = Number.parseFloat(raw);
+            if (Number.isFinite(parsed)) {
+              result[key] = parsed;
+            }
+          }
+        }
+      }
+    } else {
+      const raw = process.env[value.var]?.trim();
+      if (raw) {
+        const parsed = value.parse(raw, result[key]);
+        if (parsed !== undefined) {
+          result[key] = parsed;
+        }
+      }
+    }
+  }
+
+  return result as T;
+}
+
+/**
+ * The declarative PI_BLACKHOLE_* env-var map. Keys are UnifiedConfig field
+ * names; values are the env var names (or parsers for special types).
+ */
+export const DECLARATIVE_ENV_OVERRIDES: Record<string, EnvOverride> = {
+  // Booleans
+  memory: "PI_BLACKHOLE_MEMORY",
+  debug: "PI_BLACKHOLE_DEBUG",
+  debugLog: "PI_BLACKHOLE_DEBUG_LOG",
+  sessionFallback: "PI_BLACKHOLE_SESSION_FALLBACK",
+  fullFoldAlways: "PI_BLACKHOLE_FULL_FOLD_ALWAYS",
+  // Positive integers
+  compactAfterTokens: "PI_BLACKHOLE_COMPACT_AFTER_TOKENS",
+  observeAfterTokens: "PI_BLACKHOLE_OBSERVE_AFTER_TOKENS",
+  reflectAfterTokens: "PI_BLACKHOLE_REFLECT_AFTER_TOKENS",
+  observationsPoolMaxTokens: "PI_BLACKHOLE_OBSERVATIONS_POOL_MAX_TOKENS",
+  observationsPoolTargetTokens: "PI_BLACKHOLE_OBSERVATIONS_POOL_TARGET_TOKENS",
+  reflectorInputMaxTokens: "PI_BLACKHOLE_REFLECTOR_INPUT_MAX_TOKENS",
+  dropperInputMaxTokens: "PI_BLACKHOLE_DROPPER_INPUT_MAX_TOKENS",
+  observerChunkMaxTokens: "PI_BLACKHOLE_OBSERVER_CHUNK_MAX_TOKENS",
+  observerPreambleMaxTokens: "PI_BLACKHOLE_OBSERVER_PREAMBLE_MAX_TOKENS",
+  agentMaxTurns: "PI_BLACKHOLE_AGENT_MAX_TURNS",
+  // Float in (0, 1]
+  dropperPressureThreshold: {
+    var: "PI_BLACKHOLE_DROPPER_PRESSURE_THRESHOLD",
+    parse: (raw: string) => {
+      const n = Number.parseFloat(raw);
+      return Number.isFinite(n) && n > 0 && n <= 1 ? n : undefined;
+    },
+  },
+  // Float in (0, 1]
+  dropperPoolFullnessThreshold: {
+    var: "PI_BLACKHOLE_DROPPER_POOL_FULLNESS_THRESHOLD",
+    parse: (raw: string) => {
+      const n = Number.parseFloat(raw);
+      return Number.isFinite(n) && n > 0 && n <= 1 ? n : undefined;
+    },
+  },
+};

package/src/core/content.ts

@@ -33,7 +33,10 @@ export const clipSentence = (text: string, max = 200): string => {
 };
 
 export const nonEmptyLines = (text: string): string[] =>
-  text.split("\n").map((line) => line.trim()).filter(Boolean);
+  text
+    .split("\n")
+    .map((line) => line.trim())
+    .filter(Boolean);
 
 export const firstLine = (text: string, max = 200): string =>
   clip(text.split("\n")[0] ?? "", max);
@@ -64,10 +67,25 @@ export const isContentBearing = (args: Record<string, unknown>): boolean => {
   // Must have at least one content-bearing field
   if (typeof args.content === "string" && args.content.length > 0) return true;
   // edits must be a non-empty array of objects (each with oldText/newText)
-  if (Array.isArray(args.edits) && args.edits.length > 0 && args.edits.every((e) => typeof e === "object" && e !== null)) return true;
+  if (
+    Array.isArray(args.edits) &&
+    args.edits.length > 0 &&
+    args.edits.every((e) => typeof e === "object" && e !== null)
+  )
+    return true;
   // oldText/newText without edits are content-bearing
-  if (typeof args.oldText === "string" && args.oldText.length > 0 && args.edits === undefined) return true;
-  if (typeof args.newText === "string" && args.newText.length > 0 && args.edits === undefined) return true;
+  if (
+    typeof args.oldText === "string" &&
+    args.oldText.length > 0 &&
+    args.edits === undefined
+  )
+    return true;
+  if (
+    typeof args.newText === "string" &&
+    args.newText.length > 0 &&
+    args.edits === undefined
+  )
+    return true;
   return false;
 };
 
@@ -98,11 +116,13 @@ export const toolCallArgsText = (
         if (extracted.length >= maxBytesPerCall) break;
         if (edit && typeof edit === "object") {
           if (typeof edit.oldText === "string") {
-            extracted += edit.oldText.slice(0, Math.floor(maxBytesPerCall / 2)) + "\n";
+            extracted +=
+              edit.oldText.slice(0, Math.floor(maxBytesPerCall / 2)) + "\n";
           }
           if (extracted.length >= maxBytesPerCall) break;
           if (typeof edit.newText === "string") {
-            extracted += edit.newText.slice(0, Math.floor(maxBytesPerCall / 2)) + "\n";
+            extracted +=
+              edit.newText.slice(0, Math.floor(maxBytesPerCall / 2)) + "\n";
           }
         }
       }
@@ -122,7 +142,11 @@ export const toolCallArgsText = (
 };
 
 /** Extract a snippet of ~`radius` chars around the first match of `term` in `text`. */
-export const snippet = (text: string, term: string, radius = 60): string | null => {
+export const snippet = (
+  text: string,
+  term: string,
+  radius = 60,
+): string | null => {
   const idx = text.toLowerCase().indexOf(term.toLowerCase());
   if (idx === -1) return null;
   const start = Math.max(0, idx - radius);

package/src/core/drill-down.ts

@@ -46,10 +46,15 @@ function findContentBearingCalls(content: unknown[]): ContentBearingCall[] {
     const entry: ContentBearingCall = { name: (part as any).name ?? "", path };
     if (typeof args.content === "string") entry.content = args.content;
     if (Array.isArray(args.edits)) {
-      entry.edits = args.edits.filter((e: unknown): e is { oldText?: string; newText?: string } => e !== null && typeof e === "object");
+      entry.edits = args.edits.filter(
+        (e: unknown): e is { oldText?: string; newText?: string } =>
+          e !== null && typeof e === "object",
+      );
     }
-    if (typeof args.oldText === "string" && !Array.isArray(args.edits)) entry.oldText = args.oldText;
-    if (typeof args.newText === "string" && !Array.isArray(args.edits)) entry.newText = args.newText;
+    if (typeof args.oldText === "string" && !Array.isArray(args.edits))
+      entry.oldText = args.oldText;
+    if (typeof args.newText === "string" && !Array.isArray(args.edits))
+      entry.newText = args.newText;
     results.push(entry);
   }
   return results;
@@ -71,7 +76,10 @@ function formatToolCallContent(
     body = tc.content;
   } else if (tc.edits) {
     body = tc.edits
-      .map((e, i) => `--- edit ${i + 1} ---\n${e.oldText ?? ""}\n--- becomes ---\n${e.newText ?? ""}`)
+      .map(
+        (e, i) =>
+          `--- edit ${i + 1} ---\n${e.oldText ?? ""}\n--- becomes ---\n${e.newText ?? ""}`,
+      )
       .join("\n\n");
   } else if (tc.oldText && tc.newText) {
     body = `--- old ---\n${tc.oldText}\n--- new ---\n${tc.newText}`;
@@ -169,9 +177,13 @@ const DRILLDOWN_PATTERN = /^#(\d+):(.+?)(?::(full|\d+(?::\d+)?))?$/;
  *   :30:20      → offset 30 lines, limit 20 lines
  *   (none)      → preview first 30 lines
  */
-export function parseDrillDown(
-  query: string,
-): { index: number; pathPattern: string; full: boolean; offset?: number; limit?: number } | null {
+export function parseDrillDown(query: string): {
+  index: number;
+  pathPattern: string;
+  full: boolean;
+  offset?: number;
+  limit?: number;
+} | null {
   const match = query.match(DRILLDOWN_PATTERN);
   if (!match) return null;
   const index = parseInt(match[1], 10);
@@ -179,7 +191,13 @@ export function parseDrillDown(
   const suffix = match[3];
 
   if (suffix === "full") {
-    return { index, pathPattern, full: true, offset: undefined, limit: undefined };
+    return {
+      index,
+      pathPattern,
+      full: true,
+      offset: undefined,
+      limit: undefined,
+    };
   }
 
   if (suffix !== undefined) {
@@ -192,7 +210,13 @@ export function parseDrillDown(
     }
   }
 
-  return { index, pathPattern, full: false, offset: undefined, limit: undefined };
+  return {
+    index,
+    pathPattern,
+    full: false,
+    offset: undefined,
+    limit: undefined,
+  };
 }
 
 // ── Main export ───────────────────────────────────────────────────────────
@@ -238,10 +262,16 @@ export function expandEntryFile(
       return `No file content found in entry #${entryIndex}.`;
     }
     if (calls.length === 1) {
-      return formatToolCallContent(calls[0], entryIndex, { full, offset, limit });
+      return formatToolCallContent(calls[0], entryIndex, {
+        full,
+        offset,
+        limit,
+      });
     }
     // Multiple content-bearing calls — list them
-    const items = calls.map((tc) => `  [#${entryIndex}:${tc.path}] ${tc.name}(${tc.path})`);
+    const items = calls.map(
+      (tc) => `  [#${entryIndex}:${tc.path}] ${tc.name}(${tc.path})`,
+    );
     return `Entry #${entryIndex} has ${calls.length} file operations:\n${items.join("\n")}\n\nUse #${entryIndex}:path to drill into a specific file.`;
   }
 

package/src/core/filter-noise.ts

@@ -1,8 +1,13 @@
 import type { NormalizedBlock } from "../types";
 
 const NOISE_TOOLS = new Set([
-  "TodoWrite", "TodoRead", "ToolSearch", "WebSearch",
-  "AskUser", "ExitSpecMode", "GenerateDroid",
+  "TodoWrite",
+  "TodoRead",
+  "ToolSearch",
+  "WebSearch",
+  "AskUser",
+  "ExitSpecMode",
+  "GenerateDroid",
 ]);
 
 const NOISE_STRINGS = [
@@ -11,7 +16,8 @@ const NOISE_STRINGS = [
   "IMPORTANT: TodoWrite was not called yet.",
 ];
 
-const XML_WRAPPER_RE = /<(system-reminder|ide_opened_file|command-message|context-window-usage)[^>]*>[\s\S]*?<\/\1>/g;
+const XML_WRAPPER_RE =
+  /<(system-reminder|ide_opened_file|command-message|context-window-usage)[^>]*>[\s\S]*?<\/\1>/g;
 
 /** Return cleaned user text, or null if the block is noise. Cleans once. */
 const cleanOrNull = (text: string): string | null => {

package/src/core/format-recall.ts

@@ -27,10 +27,18 @@ export function shortPath(fullPath: string): string {
 // ── File indicator formatting ─────────────────────────────────────────────
 
 /** Render one file indicator line with shortened path. */
-function formatFileMatch(fm: FileMatch, index: number, isQuery: boolean): string {
+function formatFileMatch(
+  fm: FileMatch,
+  index: number,
+  isQuery: boolean,
+): string {
   const label = isQuery
-    ? (fm.lineCount === 1 ? "match" : "matches")
-    : (fm.lineCount === 1 ? "line" : "lines");
+    ? fm.lineCount === 1
+      ? "match"
+      : "matches"
+    : fm.lineCount === 1
+      ? "line"
+      : "lines";
   const displayPath = shortPath(fm.path);
   let line = `  [${fm.toolName}] ${displayPath} — ${fm.lineCount} ${label}    use #${index}:${fm.path}`;
   if (fm.snippet) {
@@ -61,9 +69,10 @@ export function formatTouchedOutput(
   const start = (currentPage - 1) * ps;
   const pageFiles = touched.slice(start, start + ps);
 
-  const header = totalPages > 1
-    ? `Page ${currentPage}/${totalPages} (${touched.length} total files)`
-    : `${touched.length} files touched`;
+  const header =
+    totalPages > 1
+      ? `Page ${currentPage}/${totalPages} (${touched.length} total files)`
+      : `${touched.length} files touched`;
 
   const lines = pageFiles.map((tf) => {
     const displayPath = shortPath(tf.path);