create-egregore 0.18.15 → 0.18.17

package/lib/auth.js

@@ -110,6 +110,26 @@ function explainNoGhHeadless(ui) {
   ui?.info?.(`  Install for any OS: ${GH_INSTALL_URL}`);
 }
 
+// Status text for the ACTIVE github.com account only. `gh auth status`
+// writes to stderr on some versions; capture both streams. With multiple
+// accounts the plain form lists every account (including broken ones), so
+// try --active first (gh ≥ 2.61) and otherwise cut the active account's
+// block out of the combined output.
+function ghActiveStatusText() {
+  let run = spawnSync("gh", ["auth", "status", "--active", "--hostname", "github.com"], { stdio: "pipe", encoding: "utf-8" });
+  let text = `${run.stdout || ""}${run.stderr || ""}`;
+  if (run.error || /unknown flag/i.test(text)) {
+    run = spawnSync("gh", ["auth", "status", "--hostname", "github.com"], { stdio: "pipe", encoding: "utf-8" });
+    text = `${run.stdout || ""}${run.stderr || ""}`;
+  }
+  // Split into per-account blocks (each starts at a "... account <login>"
+  // line) and keep the one marked active. Single-account/older gh output has
+  // no "Active account" marker — return it whole.
+  const blocks = text.split(/\n(?=\s*[✓✗xX-]?\s*(?:Logged in to|Failed to log in to))/);
+  const active = blocks.find((b) => /Active account:\s*true/i.test(b));
+  return active || text;
+}
+
 function tryGhAuth() {
   if (process.env.EGREGORE_SKIP_GH === "1") return null;
 
@@ -118,16 +138,21 @@ function tryGhAuth() {
 
   if (!ghCliExists()) return null;
 
-  // gh auth status writes to stderr; capture both.
-  const status = spawnSync("gh", ["auth", "status"], { stdio: "pipe", encoding: "utf-8" });
-  if (status.status !== 0) return null;
-  const statusText = `${status.stdout || ""}${status.stderr || ""}`;
-
-  const tokenRun = spawnSync("gh", ["auth", "token"], { stdio: "pipe", encoding: "utf-8" });
+  // The token is the source of truth: `gh auth token` succeeds iff the ACTIVE
+  // account is usable. Do NOT gate on `gh auth status`'s exit code — on
+  // multi-account setups it is non-zero when ANY configured account has a
+  // revoked/expired token, even though the active account is fine, which used
+  // to hard-fail installs until the user logged the stale accounts out.
+  const tokenRun = spawnSync("gh", ["auth", "token", "--hostname", "github.com"], { stdio: "pipe", encoding: "utf-8" });
   if (tokenRun.status !== 0) return null;
   const token = (tokenRun.stdout || "").trim();
   if (!token) return null;
 
+  // Status output is metadata only (scopes + login). Prefer --active (gh ≥
+  // 2.61) so stale sibling accounts don't pollute the output; fall back to the
+  // plain form and pick the active account's block out of it.
+  const statusText = ghActiveStatusText();
+
   // Parse declared token scopes when gh exposes them. Some gh versions and
   // fine-grained auth paths do not print a classic Token scopes line. Treat
   // that as "unknown" and continue with the first-party gh token instead of

package/lib/local.js

@@ -198,6 +198,63 @@ async function putFileContent(token, owner, repo, filePath, content, message) {
   return ghApi("PUT", `/repos/${owner}/${repo}/contents/${filePath}`, token, body);
 }
 
+async function paginateRepos(token, baseUrl) {
+  let all = [];
+  let page = 1;
+  while (page <= 5) { // cap at 500 repos
+    const url = `${baseUrl}${baseUrl.includes("?") ? "&" : "?"}page=${page}`;
+    const { status, data } = await ghApi("GET", url, token);
+    if (status !== 200 || !Array.isArray(data) || data.length === 0) break;
+    all = all.concat(data);
+    if (data.length < 100) break; // last page
+    page++;
+  }
+  return all;
+}
+
+function pickerRepoFilter(r) {
+  return !r.archived && r.name !== "egregore" && !r.name.endsWith("-memory");
+}
+
+function toPickerRepo(r) {
+  return { name: r.name, language: r.language || "", description: r.description || "" };
+}
+
+// Teams the user belongs to in this org. Big orgs bury a team's repos past
+// the 500-most-recently-updated cap of the org-wide listing, so a team scope
+// is often the only practical way to find them. Non-fatal on error.
+async function listUserTeams(token, org) {
+  try {
+    const teams = await paginateRepos(token, "/user/teams?per_page=100");
+    const orgLc = org.toLowerCase();
+    return teams
+      .filter((t) => t.organization && (t.organization.login || "").toLowerCase() === orgLc)
+      .map((t) => ({ name: t.name, slug: t.slug, reposCount: t.repos_count }));
+  } catch {
+    return [];
+  }
+}
+
+async function listTeamRepos(token, org, teamSlug) {
+  const repos = await paginateRepos(token, `/orgs/${org}/teams/${teamSlug}/repos?per_page=100`);
+  return repos.filter(pickerRepoFilter).map(toPickerRepo);
+}
+
+// Live search across the WHOLE org/account via GitHub's search index —
+// unlike the listing endpoints this isn't bounded to a recency window, so
+// the picker can reach any repo the token can see. Non-fatal on error.
+async function searchOrgRepos(token, owner, isOrg, term) {
+  try {
+    const qualifier = isOrg ? `org:${owner}` : `user:${owner}`;
+    const q = encodeURIComponent(`${qualifier} ${term} in:name archived:false`);
+    const { status, data } = await ghApi("GET", `/search/repositories?q=${q}&per_page=30`, token);
+    if (status !== 200 || !data || !Array.isArray(data.items)) return [];
+    return data.items.filter(pickerRepoFilter).map(toPickerRepo);
+  } catch {
+    return [];
+  }
+}
+
 async function listOrgRepos(token, owner, isOrg) {
   // Fetch all repos (public + private). Paginate to get beyond the first 100.
   //
@@ -214,16 +271,7 @@ async function listOrgRepos(token, owner, isOrg) {
     ? `/orgs/${owner}/repos?per_page=100&sort=updated&type=all`
     : `/user/repos?per_page=100&sort=updated&affiliation=owner`;
 
-  let allRepos = [];
-  let page = 1;
-  while (page <= 5) { // cap at 500 repos
-    const url = `${baseUrl}&page=${page}`;
-    const { status, data } = await ghApi("GET", url, token);
-    if (status !== 200 || !Array.isArray(data) || data.length === 0) break;
-    allRepos = allRepos.concat(data);
-    if (data.length < 100) break; // last page
-    page++;
-  }
+  let allRepos = await paginateRepos(token, baseUrl);
 
   // Personal /user/repos returns repos across all of the user's accounts
   // (their personal namespace + any orgs they're a member of). When the
@@ -233,9 +281,7 @@ async function listOrgRepos(token, owner, isOrg) {
     allRepos = allRepos.filter((r) => r.owner && r.owner.login === owner);
   }
 
-  return allRepos
-    .filter((r) => !r.archived && r.name !== "egregore" && !r.name.endsWith("-memory"))
-    .map((r) => ({ name: r.name, language: r.language || "", description: r.description || "" }));
+  return allRepos.filter(pickerRepoFilter).map(toPickerRepo);
 }
 
 async function addCollaborator(token, owner, repo, username) {
@@ -709,24 +755,67 @@ async function localFounderFlow(ui, ctx = {}) {
         ? ctx.prefilledRepo.name
         : null;
 
-    // Multi-select repos to manage
+    // Multi-select repos to manage. The org-wide listing is capped at the
+    // 500 most recently updated repos, which buries a team's repos in a big
+    // org — so the user's team repos are loaded too and boosted to the top,
+    // and typing in the picker live-searches the WHOLE org (see
+    // searchOrgRepos), so no repo is unreachable.
     const s0 = ui.spinner("Loading repos...");
+    let repos = [];
+    let teamRepoCount = 0;
     try {
-      const repos = await listOrgRepos(githubToken, githubOrg, isOrg);
-      s0.stop("Loaded repos");
-      if (repos.length > 0) {
-        const filtered = autoAdopt ? repos.filter((r) => r.name !== autoAdopt) : repos;
-        if (autoAdopt) {
-          console.log("");
-          ui.info(`${ui.cyan(autoAdopt)} will be managed automatically (your current repo)`);
+      const [orgRepos, teams] = await Promise.all([
+        listOrgRepos(githubToken, githubOrg, isOrg),
+        isOrg ? listUserTeams(githubToken, githubOrg) : Promise.resolve([]),
+      ]);
+      const teamRepoLists = await Promise.all(
+        teams.map((t) => listTeamRepos(githubToken, githubOrg, t.slug).catch(() => [])),
+      );
+      const seen = new Set();
+      for (const list of teamRepoLists) {
+        for (const r of list) {
+          if (seen.has(r.name)) continue;
+          seen.add(r.name);
+          repos.push(r);
         }
-        selectedRepos = await ui.multiSelect("Which other repos should Egregore manage?", filtered);
-      } else {
-        ui.info("No repos found yet.");
       }
+      teamRepoCount = repos.length;
+      for (const r of orgRepos) {
+        if (seen.has(r.name)) continue;
+        seen.add(r.name);
+        repos.push(r);
+      }
+      s0.stop(teamRepoCount > 0 ? `Loaded repos — your teams' ${teamRepoCount} first` : "Loaded repos");
     } catch {
       s0.stop("Could not load repos");
     }
+
+    const filtered = autoAdopt ? repos.filter((r) => r.name !== autoAdopt) : repos;
+    if (autoAdopt) {
+      console.log("");
+      ui.info(`${ui.cyan(autoAdopt)} will be managed automatically (your current repo)`);
+    }
+    selectedRepos = await ui.multiSelect(
+      "Which other repos should Egregore manage?",
+      filtered,
+      { remoteSearch: (term) => searchOrgRepos(githubToken, githubOrg, isOrg, term) },
+    );
+
+    // Non-interactive terminals get no live search — keep a typed-names
+    // escape hatch there, validated so a typo doesn't become a ghost repo.
+    if (!(ui.canInteract && ui.canInteract())) {
+      const extraRaw = await ui.prompt("any repos not listed? exact names, comma-separated (Enter to skip)");
+      for (const raw of (extraRaw || "").split(",")) {
+        const name = raw.trim();
+        if (!name || selectedRepos.includes(name)) continue;
+        if (await repoExists(githubToken, githubOrg, name)) {
+          selectedRepos.push(name);
+          ui.success(`Added ${name}`);
+        } else {
+          ui.warn(`No repo ${githubOrg}/${name} — skipping`);
+        }
+      }
+    }
     if (autoAdopt && !selectedRepos.includes(autoAdopt)) {
       selectedRepos.unshift(autoAdopt);
     }
@@ -756,17 +845,39 @@ async function localFounderFlow(ui, ctx = {}) {
     }
   }
 
-  // 6. Derive repo names from team name
-  const nameSlug = orgName
+  // 6. Derive repo names from team name — then let the founder edit them.
+  // Creating repos with silently derived names was a repeated field
+  // complaint: founders want to choose what lands in their org.
+  const slugifyName = (s) => (s || "")
     .toLowerCase()
     .replace(/[^a-z0-9-]/g, "-")
     .replace(/-+/g, "-")
-    .replace(/^-|-$/g, "") || "egregore";
+    .replace(/^-|-$/g, "");
+  const nameSlug = slugifyName(orgName) || "egregore";
   // Org slug prefixed with GitHub owner — globally unique across all egregores
-  const ghPrefix = githubOrg.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  const ghPrefix = slugifyName(githubOrg);
   const slug = ghPrefix === nameSlug ? nameSlug : `${ghPrefix}-${nameSlug}`;
-  const repoName = nameSlug;
-  const memoryRepoName = `${nameSlug}-memory`;
+
+  console.log("");
+  ui.note([
+    `Two repos will be created in ${ui.bold(githubOrg)}: the Egregore repo`,
+    "(config + skills) and its shared-memory repo. Enter keeps the defaults.",
+  ]);
+  let repoName;
+  for (;;) {
+    repoName = slugifyName(await ui.prompt("Egregore repo name", { default: nameSlug }));
+    if (!repoName) { ui.warn("That doesn't produce a valid repo name. Try letters, numbers, and dashes."); continue; }
+    if (newProjectRepo && repoName === newProjectRepo) { ui.warn(`"${repoName}" is already your project repo. Pick a different name.`); continue; }
+    break;
+  }
+  let memoryRepoName;
+  for (;;) {
+    memoryRepoName = slugifyName(await ui.prompt("memory repo name", { default: `${repoName}-memory` }));
+    if (!memoryRepoName) { ui.warn("That doesn't produce a valid repo name. Try letters, numbers, and dashes."); continue; }
+    if (memoryRepoName === repoName) { ui.warn("Memory repo can't share the Egregore repo's name."); continue; }
+    if (newProjectRepo && memoryRepoName === newProjectRepo) { ui.warn(`"${memoryRepoName}" is already your project repo. Pick a different name.`); continue; }
+    break;
+  }
 
   // Guard: if egregore repo already exists with a config, don't overwrite
   console.log("");
@@ -1169,7 +1280,11 @@ async function localFounderFlow(ui, ctx = {}) {
         ...pickable.map((m) => ({ label: m.login, description: `@${githubOrg} member` })),
         { label: "Type a username", description: "invite someone not in the list" },
       ];
-      const picked = await ui.choose(first ? "who should we invite?" : "invite someone else?", choices);
+      const picked = await ui.choose(
+        first ? "who should we invite?" : "invite someone else?",
+        choices,
+        first ? "Inviting is optional — the first option skips this step." : undefined,
+      );
       if (picked.label === stopChoice.label) break;
       if (picked.label === "Type a username") {
         invUsername = await ui.prompt("GitHub username");

package/lib/ui.js

@@ -254,12 +254,37 @@ function visualRows(line, width = process.stdout.columns || 80) {
 
 // Render a picker frame and return { lines: number } so the next frame can
 // rewind and clear. Shared by choose + multiSelect.
-function renderPicker({ question, filterText, lines, help }) {
+//
+// `input` makes the type-to-search field a first-class affordance: the
+// labelled input renders on the question line even when empty, and the REAL
+// terminal cursor is parked right after the typed text so it blinks where
+// keystrokes land — users shouldn't have to discover typing by accident.
+let _parkedRows = 0;
+
+function unparkCursor() {
+  if (_parkedRows > 0) {
+    process.stdout.write(`\x1b[${_parkedRows}B\r`);
+    _parkedRows = 0;
+  }
+}
+
+function renderPicker({ question, filterText, lines, help, input }) {
   const out = [];
-  const filterLabel = filterText
-    ? `  ${DIM}filter:${RESET} ${filterText}${CYAN}▌${RESET}`
-    : "";
-  out.push(`  ${CYAN}◆${RESET} ${BOLD}${question}${RESET}${filterLabel ? "   " + filterLabel : ""}`);
+  const width = process.stdout.columns || 80;
+  const label = (input && input.label) || "filter";
+  const showInput = !!input || !!filterText;
+
+  // Bare header (no ANSI, no cursor glyph) drives the park-position math.
+  const headerPlain = `  ◆ ${question}   ${label}: ${filterText}`;
+  // Park only when the header fits one row — wrapped rows break the math.
+  const canPark = showInput && visualRows(headerPlain, width) === 1 && headerPlain.length + 1 < width;
+
+  if (showInput) {
+    const glyph = canPark ? "" : `${CYAN}▌${RESET}`;
+    out.push(`  ${CYAN}◆${RESET} ${BOLD}${question}${RESET}   ${DIM}${label}:${RESET} ${filterText}${glyph}`);
+  } else {
+    out.push(`  ${CYAN}◆${RESET} ${BOLD}${question}${RESET}`);
+  }
   out.push("");
   for (const line of lines) out.push(line);
   if (help) {
@@ -268,11 +293,17 @@ function renderPicker({ question, filterText, lines, help }) {
   }
   const text = out.join("\n") + "\n";
   process.stdout.write(text);
-  const width = process.stdout.columns || 80;
-  return out.reduce((sum, line) => sum + visualRows(line, width), 0);
+  const rows = out.reduce((sum, line) => sum + visualRows(line, width), 0);
+  _parkedRows = 0;
+  if (canPark) {
+    process.stdout.write(`\x1b[${rows}A\x1b[${headerPlain.length + 1}G`);
+    _parkedRows = rows;
+  }
+  return rows;
 }
 
 function clearLines(n) {
+  unparkCursor();
   if (n <= 0) return;
   // Move up n lines and clear from cursor to end of screen.
   process.stdout.write(`\x1b[${n}A\x1b[0J`);
@@ -389,6 +420,7 @@ async function interactiveChoose(question, options, hint) {
       if (!key) return;
       if ((key.ctrl && key.name === "c") || key.name === "escape") {
         cleanup();
+        unparkCursor();
         process.stdout.write(`\n  ${DIM}(cancelled)${RESET}\n`);
         process.exit(130);
       }
@@ -461,58 +493,143 @@ async function legacyChoose(question, options, hint) {
 // ── multiSelect: interactive multi-select picker ────────────────────
 //
 // options: [{ name, language?, description? }]
+// opts.remoteSearch: async (term) => [{ name, language?, description? }]
+//   Hybrid search source: typing filters the local pool instantly AND
+//   (debounced) queries the remote source, merging new results into the
+//   pool. Lets a picker seeded with a bounded window (e.g. the 500 most
+//   recently updated repos of a huge org) reach everything the API can
+//   search — no pagination, no separate "type the exact name" prompt.
 // returns: array of picked names
 // keys:
 //   ↑ ↓       navigate
 //   space     toggle current
-//   a         toggle all (respecting filter)
+//   ctrl-a    toggle all (respecting filter)
 //   enter     confirm
 //   type      filter
 //   esc       confirm with current selection
 
-async function multiSelect(question, options) {
-  if (options.length === 0) return [];
-  if (!canInteract()) return legacyMultiSelect(question, options);
-  return interactiveMultiSelect(question, options);
+async function multiSelect(question, options, opts = {}) {
+  // Remote search can populate an empty pool, but only interactively —
+  // the legacy numbered fallback has no live search.
+  if (!canInteract()) return options.length === 0 ? [] : legacyMultiSelect(question, options);
+  if (options.length === 0 && !opts.remoteSearch) return [];
+  return interactiveMultiSelect(question, options, opts);
 }
 
-async function interactiveMultiSelect(question, options) {
+const MULTISELECT_MAX_ROWS = 12;
+const REMOTE_SEARCH_DEBOUNCE_MS = 300;
+
+async function interactiveMultiSelect(question, options, opts = {}) {
   return new Promise((resolve) => {
     let cursor = 0;
     let filterText = "";
     const picked = new Set();
-    let visible = filterOptions(options, filterText, (o) => `${o.name} ${o.description || ""} ${o.language || ""}`);
+    // 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];
+    const poolNames = new Set(pool.map((o) => o.name));
+    const optText = (o) => `${o.name} ${o.description || ""} ${o.language || ""}`;
+    let visible = filterOptions(pool, filterText, optText);
     let lastLineCount = 0;
+    let searchTimer = null;
+    let searching = false;
 
-    const nameWidth = Math.min(36, Math.max(...options.map((o) => (o.name || "").length)));
+    const nameWidth = () =>
+      Math.min(36, Math.max(12, ...pool.map((o) => (o.name || "").length)));
 
     const render = (first = false) => {
-      const lines = visible.map((entry, i) => {
+      const w = nameWidth();
+      const renderRow = (entry, i) => {
         const { opt } = entry;
         const isCursor = i === cursor;
         const isPicked = picked.has(opt.name);
         const cursorMark = isCursor ? `${CYAN}❯${RESET}` : " ";
         const checkbox = isPicked ? `${GREEN}[✓]${RESET}` : `${DIM}[ ]${RESET}`;
-        const name = isCursor ? `${BOLD}${CYAN}${pad(opt.name, nameWidth)}${RESET}` : pad(opt.name, nameWidth);
+        const name = isCursor ? `${BOLD}${CYAN}${pad(opt.name, w)}${RESET}` : pad(opt.name, w);
         const lang = opt.language ? `  ${DIM}(${opt.language})${RESET}` : "";
         const desc = opt.description ? `  ${DIM}${opt.description}${RESET}` : "";
         return `    ${cursorMark}  ${checkbox}  ${name}${lang}${desc}`;
-      });
-      if (visible.length === 0) {
-        lines.push(`    ${DIM}(no matches)${RESET}`);
+      };
+
+      // Bounded viewport that follows the cursor — a huge org must not dump
+      // hundreds of rows into the terminal. "↑/↓ N more" mark the remainder.
+      const lines = [];
+      const total = visible.length;
+      let start = 0;
+      if (total > MULTISELECT_MAX_ROWS) {
+        start = Math.min(
+          Math.max(0, cursor - Math.floor(MULTISELECT_MAX_ROWS / 2)),
+          total - MULTISELECT_MAX_ROWS,
+        );
       }
+      const end = Math.min(total, start + MULTISELECT_MAX_ROWS);
+      if (start > 0) lines.push(`    ${DIM}↑ ${start} more${RESET}`);
+      for (let i = start; i < end; i++) lines.push(renderRow(visible[i], i));
+      if (end < total) lines.push(`    ${DIM}↓ ${total - end} more${RESET}`);
+      if (total === 0) {
+        lines.push(searching ? `    ${DIM}searching…${RESET}` : `    ${DIM}(no matches)${RESET}`);
+      }
+
       lines.push("");
-      lines.push(`    ${DIM}${picked.size} selected${RESET}`);
+      // Selected tray: picked names stay visible even when the current
+      // filter hides their rows — a selection must never look lost.
+      if (picked.size > 0) {
+        const names = [...picked].join(", ");
+        const maxW = Math.max(20, (process.stdout.columns || 80) - 20);
+        const shown = names.length > maxW ? names.slice(0, maxW - 1) + "…" : names;
+        lines.push(`    ${GREEN}✓${RESET} ${DIM}selected (${picked.size}):${RESET} ${shown}`);
+      } else {
+        lines.push(`    ${DIM}0 selected${RESET}`);
+      }
+      if (searching && total > 0) lines.push(`    ${DIM}searching…${RESET}`);
+
+      const searchHint = opts.remoteSearch ? "type to search" : "type to filter";
       if (!first) clearLines(lastLineCount);
       lastLineCount = renderPicker({
         question,
         filterText,
         lines,
-        help: `${DIM}↑↓${RESET} nav · ${DIM}space${RESET} toggle · ${DIM}a${RESET} all · ${DIM}enter${RESET} confirm · type to filter`,
+        input: { label: opts.remoteSearch ? "search" : "filter" },
+        help: `${DIM}↑↓${RESET} nav · ${DIM}space${RESET} toggle · ${DIM}ctrl-a${RESET} all · ${DIM}enter${RESET} confirm · ${searchHint}`,
       });
     };
 
+    const refreshVisible = () => {
+      visible = filterOptions(pool, filterText, optText);
+      if (cursor >= visible.length) cursor = Math.max(0, visible.length - 1);
+    };
+
+    // Debounced remote search: merge results into the pool, ignore stale
+    // responses (the term changed while the request was in flight).
+    const scheduleRemoteSearch = () => {
+      if (!opts.remoteSearch) return;
+      if (searchTimer) clearTimeout(searchTimer);
+      const term = filterText.trim();
+      if (term.length < 2) { searching = false; return; }
+      searching = true;
+      searchTimer = setTimeout(() => {
+        Promise.resolve(opts.remoteSearch(term))
+          .then((results) => {
+            if (filterText.trim() !== term) return; // stale
+            for (const r of results || []) {
+              if (!r || !r.name || poolNames.has(r.name)) continue;
+              poolNames.add(r.name);
+              pool.push(r);
+            }
+            searching = false;
+            refreshVisible();
+            render();
+          })
+          .catch(() => {
+            if (filterText.trim() !== term) return;
+            searching = false; // network hiccup — local filter still works
+            render();
+          });
+      }, REMOTE_SEARCH_DEBOUNCE_MS);
+    };
+
     const cleanup = () => {
+      if (searchTimer) clearTimeout(searchTimer);
       process.stdin.setRawMode(false);
       process.stdin.pause();
       process.stdin.removeListener("keypress", onKey);
@@ -546,6 +663,7 @@ async function interactiveMultiSelect(question, options) {
       if (!key) return;
       if ((key.ctrl && key.name === "c") || key.name === "escape") {
         cleanup();
+        unparkCursor();
         process.stdout.write(`\n  ${DIM}(cancelled)${RESET}\n`);
         process.exit(130);
       }
@@ -565,22 +683,27 @@ async function interactiveMultiSelect(question, options) {
         render();
         return;
       }
-      if (_str === "a" && !filterText) {
+      // ctrl-a, not bare "a": with live type-to-search, a bare letter must
+      // always go to the filter — typing "alpha-api" on an empty filter used
+      // to toggle-all on the first keystroke.
+      if (key.ctrl && key.name === "a") {
         toggleAll();
         render();
         return;
       }
       if (key.name === "backspace") {
         filterText = filterText.slice(0, -1);
-        visible = filterOptions(options, filterText, (o) => `${o.name} ${o.description || ""} ${o.language || ""}`);
+        refreshVisible();
         cursor = 0;
+        scheduleRemoteSearch();
         render();
         return;
       }
       if (_str && _str.length === 1 && !key.ctrl && !key.meta && _str.charCodeAt(0) >= 32) {
         filterText += _str;
-        visible = filterOptions(options, filterText, (o) => `${o.name} ${o.description || ""} ${o.language || ""}`);
+        refreshVisible();
         cursor = 0;
+        scheduleRemoteSearch();
         render();
       }
     };
@@ -886,7 +1009,7 @@ module.exports = {
   banner, bannerCompact, section, note, card,
   info, success, warn, error, step,
   dim, bold, cyan, green, yellow, red,
-  spinner, prompt, choose, multiSelect, confirm,
+  spinner, prompt, choose, multiSelect, confirm, canInteract,
   commandBox,
   canShowScreens, welcomeScreen, summaryScreen,
   _renderWelcomeBody, _readPkgVersion,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-egregore",
-  "version": "0.18.15",
+  "version": "0.18.17",
   "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": "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:e2e": "node --test test/e2e-local.test.js",
     "test:all": "node scripts/build-runtime-bundle.mjs --check && node --test test/"
   },
@@ -30,7 +30,7 @@
   ],
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/Curve-Labs/egregore.git",
-    "directory": "packages/create-egregore"
-  }
+    "url": "git+https://github.com/egregore-labs/egregore.git"
+  },
+  "homepage": "https://github.com/egregore-labs/egregore"
 }