create-egregore 0.19.5 → 0.19.6

package/assets/egregore-launcher.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// egregore-launcher-version: 0.6.0
+// egregore-launcher-version: 0.7.1
 //
 // egregore — launch and browse Egregore instances from your terminal.
 // Installed by create-egregore. Reads ~/.egregore/instances.json.
@@ -14,6 +14,7 @@
 //   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 settings [slug]    hosting on/off, managed repos, admins (s in browser)
 //   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
@@ -30,7 +31,7 @@ const https = require("node:https");
 const { spawnSync, spawn } = require("node:child_process");
 const readline = require("node:readline");
 
-const VERSION = "0.6.0";
+const VERSION = "0.7.1";
 const REGISTRY = path.join(os.homedir(), ".egregore", "instances.json");
 const DEFAULT_FILE = path.join(os.homedir(), ".egregore", "default");
 const PUBLIC_NPX_PACKAGE = "create-egregore";
@@ -345,6 +346,7 @@ function normalizeRuntime(raw) {
   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";
+  if (value === "pi" || value === "pi-coding-agent" || value === "pi_coding_agent") return "pi";
   return null;
 }
 
@@ -355,6 +357,8 @@ function parseRuntimeFlags(argv) {
     const arg = argv[i];
     if (arg === "--codex") {
       runtimeOverride = "codex";
+    } else if (arg === "--pi") {
+      runtimeOverride = "pi";
     } else if (arg === "--claude" || arg === "--claude-code") {
       runtimeOverride = "claude-code";
     } else if (arg === "--runtime") {
@@ -368,7 +372,7 @@ function parseRuntimeFlags(argv) {
     }
   }
   const normalized = runtimeOverride ? normalizeRuntime(runtimeOverride) : null;
-  if (runtimeOverride && !normalized) die(`unknown runtime: ${runtimeOverride}\n  expected claude-code or codex`);
+  if (runtimeOverride && !normalized) die(`unknown runtime: ${runtimeOverride}\n  expected claude-code, codex, or pi`);
   return { args: rest, runtimeOverride: normalized };
 }
 
@@ -385,21 +389,32 @@ function runtimeFor(inst, runtimeOverride) {
 }
 
 function runtimeLabel(runtime) {
-  return runtime === "codex" ? "Codex" : "Claude Code";
+  if (runtime === "codex") return "Codex";
+  if (runtime === "pi") return "Pi";
+  return "Claude Code";
 }
 
 function runtimeShort(runtime) {
-  return runtime === "codex" ? "codex" : "claude-code";
+  return runtime === "codex" ? "codex" : runtime === "pi" ? "pi" : "claude-code";
 }
 
 function runtimeBinary(runtime) {
-  return runtime === "codex" ? "codex" : "claude";
+  return runtime === "codex" ? "codex" : runtime === "pi" ? "pi" : "claude";
 }
 
 function assistantInstallCommand(runtime) {
-  return runtime === "codex"
-    ? "npm install -g @openai/codex"
-    : "npm install -g @anthropic-ai/claude-code";
+  if (runtime === "codex") return "npm install -g @openai/codex";
+  if (runtime === "pi") return "npm install -g --ignore-scripts @earendil-works/pi-coding-agent";
+  return "npm install -g @anthropic-ai/claude-code";
+}
+
+function piTrustArgs() {
+  try {
+    const help = spawnSync("pi", ["--help"], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+    return `${help.stdout || ""}\n${help.stderr || ""}`.includes("--approve") ? ["--approve"] : [];
+  } catch {
+    return [];
+  }
 }
 
 function commandExists(bin) {
@@ -410,13 +425,12 @@ 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";
+    return `not installed · install ${runtimeLabel(runtime)}, then run egregore`;
   }
   bits.push("installed");
   if (runtime === stored) bits.push("saved default");
   if (runtime === "codex") bits.push("portable agent protocol");
+  else if (runtime === "pi") bits.push("project-local meta-harness");
   else bits.push("Claude Code integration");
   return bits.join(" · ");
 }
