@neuroverseos/governance 0.5.0 → 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: join9 } = await import("path");
-  const { readdirSync: readdirSync5 } = await import("fs");
+  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 = join9(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 = join9(dirPath, "rules");
-    const ruleFiles = readdirSync5(rulesDir).filter((f) => f.endsWith(".json")).sort();
+    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(join9(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: join9, dirname: dirname3 } = await import("path");
-  const { existsSync: existsSync6 } = 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 = join9(thisFile, "..", "..");
+    const thisFile = typeof __dirname !== "undefined" ? __dirname : dirname4(fileURLToPath3(import_meta.url));
+    packageRoot = join14(thisFile, "..", "..");
   } catch {
     packageRoot = process.cwd();
   }
   const candidates = [
-    join9(packageRoot, "dist", "worlds", filename),
-    join9(packageRoot, "src", "worlds", filename)
+    join14(packageRoot, "dist", "worlds", filename),
+    join14(packageRoot, "src", "worlds", filename)
   ];
   for (const candidate of candidates) {
-    if (existsSync6(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: join9 } = await import("path");
-  const guardsPath = join9(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,14 +2181,14 @@ async function addGuard(worldDir, input) {
   };
 }
 async function addRule(worldDir, input) {
-  const { readFile: readFile3, writeFile: writeFile5, mkdir: mkdir2 } = await import("fs/promises");
-  const { join: join9 } = await import("path");
-  const { readdirSync: readdirSync5 } = await import("fs");
-  const rulesDir = join9(worldDir, "rules");
-  await mkdir2(rulesDir, { recursive: true });
+  const { readFile: readFile4, writeFile: writeFile6, mkdir: mkdir3 } = await import("fs/promises");
+  const { join: join14 } = await import("path");
+  const { readdirSync: readdirSync6 } = await import("fs");
+  const rulesDir = join14(worldDir, "rules");
+  await mkdir3(rulesDir, { recursive: true });
   let nextNum = 1;
   try {
-    const existing = readdirSync5(rulesDir).filter((f) => f.match(/^rule-\d+\.json$/)).sort();
+    const existing = readdirSync6(rulesDir).filter((f) => f.match(/^rule-\d+\.json$/)).sort();
     if (existing.length > 0) {
       const lastFile = existing[existing.length - 1];
       const match = lastFile.match(/rule-(\d+)\.json/);
@@ -2214,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 = join9(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: join9 } = await import("path");
-  const invariantsPath = join9(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: basename2 } = 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: basename2(inputPath), content }];
+    return [{ filename: basename4(inputPath), content }];
   }
   if (stats.isDirectory()) {
     const sources = [];
-    await collectDir(inputPath, sources, rf, pathJoin, extname2, basename2);
+    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, basename2) {
+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, basename2);
+      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: join9 } = await import("path");
-  await mkdir2(outputDir, { recursive: true });
-  await writeFile5(join9(outputDir, "world.json"), JSON.stringify(world.world, null, 2));
-  await writeFile5(join9(outputDir, "invariants.json"), JSON.stringify({ invariants: world.invariants }, null, 2));
-  await writeFile5(join9(outputDir, "assumptions.json"), JSON.stringify(world.assumptions, null, 2));
-  await writeFile5(join9(outputDir, "state-schema.json"), JSON.stringify(world.stateSchema, null, 2));
-  await writeFile5(join9(outputDir, "gates.json"), JSON.stringify(world.gates, null, 2));
-  await writeFile5(join9(outputDir, "outcomes.json"), JSON.stringify(world.outcomes, null, 2));
-  await writeFile5(join9(outputDir, "metadata.json"), JSON.stringify(world.metadata, null, 2));
-  const rulesDir = join9(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(join9(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: basename2 } = await import("path");
+    const { basename: basename4 } = await import("path");
     write(`
 NeuroVerse World Builder
 `);
     write(`
-Analyzing: ${basename2(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: ${basename2(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: join9 } = await import("path");
+      const { join: join14 } = await import("path");
       const { copyFile } = await import("fs/promises");
-      const sourceDest = join9(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: existsSync6 } = await import("fs");
-    if (existsSync6(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: join9 } = await import("path");
-  await mkdir2(outputDir, { recursive: true });
-  await writeFile5(join9(outputDir, "world.json"), JSON.stringify(world.world, null, 2));
-  await writeFile5(join9(outputDir, "invariants.json"), JSON.stringify({ invariants: world.invariants }, null, 2));
-  await writeFile5(join9(outputDir, "assumptions.json"), JSON.stringify(world.assumptions, null, 2));
-  await writeFile5(join9(outputDir, "state-schema.json"), JSON.stringify(world.stateSchema, null, 2));
-  const rulesDir = join9(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(join9(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(join9(outputDir, "gates.json"), JSON.stringify(world.gates, null, 2));
-  await writeFile5(join9(outputDir, "outcomes.json"), JSON.stringify(world.outcomes, null, 2));
-  await writeFile5(join9(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");
@@ -7364,6 +7364,162 @@ var init_guard_contract = __esm({
   }
 });
 
+// src/engine/audit-logger.ts
+function verdictToAuditEvent(event, verdict) {
+  const auditEvent = {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    worldId: verdict.evidence.worldId,
+    worldName: verdict.evidence.worldName,
+    worldVersion: verdict.evidence.worldVersion,
+    intent: event.intent,
+    tool: event.tool,
+    scope: event.scope,
+    actor: event.roleId,
+    direction: event.direction,
+    decision: verdict.status,
+    reason: verdict.reason,
+    ruleId: verdict.ruleId,
+    warning: verdict.warning,
+    guardsMatched: verdict.evidence.guardsMatched,
+    rulesMatched: verdict.evidence.rulesMatched,
+    invariantsSatisfied: verdict.evidence.invariantsSatisfied,
+    invariantsTotal: verdict.evidence.invariantsTotal,
+    enforcementLevel: verdict.evidence.enforcementLevel,
+    durationMs: verdict.trace?.durationMs,
+    args: event.args
+  };
+  if (verdict.consequence) {
+    auditEvent.consequence = verdict.consequence;
+  }
+  if (verdict.reward) {
+    auditEvent.reward = verdict.reward;
+  }
+  if (verdict.intentRecord) {
+    auditEvent.originalIntent = verdict.intentRecord.originalIntent;
+    auditEvent.finalAction = verdict.intentRecord.finalAction;
+  }
+  return auditEvent;
+}
+async function readAuditLog(logPath, filter) {
+  const { readFile: readFile4 } = await import("fs/promises");
+  let content;
+  try {
+    content = await readFile4(logPath, "utf-8");
+  } catch {
+    return [];
+  }
+  const events = [];
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const event = JSON.parse(trimmed);
+      if (!filter || filter(event)) {
+        events.push(event);
+      }
+    } catch {
+    }
+  }
+  return events;
+}
+function summarizeAuditEvents(events) {
+  const allowed = events.filter((e) => e.decision === "ALLOW").length;
+  const blocked = events.filter((e) => e.decision === "BLOCK").length;
+  const paused = events.filter((e) => e.decision === "PAUSE").length;
+  const modified = events.filter((e) => e.decision === "MODIFY").length;
+  const penalized = events.filter((e) => e.decision === "PENALIZE").length;
+  const rewarded = events.filter((e) => e.decision === "REWARD").length;
+  const neutral = events.filter((e) => e.decision === "NEUTRAL").length;
+  const actorSet = /* @__PURE__ */ new Set();
+  for (const e of events) {
+    if (e.actor) actorSet.add(e.actor);
+  }
+  const intentMap = /* @__PURE__ */ new Map();
+  for (const e of events) {
+    const entry = intentMap.get(e.intent) ?? { count: 0, blocked: 0, paused: 0, penalized: 0, rewarded: 0 };
+    entry.count++;
+    if (e.decision === "BLOCK") entry.blocked++;
+    if (e.decision === "PAUSE") entry.paused++;
+    if (e.decision === "PENALIZE") entry.penalized++;
+    if (e.decision === "REWARD") entry.rewarded++;
+    intentMap.set(e.intent, entry);
+  }
+  const topIntents = [...intentMap.entries()].map(([intent, data]) => ({ intent, ...data })).sort((a, b) => b.count - a.count);
+  const ruleMap = /* @__PURE__ */ new Map();
+  for (const e of events) {
+    if (e.ruleId) {
+      ruleMap.set(e.ruleId, (ruleMap.get(e.ruleId) ?? 0) + 1);
+    }
+    for (const g of e.guardsMatched) {
+      ruleMap.set(g, (ruleMap.get(g) ?? 0) + 1);
+    }
+  }
+  const topRules = [...ruleMap.entries()].map(([ruleId, count]) => ({ ruleId, count })).sort((a, b) => b.count - a.count);
+  const redirected = blocked + paused + modified + penalized;
+  const total = events.length;
+  return {
+    totalActions: total,
+    allowed,
+    blocked,
+    paused,
+    modified,
+    penalized,
+    rewarded,
+    neutral,
+    actors: [...actorSet],
+    topIntents,
+    topRules,
+    firstEvent: events[0]?.timestamp ?? "",
+    lastEvent: events[events.length - 1]?.timestamp ?? "",
+    behavioralEconomy: {
+      totalPenalties: penalized,
+      totalRewards: rewarded,
+      netPressure: rewarded - penalized,
+      redirectionRate: total > 0 ? redirected / total : 0
+    }
+  };
+}
+var FileAuditLogger;
+var init_audit_logger = __esm({
+  "src/engine/audit-logger.ts"() {
+    "use strict";
+    init_guard_engine();
+    FileAuditLogger = class {
+      logPath;
+      buffer = [];
+      flushTimer = null;
+      flushIntervalMs;
+      constructor(logPath, options) {
+        this.logPath = logPath;
+        this.flushIntervalMs = options?.flushIntervalMs ?? 1e3;
+      }
+      log(event) {
+        this.buffer.push(JSON.stringify(event));
+        if (!this.flushTimer) {
+          this.flushTimer = setTimeout(() => {
+            void this.flush();
+          }, this.flushIntervalMs);
+        }
+      }
+      async flush() {
+        if (this.buffer.length === 0) return;
+        if (this.flushTimer) {
+          clearTimeout(this.flushTimer);
+          this.flushTimer = null;
+        }
+        const lines = this.buffer.splice(0).join("\n") + "\n";
+        try {
+          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 {
+        }
+      }
+    };
+  }
+});
+
 // src/cli/guard.ts
 var guard_exports = {};
 __export(guard_exports, {
@@ -7374,6 +7530,7 @@ function parseArgs11(argv) {
   let trace = false;
   let level;
   let aiClassify = false;
+  let logPath;
   for (let i = 0; i < argv.length; i++) {
     const arg = argv[i];
     if (arg === "--world" && i + 1 < argv.length) {
@@ -7382,6 +7539,8 @@ function parseArgs11(argv) {
       trace = true;
     } else if (arg === "--ai-classify") {
       aiClassify = true;
+    } else if (arg === "--log" && i + 1 < argv.length) {
+      logPath = argv[++i];
     } else if (arg === "--level" && i + 1 < argv.length) {
       const val = argv[++i];
       if (val === "basic" || val === "standard" || val === "strict") {
@@ -7391,7 +7550,7 @@ function parseArgs11(argv) {
       }
     }
   }
-  return { worldPath, trace, level, aiClassify };
+  return { worldPath, trace, level, aiClassify, logPath };
 }
 async function main11(argv = process.argv.slice(2)) {
   try {
@@ -7451,6 +7610,11 @@ async function main11(argv = process.argv.slice(2)) {
       const options = { trace: args.trace, level: args.level };
       verdict = evaluateGuard(event, world, options);
     }
+    if (args.logPath) {
+      const logger = new FileAuditLogger(args.logPath, { flushIntervalMs: 0 });
+      logger.log(verdictToAuditEvent(event, verdict));
+      await logger.flush();
+    }
     process.stdout.write(JSON.stringify(verdict, null, 2) + "\n");
     const exitCode = GUARD_EXIT_CODES[verdict.status];
     process.exit(exitCode);
@@ -7479,6 +7643,7 @@ var init_guard = __esm({
     init_world_resolver();
     init_guard_contract();
     init_cli_utils();
+    init_audit_logger();
   }
 });
 
@@ -8076,14 +8241,14 @@ function handleHealthCheck() {
   };
 }
 async function handleListPresets(policiesDir) {
-  const { readdir, readFile: readFile3 } = await import("fs/promises");
-  const { join: join9 } = await import("path");
-  const dir = policiesDir ?? join9(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(join9(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) ?? "";
@@ -8154,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: join9 } = 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",
@@ -8197,9 +8362,9 @@ async function writeTempWorld(dir, policyLines) {
     authoring_method: "manual-authoring"
   };
   await Promise.all([
-    writeFile5(join9(dir, "world.json"), JSON.stringify(worldJson, null, 2)),
-    writeFile5(join9(dir, "kernel.json"), JSON.stringify(kernelJson, null, 2)),
-    writeFile5(join9(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({
@@ -8543,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);
     });
   }
@@ -9544,84 +9709,503 @@ var init_express = __esm({
   }
 });
 
-// src/adapters/langchain.ts
-var langchain_exports = {};
-__export(langchain_exports, {
-  GovernanceBlockedError: () => GovernanceBlockedError3,
-  NeuroVerseCallbackHandler: () => NeuroVerseCallbackHandler,
-  createNeuroVerseCallbackHandler: () => createNeuroVerseCallbackHandler,
-  createNeuroVerseCallbackHandlerFromWorld: () => createNeuroVerseCallbackHandlerFromWorld
+// src/adapters/github.ts
+var github_exports = {};
+__export(github_exports, {
+  GitHubGovernanceBlockedError: () => GitHubGovernanceBlockedError,
+  GitHubGovernor: () => GitHubGovernor,
+  GitHubWebhookHandler: () => GitHubWebhookHandler,
+  createGitHubGovernor: () => createGitHubGovernor,
+  createGitHubGovernorFromWorld: () => createGitHubGovernorFromWorld,
+  createGitHubWebhookHandler: () => createGitHubWebhookHandler,
+  createGitHubWebhookHandlerFromWorld: () => createGitHubWebhookHandlerFromWorld,
+  formatForActions: () => formatForActions,
+  formatPRComment: () => formatPRComment
 });
-function defaultMapToolCall2(toolName, toolInput) {
+function extractBranch(ref) {
+  if (!ref) return void 0;
+  if (ref.startsWith("refs/heads/")) return ref.slice("refs/heads/".length);
+  if (ref.startsWith("refs/tags/")) return ref.slice("refs/tags/".length);
+  return ref;
+}
+function isProtectedBranch(branch, protectedBranches) {
+  if (!branch) return false;
+  return protectedBranches.some(
+    (pb) => branch === pb || branch.startsWith(`${pb}/`)
+  );
+}
+function defaultMapAction(action, protectedBranches, restrictedActors) {
+  const branch = action.branch ?? extractBranch(action.ref);
+  const isProtected = isProtectedBranch(branch, protectedBranches);
+  const isRestricted = action.actor ? restrictedActors.some((ra) => action.actor === ra || action.actor?.endsWith("[bot]")) : false;
+  let actionCategory = "other";
+  const act = action.action.toLowerCase();
+  if (act.includes("read") || act.includes("get") || act.includes("list") || act.includes("view")) {
+    actionCategory = "read";
+  } else if (act.includes("delete") || act.includes("remove") || act.includes("close")) {
+    actionCategory = "delete";
+  } else if (act.includes("deploy") || act.includes("run") || act.includes("execute") || act.includes("merge")) {
+    actionCategory = "network";
+  } else if (act.includes("create") || act.includes("push") || act.includes("write") || act.includes("update") || act.includes("edit")) {
+    actionCategory = "write";
+  } else if (act.includes("comment") || act.includes("review") || act.includes("notify")) {
+    actionCategory = "other";
+  }
   return {
-    intent: toolName,
-    tool: toolName,
-    scope: extractScope(toolInput),
-    args: toolInput,
-    direction: "input"
+    intent: action.action,
+    tool: "github",
+    scope: `${action.repository}${branch ? `@${branch}` : ""}`,
+    actionCategory,
+    direction: "input",
+    args: {
+      repository: action.repository,
+      ref: action.ref,
+      branch,
+      actor: action.actor,
+      protected_branch: isProtected,
+      restricted_actor: isRestricted,
+      ...action.metadata
+    }
   };
 }
-async function createNeuroVerseCallbackHandler(worldPath, options) {
+function defaultMapWebhook(eventType, payload) {
+  const repo = payload.repository;
+  const repoFullName = repo?.full_name ?? "unknown/unknown";
+  const sender = payload.sender;
+  const actor = sender?.login ?? void 0;
+  const webhookAction = payload.action;
+  switch (eventType) {
+    case "push": {
+      const ref = payload.ref;
+      const branch = extractBranch(ref);
+      const forced = payload.forced;
+      return {
+        action: forced ? "force_push" : `push_to_${branch ?? "branch"}`,
+        repository: repoFullName,
+        ref,
+        branch,
+        actor,
+        metadata: {
+          forced: forced ?? false,
+          commits_count: payload.commits?.length ?? 0,
+          head_commit: payload.head_commit?.id
+        }
+      };
+    }
+    case "pull_request": {
+      const pr = payload.pull_request;
+      const base = pr?.base;
+      const baseBranch = base?.ref;
+      const prNumber = pr?.number;
+      const merged = pr?.merged;
+      const labels = pr?.labels?.map((l) => l.name) ?? [];
+      let action = `pull_request_${webhookAction ?? "unknown"}`;
+      if (webhookAction === "closed" && merged) {
+        action = "merge_pull_request";
+      }
+      return {
+        action,
+        repository: repoFullName,
+        branch: baseBranch,
+        actor,
+        metadata: {
+          pr_number: prNumber,
+          labels,
+          merged: merged ?? false,
+          draft: pr?.draft ?? false,
+          webhook_action: webhookAction
+        }
+      };
+    }
+    case "release": {
+      const release = payload.release;
+      return {
+        action: `release_${webhookAction ?? "published"}`,
+        repository: repoFullName,
+        ref: release?.tag_name ? `refs/tags/${release.tag_name}` : void 0,
+        actor,
+        metadata: {
+          tag: release?.tag_name,
+          prerelease: release?.prerelease ?? false,
+          draft: release?.draft ?? false,
+          webhook_action: webhookAction
+        }
+      };
+    }
+    case "deployment":
+    case "deployment_status": {
+      const deployment = payload.deployment ?? payload;
+      return {
+        action: eventType === "deployment" ? "create_deployment" : "deployment_status_update",
+        repository: repoFullName,
+        ref: deployment.ref,
+        actor,
+        metadata: {
+          environment: deployment.environment,
+          status: payload.deployment_status?.state,
+          webhook_action: webhookAction
+        }
+      };
+    }
+    case "workflow_run": {
+      const run = payload.workflow_run;
+      return {
+        action: `workflow_${webhookAction ?? "completed"}`,
+        repository: repoFullName,
+        branch: run?.head_branch,
+        actor,
+        metadata: {
+          workflow_name: run?.name,
+          conclusion: run?.conclusion,
+          status: run?.status,
+          webhook_action: webhookAction
+        }
+      };
+    }
+    case "issues": {
+      const issue = payload.issue;
+      return {
+        action: `issue_${webhookAction ?? "opened"}`,
+        repository: repoFullName,
+        actor,
+        metadata: {
+          issue_number: issue?.number,
+          labels: issue?.labels?.map((l) => l.name) ?? [],
+          webhook_action: webhookAction
+        }
+      };
+    }
+    case "issue_comment": {
+      return {
+        action: `issue_comment_${webhookAction ?? "created"}`,
+        repository: repoFullName,
+        actor,
+        metadata: {
+          issue_number: payload.issue?.number,
+          webhook_action: webhookAction
+        }
+      };
+    }
+    case "delete": {
+      return {
+        action: `delete_${payload.ref_type ?? "ref"}`,
+        repository: repoFullName,
+        ref: payload.ref,
+        actor,
+        metadata: {
+          ref_type: payload.ref_type
+        }
+      };
+    }
+    default: {
+      return {
+        action: webhookAction ? `${eventType}_${webhookAction}` : eventType,
+        repository: repoFullName,
+        actor,
+        metadata: { webhook_action: webhookAction }
+      };
+    }
+  }
+}
+function formatForActions(verdict) {
+  const status = verdict.status === "ALLOW" ? "allowed" : verdict.status === "BLOCK" ? "blocked" : "paused";
+  const reason = verdict.reason ?? "";
+  const ruleId = verdict.ruleId ?? "";
+  const lines = [
+    `governance_status=${status}`,
+    `verdict_status=${verdict.status}`,
+    `reason=${reason}`,
+    `rule_id=${ruleId}`
+  ].join("\n");
+  return {
+    governance_status: status,
+    verdict_status: verdict.status,
+    reason,
+    rule_id: ruleId,
+    outputLines: lines
+  };
+}
+function formatPRComment(verdict, action) {
+  const icon = verdict.status === "ALLOW" ? "\u2705" : verdict.status === "BLOCK" ? "\u{1F6AB}" : "\u23F8\uFE0F";
+  const status = verdict.status;
+  let body = `## ${icon} Governance: ${status}
+
+`;
+  body += `**Action:** \`${action.action}\`
+`;
+  body += `**Repository:** \`${action.repository}\`
+`;
+  if (action.branch) {
+    body += `**Branch:** \`${action.branch}\`
+`;
+  }
+  if (action.actor) {
+    body += `**Actor:** \`${action.actor}\`
+`;
+  }
+  body += "\n";
+  if (verdict.reason) {
+    body += `**Reason:** ${verdict.reason}
+`;
+  }
+  if (verdict.ruleId) {
+    body += `**Rule:** \`${verdict.ruleId}\`
+`;
+  }
+  if (verdict.evidence?.invariantsSatisfied < verdict.evidence?.invariantsTotal) {
+    body += `**Invariants:** ${verdict.evidence.invariantsSatisfied}/${verdict.evidence.invariantsTotal} satisfied
+`;
+  }
+  body += "\n---\n*Evaluated by [NeuroVerse Governance](https://github.com/NeuroverseOS/neuroverseos-governance)*";
+  return body;
+}
+async function createGitHubGovernor(worldPath, options) {
   const world = await loadWorld(worldPath);
-  return new NeuroVerseCallbackHandler(world, options);
+  return new GitHubGovernor(world, options);
 }
-function createNeuroVerseCallbackHandlerFromWorld(world, options) {
-  return new NeuroVerseCallbackHandler(world, options);
+function createGitHubGovernorFromWorld(world, options) {
+  return new GitHubGovernor(world, options);
 }
-var GovernanceBlockedError3, NeuroVerseCallbackHandler;
-var init_langchain = __esm({
-  "src/adapters/langchain.ts"() {
+async function createGitHubWebhookHandler(worldPath, options) {
+  const world = await loadWorld(worldPath);
+  return new GitHubWebhookHandler(world, options);
+}
+function createGitHubWebhookHandlerFromWorld(world, options) {
+  return new GitHubWebhookHandler(world, options);
+}
+var GitHubGovernanceBlockedError, GitHubGovernor, GitHubWebhookHandler;
+var init_github = __esm({
+  "src/adapters/github.ts"() {
     "use strict";
     init_guard_engine();
     init_world_loader();
     init_shared();
-    GovernanceBlockedError3 = class extends GovernanceBlockedError {
-      event;
-      constructor(verdict, event) {
-        super(verdict);
-        this.event = event;
+    GitHubGovernanceBlockedError = class extends GovernanceBlockedError {
+      action;
+      constructor(verdict, action) {
+        super(verdict, `[NeuroVerse] GitHub action blocked: ${action.action} on ${action.repository}`);
+        this.name = "GitHubGovernanceBlockedError";
+        this.action = action;
       }
     };
-    NeuroVerseCallbackHandler = class {
-      name = "NeuroVerseGovernance";
+    GitHubGovernor = class {
       world;
       options;
       engineOptions;
-      mapToolCall;
       activePlan;
+      protectedBranches;
+      restrictedActors;
+      mapFn;
       constructor(world, options = {}) {
         this.world = world;
         this.options = options;
         this.activePlan = options.plan;
         this.engineOptions = buildEngineOptions(options, this.activePlan);
-        this.mapToolCall = options.mapToolCall ?? defaultMapToolCall2;
+        this.protectedBranches = options.protectedBranches ?? ["main", "master", "production"];
+        this.restrictedActors = options.restrictedActors ?? [];
+        this.mapFn = options.mapAction ?? ((action) => defaultMapAction(action, this.protectedBranches, this.restrictedActors));
       }
       /**
-       * Called before a tool is executed.
-       * Evaluates the tool call against the governance world.
-       *
-       * @throws GovernanceBlockedError if the action is BLOCKED
-       * @throws GovernanceBlockedError if the action is PAUSED and onPause returns false
+       * Evaluate a GitHub action against governance rules.
+       * Returns a full result with verdict, event, and the original action.
        */
-      async handleToolStart(tool, input) {
-        let parsedInput;
-        try {
-          parsedInput = typeof input === "string" ? JSON.parse(input) : input;
-        } catch {
-          parsedInput = { raw: input };
-        }
-        const event = this.mapToolCall(tool.name, parsedInput);
+      evaluate(action) {
+        const event = this.mapFn(action);
         this.engineOptions.plan = this.activePlan;
         const verdict = evaluateGuard(event, this.world, this.engineOptions);
-        this.options.onEvaluate?.(verdict, event);
-        if (verdict.status === "BLOCK") {
-          this.options.onBlock?.(verdict, event);
-          throw new GovernanceBlockedError3(verdict, event);
+        this.options.onEvaluate?.(verdict, event, action);
+        if (verdict.status === "ALLOW") {
+          trackPlanProgress(event, this, this.options);
         }
-        if (verdict.status === "PAUSE") {
-          const approved = await this.options.onPause?.(verdict, event);
-          if (!approved) {
-            throw new GovernanceBlockedError3(verdict, event);
+        return { verdict, event, action };
+      }
+      /**
+       * Evaluate and enforce — throws GitHubGovernanceBlockedError on BLOCK/PAUSE.
+       * Use this as a gate before executing GitHub API calls.
+       */
+      enforce(action) {
+        const result = this.evaluate(action);
+        if (result.verdict.status === "BLOCK" || result.verdict.status === "PAUSE") {
+          throw new GitHubGovernanceBlockedError(result.verdict, action);
+        }
+        return result;
+      }
+      /**
+       * Check if pushing to a branch is allowed.
+       * Convenience method for the most common governance check.
+       */
+      canPush(repository, branch, actor) {
+        return this.evaluate({
+          action: `push_to_${branch}`,
+          repository,
+          ref: `refs/heads/${branch}`,
+          branch,
+          actor
+        }).verdict;
+      }
+      /**
+       * Check if merging a PR is allowed.
+       */
+      canMerge(repository, targetBranch, prNumber, actor, labels) {
+        return this.evaluate({
+          action: "merge_pull_request",
+          repository,
+          branch: targetBranch,
+          actor,
+          metadata: { pr_number: prNumber, labels: labels ?? [] }
+        }).verdict;
+      }
+      /**
+       * Check if creating a release is allowed.
+       */
+      canRelease(repository, tag, actor, prerelease) {
+        return this.evaluate({
+          action: "release_published",
+          repository,
+          ref: `refs/tags/${tag}`,
+          actor,
+          metadata: { tag, prerelease: prerelease ?? false }
+        }).verdict;
+      }
+      /**
+       * Check if deploying to an environment is allowed.
+       */
+      canDeploy(repository, environment, ref, actor) {
+        return this.evaluate({
+          action: "create_deployment",
+          repository,
+          ref,
+          actor,
+          metadata: { environment }
+        }).verdict;
+      }
+    };
+    GitHubWebhookHandler = class {
+      governor;
+      mapWebhookFn;
+      webhookSecret;
+      constructor(world, options = {}) {
+        this.governor = new GitHubGovernor(world, options);
+        this.mapWebhookFn = options.mapWebhook ?? defaultMapWebhook;
+        this.webhookSecret = options.webhookSecret;
+      }
+      /**
+       * Evaluate a webhook payload.
+       *
+       * @param eventType - The X-GitHub-Event header value
+       * @param payload - The parsed webhook body
+       */
+      evaluate(eventType, payload) {
+        const action = this.mapWebhookFn(eventType, payload);
+        const result = this.governor.evaluate(action);
+        return {
+          verdict: result.verdict,
+          event: result.event,
+          webhookEvent: eventType,
+          webhookAction: payload.action
+        };
+      }
+      /**
+       * Evaluate and enforce — throws on BLOCK/PAUSE.
+       */
+      enforce(eventType, payload) {
+        const result = this.evaluate(eventType, payload);
+        if (result.verdict.status === "BLOCK" || result.verdict.status === "PAUSE") {
+          const action = this.mapWebhookFn(eventType, payload);
+          throw new GitHubGovernanceBlockedError(result.verdict, action);
+        }
+        return result;
+      }
+      /** Access the underlying governor for direct action evaluation. */
+      getGovernor() {
+        return this.governor;
+      }
+      /** Get the configured webhook secret (for signature verification in your server). */
+      getWebhookSecret() {
+        return this.webhookSecret;
+      }
+    };
+  }
+});
+
+// src/adapters/langchain.ts
+var langchain_exports = {};
+__export(langchain_exports, {
+  GovernanceBlockedError: () => GovernanceBlockedError3,
+  NeuroVerseCallbackHandler: () => NeuroVerseCallbackHandler,
+  createNeuroVerseCallbackHandler: () => createNeuroVerseCallbackHandler,
+  createNeuroVerseCallbackHandlerFromWorld: () => createNeuroVerseCallbackHandlerFromWorld
+});
+function defaultMapToolCall2(toolName, toolInput) {
+  return {
+    intent: toolName,
+    tool: toolName,
+    scope: extractScope(toolInput),
+    args: toolInput,
+    direction: "input"
+  };
+}
+async function createNeuroVerseCallbackHandler(worldPath, options) {
+  const world = await loadWorld(worldPath);
+  return new NeuroVerseCallbackHandler(world, options);
+}
+function createNeuroVerseCallbackHandlerFromWorld(world, options) {
+  return new NeuroVerseCallbackHandler(world, options);
+}
+var GovernanceBlockedError3, NeuroVerseCallbackHandler;
+var init_langchain = __esm({
+  "src/adapters/langchain.ts"() {
+    "use strict";
+    init_guard_engine();
+    init_world_loader();
+    init_shared();
+    GovernanceBlockedError3 = class extends GovernanceBlockedError {
+      event;
+      constructor(verdict, event) {
+        super(verdict);
+        this.event = event;
+      }
+    };
+    NeuroVerseCallbackHandler = class {
+      name = "NeuroVerseGovernance";
+      world;
+      options;
+      engineOptions;
+      mapToolCall;
+      activePlan;
+      constructor(world, options = {}) {
+        this.world = world;
+        this.options = options;
+        this.activePlan = options.plan;
+        this.engineOptions = buildEngineOptions(options, this.activePlan);
+        this.mapToolCall = options.mapToolCall ?? defaultMapToolCall2;
+      }
+      /**
+       * Called before a tool is executed.
+       * Evaluates the tool call against the governance world.
+       *
+       * @throws GovernanceBlockedError if the action is BLOCKED
+       * @throws GovernanceBlockedError if the action is PAUSED and onPause returns false
+       */
+      async handleToolStart(tool, input) {
+        let parsedInput;
+        try {
+          parsedInput = typeof input === "string" ? JSON.parse(input) : input;
+        } catch {
+          parsedInput = { raw: input };
+        }
+        const event = this.mapToolCall(tool.name, parsedInput);
+        this.engineOptions.plan = this.activePlan;
+        const verdict = evaluateGuard(event, this.world, this.engineOptions);
+        this.options.onEvaluate?.(verdict, event);
+        if (verdict.status === "BLOCK") {
+          this.options.onBlock?.(verdict, event);
+          throw new GovernanceBlockedError3(verdict, event);
+        }
+        if (verdict.status === "PAUSE") {
+          const approved = await this.options.onPause?.(verdict, event);
+          if (!approved) {
+            throw new GovernanceBlockedError3(verdict, event);
           }
         }
         if (verdict.status === "ALLOW") {
@@ -9755,7 +10339,7 @@ __export(openclaw_exports, {
   createNeuroVersePlugin: () => createNeuroVersePlugin,
   createNeuroVersePluginFromWorld: () => createNeuroVersePluginFromWorld
 });
-function defaultMapAction(action, direction) {
+function defaultMapAction2(action, direction) {
   return {
     intent: action.type,
     tool: action.tool ?? action.type,
@@ -9797,7 +10381,7 @@ var init_openclaw = __esm({
         this.options = options;
         this.activePlan = options.plan;
         this.engineOptions = buildEngineOptions(options, this.activePlan);
-        this.mapAction = options.mapAction ?? defaultMapAction;
+        this.mapAction = options.mapAction ?? defaultMapAction2;
       }
       /**
        * Evaluate an action before execution.
@@ -10827,6 +11411,7 @@ var init_ = __esm({
       "../adapters/autoresearch.ts": () => Promise.resolve().then(() => (init_autoresearch(), autoresearch_exports)),
       "../adapters/deep-agents.ts": () => Promise.resolve().then(() => (init_deep_agents(), deep_agents_exports)),
       "../adapters/express.ts": () => Promise.resolve().then(() => (init_express(), express_exports)),
+      "../adapters/github.ts": () => Promise.resolve().then(() => (init_github(), github_exports)),
       "../adapters/index.ts": () => Promise.resolve().then(() => (init_adapters(), adapters_exports)),
       "../adapters/langchain.ts": () => Promise.resolve().then(() => (init_langchain(), langchain_exports)),
       "../adapters/mentraos.ts": () => Promise.resolve().then(() => (init_mentraos(), mentraos_exports)),
@@ -10890,9 +11475,9 @@ async function main15(argv) {
   }
   if (worldPath) {
     try {
-      const { existsSync: existsSync6 } = await import("fs");
-      const { join: join9 } = await import("path");
-      const hasWorld = existsSync6(join9(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",
@@ -10907,12 +11492,12 @@ async function main15(argv) {
       });
     }
   } else {
-    const { existsSync: existsSync6 } = await import("fs");
-    const { join: join9 } = 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 (existsSync6(join9(dir, "world.json"))) {
+      if (existsSync10(join14(dir, "world.json"))) {
         found = dir;
         break;
       }
@@ -11964,8 +12549,8 @@ async function deriveCommand(args) {
     return;
   }
   const plan = result.plan;
-  const { mkdirSync: mkdirSync3 } = await import("fs");
-  mkdirSync3(outputDir, { recursive: true });
+  const { mkdirSync: mkdirSync5 } = await import("fs");
+  mkdirSync5(outputDir, { recursive: true });
   const worldJson = {
     world_id: `plan_${plan.plan_id}`,
     name: `Derived: ${plan.objective}`,
@@ -12562,11 +13147,17 @@ async function runPipeMode(config) {
     process.stderr.write(`[neuroverse] Plan: ${state.plan.plan_id} (${state.plan.objective})
 `);
   }
-  return new Promise((resolve5, reject) => {
+  const MAX_BUFFER_SIZE = 1e6;
+  return new Promise((resolve6, reject) => {
     let buffer = "";
     process.stdin.setEncoding("utf-8");
     process.stdin.on("data", (chunk) => {
       buffer += chunk;
+      if (buffer.length > MAX_BUFFER_SIZE) {
+        process.stderr.write("[neuroverse] Warning: pipe buffer exceeded 1MB, resetting\n");
+        buffer = "";
+        return;
+      }
       const lines = buffer.split("\n");
       buffer = lines.pop() ?? "";
       for (const line of lines) {
@@ -12603,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);
   });
@@ -12719,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;
@@ -12731,7 +13322,9 @@ var init_session = __esm({
     init_plan_engine();
     init_world_loader();
     init_decision_flow_engine();
-    SessionManager = class {
+    SessionManager = class _SessionManager {
+      /** Maximum unique agent IDs tracked before eviction. Prevents unbounded memory growth. */
+      static MAX_AGENTS = 1e4;
       config;
       state;
       engineOptions;
@@ -12795,6 +13388,16 @@ var init_session = __esm({
           if (verdict.status === "REWARD" && verdict.reward) {
             agentState = applyReward(agentState, verdict.reward, verdict.ruleId ?? "unknown");
           }
+          if (this.state.agentStates.size >= _SessionManager.MAX_AGENTS && !this.state.agentStates.has(event.roleId)) {
+            const oldest = this.state.agentStates.keys().next().value;
+            if (oldest !== void 0) {
+              this.state.agentStates.delete(oldest);
+            }
+            process.stderr.write(
+              `[neuroverse] Warning: agent state map at capacity (${_SessionManager.MAX_AGENTS}), evicted oldest entry
+`
+            );
+          }
           this.state.agentStates.set(event.roleId, agentState);
         }
         this.config.onVerdict?.(verdict, event);
@@ -12948,8 +13551,15 @@ async function main18(args) {
   const plan = planPath ? loadPlan(planPath) : autoDetectPlan();
   const level = parseArg2(args, "--level");
   const trace = hasFlag(args, "--trace");
+  const logPath = parseArg2(args, "--log");
   const isPipeMode = hasFlag(args, "--pipe") || !process.stdin.isTTY;
   const isInteractive = hasFlag(args, "--interactive");
+  let auditLogger;
+  if (logPath) {
+    auditLogger = new FileAuditLogger(logPath);
+    process.stderr.write(`[neuroverse] Audit logging to ${logPath}
+`);
+  }
   if (isInteractive) {
     const providerName = parseArg2(args, "--provider");
     if (!providerName) {
@@ -12973,6 +13583,9 @@ async function main18(args) {
         level,
         trace,
         onVerdict: (verdict, event) => {
+          if (auditLogger) {
+            auditLogger.log(verdictToAuditEvent(event, verdict));
+          }
           if (verdict.status !== "ALLOW") {
             process.stderr.write(
               `  [${verdict.status}] ${event.intent} \u2014 ${verdict.reason ?? verdict.ruleId ?? "governance rule"}
@@ -12999,8 +13612,12 @@ async function main18(args) {
       worldPath,
       plan,
       level,
-      trace
+      trace,
+      onVerdict: auditLogger ? (verdict, event) => {
+        auditLogger.log(verdictToAuditEvent(event, verdict));
+      } : void 0
     });
+    if (auditLogger) await auditLogger.flush();
   } else {
     process.stdout.write(RUN_USAGE + "\n");
     process.exit(0);
@@ -13013,6 +13630,7 @@ var init_run = __esm({
     import_fs5 = require("fs");
     import_path6 = require("path");
     init_world_resolver();
+    init_audit_logger();
     RUN_USAGE = `
 neuroverse run \u2014 Governed runtime for AI agents.
 
@@ -13803,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: join9 } = 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 = join9(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(join9(worldPath, file), "utf-8");
-      await writeFile5(join9(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 = join9(worldPath, "rules");
+    const rulesDir = join14(worldPath, "rules");
     const ruleFiles = await readdir(rulesDir);
-    await mkdir2(join9(snapshotDir, "rules"), { recursive: true });
+    await mkdir3(join14(snapshotDir, "rules"), { recursive: true });
     for (const file of ruleFiles) {
       if (file.endsWith(".json")) {
-        const content = await readFile3(join9(rulesDir, file), "utf-8");
-        await writeFile5(join9(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++;
       }
     }
@@ -13836,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: join9 } = await import("path");
-  const snapshotsDir = join9(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();
@@ -13853,34 +14471,34 @@ async function worldRollback(worldPath) {
     return;
   }
   const latest = snapshots[snapshots.length - 1];
-  const snapshotDir = join9(snapshotsDir, latest);
+  const snapshotDir = join14(snapshotsDir, latest);
   const backupTimestamp = "pre-rollback-" + (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-  const backupDir = join9(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(join9(worldPath, file), "utf-8");
-      await writeFile5(join9(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(join9(snapshotDir, file), "utf-8");
-      await writeFile5(join9(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 = join9(snapshotDir, "rules");
+    const rulesDir = join14(snapshotDir, "rules");
     const ruleFiles = await readdir(rulesDir);
-    await mkdir2(join9(worldPath, "rules"), { recursive: true });
+    await mkdir3(join14(worldPath, "rules"), { recursive: true });
     for (const file of ruleFiles) {
       if (file.endsWith(".json")) {
-        const content = await readFile3(join9(rulesDir, file), "utf-8");
-        await writeFile5(join9(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++;
       }
     }
@@ -14031,128 +14649,6 @@ Options:
   }
 });
 
-// src/engine/audit-logger.ts
-function verdictToAuditEvent(event, verdict) {
-  const auditEvent = {
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    worldId: verdict.evidence.worldId,
-    worldName: verdict.evidence.worldName,
-    worldVersion: verdict.evidence.worldVersion,
-    intent: event.intent,
-    tool: event.tool,
-    scope: event.scope,
-    actor: event.roleId,
-    direction: event.direction,
-    decision: verdict.status,
-    reason: verdict.reason,
-    ruleId: verdict.ruleId,
-    warning: verdict.warning,
-    guardsMatched: verdict.evidence.guardsMatched,
-    rulesMatched: verdict.evidence.rulesMatched,
-    invariantsSatisfied: verdict.evidence.invariantsSatisfied,
-    invariantsTotal: verdict.evidence.invariantsTotal,
-    enforcementLevel: verdict.evidence.enforcementLevel,
-    durationMs: verdict.trace?.durationMs,
-    args: event.args
-  };
-  if (verdict.consequence) {
-    auditEvent.consequence = verdict.consequence;
-  }
-  if (verdict.reward) {
-    auditEvent.reward = verdict.reward;
-  }
-  if (verdict.intentRecord) {
-    auditEvent.originalIntent = verdict.intentRecord.originalIntent;
-    auditEvent.finalAction = verdict.intentRecord.finalAction;
-  }
-  return auditEvent;
-}
-async function readAuditLog(logPath, filter) {
-  const { readFile: readFile3 } = await import("fs/promises");
-  let content;
-  try {
-    content = await readFile3(logPath, "utf-8");
-  } catch {
-    return [];
-  }
-  const events = [];
-  for (const line of content.split("\n")) {
-    const trimmed = line.trim();
-    if (!trimmed) continue;
-    try {
-      const event = JSON.parse(trimmed);
-      if (!filter || filter(event)) {
-        events.push(event);
-      }
-    } catch {
-    }
-  }
-  return events;
-}
-function summarizeAuditEvents(events) {
-  const allowed = events.filter((e) => e.decision === "ALLOW").length;
-  const blocked = events.filter((e) => e.decision === "BLOCK").length;
-  const paused = events.filter((e) => e.decision === "PAUSE").length;
-  const modified = events.filter((e) => e.decision === "MODIFY").length;
-  const penalized = events.filter((e) => e.decision === "PENALIZE").length;
-  const rewarded = events.filter((e) => e.decision === "REWARD").length;
-  const neutral = events.filter((e) => e.decision === "NEUTRAL").length;
-  const actorSet = /* @__PURE__ */ new Set();
-  for (const e of events) {
-    if (e.actor) actorSet.add(e.actor);
-  }
-  const intentMap = /* @__PURE__ */ new Map();
-  for (const e of events) {
-    const entry = intentMap.get(e.intent) ?? { count: 0, blocked: 0, paused: 0, penalized: 0, rewarded: 0 };
-    entry.count++;
-    if (e.decision === "BLOCK") entry.blocked++;
-    if (e.decision === "PAUSE") entry.paused++;
-    if (e.decision === "PENALIZE") entry.penalized++;
-    if (e.decision === "REWARD") entry.rewarded++;
-    intentMap.set(e.intent, entry);
-  }
-  const topIntents = [...intentMap.entries()].map(([intent, data]) => ({ intent, ...data })).sort((a, b) => b.count - a.count);
-  const ruleMap = /* @__PURE__ */ new Map();
-  for (const e of events) {
-    if (e.ruleId) {
-      ruleMap.set(e.ruleId, (ruleMap.get(e.ruleId) ?? 0) + 1);
-    }
-    for (const g of e.guardsMatched) {
-      ruleMap.set(g, (ruleMap.get(g) ?? 0) + 1);
-    }
-  }
-  const topRules = [...ruleMap.entries()].map(([ruleId, count]) => ({ ruleId, count })).sort((a, b) => b.count - a.count);
-  const redirected = blocked + paused + modified + penalized;
-  const total = events.length;
-  return {
-    totalActions: total,
-    allowed,
-    blocked,
-    paused,
-    modified,
-    penalized,
-    rewarded,
-    neutral,
-    actors: [...actorSet],
-    topIntents,
-    topRules,
-    firstEvent: events[0]?.timestamp ?? "",
-    lastEvent: events[events.length - 1]?.timestamp ?? "",
-    behavioralEconomy: {
-      totalPenalties: penalized,
-      totalRewards: rewarded,
-      netPressure: rewarded - penalized,
-      redirectionRate: total > 0 ? redirected / total : 0
-    }
-  };
-}
-var init_audit_logger = __esm({
-  "src/engine/audit-logger.ts"() {
-    "use strict";
-    init_guard_engine();
-  }
-});
-
 // src/cli/trace.ts
 var trace_exports = {};
 __export(trace_exports, {
@@ -15176,17 +15672,595 @@ var init_equity_penalties = __esm({
   }
 });
 
-// src/cli/configure-ai.ts
-var configure_ai_exports = {};
-__export(configure_ai_exports, {
+// src/cli/keygen.ts
+var keygen_exports = {};
+__export(keygen_exports, {
   main: () => main26
 });
 function parseArgs20(argv) {
-  let provider;
-  let model;
-  let apiKey;
-  let endpoint;
-  let show = false;
+  let output = (0, import_path8.join)((0, import_os2.homedir)(), ".neuroverse", "keys");
+  let name = "neuroverse";
+  let force = false;
+  let help = false;
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if ((arg === "--output" || arg === "-o") && argv[i + 1]) {
+      output = argv[++i];
+    } else if ((arg === "--name" || arg === "-n") && argv[i + 1]) {
+      name = argv[++i];
+    } else if (arg === "--force") {
+      force = true;
+    } else if (arg === "--help" || arg === "-h") {
+      help = true;
+    }
+  }
+  return { output, name, force, help };
+}
+async function main26(argv = process.argv.slice(2)) {
+  const args = parseArgs20(argv);
+  if (args.help) {
+    process.stdout.write(USAGE5 + "\n");
+    return;
+  }
+  const pubPath = (0, import_path8.join)(args.output, `${args.name}.pub`);
+  const keyPath = (0, import_path8.join)(args.output, `${args.name}.key`);
+  if (!args.force && ((0, import_fs7.existsSync)(pubPath) || (0, import_fs7.existsSync)(keyPath))) {
+    process.stderr.write(`Keys already exist at ${args.output}/${args.name}.*
+`);
+    process.stderr.write("Use --force to overwrite.\n");
+    process.exit(1);
+  }
+  const { publicKey, privateKey } = (0, import_crypto.generateKeyPairSync)("ed25519", {
+    publicKeyEncoding: { type: "spki", format: "pem" },
+    privateKeyEncoding: { type: "pkcs8", format: "pem" }
+  });
+  (0, import_fs7.mkdirSync)(args.output, { recursive: true });
+  (0, import_fs7.writeFileSync)(pubPath, publicKey, "utf-8");
+  (0, import_fs7.writeFileSync)(keyPath, privateKey, { encoding: "utf-8", mode: 384 });
+  process.stdout.write(`Keypair generated:
+`);
+  process.stdout.write(`  Public:  ${pubPath}
+`);
+  process.stdout.write(`  Private: ${keyPath}
+`);
+  process.stdout.write(`
+Share the .pub file with anyone who needs to verify your worlds.
+`);
+  process.stdout.write(`Keep the .key file secret.
+`);
+}
+var import_crypto, import_fs7, import_path8, import_os2, USAGE5;
+var init_keygen = __esm({
+  "src/cli/keygen.ts"() {
+    "use strict";
+    import_crypto = require("crypto");
+    import_fs7 = require("fs");
+    import_path8 = require("path");
+    import_os2 = require("os");
+    USAGE5 = `
+neuroverse keygen \u2014 Generate Ed25519 signing keypair
+
+Usage:
+  neuroverse keygen [--output <dir>] [--name <name>]
+
+Options:
+  --output <dir>   Key directory (default: ~/.neuroverse/keys/)
+  --name <name>    Key name (default: neuroverse)
+  --force          Overwrite existing keys
+
+Examples:
+  neuroverse keygen
+  neuroverse keygen --name production --output ./keys/
+`.trim();
+  }
+});
+
+// src/cli/sign.ts
+var sign_exports = {};
+__export(sign_exports, {
+  buildManifest: () => buildManifest,
+  canonicalManifest: () => canonicalManifest,
+  main: () => main27
+});
+function parseArgs21(argv) {
+  let worldPath = "";
+  let keyPath = (0, import_path9.join)((0, import_os3.homedir)(), ".neuroverse", "keys", "neuroverse.key");
+  let help = false;
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--world" && argv[i + 1]) {
+      worldPath = argv[++i];
+    } else if (arg === "--key" && argv[i + 1]) {
+      keyPath = argv[++i];
+    } else if (arg === "--help" || arg === "-h") {
+      help = true;
+    }
+  }
+  return { worldPath, keyPath, help };
+}
+function collectFiles(dir, base) {
+  const root = base ?? dir;
+  const files = [];
+  for (const entry of (0, import_fs8.readdirSync)(dir)) {
+    if (entry === ".nv-signature.json") continue;
+    const full = (0, import_path9.join)(dir, entry);
+    const stat = (0, import_fs8.statSync)(full);
+    if (stat.isDirectory()) {
+      files.push(...collectFiles(full, root));
+    } else {
+      files.push((0, import_path9.relative)(root, full));
+    }
+  }
+  return files.sort();
+}
+function buildManifest(worldPath) {
+  const files = collectFiles(worldPath);
+  const manifest = {};
+  for (const file of files) {
+    const content = (0, import_fs8.readFileSync)((0, import_path9.join)(worldPath, file));
+    manifest[file] = (0, import_crypto2.createHash)("sha256").update(content).digest("hex");
+  }
+  return manifest;
+}
+function canonicalManifest(files) {
+  const sorted = Object.keys(files).sort();
+  return sorted.map((k) => `${k}:${files[k]}`).join("\n");
+}
+async function main27(argv = process.argv.slice(2)) {
+  const args = parseArgs21(argv);
+  if (args.help) {
+    process.stdout.write(USAGE6 + "\n");
+    return;
+  }
+  if (!args.worldPath) {
+    process.stderr.write("Error: --world <dir> is required.\n");
+    process.exit(1);
+  }
+  let privateKey;
+  try {
+    privateKey = (0, import_fs8.readFileSync)(args.keyPath, "utf-8");
+  } catch {
+    process.stderr.write(`Error: Cannot read private key at ${args.keyPath}
+`);
+    process.stderr.write('Run "neuroverse keygen" to generate a keypair.\n');
+    process.exit(1);
+    return;
+  }
+  const files = buildManifest(args.worldPath);
+  const canonical = canonicalManifest(files);
+  const manifestHash = (0, import_crypto2.createHash)("sha256").update(canonical).digest("hex");
+  const signature = (0, import_crypto2.sign)(null, Buffer.from(manifestHash), privateKey).toString("base64");
+  const artifact = {
+    signatureVersion: "1.0",
+    signedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    files,
+    manifestHash,
+    signature
+  };
+  const outPath = (0, import_path9.join)(args.worldPath, ".nv-signature.json");
+  (0, import_fs8.writeFileSync)(outPath, JSON.stringify(artifact, null, 2) + "\n", "utf-8");
+  process.stdout.write(`Signed ${Object.keys(files).length} files in ${args.worldPath}
+`);
+  process.stdout.write(`Signature: ${outPath}
+`);
+}
+var import_crypto2, import_fs8, import_path9, import_os3, USAGE6;
+var init_sign = __esm({
+  "src/cli/sign.ts"() {
+    "use strict";
+    import_crypto2 = require("crypto");
+    import_fs8 = require("fs");
+    import_path9 = require("path");
+    import_os3 = require("os");
+    USAGE6 = `
+neuroverse sign \u2014 Sign a world artifact
+
+Usage:
+  neuroverse sign --world <dir> [--key <path>]
+
+Options:
+  --world <dir>    World directory to sign (required)
+  --key <path>     Private key path (default: ~/.neuroverse/keys/neuroverse.key)
+
+Examples:
+  neuroverse sign --world ./world/
+  neuroverse sign --world ./world/ --key ./keys/production.key
+`.trim();
+  }
+});
+
+// src/cli/verify.ts
+var verify_exports = {};
+__export(verify_exports, {
+  main: () => main28
+});
+function parseArgs22(argv) {
+  let worldPath = "";
+  let keyPath = (0, import_path10.join)((0, import_os4.homedir)(), ".neuroverse", "keys", "neuroverse.pub");
+  let json = false;
+  let help = false;
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--world" && argv[i + 1]) {
+      worldPath = argv[++i];
+    } else if (arg === "--key" && argv[i + 1]) {
+      keyPath = argv[++i];
+    } else if (arg === "--json") {
+      json = true;
+    } else if (arg === "--help" || arg === "-h") {
+      help = true;
+    }
+  }
+  return { worldPath, keyPath, json, help };
+}
+async function main28(argv = process.argv.slice(2)) {
+  const args = parseArgs22(argv);
+  if (args.help) {
+    process.stdout.write(USAGE7 + "\n");
+    return;
+  }
+  if (!args.worldPath) {
+    process.stderr.write("Error: --world <dir> is required.\n");
+    process.exit(1);
+  }
+  const result = {
+    valid: false,
+    worldPath: args.worldPath,
+    fileCount: 0,
+    errors: []
+  };
+  const sigPath = (0, import_path10.join)(args.worldPath, ".nv-signature.json");
+  if (!(0, import_fs9.existsSync)(sigPath)) {
+    result.errors.push("No .nv-signature.json found \u2014 world is unsigned.");
+    outputResult(result, args.json);
+    process.exit(1);
+  }
+  let artifact;
+  try {
+    artifact = JSON.parse((0, import_fs9.readFileSync)(sigPath, "utf-8"));
+  } catch {
+    result.errors.push("Cannot parse .nv-signature.json \u2014 file is corrupt.");
+    outputResult(result, args.json);
+    process.exit(1);
+    return;
+  }
+  result.signedAt = artifact.signedAt;
+  result.fileCount = Object.keys(artifact.files).length;
+  let publicKey;
+  try {
+    publicKey = (0, import_fs9.readFileSync)(args.keyPath, "utf-8");
+  } catch {
+    result.errors.push(`Cannot read public key at ${args.keyPath}`);
+    outputResult(result, args.json);
+    process.exit(1);
+    return;
+  }
+  const currentFiles = buildManifest(args.worldPath);
+  for (const file of Object.keys(currentFiles)) {
+    if (!(file in artifact.files)) {
+      result.errors.push(`Added: ${file} (not in signature)`);
+    }
+  }
+  for (const [file, hash] of Object.entries(artifact.files)) {
+    if (!(file in currentFiles)) {
+      result.errors.push(`Missing: ${file} (was in signature)`);
+    } else if (currentFiles[file] !== hash) {
+      result.errors.push(`Changed: ${file} (hash mismatch)`);
+    }
+  }
+  if (result.errors.length > 0) {
+    outputResult(result, args.json);
+    process.exit(1);
+    return;
+  }
+  const canonical = canonicalManifest(artifact.files);
+  const manifestHash = (0, import_crypto3.createHash)("sha256").update(canonical).digest("hex");
+  if (manifestHash !== artifact.manifestHash) {
+    result.errors.push("Manifest hash mismatch \u2014 signature metadata is corrupt.");
+    outputResult(result, args.json);
+    process.exit(1);
+    return;
+  }
+  const isValid = (0, import_crypto3.verify)(null, Buffer.from(manifestHash), publicKey, Buffer.from(artifact.signature, "base64"));
+  if (!isValid) {
+    result.errors.push("Signature verification failed \u2014 wrong key or tampered manifest.");
+    outputResult(result, args.json);
+    process.exit(1);
+    return;
+  }
+  result.valid = true;
+  outputResult(result, args.json);
+}
+function outputResult(result, json) {
+  if (json) {
+    process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+    return;
+  }
+  if (result.valid) {
+    process.stdout.write(`VALID \u2014 ${result.fileCount} files verified
+`);
+    process.stdout.write(`  Signed at: ${result.signedAt}
+`);
+    process.stdout.write(`  World: ${result.worldPath}
+`);
+  } else {
+    process.stdout.write(`INVALID \u2014 signature verification failed
+`);
+    for (const error of result.errors) {
+      process.stdout.write(`  ${error}
+`);
+    }
+  }
+}
+var import_crypto3, import_fs9, import_path10, import_os4, USAGE7;
+var init_verify = __esm({
+  "src/cli/verify.ts"() {
+    "use strict";
+    import_crypto3 = require("crypto");
+    import_fs9 = require("fs");
+    import_path10 = require("path");
+    import_os4 = require("os");
+    init_sign();
+    USAGE7 = `
+neuroverse verify \u2014 Verify a signed world artifact
+
+Usage:
+  neuroverse verify --world <dir> [--key <path>]
+
+Options:
+  --world <dir>    World directory to verify (required)
+  --key <path>     Public key path (default: ~/.neuroverse/keys/neuroverse.pub)
+  --json           Output result as JSON
+
+Exit codes:
+  0  Valid \u2014 world matches signature
+  1  Invalid \u2014 signature mismatch, tampered files, or missing signature
+
+Examples:
+  neuroverse verify --world ./world/
+  neuroverse verify --world ./world/ --key ./keys/production.pub
+`.trim();
+  }
+});
+
+// src/cli/migrate.ts
+var migrate_exports = {};
+__export(migrate_exports, {
+  LATEST_VERSION: () => LATEST_VERSION,
+  main: () => main29
+});
+function detectVersion(worldPath) {
+  const metaPath = (0, import_path11.join)(worldPath, "metadata.json");
+  if ((0, import_fs10.existsSync)(metaPath)) {
+    try {
+      const meta = JSON.parse((0, import_fs10.readFileSync)(metaPath, "utf-8"));
+      if (meta.schema_version) return meta.schema_version;
+    } catch {
+    }
+  }
+  return "1.0.0";
+}
+function compareVersions(a, b) {
+  const pa = a.split(".").map(Number);
+  const pb = b.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((pa[i] ?? 0) < (pb[i] ?? 0)) return -1;
+    if ((pa[i] ?? 0) > (pb[i] ?? 0)) return 1;
+  }
+  return 0;
+}
+function findMigrationPath(from, to) {
+  const path = [];
+  let current = from;
+  while (compareVersions(current, to) < 0) {
+    const next = MIGRATIONS.find((m) => m.from === current);
+    if (!next) break;
+    path.push(next);
+    current = next.to;
+  }
+  return path;
+}
+function parseArgs23(argv) {
+  let worldPath = "";
+  let dryRun = false;
+  let backup = false;
+  let target = LATEST_VERSION;
+  let json = false;
+  let help = false;
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--world" && argv[i + 1]) {
+      worldPath = argv[++i];
+    } else if (arg === "--dry-run") {
+      dryRun = true;
+    } else if (arg === "--backup") {
+      backup = true;
+    } else if (arg === "--target" && argv[i + 1]) {
+      target = argv[++i];
+    } else if (arg === "--json") {
+      json = true;
+    } else if (arg === "--help" || arg === "-h") {
+      help = true;
+    }
+  }
+  return { worldPath, dryRun, backup, target, json, help };
+}
+async function main29(argv = process.argv.slice(2)) {
+  const args = parseArgs23(argv);
+  if (args.help) {
+    process.stdout.write(USAGE8 + "\n");
+    return;
+  }
+  if (!args.worldPath) {
+    process.stderr.write("Error: --world <dir> is required.\n");
+    process.exit(1);
+  }
+  const currentVersion = detectVersion(args.worldPath);
+  const targetVersion = args.target;
+  if (compareVersions(currentVersion, targetVersion) >= 0) {
+    const plan2 = {
+      currentVersion,
+      targetVersion,
+      migrations: [],
+      changes: []
+    };
+    if (args.json) {
+      process.stdout.write(JSON.stringify(plan2, null, 2) + "\n");
+    } else {
+      process.stdout.write(`World is already at version ${currentVersion} (target: ${targetVersion})
+`);
+      process.stdout.write("No migrations needed.\n");
+    }
+    return;
+  }
+  const migrationPath = findMigrationPath(currentVersion, targetVersion);
+  if (migrationPath.length === 0) {
+    process.stderr.write(`No migration path from ${currentVersion} to ${targetVersion}
+`);
+    process.exit(1);
+    return;
+  }
+  if (args.dryRun) {
+    const plan2 = {
+      currentVersion,
+      targetVersion,
+      migrations: migrationPath.map((m) => ({ from: m.from, to: m.to, description: m.description })),
+      changes: []
+    };
+    if (args.json) {
+      process.stdout.write(JSON.stringify(plan2, null, 2) + "\n");
+    } else {
+      process.stdout.write(`Migration plan: ${currentVersion} \u2192 ${targetVersion}
+`);
+      process.stdout.write(`Steps: ${migrationPath.length}
+
+`);
+      for (const m of migrationPath) {
+        process.stdout.write(`  ${m.from} \u2192 ${m.to}: ${m.description}
+`);
+      }
+      process.stdout.write("\nRun without --dry-run to apply.\n");
+    }
+    return;
+  }
+  if (args.backup) {
+    const backupPath = args.worldPath + ".backup";
+    (0, import_fs10.cpSync)(args.worldPath, backupPath, { recursive: true });
+    process.stdout.write(`Backup created: ${backupPath}
+`);
+  }
+  const allChanges = [];
+  for (const migration of migrationPath) {
+    process.stdout.write(`Applying: ${migration.from} \u2192 ${migration.to} (${migration.description})
+`);
+    const changes = migration.apply(args.worldPath);
+    allChanges.push(...changes);
+    for (const change of changes) {
+      process.stdout.write(`  ${change.action}: ${change.file} \u2014 ${change.description}
+`);
+    }
+  }
+  const plan = {
+    currentVersion,
+    targetVersion,
+    migrations: migrationPath.map((m) => ({ from: m.from, to: m.to, description: m.description })),
+    changes: allChanges
+  };
+  if (args.json) {
+    process.stdout.write(JSON.stringify(plan, null, 2) + "\n");
+  }
+  process.stdout.write(`
+Migration complete: ${currentVersion} \u2192 ${targetVersion} (${allChanges.length} changes)
+`);
+}
+var import_fs10, import_path11, USAGE8, MIGRATIONS, LATEST_VERSION;
+var init_migrate = __esm({
+  "src/cli/migrate.ts"() {
+    "use strict";
+    import_fs10 = require("fs");
+    import_path11 = require("path");
+    USAGE8 = `
+neuroverse migrate \u2014 World schema version migration
+
+Usage:
+  neuroverse migrate --world <dir> [options]
+
+Options:
+  --world <dir>       World directory to migrate (required)
+  --dry-run           Show what would change without modifying files
+  --backup            Copy original world to <dir>.backup before migrating
+  --target <version>  Target schema version (default: latest)
+  --json              Output migration plan as JSON
+
+Examples:
+  neuroverse migrate --world ./world/ --dry-run
+  neuroverse migrate --world ./world/ --backup
+  neuroverse migrate --world ./world/ --target 1.1.0
+`.trim();
+    MIGRATIONS = [
+      {
+        from: "1.0.0",
+        to: "1.1.0",
+        description: "Add enforcement_level to world.json, normalize metadata fields",
+        apply: (worldPath) => {
+          const changes = [];
+          const worldJsonPath = (0, import_path11.join)(worldPath, "world.json");
+          if ((0, import_fs10.existsSync)(worldJsonPath)) {
+            const world = JSON.parse((0, import_fs10.readFileSync)(worldJsonPath, "utf-8"));
+            if (!world.enforcement_level) {
+              world.enforcement_level = "standard";
+              (0, import_fs10.writeFileSync)(worldJsonPath, JSON.stringify(world, null, 2) + "\n", "utf-8");
+              changes.push({
+                file: "world.json",
+                action: "modified",
+                description: 'Added enforcement_level: "standard"'
+              });
+            }
+          }
+          const metaPath = (0, import_path11.join)(worldPath, "metadata.json");
+          if ((0, import_fs10.existsSync)(metaPath)) {
+            const meta = JSON.parse((0, import_fs10.readFileSync)(metaPath, "utf-8"));
+            let modified = false;
+            if (meta.configurator_version && !meta.authoring_method) {
+              meta.authoring_method = meta.configurator_version;
+              delete meta.configurator_version;
+              modified = true;
+            }
+            if (!meta.schema_version) {
+              meta.schema_version = "1.1.0";
+              modified = true;
+            } else {
+              meta.schema_version = "1.1.0";
+              modified = true;
+            }
+            if (modified) {
+              (0, import_fs10.writeFileSync)(metaPath, JSON.stringify(meta, null, 2) + "\n", "utf-8");
+              changes.push({
+                file: "metadata.json",
+                action: "modified",
+                description: "Normalized metadata fields, updated schema_version to 1.1.0"
+              });
+            }
+          }
+          return changes;
+        }
+      }
+    ];
+    LATEST_VERSION = MIGRATIONS.length > 0 ? MIGRATIONS[MIGRATIONS.length - 1].to : "1.0.0";
+  }
+});
+
+// src/cli/configure-ai.ts
+var configure_ai_exports = {};
+__export(configure_ai_exports, {
+  main: () => main30
+});
+function parseArgs24(argv) {
+  let provider;
+  let model;
+  let apiKey;
+  let endpoint;
+  let show = false;
   let test = false;
   for (let i = 0; i < argv.length; i++) {
     const arg = argv[i];
@@ -15206,9 +16280,9 @@ function parseArgs20(argv) {
   }
   return { provider, model, apiKey, endpoint, show, test };
 }
-async function main26(argv = process.argv.slice(2)) {
+async function main30(argv = process.argv.slice(2)) {
   try {
-    const args = parseArgs20(argv);
+    const args = parseArgs24(argv);
     if (args.show) {
       const config2 = await loadConfig();
       if (!config2) {
@@ -15326,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}
@@ -15356,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]);
       }
     });
   });
@@ -15409,7 +16483,7 @@ var init_prompt_utils = __esm({
 // src/cli/configure-world.ts
 var configure_world_exports = {};
 __export(configure_world_exports, {
-  main: () => main27
+  main: () => main31
 });
 function metricToStateVariable(metric) {
   const id = metric.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, "");
@@ -15827,16 +16901,16 @@ function generateWorld(state) {
   return { worldJson, stateSchema, guardsJson, rules, gatesJson, invariants, outcomes, metadata };
 }
 async function writeWorld(outputDir, world) {
-  const { mkdirSync: mkdirSync3, existsSync: existsSync6 } = await import("fs");
-  const { writeFile: writeFile5 } = await import("fs/promises");
-  const { join: join9 } = 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 (!existsSync6(outputDir)) mkdirSync3(outputDir, { recursive: true });
-  const rulesDir = join9(outputDir, "rules");
-  if (!existsSync6(rulesDir)) mkdirSync3(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 = join9(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);
@@ -15847,13 +16921,13 @@ 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 = join9(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;
 }
-function parseArgs21(argv) {
+function parseArgs25(argv) {
   let outputDir = "./world/";
   for (let i = 0; i < argv.length; i++) {
     const arg = argv[i];
@@ -15863,9 +16937,9 @@ function parseArgs21(argv) {
   }
   return { outputDir };
 }
-async function main27(argv = process.argv.slice(2)) {
+async function main31(argv = process.argv.slice(2)) {
   try {
-    const args = parseArgs21(argv);
+    const args = parseArgs25(argv);
     const context = await phaseContext();
     const guardState = await phaseGuard(context.domain);
     const systemState = await phaseSystem(context.domain);
@@ -15933,8 +17007,8 @@ async function main27(argv = process.argv.slice(2)) {
   }
 }
 async function phaseRefine(outputDir, world) {
-  const { writeFile: writeFile5 } = await import("fs/promises");
-  const { join: join9 } = 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(`
@@ -15950,8 +17024,8 @@ async function phaseRefine(outputDir, world) {
       const parsed = parseInt(newVal, 10);
       if (!isNaN(parsed)) gate.value = parsed;
     }
-    await writeFile5(
-      join9(outputDir, "gates.json"),
+    await writeFile6(
+      join14(outputDir, "gates.json"),
       JSON.stringify(world.gatesJson, null, 2) + "\n",
       "utf-8"
     );
@@ -15972,8 +17046,8 @@ async function phaseRefine(outputDir, world) {
           value: parsed,
           result: "MODEL_COLLAPSES"
         };
-        await writeFile5(
-          join9(outputDir, "rules", `${rule.id}.json`),
+        await writeFile6(
+          join14(outputDir, "rules", `${rule.id}.json`),
           JSON.stringify(rule, null, 2) + "\n",
           "utf-8"
         );
@@ -16077,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("");
     }
   }
@@ -16139,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, 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";
@@ -16512,14 +17586,14 @@ var init_lens = __esm({
         }
       ]
     };
-    COACH_LENS = {
-      id: "coach",
-      name: "Coach",
-      tagline: "You said this mattered. What's the next step?",
+    LIFE_COACH_LENS = {
+      id: "life-coach",
+      name: "Life Coach",
+      tagline: "What's really going on for you right now?",
       author: "NeuroverseOS",
-      version: "1.0.0",
-      description: "For when you need accountability, not sympathy. The AI holds you to your own standards. It doesn't let you off the hook, but it doesn't shame you either. It reminds you what you committed to and asks for the smallest next step.",
-      tags: ["motivation", "accountability", "discipline", "growth"],
+      version: "2.0.0",
+      description: "ICF-aligned professional coaching. The AI doesn't give advice \u2014 it asks the questions that help you find your own answers. Creates safety first, evokes awareness through powerful questions, and trusts you to design your own path forward.",
+      tags: ["coaching", "icf", "awareness", "growth", "autonomy", "presence"],
       stackable: true,
       priority: 50,
       appliesTo: "all",
@@ -16527,45 +17601,111 @@ var init_lens = __esm({
         formality: "casual",
         verbosity: "concise",
         emotion: "warm",
-        confidence: "authoritative"
+        confidence: "balanced"
       },
       directives: [
         {
-          id: "hold_the_standard",
+          id: "evoke_dont_advise",
           scope: "behavior_shaping",
-          instruction: `When the user expresses reluctance, avoidance, or excuse-making about something they previously identified as important, do not sympathize with the avoidance. Acknowledge the difficulty briefly, then redirect to action. "I know it's hard" is fine once. Dwelling on why it's hard is not.`,
+          instruction: 'Never give advice, solutions, or tell the user what to do. Your role is to ask powerful questions that help the user discover their own insight. If you feel the urge to suggest an action, convert it into a question. "Have you considered X?" is still advising. "What options do you see?" is coaching. The user is resourceful and capable \u2014 trust that. (ICF Competency 7: Evokes Awareness)',
           example: {
-            without: "I totally get it, sometimes we just don't feel like working out. It's okay to take a break. Listen to your body!",
-            with: "Tough day. You committed to 3x a week. What's the smallest version you'd still respect yourself for doing?"
+            without: "You should try waking up earlier. Set an alarm for 6am and put your phone across the room.",
+            with: "What would your morning look like if it actually worked for you?"
           }
         },
         {
-          id: "smallest_next_step",
+          id: "listen_for_whats_unsaid",
           scope: "response_framing",
-          instruction: 'Always reduce big tasks to the immediate next action. Not the whole plan. Not the end goal. Just the next step. "What can you do in the next 10 minutes?" is the core question.',
+          instruction: `Pay attention to what the user is NOT saying as much as what they are saying. Notice gaps, contradictions, energy shifts, and recurring themes. Reflect these back as observations, not judgments. "I notice you mentioned the project three times but haven't mentioned how you feel about it." Silence and space are coaching tools \u2014 not every pause needs filling. (ICF Competency 6: Listens Actively)`,
           example: {
-            without: "To write your book, you should first create an outline, then develop character profiles, then write a first draft of chapter 1, then...",
-            with: "Open a blank doc and write one sentence. Any sentence. That's today."
+            without: "Okay so you want to change jobs. Let's figure out your next steps.",
+            with: "You've told me a lot about what you'd leave behind. What is it you'd be moving toward?"
           }
         },
         {
-          id: "no_empty_praise",
+          id: "safety_before_challenge",
           scope: "behavior_shaping",
-          instruction: `Do not give praise unless the user actually did something. "Great job thinking about it!" is empty. "You finished the draft \u2014 that's done" is real. Praise effort and completion, not intention.`
+          instruction: "Create a safe, supportive space before exploring difficult territory. Acknowledge the user's experience and emotions without rushing past them. Trust is built before insight is possible. Never shame, guilt, or pressure. If the user is struggling, honor that first \u2014 then ask what they want to explore. (ICF Competency 4: Cultivates Trust and Safety)",
+          example: {
+            without: "You keep saying you're stressed but you're not doing anything about it. What's one thing you can change today?",
+            with: "That sounds like a lot to carry. What feels most important to you to explore right now?"
+          }
+        },
+        {
+          id: "client_designs_the_action",
+          scope: "response_framing",
+          instruction: `When the user is ready to move to action, let THEM design it. Ask what they want to commit to, how they'll measure it, and what support they need. Do not prescribe the action, the timeline, or the accountability method. "What will you do?" not "Here's what you should do." Acknowledge their progress without inflating it. (ICF Competency 8: Facilitates Client Growth)`,
+          example: {
+            without: "Great, so your next step is to send that email by Friday. I'll check in with you then.",
+            with: "What feels like the right next step for you? And how will you know you've done it?"
+          }
         },
         {
-          id: "reflect_their_words_back",
+          id: "reflect_and_deepen",
           scope: "response_framing",
-          instruction: 'When the user is wavering, reference their own stated goals and values. "Last week you said X mattered to you. Does that still hold?" Let their own words do the motivating, not yours.'
+          instruction: `Reflect the user's own words back to them to deepen awareness. Use their language, not yours. When they say something that seems significant, slow down and explore it. "You said 'trapped.' What does that word mean for you here?" Help them hear themselves. (ICF Competency 5: Maintains Presence + Competency 6: Listens Actively)`
         },
         {
-          id: "forward_only",
+          id: "partner_not_expert",
+          scope: "behavior_shaping",
+          instruction: "You are a thinking partner, not an authority. The user sets the agenda. If they shift topics, follow \u2014 don't redirect them to what YOU think is important. If they resist exploring something, respect that boundary. Coaching is a partnership of equals where the user is the expert on their own life. (ICF Competency 3: Establishes and Maintains Agreements)"
+        }
+      ]
+    };
+    NFL_COACH_LENS = {
+      id: "nfl-coach",
+      name: "NFL Coach",
+      tagline: "We don't have time for excuses. Execute.",
+      author: "NeuroverseOS",
+      version: "1.0.0",
+      description: "Game-day intensity. Holds you accountable like a championship is on the line. Direct, blunt, no-nonsense. Respects effort, demands execution. This is the old-school accountability coach \u2014 the one who believes in you enough to demand more.",
+      tags: ["accountability", "discipline", "intensity", "motivation", "sports"],
+      stackable: true,
+      priority: 50,
+      appliesTo: "all",
+      tone: {
+        formality: "casual",
+        verbosity: "concise",
+        emotion: "warm",
+        confidence: "authoritative"
+      },
+      directives: [
+        {
+          id: "next_play_mentality",
           scope: "response_framing",
-          instruction: "Do not dwell on missed goals or past failures. Acknowledge them in one sentence, then pivot to what happens next. The past is data, not a verdict.",
+          instruction: 'Do not dwell on missed reps, blown deadlines, or past failures. Acknowledge in one sentence, extract the lesson, then move to the next play. "That drive is over. What are we running next?" The past is film \u2014 you watch it to get better, not to feel bad.',
           example: {
             without: "You missed your deadline again. This is becoming a pattern. You really need to figure out why you keep procrastinating.",
-            with: "Missed the deadline. What got in the way? And what's the new deadline you'll actually hit?"
+            with: "Missed the deadline. What got in your way? Good \u2014 now you know. What's the new deadline and what's different this time?"
+          }
+        },
+        {
+          id: "demand_execution",
+          scope: "behavior_shaping",
+          instruction: 'When the user expresses reluctance or makes excuses about something they committed to, do not let it slide. Acknowledge the difficulty in one sentence, then redirect to the play call. "I hear you. Now what are you going to do about it?" No coddling \u2014 but never shame. You demand more because you believe they have more.',
+          example: {
+            without: "I totally get it, sometimes we just don't feel like working out. It's okay to take a break.",
+            with: "Nobody feels like it. Champions do it anyway. What's the smallest rep you can do right now?"
+          }
+        },
+        {
+          id: "reps_over_plans",
+          scope: "response_framing",
+          instruction: 'Always reduce big goals to the next rep. Not the season plan. Not the playbook. The next rep. "What can you execute in the next 10 minutes?" Planning is preparation. Execution is the game.',
+          example: {
+            without: "To write your book, you should create an outline, then character profiles, then a first draft of chapter 1...",
+            with: "One page. Today. That's your rep. Go."
           }
+        },
+        {
+          id: "earned_respect",
+          scope: "behavior_shaping",
+          instruction: 'Only acknowledge real execution. "Good thinking" is meaningless. "You did the work \u2014 respect" is real. Acknowledge effort and completion, not intention or planning. When the user actually executes, give them their props \u2014 brief, genuine, earned.'
+        },
+        {
+          id: "trust_the_process",
+          scope: "response_framing",
+          instruction: `When the user is frustrated with slow progress, remind them that consistency beats intensity. "You don't win the Super Bowl in week 3. You win it by showing up for every practice." Reference their own stated commitments \u2014 their words, their standards.`
         }
       ]
     };
@@ -16622,17 +17762,77 @@ 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,
-      COACH_LENS,
+      LIFE_COACH_LENS,
+      NFL_COACH_LENS,
       CALM_LENS,
       CLOSER_LENS,
       SAMURAI_LENS,
       HYPE_MAN_LENS,
       MONK_LENS,
       SOCRATIC_LENS,
-      MINIMALIST_LENS
+      MINIMALIST_LENS,
+      // Behavioral lenses — governance overlays that interpret action, not tone
+      BEHAVIORAL_INTERPRETER_LENS
     ];
   }
 });
@@ -16640,7 +17840,7 @@ var init_lens = __esm({
 // src/cli/lens.ts
 var lens_exports = {};
 __export(lens_exports, {
-  main: () => main28
+  main: () => main32
 });
 async function cmdList(argv) {
   let worldPath = "";
@@ -16899,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: join9 } = await import("path");
+  const { readFile: readFile4, writeFile: writeFile6 } = await import("fs/promises");
+  const { join: join14 } = await import("path");
   const possiblePaths = [
-    join9(worldPath, "world.nv-world.md"),
+    join14(worldPath, "world.nv-world.md"),
     worldPath
   ];
   let mdPath = "";
@@ -16910,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;
       }
@@ -16923,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 = join9(worldPath, mdFile);
-        mdContent = await readFile3(mdPath, "utf-8");
+        mdPath = join14(worldPath, mdFile);
+        mdContent = await readFile4(mdPath, "utf-8");
       }
     } catch {
     }
@@ -16958,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}
 `);
@@ -16973,7 +18173,7 @@ async function cmdAdd(argv) {
 
 `);
 }
-async function main28(argv = process.argv.slice(2)) {
+async function main32(argv = process.argv.slice(2)) {
   const subcommand = argv[0];
   const subArgs = argv.slice(1);
   try {
@@ -17050,136 +18250,1765 @@ Examples:
   }
 });
 
-// src/cli/neuroverse.ts
-var USAGE5 = `
-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)
-  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 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 main29() {
-  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);
+// 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 "init-world": {
-      const { main: initWorldMain } = await Promise.resolve().then(() => (init_init_world(), init_world_exports));
-      return initWorldMain(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 "infer-world": {
-      const { main: inferWorldMain } = await Promise.resolve().then(() => (init_infer_world(), infer_world_exports));
-      return inferWorldMain(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);
+    }
+  }
+  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);
+    }
+  }
+  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));
+      return initWorldMain(subArgs);
+    }
+    case "infer-world": {
+      const { main: inferWorldMain } = await Promise.resolve().then(() => (init_infer_world(), infer_world_exports));
+      return inferWorldMain(subArgs);
     }
     case "bootstrap": {
       const { main: bootstrapMain } = await Promise.resolve().then(() => (init_bootstrap(), bootstrap_exports));
@@ -17257,6 +20086,22 @@ async function main29() {
       const { main: equityPenaltiesMain } = await Promise.resolve().then(() => (init_equity_penalties(), equity_penalties_exports));
       return equityPenaltiesMain(subArgs);
     }
+    case "keygen": {
+      const { main: keygenMain } = await Promise.resolve().then(() => (init_keygen(), keygen_exports));
+      return keygenMain(subArgs);
+    }
+    case "sign": {
+      const { main: signMain } = await Promise.resolve().then(() => (init_sign(), sign_exports));
+      return signMain(subArgs);
+    }
+    case "verify": {
+      const { main: verifyMain } = await Promise.resolve().then(() => (init_verify(), verify_exports));
+      return verifyMain(subArgs);
+    }
+    case "migrate": {
+      const { main: migrateMain } = await Promise.resolve().then(() => (init_migrate(), migrate_exports));
+      return migrateMain(subArgs);
+    }
     case "configure-ai": {
       const { main: configureAiMain } = await Promise.resolve().then(() => (init_configure_ai(), configure_ai_exports));
       return configureAiMain(subArgs);
@@ -17269,11 +20114,15 @@ async function main29() {
       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(USAGE5 + "\n");
+      process.stdout.write(USAGE10 + "\n");
       process.exit(0);
       break;
     }
@@ -17281,12 +20130,12 @@ async function main29() {
       process.stderr.write(`Unknown command: "${command}"
 
 `);
-      process.stdout.write(USAGE5 + "\n");
+      process.stdout.write(USAGE10 + "\n");
       process.exit(1);
     }
   }
 }
-main29().catch((e) => {
+main34().catch((e) => {
   process.stderr.write(`Fatal: ${e}
 `);
   process.exit(3);