@hicaru/pi-rlm 0.3.8 → 0.3.13

package/src/ui/model-picker/drilldown.ts

@@ -0,0 +1,173 @@
+/**
+ * drilldown — the grouped model picker: provider → model → thinking level.
+ *
+ * Three sequential pi overlays, one per level; SelectList has no native groups,
+ * so grouping is navigation instead of headers. Every level gets a "← back"
+ * row; esc cancels the whole flow. Level 3 (thinking level) is skipped for
+ * models that support none.
+ *
+ * Roles differ only in the level-1 sentinel row:
+ *   llm → "(cheapest, auto)"     — always the cheapest configured model
+ *   rlm → "(follow session model)" — child engines track pi's active model
+ */
+
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { DynamicBorder } from "@earendil-works/pi-coding-agent";
+import type { Api, Model, ThinkingLevel } from "@earendil-works/pi-ai";
+import { Container, type Component, type SelectItem, SelectList, Text, truncateToWidth } from "@earendil-works/pi-tui";
+import { CHEAPEST_VALUE, SESSION_VALUE, buildCatalog, modelRefOf, type ProviderGroup } from "./grouping.ts";
+import { selectThinkingLevel, supportedThinkingLevels } from "./levels.ts";
+
+export type PickerRole = "llm" | "rlm";
+
+export interface ModelSelection {
+  readonly model: Model<Api>;
+  readonly thinkingLevel?: ThinkingLevel;
+}
+
+const BACK_VALUE = "__rlm_back__";
+const MAX_VISIBLE = 13;
+
+const TOP_OPTIONS: Readonly<Record<PickerRole, SelectItem>> = Object.freeze({
+  llm: { value: CHEAPEST_VALUE, label: "⟳ cheapest (auto)", description: "Always use the cheapest model with a configured key" },
+  rlm: { value: SESSION_VALUE, label: "⌁ follow session model", description: "rlm_query / rlm_batch child engines use pi's active model" },
+});
+
+/** One overlay: a titled, filterable SelectList. Resolves value, or undefined on esc. */
+async function pickFromList(
+  ctx: ExtensionContext,
+  title: string,
+  items: readonly SelectItem[],
+  initialIndex: number,
+): Promise<string | undefined> {
+  const chosen = await ctx.ui.custom<string | null>((_tui, theme, _kb, done) => {
+    let query = "";
+    const container = new Container();
+    container.addChild(new DynamicBorder((s: string) => theme.fg("accent", s)));
+    container.addChild(new Text(theme.fg("accent", theme.bold(title)), 1, 0));
+    const filterLine: Component = {
+      render: (w) => [truncateToWidth(theme.fg("dim", `Filter: ${query || "type to filter…"}`), w)],
+      invalidate: () => {},
+    };
+    const list = new SelectList([...items], Math.min(items.length, MAX_VISIBLE), {
+      selectedPrefix: (t) => theme.fg("accent", t),
+      selectedText: (t) => theme.fg("accent", t),
+      description: (t) => theme.fg("muted", t),
+      scrollInfo: (t) => theme.fg("dim", t),
+      noMatch: (t) => theme.fg("warning", t),
+    });
+    if (initialIndex > 0) list.setSelectedIndex(initialIndex);
+    const isFilterText = (s: string): boolean =>
+      s.length > 0 && [...s].every((char) => char >= " " && char !== "\x7f");
+    const isBackspace = (s: string): boolean => s === "\x7f" || s === "\b";
+    list.onSelect = (item) => done(item.value);
+    list.onCancel = () => done(null);
+    container.addChild(filterLine);
+    container.addChild(list);
+    container.addChild(new Text(theme.fg("dim", "↑↓ navigate • type to filter • enter select • esc cancel"), 1, 0));
+    container.addChild(new DynamicBorder((s: string) => theme.fg("accent", s)));
+    return {
+      render: (w) => container.render(w),
+      invalidate: () => container.invalidate(),
+      handleInput: (data) => {
+        if (isFilterText(data)) {
+          query = `${query}${data.replace(/ /g, "")}`;
+          list.setFilter(query);
+          return;
+        }
+        if (isBackspace(data)) {
+          query = query.slice(0, -1);
+          list.setFilter(query);
+          return;
+        }
+        list.handleInput(data);
+      },
+    };
+  });
+  return chosen === null ? undefined : chosen;
+}
+
+function providerItems(role: PickerRole, catalog: readonly ProviderGroup[]): SelectItem[] {
+  const items: SelectItem[] = [TOP_OPTIONS[role]];
+  for (const g of catalog) items.push({ value: g.provider, label: g.provider, description: `${g.models.length} models` });
+  return items;
+}
+
+function modelItems(group: ProviderGroup): SelectItem[] {
+  const items: SelectItem[] = [{ value: BACK_VALUE, label: "← providers", description: "" }];
+  for (const m of group.models) {
+    items.push({ value: modelRefOf(m), label: m.id, description: m.reasoning ? "reasoning" : "" });
+  }
+  return items;
+}
+
+function levelItems(group: ProviderGroup, model: Model<Api>): SelectItem[] {
+  const items: SelectItem[] = [{ value: BACK_VALUE, label: `← ${group.provider} models`, description: "" }];
+  for (const level of supportedThinkingLevels(model)) {
+    items.push({ value: level, label: level, description: `Use ${level} reasoning` });
+  }
+  return items;
+}
+
+/** Show the grouped picker; resolves ModelSelection, null = role's top option, undefined = cancel. */
+export async function selectModel(
+  ctx: ExtensionContext,
+  role: PickerRole,
+  models: readonly Model<Api>[],
+  current?: Model<Api>,
+  currentThinking?: ThinkingLevel,
+  currentRef?: string,
+): Promise<ModelSelection | null | undefined> {
+  if (models.length === 0) {
+    ctx.ui.notify("RLM: no models available (add a provider key in Pi, or widen --models / enabledModels)", "warning");
+    return undefined;
+  }
+  if (ctx.mode !== "tui") {
+    const fallback = models[0];
+    if (fallback === undefined) return undefined;
+    // Prefer an explicit pin (resolved model or saved ref) over "first = cheapest".
+    const fromRef = currentRef ? models.find((m) => modelRefOf(m) === currentRef) : undefined;
+    const model = current ?? fromRef ?? fallback;
+    return { model, thinkingLevel: await selectThinkingLevel(ctx, model, currentThinking) };
+  }
+
+  const catalog = buildCatalog(models);
+  const currentRefStr = current ? modelRefOf(current) : currentRef;
+  const providerOf = (ref: string | undefined): string | undefined =>
+    ref === undefined ? undefined : catalog.find((g) => g.models.some((m) => modelRefOf(m) === ref))?.provider;
+
+  let group: ProviderGroup | undefined;
+  let model: Model<Api> | undefined;
+  // Drill-down with real back navigation: ← returns one level, esc cancels all.
+  for (;;) {
+    if (group === undefined) {
+      const items = providerItems(role, catalog);
+      const pre = providerOf(currentRefStr);
+      const l1 = await pickFromList(ctx, role === "llm" ? "LLM model — provider" : "RLM model — provider", items,
+        pre === undefined ? 0 : Math.max(0, items.findIndex((i) => i.value === pre)));
+      if (l1 === undefined) return undefined;              // esc — cancel
+      if (l1 === CHEAPEST_VALUE || l1 === SESSION_VALUE) return null; // role's top option
+      group = catalog.find((g) => g.provider === l1);
+      if (group === undefined) return undefined;
+      continue;
+    }
+    if (model === undefined) {
+      const mItems = modelItems(group);
+      const l2 = await pickFromList(ctx, `${group.provider} › models`, mItems,
+        Math.max(0, mItems.findIndex((i) => i.value === currentRefStr)));
+      if (l2 === undefined) return undefined;
+      if (l2 === BACK_VALUE) { group = undefined; continue; } // ← providers
+      const picked = group.models.find((m) => modelRefOf(m) === l2);
+      if (picked === undefined) return undefined;
+      model = picked;
+      if (supportedThinkingLevels(model).length === 0) return { model, thinkingLevel: undefined };
+      continue;
+    }
+    const lvItems = levelItems(group, model);
+    const l3 = await pickFromList(ctx, `${group.provider} › ${model.id}`, lvItems,
+      Math.max(0, lvItems.findIndex((i) => i.value === currentThinking)));
+    if (l3 === undefined) return undefined;
+    if (l3 === BACK_VALUE) { model = undefined; continue; }  // ← models
+    return { model, thinkingLevel: l3 === "off" ? undefined : (l3 as ThinkingLevel) };
+  }
+}

