@hicaru/pi-rlm 0.3.8 → 0.3.13

package/src/ui/panel/tree-panel.ts

@@ -0,0 +1,46 @@
+/**
+ * tree-panel — the ONE wiring point between pi's UI and the RLM tree.
+ *
+ * Installs the persistent below-editor widget and mediates keyboard focus:
+ * the widget never grabs keys on its own; this panel intercepts Ctrl+R via
+ * onTerminalInput, forwards keys while focused, and opens the agent modal on
+ * enter. Everything else (tree building, formatting, timelines) is delegated.
+ */
+
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { TreeWidget } from "../tree/tree-widget.ts";
+import { openAgentModal } from "../modal/agent-modal.ts";
+import type { RunRegistry } from "./run-registry.ts";
+
+const KEY_CTRL_R = "\x12";
+const WIDGET_KEY = "rlm-tree";
+
+export function installTreePanel(ctx: ExtensionContext, registry: RunRegistry): void {
+  if (ctx.mode !== "tui") return;
+
+  let widget: TreeWidget | undefined;
+  ctx.ui.setWidget(
+    WIDGET_KEY,
+    (tui, theme) => {
+      widget?.dispose();
+      widget = new TreeWidget(tui, theme, registry);
+      return widget;
+    },
+    { placement: "belowEditor" },
+  );
+
+  ctx.ui.onTerminalInput((data) => {
+    const current = widget;
+    if (current === undefined) return undefined;
+    if (!current.isFocused) {
+      if (data === KEY_CTRL_R && registry.hasActive()) {
+        current.setFocused(true);
+        return { consume: true };
+      }
+      return undefined;
+    }
+    const action = current.handleKey(data);
+    if (action.type === "open") void openAgentModal(ctx, registry, action.runId, action.nodeId);
+    return { consume: true };
+  });
+}

package/src/ui/status.ts

@@ -1,8 +1,15 @@
-/** Footer status line for RLM mode and active runs. */
+/** Status widget for RLM mode and active runs — rendered above the editor.
+ *
+ * The footer's extension-status row is sanitized to a single line, so the
+ * two-model layout lives in a dedicated multi-line widget instead: one line
+ * for the mode, one per model lane (llm = leaf sub-calls, rlm = child engines),
+ * each with the live context token spend.
+ */
 
-import type { ContextUsage, ExtensionUIContext } from "@earendil-works/pi-coding-agent";
+import type { ContextUsage, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { Api, Model } from "@earendil-works/pi-ai";
 import type { RlmController } from "../mode/rlm-mode.ts";
+import { formatTokens } from "./theme.ts";
 
 const KEY = "rlm";
 
@@ -10,19 +17,25 @@ export function modelLabel(model: Model<Api> | undefined, fallback: string): str
   return model ? `${model.provider}/${model.id}` : fallback;
 }
 
