create-egregore 0.19.33 → 0.20.0

package/assets/egregore-launcher.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// egregore-launcher-version: 0.19.33
+// egregore-launcher-version: 0.20.0
 //
 // 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.19.33";
+const VERSION = "0.20.0";
 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");
@@ -368,6 +368,7 @@ function normalizeRuntime(raw) {
   if (value === "claude" || value === "claude-code" || value === "claude_code") return "claude-code";
   if (value === "codex" || value === "openai-codex" || value === "openai_codex") return "codex";
   if (value === "pi" || value === "pi-coding-agent" || value === "pi_coding_agent") return "pi";
+  if (value === "prime" || value === "prime-agent" || value === "prime_agent") return "prime";
   return null;
 }
 
@@ -380,6 +381,8 @@ function parseRuntimeFlags(argv) {
       runtimeOverride = "codex";
     } else if (arg === "--pi") {
       runtimeOverride = "pi";
+    } else if (arg === "--prime") {
+      runtimeOverride = "prime";
     } else if (arg === "--claude" || arg === "--claude-code") {
       runtimeOverride = "claude-code";
     } else if (arg === "--runtime") {
@@ -393,7 +396,7 @@ function parseRuntimeFlags(argv) {
     }
   }
   const normalized = runtimeOverride ? normalizeRuntime(runtimeOverride) : null;
-  if (runtimeOverride && !normalized) die(`unknown runtime: ${runtimeOverride}\n  expected claude-code, codex, or pi`);
+  if (runtimeOverride && !normalized) die(`unknown runtime: ${runtimeOverride}\n  expected claude-code, codex, pi, or prime`);
   return { args: rest, runtimeOverride: normalized };
 }
 
@@ -412,20 +415,23 @@ function runtimeFor(inst, runtimeOverride) {
 function runtimeLabel(runtime) {
   if (runtime === "codex") return "Codex";
   if (runtime === "pi") return "Pi";
+  if (runtime === "prime") return "Prime Agent";
   return "Claude Code";
 }
 
 function runtimeShort(runtime) {
-  return runtime === "codex" ? "codex" : runtime === "pi" ? "pi" : "claude-code";
+  return runtime === "codex" ? "codex" : runtime === "pi" ? "pi" : runtime === "prime" ? "prime" : "claude-code";
 }
 
 function runtimeBinary(runtime) {
-  return runtime === "codex" ? "codex" : runtime === "pi" ? "pi" : "claude";
+  return runtime === "codex" ? "codex" : runtime === "pi" ? "pi" : runtime === "prime" ? "prime-agent" : "claude";
 }
 
 function assistantInstallCommand(runtime) {
   if (runtime === "codex") return "npm install -g @openai/codex";
   if (runtime === "pi") return "npm install -g --ignore-scripts @earendil-works/pi-coding-agent";
+  // Prime Agent is not on the public npm registry — install via its own script.
+  if (runtime === "prime") return "curl -fsSL https://app.primeintellect.ai/prime-agent/install.sh | sh";
   return "npm install -g @anthropic-ai/claude-code";
 }
 
@@ -438,6 +444,15 @@ function piTrustArgs() {
   }
 }
 
