pi-sessions 0.12.1 → 0.13.1

package/extensions/session-handoff/picker.ts

@@ -5,9 +5,12 @@ import {
   type KeyId,
   matchesKey,
   type TUI,
+  type TuiMouseEvent,
+  type TuiMouseEventResult,
   truncateToWidth,
   visibleWidth,
 } from "@earendil-works/pi-tui";
+import { type LegendHit, LegendPointer, layoutLegend, legendHitAt } from "../shared/legend.ts";
 import {
   stripSearchSnippetMarkers,
   transformSearchSnippetMatches,
@@ -24,6 +27,12 @@ interface PickerRightColumnWidths {
   modifiedAt: number;
 }
 
+interface PickerSessionHit {
+  row: number;
+  end: number;
+  sessionId: string;
+}
+
 export type SessionPickerResult =
   | { kind: "cancel" }
   | { kind: "insert-session-token"; sessionId: string };
@@ -66,6 +75,11 @@ export class SessionReferencePickerComponent implements Focusable {
   private includeAll = false;
   private items: SessionPickerItem[] = [];
   private selectedIndex = 0;
+  private sessionHits: PickerSessionHit[] = [];
+  private actionRows = new Map<number, LegendHit[]>();
+  private inputBounds: { row: number; width: number } | undefined;
+  private pressedSessionId: string | undefined;
+  private readonly legendPointer = new LegendPointer(() => this.tui.requestRender());
   private searchReloadTimer: ReturnType<typeof setTimeout> | undefined;
 
   get focused(): boolean {
@@ -101,10 +115,7 @@ export class SessionReferencePickerComponent implements Focusable {
     }
 
     if (this.keybindings.matches(data, "tui.input.tab")) {
-      this.includeAll = !this.includeAll;
-      this.cancelSearchReload();
-      this.reload();
-      this.tui.requestRender();
+      this.setScope(!this.includeAll);
       return;
     }
 
@@ -133,11 +144,7 @@ export class SessionReferencePickerComponent implements Focusable {
     }
 
     if (this.keybindings.matches(data, "tui.select.confirm")) {
-      this.flushSearchReload();
-      const selected = this.items[this.selectedIndex];
-      if (selected?.kind === "session") {
-        this.finish({ kind: "insert-session-token", sessionId: selected.sessionId });
-      }
+      this.confirmSelection();
       return;
     }
 
@@ -149,12 +156,88 @@ export class SessionReferencePickerComponent implements Focusable {
     }
   }
 
+  handleMouse(event: TuiMouseEvent): TuiMouseEventResult | undefined {
+    if (event.type === "press") this.pressedSessionId = undefined;
+    const action =
+      event.type === "press"
+        ? legendHitAt(this.actionRows.get(event.y) ?? [], event.x - 1)
+        : undefined;
+    const legend = this.legendPointer.handleMouse(event, action);
+    if (legend) return event.type === "press" ? { ...legend, focus: true } : legend;
+    if (event.type === "press") {
+      if (event.button !== "left") return undefined;
+      const session = this.sessionAt(event);
+      if (session) {
+        this.pressedSessionId = session.sessionId;
+        const index = this.items.findIndex(
+          (item) => item.kind === "session" && item.sessionId === session.sessionId,
+        );
+        if (index >= 0) this.selectedIndex = index;
+        return { handled: true, focus: true };
+      }
+      return undefined;
+    }
+    if (event.type === "wheel" && event.wheelDelta && this.sessionAt(event)) {
+      this.moveSelection(event.wheelDelta < 0 ? -1 : 1);
+      return { handled: true };
+    }
+    if (event.type !== "click" || event.button !== "left") return undefined;
+    const sessionId = this.pressedSessionId;
+    this.pressedSessionId = undefined;
+    if (sessionId) {
+      this.finish({ kind: "insert-session-token", sessionId });
+      return { handled: true };
+    }
+    const input = this.inputBounds;
+    if (input && event.y === input.row && event.x >= 1 && event.x < input.width + 1) {
+      // Input places its cursor on press; defer that call until click so text drags stay unhandled.
+      return this.input.handleMouse({
+        ...event,
+        type: "press",
+        x: event.x - 1,
+        y: 0,
+        width: input.width,
+        height: 1,
+      });
+    }
+    return undefined;
+  }
+
+  private sessionAt(event: TuiMouseEvent): PickerSessionHit | undefined {
+    return this.sessionHits.find((hit) => hit.row === event.y && event.x >= 1 && event.x < hit.end);
+  }
+
+  private setScope(includeAll: boolean): void {
+    this.includeAll = includeAll;
+    this.cancelSearchReload();
+    this.reload();
+    this.tui.requestRender();
+  }
+
+  private confirmSelection(): void {
+    this.flushSearchReload();
+    const selected = this.items[this.selectedIndex];
+    if (selected?.kind === "session") {
+      this.finish({ kind: "insert-session-token", sessionId: selected.sessionId });
+    }
+  }
+
   render(width: number): string[] {
+    this.sessionHits = [];
+    this.actionRows.clear();
+    this.inputBounds = undefined;
     const panelWidth = Math.max(0, width);
     const innerWidth = Math.max(0, panelWidth - 2);
-    const scopeText = this.includeAll
-      ? `${this.theme.fg("muted", "○ Current Folder | ")}${this.theme.fg("accent", "◉ All")}`
-      : `${this.theme.fg("accent", "◉ Current Folder")}${this.theme.fg("muted", " | ○ All")}`;
+    const folder = this.theme.fg(
+      this.includeAll ? "muted" : "accent",
+      `${this.includeAll ? "○" : "◉"} Current Folder`,
+    );
+    const all = this.theme.fg(
+      this.includeAll ? "accent" : "muted",
+      `${this.includeAll ? "◉" : "○"} All`,
+    );
+    const separator = this.theme.fg("muted", " | ");
+    const scopeText = `${folder}${separator}${all}`;
     const title = this.theme.bold("Add Session Reference to Prompt");
     const titleWidth = Math.max(0, innerWidth - visibleWidth(scopeText) - 1);
     const titleText = truncateToWidth(title, titleWidth, "…", true);
@@ -164,15 +247,57 @@ export class SessionReferencePickerComponent implements Focusable {
     );
 
     const lines = [this.theme.fg("border", `╭${"─".repeat(innerWidth)}╮`)];
-    lines.push(this.renderRow(`${titleText}${" ".repeat(headerSpacing)}${scopeText}`, innerWidth));
+    const scopeStart = visibleWidth(titleText) + headerSpacing;
+    if (scopeStart + visibleWidth(scopeText) <= innerWidth) {
+      const folderEnd = scopeStart + visibleWidth(folder);
+      const allStart = folderEnd + visibleWidth(separator);
+      this.actionRows.set(1, [
+        { id: "scope:folder", start: scopeStart, end: folderEnd, run: () => this.setScope(false) },
+        {
+          id: "scope:all",
+          start: allStart,
+          end: allStart + visibleWidth(all),
+          run: () => this.setScope(true),
+        },
+      ]);
+    }
+    const shownFolder =
+      this.actionRows.has(1) && this.legendPointer.pressedId === "scope:folder"
+        ? this.theme.bg("selectedBg", folder)
+        : folder;
+    const shownAll =
+      this.actionRows.has(1) && this.legendPointer.pressedId === "scope:all"
+        ? this.theme.bg("selectedBg", all)
+        : all;
     lines.push(
       this.renderRow(
-        this.theme.fg("muted", "enter add to prompt · esc cancel · tab scope"),
+        `${titleText}${" ".repeat(headerSpacing)}${shownFolder}${separator}${shownAll}`,
         innerWidth,
       ),
     );
+    const selected = this.items[this.selectedIndex];
+    const legend = layoutLegend(
+      this.theme,
+      [
+        {
+          key: "enter",
+          description: "add to prompt",
+          run: () => {
+            if (selected?.kind === "session") {
+              this.finish({ kind: "insert-session-token", sessionId: selected.sessionId });
+            }
+          },
+        },
+        { key: "esc", description: "cancel", run: () => this.finish({ kind: "cancel" }) },
+        { key: "tab", description: "scope", run: () => this.setScope(!this.includeAll) },
+      ],
+      { width: innerWidth, separator: " · ", pressedId: this.legendPointer.pressedId },
+    );
+    this.actionRows.set(lines.length, legend.hits);
+    lines.push(this.renderRow(legend.text, innerWidth));
     lines.push(this.renderRow("", innerWidth));
 
+    this.inputBounds = { row: lines.length, width: innerWidth };
     for (const inputLine of this.input.render(innerWidth)) {
       lines.push(this.renderRow(inputLine, innerWidth));
     }
@@ -183,7 +308,13 @@ export class SessionReferencePickerComponent implements Focusable {
     const rightWidths = this.getRightColumnWidths();
     for (const { item, index } of visibleItems) {
       lines.push(
-        ...this.renderPickerItem(item, index === this.selectedIndex, innerWidth, rightWidths),
+        ...this.renderPickerItem(
+          item,
+          index === this.selectedIndex,
+          innerWidth,
+          rightWidths,
+          lines.length,
+        ),
       );
     }
 
@@ -210,6 +341,7 @@ export class SessionReferencePickerComponent implements Focusable {
     selected: boolean,
     innerWidth: number,
     rightWidths: PickerRightColumnWidths,
+    firstRow: number,
   ): string[] {
     if (item.kind !== "session") {
       const message = [item.title, item.description].filter(Boolean).join(" — ");
@@ -232,7 +364,9 @@ export class SessionReferencePickerComponent implements Focusable {
       innerWidth - 2 - visibleWidth(cursor) - visibleWidth(left) - visibleWidth(right),
     );
     const titleLine = `${cursor}${left}${" ".repeat(spacing)}${right}`;
-    const lines = [this.renderSelectableRow(titleLine, innerWidth, selected)];
+    const lines = [
+      this.renderSelectableRow(titleLine, innerWidth, selected, firstRow, item.sessionId),
+    ];
 
     if (item.snippet && !highlightedTitle) {
       const snippet = this.formatSnippet(
@@ -241,7 +375,13 @@ export class SessionReferencePickerComponent implements Focusable {
       );
       if (snippet) {
         lines.push(
-          this.renderSelectableRow(`  ${this.theme.fg("dim", snippet)}`, innerWidth, selected),
+          this.renderSelectableRow(
+            `  ${this.theme.fg("dim", snippet)}`,
+            innerWidth,
+            selected,
+            firstRow + lines.length,
+            item.sessionId,
+          ),
         );
       }
     }
@@ -250,11 +390,19 @@ export class SessionReferencePickerComponent implements Focusable {
   }
 
   private renderRow(content: string, innerWidth: number): string {
+    content = truncateToWidth(content, innerWidth, "…");
     const pad = Math.max(0, innerWidth - visibleWidth(content));
     return `${this.theme.fg("border", "│")}${content}${" ".repeat(pad)}${this.theme.fg("border", "│")}`;
   }
 
-  private renderSelectableRow(content: string, innerWidth: number, selected: boolean): string {
+  private renderSelectableRow(
+    content: string,
+    innerWidth: number,
+    selected: boolean,
+    row: number,
+    sessionId: string,
+  ): string {
+    this.sessionHits.push({ row, end: 1 + Math.min(innerWidth, visibleWidth(content)), sessionId });
     return this.renderRow(selected ? this.theme.bg("selectedBg", content) : content, innerWidth);
   }
 
@@ -277,7 +425,7 @@ export class SessionReferencePickerComponent implements Focusable {
       return undefined;
     }
 
-    return truncateToWidth(rendered, maxWidth, "…", true);
+    return truncateToWidth(rendered, maxWidth, "…");
   }
 
   private highlightSnippetMatches(snippet: string): string | undefined {

package/extensions/session-handoff/review.ts

@@ -1,5 +1,5 @@
 import type { ExtensionUIContext, Theme } from "@earendil-works/pi-coding-agent";
-import type { Component } from "@earendil-works/pi-tui";
+import type { Component, TuiMouseEvent, TuiMouseEventResult } from "@earendil-works/pi-tui";
 import {
   Key,
   matchesKey,
@@ -7,6 +7,13 @@ import {
   visibleWidth,
   wrapTextWithAnsi,
 } from "@earendil-works/pi-tui";
+import {
+  type LegendHit,
+  type LegendItem,
+  LegendPointer,
+  layoutLegend,
+  legendHitAt,
+} from "../shared/legend.ts";
 import { renderStrongModal } from "./strong-modal.ts";
 
 const PREVIEW_TIMEOUT_MS = 8_000;
@@ -59,6 +66,8 @@ export class HandoffPreviewComponent implements Component {
   private isTimerActive = true;
   private scrollOffset = 0;
   private previewWidth = 80;
+  private legendRows = new Map<number, LegendHit[]>();
+  private readonly legendPointer = new LegendPointer(() => this.requestRender());
 
   public constructor(
     draft: string,
@@ -119,7 +128,26 @@ export class HandoffPreviewComponent implements Component {
     }
   }
 
+  public handleMouse(event: TuiMouseEvent): TuiMouseEventResult | undefined {
+    const hit =
+      event.type === "press" && !this.isDone
+        ? legendHitAt(this.legendRows.get(event.y) ?? [], event.x - 2)
+        : undefined;
+    const legend = this.legendPointer.handleMouse(event, hit);
+    if (legend) {
+      if (event.type === "press") this.disableTimer();
+      return legend;
+    }
+    if (event.type === "wheel" && event.wheelDelta && !this.isDone) {
+      this.disableTimer();
+      this.scrollBy(event.wheelDelta);
+      return { handled: true };
+    }
+    return undefined;
+  }
+
   public render(width: number): string[] {
+    this.legendRows.clear();
     const modalWidth = Math.max(24, width - 4);
     const promptBoxWidth = Math.max(20, modalWidth - 4);
     this.previewWidth = Math.max(16, promptBoxWidth - 4);
@@ -133,8 +161,18 @@ export class HandoffPreviewComponent implements Component {
     const contentLines = [
       this.getTitleLine(),
       "",
-      this.theme.fg("muted", formatKeymapLine("Enter: start session", "Esc: cancel")),
-      this.theme.fg("muted", formatKeymapLine("e: edit prompt", "j/k: scroll")),
+      this.renderKeymapLine(
+        3,
+        width,
+        { key: "Enter:", description: "start session", run: () => this.finish("accept") },
+        { key: "Esc:", description: "cancel", run: () => this.finish("cancel") },
+      ),
+      this.renderKeymapLine(
+        4,
+        width,
+        { key: "e:", description: "edit prompt", run: () => this.finish("edit") },
+        { key: "j/k:", description: "scroll" },
+      ),
       "",
       ...promptLines,
     ];
@@ -142,6 +180,21 @@ export class HandoffPreviewComponent implements Component {
     return renderStrongModal(contentLines, width, this.theme);
   }
 
+  private renderKeymapLine(
+    row: number,
+    width: number,
+    left: LegendItem,
+    right: LegendItem,
+  ): string {
+    const legend = layoutLegend(this.theme, [left, right], {
+      width: Math.max(20, width - 4),
+      pressedId: this.legendPointer.pressedId,
+      separator: " ".repeat(Math.max(0, 27 - visibleWidth(`${left.key} ${left.description}`))),
+    });
+    this.legendRows.set(row, legend.hits);
+    return legend.text;
+  }
+
   public invalidate(): void {}
 
   public stop(): void {
@@ -202,10 +255,6 @@ export class HandoffPreviewComponent implements Component {
   }
 }
 
-function formatKeymapLine(left: string, right: string): string {
-  return `${left.padEnd(27, " ")}${right}`;
-}
-
 function renderPromptSection(lines: string[], width: number, _theme: Theme): string[] {
   const innerWidth = Math.max(16, width - 4);
   const line = (left: string, text: string, right: string) => {

package/extensions/session-handoff/ui.ts

@@ -1,5 +1,11 @@
 import type { ExtensionUIContext } from "@earendil-works/pi-coding-agent";
-import { Key, matchesKey } from "@earendil-works/pi-tui";
+import {
+  Key,
+  matchesKey,
+  type TuiMouseEvent,
+  type TuiMouseEventResult,
+} from "@earendil-works/pi-tui";
+import { type LegendHit, LegendPointer, layoutLegend, legendHitAt } from "../shared/legend.ts";
 import { renderStrongModal } from "./strong-modal.ts";
 
 export async function runHandoffTaskWithLoader<T>(
@@ -12,6 +18,13 @@ export async function runHandoffTaskWithLoader<T>(
   const result = await ctx.ui.custom<T | undefined>(
     (tui, theme, _keybindings, done) => {
       const abortController = new AbortController();
+      let cancelHits: LegendHit[] = [];
+      const pointer = new LegendPointer(() => tui.requestRender());
+      const cancel = () => {
+        abortController.abort();
+        done(undefined);
+        tui.requestRender();
+      };
 
       task(abortController.signal)
         .then(done)
@@ -24,19 +37,31 @@ export async function runHandoffTaskWithLoader<T>(
 
       return {
         render(width: number): string[] {
+          const legend = layoutLegend(
+            theme,
+            [{ key: "Esc", description: "to cancel.", run: cancel }],
+            { width: Math.max(20, width - 4) - 6, pressedId: pointer.pressedId },
+          );
+          cancelHits = legend.hits;
           return renderStrongModal(
-            [theme.fg("accent", theme.bold(label)), "", theme.fg("muted", "Press Esc to cancel.")],
+            [
+              theme.fg("accent", theme.bold(label)),
+              "",
+              `${theme.fg("muted", "Press ")}${legend.text}`,
+            ],
             width,
             theme,
           );
         },
         invalidate(): void {},
+        handleMouse(event: TuiMouseEvent): TuiMouseEventResult | undefined {
+          return pointer.handleMouse(
+            event,
+            event.y === 3 ? legendHitAt(cancelHits, event.x - 8) : undefined,
+          );
+        },
         handleInput(data: string): void {
-          if (matchesKey(data, Key.escape)) {
-            abortController.abort();
-            done(undefined);
-            tui.requestRender();
-          }
+          if (matchesKey(data, Key.escape)) cancel();
         },
       };
     },

package/extensions/session-hooks/install.ts

@@ -5,32 +5,20 @@ import {
 } from "../session-handoff/metadata.ts";
 import { createSessionHookController } from "../session-search/hooks.ts";
 import type { IndexHandle, SessionLifecycle } from "../shared/composition.ts";
-import type { SessionSettings } from "../shared/settings.ts";
 
-export function installHooks(
-  pi: ExtensionAPI,
-  deps: { settings: SessionSettings; index: IndexHandle },
-): SessionLifecycle {
+export function installHooks(pi: ExtensionAPI, deps: { index: IndexHandle }): SessionLifecycle {
   const controller = createSessionHookController({ indexPath: deps.index.path });
 
-  pi.on("tool_call", async (event, ctx) => {
-    controller.handleToolCall(event, ctx.sessionManager.getSessionFile(), ctx.cwd);
-  });
-
-  pi.on("tool_result", async (event) => {
-    controller.handleToolResult(event);
-  });
-
   pi.on("turn_end", async (_event, ctx) => {
-    await controller.handleTurnEnd(ctx.sessionManager.getSessionFile(), ctx.cwd);
+    await controller.handleTurnEnd(ctx.sessionManager.getSessionFile());
   });
 
   pi.on("session_tree", async (_event, ctx) => {
-    await controller.handleSessionTree(ctx.sessionManager.getSessionFile(), ctx.cwd);
+    await controller.handleSessionTree(ctx.sessionManager.getSessionFile());
   });
 
   pi.on("session_compact", async (_event, ctx) => {
-    await controller.handleSessionCompact(ctx.sessionManager.getSessionFile(), ctx.cwd);
+    await controller.handleSessionCompact(ctx.sessionManager.getSessionFile());
   });
 
   return {
@@ -44,20 +32,19 @@ export function installHooks(
           await controller.handleSessionSwitch(
             previousSessionFile,
             sessionFile,
-            ctx.cwd,
             getSessionStartOrigin(ctx),
           );
           break;
         case "fork":
-          await controller.handleSessionFork(previousSessionFile, sessionFile, ctx.cwd);
+          await controller.handleSessionFork(previousSessionFile, sessionFile);
           break;
         default:
-          await controller.handleSessionStart(sessionFile, ctx.cwd);
+          await controller.handleSessionStart(sessionFile);
           break;
       }
     },
     async onSessionShutdown(_event, ctx) {
-      await controller.handleSessionShutdown(ctx.sessionManager.getSessionFile(), ctx.cwd);
+      await controller.handleSessionShutdown(ctx.sessionManager.getSessionFile());
     },
   };
 }

package/extensions/session-index/install.ts

@@ -1,17 +1,12 @@
-import {
-  BorderedLoader,
-  type ExtensionAPI,
-  type ExtensionCommandContext,
-  type Theme,
-} from "@earendil-works/pi-coding-agent";
-import { type Focusable, matchesKey, visibleWidth } from "@earendil-works/pi-tui";
+import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 import { type ReindexResult, rebuildSessionIndex } from "../session-search/reindex.ts";
 import type { IndexHandle } from "../shared/composition.ts";
 import { isTuiMode } from "../shared/pi-mode.ts";
-import { getIndexStatus, type SessionIndexStatus } from "../shared/session-index/index.ts";
+import { getIndexStatus } from "../shared/session-index/index.ts";
 import type { SessionSettings } from "../shared/settings.ts";
 
-type SessionIndexAction = "reindex" | undefined;
+import { ReindexLoader } from "./loader.ts";
+import { type SessionIndexAction, SessionIndexPanel } from "./panel.ts";
 
 export function installIndex(pi: ExtensionAPI, deps: { settings: SessionSettings }): IndexHandle {
   const indexPath = deps.settings.index.path;
@@ -26,7 +21,8 @@ export function installIndex(pi: ExtensionAPI, deps: { settings: SessionSettings
 
       const status = getIndexStatus(indexPath);
       const action = await ctx.ui.custom<SessionIndexAction>(
-        (_tui, theme, _keybindings, done) => new SessionIndexPanel(theme, status, done),
+        (tui, theme, _keybindings, done) =>
+          new SessionIndexPanel(theme, status, done, () => tui.requestRender()),
         {
           overlay: true,
           overlayOptions: {
@@ -66,78 +62,12 @@ export function installIndex(pi: ExtensionAPI, deps: { settings: SessionSettings
   return { path: indexPath };
 }
 
-class SessionIndexPanel implements Focusable {
-  readonly width = 72;
-  focused = false;
-
-  invalidate(): void {}
-
-  constructor(
-    private readonly theme: Theme,
-    private readonly status: SessionIndexStatus,
-    private readonly done: (result: SessionIndexAction) => void,
-  ) {}
-
-  handleInput(data: string): void {
-    if (isCloseKey(data)) {
-      this.done(undefined);
-      return;
-    }
-
-    if (isReindexKey(data)) {
-      this.done("reindex");
-    }
-  }
-
-  render(_width: number): string[] {
-    const innerWidth = this.width - 2;
-    const lines: string[] = [this.theme.fg("border", `╭${"─".repeat(innerWidth)}╮`)];
-
-    lines.push(
-      this.renderRow(innerWidth, ` ${this.theme.bold(this.theme.fg("accent", "Session Index"))}`),
-    );
-    lines.push(this.renderRow(innerWidth, ""));
-    lines.push(
-      this.renderRow(
-        innerWidth,
-        ` Path: ${this.status.exists ? this.status.dbPath : "<no index found>"}`,
-      ),
-    );
-    lines.push(
-      this.renderRow(
-        innerWidth,
-        ` Schema version: ${this.status.schemaVersion !== undefined ? String(this.status.schemaVersion) : "n/a"}`,
-      ),
-    );
-    lines.push(
-      this.renderRow(
-        innerWidth,
-        ` Session count: ${this.status.sessionCount !== undefined ? String(this.status.sessionCount) : "n/a"}`,
-      ),
-    );
-    lines.push(
-      this.renderRow(innerWidth, ` Last full reindex: ${this.status.lastFullReindexAt ?? "n/a"}`),
-    );
-    lines.push(this.renderRow(innerWidth, ""));
-    lines.push(this.renderRow(innerWidth, ` ${this.theme.fg("accent", "R")} rebuild from disk`));
-    lines.push(this.renderRow(innerWidth, ` ${this.theme.fg("dim", "Enter / Esc")} close`));
-    lines.push(this.theme.fg("border", `╰${"─".repeat(innerWidth)}╯`));
-    return lines;
-  }
-
-  private renderRow(innerWidth: number, content: string): string {
-    const pad = Math.max(0, innerWidth - visibleWidth(content));
-    return `${this.theme.fg("border", "│")}${content}${" ".repeat(pad)}${this.theme.fg("border", "│")}`;
-  }
-}
-
 async function runReindexWithLoader(
   ctx: ExtensionCommandContext,
   indexPath: string,
 ): Promise<ReindexResult | null> {
-  return ctx.ui.custom<ReindexResult | null>((tui, theme, _keybindings, done) => {
-    const loader = new BorderedLoader(tui, theme, "Rebuilding session index...");
-    loader.onAbort = () => done(null);
+  return ctx.ui.custom<ReindexResult | null>((tui, theme, keybindings, done) => {
+    const loader = new ReindexLoader(tui, theme, keybindings, () => done(null));
 
     void (async () => {
       try {
@@ -152,11 +82,3 @@ async function runReindexWithLoader(
     return loader;
   });
 }
-
-function isCloseKey(data: string): boolean {
-  return matchesKey(data, "escape") || matchesKey(data, "enter");
-}
-
-function isReindexKey(data: string): boolean {
-  return data === "r" || data === "R" || matchesKey(data, "r");
-}