create-egregore 0.18.18 → 0.19.0

package/assets/egregore-launcher.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// egregore-launcher-version: 0.5.27
+// egregore-launcher-version: 0.6.0
 //
 // egregore — launch and browse Egregore instances from your terminal.
 // Installed by create-egregore. Reads ~/.egregore/instances.json.
@@ -30,7 +30,7 @@ const https = require("node:https");
 const { spawnSync, spawn } = require("node:child_process");
 const readline = require("node:readline");
 
-const VERSION = "0.5.27";
+const VERSION = "0.6.0";
 const REGISTRY = path.join(os.homedir(), ".egregore", "instances.json");
 const DEFAULT_FILE = path.join(os.homedir(), ".egregore", "default");
 const PUBLIC_NPX_PACKAGE = "create-egregore";
@@ -424,7 +424,7 @@ function runtimePickerLines(inst, runtimes, stored, cursor) {
   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`,
+    `  ${DIM}↑↓${RESET} navigate · ${DIM}enter${RESET} select · ${DIM}1-${runtimes.length}${RESET} quick select · ${DIM}q${RESET} cancel`,
     `  ${CYAN}◆${RESET} ${BOLD}Launch ${title} with which harness?${RESET}`,
     "",
   ];
@@ -494,7 +494,9 @@ function pickRuntimeInteractive(inst, runtimes, stored) {
         cleanup();
         process.exit(130);
       }
-      if (key.name === "escape" || key.name === "q") return finish(null);
+      // Esc never quits (it reads as "back", and there's nowhere back to go
+      // from here) — q is the only cancel key besides Ctrl+C.
+      if (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();
@@ -832,10 +834,9 @@ 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}r${RESET}           remove selected (with confirm)`,
-    `    ${DIM}p${RESET}           prune entries with missing paths (with confirm)`,
+    `    ${DIM}d${RESET}           delete selected entry (offers cleanup of ${RED}✗${RESET} missing ones)`,
     `    ${DIM}?${RESET}           toggle help overlay`,
-    `    ${DIM}q / esc${RESET}     quit browser`,
+    `    ${DIM}q${RESET}           quit browser (esc goes back — it never quits)`,
     ``,
     `  ${BOLD}REGISTRY${RESET}`,
     `    ${DIM}instances:${RESET} ~/.egregore/instances.json`,
@@ -1463,7 +1464,7 @@ function renderRuntimePanel({ inst, cursor, width, height }) {
   }
 
   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(boxLine(`${DIM}↑↓ navigate · enter select · 1-${runtimes.length} quick select · ← back · q quit${RESET}`, innerWidth, margin));
   lines.push(`${margin}${DIM}└${"─".repeat(innerWidth)}┘${RESET}`);
   return lines;
 }
@@ -1482,6 +1483,15 @@ async function browser(args = {}) {
     return numberedPicker(registry, args.runtimeOverride);
   }
 
+  // Entries whose directory is gone are dead registry rows. They stay listed
+  // (marked ✗ missing) so the problem is visible in place — cleanup is offered
+  // through `d`, never done automatically. Cached per session; refreshed after
+  // every registry mutation instead of stat-ing on each keypress render.
+  let stalePaths = new Set(registry.filter((e) => !fs.existsSync(e.path)).map((e) => e.path));
+  const refreshStale = () => {
+    stalePaths = new Set(registry.filter((e) => !fs.existsSync(e.path)).map((e) => e.path));
+  };
+
   // State
   const state = {
     filter: "",
@@ -1493,7 +1503,7 @@ async function browser(args = {}) {
     runtimeCursor: 0,
     cursor: initialCursorForCwd(registry),
     showHelp: false,
-    modal: null, // { type: "remove" | "prune", onYes, onNo }
+    modal: null, // { type: "remove" | "sweep", onYes, onNo }
     tick: 0,
     message: null, // ephemeral info line (e.g. "default set to X")
     messageKind: "info", // "info" | "success" | "warn"
@@ -1585,7 +1595,10 @@ async function browser(args = {}) {
     out.push(ANSI.clearLine + "\n");
 
     // Layout: list takes top 60%, preview takes rest, footer is last 2 lines
-    const footerRows = 2;
+    // (3 while stale entries exist — the cleanup notice gets its own row so
+    // the layout doesn't jump when modals or messages come and go).
+    const staleCount = stalePaths.size;
+    const footerRows = staleCount > 0 ? 3 : 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));
@@ -1631,13 +1644,21 @@ async function browser(args = {}) {
       void origIdx;
       const isCursor = idx === state.cursor;
       const isDefault = e.slug === def;
+      const isMissing = stalePaths.has(e.path);
       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}`;
+        : (isDefault
+          ? `${BOLD}${pad(e.slug, slugW)}${RESET}`
+          : (isMissing ? `${DIM}${pad(e.slug, slugW)}${RESET}` : pad(e.slug, slugW)));
+      const name = isMissing && !isCursor
+        ? `${DIM}${pad(e.name || "", nameW)}${RESET}`
+        : pad(e.name || "", nameW);
+      const pathAvail = Math.max(0, listAvail - slugW - nameW - 10);
+      const pathDim = isMissing
+        ? `${RED}✗${RESET} ${DIM}${truncate(e.path, Math.max(8, pathAvail - 12))}${RESET} ${RED}(missing)${RESET}`
+        : `${DIM}${truncate(e.path, pathAvail)}${RESET}`;
       const line = ` ${cursorMark} ${defMark}  ${slug}  ${name}  ${pathDim}`;
       out.push(M + " ".repeat(listPad - 3) + line + ANSI.clearLine + "\n");
     }
@@ -1661,7 +1682,9 @@ async function browser(args = {}) {
       // value to blockWidth-15 so every line's right edge lands two cols inside
       // the box border, level with the box inner content (gutter+blockWidth-2).
       const valW = Math.max(16, blockWidth - 15);
-      previewLines.push(`  ${label("path")} ${truncate(selected.path, valW)}`);
+      previewLines.push(stalePaths.has(selected.path)
+        ? `  ${label("path")} ${RED}✗${RESET} ${truncate(selected.path, Math.max(8, valW - 12))} ${RED}(missing)${RESET}`
+        : `  ${label("path")} ${truncate(selected.path, valW)}`);
       if (pv.org) previewLines.push(`  ${label("org")} ${truncate(`${pv.org} ${DIM}(${pv.githubOrg || "?"})${RESET}`, valW)}`);
       if (pv.branch) previewLines.push(`  ${label("branch")} ${BOLD}${pv.branch}${RESET}`);
       if (pv.lastCommit) previewLines.push(`  ${label("last")} ${DIM}${truncate(pv.lastCommit, valW)}${RESET}`);
@@ -1690,32 +1713,54 @@ async function browser(args = {}) {
     // Divider
     out.push(DIM + M + "─".repeat(blockWidth) + RESET + ANSI.clearLine + "\n");
 
-    // Footer
+    // Notice row — persistent while dead entries exist, quiet otherwise. The
+    // row is reserved either way (footerRows above) so toggling modals/filter
+    // doesn't shift the layout.
+    if (staleCount > 0) {
+      const noticeIdle = !state.modal && !state.filterMode && !state.inviteMode;
+      const noun = staleCount === 1 ? "entry points to a missing folder" : "entries point to missing folders";
+      out.push(noticeIdle
+        ? `${M}  ${YELLOW}!${RESET} ${staleCount} ${noun} — ${BOLD}d${RESET} ${DIM}to clean up${RESET}${ANSI.clearLine}\n`
+        : ANSI.clearLine + "\n");
+    }
+
+    // Footer — a status band in the banner's accent color (the terminal's
+    // cyan slot) anchors the keys; the plain dim strip was easy to miss.
+    // Band color doubles as a mode signal: accent = browsing, yellow = a
+    // question needs answering, green = success flash. Input states
+    // (filter, invite) stay unbanded so the caret keeps its contrast.
+    // Content on the band is fg-black with BOLD/UNBOLD only — a RESET
+    // mid-line would kill the background fill.
+    const UNBOLD = E(22);
+    const band = (content, bg) => colorOn
+      ? `${E(bg)}${E(30)}${pad(`  ${content}`, blockWidth)}${RESET}${ANSI.clearLine}`
+      : `  ${stripAnsi(content)}${ANSI.clearLine}`;
+    const key = (k, label) => `${BOLD}${k}${UNBOLD} ${label}`;
     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}`;
+        ? `remove ${BOLD}${m.inst.slug}${UNBOLD}${m.missing ? " (folder missing)" : ""}? [y/N]`
+        : `remove ${BOLD}${m.count}${UNBOLD} ${m.count === 1 ? "entry" : "entries"} with missing folders? [y/N]`;
+      footer = band(`? ${prompt}`, 43);
     } 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}`;
+      footer = band(`${key("?", "toggles this hint")}  ${key("q", "quits")}`, 46);
     } 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}`;