+function primeTrustArgs() {
+  try {
+    const help = spawnSync("prime-agent", ["--help"], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+    return `${help.stdout || ""}\n${help.stderr || ""}`.includes("--approve") ? ["--approve"] : [];
+  } catch {
+    return [];
+  }
+}
+
 function commandExists(bin) {
   if (typeof bin !== "string" || bin.length === 0) return false;
   const pathValue = process.env.PATH || process.env.Path || process.env.path || "";
@@ -477,7 +492,7 @@ function runtimeChoiceDescription(runtime, inst, stored) {
   bits.push("installed");
   if (runtime === stored) bits.push("saved default");
   if (runtime === "codex") bits.push("portable agent protocol");
-  else if (runtime === "pi") bits.push("project-local meta-harness");
+  else if (runtime === "pi" || runtime === "prime") bits.push("project-local meta-harness");
   else bits.push("Claude Code integration");
   return bits.join(" · ");
 }
@@ -590,7 +605,7 @@ function runtimeChoicesFor(inst, runtimeOverride) {
   const override = normalizeRuntime(runtimeOverride);
   if (override) return [override];
   const stored = storedRuntimeFor(inst);
-  const choices = [stored, ...["claude-code", "codex", "pi"].filter((runtime) => runtime !== stored)];
+  const choices = [stored, ...["claude-code", "codex", "pi", "prime"].filter((runtime) => runtime !== stored)];
   return choices.sort((a, b) => Number(commandExists(runtimeBinary(b))) - Number(commandExists(runtimeBinary(a))));
 }
 
@@ -722,6 +737,75 @@ function piSupportMessage(egregoreDir) {
   ].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 primeSupportMessage(egregoreDir) {
+  return [
+    "Prime Agent runtime support is missing from this Egregore checkout.",
+    `  path: ${egregoreDir}`,
+    "",
+    "Run npx -y create-egregore@latest to install the packaged Prime Agent runtime, then rerun egregore.",
+  ].join("\n");
+}
+
+// Minimal y/N line prompt for pre-launch decisions (the TUI select machinery
+// is torn down by the time launch() runs).
+function confirmLine(question) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(`  ${question} [Y/n] `, (answer) => {
+      rl.close();
+      resolve(!/^n/i.test(String(answer).trim()));
+    });
+  });
+}
+
+// Guided install: never leave the user alone with a curl one-liner. Runs the
+// official installer with full output visible, then re-checks the binary.
+async function offerPrimeInstall() {
+  const command = assistantInstallCommand("prime");
+  process.stdout.write([
+    "",
+    `  ${BOLD}Prime Agent isn't installed.${RESET}`,
+    `  ${DIM}Egregore can run the official installer now:${RESET}`,
+    `    ${command}`,
+    "",
+  ].join("\n"));
+  const yes = await confirmLine("Install Prime Agent now?");
+  if (!yes) return false;
+  const result = spawnSync("sh", ["-c", command], { stdio: "inherit" });
+  if (result.status !== 0 || !commandExists(runtimeBinary("prime"))) {
+    process.stdout.write(`\n  ${DIM}Installer did not complete — run it manually, then: egregore${RESET}\n`);
+    return false;
+  }
+  process.stdout.write(`\n  ${CYAN}✓${RESET} Prime Agent installed\n`);
+  return true;
+}
+
+// Auth stays harness-owned; the launcher only removes the dead end of a first
+// session with no model account connected.
+function primeAuthHint() {
+  const agentDir = process.env.PRIME_AGENT_CODING_AGENT_DIR ||
+    path.join(os.homedir(), ".prime", "agent");
+  try {
+    const auth = JSON.parse(fs.readFileSync(path.join(agentDir, "auth.json"), "utf-8"));
+    if (auth && Object.keys(auth).length > 0) return;
+  } catch {}
+  process.stdout.write(
+    `\n  ${DIM}First run: connect a model account inside Prime Agent — type ${RESET}/login${DIM}` +
+    ` (Claude Pro/Max subscription or an API key). Heads-up: subscription usage in` +
+    ` third-party harnesses bills per token as extra usage.${RESET}\n\n`,
+  );
+}
+
 function installCodexSkills(egregoreDir) {
   const script = path.join(egregoreDir, "bin", "codex-install-skills.sh");
   if (!fs.existsSync(script)) return false;
@@ -766,6 +850,7 @@ function runtimeLaunchArgs(runtime, egregoreDir) {
     ];
   }
   if (runtime === "pi") return piTrustArgs();
+  if (runtime === "prime") return primeTrustArgs();
   return claudeLaunchArgs(egregoreDir);
 }
 