package/src/ui/model-picker/grouping.ts

@@ -0,0 +1,81 @@
+/**
+ * grouping — pure model-catalog grouping for the drill-down picker.
+ *
+ * Level 1: providers (with model counts).
+ * Level 2: models of one provider (label = full id, vendor prefix included —
+ *          the id IS the user-facing name on openrouter et al).
+ * Level 3: thinking levels ("variant") — owned by levels.ts, not here.
+ *
+ * No TUI imports; everything here is trivially unit-testable.
+ */
+
+import type { ModelRegistry } from "@earendil-works/pi-coding-agent";
+import type { Api, Model } from "@earendil-works/pi-ai";
+import { compareLlm } from "../../mode/llm-model.ts";
+
+/** Sentinel SelectList value for "always use cheapest available" (llm role). */
+export const CHEAPEST_VALUE = "__rlm_cheapest__";
+/** Sentinel SelectList value for "follow pi's session model" (rlm role). */
+export const SESSION_VALUE = "__rlm_session__";
+
+export interface ProviderGroup {
+  readonly provider: string;
+  readonly models: readonly Model<Api>[];
+}
+
+/**
+ * Models Pi itself would offer for this session, cheapest-first.
+ *
+ * Mirrors the built-in model switcher:
+ *   - if the session has scoped models (`--models` / enabledModels) → those only
+ *   - else → `getAvailable()` (providers with configured auth)
+ *
+ * Deliberately NOT `getAll()`: the full catalog dumps every provider's catalog entry and is
+ * not what the user sees in Pi natively. See Pi extension docs on `ctx.scopedModels`.
+ */
+export function pickableModels(
+  registry: ModelRegistry,
+  scoped?: readonly { readonly model: Model<Api> }[],
+): readonly Model<Api>[] {
+  const source = scoped !== undefined && scoped.length > 0
+    ? scoped.map((s) => s.model)
+    : registry.getAvailable();
+  return [...source].sort(compareLlm);
+}
+
+/** Group models by provider, providers alphabetical, models cheapest-first inside. */
+export function buildCatalog(models: readonly Model<Api>[]): readonly ProviderGroup[] {
+  const groups = new Map<string, Model<Api>[]>();
+  for (const m of models) {
+    const list = groups.get(m.provider);
+    if (list === undefined) groups.set(m.provider, [m]);
+    else list.push(m);
+  }
+  const out: ProviderGroup[] = [];
+  for (const [provider, list] of [...groups.entries()].sort(([a], [b]) => a.localeCompare(b))) {
+    out.push({ provider, models: [...list].sort(compareLlm) });
+  }
+  return out;
+}
+
+export const modelRefOf = (m: Model<Api>): string => `${m.provider}/${m.id}`;
+
+/**
+ * Index to pre-select in the flat model list (with cheapest row at 0 when included).
+ * Without this, the list always opens on "cheapest (auto)" and Enter silently unpins.
+ */
+export function initialModelPickerIndex(
+  models: readonly Model<Api>[],
+  current?: Model<Api>,
+  currentRef?: string,
+  includeCheapest = true,
+): number {
+  const offset = includeCheapest ? 1 : 0;
+  const ref = current ? modelRefOf(current) : currentRef;
+  if (!ref) return 0;
+  const idx = models.findIndex((m) => modelRefOf(m) === ref);
+  // When a saved ref exists but the model is absent from the current catalog
+  // (e.g. provider not refreshed yet), pre-select the first real model — NOT
+  // "cheapest", which would silently unpin on save.
+  return idx >= 0 ? idx + offset : Math.min(offset, models.length);
+}

