loom-agent 1.2.0

package/src/tui/components/SubagentPanel.tsx

@@ -0,0 +1,217 @@
+// SubagentPanel — /subagents modal listing every subagent run (active + from
+// disk) with live status, elapsed time, cost, and tool log. Enter opens a
+// detail modal with the full output; c cancels a running subagent.
+import { Show, createSignal, createMemo, onMount, onCleanup } from "solid-js";
+import { useKeyboard } from "@opentui/solid";
+import { palette } from "../theme.ts";
+import { ModalFrame } from "./Modals.tsx";
+import * as kbs from "../keybinds.ts";
+import {
+  activeSubagents, subagentHistory, cancelSubagentRun, loadSubagentHistory,
+  modal, closeModal, openModal,
+  type SubagentEntry,
+} from "../store.ts";
+
+const ui = palette("loom");
+
+function statusGlyph(s: SubagentEntry["status"]): string {
+  if (s === "running") return "\u25CF";
+  if (s === "done") return "\u2713";
+  if (s === "cancelled") return "\u2298";
+  return "\u2717";
+}
+
+function statusColor(s: SubagentEntry["status"]): string {
+  if (s === "running") return ui.warning || ui.primary;
+  if (s === "done") return ui.success || ui.primary;
+  if (s === "cancelled") return ui.fgMuted;
+  return "#ff5555";
+}
+
+function fmtCost(c: number): string {
+  if (!c || c < 0.0001) return "free";
+  if (c < 0.01) return "$" + c.toFixed(4);
+  return "$" + c.toFixed(2);
+}
+
+function fmtTokens(inT: number, outT: number): string {
+  const sum = inT + outT;
+  if (sum < 1000) return String(sum) + " tok";
+  if (sum < 1000000) return (sum / 1000).toFixed(1) + "k tok";
+  return (sum / 1000000).toFixed(2) + "M tok";
+}
+
+function fmtDuration(ms: number): string {
+  if (ms < 1000) return ms + "ms";
+  if (ms < 60000) return (ms / 1000).toFixed(1) + "s";
+  const m = Math.floor(ms / 60000);
+  const s = Math.floor((ms % 60000) / 1000);
+  return m + "m " + s + "s";
+}
+
+// Live tick — bumps once a second while the panel is mounted so running
+// subagents' elapsed/cost/time fields refresh without manual re-renders.
+function useLiveTick(): () => number {
+  const [, setTick] = createSignal(0);
+  let id: any = null;
+  onMount(() => { id = setInterval(() => setTick(v => v + 1), 1000); });
+  onCleanup(() => { if (id) clearInterval(id); });
+  return () => Date.now();
+}
+
+function openSubagentDetail(runId: string) {
+  openModal({ type: "subagent_detail", runId });
+}
+
+export function SubagentPanel() {
+  const now = useLiveTick();
+
+  // Merged list: active first (running ones float up), then history.
+  const all = createMemo<SubagentEntry[]>(() => {
+    const active = Array.from(activeSubagents().values());
+    const seen = new Set(active.map(a => a.runId));
+    const hist = subagentHistory().filter(h => !seen.has(h.runId));
+    return active.concat(hist).sort((a, b) => b.startTime - a.startTime);
+  });
+
+  const [sel, setSel] = createSignal(0);
+  const [statusMsg, setStatusMsg] = createSignal<string>("");
+
+  const PAGE = 14;
+  const win = createMemo(() => {
+    const list = all();
+    const total = list.length;
+    const idx = Math.min(sel(), Math.max(0, total - 1));
+    const start = Math.max(0, Math.min(idx - Math.floor(PAGE / 2), total - PAGE));
+    return { start: Math.max(0, start), items: list.slice(start, start + PAGE), total, idx };
+  });
+
+  useKeyboard((key: any) => {
+    const ks = kbs.keyString(key);
+    if (kbs.is("modal_cancel", ks)) { closeModal(); return; }
+    if (kbs.dialogIs("dialog_select_next", ks)) { setSel(i => Math.min(all().length - 1, i + 1)); return; }
+    if (kbs.dialogIs("dialog_select_prev", ks)) { setSel(i => Math.max(0, i - 1)); return; }
+    if (kbs.dialogIs("dialog_select_home", ks)) { setSel(0); return; }
+    if (kbs.dialogIs("dialog_select_end", ks)) { setSel(Math.max(0, all().length - 1)); return; }
+    if (kbs.dialogIs("dialog_select_submit", ks)) {
+      const list = all();
+      const cur = list[sel()];
+      if (cur) openSubagentDetail(cur.runId);
+      return;
+    }
+    if (key.name === "r") { loadSubagentHistory({ limit: 200 }); setStatusMsg("history refreshed"); return; }
+    if (key.name === "m") {
+      // Set the DEFAULT model for the selected agent id ("provider/model-id").
+      const cur = all()[sel()];
+      if (!cur) return;
+      const { loadConfig, saveConfig } = require("../../../config/settings.js");
+      const cfg = loadConfig();
+      cfg.agents = cfg.agents || {};
+      const curModel = (cfg.agents[cur.agentId] && cfg.agents[cur.agentId].model) || "";
+      openModal({
+        type: "input", title: "Default model for " + cur.agent,
+        placeholder: 'e.g. "anthropic/claude-sonnet-4-20250514" — empty clears',
+        value: curModel,
+        onPick(val: string) {
+          closeModal();
+          const v = String(val || "").trim();
+          if (v) { cfg.agents[cur.agentId] = Object.assign({}, cfg.agents[cur.agentId], { model: v }); saveConfig(cfg); }
+          else if (cfg.agents[cur.agentId]) { delete cfg.agents[cur.agentId].model; saveConfig(cfg); }
+          setStatusMsg(v ? cur.agentId + " default model \u2192 " + v : cur.agentId + " default model cleared");
+        },
+      });
+      return;
+    }
+    if (key.name === "c") {
+      const list = all();
+      const cur = list[sel()];
+      if (cur && cur.status === "running") {
+        const ok = cancelSubagentRun(cur.runId);
+        setStatusMsg(ok ? "cancelling " + cur.agent + " \u2026" : "cancel failed (already finished)");
+      } else {
+        setStatusMsg("nothing to cancel (selected is not running)");
+      }
+      return;
+    }
+  });
+
+  const activeCount = createMemo(() => Array.from(activeSubagents().values()).filter(e => e.status === "running").length);
+
+  return (
+    <ModalFrame
+      title="Subagents"
+      subtitle={(activeCount() || 0) + " active \u00B7 " + all().length + " total \u00B7 arrows navigate \u00B7 Enter details \u00B7 c cancel \u00B7 r refresh"}
+      footer="Enter details \u00B7 c cancel running \u00B7 r refresh history \u00B7 Esc close"
+    >
+      <Show when={win().total === 0}>
+        <text fg={ui.fgMuted}>No subagent runs yet. Delegate via the task tool or @mention and it will appear here</text>
+     </Show>
+      <Show when={win().total > 0}>
+        <box flexDirection="column">
+          {win().items.map((entry: any, i: number) => {
+            const abs = win().start + i;
+            const isSelected = abs === sel();
+            const ms = entry.endTime ? entry.durationMs : (now() - entry.startTime);
+            return (
+              <box flexDirection="row" paddingX={1}
+                backgroundColor={isSelected ? ui.bgInput : undefined}
+                onMouseDown={() => setSel(abs)}>
+                <text fg={statusColor(entry.status)}>{(isSelected ? "> " : "  ") + statusGlyph(entry.status) + " "}</text>
+                <text fg={isSelected ? ui.primary : ui.fg}>{entry.agent + "  "}</text>
+                <text fg={ui.fgMuted}>{fmtDuration(ms) + "  "}</text>
+                <text fg={ui.fgMuted}>{fmtCost(entry.costUsd) + "  \u00B7 "}</text>
+                <text fg={ui.fgDim}>{(entry.prompt || "").replace(/\s+/g, " ").slice(0, 44)}</text>
+              </box>
+            );
+          })}
+        </box>
+      </Show>
+      <Show when={statusMsg()}>
+        <text fg={ui.fgMuted}>{statusMsg()}</text>
+      </Show>
+    </ModalFrame>
+  );
+}
+
+export function SubagentDetailPanel() {
+  let id: any = null;
+  const [, setTick] = createSignal(0);
+  onMount(() => { id = setInterval(() => setTick(v => v + 1), 500); });
+  onCleanup(() => { if (id) clearInterval(id); });
+
+  useKeyboard((key: any) => {
+    const ks = kbs.keyString(key);
+    if (kbs.is("modal_cancel", ks)) closeModal();
+  });
+
+  const entry = createMemo<SubagentEntry | null>(() => {
+    setTick();
+    const m = modal();
+    const runId = m && m.runId;
+    if (!runId) return null;
+    const live = activeSubagents().get(runId);
+    if (live) return live;
+    return subagentHistory().find(h => h.runId === runId) || null;
+  });
+
+  const now = () => Date.now();
+
+  return (
+    <ModalFrame title="Subagent detail" subtitle="Esc close" footer="Esc close">
+      <Show when={entry()} fallback={<text fg={ui.fgMuted}>Subagent not found</text>}>
+        <box flexDirection="column">
+          <text fg={ui.primary}>{(entry() as any).agent + "  " + statusGlyph((entry() as any).status) + "  " + (entry() as any).status}</text>
+          <text fg={ui.fgMuted}>{"id: " + (entry() as any).runId}</text>
+          <text fg={ui.fgMuted}>{"started: " + new Date((entry() as any).startTime).toISOString() + ((entry() as any).endTime ? "  ended: " + new Date((entry() as any).endTime).toISOString() : "  (running)")}</text>
+          <text fg={ui.fgMuted}>{"duration: " + ((entry() as any).endTime ? fmtDuration((entry() as any).durationMs) : fmtDuration(now() - (entry() as any).startTime)) + "  cost: " + fmtCost((entry() as any).costUsd) + "  tokens: " + fmtTokens((entry() as any).tokensIn, (entry() as any).tokensOut)}</text>
+          <text fg={ui.fgMuted}>{"prompt: " + ((entry() as any).prompt || "").slice(0, 500)}</text>
+          <Show when={(entry() as any).toolLog && (entry() as any).toolLog.length > 0}>
+            <text fg={ui.fgMuted}>{"tool log: " + (entry() as any).toolLog.join(" \u00B7 ")}</text>
+          </Show>
+          <text fg={ui.fg}>output</text>
+          <text fg={ui.fgDim}>{((entry() as any).content || "(empty)").slice(0, 4000)}</text>
+        </box>
+      </Show>
+    </ModalFrame>
+  );
+}