@@ -792,7 +877,12 @@ async function launch(inst, runtimeOverride) {
   }
   const binary = runtimeBinary(runtime);
   if (!commandExists(binary)) {
-    die(`${runtimeLabel(runtime)} is not installed.\n  Install it with:\n    ${assistantInstallCommand(runtime)}\n  Then run: egregore`);
+    // Never run a curl|sh installer off non-interactive stdin: piped or
+    // closed input must fall through to the printed install command.
+    const installed = runtime === "prime" && canPrompt() && await offerPrimeInstall();
+    if (!installed) {
+      die(`${runtimeLabel(runtime)} is not installed.\n  Install it with:\n    ${assistantInstallCommand(runtime)}\n  Then run: egregore`);
+    }
   }
   if (runtime === "codex") {
     if (!hasCodexCoreSupport(inst.path)) {
@@ -806,6 +896,20 @@ async function launch(inst, runtimeOverride) {
   } else if (runtime === "pi") {
     if (!hasPiCoreSupport(inst.path)) die(piSupportMessage(inst.path));
   }
+  let launchArgs = null;
+  if (runtime === "prime") {
+    // 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.
+    const stopLoader = startSpinner("Starting Prime Agent");
+    const coreOk = hasPrimeCoreSupport(inst.path);
+    launchArgs = coreOk ? runtimeLaunchArgs(runtime, inst.path) : null;
+    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`);
+  }
   // Claude Code renders the greeting in-chat — no pre-launch card. Claude Code
   // ≥2.1.89 boots into the alternate screen buffer, which hides anything
   // printed here; the launcher-card fast path is parked in PR #1493.
@@ -816,7 +920,7 @@ async function launch(inst, runtimeOverride) {
     EGREGORE_RUNTIME: runtime,
     EGREGORE_CODEX_TRUSTED: runtime === "codex" ? "1" : process.env.EGREGORE_CODEX_TRUSTED,
   };
-  const child = spawn(binary, runtimeLaunchArgs(runtime, inst.path), {
+  const child = spawn(binary, launchArgs || runtimeLaunchArgs(runtime, inst.path), {
     cwd: inst.path,
     stdio: "inherit",
     env: launchEnv,
@@ -940,7 +1044,7 @@ function cmdHelp() {
     `    ${CYAN}egregore${RESET}                     pick an instance, then pick a harness`,
     `    ${CYAN}egregore${RESET} ${DIM}<slug|name>${RESET}         pick a harness for the matching instance`,
     `    ${CYAN}egregore --runtime${RESET} ${DIM}<name> <slug>${RESET}  advanced harness override`,
-    `      ${DIM}names: claude-code · codex · pi${RESET}`,
+    `      ${DIM}names: claude-code · codex · pi · prime${RESET}`,
     `    ${CYAN}egregore browse${RESET}              force the full-screen browser`,
     `    ${CYAN}egregore ls${RESET} ${DIM}| list${RESET}            list installed instances`,
     `    ${CYAN}egregore use${RESET} ${DIM}<slug>${RESET}          set the default for bare ${BOLD}egregore${RESET}`,
@@ -2176,6 +2280,7 @@ function renderHeroPanel({ selected, pv, width, height, countSuffix, filter, fil
       `${DIM}claude-code${RESET}: ${commandExists("claude") ? "installed" : "not installed"}`,
       `${DIM}codex${RESET}: ${commandExists("codex") ? "installed" : "not installed"}`,
       `${DIM}pi${RESET}: ${commandExists("pi") ? "installed" : "not installed"}`,
+      `${DIM}prime${RESET}: ${commandExists("prime-agent") ? "installed" : "not installed"}`,
       `${DIM}Hermes — Coming Soon${RESET}`,
     ];
     const rows = Math.max(EGREGORE_SIGIL.length + 2, right.length);
@@ -2188,11 +2293,11 @@ function renderHeroPanel({ selected, pv, width, height, countSuffix, filter, fil
     lines.push(boxLine(`${BOLD}Available Skills${RESET}`, innerWidth, margin));
     for (const group of skillGroups) lines.push(boxLine(group, innerWidth, margin));
     lines.push(emptyBoxLine(innerWidth, margin));
-    lines.push(boxLine(`${BOLD}Harnesses${RESET} ${DIM}claude-code${RESET} ${commandExists("claude") ? "installed" : "missing"} · ${DIM}codex${RESET} ${commandExists("codex") ? "installed" : "missing"} · ${DIM}pi${RESET} ${commandExists("pi") ? "installed" : "missing"} · ${DIM}Hermes — Coming Soon${RESET}`, innerWidth, margin));
+    lines.push(boxLine(`${BOLD}Harnesses${RESET} ${DIM}claude-code${RESET} ${commandExists("claude") ? "installed" : "missing"} · ${DIM}codex${RESET} ${commandExists("codex") ? "installed" : "missing"} · ${DIM}pi${RESET} ${commandExists("pi") ? "installed" : "missing"} · ${DIM}prime${RESET} ${commandExists("prime-agent") ? "installed" : "missing"} · ${DIM}Hermes — Coming Soon${RESET}`, innerWidth, margin));
   }
 
   lines.push(emptyBoxLine(innerWidth, margin));
-  lines.push(boxLine(`${DIM}enter selects an instance, then choose Claude Code, Codex, or Pi without leaving this screen${RESET}`, innerWidth, margin));
+  lines.push(boxLine(`${DIM}enter selects an instance, then choose Claude Code, Codex, Pi, or Prime Agent without leaving this screen${RESET}`, innerWidth, margin));
   lines.push(bottom);
   return lines;
 }
@@ -2555,7 +2660,7 @@ async function browser(args = {}) {
       const label = (k) => `${DIM}${pad(k, 10)}${RESET}`;
       previewLines.push(`  ${label("action")} ${BOLD}Set up a new Egregore${RESET}`);
       previewLines.push(`  ${label("flow")} guided install, Telegram, invite, ready/start`);
-      previewLines.push(`  ${label("harness")} choose Claude Code, Codex, or Pi during setup`);
+      previewLines.push(`  ${label("harness")} choose Claude Code, Codex, Pi, or Prime Agent during setup`);
       previewLines.push(`  ${label("start")} press enter to begin`);
     } else if (!selected) {
       previewLines.push(`${DIM}  (no selection)${RESET}`);

package/bin/cli.js

@@ -35,6 +35,11 @@ const {
   installPiRuntime,
   reportPiRuntimeSummary,
 } = require("../lib/pi-runtime");
+const {
+  hasPrimeRuntimeSupport,
+  installPrimeRuntime,
+  reportPrimeRuntimeSummary,
+} = require("../lib/prime-runtime");
 const {
   connectEligibility,
   fetchConnectRuntimePack,
@@ -111,6 +116,7 @@ function assistantLabel(runtime) {
   const normalized = normalizeRuntime(runtime);
   if (normalized === "codex") return "Codex";
   if (normalized === "pi") return "Pi";
+  if (normalized === "prime") return "Prime Agent";
   return "Claude Code";
 }
 
@@ -137,6 +143,12 @@ async function upgradePortableRuntimesForExisting(instances) {
         label: `Pi meta-harness for ${inst.slug || inst.name || path.basename(inst.path)}`,
         includeConflicts: !piReady,
       });
+      const primeSummary = installPrimeRuntime(inst.path);
+      const primeReady = hasPrimeRuntimeSupport(inst.path);
+      reportPrimeRuntimeSummary(primeSummary, ui, {
+        label: `Prime Agent runtime for ${inst.slug || inst.name || path.basename(inst.path)}`,
+        includeConflicts: !primeReady,
+      });
       const connectSummary = await installConnectRuntime(inst.path, { validatedPack: connectPack });
       reportConnectRuntimeSummary(connectSummary, ui, {
         label: `Connect features for ${inst.slug || inst.name || path.basename(inst.path)}`,
@@ -163,9 +175,10 @@ async function chooseRuntime(args) {
     "claude-code": binaryOnPath("claude"),
     codex: binaryOnPath("codex"),
     pi: binaryOnPath("pi"),
+    prime: binaryOnPath("prime-agent"),
   };
   const recommended = Object.keys(installedByRuntime).find((runtime) => installedByRuntime[runtime]) || "claude-code";
-  const choices = ["claude-code", "codex", "pi"]
+  const choices = ["claude-code", "codex", "pi", "prime"]
     .map((runtime) => {
       const installed = installedByRuntime[runtime];
       const label = assistantLabel(runtime);
@@ -173,7 +186,7 @@ async function chooseRuntime(args) {
       return {
         label: `${label}${installed ? "" : " (not installed)"}${recommended === runtime ? " (recommended)" : ""}`,
         description: installed
-          ? (runtime === "claude-code" ? "Installed · Claude Code integration" : runtime === "pi" ? "Installed · project-local meta-harness" : "Installed · portable agent protocol")
+          ? (runtime === "claude-code" ? "Installed · Claude Code integration" : runtime === "pi" || runtime === "prime" ? "Installed · project-local meta-harness" : "Installed · portable agent protocol")
           : missingCopy,
         runtime,
         installed,
@@ -249,6 +262,8 @@ function parseArgs(argv) {
       args.runtime = "codex";
     } else if (argv[i] === "--pi") {
       args.runtime = "pi";
+    } else if (argv[i] === "--prime") {
+      args.runtime = "prime";
     } else if (argv[i] === "--claude" || argv[i] === "--claude-code") {
       args.runtime = "claude-code";
     } else if (argv[i] === "--runtime" && argv[i + 1]) {
@@ -412,8 +427,9 @@ function showHelp() {
   ui.info("  --api <url>       Use connected API setup with this URL");
   ui.info("  --codex           Prefer Codex for this local install");
   ui.info("  --pi              Prefer Pi for this local install");
+  ui.info("  --prime           Prefer Prime Agent for this local install");
   ui.info("  --claude          Prefer Claude Code for this local install");
-  ui.info("  --runtime <name>  Harness override: claude-code, codex, or pi");
+  ui.info("  --runtime <name>  Harness override: claude-code, codex, pi, or prime");
   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");

package/lib/connect-runtime.js

@@ -83,14 +83,16 @@ function validateConnectPack(pack) {
   if (pack.schemaVersion !== 1 || pack.availability !== "connect") {
     throw new Error(`Unsupported Connect runtime pack schema: ${pack.schemaVersion}`);
   }
-  if (!Array.isArray(pack.skills) || pack.skills.length === 0) {
+  if (!Array.isArray(pack.skills)) {
     throw new Error("Connect runtime pack has no skill inventory");
   }
+  // An empty inventory is valid: every gated connector skill can ship in the
+  // OSS base, leaving the overlay with nothing to add for now.
   const skills = [...new Set(pack.skills)];
   if (skills.length !== pack.skills.length || skills.some((name) => !/^[a-z0-9-]+$/.test(name))) {
     throw new Error("Connect runtime pack has an invalid skill inventory");
   }
-  if (!Array.isArray(pack.files) || pack.files.length === 0 || pack.files.length > MAX_FILES) {
+  if (!Array.isArray(pack.files) || pack.files.length > MAX_FILES) {
     throw new Error("Connect runtime pack has an invalid file inventory");
   }
   if (!/^[a-f0-9]{64}$/.test(pack.packVersion || "")) {

package/lib/local.js

@@ -17,6 +17,7 @@ const {
 } = require("./auth");
 const { installCodexRuntime, reportCodexRuntimeSummary } = require("./codex-runtime");
 const { installPiRuntime, reportPiRuntimeSummary } = require("./pi-runtime");
+const { installPrimeRuntime, reportPrimeRuntimeSummary } = require("./prime-runtime");
 const {
   install,
   ghApi,
@@ -1398,6 +1399,17 @@ async function localFounderFlow(ui, ctx = {}) {
         run("git push", { cwd: egregoreDir });
       }
     } catch {}
+  } else if (preferredRuntime === "prime") {
+    const primeRuntime = installPrimeRuntime(egregoreDir);
+    reportPrimeRuntimeSummary(primeRuntime, ui);
+    try {
+      const toCommit = Array.isArray(primeRuntime.files) ? [...primeRuntime.files] : [];
+      if (toCommit.length) {
+        execFileSync("git", ["add", "--", ...toCommit], { cwd: egregoreDir, stdio: "pipe" });
+        run('git commit -m "Add Prime Agent meta-harness runtime"', { cwd: egregoreDir });
+        run("git push", { cwd: egregoreDir });
+      }
+    } catch {}
   } else {
     stripCodexRuntimeForClaude(egregoreDir, ui);
   }
@@ -1570,7 +1582,9 @@ async function localFounderFlow(ui, ctx = {}) {
     ? "Codex"
     : preferredRuntime === "pi"
       ? "Pi"
-      : "Claude Code";
+      : preferredRuntime === "prime"
+        ? "Prime Agent"
+        : "Claude Code";
   const setupSummary = {
     workspace: "created",
     invite: invitedUsers.length

package/lib/prime-runtime.js

@@ -0,0 +1,208 @@
+"use strict";
+
+const crypto = require("node:crypto");
+const fs = require("node:fs");
+const path = require("node:path");
+
+const PACKAGE = require("../package.json");
+
+const BUNDLE_DIR = path.join(__dirname, "..", "runtime", "prime");
+const BUNDLE_MANIFEST = path.join(BUNDLE_DIR, "manifest.json");
+const LOCAL_MANIFEST = path.join(".egregore", "prime-runtime-manifest.json");
+
+const REQUIRED_RUNTIME_PATHS = [
+  "AGENTS.md",
+  ".prime/agent/APPEND_SYSTEM.md",
+  ".prime/agent/settings.json",
+  ".prime/agent/extensions/egregore.ts",
+  ".prime/agent/skills/egregore/SKILL.md",
+  ".codex/skills",
+  "bin/agent.sh",
+  "bin/pi-branch-policy.mjs",
+  "bin/pi-product-workflows.mjs",
+  "bin/prime-session-start.sh",
+  "bin/codex-session-start.sh",
+  "bin/codex-skill-render.mjs",
+];
+
+function hashBuffer(buffer) {
+  return crypto.createHash("sha256").update(buffer).digest("hex");
+}
+
+function readJson(file, fallback) {
+  try {
+    return JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch {
+    return fallback;
+  }
+}
+
+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 bundleManifest() {
+  return readJson(BUNDLE_MANIFEST, { files: [], skills: [], skillCount: 0 });
+}
+
+function bundleFiles() {
+  return listFiles(BUNDLE_DIR).filter((rel) => rel !== "manifest.json");
+}
+
+function installManifestPath(egregoreDir) {
+  const gitPath = path.join(egregoreDir, ".git");
+  try {
+    const stat = fs.lstatSync(gitPath);
+    if (stat.isDirectory()) return path.join(gitPath, "info", "egregore-prime-runtime.json");
+    if (stat.isFile()) {
+      const match = fs.readFileSync(gitPath, "utf8").trim().match(/^gitdir:\s*(.+)$/);
+      if (match) {
+        const gitDir = path.isAbsolute(match[1]) ? match[1] : path.resolve(egregoreDir, match[1]);
+        return path.join(gitDir, "info", "egregore-prime-runtime.json");
+      }
+    }
+  } catch {}
+  return path.join(egregoreDir, LOCAL_MANIFEST);
+}
+
+function pathExists(file) {
+  try {
+    fs.lstatSync(file);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function copyFile(src, dest) {
+  fs.mkdirSync(path.dirname(dest), { recursive: true });
+  fs.copyFileSync(src, dest);
+  try { fs.chmodSync(dest, fs.statSync(src).mode & 0o777); } catch {}
+}
+
+function installPrimeRuntime(egregoreDir) {
+  if (!fs.existsSync(BUNDLE_DIR)) throw new Error(`Prime runtime bundle missing: ${BUNDLE_DIR}`);
+
+  const previousPath = installManifestPath(egregoreDir);
+  const previous = readJson(previousPath, { files: {} });
+  const previousFiles = previous.files || {};
+  const next = {
+    package: PACKAGE.name,
+    version: PACKAGE.version,
+    installedAt: new Date().toISOString(),
+    files: {},
+  };
+  const summary = {
+    installed: 0,
+    updated: 0,
+    removed: 0,
+    skipped: 0,
+    conflicted: 0,
+    conflicts: [],
+    files: [],
+    bundleSkills: bundleManifest().skills || [],
+    bundleSkillCount: bundleManifest().skillCount || 0,
+  };
+  const currentBundleFiles = bundleFiles();
+  const currentBundleSet = new Set(currentBundleFiles);
+
+  for (const [rel, record] of Object.entries(previousFiles)) {
+    if (currentBundleSet.has(rel)) continue;
+    const dest = path.join(egregoreDir, rel);
+    if (!pathExists(dest)) continue;
+    let stat;
+    try { stat = fs.lstatSync(dest); } catch { continue; }
+    if (stat.isFile() && hashBuffer(fs.readFileSync(dest)) === record.hash) {
+      fs.unlinkSync(dest);
+      try { fs.rmdirSync(path.dirname(dest)); } catch {}
+      summary.removed += 1;
+    } else {
+      summary.conflicted += 1;
+      summary.conflicts.push(rel);
+      next.files[rel] = { hash: record.hash };
+    }
+  }
+
+  for (const rel of currentBundleFiles) {
+    const src = path.join(BUNDLE_DIR, rel);
+    const dest = path.join(egregoreDir, rel);
+    const sourceHash = hashBuffer(fs.readFileSync(src));
+    const previousHash = previousFiles[rel]?.hash;
+    const record = () => {
+      next.files[rel] = { hash: sourceHash };
+      summary.files.push(rel);
+    };
+
+    if (!pathExists(dest)) {
+      copyFile(src, dest);
+      summary.installed += 1;
+      record();
+      continue;
+    }
+
+    let stat;
+    try { stat = fs.lstatSync(dest); } catch {}
+    if (!stat?.isFile()) {
+      summary.conflicted += 1;
+      summary.conflicts.push(rel);
+      if (previousHash) next.files[rel] = { hash: previousHash };
+      continue;
+    }
+
+    const currentHash = hashBuffer(fs.readFileSync(dest));
+    if (currentHash === sourceHash) {
+      try { fs.chmodSync(dest, fs.statSync(src).mode & 0o777); } catch {}
+      summary.skipped += 1;
+      record();
+    } else if (previousHash && currentHash === previousHash) {
+      copyFile(src, dest);
+      summary.updated += 1;
+      record();
+    } else {
+      summary.conflicted += 1;
+      summary.conflicts.push(rel);
+      if (previousHash) next.files[rel] = { hash: previousHash };
+    }
+  }
+
+  fs.mkdirSync(path.dirname(previousPath), { recursive: true });
+  fs.writeFileSync(previousPath, JSON.stringify(next, null, 2) + "\n");
+  return summary;
+}
+
+function hasPrimeRuntimeSupport(egregoreDir) {
+  return REQUIRED_RUNTIME_PATHS.every((rel) => fs.existsSync(path.join(egregoreDir, rel)));
+}
+
+function reportPrimeRuntimeSummary(summary, ui, opts = {}) {
+  if (!summary || !ui) return;
+  const label = opts.label || "Prime Agent runtime";
+  const changed = summary.installed + summary.updated + (summary.removed || 0);
+  if (changed > 0) {
+    ui.success(`${label} ready (${summary.installed} installed, ${summary.updated} updated, ${summary.removed || 0} removed, ${summary.skipped} unchanged)`);
+  }
+  if (opts.includeConflicts !== false && summary.conflicted > 0) {
+    const count = summary.conflicted;
+    ui.info(ui.dim
+      ? ui.dim(`${label}: kept ${count} framework file${count === 1 ? "" : "s"} this Egregore already manages.`)
+      : `${label}: kept ${count} framework file${count === 1 ? "" : "s"} this Egregore already manages.`);
+  }
+}
+
+module.exports = {
+  BUNDLE_DIR,
+  bundleFiles,
+  bundleManifest,
+  hasPrimeRuntimeSupport,
+  installManifestPath,
+  installPrimeRuntime,
+  reportPrimeRuntimeSummary,
+};