package/src/ui/model-picker/levels.ts

@@ -0,0 +1,63 @@
+/**
+ * levels — the "variant" level of the drill-down: a model's thinking levels.
+ *
+ * Extracted verbatim from the pre-grouping picker so the non-tui fallback and
+ * the level list stay exactly as tested.
+ */
+
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { DynamicBorder } from "@earendil-works/pi-coding-agent";
+import type { Api, Model, ThinkingLevel } from "@earendil-works/pi-ai";
+import { Container, SelectList, Text } from "@earendil-works/pi-tui";
+
+const LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"] as const;
+export type SelectableThinkingLevel = (typeof LEVELS)[number];
+
+/** Levels the model actually supports, in canonical order. */
+export function supportedThinkingLevels(model: Model<Api>): readonly SelectableThinkingLevel[] {
+  const map = model.thinkingLevelMap;
+  if (map === undefined) return [];
+  const supported: SelectableThinkingLevel[] = [];
+  for (const level of LEVELS) if (level in map) supported.push(level);
+  return supported;
+}
+
+/** Ask the thinking level for a model (skipped entirely when unsupported). */
+export async function selectThinkingLevel(
+  ctx: ExtensionContext,
+  model: Model<Api>,
+  current?: ThinkingLevel,
+): Promise<ThinkingLevel | undefined> {
+  const levels = supportedThinkingLevels(model);
+  if (levels.length === 0) return undefined;
+  if (ctx.mode !== "tui") {
+    const level = current ?? levels[0];
+    return level === "off" ? undefined : level;
+  }
+
+  const chosen = await ctx.ui.custom<SelectableThinkingLevel | null>((_tui, theme, _kb, done) => {
+    const container = new Container();
+    container.addChild(new DynamicBorder((s: string) => theme.fg("accent", s)));
+    container.addChild(new Text(theme.fg("accent", theme.bold("Thinking level")), 1, 0));
+    const list = new SelectList(
+      levels.map((level) => ({ value: level, label: level, description: `Use ${level} reasoning for ${model.id}` })),
+      levels.length,
+      {
+        selectedPrefix: (t) => theme.fg("accent", t),
+        selectedText: (t) => theme.fg("accent", t),
+        description: (t) => theme.fg("muted", t),
+        scrollInfo: (t) => theme.fg("dim", t),
+        noMatch: (t) => theme.fg("warning", t),
+      },
+    );
+    const initial = levels.indexOf(current ?? "off");
+    if (initial >= 0) list.setSelectedIndex(initial);
+    list.onSelect = (item) => done(item.value as SelectableThinkingLevel);
+    list.onCancel = () => done(null);
+    container.addChild(list);
+    container.addChild(new Text(theme.fg("dim", "↑↓ navigate • enter select • esc skip"), 1, 0));
+    container.addChild(new DynamicBorder((s: string) => theme.fg("accent", s)));
+    return { render: (w) => container.render(w), invalidate: () => container.invalidate(), handleInput: (data) => list.handleInput(data) };
+  });
+  return chosen === "off" ? undefined : (chosen ?? undefined);
+}

