create-egregore 0.18.17 → 0.19.0

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,9 +238,105 @@ function 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} `
+      : `  ${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();
+      process.stdin.removeListener("keypress", onKey);
+    };
+    const onKey = (_str, key) => {
+      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 === "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;
+      }
+      if (key.name === "backspace") {
+        buf = buf.slice(0, -1);
+        render();
+        return;
+      }
+      if (_str && !key.ctrl && !key.meta) {
+        const clean = _str.replace(/[\x00-\x1f\x7f]/g, "");
+        if (clean) {
+          buf += clean;
+          render();
+        }
+      }
+    };
+    readline.emitKeypressEvents(process.stdin);
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.on("keypress", onKey);
+    render();
+  });
+}
+
+// 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);
 }
@@ -289,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);
@@ -320,24 +428,37 @@ function filterOptions(options, filterText, getText) {
   return result;
 }
 
+// ── back navigation ─────────────────────────────────────────────────
+//
+// 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 ────────────────────────
 //
 // options: [{ label, description }]
-// returns: the picked option (same object reference as in options[])
+// returns: the picked option (same object reference as in options[]),
+//          or BACK when opts.escAction === "back" and the user pressed esc
 // keys:
 //   ↑ ↓       navigate
 //   enter     select
 //   type      filter (case-insensitive substring match on label + desc)
 //   backspace pop filter
-//   esc       cancel (returns the first option, or throws if opts.abortOnEsc)
+//   ← / 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) {
-  if (!canInteract()) return legacyChoose(question, options, hint);
-  return interactiveChoose(question, options, hint);
+async function choose(question, options, hint, opts = {}) {
+  if (!canInteract()) return legacyChoose(question, options, hint, opts);
+  return interactiveChoose(question, options, hint, opts);
 }
 
-async function interactiveChoose(question, options, hint) {
+async function interactiveChoose(question, options, hint, opts = {}) {
   return new Promise((resolve) => {
     let filterText = "";
     let visible = filterOptions(options, filterText, (o) => `${o.label} ${o.description || ""}`);
@@ -394,12 +515,13 @@ async function interactiveChoose(question, options, hint) {
         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 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 · ${DIM}esc${RESET} cancel`,
+        help: hint || `${DIM}↑↓${RESET} navigate · ${DIM}enter${RESET} select · type to filter${backHint} · ${DIM}ctrl-c${RESET} quit`,
       });
     };
 
@@ -416,14 +538,38 @@ async function interactiveChoose(question, options, hint) {
       resolve(value);
     };
 
+    const goBack = () => {
+      cleanup();
+      clearLines(lastLineCount);
+      process.stdout.write(`  ${CYAN}◆${RESET} ${BOLD}${question}${RESET}  ${DIM}→ ← back${RESET}\n`);
+      resolve(BACK);
+    };
+
     const onKey = (_str, key) => {
       if (!key) return;
-      if ((key.ctrl && key.name === "c") || key.name === "escape") {
+      if (key.name === "escape" && filterText) {
+        // fzf convention: first esc clears an active filter; only a clean
+        // state goes back / cancels.
+        filterText = "";
+        visible = filterOptions(options, filterText, (o) => `${o.label} ${o.description || ""}`);
+        cursor = firstEnabled();
+        render();
+        return;
+      }
+      // ← 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") {
         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;
@@ -462,7 +608,7 @@ async function interactiveChoose(question, options, hint) {
   });
 }
 
-async function legacyChoose(question, options, hint) {
+async function legacyChoose(question, options, hint, opts = {}) {
   process.stdout.write(`\n  ${CYAN}◆${RESET} ${BOLD}${question}${RESET}\n\n`);
   const labelWidth = Math.min(40, Math.max(...options.map((o) => o.label.length)));
   for (let i = 0; i < options.length; i++) {
@@ -473,8 +619,10 @@ async function legacyChoose(question, options, hint) {
     process.stdout.write(`    ${DIM}${num})${RESET} ${BOLD}${paddedLabel}${RESET}${desc}\n`);
   }
   if (hint) process.stdout.write(`\n  ${DIM}${hint}${RESET}\n`);
+  if (opts.escAction === "back") process.stdout.write(`  ${DIM}type "back" to go back${RESET}\n`);
   while (true) {
     const answer = await prompt(`pick ${DIM}[1-${options.length}]${RESET}:`);
+    if (opts.escAction === "back" && /^(b|back)$/i.test(answer)) return BACK;
     if (!answer) { warn(`Enter a number between 1 and ${options.length}.`); continue; }
     const n = parseInt(answer, 10);
     if (n >= 1 && n <= options.length) {
@@ -506,7 +654,7 @@ async function legacyChoose(question, options, hint) {
 //   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 —
@@ -523,7 +671,9 @@ async function interactiveMultiSelect(question, options, opts = {}) {
   return new Promise((resolve) => {
     let cursor = 0;
     let filterText = "";
-    const picked = new Set();
+    // opts.preselected re-arms a previous selection — used when the step
+    // machine navigates back to the picker so choices aren't lost.
+    const picked = new Set((opts.preselected || []).filter((n) => options.some((o) => o.name === n)));
     // The pool grows as remote results merge in; seed order is preserved so
     // boosted entries (e.g. the user's team repos) stay on top when idle.
     const pool = [...options];
@@ -584,13 +734,14 @@ 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}←${RESET} back` : "";
       if (!first) clearLines(lastLineCount);
       lastLineCount = renderPicker({
         question,
         filterText,
         lines,
         input: { label: opts.remoteSearch ? "search" : "filter" },
-        help: `${DIM}↑↓${RESET} nav · ${DIM}space${RESET} toggle · ${DIM}ctrl-a${RESET} all · ${DIM}enter${RESET} confirm · ${searchHint}`,
+        help: `${DIM}↑↓${RESET} nav · ${DIM}space${RESET} toggle · ${DIM}ctrl-a${RESET} all · ${DIM}enter${RESET} confirm · ${searchHint}${escHint}`,
       });
     };
 
@@ -661,12 +812,28 @@ async function interactiveMultiSelect(question, options, opts = {}) {
 
     const onKey = (_str, key) => {
       if (!key) return;
-      if ((key.ctrl && key.name === "c") || key.name === "escape") {
+      if (key.name === "escape" && filterText) {
+        filterText = "";
+        refreshVisible();
+        cursor = 0;
+        searching = false;
+        render();
+        return;
+      }
+      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") {
         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);
@@ -749,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.
@@ -1009,7 +1456,7 @@ module.exports = {
   banner, bannerCompact, section, note, card,
   info, success, warn, error, step,
   dim, bold, cyan, green, yellow, red,
-  spinner, prompt, choose, multiSelect, confirm, canInteract,
+  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.17",
+  "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": "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.