-export function formatRlmStateLine(controller: RlmController, contextUsage?: ContextUsage): string {
-  if (!controller.enabled) return "○ RLM OFF";
+export function formatRlmStatusLines(
+  controller: RlmController,
+  contextUsage?: ContextUsage,
+): readonly string[] {
+  if (!controller.enabled) return ["○ RLM OFF"];
+  const tokens = contextUsage?.tokens;
+  const tokSuffix = tokens === null || tokens === undefined ? "" : ` · ${formatTokens(tokens)} tok`;
   const llm = modelLabel(controller.llmModel, controller.savedLlmRef ?? "cheapest");
   const llmSuffix = controller.config.subSampling.reasoning ? `:${controller.config.subSampling.reasoning}` : "";
-  // `percent` is null right after a compaction, before the next assistant response reports usage.
-  const percent = contextUsage?.percent;
-  const ctxSuffix = percent === null || percent === undefined ? "" : ` · ctx ${Math.round(percent)}%`;
-  // v5 provider caps (set via rlm.json): keep the effective admission visible.
-  const caps = controller.config.providerMaxConcurrent;
-  const capsSuffix = caps === undefined ? "" : ` · caps ${Object.entries(caps).map(([p, n]) => `${p}=${n}`).join(",")}`;
-  return `● RLM ON · llm=${llm}${llmSuffix}${ctxSuffix}${capsSuffix}`;
+  const rlm = modelLabel(controller.rlmModel, controller.savedRlmRef ?? "session");
+  const rlmSuffix = controller.config.rootSampling?.reasoning ? `:${controller.config.rootSampling.reasoning}` : "";
+  return [
+    "● RLM ON",
+    ` llm=${llm}${llmSuffix}${tokSuffix}`,
+    ` rlm=${rlm}${rlmSuffix}${tokSuffix}`,
+  ];
 }
 
-export function setRlmModeStatus(ui: ExtensionUIContext, controller: RlmController, contextUsage?: ContextUsage): void {
-  ui.setStatus(KEY, formatRlmStateLine(controller, contextUsage));
+/** Set the above-editor status widget. Idempotent — call on every state change. */
+export function setRlmModeStatus(ctx: ExtensionContext, controller: RlmController, contextUsage?: ContextUsage): void {
+  ctx.ui.setWidget(KEY, [...formatRlmStatusLines(controller, contextUsage)], { placement: "aboveEditor" });
 }

package/src/ui/theme.ts

@@ -6,10 +6,6 @@ export function spinnerFrame(): string {
   return SPINNER[Math.floor(Date.now() / 100) % SPINNER.length] ?? "⠋";
 }
 
-export function formatCost(usd: number): string {
-  return `$${usd.toFixed(usd < 1 ? 4 : 2)}`;
-}
-
 export function formatTokens(n: number): string {
   if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(1)}M`;
   if (n >= 1_000) return `${(n / 1_000).toFixed(1)}k`;

package/src/ui/tree/tree-model.ts

@@ -0,0 +1,226 @@
+/**
+ * tree-model — pure projection of one run's subcall state into display rows.
+ *
+ * No TUI imports, no side effects: same inputs → same rows. The widget caches
+ * the result and only rebuilds when the underlying store reports a change.
+ *
+ * Nothing is ever hidden: every sub-call renders as its own row (parity with
+ * pi, which shows each concurrent tool call individually) — except runs of
+ * IDENTICAL sibling leaves (same label+model+status), which collapse into one
+ * expandable "label ×N" group row so a 20-item llm_batch is one line, not 20.
+ * Error leaves are NEVER grouped — each keeps its own row and reason.
+ * Collapsed subtrees are skipped at the user's explicit request (chevron flips).
+ * Token rows are own-spend only — a row never blends models.
+ */
+
+import type { RlmSubcall, RlmRunStatus, SubcallPhase, SubcallStatus } from "../../tool/rlm-details.ts";
+
+/** Immutable per-run view the model consumes (built by RunRegistry from a live store). */
+export interface RunSnapshot {
+  readonly runId: string;
+  /** Root row label — prompt preview or "repl". */
+  readonly rootLabel: string;
+  readonly status: RlmRunStatus;
+  readonly rootPhase?: SubcallPhase;
+  /** Root's OWN model ("provider/id") — the default/session model driving the run. */
+  readonly rootModel?: string;
+  /** Root's OWN token spend (driver-model turns) — never a subtree sum. */
+  readonly rootTokens: number;
+  readonly subcalls: readonly RlmSubcall[];
+}
+
+export interface NodeRow {
+  readonly type: "node";
+  /** Subcall id, or the run id for the synthetic root row. */
+  readonly id: string;
+  /** Owning run — the modal resolves its timeline through this. */
+  readonly runId: string;
+  readonly depth: number;
+  /** Tree guide prefix, e.g. "│  ├─ " — formatter stays dumb. */
+  readonly prefix: string;
+  readonly expandable: boolean;
+  readonly expanded: boolean;
+  /** SubcallStatus, or "queued" while the node parks on the rate-limit cooldown. */
+  readonly icon: SubcallStatus | "queued";
+  readonly phase?: SubcallPhase;
+  readonly label: string;
+  /** The row's OWN token spend for its OWN model — never a subtree sum. */
+  readonly tokens: number;
+  readonly model?: string;
+}
+
+export type TreeRow = NodeRow | GroupRow;
+
+/** A run of identical sibling leaves (label+model+status) shown as one row. */
+export interface GroupRow {
+  readonly type: "group";
+  /** Synthetic id — "grp:" prefix keeps it disjoint from subcall ids. */
+  readonly id: string;
+  readonly runId: string;
+  readonly depth: number;
+  readonly prefix: string;
+  readonly count: number;
+  readonly label: string;
+  readonly model?: string;
+  /** Sum over members — one model only (the group key pins it), so never a blend. */
+  readonly tokens: number;
+  /** SubcallStatus, or "queued" while any member parks on the rate-limit cooldown. */
+  readonly icon: SubcallStatus | "queued";
+  readonly expandable: boolean;
+  readonly expanded: boolean;
+}
+
+/** Internal build-time entry: a real node or an accumulating group. */
+type Entry =
+  | { readonly type: "node"; readonly sc: RlmSubcall }
+  | { readonly type: "group"; readonly key: string; readonly label: string; readonly model?: string; readonly status: SubcallStatus; readonly members: RlmSubcall[] };
+
+/** Errors never group — each keeps its own row and its own reason. */
+const groupable = (sc: RlmSubcall, byParent: ReadonlyMap<string | undefined, RlmSubcall[]>): boolean =>
+  sc.kind === "llm" && sc.status !== "error" && (byParent.get(sc.id)?.length ?? 0) === 0;
+
+const groupKey = (sc: RlmSubcall): string => `${sc.label}|${sc.model ?? ""}|${sc.status}`;
+
+/** Merge consecutive identical sibling leaves into group entries; keep order. */
+function partition(children: readonly RlmSubcall[], byParent: ReadonlyMap<string | undefined, RlmSubcall[]>): readonly Entry[] {
+  const out: Entry[] = [];
+  for (const sc of children) {
+    if (groupable(sc, byParent)) {
+      const key = groupKey(sc);
+      const last = out[out.length - 1];
+      if (last !== undefined && last.type === "group" && last.key === key) {
+        last.members.push(sc);
+        continue;
+      }
+      out.push({ type: "group", key, label: sc.label, model: sc.model, status: sc.status, members: [sc] });
+    } else {
+      out.push({ type: "node", sc });
+    }
+  }
+  return out;
+}
+
+/** RlmRunStatus has "aborted"; the row icon set does not — aborted renders as error.
+ *  A RUNNING node parked on the rate-limit cooldown renders as "queued" (◷). */
+function iconOf(status: SubcallStatus | RlmRunStatus, phase: SubcallPhase | undefined): SubcallStatus | "queued" {
+  if (status === "aborted") return "error";
+  if (status === "running" && phase === "queued") return "queued";
+  return status;
+}
+
+/**
+ * Flatten a run snapshot into visible rows. Depth-first, children ordered by
+ * startedAt. Pure: allocates fresh arrays, never mutates the snapshot.
+ */
+export function buildRows(
+  run: RunSnapshot,
+  collapsed: ReadonlySet<string>,
+  expandedGroups: ReadonlySet<string> = new Set(),
+): readonly TreeRow[] {
+  const byParent = new Map<string | undefined, RlmSubcall[]>();
+  for (const sc of run.subcalls) {
+    const siblings = byParent.get(sc.parentId);
+    if (siblings === undefined) byParent.set(sc.parentId, [sc]);
+    else siblings.push(sc);
+  }
+  // Containers (agents) sort before leaves so agent rows stay adjacent; within
+  // a group, stable by start time.
+  for (const siblings of byParent.values()) {
+    siblings.sort((a, b) => Number((byParent.get(b.id)?.length ?? 0) > 0) - Number((byParent.get(a.id)?.length ?? 0) > 0) || a.startedAt - b.startedAt);
+  }
+
+  const rows: TreeRow[] = [];
+  const roots = byParent.get(undefined) ?? [];
+
+  const visit = (sc: RlmSubcall, depth: number, prefix: string, childGuide: string): void => {
+    const children = byParent.get(sc.id) ?? [];
+    const expanded = !collapsed.has(sc.id);
+    rows.push({
+      type: "node",
+      id: sc.id,
+      runId: run.runId,
+      depth,
+      prefix,
+      expandable: children.length > 0,
+      expanded,
+      icon: iconOf(sc.status, sc.phase),
+      phase: sc.phase,
+      label: sc.label,
+      tokens: sc.tokens,
+      model: sc.model,
+    });
+    if (!expanded || children.length === 0) return;
+    visitChildren(children, depth, childGuide);
+  };
+
+  const visitChildren = (children: readonly RlmSubcall[], parentDepth: number, guide: string): void => {
+    const entries = partition(children, byParent);
+    for (let i = 0; i < entries.length; i++) {
+      const entry = entries[i];
+      if (entry === undefined) continue;
+      const isLast = i === entries.length - 1;
+      const prefix = `${guide}${isLast ? "└─ " : "├─ "}`;
+      const childGuide = `${guide}${isLast ? "   " : "│  "}`;
+      if (entry.type === "node") visit(entry.sc, parentDepth + 1, prefix, childGuide);
+      else if (entry.members.length === 1) {
+        // A single identical leaf is not a group — render it as the plain row it is.
+        const only = entry.members[0];
+        if (only !== undefined) visit(only, parentDepth + 1, prefix, childGuide);
+      } else visitGroup(entry, parentDepth + 1, prefix, childGuide);
+    }
+  };
+
+  const visitGroup = (
+    entry: Extract<Entry, { type: "group" }>,
+    depth: number,
+    prefix: string,
+    guide: string,
+  ): void => {
+    const first = entry.members[0];
+    if (first === undefined) return;
+    const id = `grp:${run.runId}:${entry.key}:${first.id}`;
+    const expanded = expandedGroups.has(id);
+    let tokens = 0;
+    for (const m of entry.members) tokens += m.tokens;
+    rows.push({
+      type: "group",
+      id,
+      runId: run.runId,
+      depth,
+      prefix,
+      count: entry.members.length,
+      label: entry.label,
+      model: entry.model,
+      tokens,
+      icon: iconOf(entry.status, entry.members.some((m) => m.phase === "queued") ? "queued" : undefined),
+      expandable: true,
+      expanded,
+    });
+    if (!expanded) return;
+    for (let i = 0; i < entry.members.length; i++) {
+      const member = entry.members[i];
+      if (member === undefined) continue;
+      const last = i === entry.members.length - 1;
+      visit(member, depth, `${guide}${last ? "└─ " : "├─ "}`, `${guide}${last ? "   " : "│  "}`);
+    }
+  };
+
+  // Synthetic root row for the run itself.
+  rows.push({
+    type: "node",
+    id: run.runId,
+    runId: run.runId,
+    depth: 0,
+    prefix: "",
+    expandable: roots.length > 0,
+    expanded: !collapsed.has(run.runId),
+    icon: iconOf(run.status, run.rootPhase),
+    phase: run.rootPhase,
+    label: run.rootLabel,
+    tokens: run.rootTokens,
+    model: run.rootModel,
+  });
+  if (!collapsed.has(run.runId)) visitChildren(roots, 0, "");
+
+  return Object.freeze(rows);
+}

package/src/ui/tree/tree-rows.ts

@@ -0,0 +1,74 @@
+/**
+ * tree-rows — pure formatting of TreeRow[] into terminal lines.
+ *
+ * String building is segment-array + join (no += chains). Width math uses
+ * pi-tui's visibleWidth/truncateToWidth so ANSI colors never break alignment.
+ * Glyphs come from ui/theme.ts (single spinner/format source — no duplicates).
+ */
+
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { formatTokens, spinnerFrame } from "../theme.ts";
+import type { GroupRow, NodeRow, TreeRow } from "./tree-model.ts";
+
+const GLYPHS = Object.freeze({ done: "✓", error: "✗", queued: "◷", expanded: "▾", collapsed: "▸", leaf: " " } as const);
+const MODEL_MAX = 14;
+
+/** "openai/gpt-5-mini" → "gpt-5-mini", hard-capped so rows stay on one line. */
+export function modelShort(model: string): string {
+  const last = model.slice(model.lastIndexOf("/") + 1);
+  return last.length > MODEL_MAX ? `${last.slice(0, MODEL_MAX - 1)}…` : last;
+}
+
+function iconGlyph(row: NodeRow, theme: Theme): string {
+  switch (row.icon) {
+    case "done": return theme.fg("success", GLYPHS.done);
+    case "error": return theme.fg("error", GLYPHS.error);
+    case "queued": return theme.fg("warning", GLYPHS.queued);
+    default: return theme.fg("warning", spinnerFrame());
+  }
+}
+
+/** Right-hand stats: "4.3k tok · gpt-5-mini" (model only when present). */
+function statsText(tokens: number, model: string | undefined): string {
+  const parts = [`${formatTokens(tokens)} tok`];
+  if (model !== undefined) parts.push(modelShort(model));
+  return parts.join(" · ");
+}
+
+/** Left/right assembly shared by node and group rows — one padding rule, no fork. */
+function assembleLine(left: string, tokens: number, model: string | undefined, selected: boolean, width: number, theme: Theme): string {
+  const right = theme.fg("dim", statsText(tokens, model));
+  const gap = width - visibleWidth(left) - visibleWidth(right) - 1;
+  const line = gap > 0 ? `${left}${" ".repeat(gap)}${right}` : `${truncateToWidth(left, width - 1)} `;
+  return selected ? theme.fg("accent", line) : line;
+}
+
+function formatNode(row: NodeRow, selected: boolean, width: number, theme: Theme): string {
+  const chevron = row.expandable ? (row.expanded ? GLYPHS.expanded : GLYPHS.collapsed) : GLYPHS.leaf;
+  const cursor = selected ? theme.fg("accent", "❯") : " ";
+  const left = `${cursor} ${row.prefix}${chevron} ${iconGlyph(row, theme)} ${row.label}`;
+  return assembleLine(left, row.tokens, row.model, selected, width, theme);
+}
+
+function formatGroup(row: GroupRow, selected: boolean, width: number, theme: Theme): string {
+  const chevron = row.expanded ? GLYPHS.expanded : GLYPHS.collapsed;
+  const cursor = selected ? theme.fg("accent", "❯") : " ";
+  const icon = row.icon === "done" ? theme.fg("success", GLYPHS.done) : row.icon === "error" ? theme.fg("error", GLYPHS.error) : theme.fg("warning", spinnerFrame());
+  const left = `${cursor} ${row.prefix}${chevron} ${icon} ${row.label} ×${row.count}`;
+  return assembleLine(left, row.tokens, row.model, selected, width, theme);
+}
+
+export function formatRow(row: TreeRow, selected: boolean, width: number, theme: Theme): string {
+  return row.type === "group" ? formatGroup(row, selected, width, theme) : formatNode(row, selected, width, theme);
+}
+
+/** Pre-sized output — row count is known, no push-in-loop. */
+export function formatRows(rows: readonly TreeRow[], selectedId: string | undefined, width: number, theme: Theme): string[] {
+  const lines = new Array<string>(rows.length);
+  for (let i = 0; i < rows.length; i++) {
+    const row = rows[i];
+    lines[i] = formatRow(row, row !== undefined && row.id === selectedId, width, theme);
+  }
+  return lines;
+}

package/src/ui/tree/tree-widget.ts

@@ -0,0 +1,186 @@
+/**
+ * TreeWidget — the persistent live agent tree below the editor.
+ *
+ * Implements pi's Component contract (render / handleInput via panel-mediated
+ * keys / invalidate / dispose). All heavy lifting is delegated: buildRows and
+ * formatRows are pure; this class only holds view state — collapsed nodes,
+ * cursor, focus mode, dirty flag — and owns the spinner timer, which runs
+ * ONLY while some node is running and is always cleared in dispose().
+ */
+
+import type { Component, TUI } from "@earendil-works/pi-tui";
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import type { RunRegistry } from "../panel/run-registry.ts";
+import { buildRows, type TreeRow } from "./tree-model.ts";
+import { formatRows } from "./tree-rows.ts";
+
+const SPINNER_INTERVAL_MS = 100;
+/** Right-aligned stats never drift past this many columns, however wide the terminal. */
+const ROW_WIDTH_CAP = 110;
+
+const KEYS = Object.freeze({
+  up: "\x1b[A",
+  down: "\x1b[B",
+  right: "\x1b[C",
+  left: "\x1b[D",
+  enter: "\r",
+  escape: "\x1b",
+} as const);
+
+/** What the panel should do after a keypress. Discriminated — never a boolean soup. */
+export type KeyAction =
+  | { readonly type: "swallowed" }
+  | { readonly type: "unfocus" }
+  | { readonly type: "open"; readonly runId: string; readonly nodeId: string };
+
+export class TreeWidget implements Component {
+  private readonly collapsed = new Set<string>();
+  /** Group rows default COLLAPSED — membership here means expanded. */
+  private readonly expandedGroups = new Set<string>();
+  private rows: readonly TreeRow[] = [];
+  private selectedId: string | undefined;
+  private focused = false;
+  private dirty = true;
+  private timer: ReturnType<typeof setInterval> | undefined;
+  private readonly unsubscribe: () => void;
+
+  constructor(
+    private readonly tui: TUI,
+    private readonly theme: Theme,
+    private readonly registry: RunRegistry,
+  ) {
+    this.unsubscribe = registry.onChange(() => {
+      this.dirty = true;
+      this.tui.requestRender();
+    });
+  }
+
+  get isFocused(): boolean {
+    return this.focused;
+  }
+
+  setFocused(focused: boolean): void {
+    this.focused = focused;
+    if (focused) {
+      this.rebuild();
+      this.selectedId = this.selectedId ?? this.rows[0]?.id;
+    }
+    this.tui.requestRender();
+  }
+
+  /** Panel-mediated key handling (widgets don't own terminal focus). */
+  handleKey(data: string): KeyAction {
+    if (data === KEYS.escape) {
+      this.setFocused(false);
+      return { type: "unfocus" };
+    }
+    if (data === KEYS.up) this.move(-1);
+    else if (data === KEYS.down) this.move(1);
+    else if (data === KEYS.left) this.collapseSelected();
+    else if (data === KEYS.right) this.expandSelected();
+    else if (data === KEYS.enter) {
+      const row = this.selectedRow();
+      if (row !== undefined) {
+        if (row.type === "group") this.toggleGroup(row.id);
+        else return { type: "open", runId: row.runId, nodeId: row.id };
+      }
+    }
+    this.tui.requestRender();
+    return { type: "swallowed" };
+  }
+
+  render(width: number): string[] {
+    if (this.dirty) this.rebuild();
+    if (this.rows.length === 0) return [];
+    // pi renders belowEditor widgets flush under the editor's own bottom rule —
+    // no full-width header from us, it would stack a third rule and eat space.
+    // Unfocused: rows only. Focused: short accent tag + key hint.
+    const body = formatRows(this.rows, this.focused ? this.selectedId : undefined, Math.min(width, ROW_WIDTH_CAP), this.theme);
+    if (!this.focused) return body;
+    return [
+      this.theme.fg("accent", "─ RLM ─"),
+      ...body,
+      this.theme.fg("dim", "↑↓ move · ←→ collapse · enter details · esc unfocus"),
+    ];
+  }
+
+  invalidate(): void {
+    this.dirty = true;
+  }
+
+  dispose(): void {
+    this.unsubscribe();
+    if (this.timer !== undefined) {
+      clearInterval(this.timer);
+      this.timer = undefined;
+    }
+  }
+
+  // ── Internal ──
+
+  private rebuild(): void {
+    const all: TreeRow[] = [];
+    for (const run of this.registry.snapshots()) {
+      for (const row of buildRows(run, this.collapsed, this.expandedGroups)) all.push(row);
+    }
+    this.rows = Object.freeze(all);
+    this.dirty = false;
+    // A node that disappeared (run unregistered) must not stay selected.
+    if (this.selectedId !== undefined && !this.rows.some((r) => r.id === this.selectedId)) {
+      this.selectedId = this.rows[0]?.id;
+    }
+    this.syncTimer();
+  }
+
+  /** Spinner ticks only while something is running; idle widgets cost zero. */
+  private syncTimer(): void {
+    const anyRunning = this.rows.some((r) => r.icon === "running");
+    if (anyRunning && this.timer === undefined) {
+      const timer = setInterval(() => this.tui.requestRender(), SPINNER_INTERVAL_MS);
+      timer.unref();
+      this.timer = timer;
+    } else if (!anyRunning && this.timer !== undefined) {
+      clearInterval(this.timer);
+      this.timer = undefined;
+    }
+  }
+
+  /** Every row is navigable — node and group alike. */
+  private selectableRows(): readonly TreeRow[] {
+    return this.rows;
+  }
+
+  private selectedRow(): TreeRow | undefined {
+    return this.rows.find((r) => r.id === this.selectedId);
+  }
+
+  private move(delta: number): void {
+    const rows = this.selectableRows();
+    if (rows.length === 0) return;
+    const at = rows.findIndex((r) => r.id === this.selectedId);
+    const next = rows[Math.min(rows.length - 1, Math.max(0, (at < 0 ? 0 : at) + delta))];
+    if (next !== undefined) this.selectedId = next.id;
+  }
+
+  private toggleGroup(id: string): void {
+    if (this.expandedGroups.has(id)) this.expandedGroups.delete(id);
+    else this.expandedGroups.add(id);
+    this.dirty = true;
+  }
+
+  private collapseSelected(): void {
+    const row = this.selectedRow();
+    if (row === undefined || !row.expandable || !row.expanded) return;
+    if (row.type === "group") this.expandedGroups.delete(row.id);
+    else this.collapsed.add(row.id);
+    this.dirty = true;
+  }
+
+  private expandSelected(): void {
+    const row = this.selectedRow();
+    if (row === undefined || !row.expandable || row.expanded) return;
+    if (row.type === "group") this.expandedGroups.add(row.id);
+    else this.collapsed.delete(row.id);
+    this.dirty = true;
+  }
+}