package/src/ui/model-picker.ts

@@ -1,201 +1,11 @@
-/** Model picker TUI — choose a model and, when supported, a thinking level. */
-
-import type { ExtensionContext, ModelRegistry } from "@earendil-works/pi-coding-agent";
-import { DynamicBorder } from "@earendil-works/pi-coding-agent";
-import type { Api, Model, ThinkingLevel } from "@earendil-works/pi-ai";
-import { Container, type Component, type SelectItem, SelectList, Text, truncateToWidth } from "@earendil-works/pi-tui";
-import { formatCost } from "./theme.ts";
-import { compareLlm } from "../mode/llm-model.ts";
-
-export interface ModelSelection {
-  readonly model: Model<Api>;
-  readonly thinkingLevel?: ThinkingLevel;
-}
-
-const LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"] as const;
-type SelectableThinkingLevel = (typeof LEVELS)[number];
-
-/** Sentinel SelectList value for "always use cheapest available". */
-export const CHEAPEST_VALUE = "__rlm_cheapest__";
-
 /**
- * Models Pi itself would offer for this session, cheapest-first.
- *
- * Mirrors the built-in model switcher:
- *   - if the session has scoped models (`--models` / enabledModels) → those only
- *   - else → `getAvailable()` (providers with configured auth)
+ * Model picker facade — grouped drill-down: provider → model → thinking level.
  *
- * Deliberately NOT `getAll()`: the full catalog dumps every provider's catalog entry and is
- * not what the user sees in Pi natively. See Pi extension docs on `ctx.scopedModels`.
+ * The implementation is split under model-picker/ (grouping = pure catalog,
+ * levels = thinking-level step, drilldown = the overlay flow); this module is
+ * the stable import path everything else (commands, tests) talks to.
  */
