@neuroverseos/governance 0.6.0 → 0.6.1

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: join14 } = await import("path");
-  const { readdirSync: readdirSync6 } = await import("fs");
+  const { join: join16 } = await import("path");
+  const { readdirSync: readdirSync7 } = await import("fs");
   async function readJson(filename) {
-    const filePath = join14(dirPath, filename);
+    const filePath = join16(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 = join14(dirPath, "rules");
-    const ruleFiles = readdirSync6(rulesDir).filter((f) => f.endsWith(".json")).sort();
+    const rulesDir = join16(dirPath, "rules");
+    const ruleFiles = readdirSync7(rulesDir).filter((f) => f.endsWith(".json")).sort();
     for (const file of ruleFiles) {
       try {
-        const content = await readFile4(join14(rulesDir, file), "utf-8");
+        const content = await readFile4(join16(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: join14, dirname: dirname4 } = await import("path");
-  const { existsSync: existsSync10 } = await import("fs");
+  const { join: join16, dirname: dirname4 } = await import("path");
+  const { existsSync: existsSync12 } = 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 = join14(thisFile, "..", "..");
+    packageRoot = join16(thisFile, "..", "..");
   } catch {
     packageRoot = process.cwd();
   }
   const candidates = [
-    join14(packageRoot, "dist", "worlds", filename),
-    join14(packageRoot, "src", "worlds", filename)
+    join16(packageRoot, "dist", "worlds", filename),
+    join16(packageRoot, "src", "worlds", filename)
   ];
   for (const candidate of candidates) {
-    if (existsSync10(candidate)) {
+    if (existsSync12(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: join14 } = await import("path");
-  const guardsPath = join14(worldDir, "guards.json");
+  const { join: join16 } = await import("path");
+  const guardsPath = join16(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: join14 } = await import("path");
-  const { readdirSync: readdirSync6 } = await import("fs");
-  const rulesDir = join14(worldDir, "rules");
+  const { join: join16 } = await import("path");
+  const { readdirSync: readdirSync7 } = await import("fs");
+  const rulesDir = join16(worldDir, "rules");
   await mkdir3(rulesDir, { recursive: true });
   let nextNum = 1;
   try {
-    const existing = readdirSync6(rulesDir).filter((f) => f.match(/^rule-\d+\.json$/)).sort();
+    const existing = readdirSync7(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 = join14(rulesDir, `rule-${ruleNum}.json`);
+  const rulePath = join16(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: join14 } = await import("path");
-  const invariantsPath = join14(worldDir, "invariants.json");
+  const { join: join16 } = await import("path");
+  const invariantsPath = join16(worldDir, "invariants.json");
   let config;
   try {
     const raw = await readFile4(invariantsPath, "utf-8");
@@ -2849,7 +2849,7 @@ ${candidates.map((c) => `  - ${c}`).join("\n")}`
 }
 async function collectMarkdownSources(inputPath) {
   const { stat, readFile: rf, readdir } = await import("fs/promises");
-  const { join: pathJoin, extname: extname2, basename: basename4 } = await import("path");
+  const { join: pathJoin, extname: extname3, basename: basename4 } = await import("path");
   const stats = await stat(inputPath);
   if (stats.isFile()) {
     const content = await rf(inputPath, "utf-8");
@@ -2857,20 +2857,20 @@ async function collectMarkdownSources(inputPath) {
   }
   if (stats.isDirectory()) {
     const sources = [];
-    await collectDir(inputPath, sources, rf, pathJoin, extname2, basename4);
+    await collectDir(inputPath, sources, rf, pathJoin, extname3, basename4);
     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, extname2, basename4) {
+async function collectDir(dir, sources, rf, pathJoin, extname3, basename4) {
   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, extname2, basename4);
-    } else if (entry.isFile() && extname2(entry.name).toLowerCase() === ".md") {
+      await collectDir(fullPath, sources, rf, pathJoin, extname3, basename4);
+    } else if (entry.isFile() && extname3(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: join14 } = await import("path");
+  const { join: join16 } = await import("path");
   await mkdir3(outputDir, { recursive: true });
-  await writeFile6(join14(outputDir, "world.json"), JSON.stringify(world.world, null, 2));
-  await writeFile6(join14(outputDir, "invariants.json"), JSON.stringify({ invariants: world.invariants }, null, 2));
-  await writeFile6(join14(outputDir, "assumptions.json"), JSON.stringify(world.assumptions, null, 2));
-  await writeFile6(join14(outputDir, "state-schema.json"), JSON.stringify(world.stateSchema, null, 2));
-  await writeFile6(join14(outputDir, "gates.json"), JSON.stringify(world.gates, null, 2));
-  await writeFile6(join14(outputDir, "outcomes.json"), JSON.stringify(world.outcomes, null, 2));
-  await writeFile6(join14(outputDir, "metadata.json"), JSON.stringify(world.metadata, null, 2));
-  const rulesDir = join14(outputDir, "rules");
+  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 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(join14(rulesDir, `rule-${ruleNum}.json`), JSON.stringify(sortedRules[i], null, 2));
+    await writeFile6(join16(rulesDir, `rule-${ruleNum}.json`), JSON.stringify(sortedRules[i], null, 2));
   }
 }
 function write(msg) {
@@ -3673,9 +3673,9 @@ World source written to: ${derivedPath}
     try {
       const emitResult = emitWorldDefinition(parseResult.world);
       await writeWorldFiles(outputDir, emitResult.world);
-      const { join: join14 } = await import("path");
+      const { join: join16 } = await import("path");
       const { copyFile } = await import("fs/promises");
-      const sourceDest = join14(outputDir, "source.nv-world.md");
+      const sourceDest = join16(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: existsSync10 } = await import("fs");
-    if (existsSync10(args.outputPath)) {
+    const { existsSync: existsSync12 } = await import("fs");
+    if (existsSync12(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: join14 } = await import("path");
+  const { join: join16 } = await import("path");
   await mkdir3(outputDir, { recursive: true });
-  await writeFile6(join14(outputDir, "world.json"), JSON.stringify(world.world, null, 2));
-  await writeFile6(join14(outputDir, "invariants.json"), JSON.stringify({ invariants: world.invariants }, null, 2));
-  await writeFile6(join14(outputDir, "assumptions.json"), JSON.stringify(world.assumptions, null, 2));
-  await writeFile6(join14(outputDir, "state-schema.json"), JSON.stringify(world.stateSchema, null, 2));
-  const rulesDir = join14(outputDir, "rules");
+  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 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(join14(rulesDir, `rule-${ruleNum}.json`), JSON.stringify(sortedRules[i], null, 2));
+    await writeFile6(join16(rulesDir, `rule-${ruleNum}.json`), JSON.stringify(sortedRules[i], null, 2));
   }
-  await writeFile6(join14(outputDir, "gates.json"), JSON.stringify(world.gates, null, 2));
-  await writeFile6(join14(outputDir, "outcomes.json"), JSON.stringify(world.outcomes, null, 2));
-  await writeFile6(join14(outputDir, "metadata.json"), JSON.stringify(world.metadata, 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));
 }
 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: join14 } = await import("path");
-  const dir = policiesDir ?? join14(process.cwd(), "policies");
+  const { join: join16 } = await import("path");
+  const dir = policiesDir ?? join16(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(join14(dir, file), "utf-8");
+      const content = await readFile4(join16(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: join14 } = await import("path");
+  const { join: join16 } = 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(join14(dir, "world.json"), JSON.stringify(worldJson, null, 2)),
-    writeFile6(join14(dir, "kernel.json"), JSON.stringify(kernelJson, null, 2)),
-    writeFile6(join14(dir, "metadata.json"), JSON.stringify(metadataJson, null, 2))
+    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))
   ]);
 }
 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((resolve6, reject) => {
+    return new Promise((resolve8, reject) => {
       const chunks = [];
       req.on("data", (chunk) => chunks.push(chunk));
-      req.on("end", () => resolve6(Buffer.concat(chunks).toString("utf-8")));
+      req.on("end", () => resolve8(Buffer.concat(chunks).toString("utf-8")));
       req.on("error", reject);
     });
   }
@@ -11475,9 +11475,9 @@ async function main15(argv) {
   }
   if (worldPath) {
     try {
-      const { existsSync: existsSync10 } = await import("fs");
-      const { join: join14 } = await import("path");
-      const hasWorld = existsSync10(join14(worldPath, "world.json"));
+      const { existsSync: existsSync12 } = await import("fs");
+      const { join: join16 } = await import("path");
+      const hasWorld = existsSync12(join16(worldPath, "world.json"));
       checks.push({
         label: "World file detected",
         status: hasWorld ? "pass" : "fail",
@@ -11492,12 +11492,12 @@ async function main15(argv) {
       });
     }
   } else {
-    const { existsSync: existsSync10 } = await import("fs");
-    const { join: join14 } = await import("path");
+    const { existsSync: existsSync12 } = await import("fs");
+    const { join: join16 } = await import("path");
     const candidates = ["./world", "./.neuroverse", "./worlds"];
     let found;
     for (const dir of candidates) {
-      if (existsSync10(join14(dir, "world.json"))) {
+      if (existsSync12(join16(dir, "world.json"))) {
         found = dir;
         break;
       }
@@ -13148,7 +13148,7 @@ async function runPipeMode(config) {
 `);
   }
   const MAX_BUFFER_SIZE = 1e6;
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve8, 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
 `
       );
-      resolve6();
+      resolve8();
     });
     process.stdin.on("error", reject);
   });
@@ -13310,8 +13310,8 @@ ${response.content}
   rl2.on("close", () => {
     session.stop();
   });
-  return new Promise((resolve6) => {
-    rl2.on("close", resolve6);
+  return new Promise((resolve8) => {
+    rl2.on("close", resolve8);
   });
 }
 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: join14 } = await import("path");
+  const { join: join16 } = await import("path");
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-  const snapshotDir = join14(worldPath, ".snapshots", timestamp);
+  const snapshotDir = join16(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(join14(worldPath, file), "utf-8");
-      await writeFile6(join14(snapshotDir, file), content, "utf-8");
+      const content = await readFile4(join16(worldPath, file), "utf-8");
+      await writeFile6(join16(snapshotDir, file), content, "utf-8");
       copied++;
     }
   }
   try {
-    const rulesDir = join14(worldPath, "rules");
+    const rulesDir = join16(worldPath, "rules");
     const ruleFiles = await readdir(rulesDir);
-    await mkdir3(join14(snapshotDir, "rules"), { recursive: true });
+    await mkdir3(join16(snapshotDir, "rules"), { recursive: true });
     for (const file of ruleFiles) {
       if (file.endsWith(".json")) {
-        const content = await readFile4(join14(rulesDir, file), "utf-8");
-        await writeFile6(join14(snapshotDir, "rules", file), content, "utf-8");
+        const content = await readFile4(join16(rulesDir, file), "utf-8");
+        await writeFile6(join16(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: join14 } = await import("path");
-  const snapshotsDir = join14(worldPath, ".snapshots");
+  const { join: join16 } = await import("path");
+  const snapshotsDir = join16(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 = join14(snapshotsDir, latest);
+  const snapshotDir = join16(snapshotsDir, latest);
   const backupTimestamp = "pre-rollback-" + (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-  const backupDir = join14(snapshotsDir, backupTimestamp);
+  const backupDir = join16(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(join14(worldPath, file), "utf-8");
-      await writeFile6(join14(backupDir, file), content, "utf-8");
+      const content = await readFile4(join16(worldPath, file), "utf-8");
+      await writeFile6(join16(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(join14(snapshotDir, file), "utf-8");
-      await writeFile6(join14(worldPath, file), content, "utf-8");
+      const content = await readFile4(join16(snapshotDir, file), "utf-8");
+      await writeFile6(join16(worldPath, file), content, "utf-8");
       restored++;
     }
   }
   try {
-    const rulesDir = join14(snapshotDir, "rules");
+    const rulesDir = join16(snapshotDir, "rules");
     const ruleFiles = await readdir(rulesDir);
-    await mkdir3(join14(worldPath, "rules"), { recursive: true });
+    await mkdir3(join16(worldPath, "rules"), { recursive: true });
     for (const file of ruleFiles) {
       if (file.endsWith(".json")) {
-        const content = await readFile4(join14(rulesDir, file), "utf-8");
-        await writeFile6(join14(worldPath, "rules", file), content, "utf-8");
+        const content = await readFile4(join16(rulesDir, file), "utf-8");
+        await writeFile6(join16(worldPath, "rules", file), content, "utf-8");
         restored++;
       }
     }
@@ -16400,27 +16400,27 @@ function closePrompts() {
 }
 function ask(question, defaultValue) {
   const suffix = defaultValue ? ` [${defaultValue}]` : "";
-  return new Promise((resolve6) => {
+  return new Promise((resolve8) => {
     getRL().question(`
   ${question}${suffix}: `, (answer) => {
       const val = answer.trim();
-      resolve6(val || defaultValue || "");
+      resolve8(val || defaultValue || "");
     });
   });
 }
 function confirm(question, defaultYes = true) {
   const hint = defaultYes ? "[Y/n]" : "[y/N]";
-  return new Promise((resolve6) => {
+  return new Promise((resolve8) => {
     getRL().question(`
   ${question} ${hint}: `, (answer) => {
       const val = answer.trim().toLowerCase();
-      if (val === "") resolve6(defaultYes);
-      else resolve6(val === "y" || val === "yes");
+      if (val === "") resolve8(defaultYes);
+      else resolve8(val === "y" || val === "yes");
     });
   });
 }
 function choose(question, options) {
-  return new Promise((resolve6) => {
+  return new Promise((resolve8) => {
     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) {
-        resolve6(options[idx]);
+        resolve8(options[idx]);
       } else {
-        resolve6(options[0]);
+        resolve8(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: existsSync10 } = await import("fs");
+  const { mkdirSync: mkdirSync5, existsSync: existsSync12 } = await import("fs");
   const { writeFile: writeFile6 } = await import("fs/promises");
-  const { join: join14 } = await import("path");
+  const { join: join16 } = await import("path");
   const files = [];
-  if (!existsSync10(outputDir)) mkdirSync5(outputDir, { recursive: true });
-  const rulesDir = join14(outputDir, "rules");
-  if (!existsSync10(rulesDir)) mkdirSync5(rulesDir, { recursive: true });
+  if (!existsSync12(outputDir)) mkdirSync5(outputDir, { recursive: true });
+  const rulesDir = join16(outputDir, "rules");
+  if (!existsSync12(rulesDir)) mkdirSync5(rulesDir, { recursive: true });
   const writeJson = async (name, data) => {
-    const path = join14(outputDir, name);
+    const path = join16(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 = join14(rulesDir, `${rule.id}.json`);
+    const rulePath = join16(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: join14 } = await import("path");
+  const { join: join16 } = 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(
-      join14(outputDir, "gates.json"),
+      join16(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(
-          join14(outputDir, "rules", `${rule.id}.json`),
+          join16(outputDir, "rules", `${rule.id}.json`),
           JSON.stringify(rule, null, 2) + "\n",
           "utf-8"
         );
@@ -17151,22 +17151,22 @@ ${parts.join(". ")}.
 `;
 }
 function previewLens(lens) {
-  const BOLD3 = "\x1B[1m";
-  const DIM3 = "\x1B[2m";
+  const BOLD4 = "\x1B[1m";
+  const DIM4 = "\x1B[2m";
   const CYAN3 = "\x1B[36m";
-  const YELLOW3 = "\x1B[33m";
+  const YELLOW4 = "\x1B[33m";
   const GREEN3 = "\x1B[32m";
-  const RESET3 = "\x1B[0m";
+  const RESET4 = "\x1B[0m";
   const lines = [];
   lines.push("");
-  lines.push(`${BOLD3}${CYAN3}  ${lens.name}${RESET3} ${DIM3}\u2014 ${lens.tagline}${RESET3}`);
-  lines.push(`${DIM3}  ${lens.description}${RESET3}`);
+  lines.push(`${BOLD4}${CYAN3}  ${lens.name}${RESET4} ${DIM4}\u2014 ${lens.tagline}${RESET4}`);
+  lines.push(`${DIM4}  ${lens.description}${RESET4}`);
   lines.push("");
   for (const d of lens.directives) {
     if (d.example) {
-      lines.push(`  ${BOLD3}${d.id}${RESET3}`);
-      lines.push(`  ${YELLOW3}Without:${RESET3} ${DIM3}${d.example.without}${RESET3}`);
-      lines.push(`  ${GREEN3}With:${RESET3}    ${d.example.with}`);
+      lines.push(`  ${BOLD4}${d.id}${RESET4}`);
+      lines.push(`  ${YELLOW4}Without:${RESET4} ${DIM4}${d.example.without}${RESET4}`);
+      lines.push(`  ${GREEN3}With:${RESET4}    ${d.example.with}`);
       lines.push("");
     }
   }
@@ -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: join14 } = await import("path");
+  const { join: join16 } = await import("path");
   const possiblePaths = [
-    join14(worldPath, "world.nv-world.md"),
+    join16(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 = join14(worldPath, mdFile);
+        mdPath = join16(worldPath, mdFile);
         mdContent = await readFile4(mdPath, "utf-8");
       }
     } catch {
@@ -19867,113 +19867,2182 @@ Examples:
   }
 });
 
+// src/radiant/lenses/auki-builder.ts
+function aukiBuilderRewrite(pattern) {
+  if (pattern.evidence.cited_invariant) {
+    return {
+      ...pattern,
+      framing: "invariant pressure",
+      emphasis: "worldmodel invariant cited by this observation \u2014 surface the cross-reference",
+      compress: true
+    };
+  }
+  if (pattern.type === "candidate") {
+    return {
+      ...pattern,
+      framing: "emergent observation (not yet in worldmodel)",
+      emphasis: "candidate pattern \u2014 surface the vanguard-domain analysis (which domain activated this?)",
+      compress: true
+    };
+  }
+  return {
+    ...pattern,
+    framing: "system-level consequence",
+    emphasis: "coordination + leverage",
+    compress: true
+  };
+}
+var AUKI_VANGUARD_FRAME, AUKI_VOCABULARY, AUKI_VOICE, AUKI_FORBIDDEN_PHRASES, AUKI_PREFERRED_PATTERNS, AUKI_STRATEGIC_PATTERNS, AUKI_EXEMPLARS, aukiBuilderLens;
+var init_auki_builder = __esm({
+  "src/radiant/lenses/auki-builder.ts"() {
+    "use strict";
+    AUKI_VANGUARD_FRAME = {
+      domains: [
+        "future-foresight",
+        "narrative-dynamics",
+        "shared-prosperity"
+      ],
+      overlaps: [
+        {
+          domains: ["future-foresight", "narrative-dynamics"],
+          emergent_state: "Inspiration",
+          description: "Visionary leaders inspire action by painting a vivid picture of a better future, helping people understand how to get there together. Emerges when long-range thinking meets language that rallies."
+        },
+        {
+          domains: ["narrative-dynamics", "shared-prosperity"],
+          emergent_state: "Trust",
+          description: "Built through authentic storytelling and consistent delivery on promises, creating a community where contributors feel secure in their contributions. Emerges when clear intent meets fair distribution \u2014 coalitions form here."
+        },
+        {
+          domains: ["shared-prosperity", "future-foresight"],
+          emergent_state: "Hope",
+          description: "Propels decentralized communities toward a collective future where resources are equitably distributed and success is shared by all. Emerges when long-term infrastructure is architected for collective benefit \u2014 the DePIN / Intercognitive posture."
+        }
+      ],
+      center_identity: "Collective Vanguard Leader",
+      evaluation_questions: [
+        "What long-range architectural thinking is present? Systems design, scenario planning, critical thinking, ethical judgment \u2014 which of these is visible, which is weak?",
+        "What communication and meaning-making is happening? Storytelling, cultural sensitivity, audience engagement, persuasive writing \u2014 who is telling the story of how the pieces connect?",
+        "What collaborative and fairness work is happening? Stakeholder management, partnership development, incentive alignment, community building \u2014 who is building coalitions and making sure value flows equitably?",
+        "Which overlap states surface \u2014 Inspiration (vision + narrative), Trust (narrative + fairness), Hope (fairness + long-term thinking)?",
+        "Is the integration complete (Collective Vanguard Leader manifests across all three dimensions) or is one dimension absent / weak?",
+        "If one dimension is weak, what specific skill inside it is the lowest-friction activation point?"
+      ],
+      scoring_rubric: `For any Auki activity, identify which specific skills are strongly present, which are weak, which are absent. Cite specific evidence for each. Name the overlap emergent states that surface using their plain-English names (Inspiration, Trust, Hope). Do not surface the bucket names (Future Foresight, Narrative Dynamics, Shared Prosperity) in the output \u2014 those are internal reasoning scaffolds, not reader-facing labels. Translate bucket-level findings into skill-level observations: not "Future Foresight is present" but "the architectural thinking is strong \u2014 the systems design is clear"; not "Shared Prosperity is weak" but "partnership development is missing" or "incentive alignment hasn't been established." Center identity (Collective Vanguard Leader) may be named sparingly, only when all three dimensions fully integrate.`,
+      /**
+       * The skills inside each domain. These are the OUTPUT-FACING vocabulary —
+       * the observable behaviors and capabilities readers understand. When the
+       * AI renders findings, it uses these skill names, not the bucket names.
+       *
+       * From Kirsten\'s original vanguard diagram (see exemplars/vanguard-diagram).
+       */
+      domain_skills: {
+        "future-foresight": [
+          "strategic thinking",
+          "systems design",
+          "scenario planning",
+          "futurism and trend analysis",
+          "critical thinking",
+          "innovative problem-solving",
+          "data-driven decision-making",
+          "ethical judgment and governance",
+          "risk assessment and mitigation",
+          "curiosity and open-mindedness"
+        ],
+        "narrative-dynamics": [
+          "storytelling and narrative crafting",
+          "behavioral psychology and memetics",
+          "emotional intelligence",
+          "communication and presentation skills",
+          "cultural sensitivity and adaptation",
+          "social media and viral messaging strategy",
+          "brand building and positioning",
+          "persuasive writing",
+          "visualization and design thinking",
+          "audience analysis and engagement"
+        ],
+        "shared-prosperity": [
+          "stakeholder management",
+          "collaborative leadership",
+          "conflict resolution and mediation",
+          "economic and tokenomic design",
+          "incentive alignment",
+          "community building and management",
+          "inclusivity and equity advocacy",
+          "partnership development",
+          "transparency and accountability",
+          "negotiation and diplomacy"
+        ]
+      },
+      /**
+       * The translation rule: bucket names stay internal; skills + overlap
+       * state names surface in output. This is enforced by both the
+       * output-directive (guidance to the AI) and the forbidden-phrases list
+       * (renderer-level rejection of any output leaking bucket names).
+       */
+      output_translation: {
+        never_surface_in_output: [
+          "Future Foresight",
+          "Narrative Dynamics",
+          "Shared Prosperity"
+        ],
+        surface_freely: [
+          "Inspiration",
+          "Trust",
+          "Hope"
+          // plus any specific skill name from domain_skills above
+        ],
+        surface_sparingly: ["Collective Vanguard Leader"],
+        translation_examples: [
+          {
+            internal_reasoning: "Future Foresight is strong",
+            external_expression: "the architectural thinking is strong; the systems design is clear"
+          },
+          {
+            internal_reasoning: "Shared Prosperity is weak",
+            external_expression: "partnership development is missing; no one has established incentive alignment across teams"
+          },
+          {
+            internal_reasoning: "Narrative Dynamics is absent",
+            external_expression: "no one is telling the story of how these pieces connect; the audience does not see the shared vision yet"
+          }
+        ]
+      }
+    };
+    AUKI_VOCABULARY = {
+      proper_nouns: [
+        "$AUKI",
+        "Posemesh",
+        "Auki Labs",
+        "Posemesh Foundation",
+        "Intercognitive Foundation",
+        "Intercognitive",
+        "Sixth Protocol",
+        "Fifth Protocol",
+        "DePIN",
+        "Cactus",
+        "Terri",
+        "Mech Jagger",
+        "peaq",
+        "Mawari",
+        "GEODNET",
+        "Nine Pillars of AI Accessibility",
+        "the real world web",
+        "the posemesh"
+      ],
+      // Generic term → Auki-native replacement
+      preferred: {
+        device: "participant",
+        client: "participant",
+        "coordinate system": "domain",
+        "QR code for calibration": "portal",
+        "work request": "task",
+        "location alignment": "calibrate",
+        "sensor reading": "observation",
+        "physical environment": "environment",
+        "the network (public-facing)": "the real world web",
+        "the network (technical)": "the posemesh",
+        "coordination between devices": "spatial orchestration",
+        "buying services": "burning tokens for credits",
+        "full autonomy": "the full stack",
+        "non-GPS environments": "GPS-denied environments",
+        "our partners": "the Intercognitive coalition (Auki, peaq, Mawari, GEODNET)"
+      },
+      architecture: [
+        "domain",
+        "domain cluster",
+        "domain manager",
+        "domain owner",
+        "semantic layer",
+        "topography layer",
+        "rendering layer",
+        "partitions",
+        "observations",
+        "portals",
+        "participant",
+        "supply participant",
+        "demand participant",
+        "capabilities",
+        "tasks",
+        "discovery service",
+        "DHT",
+        "substrate",
+        "spatial orchestration",
+        "app-free navigation",
+        "marker-free VPS",
+        "spatially aware",
+        "the stack",
+        "the robotics stack",
+        "GPS-denied",
+        "locomotion",
+        "manipulation",
+        "spatio-semantic perception",
+        "mapping",
+        "positioning",
+        "hybrid robotics",
+        "AI copilot",
+        "shared spatial layer"
+      ],
+      economic: [
+        "burn",
+        "credit",
+        "deflationary mint",
+        "reputation",
+        "vacancy",
+        "treasury",
+        "utilization rate",
+        "initial supply",
+        "total supply",
+        "organization",
+        "trustless",
+        "peer-to-peer transactions",
+        "machine passports",
+        "machine economy"
+      ],
+      framing: [
+        "machine perception",
+        "spatial computing",
+        "collaborative perception",
+        "cognitive liberty",
+        "perception-first",
+        "protocol-not-product",
+        "sovereignty",
+        "decentralization",
+        "territory capture",
+        "foundations-before-execution",
+        "make the world machine-readable",
+        "connective tissue between digital and physical",
+        "open, permissionless, interoperable, private",
+        "skip the bottleneck, ship the leverage",
+        "coalition before standard",
+        "hybrid over pure",
+        "augmentation without surveillance",
+        "civilization-scale infrastructure",
+        "public good, not proprietary asset",
+        "Inspiration",
+        "Trust",
+        "Hope",
+        "Collective Vanguard Leader"
+      ],
+      // System-internal concepts → plain English for output.
+      // Readers don't know Radiant's vocabulary. Speaking it to them is jargon.
+      jargon_translations: {
+        "worldmodel": "your strategy file",
+        "canonical pattern": "something Radiant tracks by name over time",
+        "candidate pattern": "something Radiant noticed but hasn't been told to watch for",
+        "evidence gate": "how much activity Radiant needs before it speaks",
+        "invariant": "a rule you declared non-negotiable",
+        "signal extraction": "reading the activity",
+        "alignment score": "how aligned the work is with what you said matters",
+        "actor domain": "who did the work (a person, an AI, or both together)",
+        "presence-based averaging": "only counts what actually happened",
+        "drift detection": "noticing when things are shifting from what you said you wanted",
+        "lens rewrite": "framing adjustment before output",
+        "INSUFFICIENT_EVIDENCE": "not enough to say confidently",
+        "UNAVAILABLE": "we can't measure this yet"
+      }
+    };
+    AUKI_VOICE = {
+      register: 'diagnosis mode \u2014 compressed, strategic, builder-direct. Closer to the closing paragraph of an Auki year-recap ("2025 was foundations. 2026 is execution.") than to its month-by-month celebration.',
+      active_voice: "required",
+      specificity: "required",
+      hype_vocabulary: "forbidden",
+      hedging: "forbidden",
+      playfulness: "rare",
+      close_with_strategic_frame: "preferred",
+      punchline_move: "sparing",
+      honesty_about_failure: "required",
+      output_translation: `Reason internally through the three-domain frame (Future Foresight, Narrative Dynamics, Shared Prosperity) \u2014 that is the analytical scaffold. Express findings externally in the skills vocabulary INSIDE each domain (e.g. "strategic thinking," "partnership development," "storytelling," "incentive alignment"). Use the overlap state names (Inspiration, Trust, Hope) as plain-English emergent feelings. Do NOT surface the bucket names themselves (Future Foresight, Narrative Dynamics, Shared Prosperity) as labels in output \u2014 they are the model-maker's scaffold, not reader vocabulary. Readers understand skills, not buckets. The bucket names are in the forbidden_phrases list; the renderer will fail output that leaks them. Collective Vanguard Leader may be named sparingly when all three dimensions are fully integrated.`
+    };
+    AUKI_FORBIDDEN_PHRASES = Object.freeze([
+      // Domain bucket names — never surface to readers; translate to skills
+      "future foresight",
+      "narrative dynamics",
+      "shared prosperity",
+      // AI-assistant hedging
+      "it may be beneficial to consider",
+      "there appears to be",
+      "one possible interpretation",
+      "it might be worth exploring",
+      "it might be worth considering",
+      "consider whether",
+      "it is worth noting",
+      "please note that",
+      "it should be noted",
+      "in conclusion",
+      // Corporate / marketing
+      "unparalleled",
+      "best-in-class",
+      "industry-leading",
+      "revolutionary",
+      "cutting-edge",
+      "state-of-the-art",
+      "thrilled to announce",
+      "excited to share",
+      "game-changing",
+      "synergy",
+      "synergies",
+      "stakeholders",
+      // too corporate; prefer named actors
+      "end-users",
+      "value proposition",
+      "paradigm shift",
+      // Generic motion
+      "going forward",
+      "moving forward",
+      "at the end of the day",
+      "touching base",
+      "circle back",
+      "deep dive",
+      "level set",
+      "low-hanging fruit"
+    ]);
+    AUKI_PREFERRED_PATTERNS = Object.freeze([
+      // Direct declarative observation
+      "[Specific skill] is strong here. [Named evidence].",
+      "[Specific skill] is breaking here. [Named evidence].",
+      "[Specific skill] is missing. [Named consequence].",
+      // Skills-level diagnosis (replaces the bucket-speak pattern)
+      "The [specific skill] is clear \u2014 [specific evidence]. But [another specific skill] is missing \u2014 [specific effect]. [Imperative move].",
+      "What is missing is [specific skill], not effort.",
+      "[Trust | Inspiration | Hope] won't emerge until [skill-A] and [skill-B] happen together.",
+      // Imperative move
+      "Force [action] or [consequence].",
+      "Tighten this or it fragments.",
+      "Skip the bottleneck, ship the leverage.",
+      "Coalition before standard.",
+      // Strategic close — list-becomes-argument (from year-recap)
+      "Combine [A, B, C] and suddenly [strategic implication].",
+      "[Phase A] was [what you built]. [Phase B] is [what you execute].",
+      // Binary stakes (from Intercognitive)
+      "[Centralize X in the hands of a few] or [build a decentralized alternative].",
+      // Short thesis compression (from glossary)
+      "[Subject] is [essential-function] \u2014 [one-line precision].",
+      // Named specificity
+      "[Named partner/place/number] is the one that matters here.",
+      // Honest texture (from year-recap)
+      "[Specific thing] is not yet [state] \u2014 [honest qualifier].",
+      // Pivot to reality before solution (from hybrid robotics)
+      "The truth is [current reality]. [Better approach] is [the move].",
+      // Overlap-state compression (surfacing the emergent feel, not the buckets)
+      "Trust is not emerging because [specific narrative skill] and [specific coalition skill] are not happening together.",
+      "Inspiration is landing here \u2014 [specific evidence of vision + rally].",
+      "Hope is present \u2014 [specific evidence of long-term thinking meeting fair distribution]."
+    ]);
+    AUKI_STRATEGIC_PATTERNS = Object.freeze([
+      "Skip the bottleneck, ship the leverage \u2014 identify the hard layers in the stack, build on the layers that deliver value now.",
+      "Coalition before standard \u2014 form the group that will set the rules before the rules need to exist.",
+      "Foundations before execution \u2014 build the infrastructure that makes the thing possible; then scale.",
+      "Hybrid over pure \u2014 augment humans with AI where full autonomy is not ready; transition later.",
+      "Decentralized > proprietary \u2014 when choosing architecture, prefer open / community-governed / interoperable over closed / owned / siloed.",
+      "Layered analysis first, strategic move second \u2014 decompose before deciding.",
+      'Named specificity over abstractions \u2014 cite people, places, partners, numbers; never "stakeholders" or "the industry."',
+      "Community deployment before public release \u2014 validate with a small group of operators before opening the door.",
+      "Cognitive liberty as inviolable constraint \u2014 block any move that violates sovereignty over spatial/sensor data, regardless of other benefits.",
+      "Compress mission to one sentence \u2014 one memorable thesis carries more weight than a manifesto."
+    ]);
+    AUKI_EXEMPLARS = Object.freeze([
+      {
+        path: "intercognitive-foundation.md",
+        title: "The Intercognitive Foundation",
+        exhibits: ["future-foresight", "narrative-dynamics", "shared-prosperity"],
+        integration_quality: "full \u2014 all three domains integrated; Collective Vanguard Leader manifests through the coalition itself",
+        notes: 'The perfect vanguard exemplar. Future Foresight: inflection-point framing, Nine Pillars architecture. Narrative Dynamics: "the physical world cannot remain a blind spot," rally language, invitation to join. Shared Prosperity: coalition of four founding members, "no single entity should own," community governance, public good framing. When Radiant outputs something that feels vanguard-complete, it should resemble this in structure and tone.'
+      },
+      {
+        path: "hybrid-robotics-essay.md",
+        title: "The Case for Hybrid Robotics",
+        exhibits: ["future-foresight", "shared-prosperity"],
+        integration_quality: "partial \u2014 Future Foresight dominant, Shared Prosperity secondary, Narrative Dynamics present but informing rather than rallying. Overlap: Hope emerges (long-horizon infrastructure for collective benefit).",
+        notes: 'Auki teaching how it thinks. The stack-analysis \u2192 bottleneck-identification \u2192 skip-and-ship pattern is a reusable Auki reasoning move. When the AI applies "systems-first" and "leverage-oriented" thinking, it should resemble this essay \u2014 structured, honest about current reality, pivoting to a better approach via layered reasoning.'
+      },
+      {
+        path: "glossary.md",
+        title: "Auki Glossary",
+        exhibits: ["future-foresight"],
+        integration_quality: 'primary-dominant \u2014 Future Foresight dominant (precise technical definitions as long-range conceptual infrastructure). Shared Prosperity implicit (glossary is open, cross-referenced, serves the ecosystem). Narrative Dynamics flashes once ("a mesh of machines reasoning about pose") but is not primary.',
+        notes: 'Source of the vocabulary map. Also teaches compression style: one-line precision definitions, cross-reference density, occasional poetic compression. When the renderer produces short thesis sentences, aim for the "mesh of machines reasoning about pose" level of compression.'
+      },
+      {
+        path: "year-recap-2025.md",
+        title: "Auki 2025 Year-End Recap",
+        exhibits: ["narrative-dynamics", "shared-prosperity"],
+        integration_quality: "partial \u2014 Narrative Dynamics dominant, Shared Prosperity strong, Future Foresight arrives only in the closing paragraph. Overlap: Trust emerges (stakeholders can see their place in the collective progress).",
+        notes: 'The celebration register \u2014 warm, specific, named. Not the diagnosis register the lens primarily enforces, but the same DNA. Use this exemplar when calibrating how Auki names specifics (Pepito in Bali, Mika Haak at HQ, the HK web3 robotics cabal) and how the "\u2014 literally" punchline move lands. Do NOT mimic the celebration warmth in diagnosis outputs.'
+      }
+    ]);
+    aukiBuilderLens = {
+      name: "auki-builder",
+      description: "Renders behavioral interpretation through the vanguard leadership model \u2014 Future Foresight, Narrative Dynamics, Shared Prosperity. Role-based, not personal. Encodes how Auki-grade builders think and speak when the vanguard model is running. Companion to auki-vanguard.worldmodel.md (the abstract DNA) and the exemplars at src/radiant/examples/auki/exemplars/ (worked implementations).",
+      primary_frame: {
+        domains: AUKI_VANGUARD_FRAME.domains,
+        overlaps: AUKI_VANGUARD_FRAME.overlaps,
+        center_identity: AUKI_VANGUARD_FRAME.center_identity,
+        evaluation_questions: AUKI_VANGUARD_FRAME.evaluation_questions,
+        scoring_rubric: AUKI_VANGUARD_FRAME.scoring_rubric
+      },
+      vocabulary: AUKI_VOCABULARY,
+      voice: AUKI_VOICE,
+      forbidden_phrases: AUKI_FORBIDDEN_PHRASES,
+      preferred_patterns: AUKI_PREFERRED_PATTERNS,
+      strategic_patterns: AUKI_STRATEGIC_PATTERNS,
+      exemplar_refs: AUKI_EXEMPLARS,
+      rewrite: aukiBuilderRewrite
+    };
+  }
+});
+
+// src/radiant/lenses/index.ts
+var lenses_exports = {};
+__export(lenses_exports, {
+  LENSES: () => LENSES,
+  aukiBuilderLens: () => aukiBuilderLens,
+  getLens: () => getLens2,
+  listLenses: () => listLenses
+});
+function getLens2(id) {
+  return LENSES[id];
+}
+function listLenses() {
+  return Object.freeze(Object.keys(LENSES));
+}
+var LENSES;
+var init_lenses = __esm({
+  "src/radiant/lenses/index.ts"() {
+    "use strict";
+    init_auki_builder();
+    init_auki_builder();
+    LENSES = Object.freeze({
+      "auki-builder": aukiBuilderLens
+    });
+  }
+});
+
+// src/radiant/core/prompt.ts
+function composeSystemPrompt(worldmodelContent, lens) {
+  const sections = [];
+  sections.push(
+    `## Worldmodel
+
+You are operating inside a governed environment. The worldmodel below
+defines the invariants, signals, decision priorities, and behavioral
+expectations for this organization. Every response you produce must
+be grounded in this worldmodel.
+
+` + worldmodelContent
+  );
+  const frame = lens.primary_frame;
+  const questionsBlock = frame.evaluation_questions.map((q, i) => `${i + 1}. ${q}`).join("\n");
+  const overlapsBlock = frame.overlaps.map(
+    (o) => `- ${o.domains[0]} + ${o.domains[1]} = **${o.emergent_state}**: ${o.description}`
+  ).join("\n");
+  sections.push(
+    `## How to Think (Analytical Frame: ${lens.name})
+
+${frame.scoring_rubric}
+
+### Evaluation questions to reason through
+
+${questionsBlock}
+
+### Overlap emergent states
+
+${overlapsBlock}
+
+### Center identity
+
+When all dimensions integrate fully: **${frame.center_identity}**. Surface this sparingly \u2014 only when the integration is genuinely complete.`
+  );
+  const vocabPreferred = Object.entries(lens.vocabulary.preferred).map(([generic, native]) => `- "${generic}" \u2192 **${native}**`).join("\n");
+  const vocabArchitecture = lens.vocabulary.architecture.map((t) => `\`${t}\``).join(", ");
+  const vocabProperNouns = lens.vocabulary.proper_nouns.map((n) => `**${n}**`).join(", ");
+  const strategicBlock = lens.strategic_patterns.map((p) => `- ${p}`).join("\n");
+  sections.push(
+    `## How to Speak (Voice: ${lens.name})
+
+Register: ${lens.voice.register}
+
+Rules:
+- Active voice: ${lens.voice.active_voice}
+- Named specificity (people, places, numbers): ${lens.voice.specificity}
+- Hype vocabulary: ${lens.voice.hype_vocabulary}
+- Hedging / qualified phrasing: ${lens.voice.hedging}
+- Playfulness: ${lens.voice.playfulness}
+- Close with strategic frame: ${lens.voice.close_with_strategic_frame}
+- Honesty about failure: ${lens.voice.honesty_about_failure}
+
+### Output translation discipline
+
+${lens.voice.output_translation}
+
+### Vocabulary
+
+Proper nouns (use literally): ${vocabProperNouns}
+
+Preferred term substitutions:
+${vocabPreferred}
+
+Architecture vocabulary: ${vocabArchitecture}
+
+### Strategic decision patterns
+
+When recommending action, these patterns reflect how this organization resolves tradeoffs:
+
+${strategicBlock}`
+  );
+  const forbiddenBlock = lens.forbidden_phrases.map((p) => `- "${p}"`).join("\n");
+  sections.push(
+    `## Guardrails
+
+Do NOT use any of these phrases in your response. If you catch yourself
+reaching for one, rephrase in direct, active, specific language instead.
+
+${forbiddenBlock}
+
+If your response would violate a worldmodel invariant, state the conflict
+explicitly and propose an alternative that honors the invariant.`
+  );
+  return sections.join("\n\n---\n\n");
+}
+var init_prompt = __esm({
+  "src/radiant/core/prompt.ts"() {
+    "use strict";
+  }
+});
+
+// src/radiant/core/voice-check.ts
+function checkForbiddenPhrases(lens, text) {
+  const lower = text.toLowerCase();
+  const violations = [];
+  for (const phrase of lens.forbidden_phrases) {
+    const phraseLower = phrase.toLowerCase();
+    let pos = 0;
+    while (true) {
+      const idx = lower.indexOf(phraseLower, pos);
+      if (idx === -1) break;
+      violations.push({ phrase, offset: idx });
+      pos = idx + phraseLower.length;
+    }
+  }
+  violations.sort((a, b) => a.offset - b.offset);
+  return violations;
+}
+var init_voice_check = __esm({
+  "src/radiant/core/voice-check.ts"() {
+    "use strict";
+  }
+});
+
+// src/radiant/commands/think.ts
+async function think(input) {
+  const lens = resolveLens(input.lensId);
+  const systemPrompt = composeSystemPrompt(input.worldmodelContent, lens);
+  const response = await input.ai.complete(systemPrompt, input.query);
+  const voiceViolations = checkForbiddenPhrases(lens, response);
+  return {
+    response,
+    lens: lens.name,
+    voiceViolations,
+    voiceClean: voiceViolations.length === 0,
+    systemPrompt
+  };
+}
+function resolveLens(id) {
+  const lens = getLens2(id);
+  if (!lens) {
+    const available = Object.keys(
+      // Inline import-free way to list. At runtime, getLens returns from
+      // the same LENSES record — we just need the keys for the error message.
+      // We re-import getLens from lenses/index which exposes listLenses, but
+      // since we already have lens===undefined we know the id was wrong.
+      {}
+    );
+    throw new Error(
+      `Lens "${id}" not found. Check the id or register the lens in src/radiant/lenses/index.ts.`
+    );
+  }
+  return lens;
+}
+var init_think = __esm({
+  "src/radiant/commands/think.ts"() {
+    "use strict";
+    init_lenses();
+    init_prompt();
+    init_voice_check();
+  }
+});
+
+// src/radiant/core/scopes.ts
+function parseRepoScope(scope) {
+  const cleaned = scope.replace(/^https?:\/\//, "").replace(/^github\.com\//, "").replace(/\.git$/, "").replace(/\/$/, "");
+  const parts = cleaned.split("/");
+  if (parts.length < 2 || !parts[0] || !parts[1]) {
+    throw new Error(
+      `Cannot parse repo scope: "${scope}". Expected "owner/repo" or a GitHub URL.`
+    );
+  }
+  return { owner: parts[0], repo: parts[1] };
+}
+function formatScope(scope) {
+  return `${scope.owner}/${scope.repo}`;
+}
+var init_scopes = __esm({
+  "src/radiant/core/scopes.ts"() {
+    "use strict";
+  }
+});
+
+// src/radiant/adapters/github.ts
+async function fetchGitHubActivity(scope, token, options = {}) {
+  const windowDays = options.windowDays ?? 14;
+  const perPage = options.perPage ?? 100;
+  const since = new Date(
+    Date.now() - windowDays * 24 * 60 * 60 * 1e3
+  ).toISOString();
+  const base = `https://api.github.com/repos/${formatScope(scope)}`;
+  const headers = {
+    Authorization: `token ${token}`,
+    Accept: "application/vnd.github.v3+json",
+    "User-Agent": "neuroverseos-radiant"
+  };
+  const events = [];
+  const [commits, prs, comments] = await Promise.all([
+    fetchJSON(
+      `${base}/commits?since=${since}&per_page=${perPage}`,
+      headers
+    ),
+    fetchJSON(
+      `${base}/pulls?state=all&sort=updated&direction=desc&per_page=${perPage}`,
+      headers
+    ),
+    fetchJSON(
+      `${base}/issues/comments?since=${since}&per_page=${perPage}&sort=updated&direction=desc`,
+      headers
+    )
+  ]);
+  for (const c of commits) {
+    events.push(mapCommit(c, scope));
+  }
+  const sinceDate = new Date(since);
+  for (const pr of prs) {
+    if (new Date(pr.updated_at) >= sinceDate) {
+      events.push(mapPR(pr, scope));
+    }
+  }
+  for (const comment of comments) {
+    events.push(mapComment(comment, scope));
+  }
+  events.sort(
+    (a, b) => Date.parse(a.timestamp) - Date.parse(b.timestamp)
+  );
+  return events;
+}
+function mapCommit(c, scope) {
+  const actor = mapUser(c.author, c.commit.author.name);
+  const coActors = extractCoAuthors(c.commit.message);
+  return {
+    id: `commit-${c.sha.slice(0, 8)}`,
+    timestamp: c.commit.author.date,
+    actor,
+    coActors: coActors.length > 0 ? coActors : void 0,
+    kind: "commit",
+    content: c.commit.message,
+    metadata: {
+      scope: formatScope(scope),
+      sha: c.sha
+    }
+  };
+}
+function mapPR(pr, scope) {
+  const event = {
+    id: `pr-${pr.number}`,
+    timestamp: pr.created_at,
+    actor: mapUser(pr.user),
+    kind: pr.merged_at ? "pr_merged" : pr.state === "open" ? "pr_opened" : "pr_closed",
+    content: `${pr.title}
+
+${pr.body ?? ""}`.trim(),
+    metadata: {
+      scope: formatScope(scope),
+      pr_number: pr.number,
+      state: pr.state,
+      merged_at: pr.merged_at
+    }
+  };
+  if (pr.merged_by && pr.merged_by.login !== pr.user.login) {
+    event.actor = mapUser(pr.merged_by);
+    event.kind = "pr_merged";
+    event.timestamp = pr.merged_at ?? pr.updated_at;
+    event.respondsTo = {
+      eventId: `pr-${pr.number}-opened`,
+      actor: mapUser(pr.user)
+    };
+  }
+  return event;
+}
+function mapComment(comment, scope) {
+  const issueMatch = comment.issue_url.match(/\/issues\/(\d+)$/);
+  const issueNumber = issueMatch ? issueMatch[1] : "unknown";
+  const event = {
+    id: `comment-${comment.id}`,
+    timestamp: comment.created_at,
+    actor: mapUser(comment.user),
+    kind: "comment",
+    content: comment.body,
+    respondsTo: {
+      eventId: `pr-${issueNumber}`,
+      actor: { id: "unknown", kind: "unknown" }
+    },
+    metadata: {
+      scope: formatScope(scope),
+      issue_number: issueNumber
+    }
+  };
+  return event;
+}
+function mapUser(ghUser, fallbackName) {
+  if (!ghUser) {
+    return {
+      id: fallbackName ?? "unknown",
+      kind: "unknown",
+      name: fallbackName
+    };
+  }
+  let kind = "human";
+  if (ghUser.type === "Bot" || ghUser.login.endsWith("[bot]")) {
+    kind = "bot";
+  }
+  if (KNOWN_AI_LOGINS.has(ghUser.login.toLowerCase())) {
+    kind = "bot";
+  }
+  return {
+    id: ghUser.login,
+    kind,
+    name: ghUser.login
+  };
+}
+function extractCoAuthors(message) {
+  const coAuthors = [];
+  const lines = message.split("\n");
+  for (const line of lines) {
+    const match = line.match(
+      /^Co-authored-by:\s*(.+?)\s*<([^>]*)>/i
+    );
+    if (match) {
+      const name = match[1].trim().toLowerCase();
+      const isAI = KNOWN_AI_CO_AUTHOR_NAMES.has(name) || [...KNOWN_AI_CO_AUTHOR_NAMES].some((ai) => name.includes(ai));
+      coAuthors.push({
+        id: match[2] || name,
+        kind: isAI ? "ai" : "human",
+        name: match[1].trim()
+      });
+    }
+  }
+  return coAuthors;
+}
+async function fetchJSON(url, headers) {
+  const res = await fetch(url, { headers });
+  if (!res.ok) {
+    if (res.status === 404) return [];
+    if (res.status === 403) {
+      const body = await res.text();
+      if (body.includes("rate limit")) {
+        throw new Error(
+          `GitHub API rate limit exceeded. Wait or use a token with higher limits.`
+        );
+      }
+    }
+    throw new Error(
+      `GitHub API error ${res.status} for ${url}: ${(await res.text()).slice(0, 300)}`
+    );
+  }
+  return await res.json();
+}
+var KNOWN_AI_LOGINS, KNOWN_AI_CO_AUTHOR_NAMES;
+var init_github2 = __esm({
+  "src/radiant/adapters/github.ts"() {
+    "use strict";
+    init_scopes();
+    KNOWN_AI_LOGINS = /* @__PURE__ */ new Set([
+      "github-actions[bot]",
+      "dependabot[bot]",
+      "renovate[bot]",
+      "copilot"
+    ]);
+    KNOWN_AI_CO_AUTHOR_NAMES = /* @__PURE__ */ new Set([
+      "claude",
+      "copilot",
+      "cursor",
+      "codeium",
+      "tabnine",
+      "codex"
+    ]);
+  }
+});
+
+// src/radiant/adapters/exocortex.ts
+function readExocortex(dirPath) {
+  const dir = (0, import_path13.resolve)(dirPath);
+  let filesLoaded = 0;
+  function tryRead(...paths) {
+    for (const p of paths) {
+      const full = (0, import_path13.join)(dir, p);
+      if ((0, import_fs12.existsSync)(full)) {
+        try {
+          const content = (0, import_fs12.readFileSync)(full, "utf-8").trim();
+          if (content) {
+            filesLoaded++;
+            return content;
+          }
+        } catch {
+        }
+      }
+    }
+    return null;
+  }
+  const ctx = {
+    attention: tryRead("attention.md"),
+    goals: tryRead("goals.md"),
+    identity: tryRead("identity.md"),
+    sprint: tryRead("sprint.md", "src/sprint.md"),
+    organization: tryRead("org/organization.md", "org/src/organization.md"),
+    methods: tryRead("org/methods.md", "org/src/methods.md"),
+    source: dir,
+    filesLoaded
+  };
+  return ctx;
+}
+function formatExocortexForPrompt(ctx) {
+  if (ctx.filesLoaded === 0) return "";
+  const sections = [];
+  sections.push(
+    "## Stated Intent (from exocortex)\n\nThe following is what the person/team SAYS they are doing, focused on, and working toward. Compare this against the ACTUAL activity from GitHub. Where stated intent and observed behavior diverge, that gap is the most valuable signal in this read. Name it directly."
+  );
+  if (ctx.attention) {
+    sections.push(`### Current attention
+
+${ctx.attention}`);
+  }
+  if (ctx.goals) {
+    sections.push(`### Goals
+
+${ctx.goals}`);
+  }
+  if (ctx.sprint) {
+    sections.push(`### Sprint focus
+
+${ctx.sprint}`);
+  }
+  if (ctx.identity) {
+    sections.push(`### Identity and values
+
+${ctx.identity}`);
+  }
+  if (ctx.organization) {
+    sections.push(`### Organization
+
+${ctx.organization}`);
+  }
+  if (ctx.methods) {
+    sections.push(`### Methods
+
+${ctx.methods}`);
+  }
+  return sections.join("\n\n");
+}
+function summarizeExocortex(ctx) {
+  if (ctx.filesLoaded === 0) return "no exocortex files found";
+  const loaded = [];
+  if (ctx.attention) loaded.push("attention");
+  if (ctx.goals) loaded.push("goals");
+  if (ctx.sprint) loaded.push("sprint");
+  if (ctx.identity) loaded.push("identity");
+  if (ctx.organization) loaded.push("org");
+  if (ctx.methods) loaded.push("methods");
+  return `${loaded.join(", ")} (${ctx.filesLoaded} files)`;
+}
+var import_fs12, import_path13;
+var init_exocortex = __esm({
+  "src/radiant/adapters/exocortex.ts"() {
+    "use strict";
+    import_fs12 = require("fs");
+    import_path13 = require("path");
+  }
+});
+
+// src/radiant/core/domain.ts
+function isLifeSide(k) {
+  return k === "human" || k === "unknown";
+}
+function isCyberSide(k) {
+  return k === "ai" || k === "bot";
+}
+function crossesBoundary(a, b) {
+  return isLifeSide(a) && isCyberSide(b) || isCyberSide(a) && isLifeSide(b);
+}
+function classifyActorDomain(event) {
+  const primaryKind = event.actor.kind;
+  const coKinds = (event.coActors ?? []).map((a) => a.kind);
+  const allKinds = [primaryKind, ...coKinds];
+  const hasLife = allKinds.some(isLifeSide);
+  const hasCyber = allKinds.some(isCyberSide);
+  if (hasLife && hasCyber) {
+    return "joint";
+  }
+  if (event.respondsTo && crossesBoundary(primaryKind, event.respondsTo.actor.kind)) {
+    return "joint";
+  }
+  return isCyberSide(primaryKind) ? "cyber" : "life";
+}
+var init_domain = __esm({
+  "src/radiant/core/domain.ts"() {
+    "use strict";
+  }
+});
+
+// src/radiant/core/signals.ts
+function classifyEvents(events) {
+  return events.map((event) => ({
+    event,
+    domain: classifyActorDomain(event)
+  }));
+}
+function extractSignals(events, extractors = DEFAULT_SIGNAL_EXTRACTORS) {
+  const domains = ["life", "cyber", "joint"];
+  const out = [];
+  for (const extractor of extractors) {
+    for (const domain of domains) {
+      const r = extractor.extract(events, domain);
+      out.push({
+        id: extractor.id,
+        domain,
+        score: r.score,
+        eventCount: r.eventCount,
+        confidence: r.confidence
+      });
+    }
+  }
+  return out;
+}
+function inDomain(events, domain) {
+  return events.filter((e) => e.domain === domain);
+}
+function confidenceFromCount(count) {
+  return Math.min(1, count / 10);
+}
+function clamp100(n) {
+  if (n < 0) return 0;
+  if (n > 100) return 100;
+  return n;
+}
+var ZERO, CLARITY_EXTRACTOR, OWNERSHIP_EXTRACTOR, FOLLOW_THROUGH_EXTRACTOR, ALIGNMENT_EXTRACTOR, DECISION_MOMENTUM_EXTRACTOR, DEFAULT_SIGNAL_EXTRACTORS;
+var init_signals = __esm({
+  "src/radiant/core/signals.ts"() {
+    "use strict";
+    init_domain();
+    ZERO = { score: 0, eventCount: 0, confidence: 0 };
+    CLARITY_EXTRACTOR = {
+      id: "clarity",
+      description: "Informativeness of event content \u2014 commit messages, PR bodies, review text",
+      extract(events, domain) {
+        const sub = inDomain(events, domain);
+        if (sub.length === 0) return ZERO;
+        const totalScore = sub.reduce((acc, e) => {
+          const len = (e.event.content ?? "").length;
+          const norm = Math.min(len, 200) / 200;
+          return acc + norm * 100;
+        }, 0);
+        return {
+          score: clamp100(totalScore / sub.length),
+          eventCount: sub.length,
+          confidence: confidenceFromCount(sub.length)
+        };
+      }
+    };
+    OWNERSHIP_EXTRACTOR = {
+      id: "ownership",
+      description: "Clarity of accountability \u2014 fraction of events with a known primary actor",
+      extract(events, domain) {
+        const sub = inDomain(events, domain);
+        if (sub.length === 0) return ZERO;
+        const attributed = sub.filter((e) => e.event.actor.kind !== "unknown").length;
+        return {
+          score: clamp100(attributed / sub.length * 100),
+          eventCount: sub.length,
+          confidence: confidenceFromCount(sub.length)
+        };
+      }
+    };
+    FOLLOW_THROUGH_EXTRACTOR = {
+      id: "follow_through",
+      description: "Fraction of events that were followed up \u2014 i.e. referenced by a later event",
+      extract(events, domain) {
+        const sub = inDomain(events, domain);
+        if (sub.length === 0) return ZERO;
+        const referencedIds = /* @__PURE__ */ new Set();
+        for (const e of events) {
+          const ref = e.event.respondsTo?.eventId;
+          if (ref) referencedIds.add(ref);
+        }
+        const followedUp = sub.filter((e) => referencedIds.has(e.event.id)).length;
+        return {
+          score: clamp100(followedUp / sub.length * 100),
+          eventCount: sub.length,
+          confidence: confidenceFromCount(sub.length)
+        };
+      }
+    };
+    ALIGNMENT_EXTRACTOR = {
+      id: "alignment",
+      description: "Coordination pressure \u2014 fraction of events that reference a prior event",
+      extract(events, domain) {
+        const sub = inDomain(events, domain);
+        if (sub.length === 0) return ZERO;
+        const referencing = sub.filter((e) => e.event.respondsTo !== void 0).length;
+        return {
+          score: clamp100(referencing / sub.length * 100),
+          eventCount: sub.length,
+          confidence: confidenceFromCount(sub.length)
+        };
+      }
+    };
+    DECISION_MOMENTUM_EXTRACTOR = {
+      id: "decision_momentum",
+      description: "Rate of activity in this domain \u2014 events per day, capped at 10/day",
+      extract(events, domain) {
+        const sub = inDomain(events, domain);
+        if (sub.length === 0) return ZERO;
+        if (sub.length < 2) {
+          return {
+            score: 20,
+            // token non-zero score — single event = some motion
+            eventCount: sub.length,
+            confidence: confidenceFromCount(sub.length)
+          };
+        }
+        const ts = sub.map((e) => Date.parse(e.event.timestamp)).sort((a, b) => a - b);
+        const spanMs = ts[ts.length - 1] - ts[0];
+        const spanDays = Math.max(spanMs / (24 * 60 * 60 * 1e3), 1 / 24);
+        const perDay = sub.length / spanDays;
+        const normalized = Math.min(perDay, 10) / 10;
+        return {
+          score: clamp100(normalized * 100),
+          eventCount: sub.length,
+          confidence: confidenceFromCount(sub.length)
+        };
+      }
+    };
+    DEFAULT_SIGNAL_EXTRACTORS = Object.freeze([
+      CLARITY_EXTRACTOR,
+      OWNERSHIP_EXTRACTOR,
+      FOLLOW_THROUGH_EXTRACTOR,
+      ALIGNMENT_EXTRACTOR,
+      DECISION_MOMENTUM_EXTRACTOR
+    ]);
+  }
+});
+
+// src/radiant/types.ts
+function isScored(s) {
+  return typeof s === "number";
+}
+var DEFAULT_EVIDENCE_GATE;
+var init_types = __esm({
+  "src/radiant/types.ts"() {
+    "use strict";
+    DEFAULT_EVIDENCE_GATE = { k: 3, c: 0.5 };
+  }
+});
+
+// src/radiant/core/math.ts
+function isPresent(o, gate = DEFAULT_EVIDENCE_GATE) {
+  return o.eventCount >= gate.k && o.confidence >= gate.c;
+}
+function presenceAverage(items, gate = DEFAULT_EVIDENCE_GATE) {
+  const present = items.filter((i) => isPresent(i, gate));
+  if (present.length === 0) return "INSUFFICIENT_EVIDENCE";
+  const sum = present.reduce((acc, i) => acc + i.score, 0);
+  return sum / present.length;
+}
+function scoreLife(capability, gate = DEFAULT_EVIDENCE_GATE) {
+  return presenceAverage(capability.dimensions, gate);
+}
+function scoreCyber(capability, gate = DEFAULT_EVIDENCE_GATE) {
+  return presenceAverage(capability.dimensions, gate);
+}
+function scoreNeuroVerse(components, worldmodelLoaded, gate = DEFAULT_EVIDENCE_GATE) {
+  if (!worldmodelLoaded) return "UNAVAILABLE";
+  return presenceAverage(components, gate);
+}
+function scoreComposite(a_L, a_C, a_N) {
+  const available = [];
+  if (isScored(a_L)) available.push(a_L);
+  if (isScored(a_C)) available.push(a_C);
+  if (isScored(a_N)) available.push(a_N);
+  if (available.length === 0) return "INSUFFICIENT_EVIDENCE";
+  return available.reduce((a, b) => a + b, 0) / available.length;
+}
+var init_math = __esm({
+  "src/radiant/core/math.ts"() {
+    "use strict";
+    init_types();
+  }
+});
+
+// src/radiant/core/patterns.ts
+async function interpretPatterns(input) {
+  const prompt = buildInterpretationPrompt(input);
+  const raw = await input.ai.complete(prompt, "Analyze the activity and produce the read.");
+  const parsed = parseInterpretation(raw, input.canonicalPatterns ?? []);
+  return {
+    patterns: parsed.patterns,
+    meaning: parsed.meaning,
+    move: parsed.move,
+    raw_ai_response: raw
+  };
+}
+function buildInterpretationPrompt(input) {
+  const signalSummary = formatSignalSummary(input.signals);
+  const eventSample = formatEventSample(input.events, 30);
+  const canonicalList = (input.canonicalPatterns ?? []).length > 0 ? `Patterns the organization has already named (use these names if you see them):
+${input.canonicalPatterns.map((p) => `- ${p}`).join("\n")}` : "No patterns have been named yet. Everything you observe is new.";
+  const frame = input.lens.primary_frame;
+  const evalQuestions = frame.evaluation_questions.map((q, i) => `${i + 1}. ${q}`).join("\n");
+  const forbiddenList = input.lens.forbidden_phrases.map((p) => `- "${p}"`).join("\n");
+  const jargonTable = Object.entries(input.lens.vocabulary.jargon_translations).map(([internal, plain]) => `  "${internal}" \u2192 "${plain}"`).join("\n");
+  return `You are a behavioral intelligence system reading team activity and producing a read for the reader who needs to act on it.
+
+## Context the reader has loaded
+
+${input.worldmodelContent}
+
+## What happened this window
+
+### Signal matrix (what Radiant measured)
+
+${signalSummary}
+
+### Recent events (sample)
+
+${eventSample}
+
+## How to reason
+
+Reason through these questions INTERNALLY \u2014 do not list them in your output:
+
+${evalQuestions}
+
+Scoring rubric: ${frame.scoring_rubric}
+
+${canonicalList}
+
+${input.statedIntent ? input.statedIntent + "\n" : ""}## Voice: speak like an Auki builder, not like a status report
+
+The reader wants to know **what this means and what to do**, not "what happened." Frame every observation as consequence + implication, not just description.
+
+Wrong voice (status report):
+  "Rapid deployment of complex technical architecture through composable commits."
+  "Signal extraction across life, cyber, and joint domains enables consistent behavioral analysis."
+  "Decision momentum scores suggest architectural delivery without corresponding strategic direction setting."
+
+Right voice (Auki builder):
+  "Shipping pace is high. The architecture is getting ahead of strategic decisions \u2014 velocity without a declared target."
+  "Every pattern is new. Nothing is being tracked by name yet. That's fine for now; it becomes a problem when patterns repeat and you still don't have vocabulary for them."
+  "The work is converging across three modules. The story of HOW they compose isn't being told yet."
+
+The difference: consequence in plain English, not observation in system vocabulary.
+
+## Translate internal jargon to plain English
+
+Readers don't know Radiant's vocabulary. Before ANY description appears in your output, translate these:
+
+${jargonTable}
+
+For example: don't say "update the worldmodel." Say "add a line to your strategy file."
+
+## 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:
+
+  "Nothing's broken. Keep shipping."
+  "This is what healthy looks like \u2014 the invariants are holding."
+  "Nothing here needs action."
+
+Only recommend a move when the evidence actually calls for one.
+
+## Output schema \u2014 JSON object
+
+\`\`\`json
+{
+  "patterns": [
+    {
+      "name": "pattern_name_snake_case",
+      "type": "canonical" | "candidate",
+      "description": "Consequence-framed, plain-English, 1-2 sentences. The reader understands why this matters, not just what you observed.",
+      "evidence": {
+        "signals": ["signal_id.domain", ...],
+        "events": ["event_id", ...],
+        "cited_invariant": "invariant_name_or_null"
+      },
+      "confidence": 0.0 to 1.0
+    }
+  ],
+  "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.'"
+}
+\`\`\`
+
+## Hard rules
+
+- Every signal you cite MUST appear in the signal matrix above
+- Every event you cite MUST appear in the events sample above
+- Do not invent signals or events that aren't in the data
+- Candidate patterns must have type "candidate"
+- No hedging, no hype vocabulary
+- Apply jargon translation before output
+- Health-is-valid \u2014 don't invent problems
+- Return ONLY the JSON object, no other text
+
+Do NOT use these phrases anywhere in your output:
+${forbiddenList}`;
+}
+function formatSignalSummary(signals) {
+  const lines = [];
+  const domains = ["life", "cyber", "joint"];
+  for (const domain of domains) {
+    const domainSignals = signals.filter((s) => s.domain === domain);
+    if (domainSignals.length === 0) continue;
+    lines.push(`### ${domain}`);
+    for (const s of domainSignals) {
+      const gate = s.eventCount >= 3 && s.confidence >= 0.5 ? "\u2713" : "\u25CB";
+      lines.push(
+        `  ${gate} ${s.id}: score=${s.score.toFixed(1)}, events=${s.eventCount}, conf=${s.confidence.toFixed(2)}`
+      );
+    }
+  }
+  return lines.join("\n");
+}
+function formatEventSample(events, maxEvents) {
+  const sample = events.slice(-maxEvents);
+  return sample.map((e) => {
+    const content = (e.event.content ?? "").slice(0, 200);
+    const respondsTo = e.event.respondsTo ? ` (responds to ${e.event.respondsTo.eventId})` : "";
+    return `- [${e.domain}] ${e.event.id} | ${e.event.actor.kind}:${e.event.actor.id} | ${e.event.kind ?? "event"}${respondsTo}
+  "${content}"`;
+  }).join("\n");
+}
+function parseInterpretation(raw, canonicalNames) {
+  let meaning = "";
+  let move = "";
+  let patternsArray = [];
+  const objMatch = raw.match(/\{[\s\S]*"patterns"[\s\S]*\}/);
+  if (objMatch) {
+    try {
+      const obj = JSON.parse(objMatch[0]);
+      if (Array.isArray(obj.patterns)) {
+        patternsArray = obj.patterns;
+      }
+      if (typeof obj.meaning === "string") meaning = obj.meaning;
+      if (typeof obj.move === "string") move = obj.move;
+    } catch {
+    }
+  }
+  if (patternsArray.length === 0) {
+    const arrMatch = raw.match(/\[[\s\S]*\]/);
+    if (arrMatch) {
+      try {
+        const arr = JSON.parse(arrMatch[0]);
+        if (Array.isArray(arr)) patternsArray = arr;
+      } catch {
+      }
+    }
+  }
+  const canonicalSet = new Set(canonicalNames.map((n) => n.toLowerCase()));
+  const patterns = [];
+  for (const item of patternsArray) {
+    if (!isPatternLike(item)) continue;
+    const nameStr = String(item.name ?? "unnamed");
+    const ev = item.evidence;
+    const isCanonical = item.type === "canonical" || canonicalSet.has(nameStr.toLowerCase());
+    patterns.push({
+      name: nameStr,
+      type: isCanonical ? "canonical" : "candidate",
+      declaredAs: isCanonical ? nameStr : void 0,
+      description: String(item.description ?? ""),
+      evidence: {
+        signals: Array.isArray(ev?.signals) ? ev.signals.map(String) : [],
+        events: Array.isArray(ev?.events) ? ev.events.map(String) : [],
+        cited_invariant: ev?.cited_invariant ? String(ev.cited_invariant) : void 0
+      },
+      confidence: typeof item.confidence === "number" ? Math.max(0, Math.min(1, item.confidence)) : 0.5
+    });
+  }
+  return { patterns, meaning, move };
+}
+function isPatternLike(x) {
+  return typeof x === "object" && x !== null && "name" in x;
+}
+var init_patterns = __esm({
+  "src/radiant/core/patterns.ts"() {
+    "use strict";
+  }
+});
+
+// src/radiant/core/renderer.ts
+function render(input) {
+  const text = renderText(input);
+  const frontmatter = renderFrontmatter(input);
+  return { text, frontmatter };
+}
+function renderText(input) {
+  const sections = [];
+  sections.push(
+    `Scope:  ${formatScope(input.scope)}
+Window: last ${input.windowDays} days \xB7 ${input.eventCount} events
+Lens:   ${input.lens.name}`
+  );
+  if (input.patterns.length > 0) {
+    const canonical = input.patterns.filter((p) => p.type === "canonical");
+    const candidates = input.patterns.filter((p) => p.type === "candidate");
+    let emergentBlock = "EMERGENT\n";
+    if (canonical.length > 0) {
+      for (const p of canonical) {
+        emergentBlock += `
+  ${p.name}
+`;
+        emergentBlock += `    ${p.description}
+`;
+      }
+    }
+    if (candidates.length > 0) {
+      emergentBlock += "\n  Emergent (candidates \u2014 not yet in worldmodel)\n";
+      for (const p of candidates) {
+        emergentBlock += `
+  ${p.name}  (candidate)
+`;
+        emergentBlock += `    ${p.description}
+`;
+        if (p.evidence.cited_invariant) {
+          emergentBlock += `    Cited invariant: ${p.evidence.cited_invariant}
+`;
+        }
+      }
+    }
+    sections.push(emergentBlock.trimEnd());
+  }
+  if (input.meaning) {
+    sections.push(`MEANING
+
+  ${input.meaning.split("\n").join("\n  ")}`);
+  }
+  if (input.move) {
+    sections.push(`MOVE
+
+  ${input.move.split("\n").join("\n  ")}`);
+  }
+  const alignBlock = [
+    "ALIGNMENT",
+    "",
+    `  Human work:                ${formatScore(input.scores.A_L)}`,
+    `  AI work:                   ${formatScore(input.scores.A_C)}`,
+    `  Human\u2013AI collaboration:    ${formatScore(input.scores.A_N)}`,
+    `  Composite:                 ${formatScore(input.scores.R)}`
+  ].join("\n");
+  sections.push(alignBlock);
+  sections.push(renderDepth(input.priorReadCount ?? 0, input.windowDays));
+  return sections.join("\n\n");
+}
+function renderDepth(priorReads, windowDays) {
+  if (priorReads === 0) {
+    return [
+      "DEPTH",
+      "",
+      `  This is your first read. Radiant sees ${windowDays} days of activity`,
+      "  but has no prior baseline to compare against.",
+      "",
+      "  Available now:",
+      "    \u2713 Signal extraction across life / cyber / joint domains",
+      "    \u2713 Pattern identification (canonical + candidates)",
+      "    \u2713 Alignment scoring",
+      "",
+      "  Available after 2+ reads:",
+      "    \xB7 Drift detection (is alignment improving or degrading?)",
+      '    \xB7 Baselines (what does "normal" look like for this team?)',
+      "    \xB7 Pattern confidence (are these patterns persistent or noise?)",
+      "    \xB7 Evolution proposals (should the worldmodel adapt?)",
+      "",
+      "  Run again next week. The read gets sharper every time."
+    ].join("\n");
+  }
+  if (priorReads < 4) {
+    return [
+      "DEPTH",
+      "",
+      `  Read ${priorReads + 1} of this scope. Baseline forming.`,
+      "",
+      "  Available now:",
+      "    \u2713 Signal extraction + pattern identification + alignment scoring",
+      `    \u2713 Drift detection (comparing against ${priorReads} prior read${priorReads > 1 ? "s" : ""})`,
+      "    \xB7 Baselines stabilizing (need 4+ reads for reliable averages)",
+      "    \xB7 Pattern confidence accumulating",
+      "",
+      "  The read sharpens with each run."
+    ].join("\n");
+  }
+  return [
+    "DEPTH",
+    "",
+    `  Read ${priorReads + 1} of this scope. Baseline established.`,
+    "",
+    "  Available:",
+    "    \u2713 Signal extraction + pattern identification + alignment scoring",
+    "    \u2713 Drift detection against established baseline",
+    "    \u2713 Pattern confidence (persistent vs noise)",
+    "    \u2713 Evolution proposals (candidate patterns with enough history to evaluate)"
+  ].join("\n");
+}
+function formatScore(s) {
+  if (!isScored(s)) {
+    if (s === "UNAVAILABLE") return "not available (no worldmodel loaded)";
+    return "not enough signal to call yet";
+  }
+  const n = Math.round(s);
+  let label;
+  if (n >= 75) label = "STRONG";
+  else if (n >= 60) label = "STABLE";
+  else if (n >= 45) label = "needs attention";
+  else if (n >= 30) label = "concerning";
+  else label = "critical";
+  return `${n} \xB7 ${label}`;
+}
+function renderFrontmatter(input) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const signalsByDomain = groupSignalsByDomain(input.signals);
+  const patternEntries = input.patterns.map((p) => {
+    const entry = {
+      name: p.name,
+      type: p.type,
+      conf: Number(p.confidence.toFixed(2)),
+      evidence_signals: p.evidence.signals,
+      evidence_events: p.evidence.events
+    };
+    if (p.evidence.cited_invariant) {
+      entry.cited_invariant = p.evidence.cited_invariant;
+    }
+    return entry;
+  });
+  const frontmatter = {
+    radiant_read: {
+      scope: formatScope(input.scope),
+      window: `${input.windowDays}d`,
+      timestamp: now,
+      lens: input.lens.name
+    },
+    events: {
+      total: input.eventCount
+    },
+    signals: signalsByDomain,
+    scores: {
+      A_L: isScored(input.scores.A_L) ? Math.round(input.scores.A_L) : String(input.scores.A_L),
+      A_C: isScored(input.scores.A_C) ? Math.round(input.scores.A_C) : String(input.scores.A_C),
+      A_N: isScored(input.scores.A_N) ? Math.round(input.scores.A_N) : String(input.scores.A_N),
+      R: isScored(input.scores.R) ? Math.round(input.scores.R) : String(input.scores.R)
+    },
+    patterns: patternEntries
+  };
+  return "---\n" + serializeYAML(frontmatter) + "---";
+}
+function groupSignalsByDomain(signals) {
+  const result = {};
+  for (const s of signals) {
+    if (!result[s.domain]) result[s.domain] = {};
+    result[s.domain][s.id] = {
+      score: Number(s.score.toFixed(1)),
+      n: s.eventCount,
+      conf: Number(s.confidence.toFixed(2))
+    };
+  }
+  return result;
+}
+function serializeYAML(obj, indent = 0) {
+  const pad = "  ".repeat(indent);
+  if (obj === null || obj === void 0) return "null\n";
+  if (typeof obj === "string") return `${JSON.stringify(obj)}
+`;
+  if (typeof obj === "number" || typeof obj === "boolean") return `${obj}
+`;
+  if (Array.isArray(obj)) {
+    if (obj.length === 0) return "[]\n";
+    if (obj.every((item) => typeof item === "string" || typeof item === "number")) {
+      return `[${obj.map((item) => JSON.stringify(item)).join(", ")}]
+`;
+    }
+    let result = "\n";
+    for (const item of obj) {
+      if (typeof item === "object" && item !== null && !Array.isArray(item)) {
+        const entries = Object.entries(item);
+        result += `${pad}- ${entries[0][0]}: ${serializeYAML(entries[0][1], 0).trim()}
+`;
+        for (let i = 1; i < entries.length; i++) {
+          result += `${pad}  ${entries[i][0]}: ${serializeYAML(entries[i][1], indent + 2).trim()}
+`;
+        }
+      } else {
+        result += `${pad}- ${serializeYAML(item, indent + 1).trim()}
+`;
+      }
+    }
+    return result;
+  }
+  if (typeof obj === "object") {
+    const entries = Object.entries(obj);
+    if (entries.length === 0) return "{}\n";
+    let result = "\n";
+    for (const [key, value] of entries) {
+      if (typeof value === "object" && value !== null) {
+        result += `${pad}${key}:${serializeYAML(value, indent + 1)}`;
+      } else {
+        result += `${pad}${key}: ${serializeYAML(value, indent).trim()}
+`;
+      }
+    }
+    return result;
+  }
+  return `${obj}
+`;
+}
+var init_renderer = __esm({
+  "src/radiant/core/renderer.ts"() {
+    "use strict";
+    init_types();
+    init_scopes();
+  }
+});
+
+// src/radiant/commands/emergent.ts
+async function emergent(input) {
+  const lens = resolveLens2(input.lensId);
+  const windowDays = input.windowDays ?? 14;
+  let statedIntent;
+  let exocortexContext;
+  if (input.exocortexPath) {
+    exocortexContext = readExocortex(input.exocortexPath);
+    const formatted = formatExocortexForPrompt(exocortexContext);
+    if (formatted) statedIntent = formatted;
+  }
+  const events = await fetchGitHubActivity(input.scope, input.githubToken, {
+    windowDays
+  });
+  const classified = classifyEvents(events);
+  const signals = extractSignals(classified);
+  const scores = computeScores(signals, input.worldmodelContent !== "");
+  const { patterns, meaning, move } = await interpretPatterns({
+    signals,
+    events: classified,
+    worldmodelContent: input.worldmodelContent,
+    lens,
+    ai: input.ai,
+    canonicalPatterns: input.canonicalPatterns,
+    statedIntent
+  });
+  const rewrittenPatterns = patterns.map((p) => lens.rewrite(p));
+  const allDescriptions = rewrittenPatterns.map((p) => p.description).join("\n");
+  const voiceViolations = checkForbiddenPhrases(lens, allDescriptions);
+  const rendered = render({
+    scope: input.scope,
+    windowDays,
+    eventCount: events.length,
+    signals,
+    patterns: rewrittenPatterns,
+    scores,
+    lens,
+    meaning: meaning || void 0,
+    move: move || void 0
+  });
+  return {
+    text: rendered.text,
+    frontmatter: rendered.frontmatter,
+    voiceViolations,
+    voiceClean: voiceViolations.length === 0,
+    signals,
+    scores,
+    eventCount: events.length
+  };
+}
+function computeScores(signals, worldmodelLoaded) {
+  const gate = DEFAULT_EVIDENCE_GATE;
+  const lifeSignals = signals.filter((s) => s.domain === "life");
+  const A_L = scoreLife(
+    { dimensions: lifeSignals.map(signalToDimension) },
+    gate
+  );
+  const cyberSignals = signals.filter((s) => s.domain === "cyber");
+  const A_C = scoreCyber(
+    { dimensions: cyberSignals.map(signalToDimension) },
+    gate
+  );
+  const jointSignals = signals.filter((s) => s.domain === "joint");
+  const A_N = scoreNeuroVerse(
+    jointSignals.map(signalToBridging),
+    worldmodelLoaded,
+    gate
+  );
+  const R = scoreComposite(A_L, A_C, A_N);
+  return { A_L, A_C, A_N, R };
+}
+function signalToDimension(s) {
+  return {
+    id: s.id,
+    score: s.score,
+    eventCount: s.eventCount,
+    confidence: s.confidence
+  };
+}
+function signalToBridging(s) {
+  return {
+    component: "ALIGN",
+    // Proxy: joint signals → ALIGN component
+    score: s.score,
+    eventCount: s.eventCount,
+    confidence: s.confidence
+  };
+}
+function resolveLens2(id) {
+  const lens = getLens2(id);
+  if (!lens) {
+    throw new Error(
+      `Lens "${id}" not found. Check the id or register the lens.`
+    );
+  }
+  return lens;
+}
+var init_emergent = __esm({
+  "src/radiant/commands/emergent.ts"() {
+    "use strict";
+    init_lenses();
+    init_github2();
+    init_exocortex();
+    init_signals();
+    init_math();
+    init_patterns();
+    init_renderer();
+    init_voice_check();
+    init_types();
+  }
+});
+
+// src/radiant/core/ai.ts
+function createAnthropicAI(apiKey, model = "claude-sonnet-4-20250514", maxTokens = 4096) {
+  return {
+    async complete(systemPrompt, userQuery) {
+      const res = await fetch("https://api.anthropic.com/v1/messages", {
+        method: "POST",
+        headers: {
+          "x-api-key": apiKey,
+          "anthropic-version": "2023-06-01",
+          "content-type": "application/json"
+        },
+        body: JSON.stringify({
+          model,
+          max_tokens: maxTokens,
+          system: systemPrompt,
+          messages: [{ role: "user", content: userQuery }]
+        })
+      });
+      if (!res.ok) {
+        const body = await res.text();
+        throw new Error(
+          `Anthropic API error ${res.status}: ${body.slice(0, 500)}`
+        );
+      }
+      const data = await res.json();
+      const text = data.content?.filter((c) => c.type === "text").map((c) => c.text ?? "").join("");
+      if (!text) {
+        throw new Error("Anthropic returned no text content");
+      }
+      return text;
+    }
+  };
+}
+var init_ai = __esm({
+  "src/radiant/core/ai.ts"() {
+    "use strict";
+  }
+});
+
+// src/cli/radiant.ts
+var radiant_exports = {};
+__export(radiant_exports, {
+  main: () => main34
+});
+function parseArgs27(argv) {
+  const result = {
+    subcommand: void 0,
+    lens: void 0,
+    worlds: void 0,
+    query: void 0,
+    model: void 0,
+    exocortex: void 0,
+    json: false,
+    help: false,
+    rest: []
+  };
+  let i = 0;
+  if (argv.length > 0 && !argv[0].startsWith("-")) {
+    result.subcommand = argv[0];
+    i = 1;
+  }
+  while (i < argv.length) {
+    const arg = argv[i];
+    switch (arg) {
+      case "--lens":
+        result.lens = argv[++i];
+        break;
+      case "--worlds":
+        result.worlds = argv[++i];
+        break;
+      case "--query":
+        result.query = argv[++i];
+        break;
+      case "--model":
+        result.model = argv[++i];
+        break;
+      case "--exocortex":
+        result.exocortex = argv[++i];
+        break;
+      case "--json":
+        result.json = true;
+        break;
+      case "--help":
+      case "-h":
+        result.help = true;
+        break;
+      default:
+        result.rest.push(arg);
+        break;
+    }
+    i++;
+  }
+  return result;
+}
+function loadWorldmodelContent(worldsPath) {
+  const resolved = (0, import_path14.resolve)(worldsPath);
+  if (!(0, import_fs13.existsSync)(resolved)) {
+    throw new Error(`Worlds path not found: ${resolved}`);
+  }
+  const stat = (0, import_fs13.statSync)(resolved);
+  if (stat.isFile()) {
+    return (0, import_fs13.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"))
+    ).sort();
+    if (files.length === 0) {
+      throw new Error(
+        `No .worldmodel.md or .nv-world.md files found in ${resolved}`
+      );
+    }
+    return files.map((f) => {
+      const content = (0, import_fs13.readFileSync)((0, import_path14.join)(resolved, f), "utf-8");
+      return `<!-- worldmodel: ${f} -->
+${content}`;
+    }).join("\n\n---\n\n");
+  }
+  throw new Error(`Worlds path is neither a file nor a directory: ${resolved}`);
+}
+async function cmdThink(args) {
+  const lensId = args.lens ?? process.env.RADIANT_LENS;
+  if (!lensId) {
+    process.stderr.write(
+      `${RED2}Error:${RESET3} --lens <id> or RADIANT_LENS required.
+${DIM3}Available lenses: ${listLenses().join(", ")}${RESET3}
+`
+    );
+    process.exit(1);
+  }
+  const worldsPath = args.worlds ?? process.env.RADIANT_WORLDS;
+  if (!worldsPath) {
+    process.stderr.write(
+      `${RED2}Error:${RESET3} --worlds <dir> or RADIANT_WORLDS required.
+`
+    );
+    process.exit(1);
+  }
+  const apiKey = process.env.ANTHROPIC_API_KEY;
+  if (!apiKey) {
+    process.stderr.write(
+      `${RED2}Error:${RESET3} ANTHROPIC_API_KEY environment variable not set.
+${DIM3}Set it to your Anthropic API key to use Radiant's AI features.${RESET3}
+`
+    );
+    process.exit(1);
+  }
+  let query = args.query;
+  if (!query && args.rest.length > 0) {
+    query = args.rest.join(" ");
+  }
+  if (!query && !process.stdin.isTTY) {
+    query = (0, import_fs13.readFileSync)(0, "utf-8").trim();
+  }
+  if (!query) {
+    process.stderr.write(
+      `${RED2}Error:${RESET3} No query provided.
+${DIM3}Use --query "...", pass as trailing args, or pipe via stdin.${RESET3}
+`
+    );
+    process.exit(1);
+  }
+  const worldmodelContent = loadWorldmodelContent(worldsPath);
+  const model = args.model ?? process.env.RADIANT_MODEL;
+  const ai = createAnthropicAI(apiKey, model || void 0);
+  process.stderr.write(
+    `${DIM3}Worlds: ${worldsPath}${RESET3}
+${DIM3}Lens:   ${lensId}${RESET3}
+${DIM3}Model:  ${model ?? "claude-sonnet-4-20250514 (default)"}${RESET3}
+
+`
+  );
+  const result = await think({
+    worldmodelContent,
+    lensId,
+    query,
+    ai
+  });
+  if (!result.voiceClean) {
+    process.stderr.write(
+      `${YELLOW3}Voice violations detected (${result.voiceViolations.length}):${RESET3}
+`
+    );
+    for (const v of result.voiceViolations) {
+      process.stderr.write(
+        `  ${YELLOW3}\u26A0${RESET3}  "${v.phrase}" at offset ${v.offset}
+`
+      );
+    }
+    process.stderr.write("\n");
+  }
+  if (args.json) {
+    process.stdout.write(
+      JSON.stringify(
+        {
+          response: result.response,
+          lens: result.lens,
+          voiceClean: result.voiceClean,
+          voiceViolations: result.voiceViolations
+        },
+        null,
+        2
+      ) + "\n"
+    );
+  } else {
+    process.stdout.write(result.response + "\n");
+  }
+  if (!result.voiceClean) {
+    process.exit(2);
+  }
+}
+async function cmdEmergent(args) {
+  const scopeStr = args.rest[0];
+  if (!scopeStr) {
+    process.stderr.write(
+      `${RED2}Error:${RESET3} Scope required. Usage: neuroverse radiant emergent <owner/repo>
+`
+    );
+    process.exit(1);
+  }
+  const scope = parseRepoScope(scopeStr);
+  const lensId = args.lens ?? process.env.RADIANT_LENS;
+  if (!lensId) {
+    process.stderr.write(
+      `${RED2}Error:${RESET3} --lens <id> or RADIANT_LENS required.
+${DIM3}Available lenses: ${listLenses().join(", ")}${RESET3}
+`
+    );
+    process.exit(1);
+  }
+  const worldsPath = args.worlds ?? process.env.RADIANT_WORLDS;
+  if (!worldsPath) {
+    process.stderr.write(
+      `${RED2}Error:${RESET3} --worlds <dir> or RADIANT_WORLDS required.
+`
+    );
+    process.exit(1);
+  }
+  const anthropicKey = process.env.ANTHROPIC_API_KEY;
+  if (!anthropicKey) {
+    process.stderr.write(
+      `${RED2}Error:${RESET3} ANTHROPIC_API_KEY environment variable not set.
+`
+    );
+    process.exit(1);
+  }
+  const githubToken = process.env.GITHUB_TOKEN;
+  if (!githubToken) {
+    process.stderr.write(
+      `${RED2}Error:${RESET3} GITHUB_TOKEN environment variable not set.
+${DIM3}Set it to a GitHub PAT with repo read access.${RESET3}
+`
+    );
+    process.exit(1);
+  }
+  const worldmodelContent = loadWorldmodelContent(worldsPath);
+  const model = args.model ?? process.env.RADIANT_MODEL;
+  const ai = createAnthropicAI(anthropicKey, model || void 0);
+  const exocortexPath = args.exocortex ?? process.env.RADIANT_EXOCORTEX;
+  let exocortexStatus = "not loaded";
+  if (exocortexPath) {
+    const ctx = readExocortex(exocortexPath);
+    exocortexStatus = summarizeExocortex(ctx);
+  }
+  process.stderr.write(
+    `${DIM3}Scope:      ${scope.owner}/${scope.repo}${RESET3}
+${DIM3}Lens:       ${lensId}${RESET3}
+${DIM3}Model:      ${model ?? "claude-sonnet-4-20250514 (default)"}${RESET3}
+${DIM3}ExoCortex:  ${exocortexStatus}${RESET3}
+${DIM3}Fetching activity...${RESET3}
+
+`
+  );
+  const result = await emergent({
+    scope,
+    githubToken,
+    worldmodelContent,
+    lensId,
+    ai,
+    windowDays: 14,
+    exocortexPath: exocortexPath || void 0
+  });
+  if (!result.voiceClean) {
+    process.stderr.write(
+      `${YELLOW3}Voice violations (${result.voiceViolations.length}):${RESET3}
+`
+    );
+    for (const v of result.voiceViolations) {
+      process.stderr.write(
+        `  ${YELLOW3}\u26A0${RESET3}  "${v.phrase}" at offset ${v.offset}
+`
+      );
+    }
+    process.stderr.write("\n");
+  }
+  if (args.json) {
+    process.stdout.write(
+      JSON.stringify(
+        {
+          text: result.text,
+          frontmatter: result.frontmatter,
+          scores: result.scores,
+          eventCount: result.eventCount,
+          voiceClean: result.voiceClean
+        },
+        null,
+        2
+      ) + "\n"
+    );
+  } else {
+    process.stdout.write(result.text + "\n");
+  }
+}
+async function cmdLenses(args) {
+  const subSub = args.rest[0];
+  if (!subSub || subSub === "list") {
+    const ids = listLenses();
+    if (ids.length === 0) {
+      process.stdout.write("No lenses registered.\n");
+    } else {
+      for (const id of ids) {
+        process.stdout.write(`${id}
+`);
+      }
+    }
+    return;
+  }
+  if (subSub === "describe") {
+    const { getLens: getLens3 } = await Promise.resolve().then(() => (init_lenses(), lenses_exports));
+    const id = args.rest[1];
+    if (!id) {
+      process.stderr.write(`${RED2}Error:${RESET3} Lens id required.
+`);
+      process.exit(1);
+    }
+    const lens = getLens3(id);
+    if (!lens) {
+      process.stderr.write(
+        `${RED2}Error:${RESET3} Lens "${id}" not found.
+${DIM3}Available: ${listLenses().join(", ")}${RESET3}
+`
+      );
+      process.exit(1);
+    }
+    process.stdout.write(`${BOLD3}${lens.name}${RESET3}
+`);
+    process.stdout.write(`${lens.description}
+
+`);
+    process.stdout.write(
+      `${BOLD3}Domains:${RESET3} ${lens.primary_frame.domains.join(", ")}
+`
+    );
+    process.stdout.write(
+      `${BOLD3}Overlaps:${RESET3} ${lens.primary_frame.overlaps.map((o) => o.emergent_state).join(", ")}
+`
+    );
+    process.stdout.write(
+      `${BOLD3}Center:${RESET3} ${lens.primary_frame.center_identity}
+`
+    );
+    process.stdout.write(
+      `${BOLD3}Forbidden phrases:${RESET3} ${lens.forbidden_phrases.length}
+`
+    );
+    process.stdout.write(
+      `${BOLD3}Vocabulary terms:${RESET3} ${lens.vocabulary.proper_nouns.length} proper nouns, ${Object.keys(lens.vocabulary.preferred).length} substitutions
+`
+    );
+    process.stdout.write(
+      `${BOLD3}Exemplars:${RESET3} ${lens.exemplar_refs.length}
+`
+    );
+    return;
+  }
+  process.stderr.write(
+    `${RED2}Error:${RESET3} Unknown lenses subcommand "${subSub}".
+${DIM3}Use: lenses list | lenses describe <id>${RESET3}
+`
+  );
+  process.exit(1);
+}
+async function main34(argv) {
+  const args = parseArgs27(argv);
+  if (args.help || !args.subcommand) {
+    process.stdout.write(USAGE10 + "\n");
+    return;
+  }
+  switch (args.subcommand) {
+    case "think":
+      return cmdThink(args);
+    case "lenses":
+      return cmdLenses(args);
+    case "emergent":
+      return cmdEmergent(args);
+    case "decision":
+    case "signals":
+    case "drift":
+    case "evolve":
+      process.stderr.write(
+        `${DIM3}neuroverse radiant ${args.subcommand} is not yet implemented.${RESET3}
+`
+      );
+      process.exit(1);
+      break;
+    default:
+      process.stderr.write(
+        `${RED2}Unknown radiant subcommand: "${args.subcommand}"${RESET3}
+
+`
+      );
+      process.stdout.write(USAGE10 + "\n");
+      process.exit(1);
+  }
+}
+var import_fs13, import_path14, RED2, DIM3, BOLD3, YELLOW3, RESET3, USAGE10;
+var init_radiant = __esm({
+  "src/cli/radiant.ts"() {
+    "use strict";
+    import_fs13 = require("fs");
+    import_path14 = require("path");
+    init_think();
+    init_emergent();
+    init_ai();
+    init_scopes();
+    init_exocortex();
+    init_lenses();
+    RED2 = "\x1B[31m";
+    DIM3 = "\x1B[2m";
+    BOLD3 = "\x1B[1m";
+    YELLOW3 = "\x1B[33m";
+    RESET3 = "\x1B[0m";
+    USAGE10 = `
+${BOLD3}neuroverse radiant${RESET3} \u2014 behavioral intelligence for collaboration systems
+
+${BOLD3}Stage A (voice layer):${RESET3}
+  think          Send a query through the worldmodel + lens \u2192 AI-framed response
+
+${BOLD3}Stage B (behavioral analysis, coming soon):${RESET3}
+  emergent       Pattern read on recent activity
+  decision       Evaluate a specific artifact against the worldmodel
+  signals        Extract signal matrix (debug)
+  lenses         List or describe available rendering lenses
+
+${BOLD3}Usage:${RESET3}
+  neuroverse radiant think --lens auki-builder --worlds ./worlds/ --query "What is our biggest risk?"
+  neuroverse radiant think --lens auki-builder --worlds ./worlds/ < prompt.txt
+  neuroverse radiant emergent aukiverse/posemesh --lens auki-builder --worlds ./worlds/
+  neuroverse radiant emergent aukiverse/posemesh --lens auki-builder --worlds ./worlds/ --exocortex ~/exocortex/
+  neuroverse radiant lenses list
+  neuroverse radiant lenses describe auki-builder
+
+${BOLD3}Environment:${RESET3}
+  ANTHROPIC_API_KEY    Required for AI commands (think, emergent, decision)
+  RADIANT_WORLDS       Default worlds directory (overridden by --worlds)
+  RADIANT_LENS         Default lens id (overridden by --lens)
+  RADIANT_MODEL        AI model override (default: claude-sonnet-4-20250514)
+  RADIANT_EXOCORTEX    Default exocortex directory (overridden by --exocortex)
+`.trim();
+  }
+});
+
 // src/cli/neuroverse.ts
-var USAGE10 = `
-neuroverse \u2014 Turn ideas into worlds.
+var USAGE11 = `
+neuroverse \u2014 Behavioral governance for AI systems.
 
-Commands:
+Behavioral modeling:
+  worldmodel     Build behavioral models (init, validate, build, explain, infer)
+  radiant        Behavioral intelligence for collaboration (think, emergent, lenses)
+  lens           Manage behavioral lenses (list, preview, compile, compare, add)
+
+Runtime governance:
+  guard          Evaluate events against a world (stdin \u2192 stdout)
+  plan           Plan enforcement (compile, check, status, advance, derive)
+  run            Governed runtime (pipe mode or interactive chat)
+  mcp            MCP governance server (for Claude, Cursor, etc.)
+
+World management:
+  world          Manage worlds (status, diff, snapshot, rollback, list)
   add            Add a guard, rule, or invariant to a world
-  build          Build a world from markdown (derive + compile in one step)
-  explain        Human-readable summary of a compiled world
-  simulate       Step-by-step state evolution
-  improve        Actionable suggestions for strengthening a world
-  init           Scaffold a new .nv-world.md template
-  init-world     Generate a governed world from a template (e.g., autoresearch)
-  infer-world    Scan a repo and infer a governance world from its structure
+  build          Build a world from markdown (derive + compile)
   validate       Static analysis on world files
-  guard          Runtime governance evaluation (stdin \u2192 stdout)
+  explain        Human-readable summary of a compiled world
+
+Testing:
   test           Run guard simulation suite against a world
   redteam        Adversarial containment testing (agent escape detection)
-  demo           Interactive governance demo (flow viz + simulation)
   doctor         Environment sanity check
-  playground     Interactive web demo (opens in browser)
-  plan           Plan enforcement (compile, check, status, advance, derive)
-  run            Governed runtime (pipe mode or interactive chat)
-  mcp            MCP governance server (for Claude, Cursor, etc.)
-  worlds         List available worlds (alias for world list)
-  trace          Runtime action audit log
-  impact         Counterfactual governance impact report
-  decision-flow  Intent \u2192 Rule \u2192 Outcome visualization (behavioral governance)
-  equity-penalties  Fortune 500 equity PENALIZE/REWARD simulation
-  world          World management (status, diff, snapshot, rollback)
+
+Administration:
   keygen         Generate Ed25519 signing keypair
-  sign           Sign a world artifact (cryptographic manifest)
+  sign           Sign a world artifact
   verify         Verify a signed world artifact
   migrate        Migrate world schema between versions
-  derive         AI-assisted synthesis of .nv-world.md from markdown
-  bootstrap      Compile .nv-world.md \u2192 world JSON files
   configure-ai   Configure AI provider credentials
-  configure-world  Interactive wizard: define your system in plain language
-  lens           Manage behavioral lenses (list, preview, compile, compare, add)
-  worldmodel     Behavioral world model builder (init, validate, build, explain)
 
-Usage:
-  neuroverse add "Block dairy orders" --world <dir>
-  neuroverse add guard --world <dir> --label "Block dairy" --pattern "*dairy*"
-  neuroverse add rule --world <dir> --label "Cost overrun" --trigger "cost > 100" --effect "viability *= 0.5"
-  neuroverse add invariant --world <dir> --label "Budget must never exceed 1000"
-  neuroverse build <input.md> [--output <dir>]
-  neuroverse explain <world-path-or-id> [--json]
-  neuroverse simulate <world-path-or-id> [--steps N] [--set key=value] [--profile name]
-  neuroverse improve <world-path-or-id> [--json]
-  neuroverse init [--name "World Name"] [--output path]
-  neuroverse init-world autoresearch [--context "topic"] [--dataset "name"] [--goal "goal"]
-  neuroverse infer-world ./repo [--output path] [--json] [--dry-run]
-  neuroverse validate --world <dir> [--format full|summary|findings]
-  neuroverse guard --world <dir> [--trace] [--level basic|standard|strict]
-  neuroverse test --world <dir> [--fuzz] [--count N]
-  neuroverse redteam --world <dir> [--level basic|standard|strict]
-  neuroverse demo [--world social-media] [--port 3456] [--no-browser]
-  neuroverse doctor [--world <dir>] [--json]
-  neuroverse playground --world <dir> [--port 4242]
-  neuroverse trace [--log <path>] [--summary] [--filter BLOCK] [--last 20]
-  neuroverse impact [--log <path>] [--json]
-  neuroverse world status <path>
-  neuroverse world diff <path1> <path2>
-  neuroverse world snapshot <path>
-  neuroverse world rollback <path>
-  neuroverse derive --input <path> [--output <path>] [--dry-run]
-  neuroverse bootstrap --input <.md> --output <dir> [--validate]
-  neuroverse decision-flow [--log <path>] [--json]
-  neuroverse equity-penalties --world <dir> [--agents N] [--rounds N] [--json]
-  neuroverse configure-ai --provider <name> --model <name> --api-key <key>
-  neuroverse configure-world [--output <dir>]
-  neuroverse keygen [--output <dir>] [--name <name>]
-  neuroverse sign --world <dir> [--key <path>]
-  neuroverse verify --world <dir> [--key <path>]
-  neuroverse migrate --world <dir> [--dry-run] [--backup]
-  neuroverse lens list [--world <dir>] [--json]
-  neuroverse lens preview <id> [--world <dir>]
-  neuroverse lens compile <id,...> [--world <dir>] [--role <role>] [--json]
-  neuroverse lens compare --input "text" --lenses stoic,coach,calm
-  neuroverse lens add --world <dir> --name "Name" --tagline "..." [options]
-  neuroverse worldmodel init --name "My Model"
-  neuroverse worldmodel build ./model.worldmodel.md --output ./world/
-  neuroverse worldmodel explain ./model.worldmodel.md
+Quick start:
+  neuroverse worldmodel init --name "My Model"        Create a behavioral model
+  neuroverse worldmodel build ./model.worldmodel.md   Compile it
+  neuroverse radiant think --lens auki-builder \\
+    --worlds ./worlds/ --query "..."                  Ask through the model
+  neuroverse radiant emergent owner/repo \\
+    --lens auki-builder --worlds ./worlds/             Behavioral read on a repo
 
-Examples:
-  neuroverse build horror-notes.md
-  neuroverse explain inherited_silence
-  neuroverse simulate inherited_silence --steps 5
-  neuroverse improve inherited_silence
-  neuroverse build ./docs/ --output ./my-world/
-  neuroverse init --name "Customer Service Governance"
-  neuroverse validate --world ./world/ --format summary
-  echo '{"intent":"delete user data"}' | neuroverse guard --world ./world/ --trace
+Governance:
+  echo '{"intent":"..."}' | neuroverse guard --world ./world/
   neuroverse plan compile plan.md --output plan.json
-  echo '{"intent":"write blog"}' | neuroverse plan check --plan plan.json
-  neuroverse plan status --plan plan.json
-  neuroverse plan advance write_blog_post --plan plan.json
-  neuroverse plan derive plan.md --output ./derived-world/
   neuroverse run --pipe --world ./world/ --plan plan.json
-  neuroverse run --interactive --world ./world/ --provider openai
   neuroverse mcp --world ./world/ --plan plan.json
   neuroverse test --world ./world/ --fuzz --count 50
-  neuroverse redteam --world ./world/ --level strict
-  neuroverse doctor
-  neuroverse playground --world ./world/
 `.trim();
-async function main34() {
+async function main35() {
   const args = process.argv.slice(2);
   const command = args[0];
   const subArgs = args.slice(1);
@@ -19999,6 +22068,7 @@ async function main34() {
       return improveMain(subArgs);
     }
     case "init": {
+      process.stderr.write("\x1B[2mNote: `neuroverse init` scaffolds .nv-world.md files. For behavioral models, use `neuroverse worldmodel init` instead.\x1B[0m\n");
       const { main: initMain } = await Promise.resolve().then(() => (init_init(), init_exports));
       return initMain(subArgs);
     }
@@ -20011,6 +22081,7 @@ async function main34() {
       return inferWorldMain(subArgs);
     }
     case "bootstrap": {
+      process.stderr.write("\x1B[2mNote: `neuroverse bootstrap` compiles .nv-world.md files. For behavioral models, use `neuroverse worldmodel build` instead.\x1B[0m\n");
       const { main: bootstrapMain } = await Promise.resolve().then(() => (init_bootstrap(), bootstrap_exports));
       return bootstrapMain(subArgs);
     }
@@ -20075,6 +22146,7 @@ async function main34() {
       return worldMain(subArgs);
     }
     case "derive": {
+      process.stderr.write("\x1B[2mNote: `neuroverse derive` is included in `neuroverse build`. Consider using `neuroverse build` for the combined derive + compile step.\x1B[0m\n");
       const { main: deriveMain } = await Promise.resolve().then(() => (init_derive(), derive_exports));
       return deriveMain(subArgs);
     }
@@ -20107,6 +22179,7 @@ async function main34() {
       return configureAiMain(subArgs);
     }
     case "configure-world": {
+      process.stderr.write("\x1B[2mNote: For behavioral models, use `neuroverse worldmodel init` instead. `configure-world` is the interactive wizard for .nv-world.md files.\x1B[0m\n");
       const { main: configureWorldMain } = await Promise.resolve().then(() => (init_configure_world(), configure_world_exports));
       return configureWorldMain(subArgs);
     }
@@ -20118,11 +22191,15 @@ async function main34() {
       const { main: worldmodelMain } = await Promise.resolve().then(() => (init_worldmodel(), worldmodel_exports));
       return worldmodelMain(subArgs);
     }
+    case "radiant": {
+      const { main: radiantMain } = await Promise.resolve().then(() => (init_radiant(), radiant_exports));
+      return radiantMain(subArgs);
+    }
     case "--help":
     case "-h":
     case "help":
     case void 0: {
-      process.stdout.write(USAGE10 + "\n");
+      process.stdout.write(USAGE11 + "\n");
       process.exit(0);
       break;
     }
@@ -20130,12 +22207,12 @@ async function main34() {
       process.stderr.write(`Unknown command: "${command}"
 
 `);
-      process.stdout.write(USAGE10 + "\n");
+      process.stdout.write(USAGE11 + "\n");
       process.exit(1);
     }
   }
 }
-main34().catch((e) => {
+main35().catch((e) => {
   process.stderr.write(`Fatal: ${e}
 `);
   process.exit(3);