create-egregore 0.20.3 → 0.20.5

package/assets/egregore-launcher.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// egregore-launcher-version: 0.20.3
+// egregore-launcher-version: 0.20.5
 //
 // egregore — launch and browse Egregore instances from your terminal.
 // Installed by create-egregore. Reads ~/.egregore/instances.json.
@@ -33,7 +33,7 @@ const crypto = require("node:crypto");
 const { spawnSync, spawn } = require("node:child_process");
 const readline = require("node:readline");
 
-const VERSION = "0.20.3";
+const VERSION = "0.20.5";
 const REGISTRY = path.join(os.homedir(), ".egregore", "instances.json");
 const DEFAULT_FILE = path.join(os.homedir(), ".egregore", "default");
 const UPDATE_CACHE_FILE = path.join(os.homedir(), ".egregore", "update-check.json");
@@ -689,72 +689,120 @@ async function renderCodexStartupCard(egregoreDir) {
   return false;
 }
 
-function codexSupportMessage(egregoreDir) {
-  return [
-    "Codex harness support is missing from this Egregore checkout.",
-    `  path: ${egregoreDir}`,
-    "",
-    "This checkout needs a newer Egregore core with:",
-    "  bin/codex-session-start.sh",
-    "  bin/codex-install-skills.sh",
-    "  .codex/config.toml",
-    "  .codex/skills/",
-    "  .codex/hooks.json",
-    "  .codex/hooks/",
-    "",
-    "Restore this instance using its installed runtime version, then rerun egregore.",
-    "A global CLI refresh does not repair instance files.",
-    "Egregore workflows appear as slash commands. In Codex, invoke them with the matching $skill token or ask in natural language.",
-  ].join("\n");
+const CORE_SUPPORT_PATHS = {
+  codex: [
+    "bin/codex-session-start.sh",
+    "bin/codex-install-skills.sh",
+    ".codex/config.toml",
+    ".codex/skills",
+    ".codex/hooks.json",
+    ".codex/hooks",
+  ],
+  pi: [
+    "bin/pi-session-start.sh",
+    ".pi/APPEND_SYSTEM.md",
+    ".pi/settings.json",
+    ".pi/extensions/egregore.ts",
+    ".codex/skills",
+  ],
+  prime: [
+    "bin/prime-session-start.sh",
+    ".prime/agent/APPEND_SYSTEM.md",
+    ".prime/agent/settings.json",
+    ".prime/agent/extensions/egregore.ts",
+    ".codex/skills",
+  ],
+};
+
+function missingCorePaths(runtime, egregoreDir) {
+  return (CORE_SUPPORT_PATHS[runtime] || []).filter(
+    (rel) => !fs.existsSync(path.join(egregoreDir, ...rel.split("/"))),
+  );
 }
 
 function hasCodexCoreSupport(egregoreDir) {
-  return (
-    fs.existsSync(path.join(egregoreDir, "bin", "codex-session-start.sh")) &&
-    fs.existsSync(path.join(egregoreDir, "bin", "codex-install-skills.sh")) &&
-    fs.existsSync(path.join(egregoreDir, ".codex", "config.toml")) &&
-    fs.existsSync(path.join(egregoreDir, ".codex", "skills")) &&
-    fs.existsSync(path.join(egregoreDir, ".codex", "hooks.json")) &&
-    fs.existsSync(path.join(egregoreDir, ".codex", "hooks"))
-  );
+  return missingCorePaths("codex", egregoreDir).length === 0;
 }
 
 function hasPiCoreSupport(egregoreDir) {
-  return (
-    fs.existsSync(path.join(egregoreDir, "bin", "pi-session-start.sh")) &&
-    fs.existsSync(path.join(egregoreDir, ".pi", "APPEND_SYSTEM.md")) &&
-    fs.existsSync(path.join(egregoreDir, ".pi", "settings.json")) &&
-    fs.existsSync(path.join(egregoreDir, ".pi", "extensions", "egregore.ts")) &&
-    fs.existsSync(path.join(egregoreDir, ".codex", "skills"))
-  );
+  return missingCorePaths("pi", egregoreDir).length === 0;
 }
 
-function piSupportMessage(egregoreDir) {
-  return [
-    "Pi meta-harness support is missing from this Egregore checkout.",
+function hasPrimeCoreSupport(egregoreDir) {
+  return missingCorePaths("prime", egregoreDir).length === 0;
+}
+
+// The repair command is pinned to this launcher's own release. `@latest`
+// once pulled another release channel's files into an instance; the
+// launcher and the files it installs must always be the same version.
+function harnessAddCommand(runtime) {
+  return `npx -y ${PUBLIC_NPX_PACKAGE}@${VERSION} --add-harness ${runtimeShort(runtime)}`;
+}
+
+function harnessSupportMessage(runtime, egregoreDir) {
+  const label = runtimeLabel(runtime);
+  const missing = missingCorePaths(runtime, egregoreDir);
+  const lines = [
+    `${label} support is missing from this Egregore checkout.`,
     `  path: ${egregoreDir}`,
+  ];
+  if (missing.length > 0) {
+    lines.push("", "Missing:");
+    for (const rel of missing) lines.push(`  ${rel}`);
+  }
+  lines.push(
     "",
-    "Restore this instance using its installed runtime version, then rerun egregore.",
-  ].join("\n");
+    `Add ${label} support to this instance (missing files only, nothing overwritten):`,
+    `  cd ${egregoreDir}`,
+    `  ${harnessAddCommand(runtime)}`,
+    "Then rerun egregore.",
+  );
+  if (runtime === "codex") {
+    lines.push("Egregore workflows appear as slash commands. In Codex, invoke them with the matching $skill token or ask in natural language.");
+  }
+  return lines.join("\n");
 }
 
-function hasPrimeCoreSupport(egregoreDir) {
-  return (
-    fs.existsSync(path.join(egregoreDir, "bin", "prime-session-start.sh")) &&
-    fs.existsSync(path.join(egregoreDir, ".prime", "agent", "APPEND_SYSTEM.md")) &&
-    fs.existsSync(path.join(egregoreDir, ".prime", "agent", "settings.json")) &&
-    fs.existsSync(path.join(egregoreDir, ".prime", "agent", "extensions", "egregore.ts")) &&
-    fs.existsSync(path.join(egregoreDir, ".codex", "skills"))
-  );
+function codexSupportMessage(egregoreDir) {
+  return harnessSupportMessage("codex", egregoreDir);
+}
+
+function piSupportMessage(egregoreDir) {
+  return harnessSupportMessage("pi", egregoreDir);
 }
 
 function primeSupportMessage(egregoreDir) {
-  return [
-    "Prime Agent runtime support is missing from this Egregore checkout.",
-    `  path: ${egregoreDir}`,
+  return harnessSupportMessage("prime", egregoreDir);
+}
+
+// A launch that fails the support check offers to add exactly that harness
+// to exactly this instance, using this launcher's own release. Without a
+// terminal to ask, print the command and stop; never install unattended.
+async function ensureHarnessSupport(inst, runtime) {
+  if (missingCorePaths(runtime, inst.path).length === 0) return;
+  const message = harnessSupportMessage(runtime, inst.path);
+  if (!canPrompt()) die(message);
+  const label = runtimeLabel(runtime);
+  const name = inst.name || inst.slug || path.basename(inst.path);
+  process.stdout.write([
     "",
-    "Restore this instance using its installed runtime version, then rerun egregore.",
-  ].join("\n");
+    `  ${BOLD}${label} support is missing from ${name}.${RESET}`,
+    `  ${DIM}Missing: ${missingCorePaths(runtime, inst.path).join(", ")}${RESET}`,
+    `  ${DIM}Egregore can add it now. Only missing files are written; nothing is overwritten:${RESET}`,
+    `    ${harnessAddCommand(runtime)}`,
+    "",
+  ].join("\n"));
+  const yes = await confirmLine(`Add ${label} support to ${name} now?`);
+  if (!yes) die(message);
+  const result = spawnSync(
+    "npx",
+    ["-y", `${PUBLIC_NPX_PACKAGE}@${VERSION}`, "--add-harness", runtimeShort(runtime)],
+    { cwd: inst.path, stdio: "inherit", env: process.env, timeout: 3 * 60 * 1000 },
+  );
+  if (result.error || result.status !== 0 || missingCorePaths(runtime, inst.path).length > 0) {
+    die(`${label} support could not be added automatically.\n\n${harnessSupportMessage(runtime, inst.path)}`);
+  }
+  process.stdout.write(`  ${GREEN}✓${RESET} ${label} support added to ${name}\n\n`);
 }
 
 // Minimal y/N line prompt for pre-launch decisions (the TUI select machinery
@@ -809,7 +857,7 @@ function primeAuthHint() {
 
 function installCodexSkills(egregoreDir) {
   const script = path.join(egregoreDir, "bin", "codex-install-skills.sh");
-  if (!fs.existsSync(script)) return false;
+  if (!fs.existsSync(script)) return { ok: false, stderr: `missing ${script}` };
   try {
     const result = spawnSync("bash", [script], {
       cwd: egregoreDir,
@@ -817,9 +865,9 @@ function installCodexSkills(egregoreDir) {
       encoding: "utf-8",
       maxBuffer: 1024 * 1024,
     });
-    return result.status === 0;
-  } catch {
-    return false;
+    return { ok: result.status === 0, stderr: (result.stderr || "").trim() };
+  } catch (err) {
+    return { ok: false, stderr: String(err && err.message ? err.message : err) };
   }
 }
 
@@ -886,29 +934,31 @@ async function launch(inst, runtimeOverride) {
     }
   }
   if (runtime === "codex") {
-    // Launching never changes an instance's runtime or release channel.
-    if (!hasCodexCoreSupport(inst.path)) die(codexSupportMessage(inst.path));
-    const skillsInstalled = installCodexSkills(inst.path);
+    // Launching never changes an instance's runtime or release channel. A
+    // missing harness is added only with the user's consent, one harness
+    // into this one instance, at this launcher's own version.
+    await ensureHarnessSupport(inst, runtime);
+    const skills = installCodexSkills(inst.path);
+    if (!skills.ok) {
+      die(`Codex skill setup failed in ${inst.path} (bin/codex-install-skills.sh):\n${skills.stderr || "  (no error output)"}`);
+    }
     const cardRendered = await renderCodexStartupCard(inst.path);
-    if (!skillsInstalled || !cardRendered) {
-      die(codexSupportMessage(inst.path));
+    if (!cardRendered) {
+      die(`Codex startup card failed in ${inst.path} (bin/codex-session-start.sh exited non-zero; its output is above).`);
     }
   } else if (runtime === "pi") {
-    if (!hasPiCoreSupport(inst.path)) {
-      die(piSupportMessage(inst.path));
-    }
+    await ensureHarnessSupport(inst, runtime);
   }
   let launchArgs = null;
   if (runtime === "prime") {
+    await ensureHarnessSupport(inst, runtime);
     // Cover the gap between choosing the harness and Prime's first paint:
-    // the loader runs through the launcher-side pre-flight (core-support
-    // check + the trust-flag probe, which shells out to the binary), then a
-    // single handoff line explains the remaining in-harness startup.
+    // the loader runs through the launcher-side pre-flight (the trust-flag
+    // probe, which shells out to the binary), then a single handoff line
+    // explains the remaining in-harness startup.
     const stopLoader = startSpinner("Starting Prime Agent");
-    const coreOk = hasPrimeCoreSupport(inst.path);
-    launchArgs = coreOk ? runtimeLaunchArgs(runtime, inst.path) : null;
+    launchArgs = runtimeLaunchArgs(runtime, inst.path);
     stopLoader();
-    if (!coreOk) die(primeSupportMessage(inst.path));
     primeAuthHint();
     process.stdout.write(`  ${CYAN}◆${RESET} ${BOLD}Prime Agent starting${RESET}${DIM} — the Egregore greeting loads inside in a few seconds${RESET}\n`);
   }

package/bin/cli.js

@@ -89,6 +89,32 @@ function detectCwdEgregore(cwd) {
   }
 }
 
+// Resolve which instance `--add-harness` writes into. Explicit `--instance`
+// wins; otherwise the current directory when it is an instance; otherwise the
+// only registered instance. Several registered instances and no explicit
+// choice is an error — this command must never fan out.
+function resolveAddHarnessTarget(explicitPath) {
+  const isInstance = (dir) => dir && fs.existsSync(path.join(dir, "egregore.json"));
+  if (explicitPath) {
+    const dir = path.resolve(explicitPath);
+    if (isInstance(dir)) return dir;
+    ui.error(`Not an Egregore instance: ${dir} (no egregore.json).`);
+    return null;
+  }
+  let cwd = null;
+  try { cwd = process.cwd(); } catch {}
+  if (isInstance(cwd)) return cwd;
+  const registered = readLocalInstances().filter((inst) => isInstance(inst.path));
+  if (registered.length === 1) return path.resolve(registered[0].path);
+  if (registered.length === 0) {
+    ui.error("No Egregore instance found. Run this inside the instance directory, or pass --instance <path>.");
+    return null;
+  }
+  ui.error("Several Egregore instances are registered. Pass --instance <path> to choose one:");
+  for (const inst of registered) ui.info(`  ${inst.path}`);
+  return null;
+}
+
 function binaryOnPath(bin) {
   return commandExists(bin);
 }
@@ -199,6 +225,14 @@ function parseArgs(argv) {
       args.refreshLauncher = true;
     } else if (argv[i] === "--refresh-connect") {
       args.refreshConnect = true;
+    } else if (argv[i] === "--add-harness" && argv[i + 1]) {
+      args.addHarness = argv[++i];
+    } else if (argv[i].startsWith("--add-harness=")) {
+      args.addHarness = argv[i].split("=")[1];
+    } else if (argv[i] === "--instance" && argv[i + 1]) {
+      args.instance = argv[++i];
+    } else if (argv[i].startsWith("--instance=")) {
+      args.instance = argv[i].split("=")[1];
     } else if (argv[i] === "--codex") {
       args.runtime = "codex";
     } else if (argv[i] === "--pi") {
@@ -375,6 +409,8 @@ function showHelp() {
   ui.info("  --no-autolaunch   Don't launch the harness at the end (for CI)");
   ui.info("  --no-screens      Skip the full-screen welcome/ready bookends");
   ui.info("  --refresh-launcher Refresh only the global Egregore CLI, then exit");
+  ui.info("  --add-harness <h> Add codex, pi, or prime support to one existing instance (missing files only)");
+  ui.info("  --instance <path> Instance for --add-harness (default: cwd, or the only registered instance)");
   ui.info("  -h, --help        Show this help");
   ui.info("");
 }
@@ -421,6 +457,39 @@ async function main() {
     }
   }
 
+  if (args.addHarness) {
+    // Explicit, instance-scoped harness addition. This is the only path that
+    // writes harness files into an existing instance from the global CLI: one
+    // harness, one instance, missing files only. The launcher invokes it with
+    // its own pinned version when a launch fails the support check.
+    const { addHarnessRuntime, harnessLabel, normalizeHarness } = require("../lib/harness-add");
+    const harness = normalizeHarness(args.addHarness);
+    if (!harness) {
+      ui.error(`Unknown harness "${args.addHarness}". Use --add-harness codex, pi, or prime.`);
+      process.exit(1);
+    }
+    const targetDir = resolveAddHarnessTarget(args.instance);
+    if (!targetDir) process.exit(1);
+    try {
+      const summary = addHarnessRuntime(targetDir, harness);
+      const label = harnessLabel(harness);
+      if (summary.installed.length === 0) {
+        ui.success(`${label} support already present in ${targetDir}`);
+      } else {
+        ui.success(`Added ${label} support to ${targetDir} ${ui.dim(`(${summary.installed.length} files, ${summary.present} kept)`)}`);
+      }
+      if (!summary.ready) {
+        ui.warn(`${label} support is still incomplete in ${targetDir}; an existing file may be a directory or symlink where a file is expected.`);
+        process.exit(1);
+      }
+      ui.info(`Run: egregore --runtime ${harness}`);
+      return;
+    } catch (err) {
+      ui.error(String(err.message || err));
+      process.exit(1);
+    }
+  }
+
   if (args.refreshConnect) {
     // Session-start maintenance mode: refresh the Connect overlay for an
     // existing instance. Local instances no-op instantly; network failure is
@@ -543,75 +612,20 @@ async function main() {
 }
 
 async function tokenFlow(api, token, ctx) {
-  const s = ui.spinner("Claiming setup token...");
-  let data;
-  try {
-    data = await api.claimToken(token);
-    s.stop(`Claimed — setting up ${ui.bold(data.org_name)}`);
-  } catch (err) {
-    s.fail("Token claim failed");
-    ui.error(err.message);
-    ui.info("");
-    ui.info("The token may have expired or already been used.");
-    ui.info("Visit egregore.xyz to get a new one, or run without --token:");
-    ui.info("  npx -y create-egregore@latest");
-    process.exit(1);
-  }
-
-  // Joiner tokens don't include a github_token — try gh CLI first. If gh is
-  // installed but logged out, run gh auth login instead of device flow.
-  if (!data.github_token || data.needs_cli_auth) {
-    const ghAuth = tryGhAuthOrLogin(ui, data.needs_cli_auth ? { mode: "join" } : {});
-    if (ghAuth) {
-      ui.success(`Using your ${ui.bold("gh")} CLI auth${ghAuth.user ? ` (${ghAuth.user})` : ""}`);
-      data.github_token = ghAuth.token;
-    } else if (ghCliExists()) {
-      ui.error("GitHub CLI auth did not complete.");
-      ui.info(`Run ${ui.bold("gh auth login")} and then re-run this command.`);
-      process.exit(1);
-    } else {
+  const { installFromToken } = require("../lib/token-install");
+  await installFromToken(api, token, ctx, {
+    ui, install, request: ghApi,
+    authenticate: async (forceLogin) => {
+      const auth = tryGhAuthOrLogin(ui, { mode: "join", requireRepoScope: true, forceLogin });
+      if (auth) return auth;
+      if (ghCliExists()) return null;
       if (!canUseInteractiveBrowserFlow()) {
         explainNoGhHeadless(ui);
-        process.exit(1);
-      }
-      ui.info("\nSign in to your GitHub to complete setup.\n");
-      try {
-        data.github_token = await deviceFlow(ui, data.needs_cli_auth ? { mode: "join" } : {});
-        ui.success("Authenticated with GitHub");
-      } catch (err) {
-        ui.error(`GitHub auth failed: ${err.message}`);
-        process.exit(1);
+        return null;
       }
-    }
-  }
-
-  // Token-mode setups already have their repo list baked in server-side. If
-  // the user's current working repo happens to match a managed-repo name, skip
-  // the clone/pull/configure step for it so we don't clobber uncommitted work.
-  const skipRepos = new Set();
-  if (ctx.prefilledRepo && Array.isArray(data.repos)) {
-    for (const r of data.repos) {
-      const n = typeof r === "string" ? r : r && r.name;
-      if (n && n === ctx.prefilledRepo.name) skipRepos.add(n);
-    }
-  }
-  try {
-    await install(data, ui, ctx.targetDir, {
-      skipRepos,
-      noAutolaunch: ctx.noAutolaunch,
-      noScreens: ctx.noScreens,
-      flowVariant: ctx.flowVariant,
-      runtime: ctx.runtime,
-    });
-    if (ctx.prefilledRepo && skipRepos.size === 0) {
-      console.log("");
-      ui.info(`Tip: add your current repo to managed_repos with:`);
-      ui.info(`  /add ${ctx.prefilledRepo.toplevel || `../${ctx.prefilledRepo.localName}`}`);
-    }
-  } catch (err) {
-    ui.error(`Install failed: ${err.message}`);
-    process.exit(1);
-  }
+      return { token: await deviceFlow(ui, { mode: "join", scope: "repo" }) };
+    },
+  });
 }
 
 async function interactiveFlow(api, ctx) {

package/lib/api.js

@@ -63,8 +63,12 @@ class EgregoreAPI {
     this.base = (baseUrl || DEFAULT_API).replace(/\/$/, "");
   }
 
-  async claimToken(token) {
-    return request("GET", `${this.base}/api/org/claim/${token}`);
+  async claimToken(token, githubToken) {
+    // Old APIs reject POST without consuming a one-time setup token. Never
+    // silently downgrade an authenticated retry to the legacy GET protocol.
+    return request(githubToken ? "POST" : "GET", `${this.base}/api/org/claim/${token}`, {
+      headers: githubToken ? { Authorization: `Bearer ${githubToken}` } : {},
+    });
   }
 
   async getOrgs(githubToken) {

package/lib/auth.js

@@ -212,7 +212,7 @@ function runGhAuthLogin(ui, opts = {}) {
 
 function tryGhAuthOrLogin(ui, opts = {}) {
   const existing = tryGhAuth();
-  if (existing) return existing;
+  if (existing && !opts.forceLogin && !(opts.requireRepoScope && existing.hasRepoScope === false)) return existing;
   if (!ghCliExists()) return null;
   return runGhAuthLogin(ui, opts);
 }

package/lib/harness-add.js

@@ -0,0 +1,159 @@
+"use strict";
+
+// Add one harness (Codex, Pi, Prime Agent) to an existing instance.
+//
+// Setup overlays only the harness chosen at install time, so a Claude-only
+// instance has no Codex files. The September 2026 launcher auto-repair fixed
+// that by running the *latest* installer against *every* registered instance,
+// which overwrote and deleted files in instances on another release channel.
+// This module is the scoped replacement:
+//
+//   - one harness, one instance, chosen explicitly;
+//   - copies only files that are missing from that harness's packaged bundle;
+//   - never overwrites, never deletes, never touches another harness;
+//   - records what it wrote in its own manifest so nothing else claims
+//     ownership of pre-existing files.
+
+const fs = require("node:fs");
+const path = require("node:path");
+
+const PACKAGE = require("../package.json");
+
+const HARNESSES = {
+  codex: { label: "Codex", module: "./codex-runtime", bundle: "codex" },
+  pi: { label: "Pi", module: "./pi-runtime", bundle: "pi" },
+  prime: { label: "Prime Agent", module: "./prime-runtime", bundle: "prime" },
+};
+
+function normalizeHarness(name) {
+  const value = String(name || "").trim().toLowerCase();
+  if (value === "codex") return "codex";
+  if (value === "pi") return "pi";
+  if (value === "prime" || value === "prime-agent") return "prime";
+  return null;
+}
+
+function harnessLabel(harness) {
+  return (HARNESSES[harness] && HARNESSES[harness].label) || harness;
+}
+
+function bundleDirFor(harness) {
+  return path.join(__dirname, "..", "runtime", HARNESSES[harness].bundle);
+}
+
+function listFiles(dir, prefix = "") {
+  if (!fs.existsSync(dir)) return [];
+  const result = [];
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const rel = prefix ? path.join(prefix, entry.name) : entry.name;
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      result.push(...listFiles(full, rel));
+    } else if (entry.isFile()) {
+      result.push(rel);
+    }
+  }
+  return result.sort();
+}
+
+function pathExistsOrSymlink(file) {
+  try {
+    fs.lstatSync(file);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function copyMissingFile(src, dest) {
+  fs.mkdirSync(path.dirname(dest), { recursive: true });
+  fs.copyFileSync(src, dest);
+  try {
+    const mode = fs.statSync(src).mode & 0o777;
+    fs.chmodSync(dest, mode);
+  } catch {}
+}
+
+// Required paths come from the harness module so the CLI and the launcher's
+// pre-launch check agree on what "support present" means.
+function requiredPathsFor(harness) {
+  const mod = require(HARNESSES[harness].module);
+  const checker = mod.hasCodexRuntimeSupport || mod.hasPiRuntimeSupport || mod.hasPrimeRuntimeSupport;
+  return { hasSupport: (dir) => Boolean(checker && checker(dir)) };
+}
+
+function manifestPath(egregoreDir, harness) {
+  return path.join(egregoreDir, ".egregore", `${harness}-harness-add.json`);
+}
+
+// Current Codex discovers project skills via .agents/skills -> ../.codex/skills.
+// Create the link only when nothing is there; never replace a real directory.
+function ensureAgentsSkillsLink(egregoreDir, summary) {
+  const agentsDir = path.join(egregoreDir, ".agents");
+  const link = path.join(agentsDir, "skills");
+  if (pathExistsOrSymlink(link)) return;
+  try {
+    fs.mkdirSync(agentsDir, { recursive: true });
+    fs.symlinkSync(path.join("..", ".codex", "skills"), link);
+    summary.installed.push(".agents/skills");
+  } catch {}
+}
+
+/**
+ * Copy every file of `harness`'s packaged bundle that is missing from
+ * `egregoreDir`. Existing files are left untouched regardless of content.
+ *
+ * Returns { harness, installed: [rel...], present: n, ready: bool }.
+ */
+function addHarnessRuntime(egregoreDir, harnessName) {
+  const harness = normalizeHarness(harnessName);
+  if (!harness) {
+    throw new Error(`Unknown harness "${harnessName}". Expected codex, pi, or prime.`);
+  }
+  const bundleDir = bundleDirFor(harness);
+  if (!fs.existsSync(bundleDir)) {
+    throw new Error(`This create-egregore release ships no ${harnessLabel(harness)} bundle (${bundleDir}).`);
+  }
+  if (!fs.existsSync(path.join(egregoreDir, "egregore.json"))) {
+    throw new Error(`Not an Egregore instance: ${egregoreDir} (no egregore.json).`);
+  }
+
+  const summary = { harness, installed: [], present: 0, ready: false };
+  for (const rel of listFiles(bundleDir)) {
+    if (rel === "manifest.json") continue;
+    const dest = path.join(egregoreDir, rel);
+    if (pathExistsOrSymlink(dest)) {
+      summary.present += 1;
+      continue;
+    }
+    copyMissingFile(path.join(bundleDir, rel), dest);
+    summary.installed.push(rel);
+  }
+  if (harness === "codex") ensureAgentsSkillsLink(egregoreDir, summary);
+
+  summary.ready = requiredPathsFor(harness).hasSupport(egregoreDir);
+
+  if (summary.installed.length > 0) {
+    const file = manifestPath(egregoreDir, harness);
+    const previous = (() => {
+      try { return JSON.parse(fs.readFileSync(file, "utf-8")); } catch { return { files: [] }; }
+    })();
+    const files = Array.from(new Set([...(previous.files || []), ...summary.installed])).sort();
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, JSON.stringify({
+      package: PACKAGE.name,
+      version: PACKAGE.version,
+      harness,
+      addedAt: new Date().toISOString(),
+      files,
+    }, null, 2) + "\n");
+  }
+  return summary;
+}
+
+module.exports = {
+  HARNESSES,
+  addHarnessRuntime,
+  harnessLabel,
+  normalizeHarness,
+};

package/lib/install-access.js

@@ -0,0 +1,87 @@
+/** Repository access for a connected install. Never accept unrelated invitations. */
+class RepositoryAccessError extends Error {
+  constructor(message, canReauthenticate = false) {
+    super(message);
+    this.name = "RepositoryAccessError";
+    this.canReauthenticate = canReauthenticate;
+  }
+}
+
+function repositoryFromUrl(value) {
+  const url = new URL(value);
+  const name = url.pathname.replace(/^\//, "").replace(/\.git$/, "");
+  if (url.protocol !== "https:" || url.hostname !== "github.com" || url.username || url.password ||
+      url.search || url.hash || !/^[\w.-]+\/[\w.-]+$/.test(name)) {
+    throw new Error("Setup contains an invalid GitHub repository URL.");
+  }
+  return name;
+}
+
+function requiredRepositories(data) {
+  const names = [repositoryFromUrl(data.fork_url), repositoryFromUrl(data.memory_url)];
+  for (const entry of data.repos || []) {
+    const name = typeof entry === "string" ? entry : entry?.name;
+    if (!/^[\w.-]+$/.test(name || "") || name === "." || name === "..") {
+      throw new Error("Setup contains an invalid managed repository name.");
+    }
+    names.push(repositoryFromUrl(`https://github.com/${data.github_org}/${name}`));
+  }
+  return [...new Map(names.map(name => [name.toLowerCase(), name])).values()];
+}
+
+function matchesIdentity(data, user) {
+  // IDs survive account renames. Older payloads can only be checked by login.
+  if (data.github_id != null) return String(data.github_id) === String(user?.id);
+  return !!data.github_username && data.github_username.toLowerCase() === user?.login?.toLowerCase();
+}
+
+async function ensureRepositoryAccess(data, ui, { request, sleep = ms => new Promise(r => setTimeout(r, ms)) }) {
+  const token = data.github_token;
+  if (!token) throw new RepositoryAccessError("GitHub authentication is required for this installation.", true);
+  const who = await request("GET", "/user", token);
+  if (who.status !== 200) throw new RepositoryAccessError(`GitHub identity check failed (HTTP ${who.status}).`, who.status === 401 || who.status === 403);
+  if (!matchesIdentity(data, who.data)) throw new RepositoryAccessError("Your active GitHub account does not match the account that accepted this invitation. Sign in to that account and retry.");
+
+  const required = requiredRepositories(data);
+  async function missingRepos() {
+    const missing = [];
+    for (const name of required) {
+      const result = await request("GET", `/repos/${name}`, token);
+      if (result.status === 200 && result.data?.permissions?.pull !== false) continue;
+      if (![401, 403, 404, 200].includes(result.status)) {
+        throw new RepositoryAccessError(`GitHub access check for ${name} failed (HTTP ${result.status}). Retry the same install command.`);
+      }
+      missing.push(name);
+    }
+    return missing;
+  }
+  let missing = await missingRepos();
+  if (!missing.length) return required;
+  const wanted = new Set(missing.map(name => name.toLowerCase()));
+  // Collect before accepting: removing invitations while paginating would skip entries.
+  const invitations = [];
+  for (let page = 1; ; page++) {
+    const result = await request("GET", `/user/repository_invitations?per_page=100&page=${page}`, token);
+    if (result.status !== 200 || !Array.isArray(result.data)) {
+      throw new RepositoryAccessError(`Could not list GitHub repository invitations (HTTP ${result.status}); access is missing for ${missing.join(", ")}.`, [401, 403].includes(result.status));
+    }
+    invitations.push(...result.data.filter(inv => wanted.has(inv.repository?.full_name?.toLowerCase())));
+    if (result.data.length < 100) break;
+    if (page === 100) throw new RepositoryAccessError("GitHub returned too many invitation pages. Retry after reviewing pending invitations.");
+  }
+  let acceptanceError;
+  for (const inv of invitations) {
+    const result = await request("PATCH", `/user/repository_invitations/${inv.id}`, token);
+    if (result.status >= 200 && result.status < 300) ui.success(`Accepted invite to ${inv.repository.full_name}`);
+    else acceptanceError = new RepositoryAccessError(`Could not accept the GitHub invitation for ${inv.repository.full_name} (HTTP ${result.status}).`, [401, 403].includes(result.status));
+  }
+  // A concurrent acceptance can reject our PATCH yet leave effective access ready.
+  for (let attempt = 0; attempt < 3; attempt++) {
+    missing = await missingRepos();
+    if (!missing.length) return required;
+    if (attempt < 2) await sleep(250 * (attempt + 1));
+  }
+  throw acceptanceError || new RepositoryAccessError(`GitHub access is still missing for ${missing.join(", ")}. Confirm this account has been invited to these repositories, then retry the same install command.`, true);
+}
+
+module.exports = { RepositoryAccessError, requiredRepositories, matchesIdentity, ensureRepositoryAccess };

package/lib/setup.js

@@ -29,6 +29,7 @@ const {
 const { commandExists } = require("./path-lookup");
 
 const https = require("node:https");
+const { RepositoryAccessError, ensureRepositoryAccess } = require("./install-access");
 
 function run(cmd, opts = {}) {
   return execSync(cmd, { stdio: "pipe", encoding: "utf-8", timeout: 60000, ...opts }).trim();
@@ -52,6 +53,7 @@ function ghApi(method, apiPath, token, body) {
         path: apiPath,
         method,
         headers,
+        timeout: 15000,
       },
       (res) => {
         let buf = "";
@@ -66,6 +68,7 @@ function ghApi(method, apiPath, token, body) {
       }
     );
     req.on("error", reject);
+    req.on("timeout", () => req.destroy(new Error("GitHub request timed out. Retry the same install command.")));
     if (payload) req.write(payload);
     req.end();
   });
@@ -416,9 +419,15 @@ async function install(data, ui, targetDir, opts = {}) {
   // steps are skipped. Falls through to the normal flow if anything is off.
   const alreadyInstalled = isFullySetUp(egregoreDir, memoryDir, fork_url, memory_url);
 
-  // Accept pending repo collaboration invitations (joiners get invited as collaborators)
-  if (github_token) configureGitCredentials(github_token);
-  await acceptPendingInvitations(github_token, github_org, ui);
+  // Verify before credential writes or cloning. The same verified credential
+  // handles Git operations, so an unrelated SSH account cannot take over.
+  if (opts.verifyAccess) {
+    const required = await ensureRepositoryAccess(data, ui, { request: ghApi });
+    for (const name of required) verifyGitAccess(`https://github.com/${name}.git`, github_token);
+  } else {
+    if (github_token) configureGitCredentials(github_token);
+    await acceptPendingInvitations(github_token, github_org, ui);
+  }
 
   if (alreadyInstalled) {
     ui.success(`Already installed at ${ui.bold(egregoreDir)} — refreshing setup`);
@@ -426,7 +435,9 @@ async function install(data, ui, targetDir, opts = {}) {
   } else {
     // 1. Clone fork (SSH first, HTTPS fallback — no token embedding)
     ui.step(1, totalSteps, "Cloning egregore...");
-    if (fs.existsSync(egregoreDir)) {
+    if (opts.verifyAccess) {
+      syncAuthenticatedRepository(fork_url, egregoreDir, github_token);
+    } else if (fs.existsSync(egregoreDir)) {
       ui.warn("egregore/ already exists — pulling latest");
       run("git pull", { cwd: egregoreDir });
     } else {
@@ -449,7 +460,9 @@ async function install(data, ui, targetDir, opts = {}) {
 
     // 2. Clone memory
     ui.step(2, totalSteps, "Cloning shared memory...");
-    if (fs.existsSync(memoryDir)) {
+    if (opts.verifyAccess) {
+      syncAuthenticatedRepository(memory_url, memoryDir, github_token);
+    } else if (fs.existsSync(memoryDir)) {
       ui.warn(`${memoryDirName}/ already exists — pulling latest`);
       run("git pull", { cwd: memoryDir });
     } else {
@@ -576,7 +589,9 @@ async function install(data, ui, targetDir, opts = {}) {
       continue;
     }
     try {
-      if (fs.existsSync(repoDir)) {
+      if (opts.verifyAccess) {
+        syncAuthenticatedRepository(`https://github.com/${github_org}/${repoName}.git`, repoDir, github_token);
+      } else if (fs.existsSync(repoDir)) {
         ui.warn(`${repoName}/ already exists — pulling latest`);
         run("git pull", { cwd: repoDir });
       } else {
@@ -588,7 +603,8 @@ async function install(data, ui, targetDir, opts = {}) {
       try { run("git config credential.helper store", { cwd: repoDir }); } catch {}
       clonedRepos.push(repoName);
       ui.success(`Cloned ${repoName}`);
-    } catch {
+    } catch (err) {
+      if (opts.verifyAccess) throw err;
       failedRepos.push(repoName);
       ui.warn(`Could not clone ${repoName} — you may not have access yet. Ask the org admin to grant access.`);
     }
@@ -823,6 +839,61 @@ function gitCloneEnv(base = process.env) {
   };
 }
 
+function authenticatedGitEnv(token, base = process.env) {
+  if (!token || /[\r\n]/.test(token)) throw new Error("A valid GitHub credential is required.");
+  const env = gitCloneEnv(base);
+  const count = Number(env.GIT_CONFIG_COUNT || 0);
+  if (!Number.isSafeInteger(count) || count < 0) throw new Error("Invalid Git configuration environment.");
+  const settings = [
+    ["credential.helper", ""],
+    ["http.https://github.com/.extraheader", ""],
+    ["http.https://github.com/.extraheader", `Authorization: Basic ${Buffer.from("x-access-token:" + token).toString("base64")}`],
+  ];
+  settings.forEach(([key, value], index) => {
+    env[`GIT_CONFIG_KEY_${count + index}`] = key;
+    env[`GIT_CONFIG_VALUE_${count + index}`] = value;
+  });
+  env.GIT_CONFIG_COUNT = String(count + settings.length);
+  return env;
+}
+
+function authenticatedGit(args, token, cwd) {
+  try {
+    return execFileSync("git", args, {
+      cwd, env: authenticatedGitEnv(token), timeout: 60000,
+      stdio: "pipe", encoding: "utf-8",
+    }).trim();
+  } catch (err) {
+    const detail = redactToken(err.stderr || err.message, token)
+      .split(Buffer.from("x-access-token:" + token).toString("base64")).join("***");
+    throw new Error(`Git ${args[0]} failed: ${detail.trim()}`);
+  }
+}
+
+function verifyGitAccess(url, token) {
+  try {
+    authenticatedGit(["ls-remote", url], token);
+  } catch (err) {
+    throw new RepositoryAccessError(
+      `Cannot read ${url} with the verified GitHub account. ${err.message}`,
+      /authentication|could not read Username|not found|403|access denied/i.test(err.message),
+    );
+  }
+}
+
+function syncAuthenticatedRepository(url, dir, token) {
+  if (fs.existsSync(dir)) {
+    const origin = authenticatedGit(["remote", "get-url", "origin"], token, dir);
+    if (normalizeGitUrl(origin) !== normalizeGitUrl(url)) {
+      throw new Error(`Refusing to update ${dir}: its Git origin differs from this setup.`);
+    }
+    // A retry reuses completed clones. Do not merge a remote default branch
+    // into a user's working branch or disturb changes made after the failure.
+  } else {
+    authenticatedGit(["clone", url, dir], token);
+  }
+}
+
 /**
  * Clone a repo, trying SSH first then HTTPS (no token embedded).
  * The repo:invite-scoped OAuth token can't clone — we rely on the
@@ -1021,7 +1092,7 @@ function codexSupportMessage(egregoreDir) {
     "  .codex/hooks.json",
     "  .codex/hooks/",
     "",
-    "Restore this instance using its installed runtime version, then rerun egregore.",
+    `Add it with: npx -y create-egregore@${require("../package.json").version} --add-harness codex (run inside the instance; missing files only), then rerun egregore.`,
     "Egregore workflows appear as slash commands. In Codex, invoke them with the matching $skill token or ask in natural language.",
   ].join("\n");
 }
@@ -1035,7 +1106,7 @@ function piSupportMessage(egregoreDir) {
     "Pi meta-harness support is missing from this Egregore checkout.",
     `  path: ${egregoreDir}`,
     "",
-    "Restore this instance using its installed runtime version, then rerun egregore.",
+    `Add it with: npx -y create-egregore@${require("../package.json").version} --add-harness pi (run inside the instance; missing files only), then rerun egregore.`,
     "Pi loads Egregore through project-local .pi resources and the shared portable skill corpus.",
   ].join("\n");
 }
@@ -1045,7 +1116,7 @@ function primeSupportMessage(egregoreDir) {
     "Prime Agent runtime support is missing from this Egregore checkout.",
     `  path: ${egregoreDir}`,
     "",
-    "Restore this instance using its installed runtime version, then rerun egregore.",
+    `Add it with: npx -y create-egregore@${require("../package.json").version} --add-harness prime (run inside the instance; missing files only), then rerun egregore.`,
     "Prime Agent loads Egregore through project-local .prime/agent resources and the shared portable skill corpus.",
   ].join("\n");
 }
@@ -1544,6 +1615,9 @@ module.exports = {
   redactToken,
   configureGitCredentials,
   gitCloneEnv,
+  authenticatedGitEnv,
+  verifyGitAccess,
+  syncAuthenticatedRepository,
   assistantInstallCommand,
   initMemoryDirs,
   ensureDevelop,

package/lib/token-install.js

@@ -0,0 +1,65 @@
+/** Authenticate before redeeming, and keep retries on the original connected setup. */
+const { RepositoryAccessError, matchesIdentity } = require("./install-access");
+
+async function installFromToken(api, token, ctx, deps) {
+  const { ui, authenticate, request, install } = deps;
+  let auth = await authenticate(false);
+  if (!auth?.token) throw new Error("GitHub sign-in did not complete. Retry this install command to continue joining the same Egregore.");
+  let who = await request("GET", "/user", auth.token);
+  if ([401, 403].includes(who.status)) {
+    ui.info("Your GitHub session needs authentication. Signing in again before opening this setup.");
+    auth = await authenticate(true);
+    if (!auth?.token) throw new Error("GitHub sign-in did not complete. Retry this install command.");
+    who = await request("GET", "/user", auth.token);
+  }
+  if (who.status !== 200 || !who.data?.id) throw new Error(`GitHub identity check failed (HTTP ${who.status}). Retry after signing in.`);
+  const spinner = ui.spinner("Verifying setup...");
+  let data;
+  try {
+    data = await api.claimToken(token, auth.token);
+    spinner.stop(`Setting up ${ui.bold(data.org_name)}`);
+  } catch (err) {
+    spinner.fail("Could not open this setup");
+    if (/Method Not Allowed|HTTP 405/i.test(err.message)) {
+      throw new Error("The setup service needs the authenticated retry update before this installer can continue. The setup token has not been consumed.");
+    }
+    throw new Error(`${err.message}. Retry with the GitHub account that accepted the invitation. If the setup has expired, reopen the invitation page to continue joining the same Egregore.`);
+  }
+  if (!matchesIdentity(data, who.data)) throw new Error("This setup belongs to a different GitHub account. Sign in to the account that accepted the invitation and retry.");
+
+  const skipRepos = new Set();
+  if (ctx.prefilledRepo && Array.isArray(data.repos)) {
+    for (const repo of data.repos) {
+      const name = typeof repo === "string" ? repo : repo?.name;
+      if (name === ctx.prefilledRepo.name) skipRepos.add(name);
+    }
+  }
+  const options = {
+    skipRepos,
+    noAutolaunch: ctx.noAutolaunch,
+    noScreens: ctx.noScreens,
+    flowVariant: ctx.flowVariant,
+    runtime: ctx.runtime,
+    verifyAccess: true,
+  };
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      await install({ ...data, github_token: auth.token }, ui, ctx.targetDir, options);
+      return;
+    } catch (err) {
+      if (attempt === 0 && err instanceof RepositoryAccessError && err.canReauthenticate) {
+        ui.warn(err.message);
+        ui.info("Signing in again with permission to accept invitations and read the required repositories.");
+        const next = await authenticate(true);
+        if (next?.token) {
+          auth = next;
+          // install() verifies identity again before invitations or any writes.
+          continue;
+        }
+      }
+      throw new Error(`${err.message}\nRetry the same install command to continue this setup before its token expires.`);
+    }
+  }
+}
+
+module.exports = { installFromToken };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-egregore",
-  "version": "0.20.3",
+  "version": "0.20.5",
   "description": "Set up Egregore for your team in one command \u2014 installs the egregore launcher and your choice of Claude Code, Codex, or Pi.",
   "license": "MIT",
   "bin": {
@@ -13,7 +13,7 @@
     "build:runtime": "node ../../bin/capability-distribution.mjs generate-skill-view --root ../.. && node scripts/build-runtime-bundle.mjs && node scripts/build-pi-runtime-bundle.mjs && node scripts/build-prime-runtime-bundle.mjs && node ../../api/scripts/build-connect-runtime-pack.mjs",
     "build:pi-runtime": "node scripts/build-pi-runtime-bundle.mjs",
     "build:prime-runtime": "node scripts/build-prime-runtime-bundle.mjs",
-    "test": "node ../../bin/capability-distribution.mjs validate --root ../.. && node scripts/build-runtime-bundle.mjs --check && node scripts/build-pi-runtime-bundle.mjs --check && node scripts/build-prime-runtime-bundle.mjs --check && node ../../bin/prime-render-spec.mjs --check && node ../../bin/pi-render-spec.mjs --check && node ../../api/scripts/build-connect-runtime-pack.mjs --check && node --test test/capability-distribution.test.js test/connect-runtime.test.js test/context.test.js test/path-lookup.test.js test/nixos-portability.test.js test/parse-join-target.test.js test/skip-repos.test.js test/install-origin-guard.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/pi-runtime.test.js test/prime-runtime.test.js test/prime-branch-policy.test.js test/prime-bridge-skill.test.js test/prime-session-smoke.test.js test/pi-product-workflows.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/launcher-connect.test.js test/installer-connect-choice.test.js test/launcher-connected-status.test.js test/launcher-permissions.test.js test/launcher-update.test.js test/connected-config.test.js test/workflow-settings.test.js",
+    "test": "node ../../bin/capability-distribution.mjs validate --root ../.. && node scripts/build-runtime-bundle.mjs --check && node scripts/build-pi-runtime-bundle.mjs --check && node scripts/build-prime-runtime-bundle.mjs --check && node ../../bin/prime-render-spec.mjs --check && node ../../bin/pi-render-spec.mjs --check && node ../../api/scripts/build-connect-runtime-pack.mjs --check && node --test test/invite-install.test.js test/capability-distribution.test.js test/connect-runtime.test.js test/context.test.js test/path-lookup.test.js test/nixos-portability.test.js test/parse-join-target.test.js test/skip-repos.test.js test/install-origin-guard.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/pi-runtime.test.js test/prime-runtime.test.js test/prime-branch-policy.test.js test/prime-bridge-skill.test.js test/prime-session-smoke.test.js test/pi-product-workflows.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/launcher-connect.test.js test/installer-connect-choice.test.js test/launcher-connected-status.test.js test/launcher-permissions.test.js test/launcher-update.test.js test/harness-add.test.js test/connected-config.test.js test/workflow-settings.test.js",
     "test:e2e": "node --test test/e2e-local.test.js",
     "test:all": "node scripts/build-runtime-bundle.mjs --check && node scripts/build-pi-runtime-bundle.mjs --check && node --test test/"
   },