@neuroverseos/governance 0.5.0 → 0.6.0

package/dist/cli/worldmodel.cjs

@@ -0,0 +1,1624 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/cli/worldmodel.ts
+var worldmodel_exports = {};
+__export(worldmodel_exports, {
+  main: () => main
+});
+module.exports = __toCommonJS(worldmodel_exports);
+var import_promises = require("fs/promises");
+var import_fs = require("fs");
+var import_path = require("path");
+
+// src/engine/worldmodel-parser.ts
+function splitSections(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;
+    }
+  }
+  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);
+    }
+  }
+  if (currentSection) {
+    currentSection.content = contentLines.join("\n").trim();
+    sections.push(currentSection);
+  }
+  return { frontmatter, sections };
+}
+function splitH2Sections(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 parseFrontmatter(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 = splitH2Sections(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 = splitH2Sections(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 = splitH2Sections(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 } = splitSections(markdown);
+  const frontmatter = parseFrontmatter(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
+  };
+}
+
+// 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)
+  };
+}
+
+// src/cli/worldmodel.ts
+var BOLD = "\x1B[1m";
+var DIM = "\x1B[2m";
+var CYAN = "\x1B[36m";
+var GREEN = "\x1B[32m";
+var YELLOW = "\x1B[33m";
+var RED = "\x1B[31m";
+var MAGENTA = "\x1B[35m";
+var RESET = "\x1B[0m";
+var USAGE = `
+neuroverse worldmodel \u2014 Behavioral world model toolkit
+
+  ${BOLD}This file defines how a system behaves, how that behavior
+  is interpreted, and how it evolves over time.${RESET}
+
+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();
+function parseArgs(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" ? YELLOW : DIM;
+  const icon = issue.severity === "error" ? "x" : issue.severity === "warning" ? "!" : "i";
+  const lineRef = issue.line > 0 ? `:${issue.line}` : "";
+  return `  ${color}${icon}${RESET} [${issue.section}${lineRef}] ${issue.message}`;
+}
+async function readSourceFile(inputPath) {
+  const fullPath = (0, import_path.resolve)(inputPath);
+  if (!(0, import_fs.existsSync)(fullPath)) {
+    process.stderr.write(`File not found: ${fullPath}
+`);
+    process.exit(3);
+  }
+  return (0, import_promises.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}${RESET}
+`);
+    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 = parseArgs(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_path.resolve)(
+    args.output || `./${toFileName(modelName)}.worldmodel.md`
+  );
+  if ((0, import_fs.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_path.dirname)(outputPath);
+  if (!(0, import_fs.existsSync)(dir)) {
+    await (0, import_promises.mkdir)(dir, { recursive: true });
+  }
+  await (0, import_promises.writeFile)(outputPath, template, "utf-8");
+  process.stderr.write(`${GREEN}Created${RESET} ${outputPath}
+`);
+  process.stderr.write(
+    `${DIM}Edit the template, then run: neuroverse worldmodel validate ${(0, import_path.basename)(outputPath)}${RESET}
+`
+  );
+}
+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 = parseArgs(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 summary = 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, issues: result.issues }, null, 2) + "\n"
+    );
+    process.exit(errors.length > 0 ? 1 : 0);
+    return;
+  }
+  if (errors.length === 0) {
+    process.stderr.write(
+      `${GREEN}Valid${RESET} ${args.inputPath}
+`
+    );
+  } else {
+    process.stderr.write(
+      `${RED}Invalid${RESET} ${args.inputPath}
+`
+    );
+  }
+  if (result.model) {
+    const m = result.model;
+    process.stderr.write(
+      `${DIM}  Domains: ${m.geometry.domains.length}  Overlaps: ${m.geometry.overlapEffects.length}  Signals: ${m.evolution.signals.length}${RESET}
+`
+    );
+  }
+  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 = parseArgs(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(`
+${BOLD}MODEL:${RESET} ${model.frontmatter.name} (v${model.frontmatter.version})
+
+`);
+  out.write(`${CYAN}${BOLD}CORE MODEL GEOMETRY${RESET}
+`);
+  out.write(`  ${BOLD}Mission:${RESET} ${model.geometry.mission}
+`);
+  const domainNames = model.geometry.domains.map((d) => d.name).join(", ");
+  out.write(
+    `  ${BOLD}Domains (${model.geometry.domains.length}):${RESET} ${domainNames}
+`
+  );
+  for (const domain of model.geometry.domains) {
+    out.write(`
+  ${MAGENTA}${domain.name}${RESET}
+`);
+    if (domain.skills.length > 0) {
+      out.write(`    ${DIM}Skills:${RESET} ${domain.skills.join(", ")}
+`);
+    }
+    if (domain.values.length > 0) {
+      out.write(`    ${DIM}Values:${RESET} ${domain.values.join(", ")}
+`);
+    }
+  }
+  if (model.geometry.overlapEffects.length > 0) {
+    out.write(`
+  ${BOLD}Overlaps (${model.geometry.overlapEffects.length}):${RESET}
+`);
+    for (const o of model.geometry.overlapEffects) {
+      out.write(`    ${o.domainA} + ${o.domainB} = ${GREEN}${o.effect}${RESET}
+`);
+    }
+  }
+  if (model.geometry.centerIdentity) {
+    out.write(
+      `
+  ${BOLD}Center Identity:${RESET} ${GREEN}${model.geometry.centerIdentity}${RESET}
+`
+    );
+  }
+  out.write(`
+${CYAN}${BOLD}CONTEXTUAL MODIFIERS${RESET}
+`);
+  if (model.modifiers.authorityLayers.length > 0) {
+    out.write(
+      `  ${BOLD}Authority:${RESET} ${model.modifiers.authorityLayers.join(", ")}
+`
+    );
+  }
+  if (model.modifiers.spatialContexts.length > 0) {
+    out.write(
+      `  ${BOLD}Spatial:${RESET} ${model.modifiers.spatialContexts.join(", ")}
+`
+    );
+  }
+  if (model.modifiers.interpretationRules.length > 0) {
+    out.write(
+      `  ${BOLD}Interpretation Rules:${RESET} ${model.modifiers.interpretationRules.length} defined
+`
+    );
+    for (const rule of model.modifiers.interpretationRules) {
+      out.write(`    ${DIM}- ${rule}${RESET}
+`);
+    }
+  }
+  out.write(`
+${CYAN}${BOLD}EVOLUTION LAYER${RESET}
+`);
+  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(`
+${DIM}---${RESET}
+`);
+  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 ${GREEN}${overlapEffects}${RESET} when domains interact well.
+`
+    );
+  }
+  if (model.evolution.driftBehaviors.length > 0) {
+    const driftSample = model.evolution.driftBehaviors.slice(0, 3).join("; ");
+    out.write(`Drift shows as: ${YELLOW}${driftSample}${RESET}.
+`);
+  }
+  if (model.geometry.centerIdentity) {
+    out.write(
+      `When aligned, the system becomes: ${GREEN}${BOLD}${model.geometry.centerIdentity}${RESET}.
+`
+    );
+  }
+  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 = parseArgs(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:${RESET}
+`);
+    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(`${YELLOW}Warnings:${RESET}
+`);
+    for (const issue of warnings) {
+      process.stderr.write(formatIssue(issue) + "\n");
+    }
+    process.stderr.write("\n");
+  }
+  const output = compileWorldModel(model);
+  const outputDir = (0, import_path.resolve)(
+    args.output || `.neuroverse/worldmodels/${model.frontmatter.model_id}/`
+  );
+  if (!(0, import_fs.existsSync)(outputDir)) {
+    await (0, import_promises.mkdir)(outputDir, { recursive: true });
+  }
+  const worldPath = (0, import_path.join)(outputDir, `${model.frontmatter.model_id}.nv-world.md`);
+  const signalsPath = (0, import_path.join)(outputDir, "signals.json");
+  const overlapsPath = (0, import_path.join)(outputDir, "overlaps.json");
+  const contextsPath = (0, import_path.join)(outputDir, "contexts.json");
+  const lensesPath = (0, import_path.join)(outputDir, "lenses.json");
+  await Promise.all([
+    (0, import_promises.writeFile)(worldPath, output.worldMarkdown, "utf-8"),
+    (0, import_promises.writeFile)(signalsPath, JSON.stringify(output.signalSchema, null, 2) + "\n", "utf-8"),
+    (0, import_promises.writeFile)(overlapsPath, JSON.stringify(output.overlapMap, null, 2) + "\n", "utf-8"),
+    (0, import_promises.writeFile)(contextsPath, JSON.stringify(output.contextsConfig, null, 2) + "\n", "utf-8"),
+    (0, import_promises.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(`${GREEN}Built${RESET} ${model.frontmatter.name}
+
+`);
+    process.stderr.write(`  ${BOLD}Output:${RESET} ${outputDir}/
+`);
+    process.stderr.write(`    ${(0, import_path.basename)(worldPath)}${DIM}  \u2014 executable world${RESET}
+`);
+    process.stderr.write(`    signals.json${DIM}     \u2014 signal schema${RESET}
+`);
+    process.stderr.write(`    overlaps.json${DIM}    \u2014 overlap map${RESET}
+`);
+    process.stderr.write(`    contexts.json${DIM}    \u2014 contextual modifiers${RESET}
+`);
+    process.stderr.write(`    lenses.json${DIM}      \u2014 lens suggestions${RESET}
+
+`);
+    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(
+      `  ${DIM}${invariantCount} invariants, ${model.evolution.signals.length + 1} state vars, ${ruleCount} rules, 5 gates, ${model.geometry.overlapEffects.length} lenses${RESET}
+`
+    );
+    process.stderr.write(
+      `
+  ${DIM}Next: neuroverse bootstrap --input ${worldPath} --output ${outputDir}${RESET}
+`
+    );
+  }
+}
+async function cmdEmitWorld(argv) {
+  const args = parseArgs(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_path.dirname)((0, import_path.resolve)(args.output));
+    if (!(0, import_fs.existsSync)(dir)) await (0, import_promises.mkdir)(dir, { recursive: true });
+    await (0, import_promises.writeFile)((0, import_path.resolve)(args.output), markdown, "utf-8");
+    process.stderr.write(`${GREEN}Written${RESET} ${args.output}
+`);
+  } else {
+    process.stdout.write(markdown);
+  }
+}
+async function cmdEmitSignals(argv) {
+  const args = parseArgs(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 = parseArgs(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 = parseArgs(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 = parseArgs(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 main(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(USAGE + "\n");
+      break;
+    default:
+      process.stderr.write(`Unknown worldmodel command: "${subcommand}"
+
+`);
+      process.stdout.write(USAGE + "\n");
+      process.exit(1);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  main
+});