@@ -439,7 +453,7 @@ function runtimePickerLines(inst, runtimes, stored, cursor) {
     lines.push(`  ${marker} ${BOLD}${label}${RESET}  ${DIM}${desc}${RESET}`);
   }
   // Coming-soon harnesses — shown for visibility, not selectable yet.
-  for (const soon of ["Hermes", "Pi"]) {
+  for (const soon of ["Hermes"]) {
     lines.push(`  ${DIM}· ${pad(soon, labelWidth)}  coming soon${RESET}`);
   }
   lines.push("");
@@ -529,9 +543,7 @@ 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"];
+  const choices = [stored, ...["claude-code", "codex", "pi"].filter((runtime) => runtime !== stored)];
   return choices.sort((a, b) => Number(commandExists(runtimeBinary(b))) - Number(commandExists(runtimeBinary(a))));
 }
 
@@ -637,6 +649,25 @@ function hasCodexCoreSupport(egregoreDir) {
   );
 }
 
+function hasPiCoreSupport(egregoreDir) {
+  return (
+    fs.existsSync(path.join(egregoreDir, "bin", "pi-session-start.sh")) &&
+    fs.existsSync(path.join(egregoreDir, ".pi", "APPEND_SYSTEM.md")) &&
+    fs.existsSync(path.join(egregoreDir, ".pi", "settings.json")) &&
+    fs.existsSync(path.join(egregoreDir, ".pi", "extensions", "egregore.ts")) &&
+    fs.existsSync(path.join(egregoreDir, ".codex", "skills"))
+  );
+}
+
+function piSupportMessage(egregoreDir) {
+  return [
+    "Pi meta-harness support is missing from this Egregore checkout.",
+    `  path: ${egregoreDir}`,
+    "",
+    "Run npx -y create-egregore@latest to install the packaged Pi runtime, then rerun egregore.",
+  ].join("\n");
+}
+
 function installCodexSkills(egregoreDir) {
   const script = path.join(egregoreDir, "bin", "codex-install-skills.sh");
   if (!fs.existsSync(script)) return false;
@@ -662,6 +693,7 @@ function runtimeLaunchArgs(runtime, egregoreDir) {
       "--cd", egregoreDir,
     ];
   }
+  if (runtime === "pi") return piTrustArgs();
   return ["start"];
 }
 
@@ -695,6 +727,8 @@ async function launch(inst, runtimeOverride) {
     if (!skillsInstalled || !cardRendered) {
       die(codexSupportMessage(inst.path));
     }
+  } else if (runtime === "pi") {
+    if (!hasPiCoreSupport(inst.path)) die(piSupportMessage(inst.path));
   }
   // Replace the current process with the selected assistant in the instance dir.
   // spawn + detached + exit-on-exit replicates exec() in Node.
