enigma-cli 1.1.4 → 1.3.0

package/dist/enigma.js

@@ -106,7 +106,7 @@ var init_agents = __esm({
         }
       },
       opencode: {
-        label: "opencode",
+        label: "OpenCode",
         memoryFile: "AGENTS.md",
         // opencode reads AGENTS.md from ~/.config/opencode (global) or the project
         // root (local); skills from ~/.config/opencode/skills and .opencode/skills.
@@ -217,7 +217,7 @@ var init_claude = __esm({
 import { homedir as homedir3 } from "os";
 import { join as join5 } from "path";
 import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync3 } from "fs";
-import * as p2 from "@clack/prompts";
+import * as p3 from "@clack/prompts";
 async function resolveBypassSelection(candidates, opts, interactive) {
   const supported = candidates.filter((a) => BYPASS_SUPPORTED.includes(a.name));
   if (!supported.length || opts.noBypass) return [];
@@ -229,7 +229,7 @@ async function resolveBypassSelection(candidates, opts, interactive) {
     return names.filter((n) => req.includes(n));
   }
   if (!interactive) return [];
-  const r = await p2.multiselect({
+  const r = await p3.multiselect({
     message: "Bypass approval prompts for which agents? (security trade-off: the agent stops asking before acting)",
     options: supported.map((a) => ({
       value: a.name,
@@ -239,7 +239,7 @@ async function resolveBypassSelection(candidates, opts, interactive) {
     initialValues: names.filter((n) => BYPASS_DEFAULT_ON.has(n)),
     required: false
   });
-  if (p2.isCancel(r)) return [];
+  if (p3.isCancel(r)) return [];
   return r;
 }
 function applyBypass(agentNames, scope, dryRun) {
@@ -247,9 +247,9 @@ function applyBypass(agentNames, scope, dryRun) {
     const res = enableFor(name, scope, dryRun);
     if (!res) continue;
     const label = AGENTS[name]?.label || name;
-    if (dryRun) p2.log.info(`Bypass (dry run): would enable for ${label} -> ${res.path}.`);
-    else if (res.changed) p2.log.warn(`Bypass: enabled for ${label} (${res.path}) - approval prompts are now OFF.`);
-    else p2.log.info(`Bypass: already enabled for ${label}.`);
+    if (dryRun) p3.log.info(`Bypass (dry run): would enable for ${label} -> ${res.path}.`);
+    else if (res.changed) p3.log.warn(`Bypass: enabled for ${label} (${res.path}) - approval prompts are now OFF.`);
+    else p3.log.info(`Bypass: already enabled for ${label}.`);
   }
 }
 function enableFor(name, scope, dryRun) {
@@ -453,7 +453,7 @@ var init_config = __esm({
     "use strict";
     init_util();
     CONFIG_FILE = ".enigma.json";
-    CONFIG_DEFAULTS = { commitEmoji: true, updateNotifier: true };
+    CONFIG_DEFAULTS = { commitEmoji: true, updateNotifier: true, fullscreen: true };
   }
 });
 
@@ -490,7 +490,8 @@ var init_settings_registry = __esm({
         blurb: "enigma runtime toggles (.enigma.json)",
         settings: [
           enigmaToggle("commit-emoji", "commitEmoji", "Commit subject emoji", "leading gitmoji on commit subjects"),
-          enigmaToggle("update-notifier", "updateNotifier", "Update notifications", "notify when a newer enigma-cli is published")
+          enigmaToggle("update-notifier", "updateNotifier", "Update notifications", "notify when a newer enigma-cli is published"),
+          enigmaToggle("fullscreen", "fullscreen", "Full-screen TUI", "clear the screen for a clean TUI view; off renders inline among existing output")
         ]
       },
       {
@@ -530,44 +531,29 @@ __export(settings_exports, {
   runHomeTui: () => runHomeTui,
   runSettingsTui: () => runSettingsTui
 });
-async function runHomeTui(runAction) {
-  await runTui("home", runAction);
+async function runHomeTui(hub) {
+  await runTui({ showActions: true, hub });
 }
 async function runSettingsTui() {
-  await runTui("settings");
+  await runTui({ showActions: false });
 }
-async function runTui(initialView, runAction) {
+async function runTui(opts) {
   if (!process.stdout.isTTY) return;
+  const fullscreen = readConfig().config.fullscreen;
   const React = (await import("react")).default;
   const ink = await import("ink");
   const { render } = ink;
   const h = React.createElement;
-  const restore = () => {
-    try {
-      process.stdout.write(LEAVE_ALT);
-    } catch {
-    }
-  };
-  for (; ; ) {
-    const state = { leave: "quit" };
-    const App = buildApp(React, ink, { initialView, onLeave: (a) => {
-      state.leave = a;
-    } });
-    process.stdout.write(ENTER_ALT);
-    process.on("exit", restore);
-    try {
-      const app = render(h(App), { exitOnCtrlC: true });
-      await app.waitUntilExit();
-    } finally {
-      process.removeListener("exit", restore);
-      restore();
-    }
-    if (runAction && (state.leave === "skills" || state.leave === "security")) {
-      await runAction(state.leave);
-      continue;
-    }
-    break;
+  const agents = opts.hub?.agents ?? [];
+  const protections = opts.hub?.protections ?? [];
+  const runAction = opts.hub?.runAction ?? (async () => ({ ok: false, title: "", lines: [] }));
+  if (fullscreen) try {
+    process.stdout.write(CLEAR_SCREEN);
+  } catch {
   }
+  const App = buildApp(React, ink, { showActions: opts.showActions, fullscreen, agents, protections, runAction });
+  const app = render(h(App), { exitOnCtrlC: true });
+  await app.waitUntilExit();
 }
 function buildApp(React, ink, opts) {
   const { useApp, useInput, useStdout } = ink;
@@ -575,18 +561,28 @@ function buildApp(React, ink, opts) {
   const Text = ink.Text;
   const { useState, useEffect } = React;
   const h = React.createElement;
-  const canGoHome = opts.initialView === "home";
+  const fill = opts.fullscreen;
+  const sideItems = [
+    ...CATEGORIES.map((c, i) => ({ kind: "category", catIndex: i, title: c.title })),
+    ...opts.showActions ? ACTION_ITEMS.map((a) => ({ kind: "action", ...a })) : []
+  ];
+  const actionItemKeys = (action) => action === "security" ? opts.protections.map((pr) => pr.value) : opts.agents.map((a) => a.name);
   return function App() {
     const { exit } = useApp();
     const { stdout } = useStdout();
     const [size, setSize] = useState({ columns: stdout.columns || 80, rows: stdout.rows || 24 });
-    const [view, setView] = useState(opts.initialView);
-    const [homeIndex, setHomeIndex] = useState(0);
+    const [mode, setMode] = useState("menu");
     const [scope, setScope] = useState("global");
-    const [focusSettings, setFocusSettings] = useState(false);
-    const [catIndex, setCatIndex] = useState(0);
+    const [sideIndex, setSideIndex] = useState(0);
+    const [focusRight, setFocusRight] = useState(false);
     const [setIndex, setSetIndex] = useState(0);
-    const [, redraw] = useState(0);
+    const [pending, setPending] = useState({});
+    const [confirm4, setConfirm] = useState(null);
+    const [actCursor, setActCursor] = useState(0);
+    const [actChecked, setActChecked] = useState({});
+    const [busyTitle, setBusyTitle] = useState("");
+    const [result, setResult] = useState(null);
+    const [resultScroll, setResultScroll] = useState(0);
     useEffect(() => {
       const onResize = () => setSize({ columns: stdout.columns || 80, rows: stdout.rows || 24 });
       stdout.on("resize", onResize);
@@ -594,45 +590,112 @@ function buildApp(React, ink, opts) {
         stdout.off("resize", onResize);
       };
     }, [stdout]);
-    const back = () => {
-      if (canGoHome) setView("home");
-      else {
-        opts.onLeave("quit");
-        exit();
+    const current = sideItems[sideIndex];
+    const category = current.kind === "category" ? CATEGORIES[current.catIndex] : null;
+    const action = current.kind === "action" ? current.action : null;
+    useEffect(() => {
+      if (!action) return;
+      setActCursor(0);
+      if (action === "security") {
+        setActChecked(Object.fromEntries(opts.protections.map((pr) => [pr.value, true])));
+      } else {
+        const detected = opts.agents.filter((a) => a.installed);
+        const preselect = detected.length ? detected : opts.agents;
+        setActChecked(Object.fromEntries(opts.agents.map((a) => [a.name, preselect.some((d) => d.name === a.name)])));
       }
+    }, [action]);
+    const resultRows = fill ? Math.max(3, size.rows - 7) : result?.lines.length ?? 0;
+    const maxResultScroll = Math.max(0, (result?.lines.length ?? 0) - resultRows);
+    const valueOf = (setting, sc) => {
+      const k = stageKey(setting.key, sc);
+      return k in pending ? pending[k] : setting.read(sc);
+    };
+    const isModified = (setting, sc) => {
+      const k = stageKey(setting.key, sc);
+      return k in pending && pending[k] !== setting.read(sc);
+    };
+    const dirty = Object.entries(pending).some(([k, v]) => {
+      const { key, scope: sc } = parseStageKey(k);
+      return SETTING_BY_KEY.get(key)?.read(sc) !== v;
+    });
+    const persistPending = () => {
+      for (const [k, v] of Object.entries(pending)) {
+        const { key, scope: sc } = parseStageKey(k);
+        const setting = SETTING_BY_KEY.get(key);
+        if (setting && setting.read(sc) !== v) setting.write(v, sc);
+      }
+    };
+    const runChosen = (act) => {
+      const keys = actionItemKeys(act);
+      const chosen = keys.filter((k) => actChecked[k]);
+      const req = act === "security" ? { action: act, protections: chosen } : { action: act, scope, agents: chosen };
+      persistPending();
+      setPending({});
+      setBusyTitle(actionTitle(act));
+      setResult(null);
+      setResultScroll(0);
+      setMode("running");
+      opts.runAction(req).then((res) => {
+        setResult(res);
+        setMode("result");
+      }).catch((err) => {
+        setResult({ ok: false, title: actionTitle(act), lines: [`Error: ${err.message}`] });
+        setMode("result");
+      });
     };
     useInput((input, key) => {
-      if (view === "home") {
-        if (input === "q" || key.escape) {
-          opts.onLeave("quit");
-          exit();
+      if (confirm4) {
+        if (key.escape) {
+          setConfirm(null);
           return;
         }
         if (key.upArrow || input === "k") {
-          setHomeIndex((i) => Math.max(0, i - 1));
+          setConfirm((c) => c && { index: Math.max(0, c.index - 1) });
           return;
         }
         if (key.downArrow || input === "j") {
-          setHomeIndex((i) => Math.min(HOME_ITEMS.length - 1, i + 1));
+          setConfirm((c) => c && { index: Math.min(EXIT_OPTIONS.length - 1, c.index + 1) });
           return;
         }
         if (key.return || input === " ") {
-          const item = HOME_ITEMS[homeIndex];
-          if (item.key === "settings") {
-            setView("settings");
-            setFocusSettings(false);
-          } else if (item.key === "exit") {
-            opts.onLeave("quit");
-            exit();
-          } else {
-            opts.onLeave(item.key);
-            exit();
-          }
+          const index = confirm4.index;
+          setConfirm(null);
+          if (index === 2) return;
+          if (index === 0) persistPending();
+          setPending({});
+          exit();
+        }
+        return;
+      }
+      if (mode === "running") return;
+      if (mode === "result") {
+        if (key.return || key.escape || input === " " || input === "q") {
+          setMode("menu");
+          return;
+        }
+        if (key.upArrow || input === "k") {
+          setResultScroll((s) => Math.max(0, s - 1));
+          return;
+        }
+        if (key.downArrow || input === "j") {
+          setResultScroll((s) => Math.min(maxResultScroll, s + 1));
+          return;
         }
         return;
       }
       if (input === "q" || key.escape) {
-        back();
+        dirty ? setConfirm({ index: 0 }) : exit();
+        return;
+      }
+      if (input === "s") {
+        persistPending();
+        setPending({});
+        return;
+      }
+      if (input === "x") {
+        persistPending();
+        setPending({});
+        exit();
         return;
       }
       if (input === "g") {
@@ -640,147 +703,632 @@ function buildApp(React, ink, opts) {
         return;
       }
       if (key.tab) {
-        setFocusSettings((f) => !f);
+        setFocusRight((f) => !f);
         return;
       }
       if (key.leftArrow || input === "h") {
-        setFocusSettings(false);
+        setFocusRight(false);
         return;
       }
       if (key.rightArrow || input === "l") {
-        setFocusSettings(true);
+        setFocusRight(true);
         return;
       }
       if (key.upArrow || input === "k") {
-        if (focusSettings) setSetIndex((i) => Math.max(0, i - 1));
+        if (focusRight && category) setSetIndex((i) => Math.max(0, i - 1));
+        else if (focusRight && action) setActCursor((i) => Math.max(0, i - 1));
         else {
-          setCatIndex((i) => Math.max(0, i - 1));
+          setSideIndex((i) => Math.max(0, i - 1));
           setSetIndex(0);
+          setFocusRight(false);
         }
         return;
       }
       if (key.downArrow || input === "j") {
-        if (focusSettings) setSetIndex((i) => Math.min(CATEGORIES[catIndex].settings.length - 1, i + 1));
+        if (focusRight && category) setSetIndex((i) => Math.min(category.settings.length - 1, i + 1));
+        else if (focusRight && action) setActCursor((i) => Math.min(actionItemKeys(action).length - 1, i + 1));
         else {
-          setCatIndex((i) => Math.min(CATEGORIES.length - 1, i + 1));
+          setSideIndex((i) => Math.min(sideItems.length - 1, i + 1));
           setSetIndex(0);
+          setFocusRight(false);
         }
         return;
       }
+      if (input === " " && focusRight && action) {
+        const k = actionItemKeys(action)[actCursor];
+        setActChecked((c) => ({ ...c, [k]: !c[k] }));
+        return;
+      }
       if (key.return || input === " ") {
-        if (!focusSettings) {
-          setFocusSettings(true);
+        if (!focusRight) {
+          setFocusRight(true);
+          return;
+        }
+        if (action) {
+          runChosen(action);
           return;
         }
-        const setting = CATEGORIES[catIndex].settings[setIndex];
-        setting.write(!setting.read(scope), scope);
-        redraw((n) => n + 1);
+        const setting = category.settings[setIndex];
+        setPending((pr) => ({ ...pr, [stageKey(setting.key, scope)]: !valueOf(setting, scope) }));
       }
     });
-    const titleBar = (right2) => h(
-      Box,
-      { width: size.columns, paddingX: 1, justifyContent: "space-between" },
-      h(Text, { bold: true, color: "cyan" }, "enigma"),
-      right2
-    );
-    const body = view === "home" ? renderHome(h, Box, Text, homeIndex) : renderSettings(h, Box, Text, { size, scope, focusSettings, catIndex, setIndex });
-    const footer = h(Box, { width: size.columns, paddingX: 1 }, h(
-      Text,
-      { dimColor: true },
-      view === "home" ? "up/down move    enter select    q quit" : `up/down move    tab/left/right switch    enter toggle    g scope    ${canGoHome ? "esc back" : "q quit"}`
-    ));
-    const right = view === "home" ? h(Text, { dimColor: true }, "main menu") : h(
+    const headerRight = confirm4 ? h(Text, { color: "yellow" }, "unsaved changes") : mode === "running" ? h(Text, { dimColor: true }, "working") : mode === "result" ? h(Text, { dimColor: true }, "result") : h(
       Box,
       {},
       h(Text, { dimColor: true }, "scope "),
       h(Text, { bold: true, color: scope === "global" ? "green" : "yellow" }, scope),
-      h(Text, { dimColor: true }, "   (g to change)")
+      h(Text, { dimColor: true }, "  (g)"),
+      dirty ? h(Text, { color: "yellow" }, "   * unsaved") : null
     );
+    const titleBar = h(
+      Box,
+      { width: size.columns, paddingX: 1, justifyContent: "space-between" },
+      h(Text, { bold: true, color: "cyan" }, "enigma"),
+      headerRight
+    );
+    let content;
+    if (confirm4) {
+      content = renderConfirm(h, Box, Text, confirm4.index, fill);
+    } else if (mode === "running") {
+      content = renderRunning(h, Box, Text, busyTitle, fill);
+    } else if (mode === "result" && result) {
+      content = renderResult(h, Box, Text, { res: result, scroll: Math.min(resultScroll, maxResultScroll), maxRows: resultRows, fill });
+    } else {
+      const sidebarWidth = Math.min(28, Math.max(20, Math.floor(size.columns * 0.3)));
+      const panel = category ? renderCategoryPanel(h, Box, Text, { category, scope, focusRight, setIndex, valueOf, isModified, fill }) : renderChecklist(h, Box, Text, {
+        title: actionTitle(action),
+        blurb: action === "skills" ? `Scope ${scope} (g to change). Choose agents, then enter to install.` : "Choose what the commit guard enforces, then enter to apply.",
+        items: action === "security" ? opts.protections.map((pr) => ({ key: pr.value, label: pr.label, hint: pr.hint })) : opts.agents.map((a) => ({ key: a.name, label: a.label, hint: a.installed ? "detected" : "not detected" })),
+        cursor: actCursor,
+        checked: actChecked,
+        focused: focusRight,
+        fill
+      });
+      content = h(Box, fill ? { flexGrow: 1 } : {}, renderSidebar(h, Box, Text, sideItems, sideIndex, focusRight, sidebarWidth), panel);
+    }
+    const menuFooter = focusRight && action ? action === "skills" ? "up/down move    space toggle    g scope    enter install    tab back" : "up/down move    space toggle    enter apply    tab back" : focusRight && category ? "up/down move    enter toggle    g scope    tab back" : `up/down move    tab switch    enter ${action ? "edit" : "focus"}    s save    x save & exit    q quit`;
+    const footerText = confirm4 ? "up/down move    enter select    esc cancel" : mode === "running" ? "working..." : mode === "result" ? `${maxResultScroll > 0 ? "up/down scroll    " : ""}enter / esc    back to menu` : menuFooter;
+    const footer = h(Box, { width: size.columns, paddingX: 1 }, h(Text, { dimColor: true }, footerText));
     return h(
       Box,
-      { width: size.columns, height: size.rows, flexDirection: "column" },
-      titleBar(right),
-      h(Box, { flexGrow: 1 }, body),
+      { width: size.columns, ...fill ? { height: size.rows } : {}, flexDirection: "column" },
+      titleBar,
+      content,
       footer
     );
   };
 }
-function renderHome(h, Box, Text, homeIndex) {
-  const items = HOME_ITEMS.map((item, i) => h(
+function renderSidebar(h, Box, Text, items, index, focusRight, width) {
+  return h(Box, {
+    flexDirection: "column",
+    borderStyle: "round",
+    borderColor: focusRight ? "gray" : "cyan",
+    paddingX: 1,
+    width,
+    marginRight: 1
+  }, [
+    h(Text, { key: "__t", bold: true, dimColor: true }, "MENU"),
+    ...items.map((it, i) => h(Text, {
+      key: String(i),
+      inverse: !focusRight && i === index,
+      color: i === index ? "cyan" : void 0
+    }, ` ${it.title} `))
+  ]);
+}
+function renderConfirm(h, Box, Text, index, fill) {
+  return h(
     Box,
-    { key: item.key, flexDirection: "column" },
-    h(Text, { inverse: i === homeIndex, bold: i === homeIndex }, ` ${item.label} `),
-    i === homeIndex && item.hint ? h(Text, { key: "h", dimColor: true }, `   ${item.hint}`) : null
-  ));
+    { justifyContent: "center", ...fill ? { flexGrow: 1, alignItems: "center" } : {} },
+    h(Box, {
+      flexDirection: "column",
+      borderStyle: "round",
+      borderColor: "yellow",
+      paddingX: 2,
+      paddingY: 1
+    }, [
+      h(Text, { key: "__t", bold: true, color: "yellow" }, "You have unsaved changes"),
+      h(
+        Box,
+        { key: "__o", marginTop: 1, flexDirection: "column" },
+        EXIT_OPTIONS.map((o, i) => h(Text, { key: o, inverse: i === index, bold: i === index }, ` ${o} `))
+      )
+    ])
+  );
+}
+function renderRunning(h, Box, Text, title, fill) {
   return h(Box, {
     flexDirection: "column",
     borderStyle: "round",
     borderColor: "cyan",
     paddingX: 1,
-    flexGrow: 1
+    ...fill ? { flexGrow: 1 } : {}
   }, [
-    h(Text, { key: "__t", bold: true, color: "cyan" }, "What would you like to do?"),
-    h(Box, { key: "__sp", marginTop: 1, flexDirection: "column" }, items)
+    h(Text, { key: "__t", bold: true, color: "cyan" }, title || "Working"),
+    h(Text, { key: "__w", marginTop: 1, dimColor: true }, "Working..."),
+    ...fill ? [h(Box, { key: "__grow", flexGrow: 1 })] : []
   ]);
 }
-function renderSettings(h, Box, Text, s) {
-  const category = CATEGORIES[s.catIndex];
-  const settings = category.settings;
-  const focused = settings[s.setIndex];
-  const sidebarWidth = Math.min(28, Math.max(18, Math.floor(s.size.columns * 0.3)));
-  const sidebar = h(Box, {
+function renderResult(h, Box, Text, s) {
+  const { res, maxRows } = s;
+  const windowed = maxRows > 0 && res.lines.length > maxRows;
+  const start = windowed ? Math.max(0, Math.min(s.scroll, res.lines.length - maxRows)) : 0;
+  const slice = windowed ? res.lines.slice(start, start + maxRows) : res.lines;
+  const rows = slice.length ? slice.map((line, i) => h(Text, { key: String(start + i), wrap: "truncate-end" }, ` ${line} `)) : [h(Text, { key: "__none", dimColor: true }, " (no output) ")];
+  const above = windowed && start > 0;
+  const below = windowed && start + maxRows < res.lines.length;
+  return h(Box, {
     flexDirection: "column",
     borderStyle: "round",
-    borderColor: s.focusSettings ? "gray" : "cyan",
+    borderColor: res.ok ? "green" : "red",
     paddingX: 1,
-    width: sidebarWidth,
-    marginRight: 1
+    ...s.fill ? { flexGrow: 1 } : {}
   }, [
-    h(Text, { key: "__t", bold: true, dimColor: true }, "CATEGORIES"),
-    ...CATEGORIES.map((c, i) => h(Text, {
-      key: c.title,
-      inverse: !s.focusSettings && i === s.catIndex,
-      color: i === s.catIndex ? "cyan" : void 0
-    }, ` ${c.title} `))
+    h(Text, { key: "__t", bold: true, color: res.ok ? "green" : "red" }, res.title),
+    h(Text, { key: "__up", dimColor: true }, above ? ` ... ${start} more above ` : " "),
+    h(Box, { key: "__rows", flexDirection: "column" }, rows),
+    h(Text, { key: "__dn", dimColor: true }, below ? ` ... ${res.lines.length - start - maxRows} more below ` : " "),
+    ...s.fill ? [h(Box, { key: "__grow", flexGrow: 1 })] : []
   ]);
-  const rows = settings.map((setting, i) => {
-    const on = setting.read(s.scope);
-    const selected = s.focusSettings && i === s.setIndex;
+}
+function renderChecklist(h, Box, Text, s) {
+  const rows = s.items.map((it, i) => {
+    const on = !!s.checked[it.key];
+    const selected = s.focused && i === s.cursor;
+    return h(
+      Box,
+      { key: it.key, justifyContent: "space-between" },
+      h(Text, { inverse: selected, bold: selected }, ` ${on ? "[x]" : "[ ]"} ${it.label} `),
+      h(Text, { dimColor: true }, `${it.hint}  `)
+    );
+  });
+  return h(Box, {
+    flexDirection: "column",
+    borderStyle: "round",
+    borderColor: s.focused ? "cyan" : "gray",
+    paddingX: 1,
+    flexGrow: 1
+  }, [
+    h(Text, { key: "__t", bold: true, color: "cyan" }, s.title),
+    h(Text, { key: "__bl", dimColor: true }, s.blurb),
+    h(Box, { key: "__rows", marginTop: 1, flexDirection: "column" }, rows),
+    ...s.fill ? [h(Box, { key: "__grow", flexGrow: 1 })] : []
+  ]);
+}
+function renderCategoryPanel(h, Box, Text, s) {
+  const focused = s.category.settings[s.setIndex];
+  const rows = s.category.settings.map((setting, i) => {
+    const on = s.valueOf(setting, s.scope);
+    const modified = s.isModified(setting, s.scope);
+    const selected = s.focusRight && i === s.setIndex;
     return h(
       Box,
       { key: setting.key, justifyContent: "space-between" },
       h(Text, { inverse: selected, bold: selected }, ` ${setting.label}${setting.globalOnly ? "  (global)" : ""} `),
-      h(Text, { bold: true, color: on ? "green" : "gray" }, `${valueLabel(on)} `)
+      h(Text, { bold: true, color: modified ? "yellow" : on ? "green" : "gray" }, `${valueLabel(on)}${modified ? " *" : ""} `)
     );
   });
-  const panel = h(Box, {
+  return h(Box, {
     flexDirection: "column",
     borderStyle: "round",
-    borderColor: s.focusSettings ? "cyan" : "gray",
+    borderColor: s.focusRight ? "cyan" : "gray",
     paddingX: 1,
     flexGrow: 1
   }, [
-    h(Text, { key: "__b", bold: true, color: "cyan" }, category.title),
-    h(Text, { key: "__bl", dimColor: true }, category.blurb),
+    h(Text, { key: "__b", bold: true, color: "cyan" }, s.category.title),
+    h(Text, { key: "__bl", dimColor: true }, s.category.blurb),
     h(Box, { key: "__rows", marginTop: 1, flexDirection: "column" }, rows),
-    h(Box, { key: "__grow", flexGrow: 1 }),
-    h(Text, { key: "__hint", dimColor: true, wrap: "truncate-end" }, focused.hint)
+    ...s.fill ? [h(Box, { key: "__grow", flexGrow: 1 })] : [],
+    h(Text, { key: "__hint", marginTop: 1, dimColor: true, wrap: "truncate-end" }, focused.hint)
   ]);
-  return h(Box, { flexGrow: 1 }, sidebar, panel);
 }
-var ENTER_ALT, LEAVE_ALT, HOME_ITEMS;
+var CLEAR_SCREEN, SETTING_BY_KEY, stageKey, parseStageKey, ACTION_ITEMS, actionTitle, EXIT_OPTIONS;
 var init_settings = __esm({
   "src/tui/settings.ts"() {
+    "use strict";
+    init_config();
+    init_settings_registry();
+    CLEAR_SCREEN = "\x1B[2J\x1B[H";
+    SETTING_BY_KEY = new Map(ALL_SETTINGS.map((s) => [s.key, s]));
+    stageKey = (key, scope) => `${scope}/${key}`;
+    parseStageKey = (composite) => {
+      const i = composite.indexOf("/");
+      return { scope: composite.slice(0, i), key: composite.slice(i + 1) };
+    };
+    ACTION_ITEMS = [
+      { action: "skills", title: "Install agent skills", blurb: "Claude Code, Codex, OpenCode" },
+      { action: "security", title: "Git security hooks", blurb: "block secrets, .env, node_modules on commit" }
+    ];
+    actionTitle = (action) => ACTION_ITEMS.find((a) => a.action === action).title;
+    EXIT_OPTIONS = ["Save & exit", "Exit without saving", "Cancel"];
+  }
+});
+
+// src/tui/opentui.ts
+var opentui_exports = {};
+__export(opentui_exports, {
+  runHomeTui: () => runHomeTui2
+});
+async function runHomeTui2(hub) {
+  if (!process.stdout.isTTY) return;
+  const React = (await import("react")).default;
+  const { createCliRenderer, TextAttributes } = await import("@opentui/core");
+  const { createRoot, useKeyboard, useTerminalDimensions } = await import("@opentui/react");
+  const h = React.createElement;
+  const { useState, useEffect } = React;
+  const box = "box";
+  const text = "text";
+  const BOLD = TextAttributes.BOLD;
+  const DIM = TextAttributes.DIM;
+  const agents = hub.agents;
+  const protections = hub.protections;
+  const txt = (content, props = {}) => h(text, props, content);
+  const selStyle = (selected, normal = {}) => selected ? { bg: SEL_BG, fg: SEL_FG, attributes: BOLD } : normal;
+  const panelBox = (borderColor, children, extra = {}) => h(box, { border: true, borderStyle: "rounded", borderColor, flexDirection: "column", paddingLeft: 1, paddingRight: 1, flexGrow: 1, ...extra }, ...children);
+  const renderSidebar2 = (items, index, focusRight, width) => h(
+    box,
+    { border: true, borderStyle: "rounded", borderColor: focusRight ? COL.gray : COL.cyan, flexDirection: "column", paddingLeft: 1, paddingRight: 1, width, marginRight: 1 },
+    txt("MENU", { fg: COL.gray, attributes: BOLD }),
+    ...items.map((it, i) => txt(
+      ` ${it.title} `,
+      !focusRight && i === index ? { bg: SEL_BG, fg: SEL_FG, attributes: BOLD } : { fg: i === index ? COL.cyan : void 0 }
+    ))
+  );
+  const renderChecklist2 = (s) => panelBox(s.focused ? COL.cyan : COL.gray, [
+    txt(s.title, { fg: COL.cyan, attributes: BOLD }),
+    txt(s.blurb, { fg: COL.gray }),
+    h(
+      box,
+      { flexDirection: "column", marginTop: 1 },
+      ...s.items.map((it, i) => {
+        const on = !!s.checked[it.key];
+        const selected = s.focused && i === s.cursor;
+        return h(
+          box,
+          { flexDirection: "row", justifyContent: "space-between" },
+          txt(` ${on ? "[x]" : "[ ]"} ${it.label} `, selStyle(selected)),
+          txt(`${it.hint}  `, { fg: COL.gray })
+        );
+      })
+    )
+  ]);
+  const renderCategoryPanel2 = (s) => {
+    const focusedHint = s.category.settings[s.setIndex].hint;
+    return panelBox(s.focusRight ? COL.cyan : COL.gray, [
+      txt(s.category.title, { fg: COL.cyan, attributes: BOLD }),
+      txt(s.category.blurb, { fg: COL.gray }),
+      h(
+        box,
+        { flexDirection: "column", marginTop: 1 },
+        ...s.category.settings.map((setting, i) => {
+          const on = s.valueOf(setting, s.scope);
+          const modified = s.isModified(setting, s.scope);
+          const selected = s.focusRight && i === s.setIndex;
+          return h(
+            box,
+            { flexDirection: "row", justifyContent: "space-between" },
+            txt(` ${setting.label}${setting.globalOnly ? "  (global)" : ""} `, selStyle(selected)),
+            txt(`${valueLabel(on)}${modified ? " *" : ""} `, { attributes: BOLD, fg: modified ? COL.yellow : on ? COL.green : COL.gray })
+          );
+        })
+      ),
+      h(box, { flexGrow: 1 }),
+      txt(focusedHint, { fg: COL.gray, marginTop: 1, truncate: true })
+    ]);
+  };
+  const renderConfirm2 = (index) => h(
+    box,
+    { flexGrow: 1, justifyContent: "center", alignItems: "center" },
+    h(
+      box,
+      { border: true, borderStyle: "rounded", borderColor: COL.yellow, flexDirection: "column", paddingLeft: 2, paddingRight: 2, paddingTop: 1, paddingBottom: 1 },
+      txt("You have unsaved changes", { fg: COL.yellow, attributes: BOLD }),
+      h(
+        box,
+        { flexDirection: "column", marginTop: 1 },
+        ...EXIT_OPTIONS2.map((o, i) => txt(` ${o} `, selStyle(i === index)))
+      )
+    )
+  );
+  const renderRunning2 = (title) => panelBox(COL.cyan, [
+    txt(title || "Working", { fg: COL.cyan, attributes: BOLD }),
+    txt("Working...", { fg: COL.gray, marginTop: 1 }),
+    h(box, { flexGrow: 1 })
+  ]);
+  const renderResult2 = (res, scroll, maxRows) => {
+    const windowed = maxRows > 0 && res.lines.length > maxRows;
+    const start = windowed ? Math.max(0, Math.min(scroll, res.lines.length - maxRows)) : 0;
+    const slice = windowed ? res.lines.slice(start, start + maxRows) : res.lines;
+    const above = windowed && start > 0;
+    const below = windowed && start + maxRows < res.lines.length;
+    const rows = slice.length ? slice.map((line, i) => txt(` ${line} `, { key: String(start + i), truncate: true })) : [txt(" (no output) ", { fg: COL.gray })];
+    return panelBox(res.ok ? COL.green : COL.red, [
+      txt(res.title, { fg: res.ok ? COL.green : COL.red, attributes: BOLD }),
+      txt(above ? ` ... ${start} more above ` : " ", { fg: COL.gray }),
+      h(box, { flexDirection: "column" }, ...rows),
+      txt(below ? ` ... ${res.lines.length - start - maxRows} more below ` : " ", { fg: COL.gray }),
+      h(box, { flexGrow: 1 })
+    ]);
+  };
+  const sideItems = [
+    ...CATEGORIES.map((c, i) => ({ kind: "category", catIndex: i, title: c.title })),
+    ...ACTION_ITEMS2.map((a) => ({ kind: "action", ...a }))
+  ];
+  const actionItemKeys = (action) => action === "security" ? protections.map((p7) => p7.value) : agents.map((a) => a.name);
+  function App({ onExit }) {
+    const dims = useTerminalDimensions();
+    const size = { columns: dims.width || 80, rows: dims.height || 24 };
+    const [mode, setMode] = useState("menu");
+    const [scope, setScope] = useState("global");
+    const [sideIndex, setSideIndex] = useState(0);
+    const [focusRight, setFocusRight] = useState(false);
+    const [setIndex, setSetIndex] = useState(0);
+    const [pending, setPending] = useState({});
+    const [confirm4, setConfirm] = useState(null);
+    const [actCursor, setActCursor] = useState(0);
+    const [actChecked, setActChecked] = useState({});
+    const [busyTitle, setBusyTitle] = useState("");
+    const [result, setResult] = useState(null);
+    const [resultScroll, setResultScroll] = useState(0);
+    const current = sideItems[sideIndex];
+    const category = current.kind === "category" ? CATEGORIES[current.catIndex] : null;
+    const action = current.kind === "action" ? current.action : null;
+    useEffect(() => {
+      if (!action) return;
+      setActCursor(0);
+      if (action === "security") {
+        setActChecked(Object.fromEntries(protections.map((p7) => [p7.value, true])));
+      } else {
+        const detected = agents.filter((a) => a.installed);
+        const preselect = detected.length ? detected : agents;
+        setActChecked(Object.fromEntries(agents.map((a) => [a.name, preselect.some((d) => d.name === a.name)])));
+      }
+    }, [action]);
+    const resultRows = Math.max(3, size.rows - 7);
+    const maxResultScroll = Math.max(0, (result?.lines.length ?? 0) - resultRows);
+    const valueOf = (setting, sc) => {
+      const k = stageKey2(setting.key, sc);
+      return k in pending ? pending[k] : setting.read(sc);
+    };
+    const isModified = (setting, sc) => {
+      const k = stageKey2(setting.key, sc);
+      return k in pending && pending[k] !== setting.read(sc);
+    };
+    const dirty = Object.entries(pending).some(([k, v]) => {
+      const { key, scope: sc } = parseStageKey2(k);
+      return SETTING_BY_KEY2.get(key)?.read(sc) !== v;
+    });
+    const persistPending = () => {
+      for (const [k, v] of Object.entries(pending)) {
+        const { key, scope: sc } = parseStageKey2(k);
+        const setting = SETTING_BY_KEY2.get(key);
+        if (setting && setting.read(sc) !== v) setting.write(v, sc);
+      }
+    };
+    const runChosen = (act) => {
+      const chosen = actionItemKeys(act).filter((k) => actChecked[k]);
+      const req = act === "security" ? { action: act, protections: chosen } : { action: act, scope, agents: chosen };
+      persistPending();
+      setPending({});
+      setBusyTitle(actionTitle2(act));
+      setResult(null);
+      setResultScroll(0);
+      setMode("running");
+      hub.runAction(req).then((res) => {
+        setResult(res);
+        setMode("result");
+      }).catch((err) => {
+        setResult({ ok: false, title: actionTitle2(act), lines: [`Error: ${err.message}`] });
+        setMode("result");
+      });
+    };
+    useKeyboard((key) => {
+      const name = key.name;
+      const up = name === "up", down = name === "down", left = name === "left", right = name === "right";
+      const enter = name === "return", esc = name === "escape", tab = name === "tab", space = name === "space";
+      const ch = name && name.length === 1 ? name : "";
+      if (confirm4) {
+        if (esc) {
+          setConfirm(null);
+          return;
+        }
+        if (up || ch === "k") {
+          setConfirm((c) => c && { index: Math.max(0, c.index - 1) });
+          return;
+        }
+        if (down || ch === "j") {
+          setConfirm((c) => c && { index: Math.min(EXIT_OPTIONS2.length - 1, c.index + 1) });
+          return;
+        }
+        if (enter || space) {
+          const index = confirm4.index;
+          setConfirm(null);
+          if (index === 2) return;
+          if (index === 0) persistPending();
+          setPending({});
+          onExit();
+        }
+        return;
+      }
+      if (mode === "running") return;
+      if (mode === "result") {
+        if (enter || esc || space || ch === "q") {
+          setMode("menu");
+          return;
+        }
+        if (up || ch === "k") {
+          setResultScroll((s) => Math.max(0, s - 1));
+          return;
+        }
+        if (down || ch === "j") {
+          setResultScroll((s) => Math.min(maxResultScroll, s + 1));
+          return;
+        }
+        return;
+      }
+      if (ch === "q" || esc) {
+        dirty ? setConfirm({ index: 0 }) : onExit();
+        return;
+      }
+      if (ch === "s") {
+        persistPending();
+        setPending({});
+        return;
+      }
+      if (ch === "x") {
+        persistPending();
+        setPending({});
+        onExit();
+        return;
+      }
+      if (ch === "g") {
+        setScope((s) => s === "global" ? "local" : "global");
+        return;
+      }
+      if (tab) {
+        setFocusRight((f) => !f);
+        return;
+      }
+      if (left || ch === "h") {
+        setFocusRight(false);
+        return;
+      }
+      if (right || ch === "l") {
+        setFocusRight(true);
+        return;
+      }
+      if (up || ch === "k") {
+        if (focusRight && category) setSetIndex((i) => Math.max(0, i - 1));
+        else if (focusRight && action) setActCursor((i) => Math.max(0, i - 1));
+        else {
+          setSideIndex((i) => Math.max(0, i - 1));
+          setSetIndex(0);
+          setFocusRight(false);
+        }
+        return;
+      }
+      if (down || ch === "j") {
+        if (focusRight && category) setSetIndex((i) => Math.min(category.settings.length - 1, i + 1));
+        else if (focusRight && action) setActCursor((i) => Math.min(actionItemKeys(action).length - 1, i + 1));
+        else {
+          setSideIndex((i) => Math.min(sideItems.length - 1, i + 1));
+          setSetIndex(0);
+          setFocusRight(false);
+        }
+        return;
+      }
+      if (space && focusRight && action) {
+        const k = actionItemKeys(action)[actCursor];
+        setActChecked((c) => ({ ...c, [k]: !c[k] }));
+        return;
+      }
+      if (enter || space) {
+        if (!focusRight) {
+          setFocusRight(true);
+          return;
+        }
+        if (action) {
+          runChosen(action);
+          return;
+        }
+        const setting = category.settings[setIndex];
+        setPending((p7) => ({ ...p7, [stageKey2(setting.key, scope)]: !valueOf(setting, scope) }));
+      }
+    });
+    const headerRight = confirm4 ? txt("unsaved changes", { fg: COL.yellow }) : mode === "running" ? txt("working", { fg: COL.gray }) : mode === "result" ? txt("result", { fg: COL.gray }) : h(
+      box,
+      { flexDirection: "row" },
+      txt("scope ", { fg: COL.gray }),
+      txt(scope, { fg: scope === "global" ? COL.green : COL.yellow, attributes: BOLD }),
+      txt("  (g)", { fg: COL.gray }),
+      dirty ? txt("   * unsaved", { fg: COL.yellow }) : null
+    );
+    const titleBar = h(
+      box,
+      { width: size.columns, flexDirection: "row", paddingLeft: 1, paddingRight: 1, justifyContent: "space-between" },
+      txt("enigma", { fg: COL.cyan, attributes: BOLD }),
+      headerRight
+    );
+    let content;
+    if (confirm4) {
+      content = renderConfirm2(confirm4.index);
+    } else if (mode === "running") {
+      content = renderRunning2(busyTitle);
+    } else if (mode === "result" && result) {
+      content = renderResult2(result, Math.min(resultScroll, maxResultScroll), resultRows);
+    } else {
+      const sidebarWidth = Math.min(28, Math.max(20, Math.floor(size.columns * 0.3)));
+      const panel = category ? renderCategoryPanel2({ category, scope, focusRight, setIndex, valueOf, isModified }) : renderChecklist2({
+        title: actionTitle2(action),
+        blurb: action === "skills" ? `Scope ${scope} (g to change). Choose agents, then enter to install.` : "Choose what the commit guard enforces, then enter to apply.",
+        items: action === "security" ? protections.map((p7) => ({ key: p7.value, label: p7.label, hint: p7.hint })) : agents.map((a) => ({ key: a.name, label: a.label, hint: a.installed ? "detected" : "not detected" })),
+        cursor: actCursor,
+        checked: actChecked,
+        focused: focusRight
+      });
+      content = h(box, { flexGrow: 1, flexDirection: "row" }, renderSidebar2(sideItems, sideIndex, focusRight, sidebarWidth), panel);
+    }
+    const footerLine = (s) => h(box, { width: size.columns, paddingLeft: 1, paddingRight: 1 }, txt(s, { fg: COL.gray, attributes: DIM }));
+    const menuNav = focusRight && action ? action === "skills" ? "up/down move   space toggle   g scope   enter install   tab back" : "up/down move   space toggle   enter apply   tab back" : focusRight && category ? "up/down move   enter toggle   g scope   tab back" : `up/down move   tab switch   enter ${action ? "edit" : "focus"}`;
+    let footer;
+    if (confirm4) {
+      footer = footerLine("up/down move   enter select   esc cancel");
+    } else if (mode === "running") {
+      footer = footerLine("working...");
+    } else if (mode === "result") {
+      footer = footerLine(`${maxResultScroll > 0 ? "up/down scroll   " : ""}enter / esc   back to menu`);
+    } else {
+      footer = h(
+        box,
+        { width: size.columns, flexDirection: "row", justifyContent: "space-between", paddingLeft: 1, paddingRight: 1 },
+        txt(menuNav, { fg: COL.gray, attributes: DIM }),
+        txt("s save   x save & exit   q quit", { fg: COL.gray, attributes: DIM })
+      );
+    }
+    return h(box, { width: size.columns, height: size.rows, flexDirection: "column" }, titleBar, content, footer);
+  }
+  const renderer = await createCliRenderer({ exitOnCtrlC: true });
+  await new Promise((resolve3) => {
+    const root = createRoot(renderer);
+    const onExit = () => {
+      try {
+        root.unmount();
+      } catch {
+      }
+      try {
+        renderer.destroy();
+      } catch {
+      }
+      resolve3();
+    };
+    root.render(h(App, { onExit }));
+  });
+}
+var COL, SEL_BG, SEL_FG, SETTING_BY_KEY2, stageKey2, parseStageKey2, ACTION_ITEMS2, actionTitle2, EXIT_OPTIONS2;
+var init_opentui = __esm({
+  "src/tui/opentui.ts"() {
     "use strict";
     init_settings_registry();
-    ENTER_ALT = "\x1B[?1049h\x1B[?25l";
-    LEAVE_ALT = "\x1B[?25h\x1B[?1049l";
-    HOME_ITEMS = [
-      { key: "settings", label: "Configure settings", hint: "emoji, attribution, permission bypass, ..." },
-      { key: "skills", label: "Install agent skills", hint: "Claude Code, Codex, opencode" },
-      { key: "security", label: "Git security hooks", hint: "block secrets, .env, node_modules on commit" },
-      { key: "exit", label: "Exit", hint: "leave enigma" }
+    COL = {
+      cyan: "#22d3ee",
+      green: "#22c55e",
+      yellow: "#eab308",
+      red: "#ef4444",
+      gray: "#6b7280"
+    };
+    SEL_BG = "#155e75";
+    SEL_FG = "#ffffff";
+    SETTING_BY_KEY2 = new Map(ALL_SETTINGS.map((s) => [s.key, s]));
+    stageKey2 = (key, scope) => `${scope}/${key}`;
+    parseStageKey2 = (composite) => {
+      const i = composite.indexOf("/");
+      return { scope: composite.slice(0, i), key: composite.slice(i + 1) };
+    };
+    ACTION_ITEMS2 = [
+      { action: "skills", title: "Install agent skills", blurb: "Claude Code, Codex, OpenCode" },
+      { action: "security", title: "Git security hooks", blurb: "block secrets, .env, node_modules on commit" }
     ];
+    actionTitle2 = (action) => ACTION_ITEMS2.find((a) => a.action === action).title;
+    EXIT_OPTIONS2 = ["Save & exit", "Exit without saving", "Cancel"];
   }
 });
 
@@ -788,7 +1336,52 @@ var init_settings = __esm({
 init_util();
 import { dirname as dirname4, join as join10 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
-import * as p5 from "@clack/prompts";
+import * as p6 from "@clack/prompts";
+
+// src/runtime.ts
+var isBun = () => typeof process.versions.bun === "string";
+
+// src/reporter.ts
+import * as p from "@clack/prompts";
+function clackReporter() {
+  return {
+    info: (m) => p.log.info(m),
+    success: (m) => p.log.success(m),
+    warn: (m) => p.log.warn(m),
+    error: (m) => p.log.error(m),
+    note: (body, title) => p.note(body, title),
+    spinner: () => {
+      const s = p.spinner();
+      return { start: (m) => s.start(m), stop: (m) => s.stop(m) };
+    },
+    fatal: (m) => {
+      p.cancel(m);
+      process.exit(1);
+    }
+  };
+}
+function collectReporter() {
+  const lines = [];
+  const push = (prefix, message) => {
+    for (const line of message.split("\n")) lines.push(prefix ? `${prefix} ${line}` : line);
+  };
+  return {
+    lines,
+    info: (m) => push("", m),
+    success: (m) => push("", m),
+    warn: (m) => push("!", m),
+    error: (m) => push("x", m),
+    note: (body, title) => {
+      if (title) lines.push(title);
+      push("  ", body);
+    },
+    spinner: () => ({ start: () => {
+    }, stop: (m) => push("", m) }),
+    fatal: (m) => {
+      throw new Error(m);
+    }
+  };
+}
 
 // src/skills.ts
 init_util();
@@ -797,7 +1390,7 @@ import { existsSync as existsSync5, readdirSync, readFileSync as readFileSync3,
 import { dirname as dirname2, join as join6, resolve as resolve2, relative as relative2, sep as sep2 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { createHash } from "crypto";
-import * as p3 from "@clack/prompts";
+import * as p4 from "@clack/prompts";
 
 // src/security.ts
 init_util();
@@ -805,7 +1398,7 @@ import { existsSync as existsSync3, mkdirSync, cpSync, writeFileSync, chmodSync
 import { dirname, join as join3, resolve, relative } from "path";
 import { fileURLToPath } from "url";
 import { execFileSync as execFileSync2 } from "child_process";
-import * as p from "@clack/prompts";
+import * as p2 from "@clack/prompts";
 var __dirname = dirname(fileURLToPath(import.meta.url));
 function findGuardSrc() {
   const candidates = [
@@ -838,41 +1431,41 @@ function currentHooksPath(root) {
     return "";
   }
 }
-async function setupGitHooks(opts, interactive) {
+async function setupGitHooks(opts, interactive, reporter = clackReporter()) {
   const root = findGitRoot(process.cwd());
   if (!root) {
-    p.log.error("Not inside a git repository (no .git found). Run this from your project root.");
+    reporter.error("Not inside a git repository (no .git found). Run this from your project root.");
     return false;
   }
   const guardSrc = findGuardSrc();
   if (!guardSrc) {
-    p.log.error("Cannot find the built guard (dist/guard.js). Run 'npm run build' first.");
+    reporter.error("Cannot find the built guard (dist/guard.js). Run 'npm run build' first.");
     return false;
   }
   const current = currentHooksPath(root);
   if (current && current !== ".githooks" && !opts.force) {
-    p.log.warn(`core.hooksPath is already set to '${current}'.`);
+    reporter.warn(`core.hooksPath is already set to '${current}'.`);
     if (interactive) {
-      const ok = await p.confirm({ message: `Override existing core.hooksPath '${current}' with '.githooks'?` });
-      if (p.isCancel(ok) || !ok) {
-        p.log.info("Left git hooks unchanged.");
+      const ok = await p2.confirm({ message: `Override existing core.hooksPath '${current}' with '.githooks'?` });
+      if (p2.isCancel(ok) || !ok) {
+        reporter.info("Left git hooks unchanged.");
         return false;
       }
     } else {
-      p.log.info("Re-run with --force to override.");
+      reporter.info("Re-run with --force to override.");
       return false;
     }
   }
   let enabled = opts.protections;
   if (!enabled && interactive) {
-    const r = await p.multiselect({
+    const r = await p2.multiselect({
       message: "Which protections should the commit guard enforce?",
       options: GUARD_PROTECTIONS,
       initialValues: GUARD_PROTECTIONS.map((o) => o.value),
       required: true
     });
-    if (p.isCancel(r)) {
-      p.log.info("Left git hooks unchanged.");
+    if (p2.isCancel(r)) {
+      reporter.info("Left git hooks unchanged.");
       return false;
     }
     enabled = r;
@@ -903,14 +1496,14 @@ async function setupGitHooks(opts, interactive) {
   try {
     execFileSync2("git", ["-C", root, "config", "core.hooksPath", ".githooks"]);
   } catch (err) {
-    p.log.error(`Failed to set core.hooksPath: ${err.message}`);
+    reporter.error(`Failed to set core.hooksPath: ${err.message}`);
     return false;
   }
   const on = Object.entries(config).filter(([, v]) => v).map(([k]) => k);
-  p.log.success(`Git security hooks installed in ${relative(process.cwd(), hooksDir) || ".githooks"} (core.hooksPath set).`);
-  p.log.info(`Enforcing: ${on.join(", ") || "nothing"}. Commit .githooks/ so your team inherits it.`);
+  reporter.success(`Git security hooks installed in ${relative(process.cwd(), hooksDir) || ".githooks"} (core.hooksPath set).`);
+  reporter.info(`Enforcing: ${on.join(", ") || "nothing"}. Commit .githooks/ so your team inherits it.`);
   if (isOnPath("gh")) {
-    p.log.info("GitHub CLI (gh) detected: these hooks also run for commits made via gh, since gh uses git underneath.");
+    reporter.info("GitHub CLI (gh) detected: these hooks also run for commits made via gh, since gh uses git underneath.");
   }
   return true;
 }
@@ -919,8 +1512,8 @@ async function maybeOfferGitHooks(interactive, opts) {
   const root = findGitRoot(process.cwd());
   if (!root) return;
   if (currentHooksPath(root) === ".githooks") return;
-  const ok = await p.confirm({ message: "Set up git security hooks here too (block secrets, .env, node_modules)?" });
-  if (!p.isCancel(ok) && ok) await setupGitHooks({ ...opts, protections: void 0 }, interactive);
+  const ok = await p2.confirm({ message: "Set up git security hooks here too (block secrets, .env, node_modules)?" });
+  if (!p2.isCancel(ok) && ok) await setupGitHooks({ ...opts, protections: void 0 }, interactive);
 }
 
 // src/skills.ts
@@ -1081,25 +1674,22 @@ function checkSources() {
   }
   console.log(`Integrity check passed: ${checked} skill(s) well-formed and sealed.`);
 }
-async function installSkills(opts, interactive) {
+async function installSkills(opts, interactive, reporter = clackReporter()) {
   const available = discoverAgents();
-  if (available.length === 0) {
-    p3.cancel("No installable agents known.");
-    process.exit(1);
-  }
+  if (available.length === 0) reporter.fatal("No installable agents known.");
   let scope;
   if (opts.scope) {
     scope = opts.scope;
   } else if (interactive) {
-    const r = await p3.select({
+    const r = await p4.select({
       message: "Where should skills be installed?",
       options: [
         { value: "global", label: "Global (user)", hint: "~/.claude, ~/.codex, ~/.config/opencode" },
         { value: "local", label: "Local (this project)", hint: process.cwd() }
       ]
     });
-    if (p3.isCancel(r)) {
-      p3.cancel("Aborted.");
+    if (p4.isCancel(r)) {
+      p4.cancel("Aborted.");
       return;
     }
     scope = r;
@@ -1111,19 +1701,19 @@ async function installSkills(opts, interactive) {
   if (opts.agents.length) {
     chosenAgents = available.filter((a) => opts.agents.includes(a.name));
     const unknown = opts.agents.filter((n) => !available.some((a) => a.name === n));
-    if (unknown.length) p3.log.warn(`Skipping unknown/absent agents: ${unknown.join(", ")}`);
+    if (unknown.length) reporter.warn(`Skipping unknown/absent agents: ${unknown.join(", ")}`);
   } else if (opts.allAgents) {
     chosenAgents = available;
   } else if (interactive && available.length > 1) {
     const preselect = (detected.length ? detected : available).map((a) => a.name);
-    const r = await p3.multiselect({
+    const r = await p4.multiselect({
       message: "Which agents? (detected on this system are preselected)",
       options: available.map((a) => ({ value: a.name, label: a.label, hint: a.installed ? "detected" : "not detected" })),
       initialValues: preselect,
       required: true
     });
-    if (p3.isCancel(r)) {
-      p3.cancel("Aborted.");
+    if (p4.isCancel(r)) {
+      p4.cancel("Aborted.");
       return;
     }
     chosenAgents = available.filter((a) => r.includes(a.name));
@@ -1131,17 +1721,14 @@ async function installSkills(opts, interactive) {
     chosenAgents = detected;
   } else {
     chosenAgents = available;
-    p3.log.warn("No installed agents detected; defaulting to all supported agents.");
-  }
-  if (chosenAgents.length === 0) {
-    p3.cancel("No matching agents selected.");
-    process.exit(1);
+    reporter.warn("No installed agents detected; defaulting to all supported agents.");
   }
+  if (chosenAgents.length === 0) reporter.fatal("No matching agents selected.");
   const claudeScope = chosenAgents.some((a) => a.name === "claude") ? scope : null;
   const applyClaudeConfig = () => {
     if (!claudeScope || opts.dryRun) return;
     if (disableClaudeAttribution(claudeScope)) {
-      p3.log.info("Claude Code: disabled Co-Authored-By and PR attribution in settings.json.");
+      reporter.info("Claude Code: disabled Co-Authored-By and PR attribution in settings.json.");
     }
   };
   const bypassAgents = await resolveBypassSelection(chosenAgents, opts, interactive);
@@ -1150,7 +1737,7 @@ async function installSkills(opts, interactive) {
   for (const agent of chosenAgents) {
     const target = agent.targets[scope];
     if (!target) {
-      p3.log.warn(`${agent.label} has no '${scope}' target - skipping.`);
+      reporter.warn(`${agent.label} has no '${scope}' target - skipping.`);
       continue;
     }
     const skills = inspectSkills();
@@ -1159,7 +1746,7 @@ async function installSkills(opts, interactive) {
     if (!opts.memoryOnly && opts.skills.length) {
       chosenSkills = skills.filter((s2) => opts.skills.includes(s2.name));
     } else if (!opts.memoryOnly && interactive && skills.length > 1) {
-      const r = await p3.multiselect({
+      const r = await p4.multiselect({
         message: `Skills for ${agent.label} - all selected; deselect any you don't want`,
         options: skills.map((s2) => {
           const st = skillStatus(join6(target.skills, s2.name), s2.meta);
@@ -1169,8 +1756,8 @@ async function installSkills(opts, interactive) {
         initialValues: skills.map((s2) => s2.name),
         required: false
       });
-      if (p3.isCancel(r)) {
-        p3.cancel("Aborted.");
+      if (p4.isCancel(r)) {
+        p4.cancel("Aborted.");
         return;
       }
       chosenSkills = skills.filter((s2) => r.includes(s2.name));
@@ -1187,16 +1774,16 @@ async function installSkills(opts, interactive) {
   if (tampered.length) {
     if (opts.keepModified) {
       for (const s2 of tampered) s2.overwrite = false;
-      p3.log.warn(`${tampered.length} locally-modified skill(s) will be kept (--keep-modified).`);
+      reporter.warn(`${tampered.length} locally-modified skill(s) will be kept (--keep-modified).`);
     } else if (interactive && !opts.dryRun) {
-      const sel = await p3.multiselect({
+      const sel = await p4.multiselect({
         message: `${tampered.length} skill(s) were modified locally since install. Select which to OVERWRITE`,
         options: tampered.map((s2, i) => ({ value: i, label: s2.name, hint: s2.meta.version ? `v${s2.meta.version}` : "modified" })),
         initialValues: tampered.map((_, i) => i),
         required: false
       });
-      if (p3.isCancel(sel)) {
-        p3.cancel("Aborted.");
+      if (p4.isCancel(sel)) {
+        p4.cancel("Aborted.");
         return;
       }
       tampered.forEach((s2, i) => {
@@ -1250,14 +1837,14 @@ async function installSkills(opts, interactive) {
     }
   }
   if (nInstall + nUpdate + nRemove === 0) {
-    p3.note(lines.join("\n"), "Nothing to do");
+    reporter.note(lines.join("\n"), "Nothing to do");
     applyClaudeConfig();
     applyBypassConfig();
     await maybeOfferGitHooks(interactive, opts);
-    p3.log.success(`Everything up-to-date - ${nSkip} item(s) unchanged${nKept ? `, ${nKept} kept modified` : ""} (${scope}).`);
+    reporter.success(`Everything up-to-date - ${nSkip} item(s) unchanged${nKept ? `, ${nKept} kept modified` : ""} (${scope}).`);
     return;
   }
-  p3.note(lines.join("\n"), opts.dryRun ? "Dry run - planned changes" : "Planned changes");
+  reporter.note(lines.join("\n"), opts.dryRun ? "Dry run - planned changes" : "Planned changes");
   if (interactive && !opts.dryRun) {
     const summary = [
       nInstall && `${nInstall} to install`,
@@ -1265,21 +1852,21 @@ async function installSkills(opts, interactive) {
       nRemove && `${nRemove} to remove`,
       nSkip && `${nSkip} unchanged`
     ].filter(Boolean).join(", ");
-    const ok = await p3.confirm({ message: `Apply: ${summary}?` });
-    if (p3.isCancel(ok) || !ok) {
-      p3.cancel("Aborted.");
+    const ok = await p4.confirm({ message: `Apply: ${summary}?` });
+    if (p4.isCancel(ok) || !ok) {
+      p4.cancel("Aborted.");
       return;
     }
   }
   if (opts.dryRun) {
     applyBypassConfig();
-    p3.log.info("Dry run complete - no files written.");
+    reporter.info("Dry run complete - no files written.");
     return;
   }
   const changedAgents = plan.filter(
     (x) => x.skills.some(willCopy) || x.memory.some((m) => memoryStatus(m.src, join6(x.target.memory, m.name)) !== "identical") || x.prune.length > 0
   );
-  const s = p3.spinner();
+  const s = reporter.spinner();
   s.start("Installing...");
   let copied = 0;
   try {
@@ -1300,26 +1887,28 @@ async function installSkills(opts, interactive) {
     }
   } catch (err) {
     s.stop("Failed.");
-    p3.cancel(`Error while installing: ${err.message}`);
-    process.exit(1);
+    reporter.fatal(`Error while installing: ${err.message}`);
   }
   s.stop(`Wrote ${copied} item(s)${nRemove ? `, removed ${nRemove}` : ""}.`);
   applyClaudeConfig();
   applyBypassConfig();
   await maybeOfferGitHooks(interactive, opts);
-  p3.log.success(`${nInstall} installed, ${nUpdate} updated/overwritten` + (nRemove ? `, ${nRemove} removed` : "") + (nSkip ? `, ${nSkip} unchanged` : "") + (nKept ? `, ${nKept} kept modified` : "") + ` (${scope}).`);
+  reporter.success(`${nInstall} installed, ${nUpdate} updated/overwritten` + (nRemove ? `, ${nRemove} removed` : "") + (nSkip ? `, ${nSkip} unchanged` : "") + (nKept ? `, ${nKept} kept modified` : "") + ` (${scope}).`);
   if (changedAgents.length) {
     const { known, running } = runningStatus(changedAgents.map((x) => x.agent));
     if (running.size) {
       const names = changedAgents.filter((x) => running.has(x.agent.name)).map((x) => x.agent.label);
-      p3.log.warn(`Restart ${names.join(", ")} to apply the changes (running now).`);
+      reporter.warn(`Restart ${names.join(", ")} to apply the changes (running now).`);
     } else if (!known) {
       const names = changedAgents.map((x) => x.agent.label);
-      p3.log.info(`If any of these agents are running, restart them to apply the changes: ${names.join(", ")}.`);
+      reporter.info(`If any of these agents are running, restart them to apply the changes: ${names.join(", ")}.`);
     }
   }
 }
 
+// src/cli.ts
+init_agents();
+
 // src/guard.ts
 import { readFileSync as readFileSync4, statSync as statSync2 } from "fs";
 import { execFileSync as execFileSync3 } from "child_process";
@@ -1521,7 +2110,7 @@ import { homedir as homedir5 } from "os";
 import { join as join9 } from "path";
 import { writeFileSync as writeFileSync6 } from "fs";
 import { spawn, spawnSync } from "child_process";
-import * as p4 from "@clack/prompts";
+import * as p5 from "@clack/prompts";
 var REGISTRY_URL = "https://registry.npmjs.org/enigma-cli/latest";
 var UPDATE_COMMAND = "npm i -g enigma-cli@latest";
 var CACHE_FILE = join9(homedir5(), ".enigma-update-check.json");
@@ -1606,8 +2195,8 @@ async function notifyUpdate(current, interactive) {
 ${renderUpdateBox(current, latest)}
 `);
     if (!interactive) return;
-    const ok = await p4.confirm({ message: `Update now with ${UPDATE_COMMAND}?`, initialValue: true });
-    if (p4.isCancel(ok) || !ok) return;
+    const ok = await p5.confirm({ message: `Update now with ${UPDATE_COMMAND}?`, initialValue: true });
+    if (p5.isCancel(ok) || !ok) return;
     runUpdate();
   } catch {
   }
@@ -1725,7 +2314,7 @@ Usage:
 
 Commands:
   (none)               Interactive hub: configure settings or set up features
-  install              Install/update agent skills (Claude Code, Codex, opencode)
+  install              Install/update agent skills (Claude Code, Codex, OpenCode)
   security             Set up git security hooks in the current repo
   guard [--all]        Run the commit guard (staged files, or --all for every tracked file)
   config [key val]     Configure settings: no args opens the interactive menu;
@@ -1734,7 +2323,7 @@ Commands:
   check                Integrity gate: verify skills are well-formed and sealed
   help, version
 
-Config keys: commit-emoji, update-notifier, claude-attribution,
+Config keys: commit-emoji, update-notifier, fullscreen, claude-attribution,
              bypass-claude, bypass-codex, bypass-opencode
 
 Install options:
@@ -1788,16 +2377,16 @@ async function run(argv) {
     process.exit(await runConfigCli(opts.positionals, opts.scope, interactive));
   }
   if (opts.command === "install") {
-    p5.intro("enigma - install agent skills");
+    p6.intro("enigma - install agent skills");
     await installSkills(opts, interactive);
-    p5.outro("Done.");
+    p6.outro("Done.");
     await notifyUpdate(version, interactive);
     return;
   }
   if (opts.command === "security") {
-    p5.intro("enigma - git security hooks");
+    p6.intro("enigma - git security hooks");
     const done = await setupGitHooks(opts, interactive);
-    p5.outro(done ? "Git hooks configured." : "No changes made.");
+    p6.outro(done ? "Git hooks configured." : "No changes made.");
     await notifyUpdate(version, interactive);
     return;
   }
@@ -1806,16 +2395,24 @@ async function run(argv) {
     await notifyUpdate(version, interactive);
     return;
   }
-  const { runHomeTui: runHomeTui2 } = await Promise.resolve().then(() => (init_settings(), settings_exports));
-  await runHomeTui2(async (action) => {
-    if (action === "skills") {
-      p5.intro("enigma - install agent skills");
-      await installSkills(opts, interactive);
-      p5.outro("Done.");
-    } else if (action === "security") {
-      p5.intro("enigma - git security hooks");
-      const done = await setupGitHooks(opts, interactive);
-      p5.outro(done ? "Git hooks configured." : "No changes made.");
+  const { runHomeTui: runHomeTui3 } = isBun() ? await Promise.resolve().then(() => (init_opentui(), opentui_exports)) : await Promise.resolve().then(() => (init_settings(), settings_exports));
+  await runHomeTui3({
+    agents: discoverAgents().map((a) => ({ name: a.name, label: a.label, installed: a.installed })),
+    protections: GUARD_PROTECTIONS,
+    runAction: async (req) => {
+      const reporter = collectReporter();
+      const title = req.action === "skills" ? "Install agent skills" : "Git security hooks";
+      try {
+        if (req.action === "skills") {
+          await installSkills({ ...opts, scope: req.scope ?? opts.scope, agents: req.agents ?? [], allAgents: !(req.agents && req.agents.length) }, false, reporter);
+          return { ok: true, title, lines: reporter.lines };
+        }
+        const done = await setupGitHooks({ ...opts, protections: req.protections, force: true }, false, reporter);
+        return { ok: done, title, lines: reporter.lines };
+      } catch (err) {
+        reporter.error(`Error: ${err.message}`);
+        return { ok: false, title, lines: reporter.lines };
+      }
     }
   });
   await notifyUpdate(version, interactive);