@neuroverseos/governance 0.6.1 → 0.8.0

package/dist/cli/neuroverse.cjs

@@ -2002,10 +2002,10 @@ __export(world_loader_exports, {
 });
 async function loadWorldFromDirectory(dirPath) {
   const { readFile: readFile4 } = await import("fs/promises");
-  const { join: join16 } = await import("path");
-  const { readdirSync: readdirSync7 } = await import("fs");
+  const { join: join18 } = await import("path");
+  const { readdirSync: readdirSync10 } = await import("fs");
   async function readJson(filename) {
-    const filePath = join16(dirPath, filename);
+    const filePath = join18(dirPath, filename);
     try {
       const content = await readFile4(filePath, "utf-8");
       return JSON.parse(content);
@@ -2035,11 +2035,11 @@ async function loadWorldFromDirectory(dirPath) {
   const metadataJson = await readJson("metadata.json");
   const rules = [];
   try {
-    const rulesDir = join16(dirPath, "rules");
-    const ruleFiles = readdirSync7(rulesDir).filter((f) => f.endsWith(".json")).sort();
+    const rulesDir = join18(dirPath, "rules");
+    const ruleFiles = readdirSync10(rulesDir).filter((f) => f.endsWith(".json")).sort();
     for (const file of ruleFiles) {
       try {
-        const content = await readFile4(join16(rulesDir, file), "utf-8");
+        const content = await readFile4(join18(rulesDir, file), "utf-8");
         rules.push(JSON.parse(content));
       } catch (err) {
         process.stderr.write(
@@ -2093,8 +2093,8 @@ async function loadWorld(worldPath) {
 }
 async function loadBundledWorld(name = DEFAULT_BUNDLED_WORLD) {
   const { readFile: readFile4 } = await import("fs/promises");
-  const { join: join16, dirname: dirname4 } = await import("path");
-  const { existsSync: existsSync12 } = await import("fs");
+  const { join: join18, dirname: dirname4 } = await import("path");
+  const { existsSync: existsSync14 } = await import("fs");
   const { fileURLToPath: fileURLToPath3 } = await import("url");
   const { parseWorldMarkdown: parseWorldMarkdown2 } = await Promise.resolve().then(() => (init_bootstrap_parser(), bootstrap_parser_exports));
   const { emitWorldDefinition: emitWorldDefinition2 } = await Promise.resolve().then(() => (init_bootstrap_emitter(), bootstrap_emitter_exports));
@@ -2102,16 +2102,16 @@ async function loadBundledWorld(name = DEFAULT_BUNDLED_WORLD) {
   let packageRoot;
   try {
     const thisFile = typeof __dirname !== "undefined" ? __dirname : dirname4(fileURLToPath3(import_meta.url));
-    packageRoot = join16(thisFile, "..", "..");
+    packageRoot = join18(thisFile, "..", "..");
   } catch {
     packageRoot = process.cwd();
   }
   const candidates = [
-    join16(packageRoot, "dist", "worlds", filename),
-    join16(packageRoot, "src", "worlds", filename)
+    join18(packageRoot, "dist", "worlds", filename),
+    join18(packageRoot, "src", "worlds", filename)
   ];
   for (const candidate of candidates) {
-    if (existsSync12(candidate)) {
+    if (existsSync14(candidate)) {
       const markdown = await readFile4(candidate, "utf-8");
       const parsed = parseWorldMarkdown2(markdown);
       if (!parsed.world) {
@@ -2141,8 +2141,8 @@ function slugify(text) {
 }
 async function addGuard(worldDir, input) {
   const { readFile: readFile4, writeFile: writeFile6 } = await import("fs/promises");
-  const { join: join16 } = await import("path");
-  const guardsPath = join16(worldDir, "guards.json");
+  const { join: join18 } = await import("path");
+  const guardsPath = join18(worldDir, "guards.json");
   let config;
   try {
     const raw = await readFile4(guardsPath, "utf-8");
@@ -2182,13 +2182,13 @@ async function addGuard(worldDir, input) {
 }
 async function addRule(worldDir, input) {
   const { readFile: readFile4, writeFile: writeFile6, mkdir: mkdir3 } = await import("fs/promises");
-  const { join: join16 } = await import("path");
-  const { readdirSync: readdirSync7 } = await import("fs");
-  const rulesDir = join16(worldDir, "rules");
+  const { join: join18 } = await import("path");
+  const { readdirSync: readdirSync10 } = await import("fs");
+  const rulesDir = join18(worldDir, "rules");
   await mkdir3(rulesDir, { recursive: true });
   let nextNum = 1;
   try {
-    const existing = readdirSync7(rulesDir).filter((f) => f.match(/^rule-\d+\.json$/)).sort();
+    const existing = readdirSync10(rulesDir).filter((f) => f.match(/^rule-\d+\.json$/)).sort();
     if (existing.length > 0) {
       const lastFile = existing[existing.length - 1];
       const match = lastFile.match(/rule-(\d+)\.json/);
@@ -2214,7 +2214,7 @@ async function addRule(worldDir, input) {
       effect_text: input.effects ? input.effects.map((e) => `${e.target} ${e.operation} ${e.value}`).join(", ") : "No direct effects"
     }
   };
-  const rulePath = join16(rulesDir, `rule-${ruleNum}.json`);
+  const rulePath = join18(rulesDir, `rule-${ruleNum}.json`);
   await writeFile6(rulePath, JSON.stringify(rule, null, 2) + "\n");
   const { loadWorldFromDirectory: loadWorldFromDirectory3 } = await Promise.resolve().then(() => (init_world_loader(), world_loader_exports));
   const world = await loadWorldFromDirectory3(worldDir);
@@ -2230,8 +2230,8 @@ async function addRule(worldDir, input) {
 }
 async function addInvariant(worldDir, input) {
   const { readFile: readFile4, writeFile: writeFile6 } = await import("fs/promises");
-  const { join: join16 } = await import("path");
-  const invariantsPath = join16(worldDir, "invariants.json");
+  const { join: join18 } = await import("path");
+  const invariantsPath = join18(worldDir, "invariants.json");
   let config;
   try {
     const raw = await readFile4(invariantsPath, "utf-8");
@@ -2849,28 +2849,28 @@ ${candidates.map((c) => `  - ${c}`).join("\n")}`
 }
 async function collectMarkdownSources(inputPath) {
   const { stat, readFile: rf, readdir } = await import("fs/promises");
-  const { join: pathJoin, extname: extname3, basename: basename4 } = await import("path");
+  const { join: pathJoin, extname: extname4, basename: basename5 } = await import("path");
   const stats = await stat(inputPath);
   if (stats.isFile()) {
     const content = await rf(inputPath, "utf-8");
-    return [{ filename: basename4(inputPath), content }];
+    return [{ filename: basename5(inputPath), content }];
   }
   if (stats.isDirectory()) {
     const sources = [];
-    await collectDir(inputPath, sources, rf, pathJoin, extname3, basename4);
+    await collectDir(inputPath, sources, rf, pathJoin, extname4, basename5);
     sources.sort((a, b) => a.filename.localeCompare(b.filename));
     return sources;
   }
   throw new Error(`Input path is neither a file nor a directory: ${inputPath}`);
 }
-async function collectDir(dir, sources, rf, pathJoin, extname3, basename4) {
+async function collectDir(dir, sources, rf, pathJoin, extname4, basename5) {
   const { readdir } = await import("fs/promises");
   const entries = await readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
     const fullPath = pathJoin(dir, entry.name);
     if (entry.isDirectory()) {
-      await collectDir(fullPath, sources, rf, pathJoin, extname3, basename4);
-    } else if (entry.isFile() && extname3(entry.name).toLowerCase() === ".md") {
+      await collectDir(fullPath, sources, rf, pathJoin, extname4, basename5);
+    } else if (entry.isFile() && extname4(entry.name).toLowerCase() === ".md") {
       const content = await rf(fullPath, "utf-8");
       sources.push({ filename: entry.name, content });
     }
@@ -3528,21 +3528,21 @@ function parseArgs2(argv) {
 }
 async function writeWorldFiles(outputDir, world) {
   const { writeFile: writeFile6, mkdir: mkdir3 } = await import("fs/promises");
-  const { join: join16 } = await import("path");
+  const { join: join18 } = await import("path");
   await mkdir3(outputDir, { recursive: true });
-  await writeFile6(join16(outputDir, "world.json"), JSON.stringify(world.world, null, 2));
-  await writeFile6(join16(outputDir, "invariants.json"), JSON.stringify({ invariants: world.invariants }, null, 2));
-  await writeFile6(join16(outputDir, "assumptions.json"), JSON.stringify(world.assumptions, null, 2));
-  await writeFile6(join16(outputDir, "state-schema.json"), JSON.stringify(world.stateSchema, null, 2));
-  await writeFile6(join16(outputDir, "gates.json"), JSON.stringify(world.gates, null, 2));
-  await writeFile6(join16(outputDir, "outcomes.json"), JSON.stringify(world.outcomes, null, 2));
-  await writeFile6(join16(outputDir, "metadata.json"), JSON.stringify(world.metadata, null, 2));
-  const rulesDir = join16(outputDir, "rules");
+  await writeFile6(join18(outputDir, "world.json"), JSON.stringify(world.world, null, 2));
+  await writeFile6(join18(outputDir, "invariants.json"), JSON.stringify({ invariants: world.invariants }, null, 2));
+  await writeFile6(join18(outputDir, "assumptions.json"), JSON.stringify(world.assumptions, null, 2));
+  await writeFile6(join18(outputDir, "state-schema.json"), JSON.stringify(world.stateSchema, null, 2));
+  await writeFile6(join18(outputDir, "gates.json"), JSON.stringify(world.gates, null, 2));
+  await writeFile6(join18(outputDir, "outcomes.json"), JSON.stringify(world.outcomes, null, 2));
+  await writeFile6(join18(outputDir, "metadata.json"), JSON.stringify(world.metadata, null, 2));
+  const rulesDir = join18(outputDir, "rules");
   await mkdir3(rulesDir, { recursive: true });
   const sortedRules = [...world.rules].sort((a, b) => a.order - b.order);
   for (let i = 0; i < sortedRules.length; i++) {
     const ruleNum = String(i + 1).padStart(3, "0");
-    await writeFile6(join16(rulesDir, `rule-${ruleNum}.json`), JSON.stringify(sortedRules[i], null, 2));
+    await writeFile6(join18(rulesDir, `rule-${ruleNum}.json`), JSON.stringify(sortedRules[i], null, 2));
   }
 }
 function write(msg) {
@@ -3557,12 +3557,12 @@ function printInsight(finding2) {
 async function main2(argv = process.argv.slice(2)) {
   try {
     const args = parseArgs2(argv);
-    const { basename: basename4 } = await import("path");
+    const { basename: basename5 } = await import("path");
     write(`
 NeuroVerse World Builder
 `);
     write(`
-Analyzing: ${basename4(args.inputPath)}
+Analyzing: ${basename5(args.inputPath)}
 `);
     const derivedPath = args.outputDir ? `${args.outputDir}/source.nv-world.md` : ".neuroverse/build-output.nv-world.md";
     const { mkdir: mkdir3 } = await import("fs/promises");
@@ -3673,9 +3673,9 @@ World source written to: ${derivedPath}
     try {
       const emitResult = emitWorldDefinition(parseResult.world);
       await writeWorldFiles(outputDir, emitResult.world);
-      const { join: join16 } = await import("path");
+      const { join: join18 } = await import("path");
       const { copyFile } = await import("fs/promises");
-      const sourceDest = join16(outputDir, "source.nv-world.md");
+      const sourceDest = join18(outputDir, "source.nv-world.md");
       if (derivedPath !== sourceDest) {
         await copyFile(derivedPath, sourceDest);
       }
@@ -5009,8 +5009,8 @@ async function main6(argv = process.argv.slice(2)) {
   try {
     const args = parseArgs6(argv);
     const { writeFile: writeFile6 } = await import("fs/promises");
-    const { existsSync: existsSync12 } = await import("fs");
-    if (existsSync12(args.outputPath)) {
+    const { existsSync: existsSync14 } = await import("fs");
+    if (existsSync14(args.outputPath)) {
       process.stderr.write(`File already exists: ${args.outputPath}
 `);
       process.stderr.write("Use a different --output path or remove the existing file.\n");
@@ -5868,22 +5868,22 @@ function parseArgs9(argv) {
 }
 async function writeWorldFiles2(outputDir, world) {
   const { writeFile: writeFile6, mkdir: mkdir3 } = await import("fs/promises");
-  const { join: join16 } = await import("path");
+  const { join: join18 } = await import("path");
   await mkdir3(outputDir, { recursive: true });
-  await writeFile6(join16(outputDir, "world.json"), JSON.stringify(world.world, null, 2));
-  await writeFile6(join16(outputDir, "invariants.json"), JSON.stringify({ invariants: world.invariants }, null, 2));
-  await writeFile6(join16(outputDir, "assumptions.json"), JSON.stringify(world.assumptions, null, 2));
-  await writeFile6(join16(outputDir, "state-schema.json"), JSON.stringify(world.stateSchema, null, 2));
-  const rulesDir = join16(outputDir, "rules");
+  await writeFile6(join18(outputDir, "world.json"), JSON.stringify(world.world, null, 2));
+  await writeFile6(join18(outputDir, "invariants.json"), JSON.stringify({ invariants: world.invariants }, null, 2));
+  await writeFile6(join18(outputDir, "assumptions.json"), JSON.stringify(world.assumptions, null, 2));
+  await writeFile6(join18(outputDir, "state-schema.json"), JSON.stringify(world.stateSchema, null, 2));
+  const rulesDir = join18(outputDir, "rules");
   await mkdir3(rulesDir, { recursive: true });
   const sortedRules = [...world.rules].sort((a, b) => a.order - b.order);
   for (let i = 0; i < sortedRules.length; i++) {
     const ruleNum = String(i + 1).padStart(3, "0");
-    await writeFile6(join16(rulesDir, `rule-${ruleNum}.json`), JSON.stringify(sortedRules[i], null, 2));
+    await writeFile6(join18(rulesDir, `rule-${ruleNum}.json`), JSON.stringify(sortedRules[i], null, 2));
   }
-  await writeFile6(join16(outputDir, "gates.json"), JSON.stringify(world.gates, null, 2));
-  await writeFile6(join16(outputDir, "outcomes.json"), JSON.stringify(world.outcomes, null, 2));
-  await writeFile6(join16(outputDir, "metadata.json"), JSON.stringify(world.metadata, null, 2));
+  await writeFile6(join18(outputDir, "gates.json"), JSON.stringify(world.gates, null, 2));
+  await writeFile6(join18(outputDir, "outcomes.json"), JSON.stringify(world.outcomes, null, 2));
+  await writeFile6(join18(outputDir, "metadata.json"), JSON.stringify(world.metadata, null, 2));
 }
 async function main9(argv = process.argv.slice(2)) {
   const startTime = performance.now();
@@ -8242,13 +8242,13 @@ function handleHealthCheck() {
 }
 async function handleListPresets(policiesDir) {
   const { readdir, readFile: readFile4 } = await import("fs/promises");
-  const { join: join16 } = await import("path");
-  const dir = policiesDir ?? join16(process.cwd(), "policies");
+  const { join: join18 } = await import("path");
+  const dir = policiesDir ?? join18(process.cwd(), "policies");
   const presets = [];
   try {
     const files = await readdir(dir);
     for (const file of files.filter((f) => f.endsWith(".txt")).sort()) {
-      const content = await readFile4(join16(dir, file), "utf-8");
+      const content = await readFile4(join18(dir, file), "utf-8");
       const id = file.replace(".txt", "");
       const name = id.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
       const firstLine = content.split("\n").find((l) => l.trim().length > 0) ?? "";
@@ -8320,7 +8320,7 @@ function govern(action, world, options) {
 }
 async function writeTempWorld(dir, policyLines) {
   const { writeFile: writeFile6, mkdir: mkdir3 } = await import("fs/promises");
-  const { join: join16 } = await import("path");
+  const { join: join18 } = await import("path");
   await mkdir3(dir, { recursive: true });
   const worldJson = {
     world_id: "demo-live",
@@ -8362,9 +8362,9 @@ async function writeTempWorld(dir, policyLines) {
     authoring_method: "manual-authoring"
   };
   await Promise.all([
-    writeFile6(join16(dir, "world.json"), JSON.stringify(worldJson, null, 2)),
-    writeFile6(join16(dir, "kernel.json"), JSON.stringify(kernelJson, null, 2)),
-    writeFile6(join16(dir, "metadata.json"), JSON.stringify(metadataJson, null, 2))
+    writeFile6(join18(dir, "world.json"), JSON.stringify(worldJson, null, 2)),
+    writeFile6(join18(dir, "kernel.json"), JSON.stringify(kernelJson, null, 2)),
+    writeFile6(join18(dir, "metadata.json"), JSON.stringify(metadataJson, null, 2))
   ]);
 }
 var init_govern = __esm({
@@ -8708,10 +8708,10 @@ data: ${data}
     res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
   }
   function readBody(req) {
-    return new Promise((resolve8, reject) => {
+    return new Promise((resolve10, reject) => {
       const chunks = [];
       req.on("data", (chunk) => chunks.push(chunk));
-      req.on("end", () => resolve8(Buffer.concat(chunks).toString("utf-8")));
+      req.on("end", () => resolve10(Buffer.concat(chunks).toString("utf-8")));
       req.on("error", reject);
     });
   }
@@ -11475,9 +11475,9 @@ async function main15(argv) {
   }
   if (worldPath) {
     try {
-      const { existsSync: existsSync12 } = await import("fs");
-      const { join: join16 } = await import("path");
-      const hasWorld = existsSync12(join16(worldPath, "world.json"));
+      const { existsSync: existsSync14 } = await import("fs");
+      const { join: join18 } = await import("path");
+      const hasWorld = existsSync14(join18(worldPath, "world.json"));
       checks.push({
         label: "World file detected",
         status: hasWorld ? "pass" : "fail",
@@ -11492,12 +11492,12 @@ async function main15(argv) {
       });
     }
   } else {
-    const { existsSync: existsSync12 } = await import("fs");
-    const { join: join16 } = await import("path");
+    const { existsSync: existsSync14 } = await import("fs");
+    const { join: join18 } = await import("path");
     const candidates = ["./world", "./.neuroverse", "./worlds"];
     let found;
     for (const dir of candidates) {
-      if (existsSync12(join16(dir, "world.json"))) {
+      if (existsSync14(join18(dir, "world.json"))) {
         found = dir;
         break;
       }
@@ -12549,8 +12549,8 @@ async function deriveCommand(args) {
     return;
   }
   const plan = result.plan;
-  const { mkdirSync: mkdirSync5 } = await import("fs");
-  mkdirSync5(outputDir, { recursive: true });
+  const { mkdirSync: mkdirSync6 } = await import("fs");
+  mkdirSync6(outputDir, { recursive: true });
   const worldJson = {
     world_id: `plan_${plan.plan_id}`,
     name: `Derived: ${plan.objective}`,
@@ -13148,7 +13148,7 @@ async function runPipeMode(config) {
 `);
   }
   const MAX_BUFFER_SIZE = 1e6;
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve10, reject) => {
     let buffer = "";
     process.stdin.setEncoding("utf-8");
     process.stdin.on("data", (chunk) => {
@@ -13194,7 +13194,7 @@ async function runPipeMode(config) {
         `[neuroverse] Session complete: ${finalState.actionsEvaluated} evaluated, ${finalState.actionsAllowed} allowed, ${finalState.actionsBlocked} blocked, ${finalState.actionsPaused} paused
 `
       );
-      resolve8();
+      resolve10();
     });
     process.stdin.on("error", reject);
   });
@@ -13310,8 +13310,8 @@ ${response.content}
   rl2.on("close", () => {
     session.stop();
   });
-  return new Promise((resolve8) => {
-    rl2.on("close", resolve8);
+  return new Promise((resolve10) => {
+    rl2.on("close", resolve10);
   });
 }
 var SessionManager;
@@ -14422,27 +14422,27 @@ function computeWorldDiff(a, b) {
 }
 async function worldSnapshot(worldPath) {
   const { readdir, readFile: readFile4, mkdir: mkdir3, writeFile: writeFile6 } = await import("fs/promises");
-  const { join: join16 } = await import("path");
+  const { join: join18 } = await import("path");
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-  const snapshotDir = join16(worldPath, ".snapshots", timestamp);
+  const snapshotDir = join18(worldPath, ".snapshots", timestamp);
   await mkdir3(snapshotDir, { recursive: true });
   const files = await readdir(worldPath);
   let copied = 0;
   for (const file of files) {
     if (file.endsWith(".json")) {
-      const content = await readFile4(join16(worldPath, file), "utf-8");
-      await writeFile6(join16(snapshotDir, file), content, "utf-8");
+      const content = await readFile4(join18(worldPath, file), "utf-8");
+      await writeFile6(join18(snapshotDir, file), content, "utf-8");
       copied++;
     }
   }
   try {
-    const rulesDir = join16(worldPath, "rules");
+    const rulesDir = join18(worldPath, "rules");
     const ruleFiles = await readdir(rulesDir);
-    await mkdir3(join16(snapshotDir, "rules"), { recursive: true });
+    await mkdir3(join18(snapshotDir, "rules"), { recursive: true });
     for (const file of ruleFiles) {
       if (file.endsWith(".json")) {
-        const content = await readFile4(join16(rulesDir, file), "utf-8");
-        await writeFile6(join16(snapshotDir, "rules", file), content, "utf-8");
+        const content = await readFile4(join18(rulesDir, file), "utf-8");
+        await writeFile6(join18(snapshotDir, "rules", file), content, "utf-8");
         copied++;
       }
     }
@@ -14455,8 +14455,8 @@ async function worldSnapshot(worldPath) {
 }
 async function worldRollback(worldPath) {
   const { readdir, readFile: readFile4, writeFile: writeFile6, mkdir: mkdir3 } = await import("fs/promises");
-  const { join: join16 } = await import("path");
-  const snapshotsDir = join16(worldPath, ".snapshots");
+  const { join: join18 } = await import("path");
+  const snapshotsDir = join18(worldPath, ".snapshots");
   let snapshots;
   try {
     snapshots = (await readdir(snapshotsDir)).sort();
@@ -14471,34 +14471,34 @@ async function worldRollback(worldPath) {
     return;
   }
   const latest = snapshots[snapshots.length - 1];
-  const snapshotDir = join16(snapshotsDir, latest);
+  const snapshotDir = join18(snapshotsDir, latest);
   const backupTimestamp = "pre-rollback-" + (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-  const backupDir = join16(snapshotsDir, backupTimestamp);
+  const backupDir = join18(snapshotsDir, backupTimestamp);
   await mkdir3(backupDir, { recursive: true });
   const currentFiles = await readdir(worldPath);
   for (const file of currentFiles) {
     if (file.endsWith(".json")) {
-      const content = await readFile4(join16(worldPath, file), "utf-8");
-      await writeFile6(join16(backupDir, file), content, "utf-8");
+      const content = await readFile4(join18(worldPath, file), "utf-8");
+      await writeFile6(join18(backupDir, file), content, "utf-8");
     }
   }
   const snapshotFiles = await readdir(snapshotDir);
   let restored = 0;
   for (const file of snapshotFiles) {
     if (file.endsWith(".json")) {
-      const content = await readFile4(join16(snapshotDir, file), "utf-8");
-      await writeFile6(join16(worldPath, file), content, "utf-8");
+      const content = await readFile4(join18(snapshotDir, file), "utf-8");
+      await writeFile6(join18(worldPath, file), content, "utf-8");
       restored++;
     }
   }
   try {
-    const rulesDir = join16(snapshotDir, "rules");
+    const rulesDir = join18(snapshotDir, "rules");
     const ruleFiles = await readdir(rulesDir);
-    await mkdir3(join16(worldPath, "rules"), { recursive: true });
+    await mkdir3(join18(worldPath, "rules"), { recursive: true });
     for (const file of ruleFiles) {
       if (file.endsWith(".json")) {
-        const content = await readFile4(join16(rulesDir, file), "utf-8");
-        await writeFile6(join16(worldPath, "rules", file), content, "utf-8");
+        const content = await readFile4(join18(rulesDir, file), "utf-8");
+        await writeFile6(join18(worldPath, "rules", file), content, "utf-8");
         restored++;
       }
     }
@@ -16400,27 +16400,27 @@ function closePrompts() {
 }
 function ask(question, defaultValue) {
   const suffix = defaultValue ? ` [${defaultValue}]` : "";
-  return new Promise((resolve8) => {
+  return new Promise((resolve10) => {
     getRL().question(`
   ${question}${suffix}: `, (answer) => {
       const val = answer.trim();
-      resolve8(val || defaultValue || "");
+      resolve10(val || defaultValue || "");
     });
   });
 }
 function confirm(question, defaultYes = true) {
   const hint = defaultYes ? "[Y/n]" : "[y/N]";
-  return new Promise((resolve8) => {
+  return new Promise((resolve10) => {
     getRL().question(`
   ${question} ${hint}: `, (answer) => {
       const val = answer.trim().toLowerCase();
-      if (val === "") resolve8(defaultYes);
-      else resolve8(val === "y" || val === "yes");
+      if (val === "") resolve10(defaultYes);
+      else resolve10(val === "y" || val === "yes");
     });
   });
 }
 function choose(question, options) {
-  return new Promise((resolve8) => {
+  return new Promise((resolve10) => {
     const r = getRL();
     r.write(`
   ${question}
@@ -16430,9 +16430,9 @@ function choose(question, options) {
     r.question(`  Choice [1-${options.length}]: `, (answer) => {
       const idx = parseInt(answer.trim(), 10) - 1;
       if (idx >= 0 && idx < options.length) {
-        resolve8(options[idx]);
+        resolve10(options[idx]);
       } else {
-        resolve8(options[0]);
+        resolve10(options[0]);
       }
     });
   });
@@ -16901,15 +16901,15 @@ function generateWorld(state) {
   return { worldJson, stateSchema, guardsJson, rules, gatesJson, invariants, outcomes, metadata };
 }
 async function writeWorld(outputDir, world) {
-  const { mkdirSync: mkdirSync5, existsSync: existsSync12 } = await import("fs");
+  const { mkdirSync: mkdirSync6, existsSync: existsSync14 } = await import("fs");
   const { writeFile: writeFile6 } = await import("fs/promises");
-  const { join: join16 } = await import("path");
+  const { join: join18 } = await import("path");
   const files = [];
-  if (!existsSync12(outputDir)) mkdirSync5(outputDir, { recursive: true });
-  const rulesDir = join16(outputDir, "rules");
-  if (!existsSync12(rulesDir)) mkdirSync5(rulesDir, { recursive: true });
+  if (!existsSync14(outputDir)) mkdirSync6(outputDir, { recursive: true });
+  const rulesDir = join18(outputDir, "rules");
+  if (!existsSync14(rulesDir)) mkdirSync6(rulesDir, { recursive: true });
   const writeJson = async (name, data) => {
-    const path = join16(outputDir, name);
+    const path = join18(outputDir, name);
     await writeFile6(path, JSON.stringify(data, null, 2) + "\n", "utf-8");
     files.push(path);
   };
@@ -16921,7 +16921,7 @@ async function writeWorld(outputDir, world) {
   await writeJson("outcomes.json", world.outcomes);
   await writeJson("metadata.json", world.metadata);
   for (const rule of world.rules) {
-    const rulePath = join16(rulesDir, `${rule.id}.json`);
+    const rulePath = join18(rulesDir, `${rule.id}.json`);
     await writeFile6(rulePath, JSON.stringify(rule, null, 2) + "\n", "utf-8");
     files.push(rulePath);
   }
@@ -17008,7 +17008,7 @@ async function main31(argv = process.argv.slice(2)) {
 }
 async function phaseRefine(outputDir, world) {
   const { writeFile: writeFile6 } = await import("fs/promises");
-  const { join: join16 } = await import("path");
+  const { join: join18 } = await import("path");
   heading("Refinement: Thresholds & Collapse");
   const primaryMetric = world.gatesJson.viability_classification[0]?.field || "system_health";
   info(`
@@ -17025,7 +17025,7 @@ async function phaseRefine(outputDir, world) {
       if (!isNaN(parsed)) gate.value = parsed;
     }
     await writeFile6(
-      join16(outputDir, "gates.json"),
+      join18(outputDir, "gates.json"),
       JSON.stringify(world.gatesJson, null, 2) + "\n",
       "utf-8"
     );
@@ -17047,7 +17047,7 @@ async function phaseRefine(outputDir, world) {
           result: "MODEL_COLLAPSES"
         };
         await writeFile6(
-          join16(outputDir, "rules", `${rule.id}.json`),
+          join18(outputDir, "rules", `${rule.id}.json`),
           JSON.stringify(rule, null, 2) + "\n",
           "utf-8"
         );
@@ -18100,9 +18100,9 @@ async function cmdAdd(argv) {
     id = name.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, "");
   }
   const { readFile: readFile4, writeFile: writeFile6 } = await import("fs/promises");
-  const { join: join16 } = await import("path");
+  const { join: join18 } = await import("path");
   const possiblePaths = [
-    join16(worldPath, "world.nv-world.md"),
+    join18(worldPath, "world.nv-world.md"),
     worldPath
   ];
   let mdPath = "";
@@ -18123,7 +18123,7 @@ async function cmdAdd(argv) {
       const files = await readdir(worldPath);
       const mdFile = files.find((f) => f.endsWith(".nv-world.md"));
       if (mdFile) {
-        mdPath = join16(worldPath, mdFile);
+        mdPath = join18(worldPath, mdFile);
         mdContent = await readFile4(mdPath, "utf-8");
       }
     } catch {
@@ -20473,17 +20473,30 @@ var init_think = __esm({
 });
 
 // src/radiant/core/scopes.ts
-function parseRepoScope(scope) {
+function parseScope(scope) {
   const cleaned = scope.replace(/^https?:\/\//, "").replace(/^github\.com\//, "").replace(/\.git$/, "").replace(/\/$/, "");
-  const parts = cleaned.split("/");
-  if (parts.length < 2 || !parts[0] || !parts[1]) {
+  const parts = cleaned.split("/").filter(Boolean);
+  if (parts.length === 0 || !parts[0]) {
     throw new Error(
-      `Cannot parse repo scope: "${scope}". Expected "owner/repo" or a GitHub URL.`
+      `Cannot parse scope: "${scope}". Expected "owner/repo" or "owner".`
     );
   }
-  return { owner: parts[0], repo: parts[1] };
+  if (parts.length === 1) {
+    return { type: "org", owner: parts[0] };
+  }
+  return { type: "repo", owner: parts[0], repo: parts[1] };
+}
+function parseRepoScope(scope) {
+  const parsed = parseScope(scope);
+  if (parsed.type === "org") {
+    throw new Error(
+      `Expected "owner/repo" but got org-level scope "${parsed.owner}". Use parseScope() for org-level.`
+    );
+  }
+  return parsed;
 }
 function formatScope(scope) {
+  if (scope.type === "org") return `${scope.owner} (org)`;
   return `${scope.owner}/${scope.repo}`;
 }
 var init_scopes = __esm({
@@ -20658,6 +20671,40 @@ async function fetchJSON(url, headers) {
   }
   return await res.json();
 }
+async function fetchGitHubOrgActivity(scope, token, options = {}) {
+  const perPage = options.perPage ?? 100;
+  const headers = {
+    Authorization: `token ${token}`,
+    Accept: "application/vnd.github.v3+json",
+    "User-Agent": "neuroverseos-radiant"
+  };
+  const repos = await fetchJSON(
+    `https://api.github.com/orgs/${scope.owner}/repos?sort=pushed&direction=desc&per_page=${perPage}`,
+    headers
+  );
+  const windowDays = options.windowDays ?? 14;
+  const since = new Date(Date.now() - windowDays * 24 * 60 * 60 * 1e3);
+  const activeRepos = repos.filter(
+    (r) => new Date(r.pushed_at) >= since
+  );
+  const cappedRepos = activeRepos.slice(0, 10);
+  const allEvents = [];
+  const repoNames = [];
+  for (const repo of cappedRepos) {
+    const [owner, repoName] = repo.full_name.split("/");
+    try {
+      const repoScope = { type: "repo", owner, repo: repoName };
+      const events = await fetchGitHubActivity(repoScope, token, options);
+      allEvents.push(...events);
+      if (events.length > 0) repoNames.push(repo.full_name);
+    } catch {
+    }
+  }
+  allEvents.sort(
+    (a, b) => Date.parse(a.timestamp) - Date.parse(b.timestamp)
+  );
+  return { events: allEvents, repos: repoNames };
+}
 var KNOWN_AI_LOGINS, KNOWN_AI_CO_AUTHOR_NAMES;
 var init_github2 = __esm({
   "src/radiant/adapters/github.ts"() {
@@ -20770,6 +20817,318 @@ var init_exocortex = __esm({
   }
 });
 
+// src/radiant/memory/palace.ts
+function writeRead(exocortexDir, frontmatter, text) {
+  const dir = (0, import_path14.resolve)(exocortexDir, "radiant", "reads");
+  (0, import_fs13.mkdirSync)(dir, { recursive: true });
+  const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const filename = `${date}.md`;
+  const filepath = (0, import_path14.join)(dir, filename);
+  const content = `${frontmatter}
+
+${text}
+`;
+  (0, import_fs13.writeFileSync)(filepath, content, "utf-8");
+  return filepath;
+}
+function updateKnowledge(exocortexDir, persistence, options) {
+  const dir = (0, import_path14.resolve)(exocortexDir, "radiant");
+  (0, import_fs13.mkdirSync)(dir, { recursive: true });
+  const filepath = (0, import_path14.join)(dir, "knowledge.md");
+  const totalReads = options?.totalReads ?? 0;
+  const existingUntriggered = loadUntriggeredCounts(filepath);
+  const lines = [
+    "# Radiant \u2014 Accumulated Behavioral Knowledge",
+    "",
+    `Last updated: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}`,
+    `Total reads: ${totalReads}`,
+    "",
+    "---",
+    "",
+    "## Evolution proposals",
+    ""
+  ];
+  const addCandidates = persistence.filter((p) => p.occurrences >= 3);
+  if (addCandidates.length > 0) {
+    lines.push("### Consider adding");
+    lines.push("");
+    lines.push("These candidate patterns keep recurring. They are not yet in the worldmodel.");
+    lines.push("If they represent real behavioral patterns worth tracking, add them.");
+    lines.push("If they were temporary, dismiss them.");
+    lines.push("");
+    for (const p of addCandidates) {
+      lines.push(
+        `- **${p.name}** \u2014 observed ${p.occurrences} times (${p.dates.join(", ")}). Add to auki-strategy.worldmodel.md \u2192 Evolution Layer \u2192 Drift Behaviors (if concerning) or Aligned Behaviors (if healthy).`
+      );
+    }
+    lines.push("");
+  }
+  if (options?.declaredItems && options.declaredItems.length > 0) {
+    const triggered = new Set(options.triggeredItems ?? []);
+    const removeCandidates = [];
+    for (const item of options.declaredItems) {
+      if (!triggered.has(item.name)) {
+        const prior = existingUntriggered.get(item.name) ?? 0;
+        const count = prior + 1;
+        existingUntriggered.set(item.name, count);
+        if (count >= 4) {
+          removeCandidates.push({ item, weeksSilent: count });
+        }
+      } else {
+        existingUntriggered.set(item.name, 0);
+      }
+    }
+    if (removeCandidates.length > 0) {
+      lines.push("### Consider removing");
+      lines.push("");
+      lines.push("These items are declared in the worldmodel but haven't triggered in multiple reads.");
+      lines.push("Either the team has internalized them (the rule is redundant) or they haven't been tested.");
+      lines.push("A lean worldmodel with 5 sharp invariants is stronger than a bloated one with 20.");
+      lines.push("");
+      for (const { item, weeksSilent } of removeCandidates) {
+        lines.push(
+          `- **${item.name}** (${item.type}) \u2014 hasn't triggered in ${weeksSilent} reads. Internalized or untested? Review whether it still earns its place.`
+        );
+      }
+      lines.push("");
+    }
+  }
+  if (options?.triggeredItems && options.triggeredItems.length > 0) {
+    lines.push("### Keep (recently active)");
+    lines.push("");
+    lines.push("These worldmodel items triggered governance in the most recent read. They're earning their place.");
+    lines.push("");
+    for (const name of options.triggeredItems) {
+      lines.push(`- **${name}** \u2014 triggered this read. Holding.`);
+    }
+    lines.push("");
+  }
+  lines.push("---");
+  lines.push("");
+  lines.push("## Pattern persistence (all observed)");
+  lines.push("");
+  for (const p of persistence) {
+    const status = p.occurrences >= 4 ? "**persistent**" : p.occurrences >= 2 ? "recurring" : "observed once";
+    lines.push(`### ${p.name}`);
+    lines.push(`- Status: ${status}`);
+    lines.push(`- Observed ${p.occurrences} time${p.occurrences > 1 ? "s" : ""}: ${p.dates.join(", ")}`);
+    lines.push("");
+  }
+  lines.push("---");
+  lines.push("");
+  lines.push("<!-- untriggered_counts (machine-readable, do not edit)");
+  for (const [name, count] of existingUntriggered.entries()) {
+    lines.push(`${name}=${count}`);
+  }
+  lines.push("-->");
+  (0, import_fs13.writeFileSync)(filepath, lines.join("\n"), "utf-8");
+  return filepath;
+}
+function loadUntriggeredCounts(filepath) {
+  const counts = /* @__PURE__ */ new Map();
+  if (!(0, import_fs13.existsSync)(filepath)) return counts;
+  try {
+    const content = (0, import_fs13.readFileSync)(filepath, "utf-8");
+    const match = content.match(
+      /<!-- untriggered_counts[\s\S]*?-->/
+    );
+    if (match) {
+      const lines = match[0].split("\n");
+      for (const line of lines) {
+        const eq = line.match(/^([^=]+)=(\d+)$/);
+        if (eq) {
+          counts.set(eq[1], parseInt(eq[2], 10));
+        }
+      }
+    }
+  } catch {
+  }
+  return counts;
+}
+function loadPriorReads(exocortexDir) {
+  const dir = (0, import_path14.resolve)(exocortexDir, "radiant", "reads");
+  if (!(0, import_fs13.existsSync)(dir)) return [];
+  const files = (0, import_fs13.readdirSync)(dir).filter((f) => f.endsWith(".md")).sort();
+  const reads = [];
+  for (const filename of files) {
+    const filepath = (0, import_path14.join)(dir, filename);
+    const content = (0, import_fs13.readFileSync)(filepath, "utf-8");
+    const date = filename.replace(".md", "");
+    const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    const frontmatter = fmMatch ? fmMatch[1] : "";
+    const patternNames = [];
+    const nameMatches = frontmatter.matchAll(/- name: ["']?([^"'\n]+)["']?/g);
+    for (const m of nameMatches) {
+      patternNames.push(m[1].trim());
+    }
+    reads.push({ date, filename, patternNames, frontmatter });
+  }
+  return reads;
+}
+function computePersistence(priorReads, currentPatternNames) {
+  const allPatterns = /* @__PURE__ */ new Map();
+  for (const read of priorReads) {
+    for (const name of read.patternNames) {
+      const dates = allPatterns.get(name) ?? [];
+      if (!dates.includes(read.date)) dates.push(read.date);
+      allPatterns.set(name, dates);
+    }
+  }
+  const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  for (const name of currentPatternNames) {
+    const dates = allPatterns.get(name) ?? [];
+    if (!dates.includes(today)) dates.push(today);
+    allPatterns.set(name, dates);
+  }
+  return Array.from(allPatterns.entries()).map(([name, dates]) => ({
+    name,
+    occurrences: dates.length,
+    dates: dates.sort()
+  })).sort((a, b) => b.occurrences - a.occurrences);
+}
+function formatPriorReadsForPrompt(priorReads) {
+  if (priorReads.length === 0) return "";
+  const lines = [
+    "## Prior Radiant reads (history)",
+    "",
+    `Radiant has run ${priorReads.length} time${priorReads.length > 1 ? "s" : ""} before on this scope.`,
+    "If you see patterns that appeared in prior reads, note their persistence.",
+    "Patterns that recur across 3+ reads are strong candidates for declaration in the strategy file.",
+    ""
+  ];
+  for (const read of priorReads.slice(-4)) {
+    lines.push(`### Read from ${read.date}`);
+    if (read.patternNames.length > 0) {
+      lines.push(`Patterns observed: ${read.patternNames.join(", ")}`);
+    } else {
+      lines.push("No patterns extracted from frontmatter.");
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+var import_fs13, import_path14;
+var init_palace = __esm({
+  "src/radiant/memory/palace.ts"() {
+    "use strict";
+    import_fs13 = require("fs");
+    import_path14 = require("path");
+  }
+});
+
+// src/radiant/core/governance.ts
+async function auditGovernance(events, worldPath) {
+  let world;
+  try {
+    world = await loadWorld(worldPath);
+  } catch {
+    return emptyAudit(events.length, "Could not load compiled worldmodel for governance audit.");
+  }
+  const verdicts = [];
+  for (const ce of events) {
+    const intent = ce.event.content?.slice(0, 500) || ce.event.kind || "activity";
+    const scope = ce.event.metadata?.scope || void 0;
+    try {
+      const result = evaluateGuard(
+        {
+          intent,
+          scope,
+          actionCategory: mapKindToCategory(ce.event.kind)
+        },
+        world
+      );
+      verdicts.push({
+        eventId: ce.event.id,
+        domain: ce.domain,
+        status: result.status,
+        reason: result.reason,
+        ruleId: result.ruleId,
+        warning: result.warning
+      });
+    } catch {
+      verdicts.push({
+        eventId: ce.event.id,
+        domain: ce.domain,
+        status: "ALLOW",
+        reason: "guard evaluation skipped (error)"
+      });
+    }
+  }
+  const human = bucketVerdicts(verdicts.filter((v) => v.domain === "life"));
+  const cyber = bucketVerdicts(verdicts.filter((v) => v.domain === "cyber"));
+  const joint = bucketVerdicts(verdicts.filter((v) => v.domain === "joint"));
+  const summary2 = buildSummary(human, cyber, joint, events.length);
+  return {
+    totalEvents: events.length,
+    human,
+    cyber,
+    joint,
+    summary: summary2
+  };
+}
+function bucketVerdicts(verdicts) {
+  const nonAllow = verdicts.filter((v) => v.status !== "ALLOW");
+  return {
+    allow: verdicts.filter((v) => v.status === "ALLOW").length,
+    modify: verdicts.filter((v) => v.status === "MODIFY").length,
+    block: verdicts.filter((v) => v.status === "BLOCK").length,
+    details: nonAllow
+  };
+}
+function buildSummary(human, cyber, joint, total) {
+  const humanTriggered = human.modify + human.block;
+  const cyberTriggered = cyber.modify + cyber.block;
+  const jointTriggered = joint.modify + joint.block;
+  const totalTriggered = humanTriggered + cyberTriggered + jointTriggered;
+  if (totalTriggered === 0) {
+    return `${total} events evaluated. All passed. The cocoon held \u2014 no governance triggered.`;
+  }
+  const parts = [];
+  parts.push(`${total} events evaluated. ${totalTriggered} triggered governance.`);
+  if (humanTriggered > 0) {
+    parts.push(`Human side: ${humanTriggered} (${human.block} blocked, ${human.modify} modified).`);
+  }
+  if (cyberTriggered > 0) {
+    parts.push(`AI side: ${cyberTriggered} (${cyber.block} blocked, ${cyber.modify} modified).`);
+  }
+  if (jointTriggered > 0) {
+    parts.push(`Joint work: ${jointTriggered} (${joint.block} blocked, ${joint.modify} modified).`);
+  }
+  if (humanTriggered > 0 && cyberTriggered > 0) {
+    const ratio = humanTriggered / cyberTriggered;
+    if (ratio > 2) {
+      parts.push("Human side is testing the frame more than AI. Either the worldmodel needs calibrating for human workflows, or humans are genuinely drifting.");
+    } else if (ratio < 0.5) {
+      parts.push("AI side is testing the frame more than humans. Check whether the AI's output patterns match the declared invariants.");
+    } else {
+      parts.push("Roughly balanced between human and AI \u2014 both sides are testing the frame.");
+    }
+  }
+  return parts.join(" ");
+}
+function mapKindToCategory(kind) {
+  if (!kind) return "other";
+  if (kind.includes("commit") || kind.includes("merge")) return "write";
+  if (kind.includes("review") || kind.includes("comment")) return "read";
+  return "other";
+}
+function emptyAudit(total, reason) {
+  return {
+    totalEvents: total,
+    human: { allow: 0, modify: 0, block: 0, details: [] },
+    cyber: { allow: 0, modify: 0, block: 0, details: [] },
+    joint: { allow: 0, modify: 0, block: 0, details: [] },
+    summary: reason
+  };
+}
+var init_governance = __esm({
+  "src/radiant/core/governance.ts"() {
+    "use strict";
+    init_guard_engine();
+    init_world_loader();
+  }
+});
+
 // src/radiant/core/domain.ts
 function isLifeSide(k) {
   return k === "human" || k === "unknown";
@@ -21060,6 +21419,14 @@ ${jargonTable}
 
 For example: don't say "update the worldmodel." Say "add a line to your strategy file."
 
+## When the same invariant keeps firing
+
+If the prior read history or the current evidence shows the same worldmodel invariant being triggered repeatedly (by the same side \u2014 human or AI), name it in MEANING and ask the real question:
+
+  "This invariant has been tested N times across M reads. Always on the [human/AI] side. Either the team needs alignment on WHY this rule exists \u2014 or the team is telling you something the worldmodel hasn't absorbed yet."
+
+Don't just say "invariant held." Say what it means that people keep pushing against the same wall.
+
 ## Health is a valid read
 
 If the activity is healthy and aligned with the worldmodel, SAY SO. Don't fabricate problems. Over-prescription is a voice failure. Legitimate outputs include:
@@ -21088,7 +21455,7 @@ Only recommend a move when the evidence actually calls for one.
     }
   ],
   "meaning": "3-5 sentences. Weave the patterns into ONE strategic thesis. Compress. The reader should finish this paragraph and understand the one thing that matters most in this read. Plain English \u2014 no system jargon.",
-  "move": "1-3 direct imperatives, OR explicit 'nothing to act on' if the read is healthy. Do not fabricate urgency. Examples: 'Force cross-module ownership this sprint.' / 'Nothing's broken. Keep shipping.' / 'If you want future reads to track this pattern by name, add a line to your strategy file.'"
+  "move": "1-3 direct imperatives, OR explicit 'nothing to act on' if the read is healthy. Do not fabricate urgency. When a candidate pattern has high confidence (>0.6), tell the reader EXACTLY where to declare it: 'If you want Radiant to track [pattern_name] over time, add it to auki-strategy.worldmodel.md under Evolution Layer \u2192 Drift Behaviors (or Aligned Behaviors if it is positive). If you don't, Radiant will rediscover it from scratch next run.' Be specific about the file and section \u2014 don't make them guess."
 }
 \`\`\`
 
@@ -21249,6 +21616,27 @@ Lens:   ${input.lens.name}`
     `  Composite:                 ${formatScore(input.scores.R)}`
   ].join("\n");
   sections.push(alignBlock);
+  if (input.governance && input.governance.totalEvents > 0) {
+    const gov = input.governance;
+    const govLines = ["GOVERNANCE", "", `  ${gov.summary}`];
+    const showSide = (label, side) => {
+      if (side.allow + side.modify + side.block === 0) return;
+      govLines.push("");
+      govLines.push(`  ${label}:`);
+      govLines.push(`    ${side.allow} ALLOW \xB7 ${side.modify} MODIFY \xB7 ${side.block} BLOCK`);
+      for (const d of side.details.slice(0, 3)) {
+        const reason = d.reason ? ` \u2192 ${d.reason}` : "";
+        govLines.push(`    ${d.status}: ${d.eventId}${reason}`);
+      }
+      if (side.details.length > 3) {
+        govLines.push(`    ... and ${side.details.length - 3} more`);
+      }
+    };
+    showSide("Human side", gov.human);
+    showSide("AI side", gov.cyber);
+    showSide("Human\u2013AI joint", gov.joint);
+    sections.push(govLines.join("\n"));
+  }
   sections.push(renderDepth(input.priorReadCount ?? 0, input.windowDays));
   return sections.join("\n\n");
 }
@@ -21425,14 +21813,31 @@ async function emergent(input) {
   const windowDays = input.windowDays ?? 14;
   let statedIntent;
   let exocortexContext;
+  let priorReadContext = "";
   if (input.exocortexPath) {
     exocortexContext = readExocortex(input.exocortexPath);
     const formatted = formatExocortexForPrompt(exocortexContext);
     if (formatted) statedIntent = formatted;
+    const priorReads = loadPriorReads(input.exocortexPath);
+    if (priorReads.length > 0) {
+      priorReadContext = formatPriorReadsForPrompt(priorReads);
+    }
+  }
+  let events;
+  let orgRepos;
+  if (input.scope.type === "org") {
+    const orgResult = await fetchGitHubOrgActivity(
+      input.scope,
+      input.githubToken,
+      { windowDays }
+    );
+    events = orgResult.events;
+    orgRepos = orgResult.repos;
+  } else {
+    events = await fetchGitHubActivity(input.scope, input.githubToken, {
+      windowDays
+    });
   }
-  const events = await fetchGitHubActivity(input.scope, input.githubToken, {
-    windowDays
-  });
   const classified = classifyEvents(events);
   const signals = extractSignals(classified);
   const scores = computeScores(signals, input.worldmodelContent !== "");
@@ -21443,11 +21848,18 @@ async function emergent(input) {
     lens,
     ai: input.ai,
     canonicalPatterns: input.canonicalPatterns,
-    statedIntent
+    statedIntent: statedIntent ? statedIntent + (priorReadContext ? "\n\n" + priorReadContext : "") : priorReadContext || void 0
   });
   const rewrittenPatterns = patterns.map((p) => lens.rewrite(p));
   const allDescriptions = rewrittenPatterns.map((p) => p.description).join("\n");
   const voiceViolations = checkForbiddenPhrases(lens, allDescriptions);
+  let governance;
+  if (input.worldPath) {
+    try {
+      governance = await auditGovernance(classified, input.worldPath);
+    } catch {
+    }
+  }
   const rendered = render({
     scope: input.scope,
     windowDays,
@@ -21457,8 +21869,27 @@ async function emergent(input) {
     scores,
     lens,
     meaning: meaning || void 0,
-    move: move || void 0
+    move: move || void 0,
+    governance
   });
+  if (input.exocortexPath) {
+    try {
+      const readPath = writeRead(input.exocortexPath, rendered.frontmatter, rendered.text);
+      const priorReads = loadPriorReads(input.exocortexPath);
+      const currentPatternNames = rewrittenPatterns.map((p) => p.name);
+      const persistence = computePersistence(priorReads, currentPatternNames);
+      const triggeredItems = governance ? [
+        ...governance.human.details.map((d) => d.ruleId).filter(Boolean),
+        ...governance.cyber.details.map((d) => d.ruleId).filter(Boolean),
+        ...governance.joint.details.map((d) => d.ruleId).filter(Boolean)
+      ] : [];
+      updateKnowledge(input.exocortexPath, persistence, {
+        triggeredItems,
+        totalReads: priorReads.length + 1
+      });
+    } catch {
+    }
+  }
   return {
     text: rendered.text,
     frontmatter: rendered.frontmatter,
@@ -21522,6 +21953,8 @@ var init_emergent = __esm({
     init_lenses();
     init_github2();
     init_exocortex();
+    init_palace();
+    init_governance();
     init_signals();
     init_math();
     init_patterns();
@@ -21570,6 +22003,277 @@ var init_ai = __esm({
   }
 });
 
+// src/radiant/mcp/server.ts
+var server_exports = {};
+__export(server_exports, {
+  RadiantMcpServer: () => RadiantMcpServer,
+  startRadiantMcp: () => startRadiantMcp
+});
+function loadWorldmodelContent(worldsPath) {
+  const resolved = (0, import_path15.resolve)(worldsPath);
+  if (!(0, import_fs14.existsSync)(resolved)) {
+    throw new Error(`Worlds path not found: ${resolved}`);
+  }
+  const stat = (0, import_fs14.statSync)(resolved);
+  if (stat.isFile()) {
+    return (0, import_fs14.readFileSync)(resolved, "utf-8");
+  }
+  if (stat.isDirectory()) {
+    const files = (0, import_fs14.readdirSync)(resolved).filter(
+      (f) => (0, import_path15.extname)(f) === ".md" && (f.endsWith(".worldmodel.md") || f.endsWith(".nv-world.md"))
+    ).sort();
+    if (files.length === 0) {
+      throw new Error(`No worldmodel files found in ${resolved}`);
+    }
+    return files.map((f) => (0, import_fs14.readFileSync)((0, import_path15.join)(resolved, f), "utf-8")).join("\n\n---\n\n");
+  }
+  throw new Error(`Worlds path is neither a file nor directory: ${resolved}`);
+}
+async function startRadiantMcp(args) {
+  function parseArg3(flag) {
+    const idx = args.indexOf(flag);
+    return idx >= 0 && idx + 1 < args.length ? args[idx + 1] : void 0;
+  }
+  const worldsPath = parseArg3("--worlds") ?? process.env.RADIANT_WORLDS;
+  const lensId = parseArg3("--lens") ?? process.env.RADIANT_LENS ?? "auki-builder";
+  const model = parseArg3("--model") ?? process.env.RADIANT_MODEL;
+  if (!worldsPath) {
+    process.stderr.write("Error: --worlds <dir> or RADIANT_WORLDS required.\n");
+    process.exit(1);
+  }
+  const server = new RadiantMcpServer({ worldsPath, lensId, model });
+  await server.start();
+}
+var import_fs14, import_path15, TOOLS, RadiantMcpServer;
+var init_server = __esm({
+  "src/radiant/mcp/server.ts"() {
+    "use strict";
+    import_fs14 = require("fs");
+    import_path15 = require("path");
+    init_think();
+    init_emergent();
+    init_ai();
+    init_scopes();
+    TOOLS = [
+      {
+        name: "radiant_think",
+        description: "Send a query through the loaded worldmodel + rendering lens and get an Auki-framed response. Use this for strategic questions, decision evaluation, or any question that should be interpreted through the organization's behavioral model.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            query: {
+              type: "string",
+              description: "The question or prompt to interpret through the worldmodel + lens."
+            }
+          },
+          required: ["query"]
+        }
+      },
+      {
+        name: "radiant_emergent",
+        description: "Run a behavioral read on a GitHub repository. Fetches recent activity, classifies events, extracts signals, identifies patterns, computes alignment scores, and produces the EMERGENT / MEANING / MOVE / ALIGNMENT output. Use this when asked about team activity, coordination patterns, or alignment with the worldmodel.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            scope: {
+              type: "string",
+              description: 'GitHub repository in "owner/repo" format (e.g. "aukiverse/posemesh").'
+            },
+            exocortex_dir: {
+              type: "string",
+              description: "Optional path to an exocortex directory for stated-intent-vs-observed-behavior comparison."
+            }
+          },
+          required: ["scope"]
+        }
+      }
+    ];
+    RadiantMcpServer = class {
+      config;
+      worldmodelContent;
+      buffer = "";
+      constructor(config) {
+        this.config = config;
+        this.worldmodelContent = loadWorldmodelContent(config.worldsPath);
+      }
+      async start() {
+        process.stderr.write(
+          `Radiant MCP server starting
+  Worlds: ${this.config.worldsPath}
+  Lens:   ${this.config.lensId}
+  Tools:  radiant_think, radiant_emergent
+`
+        );
+        process.stdin.setEncoding("utf-8");
+        process.stdin.on("data", (chunk) => {
+          this.buffer += chunk;
+          this.processBuffer();
+        });
+        process.stdin.on("end", () => {
+          process.exit(0);
+        });
+      }
+      processBuffer() {
+        const lines = this.buffer.split("\n");
+        this.buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed) continue;
+          try {
+            const request = JSON.parse(trimmed);
+            this.handleRequest(request).catch((err) => {
+              this.sendError(request.id, -32603, String(err));
+            });
+          } catch {
+          }
+        }
+      }
+      async handleRequest(req) {
+        switch (req.method) {
+          case "initialize":
+            this.sendResult(req.id, {
+              protocolVersion: "2024-11-05",
+              capabilities: { tools: {} },
+              serverInfo: {
+                name: "radiant",
+                version: "0.6.1"
+              }
+            });
+            break;
+          case "notifications/initialized":
+            break;
+          case "tools/list":
+            this.sendResult(req.id, { tools: TOOLS });
+            break;
+          case "tools/call":
+            await this.handleToolCall(req);
+            break;
+          default:
+            this.sendError(req.id, -32601, `Unknown method: ${req.method}`);
+        }
+      }
+      async handleToolCall(req) {
+        const params = req.params;
+        if (!params?.name) {
+          this.sendError(req.id, -32602, "Missing tool name");
+          return;
+        }
+        const args = params.arguments ?? {};
+        try {
+          switch (params.name) {
+            case "radiant_think":
+              await this.handleThink(req.id, args);
+              break;
+            case "radiant_emergent":
+              await this.handleEmergent(req.id, args);
+              break;
+            default:
+              this.sendError(req.id, -32602, `Unknown tool: ${params.name}`);
+          }
+        } catch (err) {
+          this.sendResult(req.id, {
+            content: [{ type: "text", text: `Error: ${err}` }],
+            isError: true
+          });
+        }
+      }
+      async handleThink(id, args) {
+        const query = String(args.query ?? "");
+        if (!query) {
+          this.sendResult(id, {
+            content: [{ type: "text", text: "Error: query is required" }],
+            isError: true
+          });
+          return;
+        }
+        const apiKey = process.env.ANTHROPIC_API_KEY;
+        if (!apiKey) {
+          this.sendResult(id, {
+            content: [{ type: "text", text: "Error: ANTHROPIC_API_KEY not set" }],
+            isError: true
+          });
+          return;
+        }
+        const ai = createAnthropicAI(apiKey, this.config.model || void 0);
+        const result = await think({
+          worldmodelContent: this.worldmodelContent,
+          lensId: this.config.lensId,
+          query,
+          ai
+        });
+        let text = result.response;
+        if (!result.voiceClean) {
+          text += `
+
+\u26A0 Voice violations detected: ${result.voiceViolations.map((v) => v.phrase).join(", ")}`;
+        }
+        this.sendResult(id, {
+          content: [{ type: "text", text }]
+        });
+      }
+      async handleEmergent(id, args) {
+        const scopeStr = String(args.scope ?? "");
+        if (!scopeStr) {
+          this.sendResult(id, {
+            content: [{ type: "text", text: 'Error: scope is required (e.g. "aukiverse/posemesh")' }],
+            isError: true
+          });
+          return;
+        }
+        const apiKey = process.env.ANTHROPIC_API_KEY;
+        const githubToken = process.env.GITHUB_TOKEN;
+        if (!apiKey) {
+          this.sendResult(id, {
+            content: [{ type: "text", text: "Error: ANTHROPIC_API_KEY not set" }],
+            isError: true
+          });
+          return;
+        }
+        if (!githubToken) {
+          this.sendResult(id, {
+            content: [{ type: "text", text: "Error: GITHUB_TOKEN not set" }],
+            isError: true
+          });
+          return;
+        }
+        const scope = parseRepoScope(scopeStr);
+        const ai = createAnthropicAI(apiKey, this.config.model || void 0);
+        const exocortexPath = args.exocortex_dir ? String(args.exocortex_dir) : void 0;
+        const result = await emergent({
+          scope,
+          githubToken,
+          worldmodelContent: this.worldmodelContent,
+          lensId: this.config.lensId,
+          ai,
+          windowDays: 14,
+          exocortexPath
+        });
+        let text = result.text;
+        if (!result.voiceClean) {
+          text += `
+
+\u26A0 Voice violations: ${result.voiceViolations.map((v) => v.phrase).join(", ")}`;
+        }
+        this.sendResult(id, {
+          content: [{ type: "text", text }]
+        });
+      }
+      sendResult(id, result) {
+        const response = { jsonrpc: "2.0", id, result };
+        process.stdout.write(JSON.stringify(response) + "\n");
+      }
+      sendError(id, code, message) {
+        const response = {
+          jsonrpc: "2.0",
+          id: id ?? null,
+          error: { code, message }
+        };
+        process.stdout.write(JSON.stringify(response) + "\n");
+      }
+    };
+  }
+});
+
 // src/cli/radiant.ts
 var radiant_exports = {};
 __export(radiant_exports, {
@@ -21583,6 +22287,8 @@ function parseArgs27(argv) {
     query: void 0,
     model: void 0,
     exocortex: void 0,
+    teamExocortex: void 0,
+    view: void 0,
     json: false,
     help: false,
     rest: []
@@ -21610,6 +22316,12 @@ function parseArgs27(argv) {
       case "--exocortex":
         result.exocortex = argv[++i];
         break;
+      case "--team-exocortex":
+        result.teamExocortex = argv[++i];
+        break;
+      case "--view":
+        result.view = argv[++i];
+        break;
       case "--json":
         result.json = true;
         break;
@@ -21625,18 +22337,18 @@ function parseArgs27(argv) {
   }
   return result;
 }
-function loadWorldmodelContent(worldsPath) {
-  const resolved = (0, import_path14.resolve)(worldsPath);
-  if (!(0, import_fs13.existsSync)(resolved)) {
+function loadWorldmodelContent2(worldsPath) {
+  const resolved = (0, import_path16.resolve)(worldsPath);
+  if (!(0, import_fs15.existsSync)(resolved)) {
     throw new Error(`Worlds path not found: ${resolved}`);
   }
-  const stat = (0, import_fs13.statSync)(resolved);
+  const stat = (0, import_fs15.statSync)(resolved);
   if (stat.isFile()) {
-    return (0, import_fs13.readFileSync)(resolved, "utf-8");
+    return (0, import_fs15.readFileSync)(resolved, "utf-8");
   }
   if (stat.isDirectory()) {
-    const files = (0, import_fs13.readdirSync)(resolved).filter(
-      (f) => (0, import_path14.extname)(f) === ".md" && (f.endsWith(".worldmodel.md") || f.endsWith(".nv-world.md"))
+    const files = (0, import_fs15.readdirSync)(resolved).filter(
+      (f) => (0, import_path16.extname)(f) === ".md" && (f.endsWith(".worldmodel.md") || f.endsWith(".nv-world.md"))
     ).sort();
     if (files.length === 0) {
       throw new Error(
@@ -21644,7 +22356,7 @@ function loadWorldmodelContent(worldsPath) {
       );
     }
     return files.map((f) => {
-      const content = (0, import_fs13.readFileSync)((0, import_path14.join)(resolved, f), "utf-8");
+      const content = (0, import_fs15.readFileSync)((0, import_path16.join)(resolved, f), "utf-8");
       return `<!-- worldmodel: ${f} -->
 ${content}`;
     }).join("\n\n---\n\n");
@@ -21683,7 +22395,7 @@ ${DIM3}Set it to your Anthropic API key to use Radiant's AI features.${RESET3}
     query = args.rest.join(" ");
   }
   if (!query && !process.stdin.isTTY) {
-    query = (0, import_fs13.readFileSync)(0, "utf-8").trim();
+    query = (0, import_fs15.readFileSync)(0, "utf-8").trim();
   }
   if (!query) {
     process.stderr.write(
@@ -21693,7 +22405,7 @@ ${DIM3}Use --query "...", pass as trailing args, or pipe via stdin.${RESET3}
     );
     process.exit(1);
   }
-  const worldmodelContent = loadWorldmodelContent(worldsPath);
+  const worldmodelContent = loadWorldmodelContent2(worldsPath);
   const model = args.model ?? process.env.RADIANT_MODEL;
   const ai = createAnthropicAI(apiKey, model || void 0);
   process.stderr.write(
@@ -21751,7 +22463,7 @@ async function cmdEmergent(args) {
     );
     process.exit(1);
   }
-  const scope = parseRepoScope(scopeStr);
+  const scope = parseScope(scopeStr);
   const lensId = args.lens ?? process.env.RADIANT_LENS;
   if (!lensId) {
     process.stderr.write(
@@ -21786,9 +22498,18 @@ ${DIM3}Set it to a GitHub PAT with repo read access.${RESET3}
     );
     process.exit(1);
   }
-  const worldmodelContent = loadWorldmodelContent(worldsPath);
+  const worldmodelContent = loadWorldmodelContent2(worldsPath);
   const model = args.model ?? process.env.RADIANT_MODEL;
   const ai = createAnthropicAI(anthropicKey, model || void 0);
+  const view = args.view ?? process.env.RADIANT_VIEW ?? "community";
+  const validViews = ["community", "team", "full"];
+  if (!validViews.includes(view)) {
+    process.stderr.write(
+      `${RED2}Error:${RESET3} --view must be community, team, or full. Got "${view}".
+`
+    );
+    process.exit(1);
+  }
   const exocortexPath = args.exocortex ?? process.env.RADIANT_EXOCORTEX;
   let exocortexStatus = "not loaded";
   if (exocortexPath) {
@@ -21796,7 +22517,8 @@ ${DIM3}Set it to a GitHub PAT with repo read access.${RESET3}
     exocortexStatus = summarizeExocortex(ctx);
   }
   process.stderr.write(
-    `${DIM3}Scope:      ${scope.owner}/${scope.repo}${RESET3}
+    `${DIM3}Scope:      ${scope.type === "org" ? scope.owner + " (entire org)" : scope.owner + "/" + scope.repo}${RESET3}
+${DIM3}View:       ${view}${RESET3}
 ${DIM3}Lens:       ${lensId}${RESET3}
 ${DIM3}Model:      ${model ?? "claude-sonnet-4-20250514 (default)"}${RESET3}
 ${DIM3}ExoCortex:  ${exocortexStatus}${RESET3}
@@ -21926,6 +22648,10 @@ async function main34(argv) {
       return cmdLenses(args);
     case "emergent":
       return cmdEmergent(args);
+    case "mcp": {
+      const { startRadiantMcp: startRadiantMcp2 } = await Promise.resolve().then(() => (init_server(), server_exports));
+      return startRadiantMcp2(argv);
+    }
     case "decision":
     case "signals":
     case "drift":
@@ -21946,12 +22672,12 @@ async function main34(argv) {
       process.exit(1);
   }
 }
-var import_fs13, import_path14, RED2, DIM3, BOLD3, YELLOW3, RESET3, USAGE10;
+var import_fs15, import_path16, RED2, DIM3, BOLD3, YELLOW3, RESET3, USAGE10;
 var init_radiant = __esm({
   "src/cli/radiant.ts"() {
     "use strict";
-    import_fs13 = require("fs");
-    import_path14 = require("path");
+    import_fs15 = require("fs");
+    import_path16 = require("path");
     init_think();
     init_emergent();
     init_ai();