-export function pickableModels(
-  registry: ModelRegistry,
-  scoped?: readonly { readonly model: Model<Api> }[],
-): readonly Model<Api>[] {
-  const source = scoped !== undefined && scoped.length > 0
-    ? scoped.map((s) => s.model)
-    : registry.getAvailable();
-  return [...source].sort(compareLlm);
-}
-
-function items(models: readonly Model<Api>[], includeCheapest: boolean): SelectItem[] {
-  const modelItems = models.map((m) => {
-    const price = `in ${formatCost(m.cost.input)}/Mtok · out ${formatCost(m.cost.output)}/Mtok`;
-    return {
-      value: `${m.provider}/${m.id}`,
-      label: `${m.provider}/${m.id}`,
-      description: `${price}${m.reasoning ? " · reasoning" : ""}`,
-    };
-  });
-  if (!includeCheapest) return modelItems;
-  return [
-    { value: CHEAPEST_VALUE, label: "⟳ cheapest (auto)", description: "Always use the cheapest model with a configured key" },
-    ...modelItems,
-  ];
-}
-
-/**
- * Index to pre-select in the model list (with cheapest row at 0 when included).
- * Without this, the list always opens on "cheapest (auto)" and Enter silently unpins.
- */
-export function initialModelPickerIndex(
-  models: readonly Model<Api>[],
-  current?: Model<Api>,
-  currentRef?: string,
-  includeCheapest = true,
-): number {
-  const offset = includeCheapest ? 1 : 0;
-  const ref = current ? `${current.provider}/${current.id}` : currentRef;
-  if (!ref) return 0;
-  const idx = models.findIndex((m) => `${m.provider}/${m.id}` === ref);
-  // When a saved ref exists but the model is absent from the current catalog
-  // (e.g. provider not refreshed yet), pre-select the first real model — NOT
-  // "cheapest auto". Accidentally hitting Enter on cheapest would wipe the pin
-  // silently (Root Cause #4, v0.3.2).
-  if (idx < 0) return ref ? offset : 0;
-  return idx + offset;
-}
-
-function supportedThinkingLevels(model: Model<Api>): SelectableThinkingLevel[] {
-  if (!model.reasoning) return [];
-  const map = model.thinkingLevelMap;
-  if (!map) return [...LEVELS];
-  return LEVELS.filter((level) => map[level] !== null);
-}
-
-async function selectThinkingLevel(
-  ctx: ExtensionContext,
-  model: Model<Api>,
-  current?: ThinkingLevel,
-): Promise<ThinkingLevel | undefined> {
-  const levels = supportedThinkingLevels(model);
-  if (levels.length === 0) return undefined;
-  if (ctx.mode !== "tui") {
-    const level = current ?? levels[0];
-    return level === "off" ? undefined : level;
-  }
-
-  const chosen = await ctx.ui.custom<SelectableThinkingLevel | null>((_tui, theme, _kb, done) => {
-    const container = new Container();
-    container.addChild(new DynamicBorder((s: string) => theme.fg("accent", s)));
-    container.addChild(new Text(theme.fg("accent", theme.bold("Thinking level")), 1, 0));
-    const list = new SelectList(
-      levels.map((level) => ({ value: level, label: level, description: `Use ${level} reasoning for ${model.id}` })),
-      levels.length,
-      {
-        selectedPrefix: (t) => theme.fg("accent", t),
-        selectedText: (t) => theme.fg("accent", t),
-        description: (t) => theme.fg("muted", t),
-        scrollInfo: (t) => theme.fg("dim", t),
-        noMatch: (t) => theme.fg("warning", t),
-      },
-    );
-    const initial = levels.indexOf(current ?? "off");
-    if (initial >= 0) list.setSelectedIndex(initial);
-    list.onSelect = (item) => done(item.value as SelectableThinkingLevel);
-    list.onCancel = () => done(null);
-    container.addChild(list);
-    container.addChild(new Text(theme.fg("dim", "↑↓ navigate • enter select • esc skip"), 1, 0));
-    container.addChild(new DynamicBorder((s: string) => theme.fg("accent", s)));
-    return { render: (w) => container.render(w), invalidate: () => container.invalidate(), handleInput: (data) => list.handleInput(data) };
-  });
-  return chosen === "off" ? undefined : (chosen ?? undefined);
-}
-
-/** Show a model selector; resolves to the chosen model plus optional thinking level. */
-export async function selectModel(
-  ctx: ExtensionContext,
-  title: string,
-  models: readonly Model<Api>[],
-  current?: Model<Api>,
-  currentThinking?: ThinkingLevel,
-  currentRef?: string,
-): Promise<ModelSelection | null | undefined> {
-  if (models.length === 0) {
-    ctx.ui.notify("RLM: no models available (add a provider key in Pi, or widen --models / enabledModels)", "warning");
-    return undefined;
-  }
-  if (ctx.mode !== "tui") {
-    const fallback = models[0];
-    if (!fallback) return undefined;
-    // Prefer an explicit pin (resolved model or saved ref) over "first = cheapest".
-    const fromRef = currentRef
-      ? models.find((m) => `${m.provider}/${m.id}` === currentRef)
-      : undefined;
-    const model = current ?? fromRef ?? fallback;
-    return { model, thinkingLevel: await selectThinkingLevel(ctx, model, currentThinking) };
-  }
-
-  const chosen = await ctx.ui.custom<string | null>((_tui, theme, _kb, done) => {
-    let query = "";
-    const container = new Container();
-    container.addChild(new DynamicBorder((s: string) => theme.fg("accent", s)));
-    container.addChild(new Text(theme.fg("accent", theme.bold(title)), 1, 0));
-    const filterLine: Component = {
-      render: (w) => [truncateToWidth(theme.fg("dim", `Filter: ${query || "type to filter…"}`), w)],
-      invalidate: () => {},
-    };
-    const list = new SelectList(items(models, true), Math.min(models.length + 1, 13), {
-      selectedPrefix: (t) => theme.fg("accent", t),
-      selectedText: (t) => theme.fg("accent", t),
-      description: (t) => theme.fg("muted", t),
-      scrollInfo: (t) => theme.fg("dim", t),
-      noMatch: (t) => theme.fg("warning", t),
-    });
-    const initial = initialModelPickerIndex(models, current, currentRef, true);
-    if (initial > 0) list.setSelectedIndex(initial);
-    const isFilterText = (s: string): boolean => {
-      const sanitized = s.replace(/ /g, "");
-      return sanitized.length > 0 && Array.from(sanitized).every((char) => char >= " " && char !== "\x7f");
-    };
-    const isBackspace = (s: string): boolean => s === "\x7f" || s === "\b";
-    list.onSelect = (item) => done(item.value);
-    list.onCancel = () => done(null);
-    container.addChild(filterLine);
-    container.addChild(list);
-    container.addChild(new Text(theme.fg("dim", "↑↓ navigate • type to filter • enter select • esc cancel"), 1, 0));
-    container.addChild(new DynamicBorder((s: string) => theme.fg("accent", s)));
-    return {
-      render: (w) => container.render(w),
-      invalidate: () => container.invalidate(),
-      handleInput: (data) => {
-        if (isFilterText(data)) {
-          query = `${query}${data.replace(/ /g, "")}`;
-          list.setFilter(query);
-          return;
-        }
-        if (isBackspace(data)) {
-          query = query.slice(0, -1);
-          list.setFilter(query);
-          return;
-        }
-        list.handleInput(data);
-      },
-    };
-  });
 
-  if (chosen === CHEAPEST_VALUE) return null;
-  const model = chosen ? models.find((m) => `${m.provider}/${m.id}` === chosen) : undefined;
-  if (!model) return undefined;
-  return { model, thinkingLevel: await selectThinkingLevel(ctx, model, currentThinking) };
-}
+export { CHEAPEST_VALUE, SESSION_VALUE, buildCatalog, initialModelPickerIndex, pickableModels, modelRefOf, type ProviderGroup } from "./model-picker/grouping.ts";
+export { selectThinkingLevel, supportedThinkingLevels, type SelectableThinkingLevel } from "./model-picker/levels.ts";
+export { selectModel, type ModelSelection, type PickerRole } from "./model-picker/drilldown.ts";

