@neuroverseos/governance 0.5.1 → 0.6.0

package/dist/cli/neuroverse.cjs

@@ -2001,13 +2001,13 @@ __export(world_loader_exports, {
   loadWorldFromDirectory: () => loadWorldFromDirectory
 });
 async function loadWorldFromDirectory(dirPath) {
-  const { readFile: readFile3 } = await import("fs/promises");
-  const { join: join13 } = await import("path");
+  const { readFile: readFile4 } = await import("fs/promises");
+  const { join: join14 } = await import("path");
   const { readdirSync: readdirSync6 } = await import("fs");
   async function readJson(filename) {
-    const filePath = join13(dirPath, filename);
+    const filePath = join14(dirPath, filename);
     try {
-      const content = await readFile3(filePath, "utf-8");
+      const content = await readFile4(filePath, "utf-8");
       return JSON.parse(content);
     } catch (err) {
       if (err instanceof Error && "code" in err && err.code === "ENOENT") {
@@ -2035,11 +2035,11 @@ async function loadWorldFromDirectory(dirPath) {
   const metadataJson = await readJson("metadata.json");
   const rules = [];
   try {
-    const rulesDir = join13(dirPath, "rules");
+    const rulesDir = join14(dirPath, "rules");
     const ruleFiles = readdirSync6(rulesDir).filter((f) => f.endsWith(".json")).sort();
     for (const file of ruleFiles) {
       try {
-        const content = await readFile3(join13(rulesDir, file), "utf-8");
+        const content = await readFile4(join14(rulesDir, file), "utf-8");
         rules.push(JSON.parse(content));
       } catch (err) {
         process.stderr.write(
@@ -2092,27 +2092,27 @@ async function loadWorld(worldPath) {
   throw new Error(`Cannot load world from: ${worldPath} \u2014 expected a directory`);
 }
 async function loadBundledWorld(name = DEFAULT_BUNDLED_WORLD) {
-  const { readFile: readFile3 } = await import("fs/promises");
-  const { join: join13, dirname: dirname3 } = await import("path");
-  const { existsSync: existsSync9 } = await import("fs");
+  const { readFile: readFile4 } = await import("fs/promises");
+  const { join: join14, dirname: dirname4 } = await import("path");
+  const { existsSync: existsSync10 } = 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));
   const filename = `${name}.nv-world.md`;
   let packageRoot;
   try {
-    const thisFile = typeof __dirname !== "undefined" ? __dirname : dirname3(fileURLToPath3(import_meta.url));
-    packageRoot = join13(thisFile, "..", "..");
+    const thisFile = typeof __dirname !== "undefined" ? __dirname : dirname4(fileURLToPath3(import_meta.url));
+    packageRoot = join14(thisFile, "..", "..");
   } catch {
     packageRoot = process.cwd();
   }
   const candidates = [
-    join13(packageRoot, "dist", "worlds", filename),
-    join13(packageRoot, "src", "worlds", filename)
+    join14(packageRoot, "dist", "worlds", filename),
+    join14(packageRoot, "src", "worlds", filename)
   ];
   for (const candidate of candidates) {
-    if (existsSync9(candidate)) {
-      const markdown = await readFile3(candidate, "utf-8");
+    if (existsSync10(candidate)) {
+      const markdown = await readFile4(candidate, "utf-8");
       const parsed = parseWorldMarkdown2(markdown);
       if (!parsed.world) {
         throw new Error(`Failed to parse bundled world: ${candidate}`);
@@ -2140,12 +2140,12 @@ function slugify(text) {
   return text.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, "").slice(0, 60);
 }
 async function addGuard(worldDir, input) {
-  const { readFile: readFile3, writeFile: writeFile5 } = await import("fs/promises");
-  const { join: join13 } = await import("path");
-  const guardsPath = join13(worldDir, "guards.json");
+  const { readFile: readFile4, writeFile: writeFile6 } = await import("fs/promises");
+  const { join: join14 } = await import("path");
+  const guardsPath = join14(worldDir, "guards.json");
   let config;
   try {
-    const raw = await readFile3(guardsPath, "utf-8");
+    const raw = await readFile4(guardsPath, "utf-8");
     config = JSON.parse(raw);
   } catch {
     config = { guards: [], intent_vocabulary: {} };
@@ -2167,7 +2167,7 @@ async function addGuard(worldDir, input) {
     ...input.enforcement === "modify" && input.reason && { modify_to: input.reason }
   };
   config.guards.push(guard);
-  await writeFile5(guardsPath, JSON.stringify(config, null, 2) + "\n");
+  await writeFile6(guardsPath, JSON.stringify(config, null, 2) + "\n");
   const { loadWorldFromDirectory: loadWorldFromDirectory3 } = await Promise.resolve().then(() => (init_world_loader(), world_loader_exports));
   const world = await loadWorldFromDirectory3(worldDir);
   const report = validateWorld(world);
@@ -2181,11 +2181,11 @@ async function addGuard(worldDir, input) {
   };
 }
 async function addRule(worldDir, input) {
-  const { readFile: readFile3, writeFile: writeFile5, mkdir: mkdir2 } = await import("fs/promises");
-  const { join: join13 } = await import("path");
+  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 = join13(worldDir, "rules");
-  await mkdir2(rulesDir, { recursive: true });
+  const rulesDir = join14(worldDir, "rules");
+  await mkdir3(rulesDir, { recursive: true });
   let nextNum = 1;
   try {
     const existing = readdirSync6(rulesDir).filter((f) => f.match(/^rule-\d+\.json$/)).sort();
@@ -2214,8 +2214,8 @@ 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 = join13(rulesDir, `rule-${ruleNum}.json`);
-  await writeFile5(rulePath, JSON.stringify(rule, null, 2) + "\n");
+  const rulePath = join14(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);
   const report = validateWorld(world);
@@ -2229,12 +2229,12 @@ async function addRule(worldDir, input) {
   };
 }
 async function addInvariant(worldDir, input) {
-  const { readFile: readFile3, writeFile: writeFile5 } = await import("fs/promises");
-  const { join: join13 } = await import("path");
-  const invariantsPath = join13(worldDir, "invariants.json");
+  const { readFile: readFile4, writeFile: writeFile6 } = await import("fs/promises");
+  const { join: join14 } = await import("path");
+  const invariantsPath = join14(worldDir, "invariants.json");
   let config;
   try {
-    const raw = await readFile3(invariantsPath, "utf-8");
+    const raw = await readFile4(invariantsPath, "utf-8");
     config = JSON.parse(raw);
   } catch {
     config = { invariants: [] };
@@ -2250,7 +2250,7 @@ async function addInvariant(worldDir, input) {
     mutable: false
   };
   config.invariants.push(invariant);
-  await writeFile5(invariantsPath, JSON.stringify(config, null, 2) + "\n");
+  await writeFile6(invariantsPath, JSON.stringify(config, null, 2) + "\n");
   const { loadWorldFromDirectory: loadWorldFromDirectory3 } = await Promise.resolve().then(() => (init_world_loader(), world_loader_exports));
   const world = await loadWorldFromDirectory3(worldDir);
   const report = validateWorld(world);
@@ -2849,27 +2849,27 @@ ${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: basename3 } = await import("path");
+  const { join: pathJoin, extname: extname2, basename: basename4 } = await import("path");
   const stats = await stat(inputPath);
   if (stats.isFile()) {
     const content = await rf(inputPath, "utf-8");
-    return [{ filename: basename3(inputPath), content }];
+    return [{ filename: basename4(inputPath), content }];
   }
   if (stats.isDirectory()) {
     const sources = [];
-    await collectDir(inputPath, sources, rf, pathJoin, extname2, basename3);
+    await collectDir(inputPath, sources, rf, pathJoin, extname2, 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, basename3) {
+async function collectDir(dir, sources, rf, pathJoin, extname2, 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, basename3);
+      await collectDir(fullPath, sources, rf, pathJoin, extname2, basename4);
     } else if (entry.isFile() && extname2(entry.name).toLowerCase() === ".md") {
       const content = await rf(fullPath, "utf-8");
       sources.push({ filename: entry.name, content });
@@ -3527,22 +3527,22 @@ function parseArgs2(argv) {
   return { inputPath, outputDir, validate, dryRun, provider, model, endpoint };
 }
 async function writeWorldFiles(outputDir, world) {
-  const { writeFile: writeFile5, mkdir: mkdir2 } = await import("fs/promises");
-  const { join: join13 } = await import("path");
-  await mkdir2(outputDir, { recursive: true });
-  await writeFile5(join13(outputDir, "world.json"), JSON.stringify(world.world, null, 2));
-  await writeFile5(join13(outputDir, "invariants.json"), JSON.stringify({ invariants: world.invariants }, null, 2));
-  await writeFile5(join13(outputDir, "assumptions.json"), JSON.stringify(world.assumptions, null, 2));
-  await writeFile5(join13(outputDir, "state-schema.json"), JSON.stringify(world.stateSchema, null, 2));
-  await writeFile5(join13(outputDir, "gates.json"), JSON.stringify(world.gates, null, 2));
-  await writeFile5(join13(outputDir, "outcomes.json"), JSON.stringify(world.outcomes, null, 2));
-  await writeFile5(join13(outputDir, "metadata.json"), JSON.stringify(world.metadata, null, 2));
-  const rulesDir = join13(outputDir, "rules");
-  await mkdir2(rulesDir, { recursive: true });
+  const { writeFile: writeFile6, mkdir: mkdir3 } = await import("fs/promises");
+  const { join: join14 } = 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 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 writeFile5(join13(rulesDir, `rule-${ruleNum}.json`), JSON.stringify(sortedRules[i], null, 2));
+    await writeFile6(join14(rulesDir, `rule-${ruleNum}.json`), JSON.stringify(sortedRules[i], null, 2));
   }
 }
 function write(msg) {
@@ -3557,17 +3557,17 @@ function printInsight(finding2) {
 async function main2(argv = process.argv.slice(2)) {
   try {
     const args = parseArgs2(argv);
-    const { basename: basename3 } = await import("path");
+    const { basename: basename4 } = await import("path");
     write(`
 NeuroVerse World Builder
 `);
     write(`
-Analyzing: ${basename3(args.inputPath)}
+Analyzing: ${basename4(args.inputPath)}
 `);
     const derivedPath = args.outputDir ? `${args.outputDir}/source.nv-world.md` : ".neuroverse/build-output.nv-world.md";
-    const { mkdir: mkdir2 } = await import("fs/promises");
-    const { dirname: dirname3 } = await import("path");
-    await mkdir2(dirname3(derivedPath), { recursive: true });
+    const { mkdir: mkdir3 } = await import("fs/promises");
+    const { dirname: dirname4 } = await import("path");
+    await mkdir3(dirname4(derivedPath), { recursive: true });
     const { result, exitCode, dryRunOutput } = await deriveWorld({
       inputPath: args.inputPath,
       outputPath: derivedPath,
@@ -3585,8 +3585,8 @@ Analyzing: ${basename3(args.inputPath)}
       process.exit(DERIVE_EXIT_CODES.SUCCESS);
       return;
     }
-    const { readFile: readFile3 } = await import("fs/promises");
-    const derivedContent = await readFile3(derivedPath, "utf-8");
+    const { readFile: readFile4 } = await import("fs/promises");
+    const derivedContent = await readFile4(derivedPath, "utf-8");
     const parseResult = parseWorldMarkdown(derivedContent);
     const worldName = parseResult.world?.frontmatter?.name ?? "Derived World";
     const worldId = parseResult.world?.frontmatter?.world_id ?? "derived_world";
@@ -3673,9 +3673,9 @@ World source written to: ${derivedPath}
     try {
       const emitResult = emitWorldDefinition(parseResult.world);
       await writeWorldFiles(outputDir, emitResult.world);
-      const { join: join13 } = await import("path");
+      const { join: join14 } = await import("path");
       const { copyFile } = await import("fs/promises");
-      const sourceDest = join13(outputDir, "source.nv-world.md");
+      const sourceDest = join14(outputDir, "source.nv-world.md");
       if (derivedPath !== sourceDest) {
         await copyFile(derivedPath, sourceDest);
       }
@@ -4451,8 +4451,8 @@ async function main4(argv = process.argv.slice(2)) {
     const world = await loadWorld(resolvedPath);
     let events;
     if (args.eventsPath) {
-      const { readFile: readFile3 } = await import("fs/promises");
-      const raw = await readFile3(args.eventsPath, "utf-8");
+      const { readFile: readFile4 } = await import("fs/promises");
+      const raw = await readFile4(args.eventsPath, "utf-8");
       const parsed = JSON.parse(raw);
       events = Array.isArray(parsed) ? parsed : [parsed];
       process.stderr.write(`Loaded ${events.length} event(s) from ${args.eventsPath}
@@ -5008,9 +5008,9 @@ function parseArgs6(argv) {
 async function main6(argv = process.argv.slice(2)) {
   try {
     const args = parseArgs6(argv);
-    const { writeFile: writeFile5 } = await import("fs/promises");
-    const { existsSync: existsSync9 } = await import("fs");
-    if (existsSync9(args.outputPath)) {
+    const { writeFile: writeFile6 } = await import("fs/promises");
+    const { existsSync: existsSync10 } = await import("fs");
+    if (existsSync10(args.outputPath)) {
       process.stderr.write(`File already exists: ${args.outputPath}
 `);
       process.stderr.write("Use a different --output path or remove the existing file.\n");
@@ -5018,7 +5018,7 @@ async function main6(argv = process.argv.slice(2)) {
       return;
     }
     const template = generateTemplate(args.name);
-    await writeFile5(args.outputPath, template, "utf-8");
+    await writeFile6(args.outputPath, template, "utf-8");
     const result = {
       created: args.outputPath,
       worldName: args.name,
@@ -5867,32 +5867,32 @@ function parseArgs9(argv) {
   return { inputPath, outputPath, validate, format };
 }
 async function writeWorldFiles2(outputDir, world) {
-  const { writeFile: writeFile5, mkdir: mkdir2 } = await import("fs/promises");
-  const { join: join13 } = await import("path");
-  await mkdir2(outputDir, { recursive: true });
-  await writeFile5(join13(outputDir, "world.json"), JSON.stringify(world.world, null, 2));
-  await writeFile5(join13(outputDir, "invariants.json"), JSON.stringify({ invariants: world.invariants }, null, 2));
-  await writeFile5(join13(outputDir, "assumptions.json"), JSON.stringify(world.assumptions, null, 2));
-  await writeFile5(join13(outputDir, "state-schema.json"), JSON.stringify(world.stateSchema, null, 2));
-  const rulesDir = join13(outputDir, "rules");
-  await mkdir2(rulesDir, { recursive: true });
+  const { writeFile: writeFile6, mkdir: mkdir3 } = await import("fs/promises");
+  const { join: join14 } = 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 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 writeFile5(join13(rulesDir, `rule-${ruleNum}.json`), JSON.stringify(sortedRules[i], null, 2));
+    await writeFile6(join14(rulesDir, `rule-${ruleNum}.json`), JSON.stringify(sortedRules[i], null, 2));
   }
-  await writeFile5(join13(outputDir, "gates.json"), JSON.stringify(world.gates, null, 2));
-  await writeFile5(join13(outputDir, "outcomes.json"), JSON.stringify(world.outcomes, null, 2));
-  await writeFile5(join13(outputDir, "metadata.json"), JSON.stringify(world.metadata, 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));
 }
 async function main9(argv = process.argv.slice(2)) {
   const startTime = performance.now();
   try {
     const args = parseArgs9(argv);
-    const { readFile: readFile3 } = await import("fs/promises");
+    const { readFile: readFile4 } = await import("fs/promises");
     let markdown;
     try {
-      markdown = await readFile3(args.inputPath, "utf-8");
+      markdown = await readFile4(args.inputPath, "utf-8");
     } catch {
       const errorResult = { error: `Cannot read file: ${args.inputPath}` };
       process.stderr.write(JSON.stringify(errorResult, null, 2) + "\n");
@@ -7401,10 +7401,10 @@ function verdictToAuditEvent(event, verdict) {
   return auditEvent;
 }
 async function readAuditLog(logPath, filter) {
-  const { readFile: readFile3 } = await import("fs/promises");
+  const { readFile: readFile4 } = await import("fs/promises");
   let content;
   try {
-    content = await readFile3(logPath, "utf-8");
+    content = await readFile4(logPath, "utf-8");
   } catch {
     return [];
   }
@@ -7509,9 +7509,9 @@ var init_audit_logger = __esm({
         }
         const lines = this.buffer.splice(0).join("\n") + "\n";
         try {
-          const { appendFile, mkdir: mkdir2 } = await import("fs/promises");
-          const { dirname: dirname3 } = await import("path");
-          await mkdir2(dirname3(this.logPath), { recursive: true });
+          const { appendFile, mkdir: mkdir3 } = await import("fs/promises");
+          const { dirname: dirname4 } = await import("path");
+          await mkdir3(dirname4(this.logPath), { recursive: true });
           await appendFile(this.logPath, lines, "utf-8");
         } catch {
         }
@@ -8241,14 +8241,14 @@ function handleHealthCheck() {
   };
 }
 async function handleListPresets(policiesDir) {
-  const { readdir, readFile: readFile3 } = await import("fs/promises");
-  const { join: join13 } = await import("path");
-  const dir = policiesDir ?? join13(process.cwd(), "policies");
+  const { readdir, readFile: readFile4 } = await import("fs/promises");
+  const { join: join14 } = await import("path");
+  const dir = policiesDir ?? join14(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 readFile3(join13(dir, file), "utf-8");
+      const content = await readFile4(join14(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) ?? "";
@@ -8319,9 +8319,9 @@ function govern(action, world, options) {
   return evaluateGuard(event, world, options);
 }
 async function writeTempWorld(dir, policyLines) {
-  const { writeFile: writeFile5, mkdir: mkdir2 } = await import("fs/promises");
-  const { join: join13 } = await import("path");
-  await mkdir2(dir, { recursive: true });
+  const { writeFile: writeFile6, mkdir: mkdir3 } = await import("fs/promises");
+  const { join: join14 } = await import("path");
+  await mkdir3(dir, { recursive: true });
   const worldJson = {
     world_id: "demo-live",
     name: "Live Demo World",
@@ -8362,9 +8362,9 @@ async function writeTempWorld(dir, policyLines) {
     authoring_method: "manual-authoring"
   };
   await Promise.all([
-    writeFile5(join13(dir, "world.json"), JSON.stringify(worldJson, null, 2)),
-    writeFile5(join13(dir, "kernel.json"), JSON.stringify(kernelJson, null, 2)),
-    writeFile5(join13(dir, "metadata.json"), JSON.stringify(metadataJson, null, 2))
+    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))
   ]);
 }
 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((resolve5, reject) => {
+    return new Promise((resolve6, reject) => {
       const chunks = [];
       req.on("data", (chunk) => chunks.push(chunk));
-      req.on("end", () => resolve5(Buffer.concat(chunks).toString("utf-8")));
+      req.on("end", () => resolve6(Buffer.concat(chunks).toString("utf-8")));
       req.on("error", reject);
     });
   }
@@ -11475,9 +11475,9 @@ async function main15(argv) {
   }
   if (worldPath) {
     try {
-      const { existsSync: existsSync9 } = await import("fs");
-      const { join: join13 } = await import("path");
-      const hasWorld = existsSync9(join13(worldPath, "world.json"));
+      const { existsSync: existsSync10 } = await import("fs");
+      const { join: join14 } = await import("path");
+      const hasWorld = existsSync10(join14(worldPath, "world.json"));
       checks.push({
         label: "World file detected",
         status: hasWorld ? "pass" : "fail",
@@ -11492,12 +11492,12 @@ async function main15(argv) {
       });
     }
   } else {
-    const { existsSync: existsSync9 } = await import("fs");
-    const { join: join13 } = await import("path");
+    const { existsSync: existsSync10 } = await import("fs");
+    const { join: join14 } = await import("path");
     const candidates = ["./world", "./.neuroverse", "./worlds"];
     let found;
     for (const dir of candidates) {
-      if (existsSync9(join13(dir, "world.json"))) {
+      if (existsSync10(join14(dir, "world.json"))) {
         found = dir;
         break;
       }
@@ -13148,7 +13148,7 @@ async function runPipeMode(config) {
 `);
   }
   const MAX_BUFFER_SIZE = 1e6;
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, 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
 `
       );
-      resolve5();
+      resolve6();
     });
     process.stdin.on("error", reject);
   });
@@ -13310,8 +13310,8 @@ ${response.content}
   rl2.on("close", () => {
     session.stop();
   });
-  return new Promise((resolve5) => {
-    rl2.on("close", resolve5);
+  return new Promise((resolve6) => {
+    rl2.on("close", resolve6);
   });
 }
 var SessionManager;
@@ -14421,28 +14421,28 @@ function computeWorldDiff(a, b) {
   return { changes };
 }
 async function worldSnapshot(worldPath) {
-  const { readdir, readFile: readFile3, mkdir: mkdir2, writeFile: writeFile5 } = await import("fs/promises");
-  const { join: join13 } = await import("path");
+  const { readdir, readFile: readFile4, mkdir: mkdir3, writeFile: writeFile6 } = await import("fs/promises");
+  const { join: join14 } = await import("path");
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-  const snapshotDir = join13(worldPath, ".snapshots", timestamp);
-  await mkdir2(snapshotDir, { recursive: true });
+  const snapshotDir = join14(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 readFile3(join13(worldPath, file), "utf-8");
-      await writeFile5(join13(snapshotDir, file), content, "utf-8");
+      const content = await readFile4(join14(worldPath, file), "utf-8");
+      await writeFile6(join14(snapshotDir, file), content, "utf-8");
       copied++;
     }
   }
   try {
-    const rulesDir = join13(worldPath, "rules");
+    const rulesDir = join14(worldPath, "rules");
     const ruleFiles = await readdir(rulesDir);
-    await mkdir2(join13(snapshotDir, "rules"), { recursive: true });
+    await mkdir3(join14(snapshotDir, "rules"), { recursive: true });
     for (const file of ruleFiles) {
       if (file.endsWith(".json")) {
-        const content = await readFile3(join13(rulesDir, file), "utf-8");
-        await writeFile5(join13(snapshotDir, "rules", file), content, "utf-8");
+        const content = await readFile4(join14(rulesDir, file), "utf-8");
+        await writeFile6(join14(snapshotDir, "rules", file), content, "utf-8");
         copied++;
       }
     }
@@ -14454,9 +14454,9 @@ async function worldSnapshot(worldPath) {
 `);
 }
 async function worldRollback(worldPath) {
-  const { readdir, readFile: readFile3, writeFile: writeFile5, mkdir: mkdir2 } = await import("fs/promises");
-  const { join: join13 } = await import("path");
-  const snapshotsDir = join13(worldPath, ".snapshots");
+  const { readdir, readFile: readFile4, writeFile: writeFile6, mkdir: mkdir3 } = await import("fs/promises");
+  const { join: join14 } = await import("path");
+  const snapshotsDir = join14(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 = join13(snapshotsDir, latest);
+  const snapshotDir = join14(snapshotsDir, latest);
   const backupTimestamp = "pre-rollback-" + (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-  const backupDir = join13(snapshotsDir, backupTimestamp);
-  await mkdir2(backupDir, { recursive: true });
+  const backupDir = join14(snapshotsDir, backupTimestamp);
+  await mkdir3(backupDir, { recursive: true });
   const currentFiles = await readdir(worldPath);
   for (const file of currentFiles) {
     if (file.endsWith(".json")) {
-      const content = await readFile3(join13(worldPath, file), "utf-8");
-      await writeFile5(join13(backupDir, file), content, "utf-8");
+      const content = await readFile4(join14(worldPath, file), "utf-8");
+      await writeFile6(join14(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 readFile3(join13(snapshotDir, file), "utf-8");
-      await writeFile5(join13(worldPath, file), content, "utf-8");
+      const content = await readFile4(join14(snapshotDir, file), "utf-8");
+      await writeFile6(join14(worldPath, file), content, "utf-8");
       restored++;
     }
   }
   try {
-    const rulesDir = join13(snapshotDir, "rules");
+    const rulesDir = join14(snapshotDir, "rules");
     const ruleFiles = await readdir(rulesDir);
-    await mkdir2(join13(worldPath, "rules"), { recursive: true });
+    await mkdir3(join14(worldPath, "rules"), { recursive: true });
     for (const file of ruleFiles) {
       if (file.endsWith(".json")) {
-        const content = await readFile3(join13(rulesDir, file), "utf-8");
-        await writeFile5(join13(worldPath, "rules", file), content, "utf-8");
+        const content = await readFile4(join14(rulesDir, file), "utf-8");
+        await writeFile6(join14(worldPath, "rules", file), content, "utf-8");
         restored++;
       }
     }
@@ -16400,27 +16400,27 @@ function closePrompts() {
 }
 function ask(question, defaultValue) {
   const suffix = defaultValue ? ` [${defaultValue}]` : "";
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     getRL().question(`
   ${question}${suffix}: `, (answer) => {
       const val = answer.trim();
-      resolve5(val || defaultValue || "");
+      resolve6(val || defaultValue || "");
     });
   });
 }
 function confirm(question, defaultYes = true) {
   const hint = defaultYes ? "[Y/n]" : "[y/N]";
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     getRL().question(`
   ${question} ${hint}: `, (answer) => {
       const val = answer.trim().toLowerCase();
-      if (val === "") resolve5(defaultYes);
-      else resolve5(val === "y" || val === "yes");
+      if (val === "") resolve6(defaultYes);
+      else resolve6(val === "y" || val === "yes");
     });
   });
 }
 function choose(question, options) {
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     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) {
-        resolve5(options[idx]);
+        resolve6(options[idx]);
       } else {
-        resolve5(options[0]);
+        resolve6(options[0]);
       }
     });
   });
@@ -16901,16 +16901,16 @@ function generateWorld(state) {
   return { worldJson, stateSchema, guardsJson, rules, gatesJson, invariants, outcomes, metadata };
 }
 async function writeWorld(outputDir, world) {
-  const { mkdirSync: mkdirSync5, existsSync: existsSync9 } = await import("fs");
-  const { writeFile: writeFile5 } = await import("fs/promises");
-  const { join: join13 } = await import("path");
+  const { mkdirSync: mkdirSync5, existsSync: existsSync10 } = await import("fs");
+  const { writeFile: writeFile6 } = await import("fs/promises");
+  const { join: join14 } = await import("path");
   const files = [];
-  if (!existsSync9(outputDir)) mkdirSync5(outputDir, { recursive: true });
-  const rulesDir = join13(outputDir, "rules");
-  if (!existsSync9(rulesDir)) mkdirSync5(rulesDir, { recursive: true });
+  if (!existsSync10(outputDir)) mkdirSync5(outputDir, { recursive: true });
+  const rulesDir = join14(outputDir, "rules");
+  if (!existsSync10(rulesDir)) mkdirSync5(rulesDir, { recursive: true });
   const writeJson = async (name, data) => {
-    const path = join13(outputDir, name);
-    await writeFile5(path, JSON.stringify(data, null, 2) + "\n", "utf-8");
+    const path = join14(outputDir, name);
+    await writeFile6(path, JSON.stringify(data, null, 2) + "\n", "utf-8");
     files.push(path);
   };
   await writeJson("world.json", world.worldJson);
@@ -16921,8 +16921,8 @@ 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 = join13(rulesDir, `${rule.id}.json`);
-    await writeFile5(rulePath, JSON.stringify(rule, null, 2) + "\n", "utf-8");
+    const rulePath = join14(rulesDir, `${rule.id}.json`);
+    await writeFile6(rulePath, JSON.stringify(rule, null, 2) + "\n", "utf-8");
     files.push(rulePath);
   }
   return files;
@@ -17007,8 +17007,8 @@ async function main31(argv = process.argv.slice(2)) {
   }
 }
 async function phaseRefine(outputDir, world) {
-  const { writeFile: writeFile5 } = await import("fs/promises");
-  const { join: join13 } = await import("path");
+  const { writeFile: writeFile6 } = await import("fs/promises");
+  const { join: join14 } = await import("path");
   heading("Refinement: Thresholds & Collapse");
   const primaryMetric = world.gatesJson.viability_classification[0]?.field || "system_health";
   info(`
@@ -17024,8 +17024,8 @@ async function phaseRefine(outputDir, world) {
       const parsed = parseInt(newVal, 10);
       if (!isNaN(parsed)) gate.value = parsed;
     }
-    await writeFile5(
-      join13(outputDir, "gates.json"),
+    await writeFile6(
+      join14(outputDir, "gates.json"),
       JSON.stringify(world.gatesJson, null, 2) + "\n",
       "utf-8"
     );
@@ -17046,8 +17046,8 @@ async function phaseRefine(outputDir, world) {
           value: parsed,
           result: "MODEL_COLLAPSES"
         };
-        await writeFile5(
-          join13(outputDir, "rules", `${rule.id}.json`),
+        await writeFile6(
+          join14(outputDir, "rules", `${rule.id}.json`),
           JSON.stringify(rule, null, 2) + "\n",
           "utf-8"
         );
@@ -17151,22 +17151,22 @@ ${parts.join(". ")}.
 `;
 }
 function previewLens(lens) {
-  const BOLD2 = "\x1B[1m";
-  const DIM2 = "\x1B[2m";
-  const CYAN2 = "\x1B[36m";
-  const YELLOW2 = "\x1B[33m";
-  const GREEN2 = "\x1B[32m";
-  const RESET2 = "\x1B[0m";
+  const BOLD3 = "\x1B[1m";
+  const DIM3 = "\x1B[2m";
+  const CYAN3 = "\x1B[36m";
+  const YELLOW3 = "\x1B[33m";
+  const GREEN3 = "\x1B[32m";
+  const RESET3 = "\x1B[0m";
   const lines = [];
   lines.push("");
-  lines.push(`${BOLD2}${CYAN2}  ${lens.name}${RESET2} ${DIM2}\u2014 ${lens.tagline}${RESET2}`);
-  lines.push(`${DIM2}  ${lens.description}${RESET2}`);
+  lines.push(`${BOLD3}${CYAN3}  ${lens.name}${RESET3} ${DIM3}\u2014 ${lens.tagline}${RESET3}`);
+  lines.push(`${DIM3}  ${lens.description}${RESET3}`);
   lines.push("");
   for (const d of lens.directives) {
     if (d.example) {
-      lines.push(`  ${BOLD2}${d.id}${RESET2}`);
-      lines.push(`  ${YELLOW2}Without:${RESET2} ${DIM2}${d.example.without}${RESET2}`);
-      lines.push(`  ${GREEN2}With:${RESET2}    ${d.example.with}`);
+      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("");
     }
   }
@@ -17213,7 +17213,7 @@ function lensForRole(world, roleId, roleLensOverride) {
   if (byRole) return byRole;
   return lenses[0];
 }
-var STOIC_LENS, CLOSER_LENS, SAMURAI_LENS, HYPE_MAN_LENS, MONK_LENS, SOCRATIC_LENS, MINIMALIST_LENS, LIFE_COACH_LENS, NFL_COACH_LENS, CALM_LENS, BUILTIN_LENSES;
+var STOIC_LENS, CLOSER_LENS, SAMURAI_LENS, HYPE_MAN_LENS, MONK_LENS, SOCRATIC_LENS, MINIMALIST_LENS, LIFE_COACH_LENS, NFL_COACH_LENS, CALM_LENS, BEHAVIORAL_INTERPRETER_LENS, BUILTIN_LENSES;
 var init_lens = __esm({
   "src/builder/lens.ts"() {
     "use strict";
@@ -17762,6 +17762,63 @@ var init_lens = __esm({
         }
       ]
     };
+    BEHAVIORAL_INTERPRETER_LENS = {
+      id: "behavioral-interpreter",
+      name: "Behavioral Interpreter",
+      tagline: "Read patterns, not promises.",
+      author: "NeuroverseOS",
+      version: "1.0.0",
+      description: "Interprets actions as behavioral signals. Prioritizes observed behavior over declared intent, identifies ambiguity, ownership diffusion, resistance, and alignment patterns, and frames outputs around recurring behavior rather than isolated statements.",
+      tags: ["behavior", "signals", "alignment", "analysis", "interpretation"],
+      stackable: true,
+      priority: 65,
+      appliesTo: "all",
+      tone: {
+        formality: "neutral",
+        verbosity: "concise",
+        emotion: "neutral",
+        confidence: "balanced"
+      },
+      directives: [
+        {
+          id: "actions_over_claims",
+          scope: "response_framing",
+          instruction: "Prioritize observed actions, repeated choices, and follow-through over stated intent or self-description. Treat behavior as stronger evidence than promises.",
+          example: {
+            without: "They said they're committed to the project and will prioritize it going forward.",
+            with: "They've said they'll prioritize it three times. Each time, other work was chosen instead. The pattern suggests this is not currently a priority regardless of stated intent."
+          }
+        },
+        {
+          id: "pattern_over_incident",
+          scope: "behavior_shaping",
+          instruction: "Interpret events in sequence. Look for recurring patterns across time rather than over-weighting one isolated incident.",
+          example: {
+            without: "They missed the deadline. That's a red flag.",
+            with: "One missed deadline is an event. Three missed deadlines with similar explanations is a pattern. What does the sequence tell you?"
+          }
+        },
+        {
+          id: "flag_ambiguity",
+          scope: "behavior_shaping",
+          instruction: "Notice ambiguity, indirectness, delayed commitment, and ownership diffusion. Treat these as meaningful signals when they repeat."
+        },
+        {
+          id: "separate_observed_inferred_speculative",
+          scope: "content_filtering",
+          instruction: "Clearly distinguish between what is directly observed, what is reasonably inferred from patterns, and what remains speculative."
+        },
+        {
+          id: "alignment_read",
+          scope: "value_emphasis",
+          instruction: "Assess whether words, timing, decisions, and follow-through align. Misalignment between stated priorities and actual behavior should be named clearly.",
+          example: {
+            without: "They seem supportive of the initiative.",
+            with: "They endorsed the initiative publicly but have not allocated budget, time, or personnel to it. Words and resource allocation are misaligned."
+          }
+        }
+      ]
+    };
     BUILTIN_LENSES = [
       // Character lenses — each one is a person you'd want in your corner
       STOIC_LENS,
@@ -17773,7 +17830,9 @@ var init_lens = __esm({
       HYPE_MAN_LENS,
       MONK_LENS,
       SOCRATIC_LENS,
-      MINIMALIST_LENS
+      MINIMALIST_LENS,
+      // Behavioral lenses — governance overlays that interpret action, not tone
+      BEHAVIORAL_INTERPRETER_LENS
     ];
   }
 });
@@ -18040,10 +18099,10 @@ async function cmdAdd(argv) {
   if (!id) {
     id = name.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, "");
   }
-  const { readFile: readFile3, writeFile: writeFile5 } = await import("fs/promises");
-  const { join: join13 } = await import("path");
+  const { readFile: readFile4, writeFile: writeFile6 } = await import("fs/promises");
+  const { join: join14 } = await import("path");
   const possiblePaths = [
-    join13(worldPath, "world.nv-world.md"),
+    join14(worldPath, "world.nv-world.md"),
     worldPath
   ];
   let mdPath = "";
@@ -18051,7 +18110,7 @@ async function cmdAdd(argv) {
   for (const p of possiblePaths) {
     try {
       if (p.endsWith(".md")) {
-        mdContent = await readFile3(p, "utf-8");
+        mdContent = await readFile4(p, "utf-8");
         mdPath = p;
         break;
       }
@@ -18064,8 +18123,8 @@ async function cmdAdd(argv) {
       const files = await readdir(worldPath);
       const mdFile = files.find((f) => f.endsWith(".nv-world.md"));
       if (mdFile) {
-        mdPath = join13(worldPath, mdFile);
-        mdContent = await readFile3(mdPath, "utf-8");
+        mdPath = join14(worldPath, mdFile);
+        mdContent = await readFile4(mdPath, "utf-8");
       }
     } catch {
     }
@@ -18099,7 +18158,7 @@ async function cmdAdd(argv) {
   } else {
     mdContent = mdContent.trimEnd() + "\n\n# Lenses\n" + lensBlock + "\n";
   }
-  await writeFile5(mdPath, mdContent, "utf-8");
+  await writeFile6(mdPath, mdContent, "utf-8");
   process.stderr.write("\n");
   process.stderr.write(`${GREEN}  Added lens "${name}" (${id}) to ${mdPath}${RESET}
 `);
@@ -18191,136 +18250,1757 @@ Examples:
   }
 });
 
-// src/cli/neuroverse.ts
-var USAGE9 = `
-neuroverse \u2014 Turn ideas into worlds.
-
-Commands:
-  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
-  validate       Static analysis on world files
-  guard          Runtime governance evaluation (stdin \u2192 stdout)
-  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)
-  keygen         Generate Ed25519 signing keypair
-  sign           Sign a world artifact (cryptographic manifest)
-  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)
-
-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]
-
-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
-  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 main33() {
-  const args = process.argv.slice(2);
-  const command = args[0];
-  const subArgs = args.slice(1);
-  switch (command) {
-    case "add": {
-      const { main: addMain } = await Promise.resolve().then(() => (init_add(), add_exports));
-      return addMain(subArgs);
-    }
-    case "build": {
-      const { main: buildMain } = await Promise.resolve().then(() => (init_build(), build_exports));
-      return buildMain(subArgs);
+// src/engine/worldmodel-parser.ts
+function splitSections2(markdown) {
+  const lines = markdown.split("\n");
+  let frontmatter = "";
+  let bodyStart = 0;
+  if (lines[0]?.trim() === "---") {
+    const endIdx = lines.indexOf("---", 1);
+    if (endIdx > 0) {
+      frontmatter = lines.slice(1, endIdx).join("\n");
+      bodyStart = endIdx + 1;
     }
-    case "explain": {
-      const { main: explainMain } = await Promise.resolve().then(() => (init_explain(), explain_exports));
-      return explainMain(subArgs);
+  }
+  const sections = [];
+  let currentSection = null;
+  const contentLines = [];
+  for (let i = bodyStart; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.startsWith("# ")) {
+      if (currentSection) {
+        currentSection.content = contentLines.join("\n").trim();
+        sections.push(currentSection);
+        contentLines.length = 0;
+      }
+      currentSection = {
+        name: line.replace(/^#\s+/, "").trim(),
+        content: "",
+        startLine: i + 1
+        // 1-based
+      };
+    } else if (currentSection) {
+      contentLines.push(line);
     }
-    case "simulate": {
-      const { main: simulateMain } = await Promise.resolve().then(() => (init_simulate(), simulate_exports));
-      return simulateMain(subArgs);
+  }
+  if (currentSection) {
+    currentSection.content = contentLines.join("\n").trim();
+    sections.push(currentSection);
+  }
+  return { frontmatter, sections };
+}
+function splitH2Sections2(content, baseLine) {
+  const lines = content.split("\n");
+  const sections = [];
+  let currentSection = null;
+  const contentLines = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.startsWith("## ")) {
+      if (currentSection) {
+        currentSection.content = contentLines.join("\n").trim();
+        sections.push(currentSection);
+        contentLines.length = 0;
+      }
+      currentSection = {
+        name: line.replace(/^##\s+/, "").trim(),
+        content: "",
+        startLine: baseLine + i
+      };
+    } else if (currentSection) {
+      contentLines.push(line);
     }
-    case "improve": {
-      const { main: improveMain } = await Promise.resolve().then(() => (init_improve(), improve_exports));
-      return improveMain(subArgs);
+  }
+  if (currentSection) {
+    currentSection.content = contentLines.join("\n").trim();
+    sections.push(currentSection);
+  }
+  return sections;
+}
+function splitH3Sections(content, baseLine) {
+  const lines = content.split("\n");
+  const sections = [];
+  let currentSection = null;
+  const contentLines = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.startsWith("### ")) {
+      if (currentSection) {
+        currentSection.content = contentLines.join("\n").trim();
+        sections.push(currentSection);
+        contentLines.length = 0;
+      }
+      currentSection = {
+        name: line.replace(/^###\s+/, "").trim(),
+        content: "",
+        startLine: baseLine + i
+      };
+    } else if (currentSection) {
+      contentLines.push(line);
     }
-    case "init": {
-      const { main: initMain } = await Promise.resolve().then(() => (init_init(), init_exports));
-      return initMain(subArgs);
+  }
+  if (currentSection) {
+    currentSection.content = contentLines.join("\n").trim();
+    sections.push(currentSection);
+  }
+  return sections;
+}
+function splitH4Sections(content, baseLine) {
+  const lines = content.split("\n");
+  const sections = [];
+  let currentSection = null;
+  const contentLines = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.startsWith("#### ")) {
+      if (currentSection) {
+        currentSection.content = contentLines.join("\n").trim();
+        sections.push(currentSection);
+        contentLines.length = 0;
+      }
+      currentSection = {
+        name: line.replace(/^####\s+/, "").trim(),
+        content: "",
+        startLine: baseLine + i
+      };
+    } else if (currentSection) {
+      contentLines.push(line);
+    }
+  }
+  if (currentSection) {
+    currentSection.content = contentLines.join("\n").trim();
+    sections.push(currentSection);
+  }
+  return sections;
+}
+function parseBulletList(content) {
+  const items = [];
+  let inComment = false;
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("<!--")) {
+      inComment = true;
+    }
+    if (inComment) {
+      if (trimmed.includes("-->")) {
+        inComment = false;
+      }
+      continue;
+    }
+    if (trimmed.startsWith("- ")) {
+      items.push(trimmed.slice(2).trim());
+    }
+  }
+  return items;
+}
+function extractTextContent(content) {
+  const lines = content.split("\n");
+  const textLines = [];
+  let inComment = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("<!--")) {
+      inComment = true;
+    }
+    if (inComment) {
+      if (trimmed.includes("-->")) {
+        inComment = false;
+      }
+      continue;
+    }
+    if (trimmed && !trimmed.startsWith("#")) {
+      textLines.push(trimmed);
+    }
+  }
+  return textLines.join("\n").trim();
+}
+function toKebabCase(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+function parseFrontmatter3(yaml, issues) {
+  const result = {};
+  for (const line of yaml.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const colonIdx = trimmed.indexOf(":");
+    if (colonIdx === -1) continue;
+    const key = trimmed.slice(0, colonIdx).trim();
+    const value = trimmed.slice(colonIdx + 1).trim();
+    result[key] = value;
+  }
+  const name = result.name || "";
+  if (!name) {
+    issues.push({
+      line: 1,
+      section: "frontmatter",
+      message: "Missing name in frontmatter. Provide a human-readable model name.",
+      severity: "error"
+    });
+  }
+  const model_id = result.model_id || toKebabCase(name);
+  return {
+    model_id,
+    name,
+    version: result.version || "1.0.0"
+  };
+}
+function parseGeometry(section, issues) {
+  const geometry = {
+    mission: "",
+    domains: [],
+    overlapEffects: [],
+    centerIdentity: ""
+  };
+  if (!section) {
+    issues.push({
+      line: 0,
+      section: "Core Model Geometry",
+      message: "Missing # Core Model Geometry section. Define the structural model: mission, domains with embedded skills and values, overlaps, and center identity.",
+      severity: "error"
+    });
+    return geometry;
+  }
+  const h2Sections = splitH2Sections2(section.content, section.startLine);
+  const missionSection = h2Sections.find((s) => s.name.toLowerCase() === "mission");
+  if (missionSection) {
+    geometry.mission = extractTextContent(missionSection.content);
+  }
+  if (!geometry.mission) {
+    issues.push({
+      line: missionSection?.startLine ?? section.startLine,
+      section: "Mission",
+      message: "Missing ## Mission. Define what this system is trying to achieve \u2014 the core aim, not a slogan.",
+      severity: "error"
+    });
+  }
+  const domainsSection = h2Sections.find((s) => s.name.toLowerCase() === "domains");
+  if (domainsSection) {
+    const domainSections = splitH3Sections(domainsSection.content, domainsSection.startLine);
+    for (const ds of domainSections) {
+      const domain = {
+        id: toKebabCase(ds.name),
+        name: ds.name,
+        skills: [],
+        values: [],
+        line: ds.startLine
+      };
+      const h4Sections = splitH4Sections(ds.content, ds.startLine);
+      const skillsH4 = h4Sections.find((s) => s.name.toLowerCase() === "skills");
+      if (skillsH4) {
+        domain.skills = parseBulletList(skillsH4.content);
+      }
+      const valuesH4 = h4Sections.find((s) => s.name.toLowerCase() === "values");
+      if (valuesH4) {
+        domain.values = parseBulletList(valuesH4.content);
+      }
+      if (domain.skills.length === 0) {
+        issues.push({
+          line: ds.startLine,
+          section: "Domains",
+          message: `Domain '${ds.name}' has no skills defined. Skills are the capabilities within this domain.`,
+          severity: "warning"
+        });
+      }
+      if (domain.values.length === 0) {
+        issues.push({
+          line: ds.startLine,
+          section: "Domains",
+          message: `Domain '${ds.name}' has no values defined. Behavior has no constraints without values.`,
+          severity: "warning"
+        });
+      }
+      geometry.domains.push(domain);
+    }
+  }
+  if (geometry.domains.length < 2) {
+    issues.push({
+      line: domainsSection?.startLine ?? section.startLine,
+      section: "Domains",
+      message: "At least 2 domains required. Domains are the major operating modes of the system, each carrying skills and values.",
+      severity: "error"
+    });
+  }
+  const overlapsSection = h2Sections.find(
+    (s) => s.name.toLowerCase() === "overlap effects"
+  );
+  if (overlapsSection) {
+    const bullets = parseBulletList(overlapsSection.content);
+    const domainNames = new Set(geometry.domains.map((d) => d.name.toLowerCase()));
+    for (let i = 0; i < bullets.length; i++) {
+      const bullet = bullets[i];
+      const match = bullet.match(/^(.+?)\s*\+\s*(.+?)\s*=\s*(.+)$/);
+      if (match) {
+        const domainA = match[1].trim();
+        const domainB = match[2].trim();
+        const effect = match[3].trim();
+        if (!domainNames.has(domainA.toLowerCase())) {
+          issues.push({
+            line: overlapsSection.startLine + i,
+            section: "Overlap Effects",
+            message: `Overlap references unknown domain '${domainA}'. Must reference a declared domain.`,
+            severity: "warning"
+          });
+        }
+        if (!domainNames.has(domainB.toLowerCase())) {
+          issues.push({
+            line: overlapsSection.startLine + i,
+            section: "Overlap Effects",
+            message: `Overlap references unknown domain '${domainB}'. Must reference a declared domain.`,
+            severity: "warning"
+          });
+        }
+        geometry.overlapEffects.push({
+          domainA,
+          domainB,
+          effect,
+          line: overlapsSection.startLine + i
+        });
+      } else {
+        issues.push({
+          line: overlapsSection.startLine + i,
+          section: "Overlap Effects",
+          message: `Cannot parse overlap: '${bullet}'. Expected format: 'Domain A + Domain B = Emergent State'.`,
+          severity: "warning"
+        });
+      }
+    }
+  }
+  if (geometry.overlapEffects.length === 0) {
+    issues.push({
+      line: overlapsSection?.startLine ?? section.startLine,
+      section: "Overlap Effects",
+      message: 'No overlap effects defined. Define what emerges when two domains interact well (e.g., "Domain A + Domain B = Inspiration").',
+      severity: "warning"
+    });
+  }
+  const identitySection = h2Sections.find(
+    (s) => s.name.toLowerCase() === "center identity"
+  );
+  if (identitySection) {
+    geometry.centerIdentity = extractTextContent(identitySection.content);
+  }
+  if (!geometry.centerIdentity) {
+    issues.push({
+      line: identitySection?.startLine ?? section.startLine,
+      section: "Center Identity",
+      message: "No center identity defined. Define what the system becomes when all domains are aligned \u2014 the core identity.",
+      severity: "warning"
+    });
+  }
+  return geometry;
+}
+function parseModifiers(section, issues) {
+  const modifiers = {
+    authorityLayers: [],
+    spatialContexts: [],
+    interpretationRules: []
+  };
+  if (!section) {
+    issues.push({
+      line: 0,
+      section: "Contextual Modifiers",
+      message: "Missing # Contextual Modifiers section. Define how authority, role, and spatial context change how behavior is interpreted.",
+      severity: "warning"
+    });
+    return modifiers;
+  }
+  const h2Sections = splitH2Sections2(section.content, section.startLine);
+  const authoritySection = h2Sections.find(
+    (s) => s.name.toLowerCase() === "authority layers"
+  );
+  if (authoritySection) {
+    modifiers.authorityLayers = parseBulletList(authoritySection.content);
+  }
+  const spatialSection = h2Sections.find(
+    (s) => s.name.toLowerCase() === "spatial contexts"
+  );
+  if (spatialSection) {
+    modifiers.spatialContexts = parseBulletList(spatialSection.content);
+  }
+  const rulesSection = h2Sections.find(
+    (s) => s.name.toLowerCase() === "interpretation rules"
+  );
+  if (rulesSection) {
+    modifiers.interpretationRules = parseBulletList(rulesSection.content);
+  }
+  return modifiers;
+}
+function parseEvolution(section, issues) {
+  const evolution = {
+    alignedBehaviors: [],
+    driftBehaviors: [],
+    signals: [],
+    decisionPriorities: [],
+    evolutionConditions: []
+  };
+  if (!section) {
+    issues.push({
+      line: 0,
+      section: "Evolution Layer",
+      message: "Missing # Evolution Layer section. Define observable behaviors, signals, decision priorities, and adaptation conditions.",
+      severity: "error"
+    });
+    return evolution;
+  }
+  const h2Sections = splitH2Sections2(section.content, section.startLine);
+  const alignedSection = h2Sections.find(
+    (s) => s.name.toLowerCase() === "aligned behaviors"
+  );
+  if (alignedSection) {
+    evolution.alignedBehaviors = parseBulletList(alignedSection.content);
+  }
+  if (evolution.alignedBehaviors.length === 0) {
+    issues.push({
+      line: alignedSection?.startLine ?? section.startLine,
+      section: "Aligned Behaviors",
+      message: "No aligned behaviors defined. Define what success looks like in action.",
+      severity: "warning"
+    });
+  }
+  const driftSection = h2Sections.find(
+    (s) => s.name.toLowerCase() === "drift behaviors"
+  );
+  if (driftSection) {
+    evolution.driftBehaviors = parseBulletList(driftSection.content);
+  }
+  if (evolution.driftBehaviors.length === 0) {
+    issues.push({
+      line: driftSection?.startLine ?? section.startLine,
+      section: "Drift Behaviors",
+      message: "No drift behaviors defined. Define what misalignment looks like so the system can detect behavioral drift over time.",
+      severity: "warning"
+    });
+  }
+  const signalsSection = h2Sections.find(
+    (s) => s.name.toLowerCase() === "signals"
+  );
+  if (signalsSection) {
+    evolution.signals = parseBulletList(signalsSection.content);
+  }
+  if (evolution.signals.length < 2) {
+    issues.push({
+      line: signalsSection?.startLine ?? section.startLine,
+      section: "Signals",
+      message: "At least 2 signals required. Signals are the observable metrics for detecting alignment or drift.",
+      severity: "error"
+    });
+  }
+  const prioritiesSection = h2Sections.find(
+    (s) => s.name.toLowerCase() === "decision priorities"
+  );
+  if (prioritiesSection) {
+    const bullets = parseBulletList(prioritiesSection.content);
+    for (let i = 0; i < bullets.length; i++) {
+      const bullet = bullets[i];
+      const match = bullet.match(/^(.+?)\s*>\s*(.+)$/);
+      if (match) {
+        evolution.decisionPriorities.push({
+          preferred: match[1].trim(),
+          over: match[2].trim(),
+          line: prioritiesSection.startLine + i
+        });
+      } else {
+        issues.push({
+          line: prioritiesSection.startLine + i,
+          section: "Decision Priorities",
+          message: `Cannot parse priority: '${bullet}'. Expected format: 'preferred > over'.`,
+          severity: "warning"
+        });
+      }
+    }
+  }
+  if (evolution.decisionPriorities.length === 0) {
+    issues.push({
+      line: prioritiesSection?.startLine ?? section.startLine,
+      section: "Decision Priorities",
+      message: "No decision priorities defined. Define what wins when tradeoffs appear.",
+      severity: "warning"
+    });
+  }
+  const evoSection = h2Sections.find(
+    (s) => s.name.toLowerCase() === "evolution conditions"
+  );
+  if (evoSection) {
+    evolution.evolutionConditions = parseBulletList(evoSection.content);
+  }
+  if (evolution.signals.length > 0 && evolution.driftBehaviors.length === 0) {
+    issues.push({
+      line: signalsSection?.startLine ?? section.startLine,
+      section: "Evolution Layer",
+      message: "Signals defined but no drift behaviors. System cannot detect failure without drift definitions.",
+      severity: "warning"
+    });
+  }
+  return evolution;
+}
+function parseWorldModel(markdown) {
+  const issues = [];
+  if (!markdown || !markdown.trim()) {
+    issues.push({
+      line: 0,
+      section: "file",
+      message: "Empty input. Provide a .worldmodel.md file with three layers: Core Model Geometry, Contextual Modifiers, Evolution Layer.",
+      severity: "error"
+    });
+    return { model: null, issues };
+  }
+  const { frontmatter: fmRaw, sections } = splitSections2(markdown);
+  const frontmatter = parseFrontmatter3(fmRaw, issues);
+  const geometrySection = sections.find(
+    (s) => s.name.toLowerCase() === "core model geometry"
+  );
+  const modifiersSection = sections.find(
+    (s) => s.name.toLowerCase() === "contextual modifiers"
+  );
+  const evolutionSection = sections.find(
+    (s) => s.name.toLowerCase() === "evolution layer"
+  );
+  const geometry = parseGeometry(geometrySection, issues);
+  const modifiers = parseModifiers(modifiersSection, issues);
+  const evolution = parseEvolution(evolutionSection, issues);
+  if (geometry.overlapEffects.length > 0 && !geometry.centerIdentity) {
+    issues.push({
+      line: 0,
+      section: "Core Model Geometry",
+      message: "Overlaps defined but no center identity. System lacks coherence without an aligned identity.",
+      severity: "warning"
+    });
+  }
+  const hasErrors = issues.some((i) => i.severity === "error");
+  if (hasErrors) {
+    return {
+      model: {
+        frontmatter,
+        geometry,
+        modifiers,
+        evolution
+      },
+      issues
+    };
+  }
+  return {
+    model: {
+      frontmatter,
+      geometry,
+      modifiers,
+      evolution
+    },
+    issues
+  };
+}
+var init_worldmodel_parser = __esm({
+  "src/engine/worldmodel-parser.ts"() {
+    "use strict";
+  }
+});
+
+// src/engine/worldmodel-compiler.ts
+function toSnakeCase(text) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, "");
+}
+function toKebabCase2(text) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+function titleCase(text) {
+  return text.split(/[\s_-]+/).map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join(" ");
+}
+function matchSignal(behaviorText, signals) {
+  const lowerText = behaviorText.toLowerCase();
+  for (const signal of signals) {
+    const signalWords = signal.toLowerCase().split("_");
+    if (signalWords.some((w) => w.length > 3 && lowerText.includes(w))) {
+      return signal;
+    }
+  }
+  return "alignment_score";
+}
+function emitWorldMarkdown(model) {
+  const lines = [];
+  const worldId = model.frontmatter.model_id;
+  const worldName = model.frontmatter.name;
+  const version = model.frontmatter.version;
+  lines.push("---");
+  lines.push(`world_id: ${worldId}`);
+  lines.push(`name: ${worldName}`);
+  lines.push(`version: ${version}`);
+  lines.push("runtime_mode: COMPLIANCE");
+  lines.push("default_profile: aligned");
+  lines.push("alternative_profile: drifting");
+  lines.push("---");
+  lines.push("");
+  lines.push("# Thesis");
+  lines.push("");
+  lines.push(model.geometry.mission);
+  if (model.geometry.centerIdentity) {
+    lines.push(
+      `When all domains are aligned, the system operates as: ${model.geometry.centerIdentity}.`
+    );
+  }
+  lines.push("");
+  lines.push("# Invariants");
+  lines.push("");
+  let invariantIdx = 0;
+  for (const domain of model.geometry.domains) {
+    for (const value of domain.values) {
+      invariantIdx++;
+      const invId = `${toSnakeCase(domain.name)}_value_${String(invariantIdx).padStart(2, "0")}`;
+      lines.push(
+        `- \`${invId}\` \u2014 ${value} [${domain.name}] (structural, immutable)`
+      );
+    }
+  }
+  lines.push("");
+  lines.push("# State");
+  lines.push("");
+  lines.push("## alignment_score");
+  lines.push("- type: number");
+  lines.push("- min: 0");
+  lines.push("- max: 100");
+  lines.push("- step: 5");
+  lines.push("- default: 70");
+  lines.push("- label: Alignment Score");
+  lines.push(
+    "- description: Composite behavioral alignment metric derived from all signals"
+  );
+  lines.push("");
+  for (const signal of model.evolution.signals) {
+    const signalId = toSnakeCase(signal);
+    const signalLabel = titleCase(signal);
+    lines.push(`## ${signalId}`);
+    lines.push("- type: number");
+    lines.push("- min: 0");
+    lines.push("- max: 100");
+    lines.push("- step: 5");
+    lines.push("- default: 70");
+    lines.push(`- label: ${signalLabel}`);
+    lines.push(`- description: Behavioral signal measuring ${signal.replace(/_/g, " ")}`);
+    lines.push("");
+  }
+  lines.push("# Assumptions");
+  lines.push("");
+  lines.push("## aligned");
+  lines.push("- name: Aligned");
+  lines.push("- description: All behavioral signals at healthy levels");
+  lines.push("- pressure_level: low");
+  lines.push("");
+  lines.push("## drifting");
+  lines.push("- name: Drifting");
+  lines.push("- description: Behavioral signals under pressure with drift risk");
+  lines.push("- pressure_level: high");
+  lines.push("");
+  lines.push("# Rules");
+  lines.push("");
+  let ruleIdx = 0;
+  for (const drift of model.evolution.driftBehaviors) {
+    ruleIdx++;
+    const ruleId = `rule-${String(ruleIdx).padStart(3, "0")}`;
+    const matchedSignal = matchSignal(drift, model.evolution.signals);
+    const signalId = toSnakeCase(matchedSignal);
+    lines.push(`## ${ruleId}: ${drift} (degradation)`);
+    lines.push(`Drift behavior detected: ${drift}`);
+    lines.push("");
+    lines.push(`When ${signalId} < 50 [state]`);
+    lines.push("Then alignment_score *= 0.80");
+    lines.push("");
+    lines.push(`> trigger: ${signalId} drops below threshold`);
+    lines.push(`> rule: Drift behavior weakens alignment`);
+    lines.push(`> shift: Behavioral alignment decreases`);
+    lines.push(`> effect: Alignment score reduced by 20%`);
+    lines.push("");
+  }
+  for (const aligned of model.evolution.alignedBehaviors) {
+    ruleIdx++;
+    const ruleId = `rule-${String(ruleIdx).padStart(3, "0")}`;
+    const matchedSignal = matchSignal(aligned, model.evolution.signals);
+    const signalId = toSnakeCase(matchedSignal);
+    lines.push(`## ${ruleId}: ${aligned} (advantage)`);
+    lines.push(`Aligned behavior reinforced: ${aligned}`);
+    lines.push("");
+    lines.push(`When ${signalId} >= 70 [state]`);
+    lines.push("Then alignment_score *= 1.10");
+    lines.push("");
+    lines.push(`> trigger: ${signalId} above healthy threshold`);
+    lines.push(`> rule: Aligned behavior strengthens system`);
+    lines.push(`> shift: Behavioral alignment increases`);
+    lines.push(`> effect: Alignment score boosted by 10%`);
+    lines.push("");
+  }
+  for (let i = 0; i < model.evolution.decisionPriorities.length; i++) {
+    ruleIdx++;
+    const priority = model.evolution.decisionPriorities[i];
+    const ruleId = `rule-${String(ruleIdx).padStart(3, "0")}`;
+    lines.push(
+      `## ${ruleId}: ${priority.preferred} over ${priority.over} (structural)`
+    );
+    lines.push(
+      `Priority: ${priority.preferred} takes precedence over ${priority.over} in tradeoff situations.`
+    );
+    lines.push("");
+    lines.push("When alignment_score < 40 [state]");
+    lines.push("Then alignment_score *= 0.70");
+    lines.push("Collapse: alignment_score < 10");
+    lines.push("");
+    lines.push(`> trigger: Alignment score critically low`);
+    lines.push(
+      `> rule: Priority violation \u2014 ${priority.preferred} must outweigh ${priority.over}`
+    );
+    lines.push(`> shift: System enters structural enforcement`);
+    lines.push(`> effect: Alignment sharply reduced; collapse if critical`);
+    lines.push("");
+  }
+  lines.push("# Gates");
+  lines.push("");
+  lines.push("- STRONG: alignment_score >= 85");
+  lines.push("- STABLE: alignment_score >= 65");
+  lines.push("- WATCHING: alignment_score >= 45");
+  lines.push("- FRAGILE: alignment_score > 30");
+  lines.push("- MISALIGNED: alignment_score <= 30");
+  lines.push("");
+  lines.push("# Outcomes");
+  lines.push("");
+  lines.push("## alignment_score");
+  lines.push("- type: number");
+  lines.push("- range: 0-100");
+  lines.push("- display: percentage");
+  lines.push("- label: Alignment Score");
+  lines.push("- primary: true");
+  lines.push("");
+  for (const signal of model.evolution.signals) {
+    const signalId = toSnakeCase(signal);
+    const signalLabel = titleCase(signal);
+    lines.push(`## ${signalId}`);
+    lines.push("- type: number");
+    lines.push("- range: 0-100");
+    lines.push("- display: percentage");
+    lines.push(`- label: ${signalLabel}`);
+    lines.push("");
+  }
+  const lensSuggestions = buildLensSuggestions(model);
+  if (lensSuggestions.length > 0) {
+    lines.push("# Lenses");
+    lines.push("- policy: role_default");
+    lines.push("");
+    for (const lens of lensSuggestions) {
+      lines.push(`## ${lens.id}`);
+      lines.push(`- tagline: ${lens.tagline}`);
+      lines.push(
+        `- description: Lens derived from ${lens.derived_from.domainA} and ${lens.derived_from.domainB} interaction, producing ${lens.derived_from.effect}.`
+      );
+      lines.push(`- formality: ${lens.tone.formality}`);
+      lines.push(`- verbosity: ${lens.tone.verbosity}`);
+      lines.push(`- emotion: ${lens.tone.emotion}`);
+      lines.push(`- confidence: ${lens.tone.confidence}`);
+      lines.push("- tags: behavioral, worldmodel, overlap");
+      lines.push("- default_for_roles: all");
+      lines.push("- priority: 50");
+      lines.push("- stackable: true");
+      lines.push("");
+      for (const directive of lens.directives) {
+        lines.push(`> ${directive.scope}: ${directive.instruction}`);
+      }
+      lines.push("");
+    }
+  }
+  return lines.join("\n");
+}
+function emitSignalSchema(model) {
+  const signals = model.evolution.signals.map((signal) => ({
+    id: toSnakeCase(signal),
+    name: titleCase(signal),
+    type: "number",
+    default: 70
+  }));
+  return {
+    model_id: model.frontmatter.model_id,
+    signals
+  };
+}
+function emitOverlapMap(model) {
+  const pairings = model.geometry.overlapEffects.map((o) => ({
+    domainA: o.domainA,
+    domainB: o.domainB,
+    effect: o.effect
+  }));
+  const matrix = {};
+  for (const overlap of model.geometry.overlapEffects) {
+    const keyA = toKebabCase2(overlap.domainA);
+    const keyB = toKebabCase2(overlap.domainB);
+    if (!matrix[keyA]) matrix[keyA] = {};
+    matrix[keyA][keyB] = overlap.effect;
+  }
+  return {
+    model_id: model.frontmatter.model_id,
+    pairings,
+    matrix
+  };
+}
+function emitContextsConfig(model) {
+  return {
+    model_id: model.frontmatter.model_id,
+    authority_layers: model.modifiers.authorityLayers,
+    spatial_contexts: model.modifiers.spatialContexts,
+    interpretation_rules: model.modifiers.interpretationRules
+  };
+}
+function deriveTone(domainA, domainB) {
+  const combined = `${domainA} ${domainB}`.toLowerCase();
+  let formality = "neutral";
+  if (/strateg|technic|analytic|research|engineer/.test(combined)) {
+    formality = "professional";
+  } else if (/narrat|story|communi|creative/.test(combined)) {
+    formality = "casual";
+  }
+  let verbosity = "balanced";
+  if (/foresight|scenario|plan|design/.test(combined)) {
+    verbosity = "detailed";
+  } else if (/prosper|negotiat|stakeholder/.test(combined)) {
+    verbosity = "concise";
+  }
+  let emotion = "neutral";
+  if (/empath|emoti|care|safe|trust/.test(combined)) {
+    emotion = "warm";
+  } else if (/analytic|system|data/.test(combined)) {
+    emotion = "clinical";
+  }
+  let confidence = "balanced";
+  if (/lead|command|decis|strateg/.test(combined)) {
+    confidence = "authoritative";
+  } else if (/explor|experiment|creat/.test(combined)) {
+    confidence = "exploratory";
+  }
+  return { formality, verbosity, emotion, confidence };
+}
+function buildLensSuggestions(model) {
+  const lenses = [];
+  const domainMap = new Map(model.geometry.domains.map((d) => [d.name.toLowerCase(), d]));
+  for (const overlap of model.geometry.overlapEffects) {
+    const lensId = toKebabCase2(overlap.effect);
+    const tone = deriveTone(overlap.domainA, overlap.domainB);
+    const domainAData = domainMap.get(overlap.domainA.toLowerCase());
+    const domainBData = domainMap.get(overlap.domainB.toLowerCase());
+    const directives = [];
+    if (domainAData && domainAData.skills.length > 0) {
+      directives.push({
+        scope: "response_framing",
+        instruction: `Approach through the lens of ${domainAData.skills.join(", ").toLowerCase()}.`
+      });
+    }
+    if (domainBData && domainBData.values.length > 0) {
+      directives.push({
+        scope: "behavior_shaping",
+        instruction: `Maintain ${domainBData.values.join(", ").toLowerCase()} in all responses.`
+      });
+    }
+    directives.push({
+      scope: "value_emphasis",
+      instruction: `Emphasize ${overlap.effect.toLowerCase()} as the emergent state of aligned behavior.`
+    });
+    lenses.push({
+      id: lensId,
+      name: titleCase(overlap.effect),
+      tagline: `${overlap.effect} through ${overlap.domainA} and ${overlap.domainB}.`,
+      derived_from: {
+        domainA: overlap.domainA,
+        domainB: overlap.domainB,
+        effect: overlap.effect
+      },
+      tone,
+      directives
+    });
+  }
+  return lenses;
+}
+function emitLensSuggestions(model) {
+  return buildLensSuggestions(model);
+}
+function compileWorldModel(model) {
+  return {
+    worldMarkdown: emitWorldMarkdown(model),
+    signalSchema: emitSignalSchema(model),
+    overlapMap: emitOverlapMap(model),
+    contextsConfig: emitContextsConfig(model),
+    lensSuggestions: emitLensSuggestions(model)
+  };
+}
+var init_worldmodel_compiler = __esm({
+  "src/engine/worldmodel-compiler.ts"() {
+    "use strict";
+  }
+});
+
+// src/cli/worldmodel.ts
+var worldmodel_exports = {};
+__export(worldmodel_exports, {
+  main: () => main33
+});
+function parseArgs26(argv) {
+  const args = {
+    inputPath: "",
+    output: "",
+    name: "",
+    json: false,
+    help: false
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--json") {
+      args.json = true;
+    } else if (arg === "--help" || arg === "-h") {
+      args.help = true;
+    } else if (arg === "--output" && i + 1 < argv.length) {
+      args.output = argv[++i];
+    } else if (arg === "--name" && i + 1 < argv.length) {
+      args.name = argv[++i];
+    } else if (!arg.startsWith("--") && !args.inputPath) {
+      args.inputPath = arg;
+    }
+  }
+  return args;
+}
+function formatIssue(issue) {
+  const color = issue.severity === "error" ? RED : issue.severity === "warning" ? YELLOW2 : DIM2;
+  const icon = issue.severity === "error" ? "x" : issue.severity === "warning" ? "!" : "i";
+  const lineRef = issue.line > 0 ? `:${issue.line}` : "";
+  return `  ${color}${icon}${RESET2} [${issue.section}${lineRef}] ${issue.message}`;
+}
+async function readSourceFile(inputPath) {
+  const fullPath = (0, import_path12.resolve)(inputPath);
+  if (!(0, import_fs11.existsSync)(fullPath)) {
+    process.stderr.write(`File not found: ${fullPath}
+`);
+    process.exit(3);
+  }
+  return (0, import_promises6.readFile)(fullPath, "utf-8");
+}
+async function loadAndParse(inputPath) {
+  const content = await readSourceFile(inputPath);
+  const result = parseWorldModel(content);
+  if (!result.model) {
+    process.stderr.write(`${RED}Failed to parse ${inputPath}${RESET2}
+`);
+    for (const issue of result.issues) {
+      process.stderr.write(formatIssue(issue) + "\n");
+    }
+    process.exit(1);
+  }
+  return { model: result.model, issues: result.issues };
+}
+async function cmdInit(argv) {
+  const args = parseArgs26(argv);
+  if (args.help) {
+    process.stdout.write(
+      'neuroverse worldmodel init \u2014 Scaffold a new .worldmodel.md template\n\nOptions:\n  --name <name>    Model name (default: "My Behavioral Model")\n  --output <path>  Output path (default: ./model.worldmodel.md)\n'
+    );
+    return;
+  }
+  const modelName = args.name || "My Behavioral Model";
+  const outputPath = (0, import_path12.resolve)(
+    args.output || `./${toFileName(modelName)}.worldmodel.md`
+  );
+  if ((0, import_fs11.existsSync)(outputPath)) {
+    process.stderr.write(`File already exists: ${outputPath}
+`);
+    process.stderr.write("Use --output to specify a different path.\n");
+    process.exit(1);
+  }
+  const template = generateScaffold(modelName);
+  const dir = (0, import_path12.dirname)(outputPath);
+  if (!(0, import_fs11.existsSync)(dir)) {
+    await (0, import_promises6.mkdir)(dir, { recursive: true });
+  }
+  await (0, import_promises6.writeFile)(outputPath, template, "utf-8");
+  process.stderr.write(`${GREEN2}Created${RESET2} ${outputPath}
+`);
+  process.stderr.write(
+    `${DIM2}Edit the template, then run: neuroverse worldmodel validate ${(0, import_path12.basename)(outputPath)}${RESET2}
+`
+  );
+}
+function toFileName(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+function generateScaffold(modelName) {
+  return `---
+name: ${modelName}
+version: 1.0.0
+---
+
+# Core Model Geometry
+<!--
+This section defines the STRUCTURE of your behavioral system.
+
+You are defining:
+- what the system is trying to achieve (mission)
+- the major domains it operates within (2-4 recommended)
+- the skills inside each domain
+- the values that govern those skills
+- what emerges when domains interact
+- what identity forms when everything is aligned
+
+Think of this as the "physics" of your system.
+-->
+
+## Mission
+<!-- What is this system trying to achieve? This is not a slogan \u2014 it is the core aim. -->
+
+Replace with your mission statement.
+
+## Domains
+<!--
+Define 2-4 domains. Each domain is a mode of operating.
+Each domain MUST include:
+- Skills (what it can do)
+- Values (how it must behave while doing it)
+
+Domains are NOT personality traits \u2014 they are capability environments.
+-->
+
+### Domain One
+
+#### Skills
+- Replace with a capability
+- Replace with another capability
+
+#### Values
+- Replace with a constraint
+- Replace with another constraint
+
+### Domain Two
+
+#### Skills
+- Replace with a capability
+- Replace with another capability
+
+#### Values
+- Replace with a constraint
+- Replace with another constraint
+
+## Overlap Effects
+<!--
+Define what emerges when TWO domains interact well.
+
+Format:
+- Domain A + Domain B = Emergent State
+
+These are NOT enforced rules.
+These are INTERPRETIVE STATES used downstream.
+
+They answer:
+"What does it feel like / look like when these are working together?"
+-->
+
+- Domain One + Domain Two = Replace With Emergent State
+
+## Center Identity
+<!--
+What does the system become when all domains are aligned?
+This is the CORE IDENTITY of the system.
+-->
+
+Replace with center identity name
+
+# Contextual Modifiers
+<!--
+This section defines how BEHAVIOR IS INTERPRETED differently depending on context.
+
+These do NOT define truth.
+They define how meaning changes depending on:
+- who is acting
+- where behavior occurs
+- what phase the system is in
+
+This is what makes the model multidimensional.
+-->
+
+## Authority Layers
+<!-- Who is acting? -->
+- founder
+- maintainer
+- contributor
+- agent
+
+## Spatial Contexts
+<!-- Where is behavior happening? -->
+- planning
+- execution
+- deployment
+- governance
+
+## Interpretation Rules
+<!--
+How does context change meaning?
+
+Examples:
+- ambiguity from a founder carries more risk than ambiguity from a contributor
+- weak ownership in deployment is more serious than in planning
+-->
+
+- Replace with an interpretation rule
+
+# Evolution Layer
+<!--
+This section defines:
+- what GOOD behavior looks like
+- what DRIFT looks like
+- what can be OBSERVED
+- how decisions should be made
+- how the model EVOLVES
+
+This is the EXECUTABLE layer.
+-->
+
+## Aligned Behaviors
+<!-- What does success look like in action? -->
+- Replace with an aligned behavior
+
+## Drift Behaviors
+<!-- What does misalignment look like? -->
+- Replace with a drift behavior
+
+## Signals
+<!--
+What can be measured or observed?
+
+Use simple snake_case identifiers:
+- clarity
+- ownership
+- follow_through
+-->
+
+- clarity
+- ownership
+
+## Decision Priorities
+<!--
+What wins when tradeoffs appear?
+
+Format:
+- preferred > secondary
+-->
+
+- quality > speed
+
+## Evolution Conditions
+<!--
+When should the model adapt?
+
+Examples:
+- repeated successful behavior outside assumptions should trigger review
+- persistent drift across scopes should trigger evolution proposal
+-->
+
+- Replace with an evolution condition
+`;
+}
+async function cmdValidate(argv) {
+  const args = parseArgs26(argv);
+  if (args.help || !args.inputPath) {
+    process.stdout.write(
+      "neuroverse worldmodel validate <source.worldmodel.md> [--json]\n"
+    );
+    return;
+  }
+  const content = await readSourceFile(args.inputPath);
+  const result = parseWorldModel(content);
+  const errors = result.issues.filter((i) => i.severity === "error");
+  const warnings = result.issues.filter((i) => i.severity === "warning");
+  const infos = result.issues.filter((i) => i.severity === "info");
+  if (args.json) {
+    const summary2 = result.model ? {
+      valid: errors.length === 0,
+      domains: result.model.geometry.domains.length,
+      overlaps: result.model.geometry.overlapEffects.length,
+      signals: result.model.evolution.signals.length,
+      aligned_behaviors: result.model.evolution.alignedBehaviors.length,
+      drift_behaviors: result.model.evolution.driftBehaviors.length,
+      priorities: result.model.evolution.decisionPriorities.length,
+      errors: errors.length,
+      warnings: warnings.length
+    } : { valid: false, errors: errors.length, warnings: warnings.length };
+    process.stdout.write(
+      JSON.stringify({ summary: summary2, issues: result.issues }, null, 2) + "\n"
+    );
+    process.exit(errors.length > 0 ? 1 : 0);
+    return;
+  }
+  if (errors.length === 0) {
+    process.stderr.write(
+      `${GREEN2}Valid${RESET2} ${args.inputPath}
+`
+    );
+  } else {
+    process.stderr.write(
+      `${RED}Invalid${RESET2} ${args.inputPath}
+`
+    );
+  }
+  if (result.model) {
+    const m = result.model;
+    process.stderr.write(
+      `${DIM2}  Domains: ${m.geometry.domains.length}  Overlaps: ${m.geometry.overlapEffects.length}  Signals: ${m.evolution.signals.length}${RESET2}
+`
+    );
+  }
+  if (result.issues.length > 0) {
+    process.stderr.write("\n");
+    for (const issue of result.issues) {
+      process.stderr.write(formatIssue(issue) + "\n");
+    }
+  }
+  process.exit(errors.length > 0 ? 1 : 0);
+}
+async function cmdExplain(argv) {
+  const args = parseArgs26(argv);
+  if (args.help || !args.inputPath) {
+    process.stdout.write(
+      "neuroverse worldmodel explain <source.worldmodel.md> [--json]\n"
+    );
+    return;
+  }
+  const { model } = await loadAndParse(args.inputPath);
+  if (args.json) {
+    const output = buildExplainData(model);
+    process.stdout.write(JSON.stringify(output, null, 2) + "\n");
+    return;
+  }
+  const out = process.stdout;
+  out.write(`
+${BOLD2}MODEL:${RESET2} ${model.frontmatter.name} (v${model.frontmatter.version})
+
+`);
+  out.write(`${CYAN2}${BOLD2}CORE MODEL GEOMETRY${RESET2}
+`);
+  out.write(`  ${BOLD2}Mission:${RESET2} ${model.geometry.mission}
+`);
+  const domainNames = model.geometry.domains.map((d) => d.name).join(", ");
+  out.write(
+    `  ${BOLD2}Domains (${model.geometry.domains.length}):${RESET2} ${domainNames}
+`
+  );
+  for (const domain of model.geometry.domains) {
+    out.write(`
+  ${MAGENTA2}${domain.name}${RESET2}
+`);
+    if (domain.skills.length > 0) {
+      out.write(`    ${DIM2}Skills:${RESET2} ${domain.skills.join(", ")}
+`);
+    }
+    if (domain.values.length > 0) {
+      out.write(`    ${DIM2}Values:${RESET2} ${domain.values.join(", ")}
+`);
+    }
+  }
+  if (model.geometry.overlapEffects.length > 0) {
+    out.write(`
+  ${BOLD2}Overlaps (${model.geometry.overlapEffects.length}):${RESET2}
+`);
+    for (const o of model.geometry.overlapEffects) {
+      out.write(`    ${o.domainA} + ${o.domainB} = ${GREEN2}${o.effect}${RESET2}
+`);
+    }
+  }
+  if (model.geometry.centerIdentity) {
+    out.write(
+      `
+  ${BOLD2}Center Identity:${RESET2} ${GREEN2}${model.geometry.centerIdentity}${RESET2}
+`
+    );
+  }
+  out.write(`
+${CYAN2}${BOLD2}CONTEXTUAL MODIFIERS${RESET2}
+`);
+  if (model.modifiers.authorityLayers.length > 0) {
+    out.write(
+      `  ${BOLD2}Authority:${RESET2} ${model.modifiers.authorityLayers.join(", ")}
+`
+    );
+  }
+  if (model.modifiers.spatialContexts.length > 0) {
+    out.write(
+      `  ${BOLD2}Spatial:${RESET2} ${model.modifiers.spatialContexts.join(", ")}
+`
+    );
+  }
+  if (model.modifiers.interpretationRules.length > 0) {
+    out.write(
+      `  ${BOLD2}Interpretation Rules:${RESET2} ${model.modifiers.interpretationRules.length} defined
+`
+    );
+    for (const rule of model.modifiers.interpretationRules) {
+      out.write(`    ${DIM2}- ${rule}${RESET2}
+`);
+    }
+  }
+  out.write(`
+${CYAN2}${BOLD2}EVOLUTION LAYER${RESET2}
+`);
+  out.write(
+    `  Aligned behaviors: ${model.evolution.alignedBehaviors.length} defined
+`
+  );
+  out.write(
+    `  Drift behaviors:   ${model.evolution.driftBehaviors.length} defined
+`
+  );
+  out.write(
+    `  Signals:           ${model.evolution.signals.length} tracked
+`
+  );
+  out.write(
+    `  Decision priorities: ${model.evolution.decisionPriorities.length} defined
+`
+  );
+  out.write(
+    `  Evolution conditions: ${model.evolution.evolutionConditions.length} defined
+`
+  );
+  out.write(`
+${DIM2}---${RESET2}
+`);
+  const overlapEffects = model.geometry.overlapEffects.map((o) => o.effect).join(", ");
+  out.write(
+    `
+This model operates across ${model.geometry.domains.length} domains governed by embedded values.
+`
+  );
+  if (overlapEffects) {
+    out.write(
+      `It produces ${GREEN2}${overlapEffects}${RESET2} when domains interact well.
+`
+    );
+  }
+  if (model.evolution.driftBehaviors.length > 0) {
+    const driftSample = model.evolution.driftBehaviors.slice(0, 3).join("; ");
+    out.write(`Drift shows as: ${YELLOW2}${driftSample}${RESET2}.
+`);
+  }
+  if (model.geometry.centerIdentity) {
+    out.write(
+      `When aligned, the system becomes: ${GREEN2}${BOLD2}${model.geometry.centerIdentity}${RESET2}.
+`
+    );
+  }
+  out.write("\n");
+}
+function buildExplainData(model) {
+  return {
+    name: model.frontmatter.name,
+    version: model.frontmatter.version,
+    model_id: model.frontmatter.model_id,
+    geometry: {
+      mission: model.geometry.mission,
+      domains: model.geometry.domains.map((d) => ({
+        name: d.name,
+        skills: d.skills,
+        values: d.values
+      })),
+      overlaps: model.geometry.overlapEffects.map((o) => ({
+        domainA: o.domainA,
+        domainB: o.domainB,
+        effect: o.effect
+      })),
+      centerIdentity: model.geometry.centerIdentity
+    },
+    modifiers: {
+      authority: model.modifiers.authorityLayers,
+      spatial: model.modifiers.spatialContexts,
+      interpretationRules: model.modifiers.interpretationRules.length
+    },
+    evolution: {
+      alignedBehaviors: model.evolution.alignedBehaviors.length,
+      driftBehaviors: model.evolution.driftBehaviors.length,
+      signals: model.evolution.signals,
+      priorities: model.evolution.decisionPriorities.length,
+      evolutionConditions: model.evolution.evolutionConditions.length
+    }
+  };
+}
+async function cmdBuild(argv) {
+  const args = parseArgs26(argv);
+  if (args.help || !args.inputPath) {
+    process.stdout.write(
+      "neuroverse worldmodel build <source.worldmodel.md> [--output <dir>] [--json]\n"
+    );
+    return;
+  }
+  const { model, issues } = await loadAndParse(args.inputPath);
+  const errors = issues.filter((i) => i.severity === "error");
+  if (errors.length > 0) {
+    process.stderr.write(`${RED}Cannot build \u2014 validation errors:${RESET2}
+`);
+    for (const issue of errors) {
+      process.stderr.write(formatIssue(issue) + "\n");
+    }
+    process.exit(1);
+  }
+  const warnings = issues.filter((i) => i.severity === "warning");
+  if (warnings.length > 0) {
+    process.stderr.write(`${YELLOW2}Warnings:${RESET2}
+`);
+    for (const issue of warnings) {
+      process.stderr.write(formatIssue(issue) + "\n");
+    }
+    process.stderr.write("\n");
+  }
+  const output = compileWorldModel(model);
+  const outputDir = (0, import_path12.resolve)(
+    args.output || `.neuroverse/worldmodels/${model.frontmatter.model_id}/`
+  );
+  if (!(0, import_fs11.existsSync)(outputDir)) {
+    await (0, import_promises6.mkdir)(outputDir, { recursive: true });
+  }
+  const worldPath = (0, import_path12.join)(outputDir, `${model.frontmatter.model_id}.nv-world.md`);
+  const signalsPath = (0, import_path12.join)(outputDir, "signals.json");
+  const overlapsPath = (0, import_path12.join)(outputDir, "overlaps.json");
+  const contextsPath = (0, import_path12.join)(outputDir, "contexts.json");
+  const lensesPath = (0, import_path12.join)(outputDir, "lenses.json");
+  await Promise.all([
+    (0, import_promises6.writeFile)(worldPath, output.worldMarkdown, "utf-8"),
+    (0, import_promises6.writeFile)(signalsPath, JSON.stringify(output.signalSchema, null, 2) + "\n", "utf-8"),
+    (0, import_promises6.writeFile)(overlapsPath, JSON.stringify(output.overlapMap, null, 2) + "\n", "utf-8"),
+    (0, import_promises6.writeFile)(contextsPath, JSON.stringify(output.contextsConfig, null, 2) + "\n", "utf-8"),
+    (0, import_promises6.writeFile)(lensesPath, JSON.stringify(output.lensSuggestions, null, 2) + "\n", "utf-8")
+  ]);
+  if (args.json) {
+    process.stdout.write(
+      JSON.stringify(
+        {
+          success: true,
+          outputDir,
+          files: {
+            world: worldPath,
+            signals: signalsPath,
+            overlaps: overlapsPath,
+            contexts: contextsPath,
+            lenses: lensesPath
+          }
+        },
+        null,
+        2
+      ) + "\n"
+    );
+  } else {
+    process.stderr.write(`${GREEN2}Built${RESET2} ${model.frontmatter.name}
+
+`);
+    process.stderr.write(`  ${BOLD2}Output:${RESET2} ${outputDir}/
+`);
+    process.stderr.write(`    ${(0, import_path12.basename)(worldPath)}${DIM2}  \u2014 executable world${RESET2}
+`);
+    process.stderr.write(`    signals.json${DIM2}     \u2014 signal schema${RESET2}
+`);
+    process.stderr.write(`    overlaps.json${DIM2}    \u2014 overlap map${RESET2}
+`);
+    process.stderr.write(`    contexts.json${DIM2}    \u2014 contextual modifiers${RESET2}
+`);
+    process.stderr.write(`    lenses.json${DIM2}      \u2014 lens suggestions${RESET2}
+
+`);
+    const ruleCount = model.evolution.driftBehaviors.length + model.evolution.alignedBehaviors.length + model.evolution.decisionPriorities.length;
+    const invariantCount = model.geometry.domains.reduce(
+      (sum, d) => sum + d.values.length,
+      0
+    );
+    process.stderr.write(
+      `  ${DIM2}${invariantCount} invariants, ${model.evolution.signals.length + 1} state vars, ${ruleCount} rules, 5 gates, ${model.geometry.overlapEffects.length} lenses${RESET2}
+`
+    );
+    process.stderr.write(
+      `
+  ${DIM2}Next: neuroverse bootstrap --input ${worldPath} --output ${outputDir}${RESET2}
+`
+    );
+  }
+}
+async function cmdEmitWorld(argv) {
+  const args = parseArgs26(argv);
+  if (args.help || !args.inputPath) {
+    process.stdout.write("neuroverse worldmodel emit-world <source.worldmodel.md>\n");
+    return;
+  }
+  const { model } = await loadAndParse(args.inputPath);
+  const markdown = emitWorldMarkdown(model);
+  if (args.output) {
+    const dir = (0, import_path12.dirname)((0, import_path12.resolve)(args.output));
+    if (!(0, import_fs11.existsSync)(dir)) await (0, import_promises6.mkdir)(dir, { recursive: true });
+    await (0, import_promises6.writeFile)((0, import_path12.resolve)(args.output), markdown, "utf-8");
+    process.stderr.write(`${GREEN2}Written${RESET2} ${args.output}
+`);
+  } else {
+    process.stdout.write(markdown);
+  }
+}
+async function cmdEmitSignals(argv) {
+  const args = parseArgs26(argv);
+  if (args.help || !args.inputPath) {
+    process.stdout.write(
+      "neuroverse worldmodel emit-signals <source.worldmodel.md> [--json]\n"
+    );
+    return;
+  }
+  const { model } = await loadAndParse(args.inputPath);
+  const schema = emitSignalSchema(model);
+  process.stdout.write(JSON.stringify(schema, null, 2) + "\n");
+}
+async function cmdEmitLenses(argv) {
+  const args = parseArgs26(argv);
+  if (args.help || !args.inputPath) {
+    process.stdout.write(
+      "neuroverse worldmodel emit-lenses <source.worldmodel.md> [--json]\n"
+    );
+    return;
+  }
+  const { model } = await loadAndParse(args.inputPath);
+  const lenses = emitLensSuggestions(model);
+  process.stdout.write(JSON.stringify(lenses, null, 2) + "\n");
+}
+async function cmdEmitContexts(argv) {
+  const args = parseArgs26(argv);
+  if (args.help || !args.inputPath) {
+    process.stdout.write(
+      "neuroverse worldmodel emit-contexts <source.worldmodel.md> [--json]\n"
+    );
+    return;
+  }
+  const { model } = await loadAndParse(args.inputPath);
+  const contexts = emitContextsConfig(model);
+  process.stdout.write(JSON.stringify(contexts, null, 2) + "\n");
+}
+async function cmdEmitOverlaps(argv) {
+  const args = parseArgs26(argv);
+  if (args.help || !args.inputPath) {
+    process.stdout.write(
+      "neuroverse worldmodel emit-overlaps <source.worldmodel.md> [--json]\n"
+    );
+    return;
+  }
+  const { model } = await loadAndParse(args.inputPath);
+  const overlaps = emitOverlapMap(model);
+  process.stdout.write(JSON.stringify(overlaps, null, 2) + "\n");
+}
+async function main33(argv = process.argv.slice(2)) {
+  const subcommand = argv[0] ?? "";
+  const subArgs = argv.slice(1);
+  switch (subcommand) {
+    case "init":
+      return cmdInit(subArgs);
+    case "validate":
+      return cmdValidate(subArgs);
+    case "explain":
+      return cmdExplain(subArgs);
+    case "build":
+      return cmdBuild(subArgs);
+    case "emit-world":
+      return cmdEmitWorld(subArgs);
+    case "emit-signals":
+      return cmdEmitSignals(subArgs);
+    case "emit-lenses":
+      return cmdEmitLenses(subArgs);
+    case "emit-contexts":
+      return cmdEmitContexts(subArgs);
+    case "emit-overlaps":
+      return cmdEmitOverlaps(subArgs);
+    case "--help":
+    case "-h":
+    case "help":
+    case "":
+      process.stdout.write(USAGE9 + "\n");
+      break;
+    default:
+      process.stderr.write(`Unknown worldmodel command: "${subcommand}"
+
+`);
+      process.stdout.write(USAGE9 + "\n");
+      process.exit(1);
+  }
+}
+var import_promises6, import_fs11, import_path12, BOLD2, DIM2, CYAN2, GREEN2, YELLOW2, RED, MAGENTA2, RESET2, USAGE9;
+var init_worldmodel = __esm({
+  "src/cli/worldmodel.ts"() {
+    "use strict";
+    import_promises6 = require("fs/promises");
+    import_fs11 = require("fs");
+    import_path12 = require("path");
+    init_worldmodel_parser();
+    init_worldmodel_compiler();
+    BOLD2 = "\x1B[1m";
+    DIM2 = "\x1B[2m";
+    CYAN2 = "\x1B[36m";
+    GREEN2 = "\x1B[32m";
+    YELLOW2 = "\x1B[33m";
+    RED = "\x1B[31m";
+    MAGENTA2 = "\x1B[35m";
+    RESET2 = "\x1B[0m";
+    USAGE9 = `
+neuroverse worldmodel \u2014 Behavioral world model toolkit
+
+  ${BOLD2}This file defines how a system behaves, how that behavior
+  is interpreted, and how it evolves over time.${RESET2}
+
+Commands:
+  init           Scaffold a new .worldmodel.md template
+  validate       Check structure and completeness
+  explain        Human-readable model summary
+  build          Compile to .nv-world.md + signals + overlaps + contexts + lenses
+  emit-world     Emit compiled .nv-world.md to stdout
+  emit-signals   Emit signal schema JSON to stdout
+  emit-lenses    Emit lens suggestions JSON to stdout
+  emit-contexts  Emit contextual modifiers JSON to stdout
+  emit-overlaps  Emit overlap map JSON to stdout
+
+Usage:
+  neuroverse worldmodel init [--name "Name"] [--output path]
+  neuroverse worldmodel validate <source.worldmodel.md> [--json]
+  neuroverse worldmodel explain <source.worldmodel.md> [--json]
+  neuroverse worldmodel build <source.worldmodel.md> [--output <dir>]
+  neuroverse worldmodel emit-world <source.worldmodel.md>
+  neuroverse worldmodel emit-signals <source.worldmodel.md> [--json]
+  neuroverse worldmodel emit-lenses <source.worldmodel.md> [--json]
+  neuroverse worldmodel emit-contexts <source.worldmodel.md> [--json]
+  neuroverse worldmodel emit-overlaps <source.worldmodel.md> [--json]
+
+Examples:
+  neuroverse worldmodel init --name "Auki Vanguard"
+  neuroverse worldmodel build ./auki-vanguard.worldmodel.md --output ./world/
+  neuroverse worldmodel explain ./auki-vanguard.worldmodel.md
+`.trim();
+  }
+});
+
+// src/cli/neuroverse.ts
+var USAGE10 = `
+neuroverse \u2014 Turn ideas into worlds.
+
+Commands:
+  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
+  validate       Static analysis on world files
+  guard          Runtime governance evaluation (stdin \u2192 stdout)
+  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)
+  keygen         Generate Ed25519 signing keypair
+  sign           Sign a world artifact (cryptographic manifest)
+  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
+
+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
+  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() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+  const subArgs = args.slice(1);
+  switch (command) {
+    case "add": {
+      const { main: addMain } = await Promise.resolve().then(() => (init_add(), add_exports));
+      return addMain(subArgs);
+    }
+    case "build": {
+      const { main: buildMain } = await Promise.resolve().then(() => (init_build(), build_exports));
+      return buildMain(subArgs);
+    }
+    case "explain": {
+      const { main: explainMain } = await Promise.resolve().then(() => (init_explain(), explain_exports));
+      return explainMain(subArgs);
+    }
+    case "simulate": {
+      const { main: simulateMain } = await Promise.resolve().then(() => (init_simulate(), simulate_exports));
+      return simulateMain(subArgs);
+    }
+    case "improve": {
+      const { main: improveMain } = await Promise.resolve().then(() => (init_improve(), improve_exports));
+      return improveMain(subArgs);
+    }
+    case "init": {
+      const { main: initMain } = await Promise.resolve().then(() => (init_init(), init_exports));
+      return initMain(subArgs);
     }
     case "init-world": {
       const { main: initWorldMain } = await Promise.resolve().then(() => (init_init_world(), init_world_exports));
@@ -18434,11 +20114,15 @@ async function main33() {
       const { main: lensMain } = await Promise.resolve().then(() => (init_lens2(), lens_exports));
       return lensMain(subArgs);
     }
+    case "worldmodel": {
+      const { main: worldmodelMain } = await Promise.resolve().then(() => (init_worldmodel(), worldmodel_exports));
+      return worldmodelMain(subArgs);
+    }
     case "--help":
     case "-h":
     case "help":
     case void 0: {
-      process.stdout.write(USAGE9 + "\n");
+      process.stdout.write(USAGE10 + "\n");
       process.exit(0);
       break;
     }
@@ -18446,12 +20130,12 @@ async function main33() {
       process.stderr.write(`Unknown command: "${command}"
 
 `);
-      process.stdout.write(USAGE9 + "\n");
+      process.stdout.write(USAGE10 + "\n");
       process.exit(1);
     }
   }
 }
-main33().catch((e) => {
+main34().catch((e) => {
   process.stderr.write(`Fatal: ${e}
 `);
   process.exit(3);