+      const bg = state.messageKind === "success" ? 42 : state.messageKind === "warn" ? 43 : 46;
+      footer = band(`● ${stripAnsi(state.message)}`, bg);
     } else {
       footer = blockWidth < 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}`;
+        ? 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);
     }
     out.push(M + footer + "\n");
     if (state.showHelp) {
-      out.push(`${M}  ${DIM}● default · ❯ cursor · n/+ starts guided setup · i opens /invite${RESET}${ANSI.clearLine}`);
+      out.push(M + band("● default · ❯ cursor · ✗ folder missing · d deletes an entry · esc never quits", 46));
     } else {
       out.push(ANSI.clearLine);
     }
@@ -1788,7 +1833,9 @@ async function browser(args = {}) {
       if (state.runtimeInst) {
         const runtimes = runtimeChoicesFor(state.runtimeInst, args.runtimeOverride);
         if (key.ctrl && key.name === "c") { cleanup(); process.exit(130); }
-        if (key.name === "escape") {
+        // ← is the advertised back key (enter descends, ← ascends); esc is a
+        // silent alias for the reflex — it goes back, never quits.
+        if (key.name === "escape" || key.name === "left") {
           state.runtimeInst = null;
           state.runtimeCursor = 0;
           render();
@@ -1827,16 +1874,23 @@ async function browser(args = {}) {
         return;
       }
 
-      // Modal handling takes priority
+      // Modal handling takes priority. The modal is cleared BEFORE its
+      // callback runs so a callback can chain a follow-up modal (the delete →
+      // sweep offer). Esc is a full cancel: it closes the modal and skips the
+      // chain — n/enter decline this modal but still allow the follow-up.
       if (state.modal) {
+        const m = state.modal;
         if ((chunk && /^[yY]/.test(chunk))) {
-          state.modal.onYes();
           state.modal = null;
+          m.onYes();
           render();
-        } else if (key.name === "escape" || (chunk && /^[nN]/.test(chunk)) || key.name === "return") {
-          state.modal.onNo?.();
+        } else if (key.name === "escape") {
           state.modal = null;
           render();
+        } else if ((chunk && /^[nN]/.test(chunk)) || key.name === "return") {
+          state.modal = null;
+          m.onNo?.();
+          render();
         }
         return;
       }
@@ -1908,13 +1962,20 @@ async function browser(args = {}) {
 
       // Normal mode
       if (key.ctrl && key.name === "c") { cleanup(); process.exit(130); }
-      if (key.name === "q" || key.name === "escape") {
+      // Esc never quits: at the root it only clears an active filter. Users
+      // press esc expecting either "back" or "abort" — both are safe when it
+      // can't eject them to the shell. A flash points at the real quit key.
+      if (key.name === "escape") {
         if (state.filter) {
           state.filter = "";
           clampCursor();
           render();
           return;
         }
+        flashMessage(`${BOLD}q${RESET} quits — esc never does`, "info");
+        return;
+      }
+      if (key.name === "q") {
         cleanup();
         resolve();
         return;
@@ -2000,40 +2061,49 @@ async function browser(args = {}) {
         flashMessage(`default set to ${BOLD}${pick.slug}${RESET}`, "success");
         return;
       }
-      if (chunk === "r") {
+      // d = the one delete verb (r kept as an unadvertised alias for muscle
+      // memory). Deleting confirms first; when other entries with missing
+      // folders remain, a sweep offer chains after — whether the first modal
+      // was accepted or declined, so pressing d anywhere still reaches the
+      // cleanup the notice line promises. Esc cancels without chaining.
+      if (chunk === "d" || chunk === "r") {
         const pick = visible()[state.cursor]?.e;
         if (!pick) return;
+        const offerSweep = () => {
+          const stale = registry.filter((e) => !fs.existsSync(e.path));
+          if (stale.length === 0) return;
+          state.modal = {
+            type: "sweep",
+            count: stale.length,
+            onYes: () => {
+              const bak = backupRegistry();
+              registry = registry.filter((e) => fs.existsSync(e.path));
+              writeRegistry(registry);
+              refreshStale();
+              clampCursor();
+              flashMessage(`removed ${stale.length} · ${registry.length} remain · backup: ${path.basename(bak)}`, "success");
+            },
+          };
+        };
+        const pickMissing = !fs.existsSync(pick.path);
         state.modal = {
           type: "remove",
           inst: pick,
+          missing: pickMissing,
           onYes: () => {
             const bak = backupRegistry();
             registry = registry.filter((e) => e.path !== pick.path);
             writeRegistry(registry);
             previewCache.delete(pick.path);
+            refreshStale();
             clampCursor();
             flashMessage(`removed ${BOLD}${pick.slug}${RESET} · backup: ${path.basename(bak)}`, "success");
+            offerSweep();
           },
-        };
-        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");
-          },
+          // Declining a healthy row still routes to cleanup (the notice's d
+          // lands here); declining a missing row means "leave it" — don't
+          // immediately re-offer the same removal.
+          onNo: () => { if (!pickMissing) offerSweep(); },
         };
         render();
         return;

package/lib/local.js

@@ -539,14 +539,14 @@ async function maybeSetupTelegramGroup(ui, {
   ui.info(`Bot add link: ${ui.cyan(botLink)}`);
   openBrowser(botLink);
 
-  await ui.prompt("Press Enter here after the bot is in the group");
+  await ui.prompt("Press Enter here after the bot is in the group", { hint: "enter continue · ctrl-c quit" });
   ui.note([
     "Step 4: In Telegram, copy a group invite link.",
     "Paste it below so teammate invites include the Telegram group too.",
     "If you skip this, Egregore will still work, but invites will not include Telegram.",
   ]);
 
-  const groupLink = await ui.prompt("Telegram group join link (paste here, or Enter to skip)");
+  const groupLink = await ui.prompt("Telegram group join link (paste here, or Enter to skip)", { hint: "paste the link · enter skip" });
   const cleaned = groupLink.trim();
   let storedGroupLink = "";
   if (cleaned && !looksLikeUrl(cleaned)) {
@@ -725,52 +725,92 @@ async function localFounderFlow(ui, ctx = {}) {
     return true;
   };
 
-  const stepNameProject = async () => {
-    ui.section("Name it", "what's this Egregore called?");
-    if (st.isNewProject) {
-      const name = await ui.promptOrBack("name your Egregore (team or group name)", { default: st.orgName || st.githubOrg });
-      if (name === BACK) return BACK;
-      st.orgName = name;
-      const desc = await ui.promptOrBack("what are you building? (one line)", { default: st.description || undefined });
-      if (desc === BACK) return BACK;
-      st.description = desc;
-
-      // Validate the optional project repo name against the names the
-      // Egregore/memory repos WILL get (editable later, derived for now).
-      const predictedRepoName = slugifyName(st.orgName) || "egregore";
-      const predictedMemoryRepoName = `${predictedRepoName}-memory`;
-      ui.note([
-        "Your Egregore gets its own repo (memory + config) in your account.",
-        "Have a code project too? Egregore can add a repo for it in your account.",
-      ]);
-      for (;;) {
-        const projectName = await ui.promptOrBack("code project repo name (Enter to skip)", { default: st.newProjectRepo || undefined });
-        if (projectName === BACK) return BACK;
-        if (!projectName) { st.newProjectRepo = null; break; }
-        const slug = slugifyName(projectName);
-        if (!slug) {
-          ui.warn("That doesn't produce a valid repo name. Try letters, numbers, and dashes.");
-          continue;
-        }
-        if (slug === predictedRepoName) {
-          ui.warn(`"${slug}" is already the name of your Egregore repo. Pick a different name.`);
-          ui.info(`  ${ui.dim("suggestion:")} ${ui.cyan(`${slug}-app`)}`);
-          continue;
-        }
-        if (slug === predictedMemoryRepoName) {
-          ui.warn(`"${slug}" collides with your memory repo. Pick a different name.`);
-          continue;
-        }
-        st.newProjectRepo = slug;
-        break;
-      }
-    } else {
-      const name = await ui.promptOrBack("what should we call this Egregore?", { default: st.orgName || st.githubOrg });
-      if (name === BACK) return BACK;
-      st.orgName = name;
+  const stepNameManifest = async () => {
+    // One live manifest instead of scattered naming prompts: name the thing
+    // first, watch the repo plan derive from it in place, override any line.
+    // Every collision check runs against names VISIBLE on screen — the old
+    // flow rejected a code-repo name for colliding with an Egregore repo
+    // name the user had never been shown.
+    console.log("");
+    const isNew = st.isNewProject;
+    const validSlug = (v) => (slugifyName(v)
+      ? null
+      : "That doesn't produce a valid repo name. Try letters, numbers, and dashes.");
+    const fields = [
+      {
+        key: "orgName",
+        label: "Egregore",
+        note: "team or group name",
+        hint: "type your preferred Egregore name or hit enter to pick the naming below",
+        initial: st.orgName || undefined,
+        derive: () => st.githubOrg,
+      },
+      {
+        key: "repoName",
+        label: "Egregore repo",
+        note: "config + skills",
+        hint: `enter keeps this name · type to change · created in ${st.githubOrg}`,
+        tree: true,
+        initial: st.repoName || undefined,
+        derive: (v) => slugifyName(v.orgName) || "egregore",
+        normalize: (raw) => slugifyName(raw),
+        validate: (v) => validSlug(v),
+      },
+      {
+        key: "memoryRepoName",
+        label: "memory repo",
+        note: "shared memory",
+        hint: "enter keeps this name · type to change",
+        tree: true,
+        initial: st.memoryRepoName || undefined,
+        derive: (v) => `${v.repoName || "egregore"}-memory`,
+        normalize: (raw) => slugifyName(raw),
+        validate: (v, others) => validSlug(v)
+          || (v === others.repoName ? "Memory repo can't share the Egregore repo's name." : null),
+      },
+      ...(isNew ? [{
+        key: "codeRepo",
+        label: "code repo",
+        note: "your project · optional",
+        hint: "add a repo for your code project — or enter to skip",
+        tree: true,
+        optional: true,
+        initial: st.newProjectRepo || undefined,
+        normalize: (raw) => slugifyName(raw),
+        validate: (v, others) => validSlug(v)
+          || (v === others.repoName ? `"${v}" is the Egregore repo above. Pick a different name — say, ${v}-app.` : null)
+          || (v === others.memoryRepoName ? `"${v}" is the memory repo above. Pick a different name.` : null),
+      }] : []),
+    ];
+    const result = await ui.manifestForm({
+      title: "Name it",
+      subtitle: `repos land in ${st.githubOrg}`,
+      fields,
+    });
+    if (result === BACK) return BACK;
+    const v = result.values;
+    st.orgName = v.orgName;
+    st.repoName = v.repoName;
+    st.memoryRepoName = v.memoryRepoName;
+    st.newProjectRepo = isNew ? (v.codeRepo || null) : null;
+    return true;
+  };
+
+  // The one-liner is repo metadata, not a naming decision — it lives OUTSIDE
+  // the manifest so enter on the name lands directly in the naming tree
+  // (the manifest's hint promises exactly that).
+  const stepDescription = async () => {
+    if (!st.isNewProject) {
       st.description = "";
-      st.newProjectRepo = null;
+      return SKIP;
     }
+    console.log("");
+    const desc = await ui.promptOrBack("what are you building? (one line)", {
+      default: st.description || undefined,
+      hint: "one line on what you're making · enter to skip · ↑ back",
+    });
+    if (desc === BACK) return BACK;
+    st.description = desc;
     return true;
   };
 
@@ -891,41 +931,12 @@ async function localFounderFlow(ui, ctx = {}) {
     return true;
   };
 
-  const stepRepoNames = async () => {
-    // Derived names shown as editable prompts — creating repos with silently
-    // derived names was a repeated field complaint.
-    const derivedSlug = slugifyName(st.orgName) || "egregore";
-    console.log("");
-    ui.note([
-      `Two repos will be created in ${ui.bold(st.githubOrg)}: the Egregore repo`,
-      "(config + skills) and its shared-memory repo. Enter keeps the defaults.",
-    ]);
-    for (;;) {
-      const answer = await ui.promptOrBack("Egregore repo name", { default: st.repoName || derivedSlug });
-      if (answer === BACK) return BACK;
-      const candidate = slugifyName(answer);
-      if (!candidate) { ui.warn("That doesn't produce a valid repo name. Try letters, numbers, and dashes."); continue; }
-      if (st.newProjectRepo && candidate === st.newProjectRepo) { ui.warn(`"${candidate}" is already your project repo. Pick a different name.`); continue; }
-      st.repoName = candidate;
-      break;
-    }
-    for (;;) {
-      const answer = await ui.promptOrBack("memory repo name", { default: st.memoryRepoName || `${st.repoName}-memory` });
-      if (answer === BACK) return BACK;
-      const candidate = slugifyName(answer);
-      if (!candidate) { ui.warn("That doesn't produce a valid repo name. Try letters, numbers, and dashes."); continue; }
-      if (candidate === st.repoName) { ui.warn("Memory repo can't share the Egregore repo's name."); continue; }
-      if (st.newProjectRepo && candidate === st.newProjectRepo) { ui.warn(`"${candidate}" is already your project repo. Pick a different name.`); continue; }
-      st.memoryRepoName = candidate;
-      break;
-    }
-    return true;
-  };
-
   // Direction-aware driver: BACK rewinds one step; SKIP (deterministic
   // steps) passes through in whichever direction we're moving, so backing
   // over an auto-answered step doesn't bounce the user forward again.
-  const steps = [stepHome, stepWorkType, stepNameProject, stepRepos, stepRepoNames];
+  // ALL naming (Egregore + repo plan) happens in the manifest BEFORE the
+  // existing-project repo picker — name the thing first, then attach repos.
+  const steps = [stepHome, stepWorkType, stepNameManifest, stepDescription, stepRepos];
   let stepIdx = 0;
   let stepDir = 1;
   while (stepIdx < steps.length) {
@@ -1146,7 +1157,10 @@ async function localFounderFlow(ui, ctx = {}) {
 
   // 14. "What should we call you?" + write state
   ui.section("Your name", "this is how teammates will see you in handoffs");
-  const displayName = await ui.prompt("what should we call you?", { default: user.login });
+  const displayName = await ui.prompt("what should we call you?", {
+    default: user.login,
+    hint: `type a display name · enter keeps ${user.login}`,
+  });
   const memberRole = await ensureInstallerMemberRole(
     { usage_type: "founder_group", member_role: ctx.memberRole },
     {},

package/lib/ui.js

@@ -209,7 +209,19 @@ function spinner(msg) {
 
 // ── prompts ─────────────────────────────────────────────────────────
 
-function prompt(question, { default: defaultValue } = {}) {
+// Footer band — the same visual chrome as the launcher's status band:
+// accent background (the banner's color slot), dark text, padded like a
+// bar. Walks with the active prompt in this scrolling wizard; bg 43
+// (yellow) marks errors/questions that need answering. Any ANSI inside
+// the content is stripped — a RESET mid-line would kill the fill.
+function footerBand(content, bg = 46) {
+  const plain = String(content).replace(/\x1b\[[0-9;]*m/g, "");
+  if (!COLOR) return `  ${plain}`;
+  const w = termWidth() - 3;
+  return `  ${esc(bg)}${BLACK}${pad(` ${plain}`, w)}${RESET}`;
+}
+
+function promptLegacy(question, { default: defaultValue } = {}) {
   return new Promise((resolve) => {
     const rl = readline.createInterface({
       input: process.stdin,
@@ -226,18 +238,36 @@ function prompt(question, { default: defaultValue } = {}) {
   });
 }
 
-// Line input that can step backwards: esc resolves BACK, enter resolves the
-// typed value (or the default). Raw-mode single-line editor — append +
-// backspace only, which covers the short names these prompts collect.
-// Falls back to the plain readline prompt when not interactive.
-function promptOrBack(question, { default: defaultValue } = {}) {
-  if (!canInteract()) return prompt(question, { default: defaultValue });
+// Shared single-line editor: the input line plus ONE dim hint line pinned
+// below it — the dynamic footer every wizard prompt shares, instead of
+// per-label "(esc back)" clutter. opts.back controls whether stepping
+// backwards is possible: with back, ↑ resolves BACK (esc is a silent
+// alias); without it, ↑/esc are no-ops. Esc NEVER quits either way —
+// ctrl-c is the only abort. Accepts multi-char printable chunks so paste
+// works (Telegram links, usernames).
+function lineInput(question, { default: defaultValue, hint, back = false } = {}) {
   return new Promise((resolve) => {
     let buf = "";
     const label = defaultValue
-      ? `  ${CYAN}?${RESET} ${question} ${DIM}[${defaultValue}]${RESET} ${DIM}(esc back)${RESET} `
-      : `  ${CYAN}?${RESET} ${question} ${DIM}(esc back)${RESET} `;
-    const render = () => process.stdout.write(`\r\x1b[2K${label}${buf}`);
+      ? `  ${CYAN}?${RESET} ${question} ${DIM}[${defaultValue}]${RESET} `
+      : `  ${CYAN}?${RESET} ${question} `;
+    const hintLine = footerBand(hint || (back ? "enter accept · ↑ back · ctrl-c quit" : "enter accept · ctrl-c quit"));
+    const labelCols = visibleLen(label);
+    const render = () => {
+      // Input line, a blank margin row, then the footer band — the band
+      // needs breathing room or it visually fuses with the input. The real
+      // cursor parks at the end of the typed text so keystrokes land where
+      // the eye is.
+      process.stdout.write(
+        `\r\x1b[2K${label}${buf}\n` +
+        `\x1b[2K\n` +
+        `\x1b[2K${hintLine}` +
+        `\x1b[2A\x1b[${labelCols + buf.length + 1}G`,
+      );
+    };
+    const clearHint = () => {
+      process.stdout.write(`\x1b[1B\r\x1b[2K\x1b[1B\r\x1b[2K\x1b[2A\x1b[${labelCols + buf.length + 1}G`);
+    };
     const cleanup = () => {
       process.stdin.setRawMode(false);
       process.stdin.pause();
@@ -247,17 +277,21 @@ function promptOrBack(question, { default: defaultValue } = {}) {
       if (!key) return;
       if (key.ctrl && key.name === "c") {
         cleanup();
+        clearHint();
         process.stdout.write(`\n  ${DIM}(cancelled)${RESET}\n`);
         process.exit(130);
       }
-      if (key.name === "escape") {
+      if (key.name === "up" || key.name === "escape") {
+        if (!back) return; // nothing to go back to — and esc never quits
         cleanup();
+        clearHint();
         process.stdout.write(`\r\x1b[2K${label}${DIM}← back${RESET}\n`);
         resolve(BACK);
         return;
       }
       if (key.name === "return") {
         cleanup();
+        clearHint();
         process.stdout.write("\n");
         resolve(buf.trim() || (defaultValue ?? ""));
         return;
@@ -267,9 +301,12 @@ function promptOrBack(question, { default: defaultValue } = {}) {
         render();
         return;
       }
-      if (_str && _str.length === 1 && !key.ctrl && !key.meta && _str.charCodeAt(0) >= 32) {
-        buf += _str;
-        render();
+      if (_str && !key.ctrl && !key.meta) {
+        const clean = _str.replace(/[\x00-\x1f\x7f]/g, "");
+        if (clean) {
+          buf += clean;
+          render();
+        }
       }
     };
     readline.emitKeypressEvents(process.stdin);
@@ -280,9 +317,26 @@ function promptOrBack(question, { default: defaultValue } = {}) {
   });
 }
 
+// Standard prompt — interactive sessions get the hint-line footer, pipes
+// and CI keep the plain readline fallback.
+function prompt(question, opts = {}) {
+  if (!canInteract()) return promptLegacy(question, opts);
+  return lineInput(question, { ...opts, back: false });
+}
+
+// Line input that can step backwards: ↑ resolves BACK (esc is a silent
+// alias), enter resolves the typed value (or the default).
+function promptOrBack(question, opts = {}) {
+  if (!canInteract()) return promptLegacy(question, opts);
+  return lineInput(question, { ...opts, back: true });
+}
+
 async function confirm(question, defaultYes = false) {
-  const hint = defaultYes ? `${DIM}[Y/n]${RESET}` : `${DIM}[y/N]${RESET}`;
-  const answer = await prompt(`${question} ${hint}`);
+  const bracket = defaultYes ? `${DIM}[Y/n]${RESET}` : `${DIM}[y/N]${RESET}`;
+  const hint = `y yes · n no · enter ${defaultYes ? "yes" : "no"} · ctrl-c quit`;
+  const answer = canInteract()
+    ? await lineInput(`${question} ${bracket}`, { hint, back: false })
+    : await promptLegacy(`${question} ${bracket}`);
   if (!answer) return defaultYes;
   return /^y(es)?$/i.test(answer);
 }
@@ -343,7 +397,7 @@ function renderPicker({ question, filterText, lines, help, input }) {
   for (const line of lines) out.push(line);
   if (help) {
     out.push("");
-    out.push(`  ${DIM}${help}${RESET}`);
+    out.push(footerBand(help));
   }
   const text = out.join("\n") + "\n";
   process.stdout.write(text);
@@ -376,10 +430,13 @@ function filterOptions(options, filterText, getText) {
 
 // ── back navigation ─────────────────────────────────────────────────
 //
-// Multi-step flows (the founder setup) let the user step backwards with
-// esc. Pickers and prompts opt in via `escAction: "back"` — esc then
-// resolves to the BACK sentinel instead of aborting the process, and the
-// caller's step machine rewinds. Ctrl-C always remains the hard abort.
+// Multi-step flows (the founder setup) let the user step backwards. The
+// advertised keys are spatial — ↑ in text fields/forms, ← in choice lists
+// (enter descends, ← ascends) — with esc as a silent alias everywhere.
+// Esc NEVER quits: users' terminal reflex is that esc ejects them from the
+// CLI, so no esc press may ever reach the shell. Pickers and prompts opt
+// in via `escAction: "back"` — back keys then resolve to the BACK sentinel
+// and the caller's step machine rewinds. Ctrl-C is the only hard abort.
 const BACK = Symbol.for("egregore.ui.back");
 
 // ── choose: interactive single-select picker ────────────────────────
@@ -392,7 +449,8 @@ const BACK = Symbol.for("egregore.ui.back");
 //   enter     select
 //   type      filter (case-insensitive substring match on label + desc)
 //   backspace pop filter
-//   esc       cancel — or go back with opts.escAction: "back"
+//   ← / esc   go back with opts.escAction: "back" (esc never quits;
+//             a clean-state esc with no back target is a no-op)
 //   ctrl-c    abort process
 
 async function choose(question, options, hint, opts = {}) {
@@ -457,13 +515,13 @@ async function interactiveChoose(question, options, hint, opts = {}) {
         for (let i = start; i < end; i++) lines.push(renderRow(visible[i], i));
         if (end < total) lines.push(`    ${DIM}↓ ${total - end} more · type to filter${RESET}`);
       }
-      const escHint = opts.escAction === "back" ? `${DIM}esc${RESET} back` : `${DIM}esc${RESET} cancel`;
+      const backHint = opts.escAction === "back" ? ` · ${DIM}←${RESET} back` : "";
       if (!first) clearLines(lastLineCount);
       lastLineCount = renderPicker({
         question,
         filterText,
         lines,
-        help: hint || `${DIM}↑↓${RESET} navigate · ${DIM}enter${RESET} select · type to filter · ${escHint}`,
+        help: hint || `${DIM}↑↓${RESET} navigate · ${DIM}enter${RESET} select · type to filter${backHint} · ${DIM}ctrl-c${RESET} quit`,
       });
     };
 
@@ -498,16 +556,20 @@ async function interactiveChoose(question, options, hint, opts = {}) {
         render();
         return;
       }
-      if (key.name === "escape" && opts.escAction === "back") {
+      // ← is the advertised back key in choice lists (enter descends, ←
+      // ascends); esc is a silent alias. Esc NEVER quits — a clean-state esc
+      // with no back target does nothing, ctrl-c is the only abort.
+      if ((key.name === "escape" || key.name === "left") && opts.escAction === "back") {
         goBack();
         return;
       }
-      if ((key.ctrl && key.name === "c") || key.name === "escape") {
+      if (key.ctrl && key.name === "c") {
         cleanup();
         unparkCursor();
         process.stdout.write(`\n  ${DIM}(cancelled)${RESET}\n`);
         process.exit(130);
       }
+      if (key.name === "escape") return;
       if (key.name === "return") {
         if (visible.length > 0 && !visible[cursor].opt.disabled) finish(visible[cursor].opt);
         return;
@@ -592,7 +654,7 @@ async function legacyChoose(question, options, hint, opts = {}) {
 //   ctrl-a    toggle all (respecting filter)
 //   enter     confirm
 //   type      filter
-//   esc       confirm with current selection
+//   ← / esc   go back with opts.escAction: "back" (esc never quits)
 
 async function multiSelect(question, options, opts = {}) {
   // Remote search can populate an empty pool, but only interactively —
@@ -672,7 +734,7 @@ async function interactiveMultiSelect(question, options, opts = {}) {
       if (searching && total > 0) lines.push(`    ${DIM}searching…${RESET}`);
 
       const searchHint = opts.remoteSearch ? "type to search" : "type to filter";
-      const escHint = opts.escAction === "back" ? ` · ${DIM}esc${RESET} back` : "";
+      const escHint = opts.escAction === "back" ? ` · ${DIM}←${RESET} back` : "";
       if (!first) clearLines(lastLineCount);
       lastLineCount = renderPicker({
         question,
@@ -758,19 +820,20 @@ async function interactiveMultiSelect(question, options, opts = {}) {
         render();
         return;
       }
-      if (key.name === "escape" && opts.escAction === "back") {
+      if ((key.name === "escape" || key.name === "left") && opts.escAction === "back") {
         cleanup();
         clearLines(lastLineCount);
         process.stdout.write(`  ${CYAN}◆${RESET} ${BOLD}${question}${RESET}  ${DIM}→ ← back${RESET}\n`);
         resolve(BACK);
         return;
       }
-      if ((key.ctrl && key.name === "c") || key.name === "escape") {
+      if (key.ctrl && key.name === "c") {
         cleanup();
         unparkCursor();
         process.stdout.write(`\n  ${DIM}(cancelled)${RESET}\n`);
         process.exit(130);
       }
+      if (key.name === "escape") return; // esc never quits — ctrl-c aborts
       if (key.name === "return") return finish();
       if (key.name === "up" || (key.ctrl && key.name === "p")) {
         cursor = (cursor - 1 + visible.length) % Math.max(1, visible.length);
@@ -853,6 +916,286 @@ async function legacyMultiSelect(question, options) {
   return [...picked];
 }
 
+// ── manifestForm: live-manifest form ────────────────────────────────
+//
+// A vertical form rendered as one visible block — the "what gets created"
+// plan IS the UI. One field is active at a time; derived fields (repo
+// names from the Egregore name) fill in live as earlier answers are typed,
+// so the plan builds itself in front of the user. "Back" is cursor
+// movement, not a hidden step-rewind: ↑ moves to the previous field, and
+// at the first field resolves BACK to the caller's step machine.
+//
+// fields: [{
+//   key            value key in the resolved object
+//   label          row label (left column)
+//   note           dim annotation (right column, e.g. "config + skills")
+//   hint           header guidance shown while this field is active
+//                  (falls back to the form-level subtitle)
+//   initial        previous answer (revisit) — kept only while it differs
+//                  from the live derive, so edits keep cascading
+//   derive(vals)   live default computed from earlier fields
+//   normalize(raw) canonicalize input (e.g. slugify) before validate
+//   validate(v, vals)  return an error string to reject, null to accept
+//   optional       enter on empty = skip (value "")
+//   tree           render with ├─/└─ branch glyphs (the repo plan rows)
+// }]
+//
+// keys: enter accept+next (submit on last) · ↑ previous field (BACK at the
+// first) · ↓ next · type/backspace edit · esc = silent alias of ↑ (esc
+// never quits) · ctrl-c abort
+//
+// resolves { values } or BACK.
+async function manifestForm({ title, subtitle, fields }) {
+  if (!canInteract()) {
+    // Non-interactive fallback: plain sequential prompts, same validation.
+    const values = {};
+    for (const f of fields) {
+      const def = (f.initial != null && f.initial !== "") ? f.initial : (f.derive ? f.derive(values) : "");
+      for (;;) {
+        const raw = await prompt(f.label, { default: def || undefined });
+        const val = f.normalize ? f.normalize(raw) : String(raw || "").trim();
+        if (!val && f.optional) { values[f.key] = ""; break; }
+        const err = f.validate ? f.validate(val, values) : null;
+        if (err) { warn(err); continue; }
+        values[f.key] = val;
+        break;
+      }
+    }
+    return { values };
+  }
+
+  return new Promise((resolve) => {
+    // entered[key] is set only when the user TYPED a value — accepting a
+    // derived ghost with enter leaves the field derived, so going back up
+    // and changing the name re-derives everything the user didn't override.
+    const entered = {};
+    let active = 0;
+    let buf = null;   // null = untouched → the ghost (derive/initial) shows
+    let error = null;
+    let confirmed = -1; // highest field index confirmed with enter
+    let lastRows = 0;
+
+    for (let i = 0; i < fields.length; i++) {
+      const f = fields[i];
+      if (f.initial != null && f.initial !== "") entered[f.key] = f.initial;
+    }
+    // Revisit case: initial values that match what derivation would produce
+    // are dropped back to derived so the cascade stays live.
+    {
+      const vals = {};
+      for (const f of fields) {
+        const derived = f.derive ? f.derive(vals) : "";
+        if (entered[f.key] != null && entered[f.key] === derived) delete entered[f.key];
+        vals[f.key] = entered[f.key] != null ? entered[f.key] : derived;
+      }
+      if (Object.keys(entered).length > 0) confirmed = fields.length - 1;
+    }
+
+    // Resolve every field's current value in order; the active field's
+    // in-progress buffer feeds later derives so typing the name updates the
+    // repo rows on every keystroke.
+    const computeVals = () => {
+      const vals = {};
+      for (let i = 0; i < fields.length; i++) {
+        const f = fields[i];
+        let v;
+        if (i === active && buf != null) v = f.normalize ? f.normalize(buf) : buf.trim();
+        else if (entered[f.key] != null) v = entered[f.key];
+        else v = f.derive ? f.derive(vals) : "";
+        vals[f.key] = v || "";
+      }
+      return vals;
+    };
+
+    const ghostFor = (i, vals) => {
+      const f = fields[i];
+      if (entered[f.key] != null) return entered[f.key];
+      return f.derive ? f.derive(vals) : "";
+    };
+
+    const labelW = Math.max(...fields.map((f) => f.label.length + (f.tree ? 3 : 0)));
+    const lastTreeIdx = fields.reduce((acc, f, i) => (f.tree ? i : acc), -1);
+
+    const rowLine = (i, vals) => {
+      const f = fields[i];
+      const glyph = f.tree ? (i === lastTreeIdx ? "└─ " : "├─ ") : "";
+      const labelText = pad(`${glyph}${f.label}`, labelW);
+      const isActive = i === active;
+      const isDone = i <= confirmed && !isActive;
+      const mark = isActive ? `${CYAN}❯${RESET}` : (isDone ? `${GREEN}✓${RESET}` : " ");
+      const note = f.note ? `  ${DIM}${f.note}${RESET}` : "";
+      let value;
+      if (isActive) {
+        // No drawn caret — the REAL terminal cursor is parked here after
+        // render, so it blinks where keystrokes land.
+        if (buf != null) {
+          value = buf;
+        } else {
+          const ghost = ghostFor(i, vals);
+          value = ghost
+            ? `${DIM}${ghost}${RESET}`
+            : (f.optional ? `${DIM}(enter to skip)${RESET}` : "");
+        }
+      } else {
+        const v = vals[f.key];
+        if (!v) value = `${DIM}${f.optional && isDone ? "— skipped" : "·"}${RESET}`;
+        else if (entered[f.key] != null || isDone) value = `${BOLD}${v}${RESET}`;
+        else value = `${DIM}${v}${RESET}`;
+      }
+      const valueW = 26;
+      return `    ${mark} ${DIM}${labelText}${RESET}  ${pad(value, valueW)}${note}`;
+    };
+
+    const hintLine = () => {
+      const backTarget = active === 0 ? "back" : "previous";
+      return footerBand(`enter ${active === fields.length - 1 ? "finish" : "next"} · ↑ ${backTarget} · type to edit · ctrl-c quit`);
+    };
+
+    const render = (first = false) => {
+      const vals = computeVals();
+      const lines = [];
+      // Header guidance is contextual: each field can carry its own hint
+      // ("type your preferred Egregore name or hit enter…"), so the line
+      // always says what to do RIGHT NOW instead of describing the form.
+      const guidance = fields[active].hint || subtitle;
+      lines.push(`  ${CYAN}◆${RESET} ${BOLD}${title}${RESET}${guidance ? `  ${DIM}${guidance}${RESET}` : ""}`);
+      lines.push("");
+      for (let i = 0; i < fields.length; i++) lines.push(rowLine(i, vals));
+      lines.push("");
+      lines.push(error ? footerBand(`! ${error}`, 43) : hintLine());
+      if (!first) clearLines(lastRows);
+      const width = process.stdout.columns || 80;
+      const text = lines.join("\n") + "\n";
+      process.stdout.write(CURSOR_HIDE + text);
+      lastRows = lines.reduce((sum, line) => sum + visualRows(line, width), 0);
+      // Park the REAL terminal cursor at the active field's edit point so it
+      // blinks there — the strongest "type here" affordance a terminal has.
+      // Row math is visual-row aware (the header hint may wrap); the active
+      // field row itself is short and assumed unwrapped.
+      const activeLine = 2 + active;
+      let rowsUp = 1; // the trailing newline after the block
+      for (let i = activeLine + 1; i < lines.length; i++) rowsUp += visualRows(lines[i], width);
+      const col = labelW + 9 + (buf != null ? visibleLen(buf) : 0);
+      process.stdout.write(`\x1b[${rowsUp}A\x1b[${col}G${CURSOR_SHOW}`);
+      _parkedRows = rowsUp; // clearLines() unparks before rewinding
+    };
+
+    const cleanup = () => {
+      process.stdin.setRawMode(false);
+      process.stdin.pause();
+      process.stdin.removeListener("keypress", onKey);
+      process.stdout.write(CURSOR_SHOW);
+    };
+
+    // Transcript receipt: the final plan stays in scrollback as a static
+    // tree, so the record of what was named survives the redraw region.
+    const receipt = (vals) => {
+      const lines = [`  ${CYAN}◆${RESET} ${BOLD}${title}${RESET}`];
+      for (let i = 0; i < fields.length; i++) {
+        const f = fields[i];
+        if (!vals[f.key]) continue;
+        const glyph = f.tree ? (i === lastTreeIdx ? "└─ " : "├─ ") : "";
+        const note = f.note ? `  ${DIM}${f.note}${RESET}` : "";
+        lines.push(`    ${DIM}${pad(`${glyph}${f.label}`, labelW)}${RESET}  ${pad(`${BOLD}${vals[f.key]}${RESET}`, 26)}${note}`);
+      }
+      return lines.join("\n") + "\n";
+    };
+
+    const commitActive = () => {
+      const f = fields[active];
+      const vals = computeVals();
+      const typed = buf != null && buf.trim() !== "";
+      const value = vals[f.key];
+      if (!value && !f.optional) {
+        error = `${f.label} can't be empty.`;
+        return false;
+      }
+      if (value && f.validate) {
+        // Validate against the other fields' values, not our own in-progress one.
+        const others = { ...vals };
+        delete others[f.key];
+        const err = f.validate(value, others);
+        if (err) { error = err; return false; }
+      }
+      if (typed) entered[f.key] = value;
+      else if (buf != null && buf.trim() === "" && f.optional) entered[f.key] = "";
+      error = null;
+      confirmed = Math.max(confirmed, active);
+      return true;
+    };
+
+    const onKey = (_str, key) => {
+      if (!key) return;
+      if (key.ctrl && key.name === "c") {
+        cleanup();
+        clearLines(lastRows);
+        process.stdout.write(`  ${DIM}(cancelled)${RESET}\n`);
+        process.exit(130);
+      }
+      // ↑ = previous field; at the first field it leaves the form (BACK to
+      // the previous wizard step). Esc is a silent alias — it never quits.
+      if (key.name === "up" || key.name === "escape") {
+        error = null;
+        if (active === 0) {
+          cleanup();
+          clearLines(lastRows);
+          process.stdout.write(`  ${CYAN}◆${RESET} ${BOLD}${title}${RESET}  ${DIM}→ ← back${RESET}\n`);
+          resolve(BACK);
+          return;
+        }
+        buf = null;
+        active -= 1;
+        render();
+        return;
+      }
+      if (key.name === "return" || key.name === "down") {
+        if (key.name === "down" && active === fields.length - 1) return;
+        if (!commitActive()) { render(); return; }
+        if (active === fields.length - 1) {
+          const vals = computeVals();
+          cleanup();
+          clearLines(lastRows);
+          process.stdout.write(receipt(vals));
+          resolve({ values: vals });
+          return;
+        }
+        buf = null;
+        active += 1;
+        render();
+        return;
+      }
+      if (key.name === "backspace") {
+        // Backspace on an untouched field materializes the ghost for editing.
+        if (buf == null) {
+          const vals = computeVals();
+          buf = ghostFor(active, vals).slice(0, -1);
+        } else {
+          buf = buf.slice(0, -1);
+        }
+        // Deleting everything un-touches the field — the derived suggestion
+        // returns (and downstream derives recover) instead of leaving the
+        // row stuck empty.
+        if (buf === "") buf = null;
+        error = null;
+        render();
+        return;
+      }
+      if (_str && _str.length === 1 && !key.ctrl && !key.meta && _str.charCodeAt(0) >= 32) {
+        buf = (buf == null ? "" : buf) + _str;
+        error = null;
+        render();
+      }
+    };
+
+    readline.emitKeypressEvents(process.stdin);
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.on("keypress", onKey);
+    process.stdout.write(CURSOR_HIDE);
+    render(true);
+  });
+}
+
 // ── commandBox ──────────────────────────────────────────────────────
 //
 // Preserved for back-compat; card() is the newer more-flexible version.
@@ -1113,7 +1456,7 @@ module.exports = {
   banner, bannerCompact, section, note, card,
   info, success, warn, error, step,
   dim, bold, cyan, green, yellow, red,
-  spinner, prompt, promptOrBack, choose, multiSelect, confirm, canInteract, BACK,
+  spinner, prompt, promptOrBack, manifestForm, choose, multiSelect, confirm, canInteract, BACK,
   commandBox,
   canShowScreens, welcomeScreen, summaryScreen,
   _renderWelcomeBody, _readPkgVersion,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-egregore",
-  "version": "0.18.18",
+  "version": "0.19.0",
   "description": "Set up Egregore for your team in one command — installs the egregore launcher and your choice of Claude Code or Codex.",
   "license": "MIT",
   "bin": {
@@ -11,7 +11,7 @@
   },
   "scripts": {
     "build:runtime": "node scripts/build-runtime-bundle.mjs",
-    "test": "node scripts/build-runtime-bundle.mjs --check && node --test test/context.test.js test/parse-join-target.test.js test/skip-repos.test.js test/onboarding-shortcircuit.test.js test/welcome-screen.test.js test/runtime-selection.test.js test/command-generation.test.js test/auth-gh.test.js test/gauntlet-fixes.test.js test/codex-runtime.test.js test/installer-runtime-source.test.js test/scroll-repro.test.js test/launcher-refocus-redraw.test.js test/multiselect-remote-search.test.js test/back-navigation.test.js",
+    "test": "node scripts/build-runtime-bundle.mjs --check && node --test test/context.test.js test/parse-join-target.test.js test/skip-repos.test.js test/onboarding-shortcircuit.test.js test/welcome-screen.test.js test/runtime-selection.test.js test/command-generation.test.js test/auth-gh.test.js test/gauntlet-fixes.test.js test/codex-runtime.test.js test/installer-runtime-source.test.js test/scroll-repro.test.js test/launcher-refocus-redraw.test.js test/multiselect-remote-search.test.js test/back-navigation.test.js test/manifest-form.test.js test/launcher-delete.test.js",
     "test:e2e": "node --test test/e2e-local.test.js",
     "test:all": "node scripts/build-runtime-bundle.mjs --check && node --test test/"
   },

package/runtime/codex/.codex/spec-manifest.json

@@ -11,7 +11,7 @@
     {
       "section": "Identity & Upstream",
       "action": "keep",
-      "sourceHash": "4acbf9bc2866",
+      "sourceHash": "11d07e3fcb58",
       "note": "Kept; /update, /contribute, /save tokens rendered as $skill tokens."
     },
     {
@@ -62,6 +62,12 @@
       "sourceHash": "d75dc9f6d88c",
       "note": "Kept verbatim."
     },
+    {
+      "section": "Loom Routing",
+      "action": "replace",
+      "sourceHash": "b6a6ca2bc2b7",
+      "note": "Loom delegation rides the Claude Code Agent tool; Codex has no subagent delegation — commands run inline. Preambles and bin/loom.sh calls marked skippable."
+    },
     {
       "section": "Git Workflow",
       "action": "keep",

package/runtime/codex/AGENTS.md

@@ -63,7 +63,7 @@ This block is the Codex-native Egregore behavioral spec, rendered from CLAUDE.md
 
 ## Identity & Upstream
 
-This is an Egregore instance — a downstream fork of the upstream framework at `egregore-labs/egregore`. The framework (`bin/`, `.claude/skills/`, `.claude/hooks/`, `.claude/context/`, `CLAUDE.md`, `skills/`) is synced from upstream on every session start and via `$update`. It is not authored in this repo.
+This is an Egregore instance — a downstream fork of the upstream framework at `egregore-labs/egregore`. The framework (`bin/`, `.claude/skills/`, `.claude/hooks/`, `.claude/context/`, `.claude/agents/`, `loom/`, `CLAUDE.md`, `skills/`) is synced from upstream on every session start and via `$update`. It is not authored in this repo.
 
 **Where changes belong:**
 - **Framework is outdated or a skill is missing:** run `$update` first. It pulls the latest from upstream.
@@ -198,6 +198,12 @@ Always use HTTPS for git operations — `github-auth.sh` handles credential stor
 
 ---
 
+## Loom Routing
+
+Loom routes commands across model tiers on the Claude Code runtime (`loom/routes.json` + `bin/loom.sh` + a model-pinned executor subagent). Codex has no subagent delegation — every command runs inline in the current session. Ignore "Loom routing" preambles if you encounter them in a skill spec, and skip `bin/loom.sh` calls; `loom/` and `.claude/agents/` are framework files synced for the Claude runtime.
+
+---
+
 ## Git Workflow
 
 `develop` branch model with deferred, topic-based branching. Users never interact with git directly.

package/runtime/codex/bin/codex-render-spec.mjs

@@ -224,6 +224,8 @@ Codex has no structured question tool — render each batch as compact numbered
 
 **Rules:** Max 4 questions per batch. When choices aren't mutually exclusive, say "pick any that apply".`;
 
+const LOOM_ROUTING_BODY = `Loom routes commands across model tiers on the Claude Code runtime (\`loom/routes.json\` + \`bin/loom.sh\` + a model-pinned executor subagent). Codex has no subagent delegation — every command runs inline in the current session. Ignore "Loom routing" preambles if you encounter them in a skill spec, and skip \`bin/loom.sh\` calls; \`loom/\` and \`.claude/agents/\` are framework files synced for the Claude runtime.`;
+
 const ISOLATION_BODY = `Sessions are confined to this project + memory + managed repos. On Codex this boundary is a standing instruction, not an enforced hook — hold it yourself.
 
 - **Never modify \`~/.egregore/instances.json\`** — managed by session-start.sh
@@ -266,6 +268,11 @@ const RULES = {
   'Onboarding': { action: 'keep', note: 'Kept; /onboarding rendered as $onboarding.' },
   'Transparency Beat': { action: 'keep', note: 'Kept verbatim.' },
   'Memory': { action: 'keep', note: 'Kept verbatim.' },
+  'Loom Routing': {
+    action: 'replace',
+    body: LOOM_ROUTING_BODY,
+    note: 'Loom delegation rides the Claude Code Agent tool; Codex has no subagent delegation — commands run inline. Preambles and bin/loom.sh calls marked skippable.',
+  },
   'Git Workflow': {
     action: 'keep',
     note: 'Kept; slash tokens rendered as $skill tokens. Branch diagram unchanged (code fence).',

package/runtime/codex/bin/lib/git-sync.sh

@@ -72,12 +72,12 @@ _apply_framework_update() {
   fi
   # Apply upstream changes — checkout is idempotent, skip diff check
   # (git diff with variable path lists breaks in zsh — no word-splitting)
-  for _p in bin/ .claude/commands/ .claude/skills/ .claude/hooks/ .claude/context/ CLAUDE.md skills/; do
+  for _p in bin/ .claude/commands/ .claude/skills/ .claude/hooks/ .claude/context/ .claude/agents/ loom/ CLAUDE.md skills/; do
     git checkout upstream/main -- "$_p" 2>/dev/null || true
   done
   # Only commit if there are actual changes
-  if [ -n "$(git status --porcelain bin/ .claude/ CLAUDE.md skills/ 2>/dev/null | head -1)" ]; then
-    git add bin/ .claude/ CLAUDE.md skills/ 2>/dev/null
+  if [ -n "$(git status --porcelain bin/ .claude/ loom/ CLAUDE.md skills/ 2>/dev/null | head -1)" ]; then
+    git add bin/ .claude/ loom/ CLAUDE.md skills/ 2>/dev/null
     EGREGORE_FRAMEWORK_UPDATE=1 git commit -m "Auto-update Egregore framework" --quiet 2>/dev/null || true
     FRAMEWORK_UPDATED="true"
   fi