@@ -822,10 +856,12 @@ function cmdHelp() {
     `    ${CYAN}egregore${RESET}                     pick an instance, then pick a harness`,
     `    ${CYAN}egregore${RESET} ${DIM}<slug|name>${RESET}         pick a harness for the matching instance`,
     `    ${CYAN}egregore --runtime${RESET} ${DIM}<name> <slug>${RESET}  advanced harness override`,
+    `      ${DIM}names: claude-code · codex · pi${RESET}`,
     `    ${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 settings${RESET} ${DIM}[slug]${RESET}      hosting on/off, repos, admins`,
     `    ${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`,
     ``,
@@ -836,6 +872,7 @@ function cmdHelp() {
     `    ${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}s${RESET}           settings (hosting on/off, repos, admins)`,
     `    ${DIM}d${RESET}           delete selected entry (offers cleanup of ${RED}✗${RESET} missing ones)`,
     `    ${DIM}?${RESET}           toggle help overlay`,
     `    ${DIM}q${RESET}           quit browser (esc goes back — it never quits)`,
@@ -1251,6 +1288,343 @@ async function cmdInvite(args) {
   return inviteToInstance(inst, username);
 }
 
+// ── settings ───────────────────────────────────────────────────────
+//
+// The launcher stays a THIN caller: every config change shells out to the
+// instance's deterministic `bin/settings.sh` verbs (one source of truth, no
+// JS reimplementation to drift from the script). This is the reliability point
+// — the correctness lives in the tested script; the screen below just drives it.
+
+function settingsScriptPath(inst) {
+  return path.join(inst.path, "bin", "settings.sh");
+}
+
+function runSettings(inst, args) {
+  const script = settingsScriptPath(inst);
+  if (!fs.existsSync(script)) {
+    return { status: 127, stdout: "", stderr: "bin/settings.sh not found — update this egregore (run /pull) to get settings.\n", missing: true };
+  }
+  try {
+    return spawnSync("bash", [script, ...args], { cwd: inst.path, stdio: "pipe", encoding: "utf-8", timeout: 15000 });
+  } catch (err) {
+    return { status: 1, stdout: "", stderr: String(err) };
+  }
+}
+
+function settingsDump(inst) {
+  const r = runSettings(inst, ["dump"]);
+  if (!r || r.status !== 0) return null;
+  try { return JSON.parse(r.stdout); } catch { return null; }
+}
+
+// Nested raw-mode list editor for a domain (repo | admin | people): hover an
+// item and press `d` to remove it, `a` to open an inline add field, esc to go
+// back. Mirrors the main browser's affordances. Its own raw-mode loop; resolves
+// when the user backs out. Each mutation is ONE deterministic settings.sh verb;
+// validation, the last-admin guard, and GitHub-access notes surface as notices.
+function listEditor(inst, domain, label) {
+  const fieldFor = (d) => {
+    if (domain === "repo") return (d.repos || []).map((r) => r.name || r);
+    if (domain === "admin") return d.admins || [];
+    return d.people || [];
+  };
+  const noun = domain === "repo" ? "repo name" : "github handle";
+
+  return new Promise((resolve) => {
+    let items = fieldFor(settingsDump(inst) || {});
+    let cursor = 0;
+    let mode = "browse"; // browse | add | confirm
+    let input = "";
+    let notice = "";
+    let rendered = 0;
+    let done = false;
+    const previousRaw = !!process.stdin.isRaw;
+    const isMouseEvent = makeMouseFilter();
+
+    const refresh = () => {
+      items = fieldFor(settingsDump(inst) || {});
+      if (cursor >= items.length) cursor = Math.max(0, items.length - 1);
+    };
+
+    const erase = () => {
+      if (!rendered) return;
+      process.stdout.write(`\x1b[${rendered}A` + ANSI.clearDown);
+      rendered = 0;
+    };
+
+    const buildLines = () => {
+      const out = [];
+      out.push(``);
+      out.push(`  ${BOLD}${label}${RESET}`);
+      out.push(`  ${DIM}────────────────────────────────────────${RESET}`);
+      if (items.length === 0) {
+        out.push(`    ${DIM}(none)${RESET}`);
+      } else {
+        items.forEach((it, i) => {
+          const sel = i === cursor;
+          out.push(`  ${sel ? CYAN + "❯" + RESET : " "} ${sel ? BOLD + it + RESET : it}`);
+        });
+      }
+      out.push(``);
+      if (notice) out.push(`  ${notice}`);
+      if (mode === "add") {
+        out.push(`  ${CYAN}add ${noun}:${RESET} ${input}${CYAN}▌${RESET}  ${DIM}enter save · esc cancel${RESET}`);
+      } else if (mode === "confirm") {
+        out.push(`  ${YELLOW}remove ${items[cursor]}?${RESET} ${DIM}y / N${RESET}`);
+      } else {
+        out.push(`  ${DIM}↑↓ nav · ${RESET}${BOLD}a${RESET}${DIM} add · ${RESET}${BOLD}d${RESET}${DIM} delete · esc back${RESET}`);
+      }
+      return out;
+    };
+
+    const render = () => {
+      erase();
+      const lines = buildLines();
+      rendered = lines.length;
+      process.stdout.write(lines.map((l) => l + ANSI.clearLine).join("\n") + "\n");
+    };
+
+    const cleanup = () => {
+      if (done) return;
+      done = true;
+      process.stdin.removeListener("keypress", onKey);
+      process.stdout.write(ANSI.mouseOff);
+      if (process.stdin.setRawMode) process.stdin.setRawMode(previousRaw);
+      if (!previousRaw) process.stdin.pause();
+      erase();
+    };
+
+    // Run a verb (spawnSync blocks briefly — people ops hit GitHub). Surface the
+    // last stdout/stderr line as a notice; refresh the list from disk after.
+    const runVerb = (args) => {
+      const r = runSettings(inst, args);
+      const msg = ((r.stdout || "") + " " + (r.stderr || "")).trim().split("\n").map((s) => s.trim()).filter(Boolean).pop() || "";
+      notice = r && r.status === 0 ? msg : `${YELLOW}${msg}${RESET}`;
+      refresh();
+    };
+
+    function onKey(chunk, key = {}) {
+      if (isMouseEvent(chunk, key)) return;
+      if (key.ctrl && key.name === "c") { cleanup(); process.exit(130); }
+
+      if (mode === "add") {
+        if (key.name === "escape") { mode = "browse"; input = ""; render(); return; }
+        if (key.name === "return") {
+          const v = input.trim().split(/\s+/)[0];
+          mode = "browse"; input = "";
+          if (v) runVerb([domain, "add", v]);
+          render();
+          return;
+        }
+        if (key.name === "backspace") { input = input.slice(0, -1); render(); return; }
+        if (chunk && chunk.length === 1 && chunk >= " " && !key.ctrl && !key.meta) { input += chunk; render(); return; }
+        return;
+      }
+
+      if (mode === "confirm") {
+        if (chunk === "y" || chunk === "Y") {
+          const victim = items[cursor];
+          mode = "browse";
+          if (victim) runVerb([domain, "remove", victim]);
+        } else { mode = "browse"; }
+        render();
+        return;
+      }
+
+      // browse
+      if (key.name === "escape" || key.name === "left") { cleanup(); resolve(); return; }
+      if (key.name === "up" || key.name === "k") { if (items.length) cursor = (cursor - 1 + items.length) % items.length; render(); return; }
+      if (key.name === "down" || key.name === "j") { if (items.length) cursor = (cursor + 1) % items.length; render(); return; }
+      if (chunk === "a") { mode = "add"; input = ""; notice = ""; render(); return; }
+      if (chunk === "d") { if (items.length) { mode = "confirm"; render(); } return; }
+    }
+
+    readline.emitKeypressEvents(process.stdin);
+    if (process.stdin.setRawMode) process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdout.write(ANSI.mouseOff);
+    process.stdin.on("keypress", onKey);
+    render();
+  });
+}
+
+// The `s`-key settings screen: a raw-mode menu (hosting toggle + repo/admin
+// editors) over bin/settings.sh. Modeled on pickRuntimeInteractive.
+function settingsScreen(inst) {
+  const title = inst.slug || inst.name || path.basename(inst.path);
+
+  if (!fs.existsSync(settingsScriptPath(inst))) {
+    console.log(`\n  ${YELLOW}Settings unavailable${RESET} — ${BOLD}${title}${RESET} has no ${DIM}bin/settings.sh${RESET}.`);
+    console.log(`  Update it: open the egregore and run ${CYAN}/pull${RESET}.\n`);
+    return Promise.resolve();
+  }
+
+  let data = settingsDump(inst) || { hosting: true, repos: [], admins: [], people: [] };
+
+  const rows = [
+    {
+      label: () => `Hosted Artifacts`,
+      value: () => (data.hosting ? `${GREEN}ON${RESET}` : `${YELLOW}OFF${RESET}`),
+      detailLines: () => [data.hosting
+        ? `    ${DIM}Enter toggles. When OFF, artifacts never upload to egregore.xyz.${RESET}`
+        : `    ${DIM}Artifacts stay local. /view still renders them on localhost.${RESET}`],
+    },
+    {
+      label: () => `Managed repos`,
+      value: () => `${DIM}${data.repos.length}${RESET}`,
+      detailLines: () => data.repos.length
+        ? data.repos.map((r) => `    ${DIM}·${RESET} ${r.name || r}`)
+        : [`    ${DIM}(none)${RESET}`],
+    },
+    {
+      label: () => `Admins`,
+      value: () => `${DIM}${data.admins.length}${RESET}`,
+      detailLines: () => data.admins.length
+        ? [`    ${DIM}${data.admins.join(", ")}${RESET}`]
+        : [`    ${DIM}(none)${RESET}`],
+    },
+    {
+      label: () => `People`,
+      value: () => `${DIM}${(data.people || []).length}${RESET}`,
+      detailLines: () => (data.people && data.people.length)
+        ? [`    ${DIM}${data.people.join(", ")}${RESET}`]
+        : [`    ${DIM}(none)${RESET}`],
+    },
+  ];
+
+  return new Promise((resolve) => {
+    let cursor = 0;
+    let rendered = 0;
+    let done = false;
+    let notice = "";
+    const previousRaw = !!process.stdin.isRaw;
+    const isMouseEvent = makeMouseFilter();
+
+    const erase = () => {
+      if (!rendered) return;
+      // Move to the TOP of the last-rendered block, then wipe everything below
+      // in one shot. Clearing line-by-line leaves the cursor at the BOTTOM, so
+      // the next redraw starts a row lower each time — that's the drift that
+      // pushes blank "margins" on top. Up-N + clearDown returns to the top and
+      // clears cleanly, so every render repaints in place.
+      process.stdout.write(`\x1b[${rendered}A` + ANSI.clearDown);
+      rendered = 0;
+    };
+
+    const buildLines = () => {
+      const out = [];
+      out.push(``);
+      out.push(`  ${BOLD}Settings${RESET} ${DIM}·${RESET} ${BOLD}${title}${RESET}`);
+      out.push(`  ${DIM}────────────────────────────────────────${RESET}`);
+      rows.forEach((row, i) => {
+        const sel = i === cursor;
+        const marker = sel ? `${CYAN}❯${RESET}` : ` `;
+        const name = sel ? `${BOLD}${row.label()}${RESET}` : row.label();
+        out.push(`  ${marker} ${name}   ${row.value()}`);
+        if (sel) for (const dl of row.detailLines()) out.push(dl);
+      });
+      out.push(``);
+      if (notice) out.push(`  ${notice}`);
+      out.push(`  ${DIM}↑↓ nav · enter ${cursor === 0 ? "toggle" : "edit"} · esc back · q quit${RESET}`);
+      return out;
+    };
+
+    const render = () => {
+      erase();
+      const lines = buildLines();
+      rendered = lines.length;
+      process.stdout.write(lines.map((l) => l + ANSI.clearLine).join("\n") + "\n");
+    };
+
+    const teardownRaw = () => {
+      process.stdin.removeListener("keypress", onKey);
+      process.stdout.write(ANSI.mouseOff);
+      if (process.stdin.setRawMode) process.stdin.setRawMode(previousRaw);
+      if (!previousRaw) process.stdin.pause();
+    };
+
+    const setupRaw = () => {
+      readline.emitKeypressEvents(process.stdin);
+      if (process.stdin.setRawMode) process.stdin.setRawMode(true);
+      process.stdin.resume();
+      process.stdout.write(ANSI.mouseOff);
+      process.stdin.on("keypress", onKey);
+    };
+
+    const cleanup = () => {
+      if (done) return;
+      done = true;
+      teardownRaw();
+      erase();
+    };
+
+    const toggleHosting = () => {
+      const r = runSettings(inst, ["hosting", data.hosting ? "off" : "on"]);
+      if (!r || r.status !== 0) {
+        notice = `${YELLOW}${((r && r.stderr) || "could not change hosting").trim().split("\n")[0]}${RESET}`;
+      } else {
+        data = settingsDump(inst) || data;
+        notice = `hosting ${data.hosting ? `${GREEN}ON${RESET}` : `${YELLOW}OFF${RESET}`}`;
+      }
+      render();
+    };
+
+    // Hand off to the nested raw-mode list editor, then repaint this screen with
+    // refreshed counts when the user backs out.
+    const openList = (domain, label) => {
+      erase();
+      teardownRaw();
+      listEditor(inst, domain, label).then(() => {
+        data = settingsDump(inst) || data;
+        notice = "";
+        setupRaw();
+        render();
+      });
+    };
+
+    function onKey(chunk, key = {}) {
+      if (isMouseEvent(chunk, key)) return;
+      if (key.ctrl && key.name === "c") { cleanup(); process.exit(130); }
+      if (key.name === "q") { cleanup(); resolve(); return; }
+      // Esc / ← = back (esc never quits).
+      if (key.name === "escape" || key.name === "left") { cleanup(); resolve(); return; }
+      if (key.name === "up" || key.name === "k") { cursor = (cursor - 1 + rows.length) % rows.length; render(); return; }
+      if (key.name === "down" || key.name === "j") { cursor = (cursor + 1) % rows.length; render(); return; }
+      if (key.name === "return" || chunk === " ") {
+        if (cursor === 0) toggleHosting();
+        else if (cursor === 1) openList("repo", "Managed repos");
+        else if (cursor === 2) openList("admin", "Admins");
+        else if (cursor === 3) openList("people", "People");
+      }
+    }
+
+    setupRaw();
+    render();
+  });
+}
+
+async function cmdSettings(args) {
+  const registry = readRegistry();
+  if (registry.length === 0) die("no egregores installed yet.\n  run: npx -y create-egregore@latest");
+  const DOMAINS = new Set(["hosting", "repo", "admin", "people", "dump"]);
+  let rest = args.slice();
+  let slug = "";
+  if (rest.length && !DOMAINS.has(rest[0])) { slug = rest[0]; rest = rest.slice(1); }
+  const inst = resolveInviteInstance(registry, slug);
+  if (!inst) {
+    die(`multiple egregores installed; choose one:\n  egregore settings <slug> [hosting|repo|admin]\n  run: egregore ls`);
+  }
+  // No verb + a TTY → interactive screen. Otherwise forward straight to the verb.
+  if (rest.length === 0) {
+    if (isTTY && canPrompt()) return settingsScreen(inst);
+    rest = ["dump"];
+  }
+  const r = runSettings(inst, rest);
+  if (r.stdout) process.stdout.write(r.stdout.endsWith("\n") ? r.stdout : r.stdout + "\n");
+  if (r.stderr) process.stderr.write(r.stderr);
+  process.exitCode = r.status || 0;
+}
+
 // ── tiny sync confirm (non-TUI flows) ───────────────────────────────
 
 function syncConfirm(question) {
@@ -1370,7 +1744,7 @@ function renderHeroPanel({ selected, pv, width, height, countSuffix, filter, fil
       ? `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 skillStatus = `Codex ${nativeCount} native · ${adapterCount} adapter · Pi ${skillsCount} shared · Claude ${claudeCount}`;
   const skillGroups = [
     `${DIM}core${RESET}: ${workflows}`,
     `${DIM}team${RESET}: ${joinShort(["/handoff", "/ask", "/invite", "/quest"], Math.max(16, bodyWidth - 8))}`,
@@ -1411,8 +1785,8 @@ function renderHeroPanel({ selected, pv, width, height, countSuffix, filter, fil
       `${BOLD}Harnesses${RESET}`,
       `${DIM}claude-code${RESET}: ${commandExists("claude") ? "installed" : "not installed"}`,
       `${DIM}codex${RESET}: ${commandExists("codex") ? "installed" : "not installed"}`,
+      `${DIM}pi${RESET}: ${commandExists("pi") ? "installed" : "not installed"}`,
       `${DIM}Hermes — Coming Soon${RESET}`,
-      `${DIM}Pi — Coming Soon${RESET}`,
     ];
     const rows = Math.max(EGREGORE_SIGIL.length + 2, right.length);
     for (let i = 0; i < rows; i++) {
@@ -1424,11 +1798,11 @@ function renderHeroPanel({ selected, pv, width, height, countSuffix, filter, fil
     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}Harnesses${RESET} ${DIM}claude-code${RESET} ${commandExists("claude") ? "installed" : "missing"} · ${DIM}codex${RESET} ${commandExists("codex") ? "installed" : "missing"} · ${DIM}Hermes/Pi — Coming Soon${RESET}`, innerWidth, margin));
+    lines.push(boxLine(`${BOLD}Harnesses${RESET} ${DIM}claude-code${RESET} ${commandExists("claude") ? "installed" : "missing"} · ${DIM}codex${RESET} ${commandExists("codex") ? "installed" : "missing"} · ${DIM}pi${RESET} ${commandExists("pi") ? "installed" : "missing"} · ${DIM}Hermes — Coming Soon${RESET}`, 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(boxLine(`${DIM}enter selects an instance, then choose Claude Code, Codex, or Pi without leaving this screen${RESET}`, innerWidth, margin));
   lines.push(bottom);
   return lines;
 }
@@ -1461,7 +1835,7 @@ function renderRuntimePanel({ inst, cursor, width, height }) {
     lines.push(boxLine(`${marker} ${pad(labelText, 16)} ${DIM}${desc}${RESET}`, innerWidth, margin));
   }
   // Coming-soon harnesses — shown for visibility, not selectable yet.
-  for (const soon of ["Hermes", "Pi"]) {
+  for (const soon of ["Hermes"]) {
     lines.push(boxLine(`${DIM}· ${pad(soon, 16)}  coming soon${RESET}`, innerWidth, margin));
   }
 
@@ -1674,7 +2048,7 @@ async function browser(args = {}) {
       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("harness")} choose Claude Code or Codex during setup`);
+      previewLines.push(`  ${label("harness")} choose Claude Code, Codex, or Pi during setup`);
       previewLines.push(`  ${label("start")} press enter to begin`);
     } else if (!selected) {
       previewLines.push(`${DIM}  (no selection)${RESET}`);
@@ -1697,7 +2071,7 @@ async function browser(args = {}) {
       if (pv.skills) {
         const skillLine = selectedWorkflowLine(pv, Math.max(16, blockWidth - 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}`);
+        previewLines.push(`  ${label("skills")} Codex ${BOLD}${pv.skills.native.length}${RESET} native + ${BOLD}${pv.skills.adapterCount}${RESET} adapters; Pi ${BOLD}${pv.skills.names.length}${RESET} shared; Claude ${BOLD}${pv.skills.claudeCount || 0}${RESET}`);
       }
       const modeBits = [];
       modeBits.push(runtimeShort(runtimeFor(selected, args.runtimeOverride)));
@@ -1757,8 +2131,8 @@ async function browser(args = {}) {
       footer = band(`● ${stripAnsi(state.message)}`, bg);
     } else {
       footer = blockWidth < 96
-        ? band(`${key("↑↓", "nav")}  ${key("enter", "select")}  ${key("n/+", "new")}  ${key("i", "invite")}  ${key("d", "delete")}  ${key("?", "help")}  ${key("q", "quit")}`, 46)
-        : band(`${key("↑↓", "nav")}  ${key("enter", "select")}  ${key("n/+", "new")}  ${key("/", "filter")}  ${key("i", "invite")}  ${key("u", "default")}  ${key("d", "delete")}  ${key("?", "help")}  ${key("q", "quit")}`, 46);
+        ? band(`${key("↑↓", "nav")}  ${key("enter", "select")}  ${key("n/+", "new")}  ${key("i", "invite")}  ${key("s", "settings")}  ${key("d", "delete")}  ${key("?", "help")}  ${key("q", "quit")}`, 46)
+        : band(`${key("↑↓", "nav")}  ${key("enter", "select")}  ${key("n/+", "new")}  ${key("/", "filter")}  ${key("i", "invite")}  ${key("s", "settings")}  ${key("u", "default")}  ${key("d", "delete")}  ${key("?", "help")}  ${key("q", "quit")}`, 46);
     }
     out.push(M + footer + "\n");
     if (state.showHelp) {
@@ -2056,6 +2430,13 @@ async function browser(args = {}) {
         render();
         return;
       }
+      if (chunk === "s") {
+        const pick = visible()[state.cursor]?.e;
+        if (!pick) return;
+        cleanup();
+        resolve(settingsScreen(pick));
+        return;
+      }
       if (chunk === "u") {
         const pick = visible()[state.cursor]?.e;
         if (!pick) return;
@@ -2174,6 +2555,7 @@ function main() {
   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 === "settings" || cmd === "config") return cmdSettings(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 });