package/src/tui/components/ToastOverlay.tsx

@@ -0,0 +1,34 @@
+// ToastOverlay -- transient confirmations float above the input bar (bottom-
+// right) and auto-dismiss after a few seconds. Never shown in the chat area.
+import { Show, For } from "solid-js";
+import { palette } from "../theme.ts";
+import { toasts } from "../store.ts";
+
+const ui = palette("loom");
+
+export function ToastOverlay() {
+  const list = () => toasts().slice(-3);
+  return (
+    <Show when={toasts().length > 0}>
+      <box
+        position="absolute" bottom={4} right={0} zIndex={60}
+        flexDirection="column" paddingX={1} paddingY={0}
+      >
+        <For each={list()}>
+          {(t) => (
+            <box
+              border borderStyle="rounded"
+              borderColor={t.kind === "error" ? ui.error : t.kind === "ok" ? ui.success : ui.primary}
+              paddingX={1} paddingY={0} marginTop={0}
+              backgroundColor={ui.bgPanel}
+            >
+              <text fg={t.kind === "error" ? ui.error : t.kind === "ok" ? ui.success : ui.fg}>
+                {" " + t.text}
+              </text>
+            </box>
+          )}
+        </For>
+      </box>
+    </Show>
+  );
+}

package/src/tui/keybinds.ts

