create-egregore 0.17.4 → 0.18.0

package/assets/egregore-launcher.js

@@ -0,0 +1,1965 @@
+#!/usr/bin/env node
+// egregore-launcher-version: 0.5.17
+//
+// egregore — launch and browse Egregore instances from your terminal.
+// Installed by create-egregore. Reads ~/.egregore/instances.json.
+// Zero dependencies: Node built-ins only.
+//
+// Interactive mode (bare `egregore` with a TTY):
+//   full-screen browser with filter, preview, and inline actions.
+//
+// Subcommands:
+//   egregore                    pick an instance, then pick an assistant
+//   egregore <slug|name>        pick an assistant for the matching instance
+//   egregore ls | list          list instances (non-interactive table)
+//   egregore use <slug>         set the default for bare `egregore`
+//   egregore /invite <user>     invite a GitHub user to an instance
+//   egregore prune [--dry-run]  remove entries whose path is gone
+//   egregore rm <slug|path>     remove a specific entry
+//   egregore browse             force the full-screen browser
+//   egregore help | --help
+//   egregore --version
+
+"use strict";
+
+const fs = require("node:fs");
+const path = require("node:path");
+const os = require("node:os");
+const http = require("node:http");
+const https = require("node:https");
+const { spawnSync, spawn } = require("node:child_process");
+const readline = require("node:readline");
+
+const VERSION = "0.5.17";
+const REGISTRY = path.join(os.homedir(), ".egregore", "instances.json");
+const DEFAULT_FILE = path.join(os.homedir(), ".egregore", "default");
+const PUBLIC_NPX_PACKAGE = "create-egregore";
+
+const NATIVE_CODEX_SKILLS = [
+  "activity",
+  "handoff",
+  "wrap",
+  "announce",
+  "harvest",
+  "the-spiral",
+  "dashboard",
+  "deep-reflect",
+  "quest",
+  "invite",
+  "ask",
+  "save",
+];
+
+const PRIMARY_CODEX_SKILLS = [
+  "activity",
+  "dashboard",
+  "save",
+  "wrap",
+  "handoff",
+  "ask",
+  "invite",
+  "quest",
+];
+
+const EGREGORE_ART = [
+  "███████╗ ██████╗ ██████╗ ███████╗ ██████╗  ██████╗ ██████╗ ███████╗",
+  "██╔════╝██╔════╝ ██╔══██╗██╔════╝██╔════╝ ██╔═══██╗██╔══██╗██╔════╝",
+  "█████╗  ██║  ███╗██████╔╝█████╗  ██║  ███╗██║   ██║██████╔╝█████╗",
+  "██╔══╝  ██║   ██║██╔══██╗██╔══╝  ██║   ██║██║   ██║██╔══██╗██╔══╝",
+  "███████╗╚██████╔╝██║  ██║███████╗╚██████╔╝╚██████╔╝██║  ██║███████╗",
+  "╚══════╝ ╚═════╝ ╚═╝  ╚═╝╚══════╝ ╚═════╝  ╚═════╝ ╚═╝  ╚══════╝",
+];
+
+const EGREGORE_SIGIL = [
+  "      ◆      ",
+  "     ╱ ╲     ",
+  "    ◆───◆    ",
+  "     ╲ ╱     ",
+  "      ◆      ",
+];
+
+// ── colors / ansi ───────────────────────────────────────────────────
+
+const isTTY = process.stdout.isTTY;
+const colorOn = isTTY && !process.env.NO_COLOR;
+const E = (code) => (colorOn ? `\x1b[${code}m` : "");
+const RESET = E(0);
+const BOLD = E(1);
+const DIM = E(2);
+const INV = E(7);
+const BLACK = E(30), RED = E(31), GREEN = E(32), YELLOW = E(33);
+const BLUE = E(34), MAGENTA = E(35), CYAN = E(36), WHITE = E(37);
+const GRAY = E(90);
+
+const ANSI = {
+  altScreenEnter: "\x1b[?1049h",
+  altScreenLeave: "\x1b[?1049l",
+  cursorHide:     "\x1b[?25l",
+  cursorShow:     "\x1b[?25h",
+  clear:          "\x1b[2J",
+  home:           "\x1b[H",
+  clearLine:      "\x1b[K",
+  moveTo: (row, col) => `\x1b[${row};${col}H`,
+};
+
+const stripAnsi = (s) => s.replace(/\x1b\[[0-9;]*m/g, "");
+const visLen = (s) => stripAnsi(s).length;
+const pad = (s, n) => s + " ".repeat(Math.max(0, n - visLen(s)));
+const truncate = (s, n) => {
+  if (visLen(s) <= n) return s;
+  // Naive truncate — assumes no escapes within the char range we're clipping.
+  const stripped = stripAnsi(s);
+  return stripped.slice(0, n - 1) + "…";
+};
+const canPrompt = () => process.stdin.isTTY && process.stdout.isTTY;
+const skillToken = (name) => `/${name}`;
+const npxCommand = (args = []) => ["npx", "-y", `${PUBLIC_NPX_PACKAGE}@latest`, ...args].filter(Boolean).join(" ");
+const joinCommand = (owner, repo) => npxCommand(["join", repo ? `${owner}/${repo}` : owner]);
+
+function joinShort(values, maxWidth) {
+  const clean = values.filter(Boolean);
+  let out = "";
+  let hidden = 0;
+  for (let i = 0; i < clean.length; i++) {
+    const next = out ? `${out} ${clean[i]}` : clean[i];
+    if (visLen(next) <= maxWidth) {
+      out = next;
+    } else {
+      hidden = clean.length - i;
+      break;
+    }
+  }
+  if (hidden > 0) {
+    const suffix = ` +${hidden}`;
+    if (visLen(out + suffix) <= maxWidth) return out + suffix;
+  }
+  return out || clean[0] || "";
+}
+
+function boxLine(content, innerWidth, margin = "") {
+  const bodyWidth = Math.max(8, innerWidth - 2);
+  return `${margin}${DIM}│${RESET} ${pad(truncate(content, bodyWidth), bodyWidth)} ${DIM}│${RESET}`;
+}
+
+function emptyBoxLine(innerWidth, margin = "") {
+  return boxLine("", innerWidth, margin);
+}
+
+// ── registry ────────────────────────────────────────────────────────
+
+function die(msg) {
+  process.stderr.write(`${RED}egregore:${RESET} ${msg}\n`);
+  process.exit(1);
+}
+
+function readRegistry() {
+  if (!fs.existsSync(REGISTRY)) return [];
+  try {
+    const data = JSON.parse(fs.readFileSync(REGISTRY, "utf-8"));
+    let entries = [];
+    if (Array.isArray(data)) entries = data;
+    // Tolerate legacy/alt wrapped shape: { instances: [...] }
+    else if (data && Array.isArray(data.instances)) entries = data.instances;
+    // Drop entries that don't have a `path` — older Hearth-era schemas
+    // (slug/profile/memory) coexist in some users' files and would crash
+    // `launch()` with `path: undefined`. Keep entries whose path exists OR
+    // doesn't yet exist — `egregore prune` is the canonical way to drop
+    // those, so we don't filter by existence here.
+    // Dedup by resolved path: some registries accumulated dozens of duplicate
+    // rows pointing at the same dir from older installers that didn't dedup
+    // on write. Keep the first occurrence of each path.
+    const seen = new Set();
+    const result = [];
+    for (const e of entries) {
+      if (!e || typeof e.path !== "string" || !e.path) continue;
+      const key = path.resolve(e.path);
+      if (seen.has(key)) continue;
+      seen.add(key);
+      result.push(e);
+    }
+    return result;
+  } catch {
+    return [];
+  }
+}
+
+function writeRegistry(entries) {
+  const dir = path.dirname(REGISTRY);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(REGISTRY, JSON.stringify(entries, null, 2) + "\n");
+}
+
+function backupRegistry() {
+  if (!fs.existsSync(REGISTRY)) return null;
+  const ts = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
+  const bak = `${REGISTRY}.bak.${ts}`;
+  fs.copyFileSync(REGISTRY, bak);
+  return bak;
+}
+
+function readDefault() {
+  if (!fs.existsSync(DEFAULT_FILE)) return null;
+  return fs.readFileSync(DEFAULT_FILE, "utf-8").trim() || null;
+}
+
+function writeDefault(slug) {
+  const dir = path.dirname(DEFAULT_FILE);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(DEFAULT_FILE, `${slug}\n`);
+}
+
+function resolveBySlug(registry, query) {
+  // Exact slug → exact name → case-insensitive substring (slug ∪ name)
+  let hit = registry.find((e) => e.slug === query);
+  if (hit) return hit;
+  hit = registry.find((e) => e.name === query);
+  if (hit) return hit;
+  const q = query.toLowerCase();
+  hit = registry.find(
+    (e) => e.slug.toLowerCase().includes(q) || (e.name || "").toLowerCase().includes(q),
+  );
+  return hit || null;
+}
+
+function pathContains(parent, child) {
+  const rel = path.relative(path.resolve(parent), path.resolve(child));
+  return rel === "" || (!!rel && !rel.startsWith("..") && !path.isAbsolute(rel));
+}
+
+function initialCursorForCwd(registry, cwd = process.cwd()) {
+  let best = -1;
+  let bestLen = -1;
+  for (let i = 0; i < registry.length; i++) {
+    const entryPath = registry[i]?.path;
+    if (!entryPath || !pathContains(entryPath, cwd)) continue;
+    const len = path.resolve(entryPath).length;
+    if (len > bestLen) {
+      best = i;
+      bestLen = len;
+    }
+  }
+  if (best >= 0) return best;
+
+  const def = readDefault();
+  if (def) {
+    const idx = registry.findIndex((entry) => entry.slug === def);
+    if (idx >= 0) return idx;
+  }
+  return 0;
+}
+
+// ── launch ──────────────────────────────────────────────────────────
+
+function normalizeRuntime(raw) {
+  const value = String(raw || "").trim().toLowerCase();
+  if (!value) return null;
+  if (value === "claude" || value === "claude-code" || value === "claude_code") return "claude-code";
+  if (value === "codex" || value === "openai-codex" || value === "openai_codex") return "codex";
+  return null;
+}
+
+function parseRuntimeFlags(argv) {
+  const rest = [];
+  let runtimeOverride = null;
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--codex") {
+      runtimeOverride = "codex";
+    } else if (arg === "--claude" || arg === "--claude-code") {
+      runtimeOverride = "claude-code";
+    } else if (arg === "--runtime") {
+      const next = argv[++i];
+      if (!next) die("missing value for --runtime");
+      runtimeOverride = next;
+    } else if (arg.startsWith("--runtime=")) {
+      runtimeOverride = arg.slice("--runtime=".length);
+    } else {
+      rest.push(arg);
+    }
+  }
+  const normalized = runtimeOverride ? normalizeRuntime(runtimeOverride) : null;
+  if (runtimeOverride && !normalized) die(`unknown runtime: ${runtimeOverride}\n  expected claude-code or codex`);
+  return { args: rest, runtimeOverride: normalized };
+}
+
+function storedRuntimeFor(inst) {
+  return (
+    normalizeRuntime(inst && inst.runtime) ||
+    normalizeRuntime(inst && inst.preferred_runtime) ||
+    "claude-code"
+  );
+}
+
+function runtimeFor(inst, runtimeOverride) {
+  return normalizeRuntime(runtimeOverride) || storedRuntimeFor(inst);
+}
+
+function runtimeLabel(runtime) {
+  return runtime === "codex" ? "Codex" : "Claude Code";
+}
+
+function runtimeShort(runtime) {
+  return runtime === "codex" ? "codex" : "claude-code";
+}
+
+function runtimeBinary(runtime) {
+  return runtime === "codex" ? "codex" : "claude";
+}
+
+function assistantInstallCommand(runtime) {
+  return runtime === "codex"
+    ? "npm install -g @openai/codex"
+    : "npm install -g @anthropic-ai/claude-code";
+}
+
+function commandExists(bin) {
+  return spawnSync("which", [bin], { stdio: "pipe" }).status === 0;
+}
+
+function runtimeChoiceDescription(runtime, inst, stored) {
+  const installed = commandExists(runtimeBinary(runtime));
+  const bits = [];
+  if (!installed) {
+    return runtime === "codex"
+      ? "not installed · install Codex, then run egregore"
+      : "not installed · install Claude Code, then run egregore";
+  }
+  bits.push("installed");
+  if (runtime === stored) bits.push("saved default");
+  if (runtime === "codex") bits.push("portable agent protocol");
+  else bits.push("Claude Code integration");
+  return bits.join(" · ");
+}
+
+function runtimePickerLines(inst, runtimes, stored, cursor) {
+  const title = inst.slug || inst.name || path.basename(inst.path);
+  const labelWidth = Math.max(...runtimes.map((r) => runtimeLabel(r).length));
+  const lines = [
+    "",
+    `  ${DIM}↑↓${RESET} navigate · ${DIM}enter${RESET} select · ${DIM}1-${runtimes.length}${RESET} quick select · ${DIM}esc${RESET} cancel`,
+    `  ${CYAN}◆${RESET} ${BOLD}Launch ${title} with which assistant?${RESET}`,
+    "",
+  ];
+
+  for (let i = 0; i < runtimes.length; i++) {
+    const runtime = runtimes[i];
+    const marker = i === cursor ? `${CYAN}❯${RESET}` : " ";
+    const label = pad(runtimeLabel(runtime), labelWidth);
+    const desc = runtimeChoiceDescription(runtime, inst, stored);
+    lines.push(`  ${marker} ${BOLD}${label}${RESET}  ${DIM}${desc}${RESET}`);
+  }
+  lines.push("");
+  return lines;
+}
+
+function pickRuntimeInteractive(inst, runtimes, stored) {
+  return new Promise((resolve) => {
+    let cursor = 0;
+    let rendered = 0;
+    let done = false;
+    const title = inst.slug || inst.name || path.basename(inst.path);
+    const previousRaw = !!process.stdin.isRaw;
+
+    const erase = () => {
+      if (!rendered) return;
+      process.stdout.write(`\x1b[${rendered}A`);
+      for (let i = 0; i < rendered; i++) {
+        process.stdout.write(ANSI.clearLine + (i === rendered - 1 ? "" : "\n"));
+      }
+      process.stdout.write("\r");
+      rendered = 0;
+    };
+
+    const cleanup = () => {
+      if (done) return;
+      done = true;
+      process.stdin.removeListener("keypress", onKey);
+      if (process.stdin.setRawMode) process.stdin.setRawMode(previousRaw);
+      if (!previousRaw) process.stdin.pause();
+      erase();
+    };
+
+    const finish = (runtime) => {
+      cleanup();
+      if (runtime) {
+        console.log(`  ${CYAN}◆${RESET} Launching ${title} with ${BOLD}${runtimeLabel(runtime)}${RESET}`);
+      }
+      resolve(runtime);
+    };
+
+    const render = () => {
+      erase();
+      const lines = runtimePickerLines(inst, runtimes, stored, cursor);
+      rendered = lines.length;
+      process.stdout.write(lines.map((line) => line + ANSI.clearLine).join("\n") + "\n");
+    };
+
+    function onKey(chunk, key = {}) {
+      if (key.ctrl && key.name === "c") {
+        cleanup();
+        process.exit(130);
+      }
+      if (key.name === "escape" || key.name === "q") return finish(null);
+      if (key.name === "up" || (key.ctrl && key.name === "p") || key.name === "k") {
+        cursor = (cursor - 1 + runtimes.length) % runtimes.length;
+        render();
+        return;
+      }
+      if (key.name === "down" || (key.ctrl && key.name === "n") || key.name === "j") {
+        cursor = (cursor + 1) % runtimes.length;
+        render();
+        return;
+      }
+      if (key.name === "return") return finish(runtimes[cursor]);
+      if (chunk && /^[1-9]$/.test(chunk)) {
+        const idx = Number(chunk) - 1;
+        if (idx >= 0 && idx < runtimes.length) return finish(runtimes[idx]);
+      }
+    }
+
+    readline.emitKeypressEvents(process.stdin);
+    if (process.stdin.setRawMode) process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.on("keypress", onKey);
+    render();
+  });
+}
+
+function runtimeChoicesFor(inst, runtimeOverride) {
+  const override = normalizeRuntime(runtimeOverride);
+  if (override) return [override];
+  const stored = storedRuntimeFor(inst);
+  const choices = stored === "codex"
+    ? ["codex", "claude-code"]
+    : ["claude-code", "codex"];
+  return choices.sort((a, b) => Number(commandExists(runtimeBinary(b))) - Number(commandExists(runtimeBinary(a))));
+}
+
+function startSpinner(label) {
+  if (!isTTY) {
+    console.log(`  ${label}...`);
+    return () => {};
+  }
+  const frames = ["|", "/", "-", "\\"];
+  let i = 0;
+  process.stdout.write(`  ${CYAN}${frames[i]}${RESET} ${label}`);
+  const timer = setInterval(() => {
+    i = (i + 1) % frames.length;
+    process.stdout.write(`\r  ${CYAN}${frames[i]}${RESET} ${label}${ANSI.clearLine}`);
+  }, 90);
+  return () => {
+    clearInterval(timer);
+    process.stdout.write(`\r${ANSI.clearLine}`);
+  };
+}
+
+function runCapturedWithSpinner(cmd, args, options, label) {
+  return new Promise((resolve) => {
+    const stop = startSpinner(label);
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    const child = spawn(cmd, args, {
+      cwd: options.cwd,
+      env: options.env || process.env,
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+
+    child.stdout.on("data", (chunk) => { stdout += chunk.toString(); });
+    child.stderr.on("data", (chunk) => { stderr += chunk.toString(); });
+    child.on("error", (err) => {
+      if (settled) return;
+      settled = true;
+      stop();
+      resolve({ status: 1, stdout, stderr: stderr || String(err) });
+    });
+    child.on("close", (status) => {
+      if (settled) return;
+      settled = true;
+      stop();
+      resolve({ status, stdout, stderr });
+    });
+  });
+}
+
+async function chooseRuntimeForLaunch(inst, runtimeOverride) {
+  const override = normalizeRuntime(runtimeOverride);
+  if (override) return override;
+
+  const stored = storedRuntimeFor(inst);
+  if (!canPrompt()) return stored;
+
+  const runtimes = runtimeChoicesFor(inst);
+  return pickRuntimeInteractive(inst, runtimes, stored);
+}
+
+async function renderCodexStartupCard(egregoreDir) {
+  const script = path.join(egregoreDir, "bin", "codex-session-start.sh");
+  if (fs.existsSync(script)) {
+    try {
+      const result = await runCapturedWithSpinner("bash", [script], {
+        cwd: egregoreDir,
+      }, "Preparing Codex startup");
+      if (result.stdout) process.stdout.write(result.stdout);
+      if (result.status !== 0 && result.stderr) process.stderr.write(result.stderr);
+      if (result.status === 0) return true;
+    } catch {}
+  }
+  return false;
+}
+
+function codexSupportMessage(egregoreDir) {
+  return [
+    "Codex assistant support is missing from this Egregore checkout.",
+    `  path: ${egregoreDir}`,
+    "",
+    "This checkout needs a newer Egregore core with:",
+    "  bin/codex-session-start.sh",
+    "  bin/codex-install-skills.sh",
+    "  .codex/config.toml",
+    "  .codex/skills/",
+    "  .codex/hooks.json",
+    "  .codex/hooks/",
+    "",
+    "Run npx -y create-egregore@latest to install the packaged Codex runtime, then rerun egregore.",
+    "Egregore workflows appear as slash commands. In Codex, invoke them with the matching $skill token or ask in natural language.",
+  ].join("\n");
+}
+
+function hasCodexCoreSupport(egregoreDir) {
+  return (
+    fs.existsSync(path.join(egregoreDir, "bin", "codex-session-start.sh")) &&
+    fs.existsSync(path.join(egregoreDir, "bin", "codex-install-skills.sh")) &&
+    fs.existsSync(path.join(egregoreDir, ".codex", "config.toml")) &&
+    fs.existsSync(path.join(egregoreDir, ".codex", "skills")) &&
+    fs.existsSync(path.join(egregoreDir, ".codex", "hooks.json")) &&
+    fs.existsSync(path.join(egregoreDir, ".codex", "hooks"))
+  );
+}
+
+function installCodexSkills(egregoreDir) {
+  const script = path.join(egregoreDir, "bin", "codex-install-skills.sh");
+  if (!fs.existsSync(script)) return false;
+  try {
+    const result = spawnSync("bash", [script], {
+      cwd: egregoreDir,
+      stdio: ["ignore", "ignore", "pipe"],
+      encoding: "utf-8",
+      maxBuffer: 1024 * 1024,
+    });
+    return result.status === 0;
+  } catch {
+    return false;
+  }
+}
+
+function runtimeLaunchArgs(runtime, egregoreDir) {
+  if (runtime === "codex") {
+    return [
+      "--enable", "hooks",
+      "--sandbox", "danger-full-access",
+      "--ask-for-approval", "never",
+      "--cd", egregoreDir,
+    ];
+  }
+  return ["start"];
+}
+
+async function launch(inst, runtimeOverride) {
+  if (!inst) die("no instance to launch");
+  if (!fs.existsSync(inst.path)) die(`instance path does not exist: ${inst.path}`);
+  const runtime = await chooseRuntimeForLaunch(inst, runtimeOverride);
+  if (!runtime) return;
+  const binary = runtimeBinary(runtime);
+  if (!commandExists(binary)) {
+    die(`${runtimeLabel(runtime)} is not installed.\n  Install it with:\n    ${assistantInstallCommand(runtime)}\n  Then run: egregore`);
+  }
+  if (runtime === "codex") {
+    if (!hasCodexCoreSupport(inst.path)) {
+      die(codexSupportMessage(inst.path));
+    }
+    const skillsInstalled = installCodexSkills(inst.path);
+    const cardRendered = await renderCodexStartupCard(inst.path);
+    if (!skillsInstalled || !cardRendered) {
+      die(codexSupportMessage(inst.path));
+    }
+  }
+  // Replace the current process with the selected assistant in the instance dir.
+  // spawn + detached + exit-on-exit replicates exec() in Node.
+  const child = spawn(binary, runtimeLaunchArgs(runtime, inst.path), {
+    cwd: inst.path,
+    stdio: "inherit",
+    env: {
+      ...process.env,
+      EGREGORE_RUNTIME: runtime,
+      EGREGORE_CODEX_TRUSTED: runtime === "codex" ? "1" : process.env.EGREGORE_CODEX_TRUSTED,
+    },
+  });
+  child.on("exit", (code, signal) => {
+    process.exit(signal ? 1 : (code ?? 0));
+  });
+}
+
+function setupNewEgregore(runtimeOverride) {
+  const args = ["--yes", `${PUBLIC_NPX_PACKAGE}@latest`, "--open"];
+  if (runtimeOverride) args.push("--runtime", runtimeOverride);
+  const child = spawn("npx", args, {
+    stdio: "inherit",
+    cwd: process.cwd(),
+    env: { ...process.env },
+  });
+  child.on("exit", (code, signal) => {
+    process.exit(signal ? 1 : (code ?? 0));
+  });
+}
+
+// ── non-interactive commands ────────────────────────────────────────
+
+function cmdLs() {
+  const registry = readRegistry();
+  const def = readDefault();
+  if (registry.length === 0) {
+    console.log(`  ${DIM}no egregores installed yet.${RESET}  run ${CYAN}npx -y create-egregore@latest${RESET}`);
+    return;
+  }
+  const slugW = Math.min(24, Math.max(...registry.map((r) => (r.slug || "").length)));
+  const nameW = Math.min(24, Math.max(...registry.map((r) => (r.name || "").length)));
+  const runtimeW = Math.max(9, ...registry.map((r) => runtimeShort(runtimeFor(r)).length));
+  console.log(`\n  ${BOLD}${registry.length}${RESET} egregore${registry.length === 1 ? "" : "s"} registered\n`);
+  console.log(`    ${DIM}${pad("SLUG", slugW)}  ${pad("NAME", nameW)}  ${pad("ASSISTANT", runtimeW)}  PATH${RESET}`);
+  for (const inst of registry) {
+    const marker = inst.slug === def ? `${GREEN}●${RESET}` : " ";
+    const slug = inst.slug === def ? `${BOLD}${pad(inst.slug, slugW)}${RESET}` : pad(inst.slug, slugW);
+    const runtime = pad(runtimeShort(runtimeFor(inst)), runtimeW);
+    console.log(`  ${marker} ${slug}  ${pad(inst.name || "", nameW)}  ${runtime}  ${DIM}${inst.path}${RESET}`);
+  }
+  if (def) console.log(`\n  ${GREEN}●${RESET} = default marker (used by non-interactive ${BOLD}egregore${RESET})\n`);
+  else console.log("");
+}
+
+function cmdUse(slug) {
+  if (!slug) die("usage: egregore use <slug>");
+  const registry = readRegistry();
+  const hit = resolveBySlug(registry, slug);
+  if (!hit) die(`no instance matching '${slug}'. run: egregore ls`);
+  writeDefault(hit.slug);
+  console.log(`  ${GREEN}✓${RESET} default set to ${BOLD}${hit.slug}${RESET}`);
+}
+
+function cmdRmNonInteractive(target) {
+  if (!target) die("usage: egregore rm <slug|path>");
+  const registry = readRegistry();
+  const matches = registry.filter(
+    (e) => e.slug === target || e.path === target ||
+           e.slug.includes(target) || e.path.includes(target),
+  );
+  if (matches.length === 0) die(`no instance matching '${target}'. run: egregore ls`);
+  if (matches.length > 1) {
+    process.stderr.write(`\n  ${YELLOW}!${RESET} ${matches.length} entries match ${BOLD}"${target}"${RESET}:\n\n`);
+    for (const m of matches) {
+      process.stderr.write(`    ${pad(m.slug, 22)}  ${pad(m.name, 24)}  ${DIM}${m.path}${RESET}\n`);
+    }
+    process.stderr.write(`\n  Use an exact path to pick one: ${CYAN}egregore rm <full-path>${RESET}\n\n`);
+    process.exit(1);
+  }
+  const hit = matches[0];
+  process.stdout.write(`\n  about to remove:\n    ${pad(hit.slug, 22)}  ${pad(hit.name, 24)}  ${DIM}${hit.path}${RESET}\n\n`);
+  const ans = syncConfirm("  confirm? [y/N]: ");
+  if (!ans) { console.log(`  ${DIM}cancelled.${RESET}`); return; }
+
+  const bak = backupRegistry();
+  writeRegistry(registry.filter((e) => e.path !== hit.path));
+  console.log(`  ${GREEN}✓${RESET} removed.\n  ${DIM}backup:${RESET} ${bak}\n`);
+}
+
+function cmdPruneNonInteractive(dry) {
+  const registry = readRegistry();
+  const stale = registry.filter((e) => !fs.existsSync(e.path));
+  if (stale.length === 0) {
+    console.log(`  ${GREEN}✓${RESET} registry is clean — ${registry.length} entries, all paths exist.`);
+    return;
+  }
+  console.log(`\n  ${YELLOW}!${RESET} ${stale.length} of ${registry.length} entries have missing paths:\n`);
+  for (const e of stale) console.log(`    ${RED}✗${RESET} ${pad(e.slug, 22)}  ${DIM}${e.path}${RESET}`);
+  console.log("");
+  if (dry) {
+    console.log(`  ${DIM}(dry run — nothing removed. re-run without --dry-run to apply.)${RESET}\n`);
+    return;
+  }
+  const ans = syncConfirm("  remove them? [y/N]: ");
+  if (!ans) { console.log(`  ${DIM}cancelled.${RESET}`); return; }
+  const bak = backupRegistry();
+  writeRegistry(registry.filter((e) => fs.existsSync(e.path)));
+  console.log(`  ${GREEN}✓${RESET} pruned ${stale.length} — ${registry.length - stale.length} remain.`);
+  console.log(`  ${DIM}backup:${RESET} ${bak}\n`);
+}
+
+function cmdHelp() {
+  const lines = [
+    ``,
+    `  ${BOLD}${CYAN}egregore${RESET}   ${DIM}launch and browse Egregore instances${RESET}`,
+    ``,
+    `  ${BOLD}USAGE${RESET}`,
+    `    ${CYAN}egregore${RESET}                     pick an instance, then pick an assistant`,
+    `    ${CYAN}egregore${RESET} ${DIM}<slug|name>${RESET}         pick an assistant for the matching instance`,
+    `    ${CYAN}egregore --runtime${RESET} ${DIM}<name> <slug>${RESET}  advanced assistant override`,
+    `    ${CYAN}egregore browse${RESET}              force the full-screen browser`,
+    `    ${CYAN}egregore ls${RESET} ${DIM}| list${RESET}            list installed instances`,
+    `    ${CYAN}egregore use${RESET} ${DIM}<slug>${RESET}          set the default for bare ${BOLD}egregore${RESET}`,
+    `    ${CYAN}egregore /invite${RESET} ${DIM}<user> [slug]${RESET} invite a GitHub user`,
+    `    ${CYAN}egregore prune${RESET} ${DIM}[--dry-run]${RESET}   remove entries with missing paths`,
+    `    ${CYAN}egregore rm${RESET} ${DIM}<slug|path>${RESET}     remove a specific entry`,
+    ``,
+    `  ${BOLD}BROWSER KEYS${RESET}`,
+    `    ${DIM}↑ ↓${RESET}         navigate`,
+    `    ${DIM}enter${RESET}       choose selected instance`,
+    `    ${DIM}/${RESET}           filter (type to narrow; esc to clear)`,
+    `    ${DIM}n / +${RESET}       create a new Egregore`,
+    `    ${DIM}u${RESET}           set selected as default`,
+    `    ${DIM}i${RESET}           invite a GitHub user to selected instance`,
+    `    ${DIM}r${RESET}           remove selected (with confirm)`,
+    `    ${DIM}p${RESET}           prune entries with missing paths (with confirm)`,
+    `    ${DIM}?${RESET}           toggle help overlay`,
+    `    ${DIM}q / esc${RESET}     quit browser`,
+    ``,
+    `  ${BOLD}REGISTRY${RESET}`,
+    `    ${DIM}instances:${RESET} ~/.egregore/instances.json`,
+    `    ${DIM}default:${RESET}   ~/.egregore/default`,
+    `    ${DIM}mutations back up to instances.json.bak.<timestamp>${RESET}`,
+    ``,
+  ];
+  console.log(lines.join("\n"));
+}
+
+// ── invite flow ────────────────────────────────────────────────────
+
+function readJsonFile(file) {
+  try {
+    return JSON.parse(fs.readFileSync(file, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+
+function readEnvValues(file) {
+  const values = {};
+  if (!fs.existsSync(file)) return values;
+  for (const raw of fs.readFileSync(file, "utf-8").split(/\r?\n/)) {
+    const line = raw.trim();
+    if (!line || line.startsWith("#")) continue;
+    const idx = line.indexOf("=");
+    if (idx < 0) continue;
+    values[line.slice(0, idx)] = line.slice(idx + 1);
+  }
+  return values;
+}
+
+function validGithubUsername(username) {
+  return /^[A-Za-z0-9](?:[A-Za-z0-9-]{0,37}[A-Za-z0-9])?$/.test(username);
+}
+
+function repoNameFromRemote(remote) {
+  const clean = String(remote || "").trim().replace(/\.git$/, "");
+  if (!clean) return "";
+  const parts = clean.split(/[/:]/).filter(Boolean);
+  return parts[parts.length - 1] || "";
+}
+
+function configForInstance(inst) {
+  const cfg = readJsonFile(path.join(inst.path, "egregore.json"));
+  const state = readJsonFile(path.join(inst.path, ".egregore-state.json"));
+  const env = { ...readEnvValues(path.join(inst.path, ".env")), ...process.env };
+  return { cfg, state, env };
+}
+
+function inviteRepos(cfg) {
+  const repos = [];
+  if (cfg.repo_name) repos.push(cfg.repo_name);
+  const memoryName = repoNameFromRemote(cfg.memory_repo);
+  if (memoryName) repos.push(memoryName);
+  if (Array.isArray(cfg.repos)) {
+    for (const entry of cfg.repos) {
+      const name = typeof entry === "string" ? entry : entry && entry.name;
+      if (name) repos.push(name);
+    }
+  }
+  return [...new Set(repos)];
+}
+
+function requestJson(options, body) {
+  return new Promise((resolve) => {
+    const payload = body ? JSON.stringify(body) : null;
+    const headers = {
+      Accept: "application/vnd.github+json",
+      "User-Agent": "egregore-launcher",
+      ...(options.headers || {}),
+    };
+    if (payload) {
+      headers["Content-Type"] = "application/json";
+      headers["Content-Length"] = Buffer.byteLength(payload);
+    }
+    const transport = options.protocol === "http:" ? http : https;
+    const req = transport.request({ ...options, headers }, (res) => {
+      let buf = "";
+      res.on("data", (chunk) => { buf += chunk; });
+      res.on("end", () => {
+        let data = buf;
+        try { data = buf ? JSON.parse(buf) : {}; } catch {}
+        resolve({ status: res.statusCode || 0, data });
+      });
+    });
+    req.on("error", (err) => resolve({ status: 0, data: { message: err.message } }));
+    if (payload) req.write(payload);
+    req.end();
+  });
+}
+
+function githubRequest(token, method, apiPath, body) {
+  return requestJson({
+    hostname: "api.github.com",
+    path: apiPath,
+    method,
+    headers: { Authorization: `Bearer ${token}` },
+  }, body);
+}
+
+function apiRequest(apiUrl, apiKey, apiPath, body) {
+  const url = new URL(apiPath, apiUrl.replace(/\/+$/, "") + "/");
+  return requestJson({
+    hostname: url.hostname,
+    port: url.port || undefined,
+    path: `${url.pathname}${url.search}`,
+    method: "POST",
+    protocol: url.protocol,
+    headers: { Authorization: `Bearer ${apiKey}` },
+  }, body);
+}
+
+function accessLabel(status) {
+  if (status === 201) return `${GREEN}sent${RESET}`;
+  if (status === 204) return `${GREEN}already added${RESET}`;
+  if (status === 422) return `${YELLOW}already invited or added${RESET}`;
+  if (status === 403) return `${RED}permission denied${RESET}`;
+  if (status === 404) return `${RED}not found${RESET}`;
+  if (status === 0) return `${RED}network error${RESET}`;
+  return `${RED}failed ${status}${RESET}`;
+}
+
+function runGit(cwd, args) {
+  try {
+    return spawnSync("git", ["-C", cwd, ...args], {
+      stdio: "pipe",
+      encoding: "utf-8",
+      timeout: 15000,
+    });
+  } catch (err) {
+    return { status: 1, stderr: String(err), stdout: "" };
+  }
+}
+
+function ensurePersonFile(inst, username, inviter) {
+  const memoryDir = path.join(inst.path, "memory");
+  if (!fs.existsSync(memoryDir)) return { status: "missing-memory", path: null, committed: false, pushed: false };
+  const peopleDir = path.join(memoryDir, "people");
+  fs.mkdirSync(peopleDir, { recursive: true });
+  const personPath = path.join(peopleDir, `${username}.md`);
+  let created = false;
+  if (!fs.existsSync(personPath)) {
+    const today = new Date().toISOString().slice(0, 10);
+    fs.writeFileSync(personPath, [
+      "---",
+      `name: ${username}`,
+      `github: ${username}`,
+      `invited_by: ${inviter}`,
+      `joined: ${today}`,
+      "---",
+      "",
+    ].join("\n"));
+    created = true;
+  }
+
+  return {
+    status: created ? "created" : "exists",
+    path: personPath,
+    committed: false,
+    pushed: false,
+  };
+}
+
+function managedRepoNames(cfg) {
+  if (!Array.isArray(cfg.repos)) return [];
+  return cfg.repos
+    .map((entry) => (typeof entry === "string" ? entry : entry && entry.name))
+    .filter(Boolean);
+}
+
+function yamlList(values) {
+  const clean = values.filter(Boolean);
+  if (clean.length === 0) return " []";
+  return clean.map((value) => `\n  - ${String(value).replace(/\n/g, " ")}`).join("");
+}
+
+function safeInviteFilename(username) {
+  const safe = String(username || "invitee")
+    .toLowerCase()
+    .replace(/[^a-z0-9-]+/g, "-")
+    .replace(/^-|-$/g, "") || "invitee";
+  return `${new Date().toISOString().slice(0, 10)}-${safe}.md`;
+}
+
+function memoryRepoForInvite(cfg, githubOrg) {
+  if (cfg.memory_repo && /^https?:\/\//i.test(cfg.memory_repo)) return cfg.memory_repo;
+  if (cfg.memory_repo && /^git@/i.test(cfg.memory_repo)) return cfg.memory_repo;
+  if (cfg.memory_repo) return `https://github.com/${githubOrg}/${cfg.memory_repo}.git`;
+  return `https://github.com/${githubOrg}/egregore-memory.git`;
+}
+
+function writeInviteArtifact(inst, username, inviter, cfg, opts = {}) {
+  const memoryDir = path.join(inst.path, "memory");
+  if (!fs.existsSync(memoryDir)) return { status: "missing-memory", path: null };
+  const invitesDir = path.join(memoryDir, "invites");
+  fs.mkdirSync(invitesDir, { recursive: true });
+  const githubOrg = cfg.github_org || "";
+  const repoName = cfg.repo_name || "egregore";
+  const fallbackCommand = opts.fallbackCommand || joinCommand(githubOrg, repoName);
+  const invitePath = path.join(invitesDir, safeInviteFilename(username));
+  const lines = [
+    "---",
+    "type: egregore_invite",
+    `created_at: ${new Date().toISOString()}`,
+    `inviter: ${inviter}`,
+    `invitee_github: ${username}`,
+    `org: ${githubOrg}`,
+    `repo: ${githubOrg}/${repoName}`,
+    `memory_repo: ${memoryRepoForInvite(cfg, githubOrg)}`,
+    `managed_repos:${yamlList(managedRepoNames(cfg))}`,
+    `invite_url: ${opts.inviteUrl || ""}`,
+    `fallback_command: ${fallbackCommand}`,
+    `telegram_group_link: ${cfg.telegram_group_link || ""}`,
+    `delivery: ${opts.delivery || "copyable_share_block"}`,
+    "---",
+    "",
+    `# Invite: ${username}`,
+    "",
+    `Fallback command: \`${fallbackCommand}\``,
+    "",
+  ];
+  if (opts.inviteUrl) lines.push(`Invite URL: ${opts.inviteUrl}`, "");
+  if (cfg.telegram_group_link) lines.push(`Telegram: ${cfg.telegram_group_link}`, "");
+  fs.writeFileSync(invitePath, lines.join("\n"));
+  return { status: "written", path: invitePath };
+}
+
+function ensureInviteAudit(inst, username, inviter, cfg, opts = {}) {
+  const memoryDir = path.join(inst.path, "memory");
+  const person = ensurePersonFile(inst, username, inviter);
+  const artifact = writeInviteArtifact(inst, username, inviter, cfg, opts);
+  if (!fs.existsSync(memoryDir) || !fs.existsSync(path.join(memoryDir, ".git"))) {
+    return { person, artifact, committed: false, pushed: false };
+  }
+  const paths = [person.path, artifact.path].filter(Boolean);
+  for (const p of paths) runGit(memoryDir, ["add", path.relative(memoryDir, p)]);
+  const commit = runGit(memoryDir, ["commit", "-m", `Invite ${username}`]);
+  const committed = commit.status === 0;
+  const push = committed ? runGit(memoryDir, ["push"]) : { status: 1 };
+  return { person, artifact, committed, pushed: push.status === 0 };
+}
+
+function tryNotifyInvite(inst, username, message, cfg, env) {
+  const script = path.join(inst.path, "bin", "notify.sh");
+  if (!fs.existsSync(script)) return null;
+  const hasConnectedChannel = (cfg.api_url && env.EGREGORE_API_KEY) || cfg.telegram_group_link;
+  if (!hasConnectedChannel) return null;
+  try {
+    const result = spawnSync("bash", [script, "send", username, message], {
+      cwd: inst.path,
+      stdio: "pipe",
+      encoding: "utf-8",
+      timeout: 15000,
+      env: { ...process.env, ...env },
+    });
+    const output = `${result.stdout || ""}${result.stderr || ""}`.trim();
+    if (result.status === 0 && /Sent|sent/i.test(output)) return { status: "sent", output };
+    return { status: "failed", output };
+  } catch (err) {
+    return { status: "failed", output: String(err) };
+  }
+}
+
+async function connectedInvite(inst, username, cfg, env) {
+  const apiUrl = cfg.api_url || "";
+  const apiKey = env.EGREGORE_API_KEY || "";
+  const ghToken = env.GITHUB_TOKEN || "";
+  if (!apiUrl || !apiKey || !ghToken) return null;
+  return apiRequest(apiUrl, apiKey, "/api/org/invite", {
+    github_org: cfg.github_org,
+    github_username: username,
+    repo_name: cfg.repo_name || "egregore",
+    slug: cfg.slug || inst.slug,
+    github_token: ghToken,
+  });
+}
+
+async function inviteToInstance(inst, username) {
+  if (!validGithubUsername(username)) die(`invalid GitHub username: ${username}`);
+  if (!fs.existsSync(inst.path)) die(`instance path does not exist: ${inst.path}`);
+
+  const { cfg, state, env } = configForInstance(inst);
+  const ghToken = env.GITHUB_TOKEN || "";
+  const githubOrg = cfg.github_org || "";
+  const repoName = cfg.repo_name || "egregore";
+  const orgName = cfg.org_name || inst.name || githubOrg || "this Egregore";
+  const inviter = state.github_username || state.display_name || os.userInfo().username;
+  if (!githubOrg) die(`missing github_org in ${path.join(inst.path, "egregore.json")}`);
+  if (!ghToken) die(`missing GITHUB_TOKEN in ${path.join(inst.path, ".env")}\n  run: bash bin/github-auth.sh`);
+
+  console.log("");
+  console.log(`  ${BOLD}${CYAN}/invite${RESET} ${BOLD}${username}${RESET} ${DIM}→ ${orgName}${RESET}`);
+  console.log("");
+
+  const connected = await connectedInvite(inst, username, cfg, env);
+  if (connected && connected.status >= 200 && connected.status < 300 && connected.data && connected.data.invite_url) {
+    const fallbackCommand = connected.data.fallback_command || joinCommand(githubOrg, repoName);
+    const telegramGroupLink = connected.data.telegram_group_link || cfg.telegram_group_link || "";
+    const inviteCfg = telegramGroupLink ? { ...cfg, telegram_group_link: telegramGroupLink } : cfg;
+    const audit = ensureInviteAudit(inst, username, inviter, inviteCfg, {
+      inviteUrl: connected.data.invite_url,
+      fallbackCommand,
+      delivery: "invite_url",
+    });
+    console.log(`  ${GREEN}✓${RESET} invite link created`);
+    if (connected.data.github_invite?.status) {
+      console.log(`  ${DIM}github${RESET} ${connected.data.github_invite.status}`);
+    }
+    if (connected.data.memory_access) {
+      console.log(`  ${DIM}memory${RESET} ${connected.data.memory_access.status || connected.data.memory_access}`);
+    }
+    const auditStatus = audit.artifact.status === "missing-memory"
+      ? `${YELLOW}memory/ missing${RESET}`
+      : `${GREEN}recorded${RESET}${audit.pushed ? DIM + " · pushed" + RESET : ""}`;
+    console.log(`  ${DIM}memory/invites${RESET} ${auditStatus}`);
+    const notified = tryNotifyInvite(inst, username, connected.data.invite_url, cfg, env);
+    if (notified && notified.status === "sent") {
+      console.log(`  ${DIM}notify${RESET} ${GREEN}sent${RESET}`);
+    }
+    console.log("");
+    console.log(`  ${BOLD}Share this link:${RESET}`);
+    console.log(`  ${CYAN}${connected.data.invite_url}${RESET}`);
+    console.log(`  ${DIM}fallback:${RESET} ${fallbackCommand}`);
+    if (telegramGroupLink) console.log(`  ${DIM}telegram:${RESET} ${telegramGroupLink}`);
+    console.log("");
+    return;
+  }
+  if (connected && connected.status !== 0) {
+    const detail = connected.data && (connected.data.detail || connected.data.message || connected.data.error);
+    console.log(`  ${YELLOW}!${RESET} connected invite unavailable${detail ? `: ${detail}` : ""}`);
+    console.log(`  ${DIM}falling back to GitHub collaborator access${RESET}`);
+    console.log("");
+  }
+
+  const repos = inviteRepos(cfg);
+  if (repos.length === 0) die("no repos configured for this Egregore");
+  const results = [];
+  for (const repo of repos) {
+    const result = await githubRequest(
+      ghToken,
+      "PUT",
+      `/repos/${encodeURIComponent(githubOrg)}/${encodeURIComponent(repo)}/collaborators/${encodeURIComponent(username)}`,
+      { permission: "push" },
+    );
+    results.push({ repo, status: result.status, data: result.data });
+  }
+
+  const fallbackCommand = joinCommand(githubOrg, repoName);
+  const audit = ensureInviteAudit(inst, username, inviter, cfg, {
+    fallbackCommand,
+    delivery: "copyable_share_block",
+  });
+  for (const result of results) {
+    console.log(`  ${DIM}${pad(result.repo, 24)}${RESET} ${accessLabel(result.status)}`);
+  }
+  const personState = audit.person.status === "missing-memory"
+    ? `${YELLOW}memory/ missing${RESET}`
+    : audit.person.status === "created"
+      ? `${GREEN}created${RESET}`
+      : `${DIM}already exists${RESET}`;
+  const artifactState = audit.artifact.status === "missing-memory"
+    ? `${YELLOW}memory/ missing${RESET}`
+    : `${GREEN}recorded${RESET}${audit.pushed ? DIM + " · pushed" + RESET : ""}`;
+  console.log(`  ${DIM}${pad("memory/people", 24)}${RESET} ${personState}`);
+  console.log(`  ${DIM}${pad("memory/invites", 24)}${RESET} ${artifactState}`);
+  console.log("");
+  console.log(`  ${BOLD}Send them this join command:${RESET}`);
+  console.log(`  ${CYAN}${fallbackCommand}${RESET}`);
+  if (cfg.telegram_group_link) console.log(`  ${DIM}telegram:${RESET} ${cfg.telegram_group_link}`);
+
+  const failed = results.filter((r) => ![201, 204, 422].includes(r.status));
+  if (failed.length > 0) {
+    console.log("");
+    console.log(`  ${YELLOW}!${RESET} Some repo invites failed. Manual access page:`);
+    console.log(`  ${CYAN}https://github.com/${githubOrg}/${repoName}/settings/access${RESET}`);
+  }
+  console.log("");
+}
+
+function resolveInviteInstance(registry, query) {
+  if (query) return resolveBySlug(registry, query);
+  const def = readDefault();
+  if (def) {
+    const hit = registry.find((e) => e.slug === def);
+    if (hit) return hit;
+  }
+  return registry.length === 1 ? registry[0] : null;
+}
+
+function syncPrompt(question) {
+  process.stdout.write(question);
+  const buf = Buffer.alloc(256);
+  const n = fs.readSync(0, buf, 0, 256, null);
+  return buf.slice(0, n).toString().trim();
+}
+
+async function cmdInvite(args) {
+  const registry = readRegistry();
+  if (registry.length === 0) die("no egregores installed yet.\n  run: npx -y create-egregore@latest");
+  let username = args[0] || "";
+  const instanceQuery = args[1] || "";
+  if (!username && canPrompt()) username = syncPrompt("  GitHub username to invite: ");
+  if (!username) die("usage: egregore /invite <github-username> [slug]");
+  const inst = resolveInviteInstance(registry, instanceQuery);
+  if (!inst) {
+    die(`multiple egregores installed; choose one:\n  egregore /invite ${username} <slug>\n  run: egregore ls`);
+  }
+  return inviteToInstance(inst, username);
+}
+
+// ── tiny sync confirm (non-TUI flows) ───────────────────────────────
+
+function syncConfirm(question) {
+  process.stdout.write(question);
+  // Synchronous read from stdin — blocks until the user hits Enter.
+  const buf = Buffer.alloc(256);
+  const n = fs.readSync(0, buf, 0, 256, null);
+  const input = buf.slice(0, n).toString().trim();
+  return /^y(es)?$/i.test(input);
+}
+
+// ── git info for preview ────────────────────────────────────────────
+
+const previewCache = new Map(); // path → { branch, lastCommit, repos }
+
+function loadSkillSummary(egregoreDir) {
+  const skillsDir = path.join(egregoreDir, ".codex", "skills");
+  const claudeSkillsDir = path.join(egregoreDir, ".claude", "skills");
+  const summary = {
+    names: [],
+    native: [],
+    adapterCount: 0,
+    claudeNames: [],
+    claudeCount: 0,
+  };
+  const loadNames = (dir) => {
+    if (!fs.existsSync(dir)) return [];
+    return fs.readdirSync(dir, { withFileTypes: true })
+      .filter((entry) => entry.isDirectory())
+      .map((entry) => entry.name)
+      .filter((name) => fs.existsSync(path.join(dir, name, "SKILL.md")))
+      .sort();
+  };
+  try {
+    summary.names = loadNames(skillsDir);
+    const adapters = [];
+    for (const name of summary.names) {
+      const skillFile = path.join(skillsDir, name, "SKILL.md");
+      const body = fs.readFileSync(skillFile, "utf-8");
+      if (body.includes("Fallback Codex adapter")) adapters.push(name);
+      else summary.native.push(name);
+    }
+    summary.adapterCount = adapters.length;
+  } catch {}
+  try {
+    summary.claudeNames = loadNames(claudeSkillsDir);
+    summary.claudeCount = summary.claudeNames.length;
+  } catch {}
+  return summary;
+}
+
+function loadPreview(inst) {
+  if (previewCache.has(inst.path)) return previewCache.get(inst.path);
+  const data = { branch: null, lastCommit: null, repos: [], telegram: false, skills: loadSkillSummary(inst.path) };
+  try {
+    const r = spawnSync("git", ["-C", inst.path, "rev-parse", "--abbrev-ref", "HEAD"], {
+      stdio: "pipe", encoding: "utf-8", timeout: 2000,
+    });
+    if (r.status === 0) data.branch = (r.stdout || "").trim();
+  } catch {}
+  try {
+    const r = spawnSync("git", ["-C", inst.path, "log", "-1", "--format=%cr · %s"], {
+      stdio: "pipe", encoding: "utf-8", timeout: 2000,
+    });
+    if (r.status === 0) data.lastCommit = (r.stdout || "").trim();
+  } catch {}
+  try {
+    const cfgPath = path.join(inst.path, "egregore.json");
+    if (fs.existsSync(cfgPath)) {
+      const cfg = JSON.parse(fs.readFileSync(cfgPath, "utf-8"));
+      data.repos = Array.isArray(cfg.repos)
+        ? cfg.repos.map((r) => (typeof r === "string" ? r : r && r.name)).filter(Boolean)
+        : [];
+      data.telegram = !!(cfg.telegram_chat_id || cfg.telegram_group_link);
+      data.org = cfg.org_name;
+      data.githubOrg = cfg.github_org;
+      data.mode = cfg.mode;
+      data.flowVariant = cfg.flow_variant;
+    }
+  } catch {}
+  previewCache.set(inst.path, data);
+  return data;
+}
+
+function selectedWorkflowLine(pv, width) {
+  if (pv?.skills && pv.skills.native.length === 0) {
+    return truncate("no Codex skills in this checkout", Math.max(12, width));
+  }
+  const available = pv?.skills?.native?.length
+    ? PRIMARY_CODEX_SKILLS.filter((name) => pv.skills.native.includes(name))
+    : PRIMARY_CODEX_SKILLS;
+  return joinShort(available.map(skillToken), Math.max(12, width));
+}
+
+function renderHeroPanel({ selected, pv, width, height, countSuffix, filter, filterMode }) {
+  const outerWidth = Math.min(Math.max(50, width - 2), 126);
+  const innerWidth = Math.max(48, outerWidth - 2);
+  const bodyWidth = Math.max(8, innerWidth - 2);
+  const margin = " ".repeat(Math.max(0, Math.floor((width - outerWidth) / 2)));
+  const label = " egregore ";
+  const top = `${margin}${DIM}┌${"─".repeat(2)}${label}${"─".repeat(Math.max(0, innerWidth - label.length - 2))}┐${RESET}`;
+  const bottom = `${margin}${DIM}└${"─".repeat(innerWidth)}┘${RESET}`;
+  const mid = `${margin}${DIM}├${"─".repeat(innerWidth)}┤${RESET}`;
+  const lines = [top];
+
+  const title = selected ? `${selected.slug || selected.name || "egregore"}` : "egregore";
+  const org = pv?.org || selected?.name || "Egregore";
+  const runtime = selected ? runtimeShort(runtimeFor(selected)) : "launcher";
+  const skillsCount = pv?.skills?.names?.length || 0;
+  const nativeCount = pv?.skills?.native?.length || 0;
+  const adapterCount = pv?.skills?.adapterCount || 0;
+  const claudeCount = pv?.skills?.claudeCount || 0;
+  const workflows = selectedWorkflowLine(pv, innerWidth - 16);
+  const filterText = filterMode
+    ? `filter /${filter}▌`
+    : filter
+      ? `filter /${filter}`
+      : "press ? for help";
+  const canShowBigLogo = bodyWidth >= Math.max(...EGREGORE_ART.map((line) => line.length)) && height >= 24;
+  const skillStatus = `Codex ${nativeCount} native · ${adapterCount} adapter · ${skillsCount} total · Claude ${claudeCount}`;
+  const skillGroups = [
+    `${DIM}core${RESET}: ${workflows}`,
+    `${DIM}team${RESET}: ${joinShort(["/handoff", "/ask", "/invite", "/quest"], Math.max(16, bodyWidth - 8))}`,
+    `${DIM}deeper${RESET}: ${joinShort(["/announce", "/harvest", "/the-spiral", "/deep-reflect"], Math.max(16, bodyWidth - 10))}`,
+    `${DIM}fallback${RESET}: ${adapterCount} adapter skills`,
+  ];
+
+  lines.push(emptyBoxLine(innerWidth, margin));
+  if (canShowBigLogo) {
+    for (const artLine of EGREGORE_ART) {
+      const centered = " ".repeat(Math.max(0, Math.floor((bodyWidth - artLine.length) / 2))) + `${BOLD}${CYAN}${artLine}${RESET}`;
+      lines.push(boxLine(centered, innerWidth, margin));
+    }
+  } else {
+    lines.push(boxLine(`${BOLD}${CYAN}EGREGORE${RESET} ${DIM}v${VERSION} · ${countSuffix} · ${filterText}${RESET}`, innerWidth, margin));
+  }
+  lines.push(emptyBoxLine(innerWidth, margin));
+  lines.push(mid);
+  lines.push(boxLine(`${BOLD}${title}${RESET} ${DIM}· ${org} · ${runtime} · ${countSuffix} · ${filterText}${RESET}`, innerWidth, margin));
+  lines.push(boxLine(`${DIM}skills${RESET} ${skillStatus}`, innerWidth, margin));
+  lines.push(emptyBoxLine(innerWidth, margin));
+
+  const sigilWidth = Math.max(...EGREGORE_SIGIL.map((line) => line.length));
+  const twoColumn = bodyWidth >= 68;
+  if (twoColumn) {
+    const gap = 3;
+    const rightWidth = Math.max(28, bodyWidth - sigilWidth - gap);
+    const right = [
+      `${BOLD}Available Skills${RESET}`,
+      ...skillGroups,
+      "",
+      `${BOLD}Assistants${RESET}`,
+      `${DIM}claude-code${RESET}: ${commandExists("claude") ? "installed" : "not installed"}`,
+      `${DIM}codex${RESET}: ${commandExists("codex") ? "installed" : "not installed"}`,
+    ];
+    const rows = Math.max(EGREGORE_SIGIL.length + 2, right.length);
+    for (let i = 0; i < rows; i++) {
+      const sigil = i < EGREGORE_SIGIL.length ? `${CYAN}${pad(EGREGORE_SIGIL[i], sigilWidth)}${RESET}` : " ".repeat(sigilWidth);
+      const info = right[i] || "";
+      lines.push(boxLine(`${sigil}${" ".repeat(gap)}${truncate(info, rightWidth)}`, innerWidth, margin));
+    }
+  } else {
+    lines.push(boxLine(`${BOLD}Available Skills${RESET}`, innerWidth, margin));
+    for (const group of skillGroups) lines.push(boxLine(group, innerWidth, margin));
+    lines.push(emptyBoxLine(innerWidth, margin));
+    lines.push(boxLine(`${BOLD}Assistants${RESET} ${DIM}claude-code${RESET} ${commandExists("claude") ? "installed" : "missing"} · ${DIM}codex${RESET} ${commandExists("codex") ? "installed" : "missing"}`, innerWidth, margin));
+  }
+
+  lines.push(emptyBoxLine(innerWidth, margin));
+  lines.push(boxLine(`${DIM}enter selects an instance, then choose Claude Code or Codex without leaving this screen${RESET}`, innerWidth, margin));
+  lines.push(bottom);
+  return lines;
+}
+
+function renderRuntimePanel({ inst, cursor, width, height }) {
+  void height;
+  const runtimes = runtimeChoicesFor(inst);
+  const stored = storedRuntimeFor(inst);
+  const title = inst.slug || inst.name || path.basename(inst.path);
+  const outerWidth = Math.min(Math.max(50, width - 2), 112);
+  const innerWidth = Math.max(48, outerWidth - 2);
+  const margin = " ".repeat(Math.max(0, Math.floor((width - outerWidth) / 2)));
+  const label = " assistant ";
+  const lines = [
+    `${margin}${DIM}┌${"─".repeat(2)}${label}${"─".repeat(Math.max(0, innerWidth - label.length - 2))}┐${RESET}`,
+    emptyBoxLine(innerWidth, margin),
+    boxLine(`${BOLD}${CYAN}Launch ${title}${RESET}`, innerWidth, margin),
+    boxLine(`${DIM}${inst.path}${RESET}`, innerWidth, margin),
+    emptyBoxLine(innerWidth, margin),
+  ];
+
+  for (let i = 0; i < runtimes.length; i++) {
+    const runtime = runtimes[i];
+    const selected = i === cursor;
+    const marker = selected ? `${CYAN}❯${RESET}` : " ";
+    const labelText = selected ? `${BOLD}${runtimeLabel(runtime)}${RESET}` : runtimeLabel(runtime);
+    const desc = runtimeChoiceDescription(runtime, inst, stored);
+    lines.push(boxLine(`${marker} ${pad(labelText, 16)} ${DIM}${desc}${RESET}`, innerWidth, margin));
+  }
+
+  lines.push(emptyBoxLine(innerWidth, margin));
+  lines.push(boxLine(`${DIM}↑↓ navigate · enter select · 1-${runtimes.length} quick select · esc back · q quit${RESET}`, innerWidth, margin));
+  lines.push(`${margin}${DIM}└${"─".repeat(innerWidth)}┘${RESET}`);
+  return lines;
+}
+
+// ── browser (full-screen TUI) ───────────────────────────────────────
+
+async function browser(args = {}) {
+  let registry = readRegistry();
+  if (registry.length === 0) {
+    if (canPrompt()) return setupNewEgregore(args.runtimeOverride);
+    console.log(`  ${DIM}no egregores installed yet.${RESET}\n  run ${CYAN}npx -y create-egregore@latest${RESET}`);
+    return;
+  }
+  if (!isTTY) {
+    // Non-TTY fallback: numbered picker.
+    return numberedPicker(registry, args.runtimeOverride);
+  }
+
+  // State
+  const state = {
+    filter: "",
+    filterMode: false,
+    inviteMode: false,
+    inviteUsername: "",
+    inviteInst: null,
+    runtimeInst: null,
+    runtimeCursor: 0,
+    cursor: initialCursorForCwd(registry),
+    showHelp: false,
+    modal: null, // { type: "remove" | "prune", onYes, onNo }
+    tick: 0,
+    message: null, // ephemeral info line (e.g. "default set to X")
+    messageKind: "info", // "info" | "success" | "warn"
+    messageUntil: 0,
+  };
+
+  const newAction = {
+    action: "new",
+    label: "Set up a new Egregore",
+    description: "guided install, Telegram, invite, assistant setup",
+  };
+
+  const visible = () => {
+    const instanceItems = registry.map((e, i) => ({ type: "instance", e, origIdx: i }));
+    if (!state.filter) return [...instanceItems, newAction];
+    const q = state.filter.toLowerCase();
+    const filtered = instanceItems
+      .filter(({ e }) =>
+        e.slug.toLowerCase().includes(q) ||
+        (e.name || "").toLowerCase().includes(q) ||
+        e.path.toLowerCase().includes(q),
+      );
+    if ("new setup create install another egregore".includes(q)) filtered.push(newAction);
+    return filtered;
+  };
+
+  const clampCursor = () => {
+    const v = visible();
+    if (v.length === 0) { state.cursor = 0; return; }
+    if (state.cursor >= v.length) state.cursor = v.length - 1;
+    if (state.cursor < 0) state.cursor = 0;
+  };
+
+  // ── render ────────────────────────────
+  const render = () => {
+    const w = process.stdout.columns || 80;
+    const h = process.stdout.rows || 24;
+
+    const out = [];
+    out.push(ANSI.home);
+
+    if (state.runtimeInst) {
+      const runtimeLines = renderRuntimePanel({
+        inst: state.runtimeInst,
+        cursor: state.runtimeCursor,
+        width: w,
+        height: h,
+      });
+      for (const line of runtimeLines) out.push(line + ANSI.clearLine + "\n");
+      const remainingRows = Math.max(0, h - runtimeLines.length - 1);
+      for (let i = 0; i < remainingRows; i++) out.push(ANSI.clearLine + "\n");
+      process.stdout.write(out.join(""));
+      return;
+    }
+
+    // Header / hero panel
+    const def = readDefault();
+    const v = visible();
+    const selectedItem = v[state.cursor];
+    const selected = selectedItem?.e || null;
+    const pv = selected ? loadPreview(selected) : null;
+    const countSuffix = state.filter
+      ? `${v.length} of ${registry.length}`
+      : `${registry.length} instance${registry.length === 1 ? "" : "s"}`;
+    const heroLines = renderHeroPanel({
+      selected,
+      pv,
+      width: w,
+      height: h,
+      countSuffix,
+      filter: state.filter,
+      filterMode: state.filterMode,
+    });
+    for (const line of heroLines) out.push(line + ANSI.clearLine + "\n");
+    out.push(ANSI.clearLine + "\n");
+
+    // Layout: list takes top 60%, preview takes rest, footer is last 2 lines
+    const footerRows = 2;
+    const usedRows = heroLines.length + 1;
+    const availableRows = Math.max(8, h - usedRows - footerRows - 2);
+    const listRows = Math.max(4, Math.floor(availableRows * 0.48));
+    const previewRows = Math.max(3, availableRows - listRows - 2); // -2 for dividers
+
+    // List
+    const listPad = 4;
+    const listAvail = w - listPad * 2;
+    const slugW = Math.min(22, Math.max(6, ...registry.map((r) => (r.slug || "").length)));
+    const nameW = Math.min(24, Math.max(6, ...registry.map((r) => (r.name || "").length)));
+
+    // Scroll window
+    let scrollOff = 0;
+    if (v.length > listRows) {
+      // Keep cursor in view; center when possible.
+      const half = Math.floor(listRows / 2);
+      scrollOff = Math.max(0, Math.min(v.length - listRows, state.cursor - half));
+    }
+
+    for (let i = 0; i < listRows; i++) {
+      const idx = scrollOff + i;
+      if (idx >= v.length) {
+        if (v.length === 0 && i === Math.floor(listRows / 2)) {
+          const msg = state.filter ? "(no matches)" : "(empty)";
+          out.push(" ".repeat(listPad) + DIM + msg + RESET + ANSI.clearLine + "\n");
+        } else {
+          out.push(ANSI.clearLine + "\n");
+        }
+        continue;
+      }
+      const item = v[idx];
+      if (item.action === "new") {
+        const isCursor = idx === state.cursor;
+        const cursorMark = isCursor ? `${CYAN}❯${RESET}` : " ";
+        const plus = isCursor ? `${BOLD}${CYAN}+ new${RESET}` : `${CYAN}+ new${RESET}`;
+        const label = isCursor ? `${BOLD}${item.label}${RESET}` : item.label;
+        const desc = `${DIM}${item.description}${RESET}`;
+        const line = ` ${cursorMark}    ${pad(plus, slugW)}  ${pad(label, nameW)}  ${truncate(desc, Math.max(0, listAvail - slugW - nameW - 10))}`;
+        out.push(" ".repeat(listPad - 3) + line + ANSI.clearLine + "\n");
+        continue;
+      }
+      const { e, origIdx } = item;
+      void origIdx;
+      const isCursor = idx === state.cursor;
+      const isDefault = e.slug === def;
+      const cursorMark = isCursor ? `${CYAN}❯${RESET}` : " ";
+      const defMark = isDefault ? `${GREEN}●${RESET}` : " ";
+      const slug = isCursor
+        ? `${BOLD}${CYAN}${pad(e.slug, slugW)}${RESET}`
+        : (isDefault ? `${BOLD}${pad(e.slug, slugW)}${RESET}` : pad(e.slug, slugW));
+      const name = pad(e.name || "", nameW);
+      const pathDim = `${DIM}${truncate(e.path, Math.max(0, listAvail - slugW - nameW - 10))}${RESET}`;
+      const line = ` ${cursorMark} ${defMark}  ${slug}  ${name}  ${pathDim}`;
+      out.push(" ".repeat(listPad - 3) + line + ANSI.clearLine + "\n");
+    }
+
+    // Divider
+    out.push(DIM + "  " + "─".repeat(w - 4) + RESET + ANSI.clearLine + "\n");
+
+    // Preview
+    const previewLines = [];
+    if (selectedItem?.action === "new") {
+      const label = (k) => `${DIM}${pad(k, 10)}${RESET}`;
+      previewLines.push(`  ${label("action")} ${BOLD}Set up a new Egregore${RESET}`);
+      previewLines.push(`  ${label("flow")} guided install, Telegram, invite, ready/start`);
+      previewLines.push(`  ${label("assistant")} choose Claude Code or Codex during setup`);
+      previewLines.push(`  ${label("start")} press enter to begin`);
+    } else if (!selected) {
+      previewLines.push(`${DIM}  (no selection)${RESET}`);
+    } else {
+      const label = (k) => `${DIM}${pad(k, 10)}${RESET}`;
+      previewLines.push(`  ${label("path")} ${selected.path}`);
+      if (pv.org) previewLines.push(`  ${label("org")} ${pv.org} ${DIM}(${pv.githubOrg || "?"})${RESET}`);
+      if (pv.branch) previewLines.push(`  ${label("branch")} ${BOLD}${pv.branch}${RESET}`);
+      if (pv.lastCommit) previewLines.push(`  ${label("last")} ${DIM}${truncate(pv.lastCommit, w - 18)}${RESET}`);
+      if (pv.repos && pv.repos.length) {
+        previewLines.push(`  ${label("repos")} ${pv.repos.slice(0, 4).join(", ")}${pv.repos.length > 4 ? DIM + ` (+${pv.repos.length - 4} more)` + RESET : ""}`);
+      }
+      if (pv.skills) {
+        const skillLine = selectedWorkflowLine(pv, Math.max(16, w - 20));
+        previewLines.push(`  ${label("invoke")} ${skillLine}`);
+        previewLines.push(`  ${label("skills")} Codex ${BOLD}${pv.skills.native.length}${RESET} native, ${BOLD}${pv.skills.adapterCount}${RESET} adapters; Claude ${BOLD}${pv.skills.claudeCount || 0}${RESET}`);
+      }
+      const modeBits = [];
+      modeBits.push(runtimeShort(runtimeFor(selected, args.runtimeOverride)));
+      if (pv.mode) modeBits.push(pv.mode);
+      if (pv.flowVariant && pv.flowVariant !== "legacy") modeBits.push(pv.flowVariant);
+      if (pv.telegram) modeBits.push("telegram");
+      if (selected.slug === def) modeBits.push("default");
+      if (modeBits.length) previewLines.push(`  ${label("tags")} ${modeBits.map((m) => `${DIM}[${RESET}${m}${DIM}]${RESET}`).join(" ")}`);
+    }
+    for (let i = 0; i < previewRows; i++) {
+      const line = previewLines[i] || "";
+      out.push(line + ANSI.clearLine + "\n");
+    }
+
+    // Divider
+    out.push(DIM + "  " + "─".repeat(w - 4) + RESET + ANSI.clearLine + "\n");
+
+    // Footer
+    let footer;
+    if (state.modal) {
+      const m = state.modal;
+      const prompt = m.type === "remove"
+        ? `remove ${BOLD}${m.inst.slug}${RESET}? ${DIM}[y/N]${RESET}`
+        : `prune ${BOLD}${m.count}${RESET} stale entries? ${DIM}[y/N]${RESET}`;
+      footer = `  ${YELLOW}?${RESET} ${prompt}${ANSI.clearLine}`;
+    } else if (state.filterMode) {
+      footer = `  ${DIM}typing filter · enter/esc to exit filter mode${RESET}${ANSI.clearLine}`;
+    } else if (state.inviteMode) {
+      const target = state.inviteInst?.slug || "selected";
+      footer = `  ${CYAN}/invite${RESET} ${DIM}${target}:${RESET} ${state.inviteUsername}${CYAN}▌${RESET} ${DIM}enter send · esc cancel${RESET}${ANSI.clearLine}`;
+    } else if (state.showHelp) {
+      footer = `  ${DIM}? toggles this hint · q quits${RESET}${ANSI.clearLine}`;
+    } else if (state.message && Date.now() < state.messageUntil) {
+      const kindColor = state.messageKind === "success" ? GREEN : state.messageKind === "warn" ? YELLOW : CYAN;
+      footer = `  ${kindColor}●${RESET} ${state.message}${ANSI.clearLine}`;
+    } else {
+      footer = w < 96
+        ? `  ${DIM}↑↓${RESET} nav  ${DIM}enter${RESET} select  ${DIM}n/+${RESET} new  ${DIM}i${RESET} invite  ${DIM}?${RESET} help  ${DIM}q${RESET} quit${ANSI.clearLine}`
+        : `  ${DIM}↑↓${RESET} nav  ${DIM}enter${RESET} select  ${DIM}n/+${RESET} new  ${DIM}/${RESET} filter  ${DIM}i${RESET} invite  ${DIM}u${RESET} default  ${DIM}r${RESET} rm  ${DIM}p${RESET} prune  ${DIM}?${RESET} help  ${DIM}q${RESET} quit${ANSI.clearLine}`;
+    }
+    out.push(footer + "\n");
+    if (state.showHelp) {
+      out.push(`  ${DIM}● default · ❯ cursor · n/+ starts guided setup · i opens /invite${RESET}${ANSI.clearLine}`);
+    } else {
+      out.push(ANSI.clearLine);
+    }
+
+    process.stdout.write(out.join(""));
+  };
+
+  // ── setup / teardown ───────────────────
+  process.stdout.write(ANSI.altScreenEnter + ANSI.cursorHide + ANSI.clear + ANSI.home);
+  let done = false;
+  const cleanup = () => {
+    if (done) return;
+    done = true;
+    process.stdin.setRawMode(false);
+    process.stdin.pause();
+    process.stdin.removeAllListeners("keypress");
+    process.stdout.write(ANSI.cursorShow + ANSI.altScreenLeave);
+  };
+  process.on("exit", cleanup);
+  process.on("SIGINT", () => { cleanup(); process.exit(130); });
+  process.on("SIGTERM", () => { cleanup(); process.exit(143); });
+  process.stdout.on("resize", () => render());
+
+  readline.emitKeypressEvents(process.stdin);
+  process.stdin.setRawMode(true);
+  process.stdin.resume();
+
+  const flashMessage = (msg, kind = "info", ms = 2200) => {
+    state.message = msg;
+    state.messageKind = kind;
+    state.messageUntil = Date.now() + ms;
+    render();
+    setTimeout(() => {
+      if (Date.now() >= state.messageUntil) render();
+    }, ms + 50);
+  };
+
+  return new Promise((resolve) => {
+    process.stdin.on("keypress", (chunk, key) => {
+      if (!key) return;
+
+      if (state.runtimeInst) {
+        const runtimes = runtimeChoicesFor(state.runtimeInst, args.runtimeOverride);
+        if (key.ctrl && key.name === "c") { cleanup(); process.exit(130); }
+        if (key.name === "escape") {
+          state.runtimeInst = null;
+          state.runtimeCursor = 0;
+          render();
+          return;
+        }
+        if (key.name === "q") {
+          cleanup();
+          resolve();
+          return;
+        }
+        if (key.name === "up" || (key.ctrl && key.name === "p") || key.name === "k") {
+          state.runtimeCursor = (state.runtimeCursor - 1 + runtimes.length) % runtimes.length;
+          render();
+          return;
+        }
+        if (key.name === "down" || (key.ctrl && key.name === "n") || key.name === "j") {
+          state.runtimeCursor = (state.runtimeCursor + 1) % runtimes.length;
+          render();
+          return;
+        }
+        if (chunk && /^[1-9]$/.test(chunk)) {
+          const idx = Number(chunk) - 1;
+          if (idx >= 0 && idx < runtimes.length) {
+            const inst = state.runtimeInst;
+            cleanup();
+            resolve(launch(inst, runtimes[idx]));
+          }
+          return;
+        }
+        if (key.name === "return") {
+          const runtime = runtimes[state.runtimeCursor];
+          const inst = state.runtimeInst;
+          cleanup();
+          resolve(launch(inst, runtime));
+        }
+        return;
+      }
+
+      // Modal handling takes priority
+      if (state.modal) {
+        if ((chunk && /^[yY]/.test(chunk))) {
+          state.modal.onYes();
+          state.modal = null;
+          render();
+        } else if (key.name === "escape" || (chunk && /^[nN]/.test(chunk)) || key.name === "return") {
+          state.modal.onNo?.();
+          state.modal = null;
+          render();
+        }
+        return;
+      }
+
+      // Invite input mode
+      if (state.inviteMode) {
+        if (key.name === "escape") {
+          state.inviteMode = false;
+          state.inviteUsername = "";
+          state.inviteInst = null;
+          render();
+          return;
+        }
+        if (key.name === "return") {
+          const username = state.inviteUsername.trim();
+          const inst = state.inviteInst;
+          if (!username || !inst) {
+            state.inviteMode = false;
+            state.inviteUsername = "";
+            state.inviteInst = null;
+            render();
+            return;
+          }
+          cleanup();
+          resolve(inviteToInstance(inst, username));
+          return;
+        }
+        if (key.name === "backspace") {
+          state.inviteUsername = state.inviteUsername.slice(0, -1);
+          render();
+          return;
+        }
+        if (chunk && chunk.length === 1 && chunk.charCodeAt(0) >= 32 && !key.ctrl && !key.meta) {
+          state.inviteUsername += chunk;
+          render();
+          return;
+        }
+        return;
+      }
+
+      // Filter mode
+      if (state.filterMode) {
+        if (key.name === "escape") {
+          state.filter = "";
+          state.filterMode = false;
+          clampCursor();
+          render();
+          return;
+        }
+        if (key.name === "return") {
+          state.filterMode = false;
+          render();
+          return;
+        }
+        if (key.name === "backspace") {
+          state.filter = state.filter.slice(0, -1);
+          clampCursor();
+          render();
+          return;
+        }
+        if (chunk && chunk.length === 1 && chunk.charCodeAt(0) >= 32 && !key.ctrl && !key.meta) {
+          state.filter += chunk;
+          state.cursor = 0;
+          render();
+          return;
+        }
+        return;
+      }
+
+      // Normal mode
+      if (key.ctrl && key.name === "c") { cleanup(); process.exit(130); }
+      if (key.name === "q" || key.name === "escape") {
+        if (state.filter) {
+          state.filter = "";
+          clampCursor();
+          render();
+          return;
+        }
+        cleanup();
+        resolve();
+        return;
+      }
+      if (key.name === "up" || (key.ctrl && key.name === "p") || key.name === "k") {
+        const v = visible();
+        if (v.length > 0) state.cursor = (state.cursor - 1 + v.length) % v.length;
+        render();
+        return;
+      }
+      if (key.name === "down" || (key.ctrl && key.name === "n") || key.name === "j") {
+        const v = visible();
+        if (v.length > 0) state.cursor = (state.cursor + 1) % v.length;
+        render();
+        return;
+      }
+      if (key.name === "pageup") {
+        const v = visible();
+        if (v.length > 0) state.cursor = Math.max(0, state.cursor - 10);
+        render();
+        return;
+      }
+      if (key.name === "pagedown") {
+        const v = visible();
+        if (v.length > 0) state.cursor = Math.min(v.length - 1, state.cursor + 10);
+        render();
+        return;
+      }
+      if (key.name === "home" || (key.shift && key.name === "g")) {
+        state.cursor = 0;
+        render();
+        return;
+      }
+      if (key.name === "end" || chunk === "G") {
+        const v = visible();
+        if (v.length > 0) state.cursor = v.length - 1;
+        render();
+        return;
+      }
+      if (key.name === "return") {
+        const v = visible();
+        const picked = v[state.cursor];
+        if (picked?.action === "new") {
+          cleanup();
+          resolve(setupNewEgregore(args.runtimeOverride));
+          return;
+        }
+        const pick = picked?.e;
+        if (!pick) return;
+        if (args.runtimeOverride) {
+          cleanup();
+          resolve(launch(pick, args.runtimeOverride)); // replaces process
+          return;
+        }
+        state.runtimeInst = pick;
+        state.runtimeCursor = 0;
+        render();
+        return;
+      }
+      if (chunk === "/") {
+        state.filterMode = true;
+        render();
+        return;
+      }
+      if (chunk === "n" || chunk === "+") {
+        cleanup();
+        resolve(setupNewEgregore(args.runtimeOverride));
+        return;
+      }
+      if (chunk === "i") {
+        const pick = visible()[state.cursor]?.e;
+        if (!pick) return;
+        state.inviteMode = true;
+        state.inviteUsername = "";
+        state.inviteInst = pick;
+        render();
+        return;
+      }
+      if (chunk === "u") {
+        const pick = visible()[state.cursor]?.e;
+        if (!pick) return;
+        writeDefault(pick.slug);
+        flashMessage(`default set to ${BOLD}${pick.slug}${RESET}`, "success");
+        return;
+      }
+      if (chunk === "r") {
+        const pick = visible()[state.cursor]?.e;
+        if (!pick) return;
+        state.modal = {
+          type: "remove",
+          inst: pick,
+          onYes: () => {
+            const bak = backupRegistry();
+            registry = registry.filter((e) => e.path !== pick.path);
+            writeRegistry(registry);
+            previewCache.delete(pick.path);
+            clampCursor();
+            flashMessage(`removed ${BOLD}${pick.slug}${RESET} · backup: ${path.basename(bak)}`, "success");
+          },
+        };
+        render();
+        return;
+      }
+      if (chunk === "p") {
+        const stale = registry.filter((e) => !fs.existsSync(e.path));
+        if (stale.length === 0) {
+          flashMessage(`registry is clean — all ${registry.length} paths exist.`, "success");
+          return;
+        }
+        state.modal = {
+          type: "prune",
+          count: stale.length,
+          onYes: () => {
+            const bak = backupRegistry();
+            registry = registry.filter((e) => fs.existsSync(e.path));
+            writeRegistry(registry);
+            clampCursor();
+            flashMessage(`pruned ${stale.length} · ${registry.length} remain · backup: ${path.basename(bak)}`, "success");
+          },
+        };
+        render();
+        return;
+      }
+      if (chunk === "?") {
+        state.showHelp = !state.showHelp;
+        render();
+        return;
+      }
+    });
+
+    render();
+  });
+}
+
+// ── non-TTY fallback picker ─────────────────────────────────────────
+
+async function numberedPicker(registry, runtimeOverride) {
+  const def = readDefault();
+  console.log("");
+  console.log(`  Multiple egregores installed. Pick one:\n`);
+  for (let i = 0; i < registry.length; i++) {
+    const inst = registry[i];
+    const marker = inst.slug === def ? `${GREEN}●${RESET}` : " ";
+    console.log(`  ${marker} ${String(i + 1).padStart(2, " ")}) ${BOLD}${pad(inst.slug, 22)}${RESET}  ${pad(inst.name || "", 24)}`);
+  }
+  console.log("");
+  process.stdout.write("  Enter number or slug: ");
+  const buf = Buffer.alloc(256);
+  const n = fs.readSync(0, buf, 0, 256, null);
+  const ans = buf.slice(0, n).toString().trim();
+  if (!ans) die("no selection");
+  const idx = parseInt(ans, 10);
+  if (!isNaN(idx) && idx >= 1 && idx <= registry.length) return launch(registry[idx - 1], runtimeOverride);
+  const hit = resolveBySlug(registry, ans);
+  if (hit) return launch(hit, runtimeOverride);
+  die(`no instance matching '${ans}'`);
+}
+
+// ── main ────────────────────────────────────────────────────────────
+
+function main() {
+  const parsed = parseRuntimeFlags(process.argv.slice(2));
+  const args = parsed.args;
+  const runtimeOverride = parsed.runtimeOverride;
+
+  const cmd = args[0] || "";
+
+  // Flags
+  if (cmd === "--help" || cmd === "-h" || cmd === "help") return cmdHelp();
+  if (cmd === "--version" || cmd === "-V" || cmd === "version") {
+    console.log(`egregore ${VERSION}`);
+    return;
+  }
+
+  // Non-interactive subcommands
+  if (cmd === "ls" || cmd === "list") return cmdLs();
+  if (cmd === "use") return cmdUse(args[1]);
+  if (cmd === "/invite" || cmd === "invite") return cmdInvite(args.slice(1));
+  if (cmd === "prune") return cmdPruneNonInteractive(args[1] === "--dry-run" || args[1] === "-n");
+  if (cmd === "rm" || cmd === "remove") return cmdRmNonInteractive(args[1]);
+  if (cmd === "browse") return browser({ force: true, runtimeOverride });
+
+  // Anything starting with `-` that we didn't handle is unknown
+  if (cmd.startsWith("-")) die(`unknown flag: ${cmd}\n  run: egregore help`);
+
+  const registry = readRegistry();
+  if (registry.length === 0) {
+    if (canPrompt()) return setupNewEgregore(runtimeOverride);
+    die("no egregores installed yet.\n  run: npx -y create-egregore@latest");
+  }
+
+  // Direct slug/name match fast path
+  if (cmd) {
+    const hit = resolveBySlug(registry, cmd);
+    if (!hit) die(`no instance matching '${cmd}'. run: egregore ls`);
+    return launch(hit, runtimeOverride);
+  }
+
+  // No args — in an interactive terminal, always keep the styled command
+  // surface visible, even when only one instance is registered.
+  if (canPrompt()) {
+    return browser({ runtimeOverride });
+  }
+
+  // Non-interactive fallback keeps old default/single-instance semantics.
+  const def = readDefault();
+  if (def) {
+    const hit = registry.find((e) => e.slug === def);
+    if (hit) return launch(hit, runtimeOverride);
+  }
+  if (registry.length === 1) return launch(registry[0], runtimeOverride);
+
+  // Multi-instance, no default — open the browser (TTY) or numbered picker (non-TTY).
+  return browser({ runtimeOverride });
+}
+
+try {
+  const r = main();
+  if (r && typeof r.then === "function") {
+    r.catch((err) => die(err.message || String(err)));
+  }
+} catch (err) {
+  die(err.message || String(err));
+}