package/src/ui/panel/run-registry.ts

@@ -0,0 +1,135 @@
+/**
+ * RunRegistry — session-scoped index of every live RLM surface (repl cells,
+ * rlm tool runs, detached background work) for the tree widget and agent modal.
+ *
+ * Sources are registered as ACCESSORS (subcalls/totals) so any owner — a
+ * per-call SubcallStore, BackgroundTasks' live view — fits without coupling.
+ * The registry fans every emitter's change events out to widget/modal listeners
+ * and builds immutable RunSnapshots on demand. register() returns an unregister
+ * function; callers invoke it in finally so a failed run never leaks.
+ */
+
+import type { RlmEmitter } from "../../tool/rlm-events.ts";
+import type { RlmRunStatus, RlmSubcall, SubcallPhase } from "../../tool/rlm-details.ts";
+import type { RunSnapshot } from "../tree/tree-model.ts";
+import { TimelineStore } from "../modal/timeline-store.ts";
+
+export interface RunRegistration {
+  readonly runId: string;
+  /** Root row label — prompt or code preview. */
+  readonly label: string;
+  readonly emitter: RlmEmitter;
+  readonly subcalls: () => readonly RlmSubcall[];
+  readonly totals: () => { readonly costUsd: number; readonly tokens: number };
+  /** Live root state; defaults: running, no phase, no turns. */
+  readonly rootStatus?: () => RlmRunStatus;
+  readonly rootPhase?: () => SubcallPhase | undefined;
+  readonly turns?: () => { readonly current: number; readonly max: number };
+  /** Root's OWN model ("provider/id") — the row never shows a blended/absent model. */
+  readonly rootModel?: () => string | undefined;
+  /** Root's OWN spend (driver-model turns) — never a subtree sum across models. */
+  readonly rootTokens?: () => number;
+  /** Persistent entries (background work) stay hidden until they hold subcalls. */
+  readonly hideWhenEmpty?: boolean;
+}
+
+export interface RunEntry {
+  readonly runId: string;
+  readonly label: string;
+  readonly timeline: TimelineStore;
+  readonly subcalls: () => readonly RlmSubcall[];
+  readonly totals: () => { readonly costUsd: number; readonly tokens: number };
+  readonly rootStatus: () => RlmRunStatus;
+  readonly rootPhase: () => SubcallPhase | undefined;
+  readonly turns: () => { readonly current: number; readonly max: number };
+  readonly rootModel: () => string | undefined;
+  readonly rootTokens: () => number;
+  readonly hideWhenEmpty: boolean;
+}
+
+const DEFAULT_TURNS = Object.freeze({ current: 0, max: 0 });
+
+export class RunRegistry {
+  private readonly entries = new Map<string, RunEntry>();
+  private readonly listeners: (() => void)[] = [];
+
+  /** Register a live run. Returns an idempotent unregister — call it in finally. */
+  register(run: RunRegistration): () => void {
+    const entry: RunEntry = {
+      runId: run.runId,
+      label: run.label,
+      timeline: new TimelineStore(run.emitter, run.runId),
+      subcalls: run.subcalls,
+      totals: run.totals,
+      rootStatus: run.rootStatus ?? (() => "running"),
+      rootPhase: run.rootPhase ?? (() => undefined),
+      turns: run.turns ?? (() => DEFAULT_TURNS),
+      rootModel: run.rootModel ?? (() => undefined),
+      rootTokens: run.rootTokens ?? (() => 0),
+      hideWhenEmpty: run.hideWhenEmpty ?? false,
+    };
+    this.entries.set(run.runId, entry);
+    const unsubs = [
+      run.emitter.onSubcallCreated(() => this.notify()),
+      run.emitter.onSubcallUpdated(() => this.notify()),
+      run.emitter.onRootPhase(() => this.notify()),
+      run.emitter.onStatus(() => this.notify()),
+      run.emitter.onTurn(() => this.notify()),
+    ];
+    this.notify();
+
+    let disposed = false;
+    return () => {
+      if (disposed) return;
+      disposed = true;
+      for (const unsub of unsubs) unsub();
+      entry.timeline.dispose();
+      this.entries.delete(run.runId);
+      this.notify();
+    };
+  }
+
+  /** Subscribe to any change in any registered run. Returns unsubscribe. */
+  onChange(listener: () => void): () => void {
+    this.listeners.push(listener);
+    return () => {
+      const at = this.listeners.indexOf(listener);
+      if (at >= 0) this.listeners.splice(at, 1);
+    };
+  }
+
+  hasActive(): boolean {
+    for (const entry of this.entries.values()) if (this.isVisible(entry)) return true;
+    return false;
+  }
+
+  find(runId: string): RunEntry | undefined {
+    return this.entries.get(runId);
+  }
+
+  /** Immutable view of every visible live run, registration order. */
+  snapshots(): readonly RunSnapshot[] {
+    const out: RunSnapshot[] = [];
+    for (const entry of this.entries.values()) {
+      if (!this.isVisible(entry)) continue;
+      out.push({
+        runId: entry.runId,
+        rootLabel: entry.label,
+        status: entry.rootStatus(),
+        rootPhase: entry.rootPhase(),
+        rootModel: entry.rootModel(),
+        rootTokens: entry.rootTokens(),
+        subcalls: entry.subcalls(),
+      });
+    }
+    return Object.freeze(out);
+  }
+
+  private isVisible(entry: RunEntry): boolean {
+    return !entry.hideWhenEmpty || entry.subcalls().length > 0;
+  }
+
+  private notify(): void {
+    for (const listener of this.listeners) listener();
+  }
+}