@pi-unipi/compactor 2.6.1 → 2.6.2

package/src/tools/register.ts

@@ -15,8 +15,7 @@
 
 import { Type } from "typebox";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { compactTool } from "./compact.js";
-import { MAX_RECALL_RESULTS, vccRecall, type RecallInput } from "./vcc-recall.js";
+import { vccRecall } from "./vcc-recall.js";
 import { ctxExecute, type CtxExecuteInput } from "./ctx-execute.js";
 import { ctxExecuteFile, type CtxExecuteFileInput } from "./ctx-execute-file.js";
 import { ctxBatchExecute, type BatchItem } from "./ctx-batch-execute.js";
@@ -51,17 +50,15 @@ const CompactParams = Type.Object({
 });
 
 const RecallParams = Type.Object({
-  query: Type.String({ description: "Search query for session history" }),
-  mode: Type.Optional(Type.Union([Type.Literal("bm25"), Type.Literal("regex")], {
-    description: "Search mode: bm25 (default) or regex fallback",
+  query: Type.Optional(Type.String({ description: "What to recall, in plain keywords (e.g. 'redis cache decision'). Multi-word queries are ranked by relevance. A regex pattern also works. #N:path drills into a file's content from an entry." })),
+  expand: Type.Optional(Type.Array(Type.Number(), { description: "Entry indices to return full untruncated content for" })),
+  page: Type.Optional(Type.Number({ description: "Page number (1-based) for paginated search results. Default: 1.", minimum: 1 })),
+  scope: Type.Optional(Type.Union([Type.Literal("lineage"), Type.Literal("all")], {
+    description: "Default 'lineage' covers the active conversation path. Use 'all' to also reach messages from other branches, such as turns that were edited or retried.",
   })),
-  limit: Type.Optional(Type.Number({
-    description: `Max results to return (default 10, hard cap ${MAX_RECALL_RESULTS})`,
-    minimum: 1,
-    maximum: MAX_RECALL_RESULTS,
+  mode: Type.Optional(Type.Union([Type.Literal("hybrid"), Type.Literal("touched")], {
+    description: "What to show. hybrid (default) = normal search; touched = aggregated files-by-path with entry indices.",
   })),
-  offset: Type.Optional(Type.Number({ description: "Pagination offset", minimum: 0 })),
-  expand: Type.Optional(Type.Boolean({ description: "Return full message content for hits" })),
 });
 
 const SandboxParams = Type.Object({
@@ -111,20 +108,6 @@ function jsonResult(data: unknown, label?: string): any {
   };
 }
 
-/** Log a deprecation warning when old tool names are used. */
-function deprecationLog(_oldName: string, _newName: string): void {
-  // Deprecation logging disabled — was writing to stdout causing TUI rendering issues.
-}
-
-// --- Old schema names for backward compat aliases ---
-
-const VccRecallParams = RecallParams;
-const CtxExecuteParams = SandboxParams;
-const CtxExecuteFileParams = SandboxFileParams;
-const CtxBatchExecuteParams = SandboxBatchParams;
-const CtxStatsParams = StatsParams;
-const CtxDoctorParams = DoctorParams;
-
 // --- Registration ---
 
 export interface CompactorToolDeps {
@@ -163,8 +146,7 @@ export function registerCompactorTools(pi: ExtensionAPI, deps: CompactorToolDeps
       }
       const c = deps.getCounters?.();
       if (c) { c.compactions++; }
-      const result = compactTool();
-      return jsonResult(result, "Compaction triggered");
+      return jsonResult({ success: true, message: "Compaction triggered. Stats will be available after next compact event." }, "Compaction triggered");
     },
   } as any));
 
@@ -175,28 +157,28 @@ export function registerCompactorTools(pi: ExtensionAPI, deps: CompactorToolDeps
     const config = loadConfig(ctx?.cwd ?? process.cwd());
     const liveBlocks = ctx ? filterNoise(recallBlocksFromContext(ctx), config.pipeline?.customNoisePatterns) : [];
     const blocks = liveBlocks.length > 0 ? liveBlocks : deps.getBlocks();
-    const input: RecallInput = {
+    const result = vccRecall(blocks, {
       query: params.query,
+      scope: params.scope,
       mode: params.mode,
-      limit: params.limit,
-      offset: params.offset,
+      page: params.page,
       expand: params.expand,
-    };
-    const result = vccRecall(blocks, input);
-    if (result.hits.length === 0) {
-      return textResult(`No results found for "${result.query}".`);
-    }
-    const lines = result.hits.map(
-      (h, i) =>
-        `[${i + 1}/${result.total}] score=${h.score.toFixed(2)} kind=${h.kind}\n${h.text}`,
-    );
-    return textResult(
-      `Found ${result.total} results for "${result.query}":\n\n${lines.join("\n\n")}`,
-      result as unknown as Record<string, unknown>,
-    );
+    });
+    return textResult(result.text, { query: params.query ?? null });
   };
-  pi.registerTool({ name: "session_recall", label: "Session Recall", description: "Search session history using BM25 or regex. Find previous goals, files, commits, and context.", parameters: RecallParams, execute: recallExec } as any);
-  pi.registerTool({ name: "vcc_recall", label: "Session Recall", description: "Search session history using BM25 or regex. (DEPRECATED: use session_recall instead)", parameters: VccRecallParams, async execute(tcId: string, p: any) { deprecationLog("vcc_recall", "session_recall"); return recallExec(tcId, p); } } as any);
+  pi.registerTool({
+    name: "session_recall",
+    label: "Session Recall",
+    description:
+      "Search session history using keyword or regex search. Find previous goals, files, commits, decisions, and context — " +
+      "including anything dropped by compaction. Reach for this before telling the user you no longer have the context. " +
+      "Plain keywords work best; a regex pattern is also accepted. Results are paged (page); pass expand with entry indices " +
+      "to read full untruncated content. Use mode:'touched' to list files worked on in this session with their entry indices, " +
+      "and #N:path to drill into a file's content from an entry (#N:path:full for all lines). Only the current session is " +
+      "searchable — earlier sessions are not.",
+    parameters: RecallParams,
+    execute: recallExec,
+  } as any);
 
   // Sandbox tools are session-scoped and only registered when enabled.
   if (deps.sandbox) {
@@ -226,7 +208,6 @@ export function registerCompactorTools(pi: ExtensionAPI, deps: CompactorToolDeps
     }
   };
   pi.registerTool({ name: "sandbox", label: "Sandbox", description: "Run code in a sandboxed environment. Supports 11 languages. Only stdout enters context.", parameters: SandboxParams, execute: sandboxExec } as any);
-  pi.registerTool({ name: "ctx_execute", label: "Sandbox", description: "Run code in sandbox. (DEPRECATED: use sandbox instead)", parameters: CtxExecuteParams, async execute(tcId: string, p: any) { deprecationLog("ctx_execute", "sandbox"); return sandboxExec(tcId, p); } } as any);
 
   // 4. sandbox_file (new) / ctx_execute_file (deprecated) — execute file
   const sandboxFileExec = async (_toolCallId: string, params: any): Promise<import("@earendil-works/pi-coding-agent").AgentToolResult<unknown>> => {
@@ -246,7 +227,6 @@ export function registerCompactorTools(pi: ExtensionAPI, deps: CompactorToolDeps
     }
   };
   pi.registerTool({ name: "sandbox_file", label: "Sandbox File", description: "Execute a file in the sandbox. File content is injected as FILE_CONTENT variable.", parameters: SandboxFileParams, execute: sandboxFileExec } as any);
-  pi.registerTool({ name: "ctx_execute_file", label: "Sandbox File", description: "Execute file in sandbox. (DEPRECATED: use sandbox_file instead)", parameters: CtxExecuteFileParams, async execute(tcId: string, p: any) { deprecationLog("ctx_execute_file", "sandbox_file"); return sandboxFileExec(tcId, p); } } as any);
 
   // 5. sandbox_batch (new) / ctx_batch_execute (deprecated) — atomic batch (execute only)
   const sandboxBatchExec = async (_toolCallId: string, params: any): Promise<import("@earendil-works/pi-coding-agent").AgentToolResult<unknown>> => {
@@ -266,7 +246,6 @@ export function registerCompactorTools(pi: ExtensionAPI, deps: CompactorToolDeps
     }
   };
   pi.registerTool({ name: "sandbox_batch", label: "Sandbox Batch", description: "Run multiple code executions atomically as a batch.", parameters: SandboxBatchParams, execute: sandboxBatchExec } as any);
-  pi.registerTool({ name: "ctx_batch_execute", label: "Sandbox Batch", description: "Run batch operations. (DEPRECATED: use sandbox_batch instead)", parameters: CtxBatchExecuteParams, async execute(tcId: string, p: any) { deprecationLog("ctx_batch_execute", "sandbox_batch"); return sandboxBatchExec(tcId, p); } } as any);
   }
 
   // 6. compactor_stats (new) / ctx_stats (deprecated) — context savings dashboard
@@ -287,7 +266,6 @@ export function registerCompactorTools(pi: ExtensionAPI, deps: CompactorToolDeps
     }
   };
   pi.registerTool({ name: "compactor_stats", label: "Compactor Stats", description: "Show context savings dashboard — session events, compactions, tool usage.", parameters: StatsParams, execute: statsExec } as any);
-  pi.registerTool({ name: "ctx_stats", label: "Compactor Stats", description: "Show stats dashboard. (DEPRECATED: use compactor_stats instead)", parameters: CtxStatsParams, async execute() { deprecationLog("ctx_stats", "compactor_stats"); return statsExec(); } } as any);
 
   // 7. compactor_doctor (new) / ctx_doctor (deprecated) — diagnostics checklist
   const doctorExec = async (): Promise<import("@earendil-works/pi-coding-agent").AgentToolResult<unknown>> => {
@@ -305,7 +283,6 @@ export function registerCompactorTools(pi: ExtensionAPI, deps: CompactorToolDeps
     }
   };
   pi.registerTool({ name: "compactor_doctor", label: "Compactor Doctor", description: "Run diagnostics checklist — validate config, DB, runtimes.", parameters: DoctorParams, execute: doctorExec } as any);
-  pi.registerTool({ name: "ctx_doctor", label: "Compactor Doctor", description: "Run diagnostics. (DEPRECATED: use compactor_doctor instead)", parameters: CtxDoctorParams, async execute() { deprecationLog("ctx_doctor", "compactor_doctor"); return doctorExec(); } } as any);
 
   // 8. context_budget — estimate remaining context window
   pi.registerTool(({

package/src/tools/vcc-recall.ts

@@ -1,19 +1,36 @@
 /**
- * vcc_recall tool — BM25-lite session history search
+ * session_recall / vcc_recall — session history search (pi-vcc parity).
+ *
+ * Hybrid keyword/regex search over the session branch, with:
+ * - scope: lineage (active branch, default) | all
+ * - pagination (page, 5 results/page)
+ * - mode:"touched" — files worked on + entry indices
+ * - #N:path drill-down into file content from an entry
+ * - expand: entry indices returned as full untruncated content
  */
 
 import type { NormalizedBlock } from "../types.js";
-import { searchEntries } from "../compaction/search-entries.js";
+import { searchEntries, type RecallHit } from "../compaction/search-entries.js";
+import { getTouchedFiles } from "../compaction/touched-files.js";
+import { formatRecallOutput, formatTouchedOutput } from "../compaction/format-recall.js";
+import { normalizeRecallScope, normalizeRecallMode, type RecallScope } from "../compaction/recall-scope.js";
+import { parseDrillDown, expandEntryFile } from "../compaction/drill-down.js";
 
 export const MAX_RECALL_RESULTS = 50;
 export const MAX_EXPANDED_HIT_BYTES = 16 * 1024;
+export const DEFAULT_RECENT = 25;
+export const PAGE_SIZE = 5;
 
 export interface RecallInput {
-  query: string;
-  mode?: "bm25" | "regex";
-  limit?: number;
-  offset?: number;
-  expand?: boolean;
+  query?: string;
+  scope?: string;
+  mode?: string;
+  page?: number;
+  expand?: number[];
+}
+
+export interface RecallResult {
+  text: string;
 }
 
 function truncateExpandedHit(text: string): string {
@@ -24,56 +41,77 @@ function truncateExpandedHit(text: string): string {
   return `${visible}\n… ${omitted} bytes omitted from this hit; narrow the query to inspect more specific context …`;
 }
 
-export interface RecallResult {
-  hits: Array<{
-    index: number;
-    score: number;
-    text: string;
-    kind: string;
-  }>;
-  total: number;
-  query: string;
-}
+export const invalidExpandIndices = (requested: number[], available: Set<number>): number[] =>
+  requested.filter((i) => !Number.isInteger(i) || !available.has(i));
+
+const scopeSuffix = (scope: RecallScope): string => (scope === "all" ? " (scope: all)" : "");
 
 export function vccRecall(
   blocks: NormalizedBlock[],
   input: RecallInput,
 ): RecallResult {
-  const { query, mode = "bm25", expand = false } = input;
-  const requestedLimit = Number.isFinite(input.limit) ? Math.floor(input.limit!) : 10;
-  const requestedOffset = Number.isFinite(input.offset) ? Math.floor(input.offset!) : 0;
-  const limit = Math.min(MAX_RECALL_RESULTS, Math.max(1, requestedLimit));
-  const offset = Math.max(0, requestedOffset);
+  const scope = normalizeRecallScope(input.scope);
 
-  let hits: Array<{ index: number; score: number; text: string; kind: string }> = [];
+  // Drill-down: #N:path resolves to file-scoped tool content. Anchored so
+  // inline mentions like "see #42:auth.ts" are never treated as drill-down.
+  const q = input.query?.trim();
+  if (q && parseDrillDown(q)) {
+    const parsed = parseDrillDown(q)!;
+    const text = expandEntryFile(blocks, parsed.index, parsed.pathPattern, parsed.full, parsed.offset, parsed.limit);
+    return { text };
+  }
 
-  if (mode === "bm25") {
-    const results = searchEntries(blocks, query, { limit: limit + offset, offset: 0 });
-    hits = results.map((r, i) => ({
-      index: r.docId,
-      score: r.score,
-      text: expand ? truncateExpandedHit(r.text) : r.text.slice(0, 200),
-      kind: r.kind,
-    }));
-  } else {
-    // Regex fallback
-    const re = new RegExp(query, "i");
-    for (let i = 0; i < blocks.length; i++) {
-      const b = blocks[i];
-      const text = b.kind === "tool_call" ? `${b.name} ${JSON.stringify(b.args)}` : b.kind === "tool_result" ? `${b.name} ${b.text}` : b.text;
-      if (re.test(text)) {
-        hits.push({
-          index: i,
-          score: 1,
-          text: expand ? truncateExpandedHit(text) : text.slice(0, 200),
-          kind: b.kind,
-        });
-      }
+  // touched mode: aggregate file operations across the searched window.
+  if (normalizeRecallMode(input.mode) === "touched") {
+    const touched = getTouchedFiles(blocks);
+    return { text: formatTouchedOutput(touched, input.page) };
+  }
+
+  const expandSet = new Set(input.expand ?? []);
+  const hasExpand = expandSet.size > 0;
+
+  // expand without query: return full untruncated content for the indices
+  if (hasExpand && !q) {
+    const byIndex = new Map(blocks.map((b, i) => [b.sourceIndex ?? i, b]));
+    const requested = [...expandSet];
+    const invalid = invalidExpandIndices(requested, new Set(byIndex.keys()));
+    if (invalid.length > 0) {
+      return {
+        text: `Cannot expand indices outside ${scope === "all" ? "session history" : "active lineage"}: ${invalid.join(", ")}`,
+      };
     }
+    const expanded = requested
+      .sort((a, b) => a - b)
+      .map((i) => byIndex.get(i))
+      .filter((b): b is NormalizedBlock => Boolean(b));
+    const lines = expanded.map((b) => {
+      const idx = b.sourceIndex ?? 0;
+      const text = truncateExpandedHit(b.kind === "tool_call" ? `${b.name} ${JSON.stringify(b.args)}` : b.text);
+      return `#${idx} [${b.kind}] ${text}`;
+    });
+    return { text: (scope === "all" ? "Scope: all\n\n" : "") + lines.join("\n\n") };
   }
 
-  const total = hits.length;
-  const paginated = hits.slice(offset, offset + limit);
+  const allResults = q ? searchEntries(blocks, q) : searchEntries(blocks).slice(-DEFAULT_RECENT);
+
+  if (q) {
+    const page = Math.max(1, input.page ?? 1);
+    const start = (page - 1) * PAGE_SIZE;
+    const pageResults: RecallHit[] = allResults.slice(start, start + PAGE_SIZE);
+    const totalPages = Math.ceil(allResults.length / PAGE_SIZE);
+    if (pageResults.length === 0) {
+      return { text: `No matches for "${q}"${scopeSuffix(scope)}${page > 1 ? ` on page ${page}` : ""}.` };
+    }
+    const header = totalPages > 1
+      ? `Page ${page}/${totalPages} (${allResults.length} total matches${scopeSuffix(scope)})`
+      : `${allResults.length} matches${scopeSuffix(scope)}`;
+    const footer = page < totalPages
+      ? `\n--- Use page:${page + 1}${scope === "all" ? " with scope:'all'" : ""} for more results ---`
+      : "";
+    return { text: formatRecallOutput(pageResults, q, header) + footer };
+  }
 
-  return { hits: paginated, total, query };
+  // No query: recent entries
+  const output = (scope === "all" ? "Scope: all\n\n" : "") + formatRecallOutput(allResults, q);
+  return { text: output };
 }

package/src/tui/settings-overlay.ts

@@ -8,14 +8,14 @@
  */
 
 import type { Component, TUI } from "@earendil-works/pi-tui";
-import { matchesKey, truncateToWidth, visibleWidth, SettingsList, type SettingItem, type SettingsListTheme } from "@earendil-works/pi-tui";
+import { Key, matchesKey, SettingsList, type SettingItem, type SettingsListTheme } from "@earendil-works/pi-tui";
 import type { Theme, KeybindingsManager } from "@earendil-works/pi-coding-agent";
 import { loadConfig, saveConfig, projectConfigPath } from "../config/manager.js";
 import { applyPreset, detectPreset } from "../config/presets.js";
 import type { CompactorPreset } from "../types.js";
 import type { CompactorConfig } from "../types.js";
 import { existsSync, unlinkSync } from "node:fs";
-import { boxInnerWidth } from "@pi-unipi/core";
+import { boxInnerWidth, OverlayTheme } from "@pi-unipi/core";
 
 // ─── Section types ─────────────────────────────────────────────────────
 
@@ -48,16 +48,6 @@ interface PipelineDef {
 // ─── Static definitions ────────────────────────────────────────────────
 
 const STRATEGIES: StrategyDef[] = [
-  {
-    key: "debug",
-    label: "Verbose Debug",
-    description: "Log ALL compaction events to console",
-    modes: ["on", "off"],
-    getEnabled: (c) => c.debug,
-    setEnabled: (c, v) => (c.debug = v),
-    getMode: (c) => (c.debug ? "on" : "off"),
-    setMode: (c, v) => (c.debug = v === "on"),
-  },
   {
     key: "sessionGoals",
     label: "Session Goals",
@@ -144,6 +134,9 @@ const PIPELINE_ITEMS: PipelineDef[] = [
   // Only expose implemented behavior. Reserved compatibility fields remain in
   // the persisted schema so existing config files continue to load.
   { key: "autoInjection", label: "Auto Injection", description: "Inject behavioral state after compaction", group: "On Compaction", getValue: (c) => c.pipeline.autoInjection, setValue: (c, v) => (c.pipeline.autoInjection = v) },
+  { key: "smartKeepTail", label: "Smart Keep Tail", description: "Grow keep:N tail to ≥5k tokens when it would be tiny", group: "Cut Behavior", getValue: (c) => c.smartKeepTail, setValue: (c, v) => (c.smartKeepTail = v) },
+  { key: "continueAfterThresholdCompact", label: "Auto-continue", description: "Resume agent after threshold/overflow compaction", group: "On Compaction", getValue: (c) => c.continueAfterThresholdCompact, setValue: (c, v) => (c.continueAfterThresholdCompact = v) },
+  { key: "debug", label: "Debug Output", description: "Write compaction diagnostics to /tmp/compactor-debug.json", group: "Diagnostics", getValue: (c) => c.debug, setValue: (c, v) => (c.debug = v) },
 ];
 
 const PRESETS: CompactorPreset[] = ["precise", "balanced", "thorough", "lean"];
@@ -181,23 +174,10 @@ const THEME: SettingsListTheme = {
   hint: (text) => `\x1b[2m${text}\x1b[0m`,
 };
 
-// ─── Helper: frame a line inside box drawing ───────────────────────────
-
-function frameLine(content: string, innerWidth: number): string {
-  const truncated = truncateToWidth(content, innerWidth, "");
-  const padding = Math.max(0, innerWidth - visibleWidth(truncated));
-  return `\x1b[90m│\x1b[0m${truncated}${" ".repeat(padding)}\x1b[90m│\x1b[0m`;
-}
+// ─── Shared box-drawing helper ────────────────────────────────────────
 
-function ruleLine(innerWidth: number): string {
-  return `\x1b[90m├${"─".repeat(innerWidth)}┤\x1b[0m`;
-}
+const overlay = new OverlayTheme();
 
-function borderLine(innerWidth: number, edge: "top" | "bottom"): string {
-  const left = edge === "top" ? "┌" : "└";
-  const right = edge === "top" ? "┐" : "┘";
-  return `\x1b[90m${left}${"─".repeat(innerWidth)}${right}\x1b[0m`;
-}
 
 function uniqueValues(values: string[]): string[] {
   return [...new Set(values)];
@@ -538,7 +518,7 @@ export class CompactorSettingsOverlay implements Component {
 
   handleInput(data: string): void {
     // Tab switches section
-    if (data === "\t" || data === "\x1b[Z") {
+    if (data === "\t" || matchesKey(data, Key.shift("tab"))) {
       const idx = SECTIONS.indexOf(this.section);
       this.section = SECTIONS[(idx + 1) % SECTIONS.length];
       return;
@@ -569,8 +549,8 @@ export class CompactorSettingsOverlay implements Component {
     const lines: string[] = [];
 
     // Header
-    lines.push(borderLine(innerWidth, "top"));
-    lines.push(frameLine(`\x1b[1m\x1b[36m🗜️  Compactor Settings\x1b[0m`, innerWidth));
+    lines.push(overlay.borderLine(innerWidth, "top"));
+    lines.push(overlay.frameLine(`\x1b[1m\x1b[36m🗜️  Compactor Settings\x1b[0m`, innerWidth));
 
     // Current preset indicator
     const presetName = detectPreset(this.config);
@@ -578,8 +558,8 @@ export class CompactorSettingsOverlay implements Component {
     const overrideLabel = this.perProjectOverride
       ? `\x1b[33mProject override\x1b[0m`
       : `\x1b[2mGlobal config\x1b[0m`;
-    lines.push(frameLine(`\x1b[2mPreset: ${presetLabel}  ·  ${overrideLabel}\x1b[0m`, innerWidth));
-    lines.push(ruleLine(innerWidth));
+    lines.push(overlay.frameLine(`\x1b[2mPreset: ${presetLabel}  ·  ${overrideLabel}\x1b[0m`, innerWidth));
+    lines.push(overlay.ruleLine(innerWidth));
 
     // Section tabs
     const tabParts = SECTIONS.map((s) => {
@@ -589,28 +569,28 @@ export class CompactorSettingsOverlay implements Component {
       }
       return `\x1b[2m${label}\x1b[0m`;
     });
-    lines.push(frameLine(`  ${tabParts.join("  ")}`, innerWidth));
-    lines.push(ruleLine(innerWidth));
+    lines.push(overlay.frameLine(`  ${tabParts.join("  ")}`, innerWidth));
+    lines.push(overlay.ruleLine(innerWidth));
 
     // Section content (rendered by SettingsList)
     const contentLines = this.currentList.render(innerWidth - 2);
     for (const line of contentLines) {
-      lines.push(frameLine(` ${line}`, innerWidth));
+      lines.push(overlay.frameLine(` ${line}`, innerWidth));
     }
 
     // Saved indicator
     if (this.saved) {
-      lines.push(ruleLine(innerWidth));
-      lines.push(frameLine(`  \x1b[32m✓ Settings saved\x1b[0m`, innerWidth));
+      lines.push(overlay.ruleLine(innerWidth));
+      lines.push(overlay.frameLine(`  \x1b[32m✓ Settings saved\x1b[0m`, innerWidth));
     }
 
     // Footer hints
-    lines.push(ruleLine(innerWidth));
+    lines.push(overlay.ruleLine(innerWidth));
     const hints = this.section === "strategies"
       ? "↑↓ navigate · Space change · Tab switch · / search · Enter save · Esc cancel"
       : "↑↓ navigate · Space change · Tab switch · Enter save · Esc cancel";
-    lines.push(frameLine(`\x1b[2m${hints}\x1b[0m`, innerWidth));
-    lines.push(borderLine(innerWidth, "bottom"));
+    lines.push(overlay.frameLine(`\x1b[2m${hints}\x1b[0m`, innerWidth));
+    lines.push(overlay.borderLine(innerWidth, "bottom"));
 
     return lines;
   }