create-egregore 0.21.0-runtime-mvp.26 → 0.21.0-runtime-mvp.28

package/assets/egregore-launcher.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// egregore-launcher-version: 0.21.0-runtime-mvp.26
+// egregore-launcher-version: 0.21.0-runtime-mvp.28
 //
 // egregore — launch and browse Egregore instances from your terminal.
 // Installed by create-egregore. Reads ~/.egregore/instances.json.
@@ -35,7 +35,7 @@ const crypto = require("node:crypto");
 const { spawnSync, spawn } = require("node:child_process");
 const readline = require("node:readline");
 
-const VERSION = "0.21.0-runtime-mvp.26";
+const VERSION = "0.21.0-runtime-mvp.28";
 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");
@@ -753,72 +753,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
@@ -873,7 +921,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,
@@ -881,9 +929,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) };
   }
 }
 
@@ -966,29 +1014,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

@@ -91,6 +91,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);
 }
@@ -211,6 +237,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") {
@@ -386,7 +420,9 @@ function showHelp() {
   ui.info("  --force           Skip the in-repo detection check");
   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 the Egregore CLI and runtime packs, then exit");
+  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("");
 }
@@ -433,6 +469,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
@@ -559,75 +628,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,
+};