@@ -0,0 +1,318 @@
+// Keybinds — configurable keybindings for the Loom TUI.
+//
+// Reads `keybinds`, `leader`, and `leader_timeout` from ~/.loom/tui.json
+// (see docs/keybinds.md). OpenCode-compatible action names are accepted as
+// aliases; unknown names are ignored with a warning. Binding values follow the
+// same rules as OpenCode: a string with comma-separated alternatives, an
+// array, an object ({ key }), or "none" / false to disable. "<leader>X"
+// bindings fire after the leader key.
+//
+// This module is intentionally dependency-free (no Solid, no store) so it can
+// be unit-tested in isolation; the App owns action execution and the leader
+// state lives here as a plain boolean.
+import { loadTuiJson } from "./tui-config.ts";
+
+export interface KeybindAction {
+  action: string;
+  desc: string;
+  def: string | string[];
+  slash?: string;
+  opencode?: string;
+  context?: "app" | "dialog";
+}
+
+export const KB_ACTIONS: KeybindAction[] = [
+  // ── App / session ──
+  { action: "app_exit", desc: "Quit Loom Code", def: "ctrl+c,<leader>q", opencode: "app_exit" },
+  { action: "command_list", desc: "Open the command palette", def: "ctrl+p", opencode: "command_list" },
+  { action: "sidebar_toggle", desc: "Toggle the sidebar", def: "ctrl+b", opencode: "sidebar_toggle" },
+  { action: "sidebar_cycle_tab", desc: "Cycle the sidebar tab", def: "ctrl+i" },
+  { action: "session_interrupt", desc: "Interrupt the running task / clear the draft", def: "escape", opencode: "session_interrupt" },
+  { action: "modal_cancel", desc: "Close the open dialog", def: "escape" },
+  { action: "user_expand", desc: "Expand/collapse the most recent long message", def: "ctrl+e" },
+  { action: "session_new", desc: "Start a new session", def: "<leader>n", slash: "/new", opencode: "session_new" },
+  { action: "session_list", desc: "Browse saved sessions", def: "<leader>l", slash: "/sessions", opencode: "session_list" },
+  { action: "session_export", desc: "Export the session to markdown", def: "<leader>x", slash: "/export", opencode: "session_export" },
+  { action: "session_compact", desc: "Compact the conversation", def: "<leader>c", slash: "/compact", opencode: "session_compact" },
+  { action: "model_list", desc: "Open the model picker", def: "<leader>m", slash: "/models", opencode: "model_list,model_provider_list" },
+  { action: "agent_list", desc: "List agents", def: "<leader>a", slash: "/agents", opencode: "agent_list" },
+  { action: "subagent_list", desc: "View subagents (live + history, cancel, details)", def: "<leader>j", slash: "/subagents" },
+  { action: "help_show", desc: "Show help", def: "<leader>h", slash: "/help", opencode: "help_show" },
+  { action: "editor_open", desc: "Open LOOM.md in your editor", def: "<leader>e", slash: "/editor", opencode: "editor_open" },
+  { action: "display_thinking", desc: "Toggle thinking visibility", def: "<leader>t", slash: "/thinking", opencode: "display_thinking" },
+  { action: "tool_details", desc: "Toggle tool detail visibility", def: "<leader>d", slash: "/details", opencode: "tool_details" },
+  { action: "app_settings", desc: "Open settings", def: "<leader>s", slash: "/settings" },
+  { action: "app_undo", desc: "Undo the last exchange", def: "<leader>u", slash: "/undo" },
+  { action: "app_redo", desc: "Redo the last undone exchange", def: "<leader>r", slash: "/redo" },
+  { action: "mode_build", desc: "Switch to Build mode", def: "<leader>b", slash: "/build" },
+  { action: "mode_plan", desc: "Switch to Plan mode", def: "<leader>p", slash: "/plan" },
+  { action: "theme_list", desc: "Open the theme picker", def: "none", slash: "/theme", opencode: "theme_list" },
+  // ── Prompt input (readline-style editing) ──
+  { action: "input_submit", desc: "Submit the prompt", def: "return", opencode: "input_submit,prompt_submit" },
+  { action: "input_newline", desc: "Insert a newline", def: "shift+return", opencode: "input_newline" },
+  { action: "input_paste", desc: "Paste (the terminal handles it)", def: "ctrl+v", opencode: "input_paste" },
+  { action: "input_select_all", desc: "Select the whole draft", def: "ctrl+a", opencode: "input_select_all" },
+  { action: "input_move_left", desc: "Move the caret left", def: "left", opencode: "input_move_left" },
+  { action: "input_move_right", desc: "Move the caret right", def: "right", opencode: "input_move_right" },
+  { action: "line_home", desc: "Move to the start of the draft", def: "home", opencode: "input_line_home,input_buffer_home" },
+  { action: "line_end", desc: "Move to the end of the draft", def: "end", opencode: "input_line_end,input_buffer_end" },
+  { action: "input_backspace", desc: "Backspace", def: "backspace", opencode: "input_backspace" },
+  { action: "input_delete", desc: "Delete forward", def: "ctrl+d,delete", opencode: "input_delete" },
+  { action: "prompt_autocomplete_next", desc: "Next suggestion / cycle the mode", def: "tab", opencode: "prompt.autocomplete.next,prompt.autocomplete.complete" },
+  { action: "up_context", desc: "Up (suggestion / caret line / history)", def: "up", opencode: "input_move_up,history_previous,prompt.autocomplete.prev" },
+  { action: "down_context", desc: "Down (suggestion / caret line / history)", def: "down", opencode: "input_move_down,history_next" },
+  // ── Dialog keys (modal lists & prompts) ──
+  { action: "dialog_select_prev", desc: "Dialog: previous row", def: "up", context: "dialog", opencode: "dialog.select.prev" },
+  { action: "dialog_select_next", desc: "Dialog: next row", def: "down", context: "dialog", opencode: "dialog.select.next" },
+  { action: "dialog_select_submit", desc: "Dialog: select the row", def: "return", context: "dialog", opencode: "dialog.select.submit,dialog.prompt.submit" },
+  { action: "dialog_select_page_up", desc: "Dialog: page up", def: "pageup", context: "dialog", opencode: "dialog.select.page_up" },
+  { action: "dialog_select_page_down", desc: "Dialog: page down", def: "pagedown", context: "dialog", opencode: "dialog.select.page_down" },
+  { action: "dialog_select_home", desc: "Dialog: first row", def: "home", context: "dialog", opencode: "dialog.select.home" },
+  { action: "dialog_select_end", desc: "Dialog: last row", def: "end", context: "dialog", opencode: "dialog.select.end" },
+];
+
+// ─── Config file ───
+
+// ─── Canonical key strings ───
+// Both the event serializer and the config parser produce the same shape:
+// modifier+name, e.g. "ctrl+shift+y", "shift+return", "escape", "f5".
+const NAME_ALIASES: Record<string, string> = {
+  enter: "return", esc: "escape", del: "delete", ins: "insert",
+  "page-up": "pageup", page_up: "pageup", pgup: "pageup", pgdn: "pagedown",
+  page_down: "pagedown", "page-down": "pagedown",
+};
+
+export function keyString(k: any): string {
+  if (!k || !k.name) return "";
+  const parts: string[] = [];
+  if (k.ctrl) parts.push("ctrl");
+  if (k.shift) parts.push("shift");
+  if (k.meta || k.option) parts.push("alt");
+  if (k.super) parts.push("super");
+  if (k.hyper) parts.push("hyper");
+  let name = String(k.name).toLowerCase();
+  if (/^f([1-9]|1[0-2])$/.test(name)) name = name.toLowerCase();
+  else if (NAME_ALIASES[name]) name = NAME_ALIASES[name];
+  parts.push(name);
+  return parts.join("+");
+}
+
+const MODIFIER_ALIASES: Record<string, string> = {
+  ctrl: "ctrl", control: "ctrl",
+  shift: "shift",
+  alt: "alt", meta: "alt", option: "alt",
+  super: "super", cmd: "super", win: "super", mod: "super",
+  hyper: "hyper",
+};
+
+function canonKey(s: string): string {
+  if (typeof s !== "string") return "";
+  const t = s.trim();
+  if (!t) return "";
+  if (t.startsWith("<leader>")) {
+    const rest = canonKey(t.slice(8));
+    return rest ? "<leader>" + rest : "";
+  }
+  const parts = t.split("+").map(p => p.trim().toLowerCase()).filter(Boolean);
+  const mods: string[] = [];
+  let name = "";
+  for (const p of parts) {
+    const m = MODIFIER_ALIASES[p];
+    if (m) { if (mods.indexOf(m) < 0) mods.push(m); continue; }
+    if (!name) name = NAME_ALIASES[p] || (/^f([1-9]|1[0-2])$/i.test(p) ? p.toLowerCase() : p);
+  }
+  const order = ["ctrl", "shift", "alt", "super", "hyper"];
+  const out = order.filter(m => mods.indexOf(m) >= 0);
+  if (name) out.push(name);
+  return out.join("+");
+}
+
+// ─── Binding value parsing ───
+// Returns the list of raw key specs, or null when the binding is disabled.
+function parseBindings(value: any): string[] | null {
+  if (value === false || value === null) return null;
+  if (value === undefined) return null;
+  if (typeof value === "string") {
+    if (value.trim() === "" || value.trim().toLowerCase() === "none") return null;
+    return value.split(",").map(s => s.trim()).filter(Boolean);
+  }
+  if (Array.isArray(value)) return value.map(v => String(v).trim()).filter(Boolean);
+  if (typeof value === "object" && value && value.key !== undefined) return [String(value.key).trim()];
+  return null;
+}
+
+// ─── Alias resolution (opencode-compatible names) ───
+const ALIAS_TO_ACTION: Record<string, string> = {};
+const ACTION_BY_NAME: Record<string, KeybindAction> = {};
+for (const a of KB_ACTIONS) {
+  ACTION_BY_NAME[a.action] = a;
+  for (const alias of (a.opencode || "").split(",").map(s => s.trim()).filter(Boolean)) {
+    ALIAS_TO_ACTION[alias] = a.action;
+  }
+}
+function resolveActionName(name: string): string | undefined {
+  const n = name.trim();
+  if (ACTION_BY_NAME[n]) return n;
+  if (ALIAS_TO_ACTION[n]) return ALIAS_TO_ACTION[n];
+  return undefined;
+}
+
+// ─── Resolved maps ───
+let appMap = new Map<string, string>();      // keystring → action (app context)
+let dialogMap = new Map<string, string>();   // keystring → action (dialog context)
+let modalMap = new Map<string, string>();    // keystring → "modal_cancel" (own map: it
+                                            // shares its key with session_interrupt)
+let leaderMap = new Map<string, string>();   // "leader:<keystring>" → action
+let labels = new Map<string, string[]>();    // action → display strings
+let leader = "ctrl+x";
+let leaderTimeoutMs = 2000;
+let configWarnings: string[] = [];
+
+function removeAction(action: string) {
+  for (const m of [appMap, dialogMap, modalMap, leaderMap]) {
+    for (const [ks, a] of Array.from(m.entries())) {
+      if (a === action) m.delete(ks);
+    }
+  }
+  labels.delete(action);
+}
+
+function addBinding(mode: "app" | "dialog" | "leader", keystring: string, action: string) {
+  const target = mode === "leader" ? leaderMap
+    : action === "modal_cancel" ? modalMap
+    : mode === "dialog" ? dialogMap
+    : appMap;
+  target.set(mode === "leader" ? "leader:" + keystring : keystring, action);
+  const disp = mode === "leader" ? "<leader>" + keystring : keystring;
+  const l = labels.get(action) || [];
+  l.push(disp);
+  labels.set(action, l);
+}
+
+function actionContext(action: string): "app" | "dialog" {
+  return ACTION_BY_NAME[action]?.context === "dialog" ? "dialog" : "app";
+}
+
+export function reload() {
+  appMap = new Map();
+  dialogMap = new Map();
+  modalMap = new Map();
+  leaderMap = new Map();
+  labels = new Map();
+  configWarnings = [];
+  const cfg = loadTuiJson();
+
+  // Leader key + timeout.
+  const lv = cfg.leader;
+  if (lv === false || lv === "none" || lv === "") leader = "";
+  else leader = lv == null ? "ctrl+x" : canonKey(String(lv));
+  const lt = Number(cfg.leader_timeout);
+  leaderTimeoutMs = Number.isFinite(lt) && lt > 0 ? lt : 2000;
+  cancelLeader();
+
+  // Defaults first…
+  for (const a of KB_ACTIONS) {
+    const binds = parseBindings(a.def);
+    if (!binds) continue;
+    for (const b of binds) {
+      const c = canonKey(b);
+      if (!c) continue;
+      if (c.startsWith("<leader>")) addBinding("leader", c.slice(8), a.action);
+      else addBinding(a.context === "dialog" ? "dialog" : "app", c, a.action);
+    }
+  }
+
+  // …then user overrides (a configured value fully replaces the defaults).
+  const ub = cfg.keybinds && typeof cfg.keybinds === "object" ? cfg.keybinds : {};
+  let modalCancelConfigured = false;
+  for (const name of Object.keys(ub)) {
+    const action = resolveActionName(name);
+    if (!action) { configWarnings.push("unknown keybind action: " + name); continue; }
+    if (action === "modal_cancel") modalCancelConfigured = true;
+    const binds = parseBindings(ub[name]);
+    removeAction(action);
+    if (!binds) continue;
+    for (const b of binds) {
+      const c = canonKey(b);
+      if (!c) continue;
+      if (c.startsWith("<leader>")) addBinding("leader", c.slice(8), action);
+      else addBinding(actionContext(action), c, action);
+    }
+  }
+
+  // modal_cancel mirrors session_interrupt's keys unless configured separately,
+  // so ESC both clears the input and closes an open modal (legacy behavior).
+  if (!modalCancelConfigured) {
+    removeAction("modal_cancel");
+    for (const m of [appMap, leaderMap]) {
+      for (const [ks, a] of Array.from(m.entries())) {
+        if (a !== "session_interrupt") continue;
+        const plain = ks.startsWith("leader:") ? ks.slice(7) : ks;
+        addBinding(m === leaderMap ? "leader" : "app", plain, "modal_cancel");
+      }
+    }
+  }
+}
+
+// ─── Leader state ───
+let leaderArmed = false;
+let leaderTimer: any = null;
+
+export function isLeaderPending() { return leaderArmed; }
+
+export function cancelLeader() {
+  leaderArmed = false;
+  if (leaderTimer) { clearTimeout(leaderTimer); leaderTimer = null; }
+}
+
+/** Returns true when ks IS the leader key (arms the leader mode). */
+export function tapLeader(ks: string): boolean {
+  if (!leader || !ks || ks !== leader) return false;
+  leaderArmed = true;
+  if (leaderTimer) clearTimeout(leaderTimer);
+  leaderTimer = setTimeout(cancelLeader, leaderTimeoutMs);
+  return true;
+}
+
+/** While the leader is pending, look up the action bound to <leader>+ks. */
+export function leaderMatch(ks: string): string | undefined {
+  return leaderMap.get("leader:" + ks);
+}
+
+// ─── Lookups ───
+export function is(action: string, ks: string): boolean {
+  if (action === "modal_cancel") return modalMap.get(ks) === action;
+  return appMap.get(ks) === action;
+}
+export function dialogIs(action: string, ks: string): boolean { return dialogMap.get(ks) === action; }
+export function leaderKey(): string { return leader; }
+export function leaderTimeout(): number { return leaderTimeoutMs; }
+export function slashFor(action: string): string { return ACTION_BY_NAME[action]?.slash || ""; }
+export function warnings(): string[] { return configWarnings.slice(); }
+
+/** Human-readable label for an action (first bound key), for help/footers. */
+export function label(action: string): string {
+  const l = labels.get(action);
+  return l && l.length ? l[0] : "none";
+}
+
+/** Full description for /keybinds: one line per bound action. */
+export function describeAll(): string {
+  const lines: string[] = [];
+  lines.push("Keybinds (from ~/.loom/tui.json):");
+  for (const a of KB_ACTIONS) {
+    const l = labels.get(a.action);
+    if (!l || !l.length) continue;
+    lines.push("  " + a.action.padEnd(24) + " " + l.join(", "));
+  }
+  if (leader) lines.push("  " + "leader".padEnd(24) + " " + leader + "  (timeout " + leaderTimeout() + "ms)");
+  else lines.push("  " + "leader".padEnd(24) + " disabled");
+  if (configWarnings.length) {
+    lines.push("Warnings:");
+    for (const w of configWarnings) lines.push("  " + w);
+  }
+  lines.push("Edit ~/.loom/tui.json, then restart. See docs/keybinds.md.");
+  return lines.join("\n");
+}
+
+reload();