0xray 3.5.4 → 4.0.0

package/scripts/node/install-bridges.cjs

@@ -13,23 +13,19 @@ const {
   wireOpencodeBridge,
   wireOpenClawBridge,
   deployPortableProjectMcpJson,
+  copyHermesFindProjectRootHelper,
+  copyHermesHookRuntimes,
+  installOpenClawHostWear,
+  maybeWriteOpenClawCliBackend,
+  isEphemeralInstallRoot,
+  enableMemoryRoutingIfResolves,
+  XRAY_MCP_SERVERS,
 } = require("./bridge-mcp-wiring.cjs");
 
 const SKIP_DIRS = new Set(["node_modules", "logs"]);
 const MERGE_FILES = new Set(["enforcer-config.json"]);
 const KEEP_IF_EXISTS = new Set([".yml", ".yaml", ".md"]);
 
-/** Canonical 7-server MCP surface — matches package .mcp.json and Grok plugin */
-const XRAY_MCP_SERVERS = [
-  { name: "xray-governance", mcpCmd: "governance", env: { XRAY_FORCE_MCP_GOVERNANCE: "true" } },
-  { name: "xray-skills", mcpCmd: "skills", env: {} },
-  { name: "xray-orchestrator", mcpCmd: "orchestrator", env: {} },
-  { name: "xray-enforcer", mcpCmd: "enforcer", env: {} },
-  { name: "xray-researcher", mcpCmd: "researcher", env: {} },
-  { name: "xray-code-review", mcpCmd: "code-review", env: {} },
-  { name: "xray-architect-tools", mcpCmd: "architect-tools", env: {} },
-];
-
 function resolveConsumerTargetDir(packageRoot, fallbackDir) {
   const resolved = path.resolve(packageRoot);
   const inNodeModules =
@@ -128,8 +124,21 @@ function copyTree(src, dest, relPath = "") {
 
 function copyPluginDir(src, dest) {
   if (!fs.existsSync(src)) return false;
-  fs.cpSync(src, dest, { recursive: true, force: true });
-  return true;
+  try {
+    if (fs.existsSync(dest)) {
+      fs.rmSync(dest, { recursive: true, force: true });
+    }
+    fs.cpSync(src, dest, { recursive: true, force: true });
+    return true;
+  } catch (e) {
+    try {
+      fs.rmSync(dest, { recursive: true, force: true });
+      fs.cpSync(src, dest, { recursive: true, force: true });
+      return true;
+    } catch {
+      throw e;
+    }
+  }
 }
 
 function writePluginMcpJson(pluginDir, targetDir, log, label) {
@@ -168,30 +177,96 @@ function mergeOpencodeJson(targetDir, packageRoot, log) {
   }
 }
 
+function grokHookShellCommand(packageRoot, scriptName, extraArgs) {
+  const script = path.join(packageRoot, "dist", "integrations", "grok", "hooks", scriptName);
+  const extra = extraArgs ? ` ${extraArgs}` : "";
+  // JSON.stringify quotes so spaces/$ in install paths still exec (Grok fail-opens on crash).
+  return `XRAY_AI_PATH=${JSON.stringify(packageRoot)} node ${JSON.stringify(script)}${extra}`;
+}
+
+function patchGrokHookEntry(hook, packageRoot, targetDir, scriptName, extraArgs) {
+  if (!hook) return;
+  hook.type = "command";
+  hook.command = grokHookShellCommand(packageRoot, scriptName, extraArgs);
+  hook.timeout = 30;
+  delete hook.args;
+  hook.env = {
+    ...(hook.env || {}),
+    XRAY_ROOT: targetDir,
+    XRAY_AI_PATH: packageRoot,
+  };
+}
+
+function ensureGrokHookEvent(hooks, eventName) {
+  if (!hooks.hooks) hooks.hooks = {};
+  if (!Array.isArray(hooks.hooks[eventName]) || !hooks.hooks[eventName][0]) {
+    hooks.hooks[eventName] = [{ hooks: [{}] }];
+  }
+  if (!Array.isArray(hooks.hooks[eventName][0].hooks) || !hooks.hooks[eventName][0].hooks[0]) {
+    hooks.hooks[eventName][0].hooks = [{}];
+  }
+}
+
 function patchGrokHooks(pluginDir, packageRoot, targetDir, log, label) {
-  const hooksPath = path.join(pluginDir, "hooks", "hooks.json");
+  const hooksDir = path.join(pluginDir, "hooks");
+  const hooksPath = path.join(hooksDir, "hooks.json");
   const hookScript = path.join(packageRoot, "dist", "integrations", "grok", "hooks", "pre-tool-use.js");
-  if (!fs.existsSync(hooksPath)) return;
+  if (!fs.existsSync(hooksPath)) {
+    if (!fs.existsSync(hooksDir)) fs.mkdirSync(hooksDir, { recursive: true });
+    if (!fs.existsSync(hooksPath)) return;
+  }
 
   try {
     const hooks = JSON.parse(fs.readFileSync(hooksPath, "utf8"));
-    const preTool = hooks.hooks?.PreToolUse?.[0]?.hooks?.[0];
-    if (preTool && fs.existsSync(hookScript)) {
-      preTool.command = "node";
-      preTool.args = [hookScript];
-      preTool.env = {
-        ...(preTool.env || {}),
-        XRAY_ROOT: targetDir,
-        XRAY_AI_PATH: packageRoot,
-      };
-      fs.writeFileSync(hooksPath, JSON.stringify(hooks, null, 2) + "\n");
-      log(label, "hooks.json patched → enforcement gate", "info");
-    }
+    if (!fs.existsSync(hookScript)) return;
+    patchGrokHookEntry(hooks.hooks?.PreToolUse?.[0]?.hooks?.[0], packageRoot, targetDir, "pre-tool-use.js");
+    patchGrokHookEntry(hooks.hooks?.SessionStart?.[0]?.hooks?.[0], packageRoot, targetDir, "session-start.js");
+    patchGrokHookEntry(
+      hooks.hooks?.UserPromptSubmit?.[0]?.hooks?.[0],
+      packageRoot,
+      targetDir,
+      "session-start.js",
+      "--hook-event=user_prompt_submit",
+    );
+    patchGrokHookEntry(hooks.hooks?.PostToolUse?.[0]?.hooks?.[0], packageRoot, targetDir, "post-tool-use.js");
+    ensureGrokHookEvent(hooks, "PreCompact");
+    ensureGrokHookEvent(hooks, "PostCompact");
+    patchGrokHookEntry(
+      hooks.hooks?.PreCompact?.[0]?.hooks?.[0],
+      packageRoot,
+      targetDir,
+      "session-start.js",
+      "--hook-event=pre_compact",
+    );
+    patchGrokHookEntry(
+      hooks.hooks?.PostCompact?.[0]?.hooks?.[0],
+      packageRoot,
+      targetDir,
+      "session-start.js",
+      "--hook-event=post_compact",
+    );
+    fs.writeFileSync(hooksPath, JSON.stringify(hooks, null, 2) + "\n");
+    writeGrokDiscoveredHooks(targetDir, hooksPath, log, label);
+    log(label, "hooks.json patched → Grok command-string enforcement gate", "info");
   } catch (e) {
     log(label, "hooks.json patch failed", "warn", { error: e.message });
   }
 }
 
+/** Grok TUI loads `<project>/.grok/hooks/*.json`, not `plugins/0xray/hooks`. */
+function writeGrokDiscoveredHooks(targetDir, hooksPath, log, label) {
+  if (!targetDir || !fs.existsSync(hooksPath)) return;
+  try {
+    const destDir = path.join(targetDir, ".grok", "hooks");
+    fs.mkdirSync(destDir, { recursive: true });
+    const dest = path.join(destDir, "0xray.json");
+    fs.copyFileSync(hooksPath, dest);
+    log(label, "Grok discovered hooks → .grok/hooks/0xray.json", "info", { dest });
+  } catch (e) {
+    log(label, "Grok discovered hooks copy failed", "warn", { error: e.message });
+  }
+}
+
 function installOpencodeBridge(targetDir, packageRoot, log) {
   const opencodeSource = path.join(packageRoot, ".opencode");
   const opencodeDest = path.join(targetDir, ".opencode");
@@ -287,10 +362,13 @@ function installGrokBridge(targetDir, packageRoot, log) {
   }
 
   const home = os.homedir();
-  const targets = [
-    path.join(targetDir, ".grok", "plugins", "0xray"),
-    path.join(home, ".grok", "plugins", "0xray"),
-  ];
+  const ephemeral = isEphemeralInstallRoot(targetDir);
+  const targets = [path.join(targetDir, ".grok", "plugins", "0xray")];
+  if (!ephemeral) {
+    targets.push(path.join(home, ".grok", "plugins", "0xray"));
+  } else {
+    log("grok-bridge", "skip machine ~/.grok plugin — ephemeral consumer", "info");
+  }
 
   for (const dest of targets) {
     if (copyPluginDir(sourceDir, dest)) {
@@ -303,14 +381,14 @@ function installGrokBridge(targetDir, packageRoot, log) {
     }
   }
 
-  // Grok Build / Cursor also reads ~/.grok/skills/ for agent_skills
-  const grokGlobalSkills = path.join(home, ".grok", "skills");
-  const globalCopied = syncBuiltinSkills(grokGlobalSkills, packageRoot);
-  if (globalCopied > 0) {
-    log("grok-bridge", `global skills synced (${globalCopied})`, "info", { path: "~/.grok/skills/" });
+  if (!ephemeral) {
+    const grokGlobalSkills = path.join(home, ".grok", "skills");
+    const globalCopied = syncBuiltinSkills(grokGlobalSkills, packageRoot);
+    if (globalCopied > 0) {
+      log("grok-bridge", `global skills synced (${globalCopied})`, "info", { path: "~/.grok/skills/" });
+    }
+    registerGrokMcpServers(targetDir, log);
   }
-
-  registerGrokMcpServers(targetDir, log);
 }
 
 function installHermesBridge(targetDir, packageRoot, log) {
@@ -335,6 +413,10 @@ function installHermesBridge(targetDir, packageRoot, log) {
       fs.copyFileSync(src, dst);
     }
   }
+  copyHermesFindProjectRootHelper(packageRoot, targetPluginDir);
+  if (copyHermesHookRuntimes(packageRoot)) {
+    log("hermes-bridge", "hook runtimes copied", "info", { path: "~/.hermes/plugins/hooks" });
+  }
   log("hermes-bridge", "plugin copied", "info", { path: "~/.hermes/plugins/xray-hermes" });
 
   writePluginMcpJson(targetPluginDir, targetDir, log, "hermes-bridge");
@@ -342,10 +424,13 @@ function installHermesBridge(targetDir, packageRoot, log) {
   const copied = syncBuiltinSkills(path.join(targetPluginDir, "skills"), packageRoot);
   if (copied > 0) log("hermes-bridge", `skills synced (${copied})`, "info");
 
-  // Marker so bridge.mjs resolves the consumer project on hook invocation
   const rootMarker = path.join(targetPluginDir, "xray-consumer-root.txt");
-  fs.writeFileSync(rootMarker, targetDir + "\n");
-  log("hermes-bridge", "consumer root marker written", "info");
+  if (!isEphemeralInstallRoot(targetDir)) {
+    fs.writeFileSync(rootMarker, targetDir + "\n");
+    log("hermes-bridge", "consumer root marker written", "info");
+  } else {
+    log("hermes-bridge", "skip machine consumer marker — ephemeral consumer", "info");
+  }
 
   try {
     const result = wireHermesBridge(targetDir);
@@ -399,6 +484,16 @@ function installOpenclawBridge(targetDir, packageRoot, log) {
   } catch (e) {
     log("openclaw-bridge", "openclaw.json mcp wire failed", "warn", { error: e.message });
   }
+
+  if (!isEphemeralInstallRoot(targetDir)) {
+    const hook = installOpenClawHostWear(packageRoot);
+    if (hook) log("openclaw-bridge", "PreToolUse hook installed", "info", { path: hook });
+    if (maybeWriteOpenClawCliBackend()) {
+      log("openclaw-bridge", "opencode-cli backend written", "info");
+    }
+  } else {
+    log("openclaw-bridge", "skip machine PreToolUse wear — ephemeral consumer", "info");
+  }
 }
 
 const XRAY_CONFIG_FILES = ["codex.json", "features.json", "features.schema.json", "config.json"];
@@ -419,9 +514,20 @@ function writeJsonFile(filePath, data) {
   fs.writeFileSync(filePath, `${JSON.stringify(data, null, 2)}\n`);
 }
 
-function deployXrayConfigFile(file, src, dst, packageRoot) {
+function applyResolvedMemoryRouting(dst, targetDir) {
+  try {
+    const features = JSON.parse(fs.readFileSync(dst, "utf8"));
+    const next = enableMemoryRoutingIfResolves(features, targetDir);
+    if (next.changed) writeJsonFile(dst, next.features);
+  } catch {
+    /* leftover default stays off when features.json is unreadable */
+  }
+}
+
+function deployXrayConfigFile(file, src, dst, packageRoot, targetDir) {
   if (!fs.existsSync(dst)) {
     fs.copyFileSync(src, dst);
+    if (file === "features.json") applyResolvedMemoryRouting(dst, targetDir);
     return true;
   }
 
@@ -442,12 +548,28 @@ function deployXrayConfigFile(file, src, dst, packageRoot) {
         const pkgVersion = readPackageVersion(packageRoot);
         if (pkgVersion) merged.version = pkgVersion;
         else if (shipped.version) merged.version = shipped.version;
+        // v3: existing consumers without suit_temperament stay guided on upgrade.
+        // Fresh copy (dst missing) already returned above with shipped auto.
+        const hadTemperament =
+          consumer.suit_temperament &&
+          typeof consumer.suit_temperament === "object" &&
+          consumer.suit_temperament.profile;
+        if (!hadTemperament) {
+          merged.suit_temperament = {
+            ...(merged.suit_temperament || {}),
+            profile: "guided",
+          };
+        }
+        writeJsonFile(dst, merged);
+        applyResolvedMemoryRouting(dst, targetDir);
+        return true;
       }
       writeJsonFile(dst, merged);
       return true;
     } catch {
       if (fs.statSync(src).mtime > fs.statSync(dst).mtime) {
         fs.copyFileSync(src, dst);
+        if (file === "features.json") applyResolvedMemoryRouting(dst, targetDir);
         return true;
       }
       return false;
@@ -481,7 +603,7 @@ function deployXrayConfig(targetDir, packageRoot, log) {
     const src = resolveXrayConfigSource(packageRoot, file);
     const dst = path.join(xrayTargetDir, file);
     if (!src) continue;
-    if (deployXrayConfigFile(file, src, dst, packageRoot)) {
+    if (deployXrayConfigFile(file, src, dst, packageRoot, targetDir)) {
       copied++;
     }
   }
@@ -500,6 +622,29 @@ function installGitHooks(packageRoot, log) {
   }
 }
 
+/**
+ * Framework dogfood: do not deploy consumer copies over the package,
+ * but keep Grok discovery hooks hot and enable Repertoire when it resolves.
+ */
+function installFrameworkDogfoodWear(packageRoot, log) {
+  const featuresPath = path.join(packageRoot, ".xray", "features.json");
+  if (fs.existsSync(featuresPath)) {
+    applyResolvedMemoryRouting(featuresPath, packageRoot);
+  }
+
+  const sourceDir = findGrokPluginSource(packageRoot);
+  const pluginDest = path.join(packageRoot, ".grok", "plugins", "0xray");
+  if (!sourceDir) {
+    log("grok-dogfood", "skipped", "warn", { reason: "grok plugin source missing" });
+    return;
+  }
+  const hooksJson = path.join(pluginDest, "hooks", "hooks.json");
+  if (!fs.existsSync(hooksJson)) {
+    copyPluginDir(sourceDir, pluginDest);
+  }
+  patchGrokHooks(pluginDest, packageRoot, packageRoot, log, "grok-dogfood");
+}
+
 /**
  * Install all 4 platform bridges for a consumer project.
  * @param {{ targetDir: string, packageRoot: string, log?: Function }} opts
@@ -513,7 +658,11 @@ function installAllBridges(opts) {
       /* noop */
     });
 
-  if (!isConsumerInstall(packageRoot, targetDir)) return;
+  if (!isConsumerInstall(packageRoot, targetDir)) {
+    log("install-bridges", "framework dogfood wear", "info");
+    installFrameworkDogfoodWear(packageRoot, log);
+    return;
+  }
 
   log("install-bridges", "starting 4-platform install", "info");
 
@@ -539,4 +688,9 @@ module.exports = {
   resolveXrayConfigSource,
   XRAY_CONFIG_FILES,
   MERGE_CONFIG_FILES,
+  patchGrokHooks,
+  grokHookShellCommand,
+  writeGrokDiscoveredHooks,
+  isEphemeralInstallRoot,
+  installFrameworkDogfoodWear,
 };

package/scripts/node/load-reflection-config.mjs

@@ -16,9 +16,9 @@ const root = process.env.PROJECT_ROOT || process.cwd();
 const configPath = join(root, '.xray', 'features.json');
 
 let mode = 'minimal';
-let commitThreshold = 25;
+let commitThreshold = 50;
 let daysThreshold = 14;
-let autoGenerate = true;
+let autoGenerate = false;
 let promptUser = true;
 
 if (existsSync(configPath)) {

package/scripts/node/postinstall.cjs

@@ -15,17 +15,12 @@ function structuredLog(component, action, status, details) {
   console.log(`${ts} [${component}] ${action} - ${String(status).toUpperCase()}${detailsPart}`);
 }
 
-const packageRoot = path.join(__dirname, "..", "..");
-const targetDir = resolveConsumerTargetDir(packageRoot, process.env.PWD || process.cwd());
-const resolvedPackage = path.resolve(packageRoot);
-const resolvedTarget = path.resolve(targetDir);
-
 const XRAY_MANAGED_AGENTS_MARKER = "<!-- 0xray-managed -->";
 
-// Copy AGENTS-consumer.md → AGENTS.md (only if absent or still 0xray-managed)
-const agentsConsumer = path.join(packageRoot, "AGENTS-consumer.md");
-const agentsDest = path.join(targetDir, "AGENTS.md");
-if (fs.existsSync(agentsConsumer) && isConsumerInstall(resolvedPackage, resolvedTarget)) {
+function deployManagedAgents(packageRoot, targetDir, log) {
+  const agentsConsumer = path.join(packageRoot, "AGENTS-consumer.md");
+  const agentsDest = path.join(targetDir, "AGENTS.md");
+  if (!fs.existsSync(agentsConsumer)) return;
   const shouldDeployAgents =
     !fs.existsSync(agentsDest) ||
     fs.readFileSync(agentsDest, "utf8").includes(XRAY_MANAGED_AGENTS_MARKER);
@@ -36,37 +31,65 @@ if (fs.existsSync(agentsConsumer) && isConsumerInstall(resolvedPackage, resolved
     }
     fs.writeFileSync(agentsDest, content);
   } else {
-    structuredLog("postinstall", "Skipped AGENTS.md (consumer-customized)", "info");
+    log("postinstall", "Skipped AGENTS.md (consumer-customized)", "info");
   }
 }
 
-// .gitignore: full template when absent; merge suit block when existing
-if (isConsumerInstall(resolvedPackage, resolvedTarget)) {
+function deployConsumerGitignore(packageRoot, targetDir, log) {
   const gitignoreResult = applyConsumerGitignore(targetDir, packageRoot);
   if (gitignoreResult === "created") {
-    structuredLog("postinstall", "Created .gitignore from template", "info");
+    log("postinstall", "Created .gitignore from template", "info");
   } else if (gitignoreResult === "merged") {
-    structuredLog("postinstall", "Merged 0xray suit entries into .gitignore", "info");
+    log("postinstall", "Merged 0xray suit entries into .gitignore", "info");
   }
 }
 
-// Unified 4-platform bridge install (OpenCode, Grok, Hermes, OpenClaw)
-if (isConsumerInstall(resolvedPackage, resolvedTarget)) {
+/**
+ * Wear bridges for consumers (full 4-platform) and the framework repo (dogfood).
+ * installAllBridges already decides which path.
+ */
+function runPostinstall(packageRoot, targetDir, log) {
+  const logFn = log || structuredLog;
+  const resolvedPackage = path.resolve(packageRoot);
+  const resolvedTarget = path.resolve(targetDir);
+  const consumer = isConsumerInstall(resolvedPackage, resolvedTarget);
+
+  if (consumer) {
+    deployManagedAgents(resolvedPackage, resolvedTarget, logFn);
+    deployConsumerGitignore(resolvedPackage, resolvedTarget, logFn);
+  }
+
   try {
     installAllBridges({
-      targetDir,
-      packageRoot,
-      log: structuredLog,
+      targetDir: resolvedTarget,
+      packageRoot: resolvedPackage,
+      log: logFn,
     });
   } catch (e) {
-    structuredLog("postinstall", "Bridge install failed", "error", { error: e.message });
+    logFn("postinstall", "Bridge install failed", "error", { error: e.message });
+    throw e;
+  }
+
+  if (consumer) {
+    logFn(
+      "postinstall",
+      "0xRay framework installed (4 bridges). Run `npx 0xray setup` for symlinks/Hermes skill extras.",
+      "success",
+    );
+  } else {
+    logFn("postinstall", "framework dogfood wear complete", "success");
+  }
+}
+
+module.exports = { runPostinstall };
+
+if (require.main === module) {
+  const packageRoot = path.join(__dirname, "..", "..");
+  const targetDir = resolveConsumerTargetDir(packageRoot, process.env.PWD || process.cwd());
+  try {
+    runPostinstall(packageRoot, targetDir);
+  } catch {
     console.error("\n❌ 0xRay postinstall failed — bridge wiring did not complete.\n");
     process.exit(1);
   }
-
-  structuredLog(
-    "postinstall",
-    "0xRay framework installed (4 bridges). Run `npx 0xray setup` for symlinks/Hermes skill extras.",
-    "success"
-  );
-}
+}

package/scripts/node/release-gate.mjs

@@ -48,14 +48,18 @@ function main() {
         step("4/5 Consumer install smoke", "node scripts/node/consumer-install-smoke.mjs");
       }
     } else {
-      step("1/5 Build", "npm run build");
-      step("2/5 Tests", "npm test");
+      step("1/6 Build", "npm run build");
+      step("2/6 Tests", "npm test");
       step(
-        "3/5 Plugin infrastructure",
+        "3/6 Consumer hook verifiers",
+        "npm run verify:pre-commit-diff && npm run verify:pre-push-diff && node scripts/mjs/verify-delegation-gate-core.mjs --host=grok && node scripts/mjs/verify-delegation-gate-core.mjs --host=hermes && node scripts/mjs/verify-delegation-gate-core.mjs --host=opencode && node scripts/mjs/verify-hermes-session-start.mjs && node scripts/mjs/verify-confer-core.mjs && npm run verify:user-aside && npm run build && node scripts/mjs/verify-pipeline-facets.mjs --package-only",
+      );
+      step(
+        "4/6 Plugin infrastructure",
         "node scripts/test/validate-plugins-e2e.cjs --structural-only",
       );
       if (!skipSmoke) {
-        step("4/5 Consumer install smoke (fresh + upgrade)", "node scripts/node/consumer-install-smoke.mjs");
+        step("5/6 Consumer install smoke (fresh + upgrade)", "node scripts/node/consumer-install-smoke.mjs");
       }
     }
 

package/scripts/node/release.mjs

@@ -24,7 +24,7 @@ import { getReleaseArtifactPaths } from "./version-manager.mjs";
 const rootDir = process.cwd();
 const args = process.argv.slice(2);
 const dryRun = args.includes("--dry-run");
-const releaseType = args.find((a) => ["major", "minor", "patch"].includes(a)) || "patch";
+const releaseType = args.find((a) => ["major", "minor", "patch"].includes(a));
 
 function run(cmd, label) {
   console.log(`\n> ${cmd}`);
@@ -70,7 +70,7 @@ function publishIdempotent(version) {
 }
 
 async function main() {
-  if (!["major", "minor", "patch"].includes(releaseType)) {
+  if (!releaseType || !["major", "minor", "patch"].includes(releaseType)) {
     console.error("Usage: node scripts/node/release.mjs [patch|minor|major] [--dry-run]");
     process.exit(1);
   }

package/scripts/node/validate-release-docs.mjs

@@ -24,7 +24,7 @@ const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const defaultRoot = path.resolve(__dirname, '../..');
 
 const STANDARD_HEADER_RE =
-  /^\*{0,2}v[\d.]+\*{0,2}\s*—\s*\d+ agents · \d+ skills · \d+ MCP servers? · \d+ codex terms(?: · [\d,]+ tests)?/m;
+  /^\*{0,2}v[\d.]+\*{0,2}\s*—\s*a suit that survives the context window/m;
 
 /** Guides that must exist and reference the current release (body or header). */
 const REQUIRED_GUIDES = [
@@ -45,7 +45,10 @@ const ROOT_DOC_CHECKS = [
     validate: (content, version, counts, header) => {
       const errors = [];
       if (!content.includes(header)) {
-        errors.push(`missing or stale standard header (expected: ${header})`);
+        errors.push(`missing kernel header (expected substring: ${header})`);
+      }
+      if (!content.includes('survive the context window') && !content.includes('survives the context window')) {
+        errors.push('missing context-window / exo kernel copy');
       }
       if (!content.includes('SKILLS.md')) {
         errors.push('missing SKILLS.md reference in postinstall/docs section');
@@ -63,14 +66,8 @@ const ROOT_DOC_CHECKS = [
       if (!content.includes(`**v${version}**`)) {
         errors.push(`missing version marker **v${version}**`);
       }
-      if (!content.includes(`${counts.agents} agents`)) {
-        errors.push(`expected ${counts.agents} agents in header`);
-      }
-      if (!content.includes(`${counts.skills} skills`)) {
-        errors.push(`expected ${counts.skills} skills in header`);
-      }
-      if (!content.includes('68 codex terms')) {
-        errors.push('expected 68 codex terms in header');
+      if (!content.includes('survive the context window') && !content.includes('survives the context window') && !content.includes('Exo, not catalog')) {
+        errors.push('missing exo / context-window kernel copy');
       }
       if (!content.includes('aside-context.md') && !content.includes('AsideContext')) {
         errors.push('missing AsideContext documentation reference');
@@ -85,9 +82,11 @@ const ROOT_DOC_CHECKS = [
     rel: 'AGENTS-consumer.md',
     validate: (content, version, counts) => {
       const errors = [];
-      const expected = `**v${version}** — ${counts.mcps} MCP servers · ${counts.skills} skills · 68 codex terms`;
-      if (!content.includes(expected)) {
-        errors.push(`consumer header stale (expected substring: ${expected})`);
+      if (!content.includes(`**v${version}**`)) {
+        errors.push(`missing version marker **v${version}**`);
+      }
+      if (!content.includes('survive the context window') && !content.includes('survives the context window')) {
+        errors.push('consumer header missing context-window kernel copy');
       }
       if (!content.includes('SKILLS.md')) {
         errors.push('missing SKILLS.md in postinstall section');
@@ -146,28 +145,16 @@ function validateChangelog(content, version) {
 }
 
 function validateStandardHeader(content, expectedHeader, label) {
-  const match = content.match(STANDARD_HEADER_RE);
-  if (!match) {
-    return [`${label}: no standard docs header line found`];
-  }
-  if (match[0] !== expectedHeader) {
-    return [`${label}: header is "${match[0]}", expected "${expectedHeader}"`];
+  if (!content.includes(expectedHeader) && !STANDARD_HEADER_RE.test(content)) {
+    return [`${label}: missing kernel header (expected substring: ${expectedHeader})`];
   }
   return [];
 }
 
-function validateDocusaurusTagline(content, counts) {
+function validateDocusaurusTagline(content) {
   const errors = [];
-  const expectedParts = [
-    `${counts.agents} agents`,
-    `${counts.skills} skills`,
-    `${counts.mcps} MCP servers`,
-    '68 codex terms',
-  ];
-  for (const part of expectedParts) {
-    if (!content.includes(part)) {
-      errors.push(`docusaurus.config.ts tagline missing "${part}"`);
-    }
+  if (!content.includes('survive the context window') && !content.includes('survives the context window')) {
+    errors.push('docusaurus.config.ts tagline missing context-window kernel copy');
   }
   return errors;
 }
@@ -184,8 +171,8 @@ export function validateReleaseDocs(rootDir = defaultRoot) {
   const expectedHeader = buildDocsHeader(counts, version);
   const codexTerms = getCodexTermCount(rootDir);
 
-  if (codexTerms !== null && codexTerms !== 68) {
-    warnings.push(`codex.json has ${codexTerms} terms (docs reference 68)`);
+  if (codexTerms !== null && counts.codexTerms && codexTerms !== counts.codexTerms) {
+    warnings.push(`codex.json has ${codexTerms} terms (counts.codexTerms is ${counts.codexTerms})`);
   }
 
   const changelog = readFile(rootDir, 'CHANGELOG.md');
@@ -234,7 +221,7 @@ export function validateReleaseDocs(rootDir = defaultRoot) {
   if (!docusaurus) {
     errors.push('docs-site/docusaurus.config.ts: missing');
   } else {
-    errors.push(...validateDocusaurusTagline(docusaurus, counts));
+    errors.push(...validateDocusaurusTagline(docusaurus));
   }
 
   for (const rel of getReleaseArtifactPaths()) {