@neuroverseos/governance 0.1.0 → 0.1.2

package/dist/index.cjs

@@ -0,0 +1,4227 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BOOTSTRAP_EXIT_CODES: () => BOOTSTRAP_EXIT_CODES,
+  CONFIGURE_AI_EXIT_CODES: () => CONFIGURE_AI_EXIT_CODES,
+  CompositeAuditLogger: () => CompositeAuditLogger,
+  ConsoleAuditLogger: () => ConsoleAuditLogger,
+  DERIVE_EXIT_CODES: () => DERIVE_EXIT_CODES,
+  FileAuditLogger: () => FileAuditLogger,
+  GUARD_EXIT_CODES: () => GUARD_EXIT_CODES,
+  VALIDATE_EXIT_CODES: () => VALIDATE_EXIT_CODES,
+  createGovernanceEngine: () => createGovernanceEngine,
+  deriveWorld: () => deriveWorld,
+  emitWorldDefinition: () => emitWorldDefinition,
+  evaluateCondition: () => evaluateCondition,
+  evaluateGuard: () => evaluateGuard,
+  eventToAllowlistKey: () => eventToAllowlistKey,
+  explainWorld: () => explainWorld,
+  extractWorldMarkdown: () => extractWorldMarkdown,
+  formatVerdict: () => formatVerdict,
+  formatVerdictOneLine: () => formatVerdictOneLine,
+  generateImpactReport: () => generateImpactReport,
+  generateImpactReportFromFile: () => generateImpactReportFromFile,
+  improveWorld: () => improveWorld,
+  loadWorld: () => loadWorld,
+  loadWorldFromDirectory: () => loadWorldFromDirectory,
+  normalizeWorldMarkdown: () => normalizeWorldMarkdown,
+  parseWorldMarkdown: () => parseWorldMarkdown,
+  readAuditLog: () => readAuditLog,
+  renderExplainText: () => renderExplainText,
+  renderImpactReport: () => renderImpactReport,
+  renderImproveText: () => renderImproveText,
+  renderSimulateText: () => renderSimulateText,
+  simulateWorld: () => simulateWorld,
+  summarizeAuditEvents: () => summarizeAuditEvents,
+  validateWorld: () => validateWorld,
+  verdictToAuditEvent: () => verdictToAuditEvent
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/engine/guard-engine.ts
+var PROMPT_INJECTION_PATTERNS = [
+  // Instruction override
+  { pattern: /ignore\s+(previous|all|prior|above)\s+(instructions?|rules?)/i, label: "ignore-instructions" },
+  { pattern: /disregard\s+(your|the)\s+(rules|constraints)/i, label: "disregard-rules" },
+  { pattern: /new\s+instructions?:/i, label: "new-instructions" },
+  // Identity manipulation
+  { pattern: /you\s+are\s+now/i, label: "identity-override" },
+  { pattern: /new\s+persona/i, label: "new-persona" },
+  { pattern: /act\s+as\s+if/i, label: "act-as-if" },
+  { pattern: /pretend\s+(you|to\s+be|you\s+are\s+unrestricted)/i, label: "pretend-to-be" },
+  // Context reset
+  { pattern: /forget\s+(everything|all|your)/i, label: "forget-context" },
+  { pattern: /system\s*:\s*override/i, label: "system-override" },
+  // Constraint bypass
+  { pattern: /override\s+(your|the)\s+(programming|constraints)/i, label: "override-constraints" },
+  { pattern: /bypass\s+(your|the)\s+(filters|constraints|rules)/i, label: "bypass-filters" },
+  // Prompt extraction
+  { pattern: /system\s+prompt/i, label: "system-prompt-probe" },
+  { pattern: /reveal\s+your\s+(instructions?|prompt|rules)/i, label: "reveal-instructions" },
+  // Known jailbreak terms
+  { pattern: /jailbreak/i, label: "jailbreak" },
+  { pattern: /DAN\s+mode/i, label: "dan-mode" },
+  { pattern: /developer\s+mode/i, label: "developer-mode" }
+];
+var EXECUTION_CLAIM_PATTERNS = [
+  { pattern: /I have (executed|completed|performed|done|made|created|sent|deleted|modified|updated)/i, label: "claim-i-have" },
+  { pattern: /Successfully (created|deleted|modified|updated|sent|executed|performed)/i, label: "claim-successfully" },
+  { pattern: /The file has been/i, label: "claim-file-modified" },
+  { pattern: /I've made the changes/i, label: "claim-made-changes" },
+  { pattern: /I('ve| have) (sent|posted|submitted|uploaded|downloaded)/i, label: "claim-sent" },
+  { pattern: /Your (email|message|file|request) has been (sent|submitted)/i, label: "claim-your-sent" },
+  { pattern: /Transaction complete/i, label: "claim-transaction" },
+  { pattern: /Order placed/i, label: "claim-order" },
+  { pattern: /Payment processed/i, label: "claim-payment" }
+];
+var EXECUTION_INTENT_PATTERNS = [
+  { pattern: /^(execute|run|perform|do this)/i, label: "intent-execute" },
+  { pattern: /^(create|write|delete|modify) (a |the )?(file|folder|document)/i, label: "intent-file-ops" },
+  { pattern: /^(send|post|submit) (a |an |the )?(email|message|tweet|post)/i, label: "intent-send" },
+  { pattern: /^(search|look up|browse) (the )?web/i, label: "intent-web-search" },
+  { pattern: /^(make|call|invoke) (a |an )?(api|http|rest) (call|request)/i, label: "intent-api-call" },
+  { pattern: /^(buy|purchase|order|pay|transfer|send money)/i, label: "intent-financial" },
+  { pattern: /^(book|schedule|reserve)/i, label: "intent-booking" },
+  { pattern: /^(download|upload|save to|export to)/i, label: "intent-transfer" }
+];
+var SCOPE_ESCAPE_PATTERNS = [
+  { pattern: /\.\.\//, label: "parent-traversal" },
+  { pattern: /^\/(?!home|project|workspace)/i, label: "absolute-path-outside-safe" },
+  { pattern: /~\//, label: "home-directory" },
+  { pattern: /\/etc\//i, label: "system-config" },
+  { pattern: /\/usr\//i, label: "system-binaries" },
+  { pattern: /\/var\//i, label: "system-variable-data" }
+];
+var NEUTRAL_MESSAGES = {
+  "prompt-injection": "This input contains patterns that could alter agent behavior.",
+  "scope-escape": "This action would affect resources outside the declared scope.",
+  "execution-claim": "This response claims to have performed an action.",
+  "execution-intent": "This input requests execution in a thinking-only environment.",
+  "delete": "This action would remove files. Confirmation needed.",
+  "write-external": "This action would write outside the project folder.",
+  "network-mutate": "This action would send data to an external service.",
+  "credential-access": "This action would access stored credentials."
+};
+function levelRequiresConfirmation(level, actionType) {
+  if (level === "strict") return true;
+  if (level === "standard") {
+    return actionType === "delete" || actionType === "credential-access";
+  }
+  return false;
+}
+function isExternalScope(scope) {
+  const internalPatterns = [
+    /^\.?\/?src\//i,
+    /^\.?\/?lib\//i,
+    /^\.?\/?app\//i,
+    /^\.?\/?components\//i,
+    /^\.?\/?pages\//i,
+    /^\.?\/?public\//i,
+    /^\.?\/?assets\//i,
+    /^\.\//
+  ];
+  return !internalPatterns.some((p) => p.test(scope));
+}
+function evaluateGuard(event, world, options = {}) {
+  const startTime = performance.now();
+  const level = options.level ?? "standard";
+  const includeTrace = options.trace ?? false;
+  const eventText = (event.intent + " " + (event.tool ?? "") + " " + (event.scope ?? "")).toLowerCase();
+  const invariantChecks = [];
+  const safetyChecks = [];
+  const roleChecks = [];
+  const guardChecks = [];
+  const kernelRuleChecks = [];
+  const levelChecks = [];
+  let decidingLayer = "default-allow";
+  let decidingId;
+  const guardsMatched = [];
+  const rulesMatched = [];
+  checkInvariantCoverage(world, invariantChecks);
+  if (options.sessionAllowlist) {
+    const key = eventToAllowlistKey(event);
+    if (options.sessionAllowlist.has(key)) {
+      decidingLayer = "session-allowlist";
+      decidingId = `allowlist:${key}`;
+      return buildVerdict(
+        "ALLOW",
+        void 0,
+        `allowlist:${key}`,
+        void 0,
+        world,
+        level,
+        invariantChecks,
+        guardsMatched,
+        rulesMatched,
+        includeTrace ? buildTrace(
+          invariantChecks,
+          safetyChecks,
+          roleChecks,
+          guardChecks,
+          kernelRuleChecks,
+          levelChecks,
+          decidingLayer,
+          decidingId,
+          startTime
+        ) : void 0
+      );
+    }
+  }
+  const safetyVerdict = checkSafety(event, eventText, safetyChecks);
+  if (safetyVerdict) {
+    decidingLayer = "safety";
+    decidingId = safetyVerdict.ruleId;
+    return buildVerdict(
+      safetyVerdict.status,
+      safetyVerdict.reason,
+      safetyVerdict.ruleId,
+      void 0,
+      world,
+      level,
+      invariantChecks,
+      guardsMatched,
+      rulesMatched,
+      includeTrace ? buildTrace(
+        invariantChecks,
+        safetyChecks,
+        roleChecks,
+        guardChecks,
+        kernelRuleChecks,
+        levelChecks,
+        decidingLayer,
+        decidingId,
+        startTime
+      ) : void 0
+    );
+  }
+  const roleVerdict = checkRoleRules(event, eventText, world, roleChecks);
+  if (roleVerdict) {
+    decidingLayer = "role";
+    decidingId = roleVerdict.ruleId;
+    return buildVerdict(
+      roleVerdict.status,
+      roleVerdict.reason,
+      roleVerdict.ruleId,
+      void 0,
+      world,
+      level,
+      invariantChecks,
+      guardsMatched,
+      rulesMatched,
+      includeTrace ? buildTrace(
+        invariantChecks,
+        safetyChecks,
+        roleChecks,
+        guardChecks,
+        kernelRuleChecks,
+        levelChecks,
+        decidingLayer,
+        decidingId,
+        startTime
+      ) : void 0
+    );
+  }
+  const guardVerdict = checkGuards(event, eventText, world, guardChecks, guardsMatched);
+  if (guardVerdict) {
+    if (guardVerdict.status !== "ALLOW") {
+      decidingLayer = "guard";
+      decidingId = guardVerdict.ruleId;
+      return buildVerdict(
+        guardVerdict.status,
+        guardVerdict.reason,
+        guardVerdict.ruleId,
+        void 0,
+        world,
+        level,
+        invariantChecks,
+        guardsMatched,
+        rulesMatched,
+        includeTrace ? buildTrace(
+          invariantChecks,
+          safetyChecks,
+          roleChecks,
+          guardChecks,
+          kernelRuleChecks,
+          levelChecks,
+          decidingLayer,
+          decidingId,
+          startTime
+        ) : void 0
+      );
+    }
+  }
+  const kernelVerdict = checkKernelRules(eventText, world, kernelRuleChecks, rulesMatched);
+  if (kernelVerdict) {
+    decidingLayer = "kernel-rule";
+    decidingId = kernelVerdict.ruleId;
+    return buildVerdict(
+      kernelVerdict.status,
+      kernelVerdict.reason,
+      kernelVerdict.ruleId,
+      void 0,
+      world,
+      level,
+      invariantChecks,
+      guardsMatched,
+      rulesMatched,
+      includeTrace ? buildTrace(
+        invariantChecks,
+        safetyChecks,
+        roleChecks,
+        guardChecks,
+        kernelRuleChecks,
+        levelChecks,
+        decidingLayer,
+        decidingId,
+        startTime
+      ) : void 0
+    );
+  }
+  const levelVerdict = checkLevelConstraints(event, level, levelChecks);
+  if (levelVerdict) {
+    decidingLayer = "level-constraint";
+    decidingId = levelVerdict.ruleId;
+    return buildVerdict(
+      levelVerdict.status,
+      levelVerdict.reason,
+      levelVerdict.ruleId,
+      void 0,
+      world,
+      level,
+      invariantChecks,
+      guardsMatched,
+      rulesMatched,
+      includeTrace ? buildTrace(
+        invariantChecks,
+        safetyChecks,
+        roleChecks,
+        guardChecks,
+        kernelRuleChecks,
+        levelChecks,
+        decidingLayer,
+        decidingId,
+        startTime
+      ) : void 0
+    );
+  }
+  const warning = guardVerdict?.warning;
+  return buildVerdict(
+    "ALLOW",
+    void 0,
+    void 0,
+    warning,
+    world,
+    level,
+    invariantChecks,
+    guardsMatched,
+    rulesMatched,
+    includeTrace ? buildTrace(
+      invariantChecks,
+      safetyChecks,
+      roleChecks,
+      guardChecks,
+      kernelRuleChecks,
+      levelChecks,
+      decidingLayer,
+      decidingId,
+      startTime
+    ) : void 0
+  );
+}
+function checkInvariantCoverage(world, checks) {
+  const invariants = world.invariants ?? [];
+  const guards = world.guards?.guards ?? [];
+  for (const invariant of invariants) {
+    const coveringGuard = guards.find(
+      (g) => g.invariant_ref === invariant.id && g.immutable
+    );
+    checks.push({
+      invariantId: invariant.id,
+      label: invariant.label,
+      hasGuardCoverage: !!coveringGuard,
+      coveringGuardId: coveringGuard?.id
+    });
+  }
+}
+function checkSafety(event, eventText, checks) {
+  const textToCheck = event.intent + (event.payload ? JSON.stringify(event.payload) : "");
+  for (const { pattern, label } of PROMPT_INJECTION_PATTERNS) {
+    const triggered = pattern.test(textToCheck);
+    checks.push({
+      checkType: "prompt-injection",
+      triggered,
+      matchedPattern: triggered ? label : void 0
+    });
+    if (triggered) {
+      for (const remaining of PROMPT_INJECTION_PATTERNS.filter((p) => p.label !== label)) {
+        checks.push({
+          checkType: "prompt-injection",
+          triggered: remaining.pattern.test(textToCheck),
+          matchedPattern: remaining.pattern.test(textToCheck) ? remaining.label : void 0
+        });
+      }
+      return {
+        status: "PAUSE",
+        reason: NEUTRAL_MESSAGES["prompt-injection"],
+        ruleId: `safety-injection-${label}`
+      };
+    }
+  }
+  const scopeToCheck = event.scope ?? event.intent;
+  for (const { pattern, label } of SCOPE_ESCAPE_PATTERNS) {
+    const triggered = pattern.test(scopeToCheck);
+    checks.push({
+      checkType: "scope-escape",
+      triggered,
+      matchedPattern: triggered ? label : void 0
+    });
+    if (triggered) {
+      for (const remaining of SCOPE_ESCAPE_PATTERNS.filter((p) => p.label !== label)) {
+        checks.push({
+          checkType: "scope-escape",
+          triggered: remaining.pattern.test(scopeToCheck),
+          matchedPattern: remaining.pattern.test(scopeToCheck) ? remaining.label : void 0
+        });
+      }
+      return {
+        status: "PAUSE",
+        reason: NEUTRAL_MESSAGES["scope-escape"],
+        ruleId: `safety-scope-${label}`
+      };
+    }
+  }
+  if (event.direction === "output") {
+    for (const { pattern, label } of EXECUTION_CLAIM_PATTERNS) {
+      const triggered = pattern.test(textToCheck);
+      checks.push({
+        checkType: "execution-claim",
+        triggered,
+        matchedPattern: triggered ? label : void 0
+      });
+      if (triggered) {
+        for (const remaining of EXECUTION_CLAIM_PATTERNS.filter((p) => p.label !== label)) {
+          checks.push({
+            checkType: "execution-claim",
+            triggered: remaining.pattern.test(textToCheck),
+            matchedPattern: remaining.pattern.test(textToCheck) ? remaining.label : void 0
+          });
+        }
+        return {
+          status: "PAUSE",
+          reason: NEUTRAL_MESSAGES["execution-claim"],
+          ruleId: `safety-execution-claim-${label}`
+        };
+      }
+    }
+  }
+  if (event.direction === "input") {
+    const intentTrimmed = event.intent.trim();
+    for (const { pattern, label } of EXECUTION_INTENT_PATTERNS) {
+      const triggered = pattern.test(intentTrimmed);
+      checks.push({
+        checkType: "execution-intent",
+        triggered,
+        matchedPattern: triggered ? label : void 0
+      });
+      if (triggered) {
+        for (const remaining of EXECUTION_INTENT_PATTERNS.filter((p) => p.label !== label)) {
+          checks.push({
+            checkType: "execution-intent",
+            triggered: remaining.pattern.test(intentTrimmed),
+            matchedPattern: remaining.pattern.test(intentTrimmed) ? remaining.label : void 0
+          });
+        }
+        return {
+          status: "PAUSE",
+          reason: NEUTRAL_MESSAGES["execution-intent"],
+          ruleId: `safety-execution-intent-${label}`
+        };
+      }
+    }
+  }
+  return null;
+}
+function checkRoleRules(event, eventText, world, checks) {
+  if (!event.roleId || !world.roles) return null;
+  const role = world.roles.roles.find((r) => r.id === event.roleId);
+  if (!role) return null;
+  if (role.requiresApproval) {
+    checks.push({
+      roleId: role.id,
+      roleName: role.name,
+      rule: "All actions require approval",
+      ruleType: "requiresApproval",
+      matched: true
+    });
+    return {
+      status: "PAUSE",
+      reason: `Role "${role.name}" requires approval for all actions.`,
+      ruleId: `role-${role.id}-requires-approval`
+    };
+  }
+  for (const rule of role.cannotDo) {
+    const matched = matchesKeywords(eventText, rule);
+    checks.push({
+      roleId: role.id,
+      roleName: role.name,
+      rule,
+      ruleType: "cannotDo",
+      matched
+    });
+    if (matched) {
+      return {
+        status: "BLOCK",
+        reason: `Role "${role.name}" cannot: ${rule}`,
+        ruleId: `role-${role.id}-cannotdo`
+      };
+    }
+  }
+  for (const rule of role.canDo) {
+    checks.push({
+      roleId: role.id,
+      roleName: role.name,
+      rule,
+      ruleType: "canDo",
+      matched: matchesKeywords(eventText, rule)
+    });
+  }
+  return null;
+}
+function checkGuards(event, eventText, world, checks, guardsMatched) {
+  if (!world.guards) return null;
+  const guardsConfig = world.guards;
+  let warnResult = null;
+  const compiledPatterns = /* @__PURE__ */ new Map();
+  for (const [key, def] of Object.entries(guardsConfig.intent_vocabulary)) {
+    try {
+      compiledPatterns.set(key, new RegExp(def.pattern, "i"));
+    } catch {
+    }
+  }
+  const eventTool = (event.tool ?? "").toLowerCase();
+  for (const guard of guardsConfig.guards) {
+    if (guard.appliesTo && guard.appliesTo.length > 0) {
+      const normalizedAppliesTo = guard.appliesTo.map((t) => t.toLowerCase());
+      if (!normalizedAppliesTo.includes(eventTool)) {
+        continue;
+      }
+    }
+    const enabled = guard.immutable || guard.default_enabled !== false;
+    const matchedPatterns = [];
+    for (const patternKey of guard.intent_patterns) {
+      const regex = compiledPatterns.get(patternKey);
+      if (regex?.test(eventText)) {
+        matchedPatterns.push(patternKey);
+      }
+    }
+    const matched = matchedPatterns.length > 0 && enabled;
+    let roleGated = false;
+    if (matched && guard.required_roles && guard.required_roles.length > 0 && event.roleId && guard.required_roles.includes(event.roleId)) {
+      roleGated = true;
+    }
+    checks.push({
+      guardId: guard.id,
+      label: guard.label,
+      category: guard.category,
+      enabled,
+      matched: matched && !roleGated,
+      enforcement: guard.enforcement,
+      matchedPatterns,
+      roleGated
+    });
+    if (!matched || roleGated) continue;
+    guardsMatched.push(guard.id);
+    const actionMode = guard.player_modes?.action ?? guard.enforcement;
+    const reason = guard.redirect ? `${guard.description} \u2014 ${guard.redirect}` : guard.description;
+    if (actionMode === "block") {
+      return { status: "BLOCK", reason, ruleId: `guard-${guard.id}` };
+    }
+    if (actionMode === "pause") {
+      return { status: "PAUSE", reason, ruleId: `guard-${guard.id}` };
+    }
+    if (actionMode === "warn" && !warnResult) {
+      warnResult = { status: "ALLOW", warning: reason, ruleId: `guard-${guard.id}` };
+    }
+  }
+  return warnResult;
+}
+function checkKernelRules(eventText, world, checks, rulesMatched) {
+  if (!world.kernel) return null;
+  const forbidden = world.kernel.input_boundaries?.forbidden_patterns ?? [];
+  const output = world.kernel.output_boundaries?.forbidden_patterns ?? [];
+  for (const rule of forbidden) {
+    let matched = false;
+    let matchMethod = "none";
+    if (rule.pattern) {
+      try {
+        matched = new RegExp(rule.pattern, "i").test(eventText);
+        matchMethod = "pattern";
+      } catch {
+      }
+    }
+    if (!matched && rule.reason) {
+      matched = matchesKeywords(eventText, rule.reason);
+      if (matched) matchMethod = "keyword";
+    }
+    checks.push({
+      ruleId: rule.id,
+      text: rule.reason,
+      category: "forbidden",
+      matched,
+      matchMethod
+    });
+    if (matched) {
+      rulesMatched.push(rule.id);
+      if (rule.action === "BLOCK") {
+        return {
+          status: "BLOCK",
+          reason: rule.reason,
+          ruleId: `kernel-${rule.id}`
+        };
+      }
+    }
+  }
+  return null;
+}
+function checkLevelConstraints(event, level, checks) {
+  if (level === "basic") return null;
+  const intent = event.intent.toLowerCase();
+  const tool = (event.tool ?? "").toLowerCase();
+  const isDelete = intent.includes("delete") || intent.includes("remove") || intent.includes("rm ") || tool === "delete";
+  const deleteTriggered = isDelete && levelRequiresConfirmation(level, "delete");
+  checks.push({
+    checkType: "delete",
+    level,
+    triggered: deleteTriggered,
+    reason: deleteTriggered ? NEUTRAL_MESSAGES["delete"] : void 0
+  });
+  if (deleteTriggered) {
+    return { status: "PAUSE", reason: NEUTRAL_MESSAGES["delete"], ruleId: "level-delete-check" };
+  }
+  const isExternal = event.scope ? isExternalScope(event.scope) : false;
+  const externalTriggered = isExternal && levelRequiresConfirmation(level, "write-external");
+  checks.push({
+    checkType: "write-external",
+    level,
+    triggered: externalTriggered,
+    reason: externalTriggered ? NEUTRAL_MESSAGES["write-external"] : void 0
+  });
+  if (externalTriggered) {
+    return { status: "PAUSE", reason: NEUTRAL_MESSAGES["write-external"], ruleId: "level-external-write-check" };
+  }
+  const isNetwork = tool === "http" || tool === "fetch" || tool === "request" || intent.includes("post ") || intent.includes("sending");
+  const networkTriggered = isNetwork && levelRequiresConfirmation(level, "network-mutate");
+  checks.push({
+    checkType: "network-mutate",
+    level,
+    triggered: networkTriggered,
+    reason: networkTriggered ? NEUTRAL_MESSAGES["network-mutate"] : void 0
+  });
+  if (networkTriggered) {
+    return { status: "PAUSE", reason: NEUTRAL_MESSAGES["network-mutate"], ruleId: "level-network-mutate-check" };
+  }
+  const isCredential = intent.includes("credential") || intent.includes("password") || intent.includes("secret") || intent.includes("api key") || intent.includes("token");
+  const credentialTriggered = isCredential && levelRequiresConfirmation(level, "credential-access");
+  checks.push({
+    checkType: "credential-access",
+    level,
+    triggered: credentialTriggered,
+    reason: credentialTriggered ? NEUTRAL_MESSAGES["credential-access"] : void 0
+  });
+  if (credentialTriggered) {
+    return { status: "PAUSE", reason: NEUTRAL_MESSAGES["credential-access"], ruleId: "level-credential-check" };
+  }
+  const irreversibleTriggered = !!event.irreversible && level !== "basic";
+  checks.push({
+    checkType: "irreversible",
+    level,
+    triggered: irreversibleTriggered,
+    reason: irreversibleTriggered ? "This action is marked as irreversible." : void 0
+  });
+  if (irreversibleTriggered) {
+    return {
+      status: "PAUSE",
+      reason: "This action is marked as irreversible.",
+      ruleId: "level-irreversible-check"
+    };
+  }
+  return null;
+}
+function matchesKeywords(eventText, ruleText) {
+  const keywords = ruleText.toLowerCase().split(/\s+/).filter((w) => w.length > 3);
+  if (keywords.length === 0) return false;
+  return keywords.every((kw) => eventText.includes(kw));
+}
+function eventToAllowlistKey(event) {
+  return `${(event.tool ?? "*").toLowerCase()}::${event.intent.toLowerCase().trim()}`;
+}
+function buildTrace(invariantChecks, safetyChecks, roleChecks, guardChecks, kernelRuleChecks, levelChecks, decidingLayer, decidingId, startTime) {
+  return {
+    invariantChecks,
+    safetyChecks,
+    roleChecks,
+    guardChecks,
+    kernelRuleChecks,
+    levelChecks,
+    precedenceResolution: {
+      decidingLayer,
+      decidingId,
+      strategy: "first-match-wins",
+      chainOrder: [
+        "invariant-coverage",
+        "session-allowlist",
+        "safety-injection",
+        "safety-scope-escape",
+        "safety-execution-claim",
+        "safety-execution-intent",
+        "role-rules",
+        "declarative-guards",
+        "kernel-rules",
+        "level-constraints",
+        "default-allow"
+      ]
+    },
+    durationMs: performance.now() - startTime
+  };
+}
+function buildVerdict(status, reason, ruleId, warning, world, level, invariantChecks, guardsMatched, rulesMatched, trace) {
+  const evidence = {
+    worldId: world.world.world_id,
+    worldName: world.world.name,
+    worldVersion: world.world.version,
+    evaluatedAt: Date.now(),
+    invariantsSatisfied: invariantChecks.filter((c2) => c2.hasGuardCoverage).length,
+    invariantsTotal: invariantChecks.length,
+    guardsMatched,
+    rulesMatched,
+    enforcementLevel: level
+  };
+  const verdict = {
+    status,
+    evidence
+  };
+  if (reason) verdict.reason = reason;
+  if (ruleId) verdict.ruleId = ruleId;
+  if (warning) verdict.warning = warning;
+  if (trace) verdict.trace = trace;
+  return verdict;
+}
+
+// src/contracts/guard-contract.ts
+var GUARD_EXIT_CODES = {
+  ALLOW: 0,
+  BLOCK: 1,
+  PAUSE: 2,
+  ERROR: 3
+};
+
+// src/engine/audit-logger.ts
+var 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: mkdir2 } = await import("fs/promises");
+      const { dirname: dirname2 } = await import("path");
+      await mkdir2(dirname2(this.logPath), { recursive: true });
+      await appendFile(this.logPath, lines, "utf-8");
+    } catch {
+    }
+  }
+};
+var ConsoleAuditLogger = class {
+  log(event) {
+    const icon = event.decision === "ALLOW" ? "\u2713" : event.decision === "BLOCK" ? "\u2717" : "\u23F8";
+    const ts = event.timestamp.split("T")[1]?.replace("Z", "") ?? event.timestamp;
+    process.stderr.write(
+      `[${ts}] ${icon} ${event.decision.padEnd(5)} ${event.actor ?? "\u2014"} \u2192 ${event.intent}${event.reason ? ` (${event.reason})` : ""}
+`
+    );
+  }
+};
+var CompositeAuditLogger = class {
+  loggers;
+  constructor(...loggers) {
+    this.loggers = loggers;
+  }
+  log(event) {
+    for (const logger of this.loggers) {
+      try {
+        logger.log(event);
+      } catch {
+      }
+    }
+  }
+  async flush() {
+    await Promise.all(
+      this.loggers.map((l) => l.flush?.()).filter(Boolean)
+    );
+  }
+};
+function verdictToAuditEvent(event, verdict) {
+  return {
+    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
+  };
+}
+function createGovernanceEngine(world, options = {}) {
+  const { auditLogger, auditArgs, ...engineOptions } = options;
+  return {
+    /**
+     * Evaluate a governance event and log the result.
+     */
+    evaluate(event) {
+      const verdict = evaluateGuard(event, world, engineOptions);
+      if (auditLogger) {
+        const auditEvent = verdictToAuditEvent(event, verdict);
+        if (!auditArgs) {
+          delete auditEvent.args;
+        }
+        auditLogger.log(auditEvent);
+      }
+      return verdict;
+    },
+    /** Flush the audit logger. */
+    async flush() {
+      await auditLogger?.flush?.();
+    },
+    /** The underlying world definition. */
+    world
+  };
+}
+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 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 };
+    entry.count++;
+    if (e.decision === "BLOCK") entry.blocked++;
+    if (e.decision === "PAUSE") entry.paused++;
+    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);
+  return {
+    totalActions: events.length,
+    allowed,
+    blocked,
+    paused,
+    actors: [...actorSet],
+    topIntents,
+    topRules,
+    firstEvent: events[0]?.timestamp ?? "",
+    lastEvent: events[events.length - 1]?.timestamp ?? ""
+  };
+}
+
+// src/engine/verdict-formatter.ts
+var ANSI = {
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  reset: "\x1B[0m"
+};
+function c(text, ...codes) {
+  return codes.join("") + text + ANSI.reset;
+}
+function formatVerdict(verdict, options = {}) {
+  const {
+    showRuleId = true,
+    showEvidence = false,
+    showWarning = true,
+    color = false,
+    compact = false
+  } = options;
+  if (compact) {
+    return formatCompact(verdict, { showRuleId, showWarning, color });
+  }
+  return formatFull(verdict, { showRuleId, showEvidence, showWarning, color });
+}
+function formatCompact(verdict, opts) {
+  const status = formatStatus(verdict.status, opts.color);
+  const parts = [status];
+  if (opts.showRuleId && verdict.ruleId) {
+    parts.push(verdict.ruleId);
+  }
+  if (verdict.reason) {
+    parts.push(verdict.reason);
+  }
+  if (opts.showWarning && verdict.warning) {
+    parts.push(`warning: ${verdict.warning}`);
+  }
+  return parts.join(" \u2014 ");
+}
+function formatFull(verdict, opts) {
+  const lines = [];
+  lines.push(formatStatus(verdict.status, opts.color));
+  if (opts.showRuleId && verdict.ruleId) {
+    lines.push(`  Rule: ${verdict.ruleId}`);
+  }
+  if (verdict.reason) {
+    lines.push(`  Reason: ${verdict.reason}`);
+  }
+  if (opts.showWarning && verdict.warning) {
+    const label = opts.color ? c("Warning:", ANSI.yellow) : "Warning:";
+    lines.push(`  ${label} ${verdict.warning}`);
+  }
+  if (opts.showEvidence) {
+    const ev = verdict.evidence;
+    lines.push(`  World: ${ev.worldName} v${ev.worldVersion}`);
+    lines.push(`  Invariants: ${ev.invariantsSatisfied}/${ev.invariantsTotal} covered`);
+    if (ev.guardsMatched.length > 0) {
+      lines.push(`  Guards matched: ${ev.guardsMatched.join(", ")}`);
+    }
+    if (ev.rulesMatched.length > 0) {
+      lines.push(`  Rules matched: ${ev.rulesMatched.join(", ")}`);
+    }
+    lines.push(`  Enforcement: ${ev.enforcementLevel}`);
+  }
+  return lines.join("\n");
+}
+function formatStatus(status, color) {
+  switch (status) {
+    case "ALLOW":
+      return color ? c("ALLOWED", ANSI.green, ANSI.bold) : "ALLOWED";
+    case "BLOCK":
+      return color ? c("BLOCKED", ANSI.red, ANSI.bold) : "BLOCKED";
+    case "PAUSE":
+      return color ? c("PAUSED", ANSI.yellow, ANSI.bold) : "PAUSED";
+    default:
+      return status;
+  }
+}
+function formatVerdictOneLine(verdict) {
+  const parts = [verdict.status];
+  if (verdict.ruleId) {
+    parts[0] += `: ${verdict.ruleId}`;
+  }
+  if (verdict.reason) {
+    parts.push(verdict.reason);
+  }
+  return parts.join(" \u2014 ");
+}
+
+// src/engine/impact-report.ts
+function generateImpactReport(events) {
+  if (events.length === 0) {
+    return emptyReport();
+  }
+  const blocked = events.filter((e) => e.decision === "BLOCK");
+  const paused = events.filter((e) => e.decision === "PAUSE");
+  const prevented = [...blocked, ...paused];
+  const categoryMap = /* @__PURE__ */ new Map();
+  for (const e of prevented) {
+    const cat = classifyPreventionCategory(e);
+    if (!categoryMap.has(cat)) categoryMap.set(cat, /* @__PURE__ */ new Set());
+    categoryMap.get(cat).add(e.intent);
+  }
+  const preventedByCategory = [...categoryMap.entries()].map(([category, intents]) => ({
+    category,
+    count: prevented.filter((e) => classifyPreventionCategory(e) === category).length,
+    examples: [...intents].slice(0, 5)
+  })).sort((a, b) => b.count - a.count);
+  const intentMap = /* @__PURE__ */ new Map();
+  for (const e of prevented) {
+    const entry = intentMap.get(e.intent) ?? { count: 0, rules: /* @__PURE__ */ new Map() };
+    entry.count++;
+    if (e.ruleId) {
+      entry.rules.set(e.ruleId, (entry.rules.get(e.ruleId) ?? 0) + 1);
+    }
+    for (const g of e.guardsMatched) {
+      entry.rules.set(g, (entry.rules.get(g) ?? 0) + 1);
+    }
+    intentMap.set(e.intent, entry);
+  }
+  const topPreventedIntents = [...intentMap.entries()].map(([intent, data]) => {
+    let topRule = "";
+    let topCount = 0;
+    for (const [rule, count] of data.rules) {
+      if (count > topCount) {
+        topRule = rule;
+        topCount = count;
+      }
+    }
+    return { intent, count: data.count, topRule };
+  }).sort((a, b) => b.count - a.count).slice(0, 15);
+  const actorMap = /* @__PURE__ */ new Map();
+  for (const e of events) {
+    const actor = e.actor ?? "unknown";
+    const entry = actorMap.get(actor) ?? { blocked: 0, paused: 0, total: 0 };
+    entry.total++;
+    if (e.decision === "BLOCK") entry.blocked++;
+    if (e.decision === "PAUSE") entry.paused++;
+    actorMap.set(actor, entry);
+  }
+  const hotActors = [...actorMap.entries()].filter(([, data]) => data.blocked > 0 || data.paused > 0).map(([actor, data]) => ({ actor, ...data })).sort((a, b) => b.blocked + b.paused - (a.blocked + a.paused)).slice(0, 10);
+  const ruleMap = /* @__PURE__ */ new Map();
+  for (const e of prevented) {
+    const ruleIds = [e.ruleId, ...e.guardsMatched, ...e.rulesMatched].filter(Boolean);
+    for (const rId of new Set(ruleIds)) {
+      const entry = ruleMap.get(rId) ?? { blockCount: 0, pauseCount: 0 };
+      if (e.decision === "BLOCK") entry.blockCount++;
+      if (e.decision === "PAUSE") entry.pauseCount++;
+      ruleMap.set(rId, entry);
+    }
+  }
+  const mostActiveRules = [...ruleMap.entries()].map(([ruleId, data]) => ({ ruleId, ...data })).sort((a, b) => b.blockCount + b.pauseCount - (a.blockCount + a.pauseCount)).slice(0, 10);
+  const hourMap = /* @__PURE__ */ new Map();
+  for (const e of events) {
+    const hour = new Date(e.timestamp).getHours();
+    const entry = hourMap.get(hour) ?? { total: 0, blocked: 0 };
+    entry.total++;
+    if (e.decision === "BLOCK") entry.blocked++;
+    hourMap.set(hour, entry);
+  }
+  const hourlyDistribution = Array.from({ length: 24 }, (_, hour) => ({
+    hour,
+    total: hourMap.get(hour)?.total ?? 0,
+    blocked: hourMap.get(hour)?.blocked ?? 0
+  }));
+  const violationKey = (e) => `${e.actor ?? "unknown"}::${e.intent}`;
+  const violationMap = /* @__PURE__ */ new Map();
+  for (const e of blocked) {
+    const key = violationKey(e);
+    const entry = violationMap.get(key) ?? {
+      intent: e.intent,
+      actor: e.actor ?? "unknown",
+      attempts: 0,
+      firstSeen: e.timestamp,
+      lastSeen: e.timestamp
+    };
+    entry.attempts++;
+    entry.lastSeen = e.timestamp;
+    violationMap.set(key, entry);
+  }
+  const repeatViolations = [...violationMap.values()].filter((v) => v.attempts > 1).sort((a, b) => b.attempts - a.attempts).slice(0, 10);
+  return {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    periodStart: events[0].timestamp,
+    periodEnd: events[events.length - 1].timestamp,
+    worldName: events[0].worldName ?? "unknown",
+    totalEvaluations: events.length,
+    totalBlocked: blocked.length,
+    totalPaused: paused.length,
+    totalAllowed: events.length - blocked.length - paused.length,
+    preventionRate: prevented.length / events.length,
+    preventedByCategory,
+    topPreventedIntents,
+    hotActors,
+    mostActiveRules,
+    hourlyDistribution,
+    repeatViolations
+  };
+}
+function classifyPreventionCategory(event) {
+  const intent = event.intent.toLowerCase();
+  const rule = (event.ruleId ?? "").toLowerCase();
+  const combined = `${intent} ${rule}`;
+  if (combined.match(/inject|prompt|jailbreak|bypass/)) return "Prompt Injection Prevention";
+  if (combined.match(/scope|escape|traversal|path/)) return "Scope Escape Prevention";
+  if (combined.match(/delete|drop|destroy|remove|purge/)) return "Destructive Action Prevention";
+  if (combined.match(/trade|margin|position|leverage/)) return "Financial Risk Prevention";
+  if (combined.match(/withdraw|transfer|payment|fund/)) return "Unauthorized Transfer Prevention";
+  if (combined.match(/credential|secret|key|password|token/)) return "Credential Access Prevention";
+  if (combined.match(/shell|exec|command|script/)) return "Command Execution Prevention";
+  if (combined.match(/network|http|api|external/)) return "Network Access Prevention";
+  if (combined.match(/write|modify|update|alter/)) return "Unauthorized Modification Prevention";
+  if (combined.match(/approval|review|confirm/)) return "Approval Gate";
+  return "Policy Violation Prevention";
+}
+function renderImpactReport(report) {
+  const lines = [];
+  lines.push("GOVERNANCE IMPACT REPORT");
+  lines.push("\u2550".repeat(50));
+  lines.push("");
+  lines.push(`  World: ${report.worldName}`);
+  lines.push(`  Period: ${report.periodStart.split("T")[0]} \u2192 ${report.periodEnd.split("T")[0]}`);
+  lines.push(`  Generated: ${report.generatedAt}`);
+  lines.push("");
+  lines.push("SUMMARY");
+  lines.push("\u2500".repeat(50));
+  lines.push(`  Total evaluations:   ${report.totalEvaluations}`);
+  lines.push(`  Allowed:             ${report.totalAllowed}`);
+  lines.push(`  Blocked:             ${report.totalBlocked}`);
+  lines.push(`  Paused:              ${report.totalPaused}`);
+  lines.push(`  Prevention rate:     ${(report.preventionRate * 100).toFixed(1)}%`);
+  lines.push("");
+  if (report.totalBlocked > 0 || report.totalPaused > 0) {
+    lines.push("WITHOUT GOVERNANCE");
+    lines.push("\u2500".repeat(50));
+    lines.push(`  ${report.totalBlocked + report.totalPaused} actions would have executed unchecked:`);
+    for (const cat of report.preventedByCategory) {
+      lines.push(`    ${cat.category.padEnd(38)} ${String(cat.count).padStart(5)}`);
+      if (cat.examples.length > 0) {
+        lines.push(`      e.g. ${cat.examples.slice(0, 3).join(", ")}`);
+      }
+    }
+    lines.push("");
+  }
+  if (report.topPreventedIntents.length > 0) {
+    lines.push("TOP PREVENTED ACTIONS");
+    lines.push("\u2500".repeat(50));
+    for (const entry of report.topPreventedIntents.slice(0, 10)) {
+      lines.push(`  ${entry.intent.padEnd(30)} ${String(entry.count).padStart(5)}  (rule: ${entry.topRule || "\u2014"})`);
+    }
+    lines.push("");
+  }
+  if (report.hotActors.length > 0) {
+    lines.push("ACTORS WITH MOST VIOLATIONS");
+    lines.push("\u2500".repeat(50));
+    for (const actor of report.hotActors) {
+      const violations = actor.blocked + actor.paused;
+      const rate = (violations / actor.total * 100).toFixed(0);
+      lines.push(`  ${actor.actor.padEnd(25)} ${String(violations).padStart(5)} violations / ${actor.total} total (${rate}%)`);
+    }
+    lines.push("");
+  }
+  if (report.mostActiveRules.length > 0) {
+    lines.push("MOST ACTIVE RULES");
+    lines.push("\u2500".repeat(50));
+    for (const rule of report.mostActiveRules) {
+      lines.push(`  ${rule.ruleId.padEnd(30)} ${String(rule.blockCount).padStart(5)} blocked  ${String(rule.pauseCount).padStart(5)} paused`);
+    }
+    lines.push("");
+  }
+  if (report.repeatViolations.length > 0) {
+    lines.push("REPEAT VIOLATIONS");
+    lines.push("\u2500".repeat(50));
+    lines.push("  Actions attempted multiple times after being blocked:");
+    for (const v of report.repeatViolations) {
+      lines.push(`  ${v.actor.padEnd(20)} ${v.intent.padEnd(25)} ${v.attempts}x  (${v.firstSeen.split("T")[0]} \u2192 ${v.lastSeen.split("T")[0]})`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+async function generateImpactReportFromFile(logPath) {
+  const events = await readAuditLog(logPath);
+  return generateImpactReport(events);
+}
+function emptyReport() {
+  return {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    periodStart: "",
+    periodEnd: "",
+    worldName: "unknown",
+    totalEvaluations: 0,
+    totalBlocked: 0,
+    totalPaused: 0,
+    totalAllowed: 0,
+    preventionRate: 0,
+    preventedByCategory: [],
+    topPreventedIntents: [],
+    hotActors: [],
+    mostActiveRules: [],
+    hourlyDistribution: [],
+    repeatViolations: []
+  };
+}
+
+// src/loader/world-loader.ts
+async function loadWorldFromDirectory(dirPath) {
+  const { readFile: readFile3 } = await import("fs/promises");
+  const { join: join3 } = await import("path");
+  const { readdirSync } = await import("fs");
+  async function readJson(filename) {
+    try {
+      const content = await readFile3(join3(dirPath, filename), "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return void 0;
+    }
+  }
+  const worldJson = await readJson("world.json");
+  if (!worldJson) {
+    throw new Error(`Cannot read world.json in ${dirPath}`);
+  }
+  const invariantsJson = await readJson("invariants.json");
+  const assumptionsJson = await readJson("assumptions.json");
+  const stateSchemaJson = await readJson("state-schema.json");
+  const gatesJson = await readJson("gates.json");
+  const outcomesJson = await readJson("outcomes.json");
+  const guardsJson = await readJson("guards.json");
+  const rolesJson = await readJson("roles.json");
+  const kernelJson = await readJson("kernel.json");
+  const metadataJson = await readJson("metadata.json");
+  const rules = [];
+  try {
+    const rulesDir = join3(dirPath, "rules");
+    const ruleFiles = readdirSync(rulesDir).filter((f) => f.endsWith(".json")).sort();
+    for (const file of ruleFiles) {
+      const content = await readFile3(join3(rulesDir, file), "utf-8");
+      rules.push(JSON.parse(content));
+    }
+  } catch {
+  }
+  return {
+    world: worldJson,
+    invariants: invariantsJson?.invariants ?? [],
+    assumptions: assumptionsJson ?? { profiles: {}, parameter_definitions: {} },
+    stateSchema: stateSchemaJson ?? { variables: {}, presets: {} },
+    rules,
+    gates: gatesJson ?? {
+      viability_classification: [],
+      structural_override: { description: "", enforcement: "mandatory" },
+      sustainability_threshold: 0,
+      collapse_visual: { background: "", text: "", border: "", label: "" }
+    },
+    outcomes: outcomesJson ?? {
+      computed_outcomes: [],
+      comparison_layout: { primary_card: "", status_badge: "", structural_indicators: [] }
+    },
+    guards: guardsJson,
+    roles: rolesJson,
+    kernel: kernelJson,
+    metadata: metadataJson ?? {
+      format_version: "1.0.0",
+      created_at: "",
+      last_modified: "",
+      authoring_method: "manual-authoring"
+    }
+  };
+}
+async function loadWorld(worldPath) {
+  const { stat } = await import("fs/promises");
+  const info = await stat(worldPath);
+  if (info.isDirectory()) {
+    return loadWorldFromDirectory(worldPath);
+  }
+  if (worldPath.endsWith(".nv-world.zip")) {
+    throw new Error(".nv-world.zip loading not yet implemented \u2014 use a world directory");
+  }
+  throw new Error(`Cannot load world from: ${worldPath} \u2014 expected a directory or .nv-world.zip`);
+}
+
+// src/engine/condition-engine.ts
+function getFieldValue(event, field) {
+  if (field.startsWith("args.")) {
+    const key = field.slice(5);
+    return event.args?.[key];
+  }
+  return event[field];
+}
+function toString(value) {
+  if (value === null || value === void 0) return "";
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  return JSON.stringify(value);
+}
+function evaluateCondition(condition, event) {
+  const fieldValue = getFieldValue(event, condition.field);
+  if (fieldValue === void 0 && condition.operator !== "!=") {
+    return { matched: false, evidence: null };
+  }
+  switch (condition.operator) {
+    case "==":
+      return evaluateEquals(fieldValue, condition.value);
+    case "!=":
+      return evaluateNotEquals(fieldValue, condition.value);
+    case ">":
+      return evaluateComparison(fieldValue, condition.value, (a, b) => a > b);
+    case "<":
+      return evaluateComparison(fieldValue, condition.value, (a, b) => a < b);
+    case ">=":
+      return evaluateComparison(fieldValue, condition.value, (a, b) => a >= b);
+    case "<=":
+      return evaluateComparison(fieldValue, condition.value, (a, b) => a <= b);
+    case "in":
+      return evaluateIn(fieldValue, condition.value);
+    case "contains":
+      return evaluateContains(fieldValue, condition.value);
+    case "contains_any":
+      return evaluateContainsAny(fieldValue, condition.value);
+    case "matches_pattern":
+      return evaluateMatchesPattern(fieldValue, condition.value);
+    case "starts_with":
+      return evaluateStartsWith(fieldValue, condition.value);
+    case "ends_with":
+      return evaluateEndsWith(fieldValue, condition.value);
+    default:
+      return { matched: false, evidence: null };
+  }
+}
+function evaluateEquals(fieldValue, conditionValue) {
+  const fieldStr = toString(fieldValue);
+  const condStr = toString(conditionValue);
+  const matched = fieldStr === condStr;
+  return {
+    matched,
+    evidence: matched ? `${fieldStr} == ${condStr}` : null
+  };
+}
+function evaluateNotEquals(fieldValue, conditionValue) {
+  const fieldStr = toString(fieldValue);
+  const condStr = toString(conditionValue);
+  const matched = fieldStr !== condStr;
+  return {
+    matched,
+    evidence: matched ? `${fieldStr} != ${condStr}` : null
+  };
+}
+function evaluateComparison(fieldValue, conditionValue, comparator) {
+  const a = Number(fieldValue);
+  const b = Number(conditionValue);
+  if (isNaN(a) || isNaN(b)) return { matched: false, evidence: null };
+  const matched = comparator(a, b);
+  return {
+    matched,
+    evidence: matched ? `${a} compared to ${b}` : null
+  };
+}
+function evaluateIn(fieldValue, conditionValue) {
+  if (!Array.isArray(conditionValue)) return { matched: false, evidence: null };
+  const fieldStr = toString(fieldValue);
+  const matched = conditionValue.some((v) => toString(v) === fieldStr);
+  return {
+    matched,
+    evidence: matched ? `"${fieldStr}" found in [${conditionValue.join(", ")}]` : null
+  };
+}
+function evaluateContains(fieldValue, conditionValue) {
+  const fieldStr = toString(fieldValue).toLowerCase();
+  const searchStr = toString(conditionValue).toLowerCase();
+  const matched = fieldStr.includes(searchStr);
+  return {
+    matched,
+    evidence: matched ? `"${searchStr}" found in field` : null
+  };
+}
+function evaluateContainsAny(fieldValue, conditionValue) {
+  if (!Array.isArray(conditionValue)) return { matched: false, evidence: null };
+  const fieldStr = toString(fieldValue).toLowerCase();
+  for (const pattern of conditionValue) {
+    const patternLower = toString(pattern).toLowerCase();
+    if (fieldStr.includes(patternLower)) {
+      return {
+        matched: true,
+        evidence: `"${patternLower}" found in field`
+      };
+    }
+  }
+  return { matched: false, evidence: null };
+}
+function evaluateMatchesPattern(fieldValue, conditionValue) {
+  const fieldStr = toString(fieldValue);
+  const patterns = Array.isArray(conditionValue) ? conditionValue : [toString(conditionValue)];
+  for (const pattern of patterns) {
+    try {
+      const regex = new RegExp(toString(pattern), "i");
+      if (regex.test(fieldStr)) {
+        return {
+          matched: true,
+          evidence: `matched pattern /${pattern}/`
+        };
+      }
+    } catch {
+      continue;
+    }
+  }
+  return { matched: false, evidence: null };
+}
+function evaluateStartsWith(fieldValue, conditionValue) {
+  const fieldStr = toString(fieldValue).toLowerCase();
+  const prefix = toString(conditionValue).toLowerCase();
+  const matched = fieldStr.startsWith(prefix);
+  return {
+    matched,
+    evidence: matched ? `field starts with "${prefix}"` : null
+  };
+}
+function evaluateEndsWith(fieldValue, conditionValue) {
+  const fieldStr = toString(fieldValue).toLowerCase();
+  const suffix = toString(conditionValue).toLowerCase();
+  const matched = fieldStr.endsWith(suffix);
+  return {
+    matched,
+    evidence: matched ? `field ends with "${suffix}"` : null
+  };
+}
+
+// src/engine/validate-engine.ts
+function validateWorld(world) {
+  const startTime = performance.now();
+  const findings = [];
+  checkCompleteness(world, findings);
+  checkReferentialIntegrity(world, findings);
+  checkGuardCoverage(world, findings);
+  checkContradictions(world, findings);
+  checkOrphans(world, findings);
+  checkSchemaViolations(world, findings);
+  const severityOrder = { error: 0, warning: 1, info: 2 };
+  findings.sort((a, b) => severityOrder[a.severity] - severityOrder[b.severity]);
+  const errors = findings.filter((f) => f.severity === "error").length;
+  const warnings = findings.filter((f) => f.severity === "warning").length;
+  const info = findings.filter((f) => f.severity === "info").length;
+  const completenessScore = computeCompletenessScore(world);
+  const invariantCoverage = computeInvariantCoverage(world);
+  const summary = {
+    errors,
+    warnings,
+    info,
+    completenessScore,
+    invariantCoverage,
+    canRun: errors === 0,
+    isHealthy: errors === 0 && warnings === 0
+  };
+  return {
+    worldId: world.world.world_id,
+    worldName: world.world.name,
+    worldVersion: world.world.version,
+    validatedAt: Date.now(),
+    durationMs: performance.now() - startTime,
+    summary,
+    findings
+  };
+}
+function checkCompleteness(world, findings) {
+  if (!world.world?.world_id) {
+    findings.push(finding("missing-world-id", "World identity is missing world_id", "error", "completeness", ["world.json"]));
+  }
+  if (!world.world?.name) {
+    findings.push(finding("missing-world-name", "World identity is missing name", "error", "completeness", ["world.json"]));
+  }
+  if (!world.world?.thesis) {
+    findings.push(finding("missing-thesis", "World has no thesis \u2014 there is nothing to simulate", "error", "completeness", ["world.json"]));
+  }
+  if (!world.invariants || world.invariants.length === 0) {
+    findings.push(finding("missing-invariants", "No invariants declared \u2014 world has no structural constraints", "error", "completeness", ["invariants.json"]));
+  }
+  if (!world.stateSchema?.variables || Object.keys(world.stateSchema.variables).length === 0) {
+    findings.push(finding("missing-state-schema", "No state variables declared \u2014 nothing to simulate", "error", "completeness", ["state-schema.json"]));
+  }
+  if (!world.rules || world.rules.length === 0) {
+    findings.push(finding("missing-rules", "No rules declared \u2014 world has no causal mechanics", "error", "completeness", ["rules/"]));
+  }
+  if (!world.gates?.viability_classification || world.gates.viability_classification.length === 0) {
+    findings.push(finding("missing-gates", "No viability gates declared \u2014 cannot classify outcomes", "error", "completeness", ["gates.json"]));
+  }
+  if (!world.outcomes?.computed_outcomes || world.outcomes.computed_outcomes.length === 0) {
+    findings.push(finding("missing-outcomes", "No computed outcomes declared \u2014 nothing to display", "warning", "completeness", ["outcomes.json"]));
+  }
+  if (!world.assumptions?.profiles || Object.keys(world.assumptions.profiles).length === 0) {
+    findings.push(finding("missing-assumptions", "No assumption profiles declared \u2014 cannot compare scenarios", "warning", "completeness", ["assumptions.json"]));
+  }
+  if (!world.metadata) {
+    findings.push(finding("missing-metadata", "No metadata block \u2014 world has no version history", "warning", "completeness", ["metadata.json"]));
+  }
+  if (!world.guards) {
+    findings.push(finding("no-guards", "No guards declared \u2014 Action Space enforcement unavailable", "info", "completeness", ["guards.json"]));
+  }
+  if (!world.roles) {
+    findings.push(finding("no-roles", "No roles declared \u2014 multi-agent governance unavailable", "info", "completeness", ["roles.json"]));
+  }
+  if (!world.kernel) {
+    findings.push(finding("no-kernel", "No kernel config \u2014 Thinking Space governance unavailable", "info", "completeness", ["kernel.json"]));
+  }
+}
+function checkReferentialIntegrity(world, findings) {
+  if (!world.rules || !world.stateSchema?.variables) return;
+  const declaredVars = new Set(Object.keys(world.stateSchema.variables));
+  const declaredOutcomes = new Set(
+    (world.outcomes?.computed_outcomes ?? []).map((o) => o.id)
+  );
+  const declaredAssumptionParams = new Set(
+    Object.keys(world.assumptions?.parameter_definitions ?? {})
+  );
+  const allDeclared = /* @__PURE__ */ new Set([...declaredVars, ...declaredOutcomes]);
+  for (const rule of world.rules) {
+    for (const trigger of rule.triggers) {
+      if (trigger.source === "state" && !allDeclared.has(trigger.field)) {
+        findings.push(finding(
+          `undeclared-trigger-${rule.id}-${trigger.field}`,
+          `Rule "${rule.id}" trigger references undeclared state variable "${trigger.field}"`,
+          "error",
+          "referential-integrity",
+          ["rules/", "state-schema.json"],
+          rule.id,
+          `Add "${trigger.field}" to state-schema.json variables`
+        ));
+      }
+      if (trigger.source === "assumption" && !declaredAssumptionParams.has(trigger.field)) {
+        findings.push(finding(
+          `undeclared-assumption-trigger-${rule.id}-${trigger.field}`,
+          `Rule "${rule.id}" trigger references undeclared assumption parameter "${trigger.field}"`,
+          "error",
+          "referential-integrity",
+          ["rules/", "assumptions.json"],
+          rule.id,
+          `Add "${trigger.field}" to assumptions.json parameter_definitions`
+        ));
+      }
+    }
+    for (const effect of rule.effects ?? []) {
+      if (!allDeclared.has(effect.target)) {
+        findings.push(finding(
+          `undeclared-effect-${rule.id}-${effect.target}`,
+          `Rule "${rule.id}" effect targets undeclared variable "${effect.target}"`,
+          "error",
+          "referential-integrity",
+          ["rules/", "state-schema.json", "outcomes.json"],
+          rule.id,
+          `Add "${effect.target}" to state-schema.json or outcomes.json`
+        ));
+      }
+    }
+    if (rule.exclusive_with) {
+      const refExists = world.rules.some((r) => r.id === rule.exclusive_with);
+      if (!refExists) {
+        findings.push(finding(
+          `broken-exclusive-${rule.id}`,
+          `Rule "${rule.id}" has exclusive_with="${rule.exclusive_with}" but that rule does not exist`,
+          "error",
+          "referential-integrity",
+          ["rules/"],
+          rule.id
+        ));
+      }
+    }
+    if (rule.collapse_check && !allDeclared.has(rule.collapse_check.field)) {
+      findings.push(finding(
+        `undeclared-collapse-${rule.id}`,
+        `Rule "${rule.id}" collapse_check references undeclared field "${rule.collapse_check.field}"`,
+        "error",
+        "referential-integrity",
+        ["rules/", "state-schema.json"],
+        rule.id
+      ));
+    }
+  }
+  for (const gate of world.gates?.viability_classification ?? []) {
+    if (!allDeclared.has(gate.field)) {
+      findings.push(finding(
+        `undeclared-gate-field-${gate.status}`,
+        `Gate "${gate.status}" references undeclared field "${gate.field}"`,
+        "error",
+        "referential-integrity",
+        ["gates.json", "state-schema.json", "outcomes.json"]
+      ));
+    }
+  }
+}
+function checkGuardCoverage(world, findings) {
+  if (!world.invariants || world.invariants.length === 0) return;
+  const guards = world.guards?.guards ?? [];
+  for (const invariant of world.invariants) {
+    if (invariant.enforcement === "prompt") continue;
+    const coveringGuard = guards.find(
+      (g) => g.invariant_ref === invariant.id && g.immutable
+    );
+    if (!coveringGuard) {
+      findings.push(finding(
+        `uncovered-invariant-${invariant.id}`,
+        `Invariant "${invariant.id}" has no backing structural guard \u2014 it is declared but not enforced at runtime`,
+        "warning",
+        "guard-coverage",
+        ["invariants.json", "guards.json"],
+        invariant.id,
+        `Add a structural guard with invariant_ref="${invariant.id}" to guards.json`
+      ));
+    }
+  }
+  for (const guard of guards) {
+    if (guard.invariant_ref) {
+      const invariantExists = world.invariants.some((i) => i.id === guard.invariant_ref);
+      if (!invariantExists) {
+        findings.push(finding(
+          `broken-guard-invariant-ref-${guard.id}`,
+          `Guard "${guard.id}" references invariant "${guard.invariant_ref}" which does not exist`,
+          "error",
+          "referential-integrity",
+          ["guards.json", "invariants.json"],
+          guard.id
+        ));
+      }
+    }
+  }
+  if (world.guards) {
+    const vocabKeys = new Set(Object.keys(world.guards.intent_vocabulary));
+    for (const guard of guards) {
+      for (const patternKey of guard.intent_patterns) {
+        if (!vocabKeys.has(patternKey)) {
+          findings.push(finding(
+            `broken-guard-pattern-${guard.id}-${patternKey}`,
+            `Guard "${guard.id}" references intent pattern "${patternKey}" which is not in intent_vocabulary`,
+            "error",
+            "referential-integrity",
+            ["guards.json"],
+            guard.id
+          ));
+        }
+      }
+    }
+  }
+}
+function checkContradictions(world, findings) {
+  if (!world.rules || world.rules.length < 2) return;
+  checkCircularExclusiveWith(world.rules, findings);
+  const tensions = detectSemanticTensions(world.rules);
+  for (let i = 0; i < tensions.length; i++) {
+    const tension = tensions[i];
+    findings.push(finding(
+      `semantic-tension-${i}`,
+      tension.message,
+      tension.severity,
+      "semantic-tension",
+      tension.affectedBlocks
+    ));
+  }
+}
+function checkCircularExclusiveWith(rules, findings) {
+  const exclusiveMap = /* @__PURE__ */ new Map();
+  for (const rule of rules) {
+    if (rule.exclusive_with) {
+      exclusiveMap.set(rule.id, rule.exclusive_with);
+    }
+  }
+  const reportedPairs = /* @__PURE__ */ new Set();
+  for (const [ruleA, ruleB] of exclusiveMap) {
+    if (exclusiveMap.get(ruleB) === ruleA) {
+      const pairKey = [ruleA, ruleB].sort().join("::");
+      if (!reportedPairs.has(pairKey)) {
+        reportedPairs.add(pairKey);
+        findings.push(finding(
+          `mutual-exclusion-${pairKey.replace("::", "-")}`,
+          `Rules "${ruleA}" and "${ruleB}" are mutually exclusive \u2014 only one can fire per evaluation`,
+          "info",
+          "semantic-tension",
+          ["rules/"],
+          `${ruleA}, ${ruleB}`
+        ));
+      }
+    }
+  }
+  const reportedChains = /* @__PURE__ */ new Set();
+  for (const startRule of exclusiveMap.keys()) {
+    let current = startRule;
+    const visited = /* @__PURE__ */ new Set();
+    const chain = [];
+    while (current && !visited.has(current)) {
+      visited.add(current);
+      chain.push(current);
+      current = exclusiveMap.get(current);
+    }
+    if (current === startRule && visited.size > 2) {
+      const chainKey = [...chain].sort().join("::");
+      if (!reportedChains.has(chainKey)) {
+        reportedChains.add(chainKey);
+        findings.push(finding(
+          `circular-exclusive-chain-${startRule}`,
+          `Circular exclusive_with chain: ${chain.join(" \u2192 ")} \u2192 ${startRule} (${chain.length} rules)`,
+          "warning",
+          "contradiction",
+          ["rules/"],
+          chain.join(", ")
+        ));
+      }
+    }
+  }
+}
+function detectSemanticTensions(rules) {
+  const results = [];
+  if (rules.length < 2) return results;
+  const exclusivePairs = /* @__PURE__ */ new Set();
+  for (const rule of rules) {
+    if (rule.exclusive_with) {
+      exclusivePairs.add(`${rule.id}:${rule.exclusive_with}`);
+      exclusivePairs.add(`${rule.exclusive_with}:${rule.id}`);
+    }
+  }
+  const isExclusive = (a, b) => exclusivePairs.has(`${a}:${b}`);
+  const targetEffects = /* @__PURE__ */ new Map();
+  for (const rule of rules) {
+    const allEffects = [
+      ...rule.effects || [],
+      ...(rule.effects_conditional || []).flatMap((c2) => c2.effects)
+    ];
+    for (const effect of allEffects) {
+      const direction = classifyEffectDirection(effect);
+      if (direction === "neutral") continue;
+      const entries = targetEffects.get(effect.target) ?? [];
+      entries.push({ ruleId: rule.id, ruleLabel: rule.label, direction, effect });
+      targetEffects.set(effect.target, entries);
+    }
+  }
+  for (const [target, effects] of targetEffects) {
+    const increasing = effects.filter((e) => e.direction === "increase");
+    const decreasing = effects.filter((e) => e.direction === "decrease");
+    if (increasing.length === 0 || decreasing.length === 0) continue;
+    const incRuleIds = /* @__PURE__ */ new Set();
+    const decRuleIds = /* @__PURE__ */ new Set();
+    for (const inc of increasing) {
+      for (const dec of decreasing) {
+        if (inc.ruleId === dec.ruleId) continue;
+        if (isExclusive(inc.ruleId, dec.ruleId)) continue;
+        incRuleIds.add(inc.ruleId);
+        decRuleIds.add(dec.ruleId);
+      }
+    }
+    if (incRuleIds.size === 0 || decRuleIds.size === 0) continue;
+    const incLabels = [...incRuleIds].map((id) => {
+      const e = increasing.find((e2) => e2.ruleId === id);
+      return `"${e.ruleLabel}" (${describeEffect(e.effect)})`;
+    });
+    const decLabels = [...decRuleIds].map((id) => {
+      const e = decreasing.find((e2) => e2.ruleId === id);
+      return `"${e.ruleLabel}" (${describeEffect(e.effect)})`;
+    });
+    results.push({
+      type: "semantic_tension",
+      severity: "warning",
+      message: `Opposing effects on "${target}": ${incLabels.join(", ")} increase it while ${decLabels.join(", ")} decrease it`,
+      affectedBlocks: ["rules"]
+    });
+  }
+  const setEffects = /* @__PURE__ */ new Map();
+  for (const rule of rules) {
+    const allEffects = [
+      ...rule.effects || [],
+      ...(rule.effects_conditional || []).flatMap((c2) => c2.effects)
+    ];
+    for (const effect of allEffects) {
+      if (effect.operation !== "set" && effect.operation !== "set_boolean" && effect.operation !== "set_dynamic") continue;
+      const entries = setEffects.get(effect.target) ?? [];
+      entries.push({ ruleId: rule.id, ruleLabel: rule.label, value: effect.value });
+      setEffects.set(effect.target, entries);
+    }
+  }
+  for (const [target, effects] of setEffects) {
+    if (effects.length < 2) continue;
+    const byValue = /* @__PURE__ */ new Map();
+    for (const e of effects) {
+      const key = String(e.value);
+      const existing = byValue.get(key) ?? [];
+      existing.push(e);
+      byValue.set(key, existing);
+    }
+    if (byValue.size < 2) continue;
+    const valueGroups = [...byValue.entries()];
+    const involvedRules = [];
+    for (let i = 0; i < valueGroups.length; i++) {
+      for (let j = i + 1; j < valueGroups.length; j++) {
+        for (const a of valueGroups[i][1]) {
+          for (const b of valueGroups[j][1]) {
+            if (a.ruleId === b.ruleId) continue;
+            if (isExclusive(a.ruleId, b.ruleId)) continue;
+            if (!involvedRules.includes(a.ruleId)) involvedRules.push(a.ruleId);
+            if (!involvedRules.includes(b.ruleId)) involvedRules.push(b.ruleId);
+          }
+        }
+      }
+    }
+    if (involvedRules.length === 0) continue;
+    const descriptions = involvedRules.map((id) => {
+      const e = effects.find((e2) => e2.ruleId === id);
+      return `"${e.ruleLabel}" sets to ${e.value}`;
+    });
+    results.push({
+      type: "semantic_tension",
+      severity: "warning",
+      message: `Conflicting set operations on "${target}": ${descriptions.join(", ")}`,
+      affectedBlocks: ["rules"]
+    });
+  }
+  return results;
+}
+function classifyEffectDirection(effect) {
+  if (effect.operation === "multiply" || effect.operation === "multiply_dynamic") {
+    const val = typeof effect.value === "number" ? effect.value : 1;
+    return val > 1 ? "increase" : val < 1 ? "decrease" : "neutral";
+  }
+  if (effect.operation === "add" || effect.operation === "add_dynamic") {
+    const val = typeof effect.value === "number" ? effect.value : 0;
+    return val > 0 ? "increase" : val < 0 ? "decrease" : "neutral";
+  }
+  if (effect.operation === "subtract" || effect.operation === "subtract_dynamic") {
+    const val = typeof effect.value === "number" ? effect.value : 0;
+    return val > 0 ? "decrease" : val < 0 ? "increase" : "neutral";
+  }
+  return "neutral";
+}
+function describeEffect(effect) {
+  switch (effect.operation) {
+    case "multiply":
+    case "multiply_dynamic":
+      return `multiplies by ${effect.value}`;
+    case "add":
+    case "add_dynamic":
+      return `adds ${effect.value}`;
+    case "subtract":
+    case "subtract_dynamic":
+      return `subtracts ${effect.value}`;
+    case "set":
+    case "set_dynamic":
+    case "set_boolean":
+      return `sets to ${effect.value}`;
+    default:
+      return `${effect.operation} ${effect.value}`;
+  }
+}
+function checkOrphans(world, findings) {
+  if (!world.stateSchema?.variables || !world.rules) return;
+  const referencedVars = /* @__PURE__ */ new Set();
+  for (const rule of world.rules) {
+    for (const trigger of rule.triggers) {
+      referencedVars.add(trigger.field);
+    }
+    for (const effect of rule.effects ?? []) {
+      referencedVars.add(effect.target);
+    }
+    if (rule.collapse_check) {
+      referencedVars.add(rule.collapse_check.field);
+    }
+  }
+  for (const gate of world.gates?.viability_classification ?? []) {
+    referencedVars.add(gate.field);
+  }
+  for (const varId of Object.keys(world.stateSchema.variables)) {
+    if (!referencedVars.has(varId)) {
+      findings.push(finding(
+        `orphan-variable-${varId}`,
+        `State variable "${varId}" is declared but never referenced by any rule or gate`,
+        "warning",
+        "orphan",
+        ["state-schema.json"],
+        varId,
+        "Remove this variable or add rules that reference it"
+      ));
+    }
+  }
+  const effectTargets = /* @__PURE__ */ new Set();
+  for (const rule of world.rules) {
+    for (const effect of rule.effects ?? []) {
+      effectTargets.add(effect.target);
+    }
+  }
+  for (const outcome of world.outcomes?.computed_outcomes ?? []) {
+    if (outcome.assignment === "external") continue;
+    if (!effectTargets.has(outcome.id) && !outcome.derived_from) {
+      findings.push(finding(
+        `orphan-outcome-${outcome.id}`,
+        `Outcome "${outcome.id}" is declared but no rule produces it`,
+        "warning",
+        "orphan",
+        ["outcomes.json", "rules/"],
+        outcome.id
+      ));
+    }
+  }
+}
+function checkSchemaViolations(world, findings) {
+  if (!world.stateSchema?.variables) return;
+  for (const [varId, variable] of Object.entries(world.stateSchema.variables)) {
+    if (variable.type === "number") {
+      const def = variable.default;
+      if (variable.min !== void 0 && def < variable.min) {
+        findings.push(finding(
+          `default-below-min-${varId}`,
+          `Variable "${varId}" default (${def}) is below declared min (${variable.min})`,
+          "error",
+          "schema-violation",
+          ["state-schema.json"],
+          varId
+        ));
+      }
+      if (variable.max !== void 0 && def > variable.max) {
+        findings.push(finding(
+          `default-above-max-${varId}`,
+          `Variable "${varId}" default (${def}) is above declared max (${variable.max})`,
+          "error",
+          "schema-violation",
+          ["state-schema.json"],
+          varId
+        ));
+      }
+    }
+    if (variable.type === "enum") {
+      if (!variable.options || variable.options.length === 0) {
+        findings.push(finding(
+          `enum-no-options-${varId}`,
+          `Enum variable "${varId}" has no options declared`,
+          "error",
+          "schema-violation",
+          ["state-schema.json"],
+          varId
+        ));
+      } else if (!variable.options.includes(variable.default)) {
+        findings.push(finding(
+          `enum-default-invalid-${varId}`,
+          `Enum variable "${varId}" default "${variable.default}" is not in declared options`,
+          "error",
+          "schema-violation",
+          ["state-schema.json"],
+          varId
+        ));
+      }
+    }
+  }
+  for (const [presetName, preset] of Object.entries(world.stateSchema.presets ?? {})) {
+    for (const [varId, value] of Object.entries(preset.values)) {
+      const variable = world.stateSchema.variables[varId];
+      if (!variable) {
+        findings.push(finding(
+          `preset-undeclared-var-${presetName}-${varId}`,
+          `Preset "${presetName}" sets undeclared variable "${varId}"`,
+          "error",
+          "referential-integrity",
+          ["state-schema.json"],
+          presetName
+        ));
+        continue;
+      }
+      if (variable.type === "number" && typeof value === "number") {
+        if (variable.min !== void 0 && value < variable.min) {
+          findings.push(finding(
+            `preset-below-min-${presetName}-${varId}`,
+            `Preset "${presetName}" sets "${varId}" to ${value}, below min ${variable.min}`,
+            "warning",
+            "schema-violation",
+            ["state-schema.json"],
+            presetName
+          ));
+        }
+        if (variable.max !== void 0 && value > variable.max) {
+          findings.push(finding(
+            `preset-above-max-${presetName}-${varId}`,
+            `Preset "${presetName}" sets "${varId}" to ${value}, above max ${variable.max}`,
+            "warning",
+            "schema-violation",
+            ["state-schema.json"],
+            presetName
+          ));
+        }
+      }
+    }
+  }
+}
+function computeCompletenessScore(world) {
+  let score = 0;
+  const total = 9;
+  if (world.world?.world_id && world.world?.name && world.world?.thesis) score++;
+  if (world.invariants && world.invariants.length > 0) score++;
+  if (world.assumptions?.profiles && Object.keys(world.assumptions.profiles).length > 0) score++;
+  if (world.stateSchema?.variables && Object.keys(world.stateSchema.variables).length > 0) score++;
+  if (world.rules && world.rules.length > 0) score++;
+  if (world.gates?.viability_classification && world.gates.viability_classification.length > 0) score++;
+  if (world.outcomes?.computed_outcomes && world.outcomes.computed_outcomes.length > 0) score++;
+  if (world.guards?.guards && world.guards.guards.length > 0) score++;
+  if (world.metadata) score++;
+  return Math.round(score / total * 100);
+}
+function computeInvariantCoverage(world) {
+  if (!world.invariants || world.invariants.length === 0) return 0;
+  const guards = world.guards?.guards ?? [];
+  let covered = 0;
+  for (const invariant of world.invariants) {
+    const hasGuard = guards.some((g) => g.invariant_ref === invariant.id && g.immutable);
+    if (hasGuard) covered++;
+  }
+  return Math.round(covered / world.invariants.length * 100);
+}
+function finding(id, message, severity, category, affectedBlocks, source, suggestion) {
+  const f = { id, message, severity, category, affectedBlocks };
+  if (source) f.source = source;
+  if (suggestion) f.suggestion = suggestion;
+  return f;
+}
+
+// src/contracts/validate-contract.ts
+var VALIDATE_EXIT_CODES = {
+  PASS: 0,
+  FAIL: 1,
+  WARN: 2,
+  ERROR: 3
+};
+
+// src/engine/bootstrap-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 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;
+  }
+  if (!result.world_id) {
+    issues.push({ line: 1, section: "frontmatter", message: "Missing world_id in frontmatter", severity: "error" });
+  }
+  if (!result.name) {
+    issues.push({ line: 1, section: "frontmatter", message: "Missing name in frontmatter", severity: "error" });
+  }
+  return {
+    world_id: result.world_id ?? "",
+    name: result.name ?? "",
+    version: result.version,
+    runtime_mode: result.runtime_mode,
+    default_profile: result.default_profile,
+    alternative_profile: result.alternative_profile
+  };
+}
+function parseThesis(content, startLine, issues) {
+  const thesis = content.trim();
+  if (!thesis) {
+    issues.push({ line: startLine, section: "Thesis", message: "Thesis section is empty", severity: "error" });
+  }
+  return thesis;
+}
+function parseInvariants(content, startLine, issues) {
+  const invariants = [];
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (!line.startsWith("- ")) continue;
+    const lineNum = startLine + i + 1;
+    const match = line.match(
+      /^-\s+`([^`]+)`\s*[—–-]\s*(.+?)(?:\s*\(([^)]+)\))?\s*$/
+    );
+    if (match) {
+      const id = match[1];
+      const label = match[2].trim();
+      const parens = match[3] ?? "structural, immutable";
+      const enforcement = parens.includes("prompt") ? "prompt" : parens.includes("operational") ? "operational" : "structural";
+      const mutable = parens.includes("mutable") && !parens.includes("immutable");
+      invariants.push({ id, label, enforcement, mutable, line: lineNum });
+    } else {
+      const fallback = line.match(/^-\s+\*\*([^*]+)\*\*\s*[—–-]\s*(.+)/);
+      if (fallback) {
+        const id = fallback[1].toLowerCase().replace(/\s+/g, "_");
+        const label = fallback[2].trim();
+        invariants.push({ id, label, enforcement: "structural", mutable: false, line: lineNum });
+      } else {
+        issues.push({ line: lineNum, section: "Invariants", message: `Could not parse invariant: "${line}"`, severity: "warning" });
+      }
+    }
+  }
+  if (invariants.length === 0) {
+    issues.push({ line: startLine, section: "Invariants", message: "No invariants found", severity: "error" });
+  }
+  return invariants;
+}
+function parseStateVariables(content, startLine, issues) {
+  const variables = [];
+  const subSections = splitH2Sections(content, startLine);
+  for (const sub of subSections) {
+    const props = parseKeyValueBullets(sub.content);
+    const lineNum = sub.startLine;
+    const type = props.type;
+    if (!type) {
+      issues.push({ line: lineNum, section: "State", message: `Variable "${sub.name}" missing type`, severity: "error" });
+      continue;
+    }
+    let defaultVal = props.default ?? "";
+    if (type === "number") {
+      defaultVal = parseFloat(String(defaultVal)) || 0;
+    } else if (type === "boolean") {
+      defaultVal = String(defaultVal).toLowerCase() === "true";
+    }
+    const variable = {
+      id: sub.name,
+      type,
+      default: defaultVal,
+      label: props.label ?? sub.name,
+      description: props.description ?? "",
+      line: lineNum
+    };
+    if (type === "number") {
+      if (props.min !== void 0) variable.min = parseFloat(props.min);
+      if (props.max !== void 0) variable.max = parseFloat(props.max);
+      if (props.step !== void 0) variable.step = parseFloat(props.step);
+    }
+    if (type === "enum" && props.options) {
+      variable.options = props.options.split(",").map((s) => s.trim());
+    }
+    variables.push(variable);
+  }
+  return variables;
+}
+function parseAssumptions(content, startLine, issues) {
+  const profiles = [];
+  const subSections = splitH2Sections(content, startLine);
+  for (const sub of subSections) {
+    const props = parseKeyValueBullets(sub.content);
+    const name = props.name ?? sub.name;
+    const description = props.description ?? "";
+    const parameters = {};
+    for (const [key, val] of Object.entries(props)) {
+      if (key === "name" || key === "description") continue;
+      if (val === "true") parameters[key] = true;
+      else if (val === "false") parameters[key] = false;
+      else if (!isNaN(Number(val)) && val.trim() !== "") parameters[key] = Number(val);
+      else parameters[key] = val;
+    }
+    profiles.push({
+      id: sub.name,
+      name,
+      description,
+      parameters,
+      line: sub.startLine
+    });
+  }
+  return profiles;
+}
+function parseRules(content, startLine, issues) {
+  const rules = [];
+  const subSections = splitH2Sections(content, startLine);
+  for (let ruleIdx = 0; ruleIdx < subSections.length; ruleIdx++) {
+    const sub = subSections[ruleIdx];
+    const lineNum = sub.startLine;
+    const headingMatch = sub.name.match(/^([^:]+):\s*(.+?)(?:\s*\(([^)]+)\))?\s*$/);
+    const id = headingMatch ? headingMatch[1].trim() : `rule-${String(ruleIdx + 1).padStart(3, "0")}`;
+    const label = headingMatch ? headingMatch[2].trim() : sub.name;
+    const severity = headingMatch?.[3]?.trim() ?? "degradation";
+    const lines = sub.content.split("\n");
+    let description = "";
+    const triggers = [];
+    const effects = [];
+    let collapseCheck;
+    const causalParts = {};
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+      if (line.startsWith("When ")) {
+        const triggerStr = line.slice(5);
+        const parts = triggerStr.split(/\s+AND\s+/i);
+        for (const part of parts) {
+          const trigger = parseTriggerExpression(part.trim());
+          if (trigger) triggers.push(trigger);
+          else issues.push({ line: lineNum + i, section: "Rules", message: `Could not parse trigger: "${part}"`, severity: "warning" });
+        }
+      } else if (line.startsWith("Then ")) {
+        const effectStr = line.slice(5);
+        const parts = effectStr.split(",");
+        for (const part of parts) {
+          const effect = parseEffectExpression(part.trim());
+          if (effect) effects.push(effect);
+          else issues.push({ line: lineNum + i, section: "Rules", message: `Could not parse effect: "${part}"`, severity: "warning" });
+        }
+      } else if (line.startsWith("Collapse:")) {
+        const collapseStr = line.slice(9).trim();
+        const collapse = parseCollapseExpression(collapseStr);
+        if (collapse) collapseCheck = collapse;
+        else issues.push({ line: lineNum + i, section: "Rules", message: `Could not parse collapse: "${collapseStr}"`, severity: "warning" });
+      } else if (line.startsWith("> ")) {
+        const causalMatch = line.match(/^>\s*(trigger|rule|shift|effect):\s*(.+)/i);
+        if (causalMatch) {
+          causalParts[causalMatch[1].toLowerCase()] = causalMatch[2].trim();
+        }
+      } else if (line && !line.startsWith("-") && !line.startsWith("#")) {
+        if (!description) description = line;
+        else description += " " + line;
+      }
+    }
+    if (triggers.length === 0) {
+      issues.push({ line: lineNum, section: "Rules", message: `Rule "${id}" has no triggers (missing "When" line)`, severity: "warning" });
+    }
+    if (effects.length === 0) {
+      issues.push({ line: lineNum, section: "Rules", message: `Rule "${id}" has no effects (missing "Then" line)`, severity: "warning" });
+    }
+    const causal_translation = Object.keys(causalParts).length > 0 ? {
+      trigger_text: causalParts.trigger ?? "",
+      rule_text: causalParts.rule ?? "",
+      shift_text: causalParts.shift ?? "",
+      effect_text: causalParts.effect ?? ""
+    } : void 0;
+    rules.push({
+      id,
+      label,
+      severity,
+      description: description || void 0,
+      order: ruleIdx + 1,
+      triggers,
+      effects,
+      collapse_check: collapseCheck,
+      causal_translation,
+      line: lineNum
+    });
+  }
+  return rules;
+}
+function parseTriggerExpression(expr) {
+  const match = expr.match(
+    /^(\w+)\s*(==|!=|>=|<=|>|<|in)\s*(.+?)\s*\[(state|assumption)\]\s*$/
+  );
+  if (!match) return null;
+  const field = match[1];
+  const operator = match[2];
+  let value = match[3].trim();
+  const source = match[4];
+  value = parseValueLiteral(value);
+  return { field, operator, value, source };
+}
+function parseEffectExpression(expr) {
+  const compound = expr.match(/^(\w+)\s*(\*=|\+=|-=)\s*(.+)$/);
+  if (compound) {
+    const target = compound[1];
+    const op = compound[2];
+    const value = parseValueLiteral(compound[3].trim());
+    const operationMap = {
+      "*=": "multiply",
+      "+=": "add",
+      "-=": "subtract"
+    };
+    return { target, operation: operationMap[op], value };
+  }
+  const assignment = expr.match(/^(\w+)\s*=\s*(.+)$/);
+  if (assignment) {
+    const target = assignment[1];
+    const value = parseValueLiteral(assignment[2].trim());
+    const operation = typeof value === "boolean" ? "set_boolean" : "set";
+    return { target, operation, value };
+  }
+  return null;
+}
+function parseCollapseExpression(expr) {
+  const cleaned = expr.replace(/\s*→.*$/, "").trim();
+  const match = cleaned.match(/^(\w+)\s*(==|!=|>=|<=|>|<)\s*([\d.]+)$/);
+  if (!match) return null;
+  return {
+    field: match[1],
+    operator: match[2],
+    value: parseFloat(match[3])
+  };
+}
+function parseGates(content, startLine, issues) {
+  const gates = [];
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (!line.startsWith("- ")) continue;
+    const lineNum = startLine + i + 1;
+    const match = line.match(/^-\s+(\w+):\s*(\w+)\s*(==|!=|>=|<=|>|<)\s*([\d.]+)/);
+    if (match) {
+      gates.push({
+        status: match[1],
+        field: match[2],
+        operator: match[3],
+        value: parseFloat(match[4]),
+        line: lineNum
+      });
+    } else {
+      issues.push({ line: lineNum, section: "Gates", message: `Could not parse gate: "${line}"`, severity: "warning" });
+    }
+  }
+  if (gates.length === 0) {
+    issues.push({ line: startLine, section: "Gates", message: "No gates found", severity: "error" });
+  }
+  return gates;
+}
+function parseOutcomes(content, startLine, issues) {
+  const outcomes = [];
+  const subSections = splitH2Sections(content, startLine);
+  for (const sub of subSections) {
+    const props = parseKeyValueBullets(sub.content);
+    const outcome = {
+      id: sub.name,
+      type: props.type ?? "number",
+      label: props.label ?? sub.name,
+      line: sub.startLine
+    };
+    if (props.range) {
+      const rangeParts = props.range.split("-").map(Number);
+      if (rangeParts.length === 2 && !isNaN(rangeParts[0]) && !isNaN(rangeParts[1])) {
+        outcome.range = [rangeParts[0], rangeParts[1]];
+      }
+    }
+    if (props.display) outcome.display = props.display;
+    if (props.primary) outcome.primary = props.primary === "true";
+    if (props.assignment) outcome.assignment = props.assignment;
+    outcomes.push(outcome);
+  }
+  return outcomes;
+}
+function splitH2Sections(content, baseStartLine) {
+  const lines = content.split("\n");
+  const sections = [];
+  let current = null;
+  const contentLines = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.startsWith("## ")) {
+      if (current) {
+        current.content = contentLines.join("\n").trim();
+        sections.push(current);
+        contentLines.length = 0;
+      }
+      current = {
+        name: line.replace(/^##\s+/, "").trim(),
+        content: "",
+        startLine: baseStartLine + i + 1
+      };
+    } else if (current) {
+      contentLines.push(line);
+    }
+  }
+  if (current) {
+    current.content = contentLines.join("\n").trim();
+    sections.push(current);
+  }
+  return sections;
+}
+function parseKeyValueBullets(content) {
+  const result = {};
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    const match = trimmed.match(/^-\s+(\w[\w\s]*?):\s*(.+)$/);
+    if (match) {
+      result[match[1].trim().toLowerCase().replace(/\s+/g, "_")] = match[2].trim();
+    }
+  }
+  return result;
+}
+function parseValueLiteral(raw) {
+  if (raw === "true") return true;
+  if (raw === "false") return false;
+  if (raw.startsWith('"') && raw.endsWith('"') || raw.startsWith("'") && raw.endsWith("'")) {
+    return raw.slice(1, -1);
+  }
+  const num = Number(raw);
+  if (!isNaN(num) && raw.trim() !== "") return num;
+  return raw;
+}
+function parseWorldMarkdown(markdown) {
+  const issues = [];
+  const { frontmatter: fmRaw, sections } = splitSections(markdown);
+  const frontmatter = parseFrontmatter(fmRaw, issues);
+  const findSection = (name) => sections.find((s) => s.name.toLowerCase() === name.toLowerCase());
+  const thesisSection = findSection("Thesis");
+  const thesis = thesisSection ? parseThesis(thesisSection.content, thesisSection.startLine, issues) : "";
+  if (!thesisSection) {
+    issues.push({ line: 0, section: "Thesis", message: "Missing # Thesis section", severity: "error" });
+  }
+  const invariantsSection = findSection("Invariants");
+  const invariants = invariantsSection ? parseInvariants(invariantsSection.content, invariantsSection.startLine, issues) : [];
+  if (!invariantsSection) {
+    issues.push({ line: 0, section: "Invariants", message: "Missing # Invariants section", severity: "error" });
+  }
+  const stateSection = findSection("State");
+  const stateVariables = stateSection ? parseStateVariables(stateSection.content, stateSection.startLine, issues) : [];
+  if (!stateSection) {
+    issues.push({ line: 0, section: "State", message: "Missing # State section", severity: "warning" });
+  }
+  const assumptionsSection = findSection("Assumptions");
+  const assumptions = assumptionsSection ? parseAssumptions(assumptionsSection.content, assumptionsSection.startLine, issues) : [];
+  if (!assumptionsSection) {
+    issues.push({ line: 0, section: "Assumptions", message: "Missing # Assumptions section", severity: "warning" });
+  }
+  const rulesSection = findSection("Rules");
+  const rules = rulesSection ? parseRules(rulesSection.content, rulesSection.startLine, issues) : [];
+  if (!rulesSection) {
+    issues.push({ line: 0, section: "Rules", message: "Missing # Rules section", severity: "warning" });
+  }
+  const gatesSection = findSection("Gates");
+  const gates = gatesSection ? parseGates(gatesSection.content, gatesSection.startLine, issues) : [];
+  if (!gatesSection) {
+    issues.push({ line: 0, section: "Gates", message: "Missing # Gates section", severity: "warning" });
+  }
+  const outcomesSection = findSection("Outcomes");
+  const outcomes = outcomesSection ? parseOutcomes(outcomesSection.content, outcomesSection.startLine, issues) : [];
+  const parsedSections = sections.map((s) => s.name);
+  const knownSections = /* @__PURE__ */ new Set(["thesis", "invariants", "state", "assumptions", "rules", "gates", "outcomes"]);
+  for (const section of sections) {
+    if (!knownSections.has(section.name.toLowerCase())) {
+      issues.push({
+        line: section.startLine,
+        section: section.name,
+        message: `Unrecognized section "${section.name}" \u2014 will be ignored`,
+        severity: "info"
+      });
+    }
+  }
+  const hasErrors = issues.some((i) => i.severity === "error");
+  if (!frontmatter.world_id || !thesis) {
+    if (hasErrors) {
+      return { world: null, issues };
+    }
+  }
+  return {
+    world: {
+      frontmatter,
+      thesis,
+      invariants,
+      stateVariables,
+      assumptions,
+      rules,
+      gates,
+      outcomes
+    },
+    issues
+  };
+}
+
+// src/engine/bootstrap-emitter.ts
+var GATE_DEFAULTS = {
+  THRIVING: { color: "#0f6b3a", icon: "\u2726" },
+  STABLE: { color: "#1856b8", icon: "\u25CF" },
+  COMPRESSED: { color: "#a16207", icon: "\u25B2" },
+  CRITICAL: { color: "#b91c1c", icon: "\u26A0" },
+  MODEL_COLLAPSES: { color: "#7f1d1d", icon: "\u2715" }
+};
+function emitWorldDefinition(parsed) {
+  const issues = [];
+  const fm = parsed.frontmatter;
+  const defaultProfile = fm.default_profile ?? parsed.assumptions[0]?.id ?? "baseline";
+  const altProfile = fm.alternative_profile ?? parsed.assumptions[1]?.id ?? "alternative";
+  const world = {
+    world_id: fm.world_id,
+    name: fm.name,
+    thesis: parsed.thesis,
+    version: fm.version ?? "1.0.0",
+    runtime_mode: fm.runtime_mode ?? "SIMULATION",
+    default_assumption_profile: defaultProfile,
+    default_alternative_profile: altProfile,
+    modules: parsed.rules.map((r) => r.id),
+    players: {
+      thinking_space: true,
+      experience_space: true,
+      action_space: true
+    }
+  };
+  const invariants = parsed.invariants.map((inv) => ({
+    id: inv.id,
+    label: inv.label,
+    enforcement: inv.enforcement === "prompt" ? "prompt" : "structural",
+    mutable: false
+  }));
+  const profiles = {};
+  const parameterDefinitions = {};
+  for (let i = 0; i < parsed.assumptions.length; i++) {
+    const profile = parsed.assumptions[i];
+    const params = {};
+    for (const [key, val] of Object.entries(profile.parameters)) {
+      params[key] = String(val);
+      if (!parameterDefinitions[key]) {
+        parameterDefinitions[key] = {
+          type: typeof val === "boolean" ? "boolean" : typeof val === "number" ? "number" : "enum",
+          label: key.replace(/_/g, " ").replace(/\b\w/g, (c2) => c2.toUpperCase()),
+          description: `Parameter: ${key}`
+        };
+      }
+    }
+    profiles[profile.id] = {
+      name: profile.name,
+      description: profile.description,
+      is_default_baseline: i === 0 || profile.id === defaultProfile,
+      is_default_alternative: i === 1 || profile.id === altProfile,
+      parameters: params
+    };
+  }
+  const assumptions = { profiles, parameter_definitions: parameterDefinitions };
+  const variables = {};
+  for (const v of parsed.stateVariables) {
+    const stateVar = {
+      type: v.type,
+      default: v.default,
+      mutable: true,
+      label: v.label,
+      description: v.description
+    };
+    if (v.type === "number") {
+      if (v.min !== void 0) stateVar.min = v.min;
+      if (v.max !== void 0) stateVar.max = v.max;
+      if (v.step !== void 0) stateVar.step = v.step;
+    }
+    if (v.type === "enum" && v.options) {
+      stateVar.options = v.options;
+    }
+    variables[v.id] = stateVar;
+  }
+  const stateSchema = { variables, presets: {} };
+  const rules = parsed.rules.map((r) => {
+    const triggers = r.triggers.map((t) => ({
+      field: t.field,
+      operator: t.operator,
+      value: t.value,
+      source: t.source
+    }));
+    const effects = r.effects.map((e) => ({
+      target: e.target,
+      operation: e.operation,
+      value: e.value
+    }));
+    let collapse_check;
+    if (r.collapse_check) {
+      collapse_check = {
+        field: r.collapse_check.field,
+        operator: r.collapse_check.operator,
+        value: r.collapse_check.value,
+        result: "MODEL_COLLAPSES"
+      };
+    }
+    const causal_translation = r.causal_translation ?? {
+      trigger_text: "",
+      rule_text: "",
+      shift_text: "",
+      effect_text: ""
+    };
+    const rule = {
+      id: r.id,
+      severity: r.severity,
+      label: r.label,
+      description: r.description ?? r.label,
+      order: r.order,
+      triggers,
+      effects: effects.length > 0 ? effects : void 0,
+      collapse_check,
+      causal_translation
+    };
+    return rule;
+  });
+  const viabilityClassification = parsed.gates.map((g) => {
+    const defaults = GATE_DEFAULTS[g.status] ?? { color: "#5c5a52", icon: "\u25CF" };
+    return {
+      status: g.status,
+      field: g.field,
+      operator: g.operator,
+      value: g.value,
+      color: defaults.color,
+      icon: defaults.icon
+    };
+  });
+  const gates = {
+    viability_classification: viabilityClassification,
+    structural_override: {
+      description: "Rules with severity=structural and triggered collapse_check force MODEL_COLLAPSES regardless of final margin.",
+      enforcement: "mandatory"
+    },
+    sustainability_threshold: 0.1,
+    collapse_visual: {
+      background: "#1c1917",
+      text: "#fef2f2",
+      border: "#b91c1c",
+      label: "Structural Failure"
+    }
+  };
+  const computedOutcomes = parsed.outcomes.map((o) => {
+    const outcome = {
+      id: o.id,
+      type: o.type,
+      label: o.label,
+      show_in_comparison: true
+    };
+    if (o.range) outcome.range = o.range;
+    if (o.display) outcome.display_as = o.display;
+    if (o.primary) outcome.primary = o.primary;
+    if (o.assignment) outcome.assignment = o.assignment;
+    return outcome;
+  });
+  const outcomes = {
+    computed_outcomes: computedOutcomes,
+    comparison_layout: {
+      primary_card: computedOutcomes.find((o) => o.primary)?.id ?? computedOutcomes[0]?.id ?? "",
+      status_badge: "viability_status",
+      structural_indicators: rules.filter((r) => r.severity === "structural").map((r) => r.id)
+    }
+  };
+  const metadata = {
+    format_version: "1.0.0",
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    last_modified: (/* @__PURE__ */ new Date()).toISOString(),
+    authoring_method: "manual-authoring"
+  };
+  const worldDefinition = {
+    world,
+    invariants,
+    assumptions,
+    stateSchema,
+    rules,
+    gates,
+    outcomes,
+    metadata
+  };
+  return { world: worldDefinition, issues };
+}
+
+// src/contracts/bootstrap-contract.ts
+var BOOTSTRAP_EXIT_CODES = {
+  SUCCESS: 0,
+  FAIL: 1,
+  ERROR: 3
+};
+
+// src/engine/derive-engine.ts
+var import_promises3 = require("fs/promises");
+
+// src/engine/derive-normalizer.ts
+function findSections(lines) {
+  const sections = [];
+  let current = null;
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].startsWith("# ")) {
+      if (current) {
+        current.end = i;
+        sections.push(current);
+      }
+      current = { name: lines[i].replace(/^#\s+/, "").trim(), start: i, end: lines.length };
+    }
+  }
+  if (current) {
+    current.end = lines.length;
+    sections.push(current);
+  }
+  return sections;
+}
+var VALID_INVARIANT_RE = /^-\s+`[^`]+`\s*[—–-]\s*.+/;
+function normalizeInvariantLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed.startsWith("- ")) return line;
+  if (VALID_INVARIANT_RE.test(trimmed)) return line;
+  const boldMatch = trimmed.match(/^-\s+\*\*([^*]+)\*\*\s*([—–-])\s*(.+)$/);
+  if (boldMatch) {
+    const id = boldMatch[1].toLowerCase().replace(/\s+/g, "_");
+    const desc = boldMatch[3].trim();
+    const hasParens = /\([^)]+\)\s*$/.test(desc);
+    return `- \`${id}\` \u2014 ${hasParens ? desc : desc + " (structural, immutable)"}`;
+  }
+  const snakeMatch = trimmed.match(/^-\s+(\w[\w]*(?:_\w+)+)\s*([—–-])\s*(.+)$/);
+  if (snakeMatch) {
+    const id = snakeMatch[1];
+    const desc = snakeMatch[3].trim();
+    const hasParens = /\([^)]+\)\s*$/.test(desc);
+    return `- \`${id}\` \u2014 ${hasParens ? desc : desc + " (structural, immutable)"}`;
+  }
+  const proseMatch = trimmed.match(/^-\s+([A-Z][^(]+?)(?:\s*\(([^)]+)\))?\s*$/);
+  if (proseMatch) {
+    const desc = proseMatch[1].trim();
+    const parens = proseMatch[2] ?? "structural, immutable";
+    const id = desc.toLowerCase().replace(/[^a-z0-9\s]/g, "").replace(/\s+/g, "_").slice(0, 50);
+    if (id.length >= 3) {
+      return `- \`${id}\` \u2014 ${desc} (${parens})`;
+    }
+  }
+  return line;
+}
+var VALID_GATE_RE = /^-\s+\w+:\s*\w+\s*(==|!=|>=|<=|>|<)\s*[\d.]+/;
+var SYMBOLIC_TO_NUMERIC = {
+  // Positive states
+  full: 100,
+  complete: 100,
+  total: 100,
+  optimal: 95,
+  maximum: 100,
+  high: 80,
+  strong: 80,
+  // Mid states
+  partial: 60,
+  moderate: 50,
+  medium: 50,
+  growing: 60,
+  developing: 50,
+  // Low/negative states
+  low: 30,
+  minimal: 20,
+  weak: 20,
+  declining: 40,
+  limited: 30,
+  escalating: 50,
+  // Extreme states
+  none: 0,
+  absent: 0,
+  zero: 0,
+  critical: 80,
+  extreme: 90,
+  severe: 85,
+  indiscriminate: 80,
+  uncontrolled: 90,
+  overwhelming: 90
+};
+function normalizeGateLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed.startsWith("- ")) return line;
+  if (VALID_GATE_RE.test(trimmed)) return line;
+  const symbolicMatch = trimmed.match(
+    /^-\s+(\w+):\s*(\w+)\s*(?:==?)\s*"?([a-zA-Z_]+)"?\s*$/
+  );
+  if (symbolicMatch) {
+    const status = symbolicMatch[1];
+    const field = symbolicMatch[2];
+    const symbolic = symbolicMatch[3].toLowerCase();
+    const numeric = SYMBOLIC_TO_NUMERIC[symbolic];
+    if (numeric !== void 0) {
+      return `- ${status}: ${field} >= ${numeric}`;
+    }
+    return `- ${status}: ${field} >= 50`;
+  }
+  const eqNumMatch = trimmed.match(/^-\s+(\w+):\s*(\w+)\s*=\s*([\d.]+)\s*$/);
+  if (eqNumMatch) {
+    return `- ${eqNumMatch[1]}: ${eqNumMatch[2]} >= ${eqNumMatch[3]}`;
+  }
+  return line;
+}
+function normalizeWhenLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed.startsWith("When ")) return line;
+  const parts = trimmed.slice(5).split(/\s+AND\s+/i);
+  const normalized = parts.map((part) => {
+    const p = part.trim();
+    if (/\[(state|assumption)\]\s*$/.test(p)) return p;
+    return p + " [state]";
+  });
+  return "When " + normalized.join(" AND ");
+}
+function normalizeWorldMarkdown(markdown) {
+  const lines = markdown.split("\n");
+  const sections = findSections(lines);
+  const report = { fixCount: 0, invariantIds: 0, gateThresholds: 0, triggerTags: 0 };
+  const invariantsSection = sections.find((s) => s.name.toLowerCase() === "invariants");
+  const gatesSection = sections.find((s) => s.name.toLowerCase() === "gates");
+  const rulesSection = sections.find((s) => s.name.toLowerCase() === "rules");
+  for (let i = 0; i < lines.length; i++) {
+    const original = lines[i];
+    if (invariantsSection && i > invariantsSection.start && i < invariantsSection.end) {
+      lines[i] = normalizeInvariantLine(lines[i]);
+      if (lines[i] !== original) report.invariantIds++;
+    }
+    if (gatesSection && i > gatesSection.start && i < gatesSection.end) {
+      lines[i] = normalizeGateLine(lines[i]);
+      if (lines[i] !== original) report.gateThresholds++;
+    }
+    if (rulesSection && i > rulesSection.start && i < rulesSection.end) {
+      lines[i] = normalizeWhenLine(lines[i]);
+      if (lines[i] !== original) report.triggerTags++;
+    }
+    if (lines[i] !== original) report.fixCount++;
+  }
+  return { normalized: lines.join("\n"), fixCount: report.fixCount, report };
+}
+
+// src/engine/derive-prompt.ts
+var import_promises = require("fs/promises");
+var import_path = require("path");
+var import_meta = {};
+var WORLD_FILENAME = "derivation-world.nv-world.md";
+function getModuleDir() {
+  try {
+    return (0, import_path.dirname)(new URL(import_meta.url).pathname);
+  } catch {
+    return __dirname;
+  }
+}
+async function loadDerivationWorld() {
+  const moduleDir = getModuleDir();
+  const candidates = [
+    (0, import_path.join)(moduleDir, "..", "worlds", WORLD_FILENAME),
+    (0, import_path.join)(moduleDir, "worlds", WORLD_FILENAME)
+  ];
+  for (const candidate of candidates) {
+    try {
+      return await (0, import_promises.readFile)(candidate, "utf-8");
+    } catch {
+    }
+  }
+  throw new Error(
+    `DerivationWorld not found. Searched:
+${candidates.map((c2) => `  - ${c2}`).join("\n")}`
+  );
+}
+async function collectMarkdownSources(inputPath) {
+  const { stat, readFile: rf, readdir } = await import("fs/promises");
+  const { join: pathJoin, extname, basename } = await import("path");
+  const stats = await stat(inputPath);
+  if (stats.isFile()) {
+    const content = await rf(inputPath, "utf-8");
+    return [{ filename: basename(inputPath), content }];
+  }
+  if (stats.isDirectory()) {
+    const sources = [];
+    await collectDir(inputPath, sources, rf, pathJoin, extname, basename);
+    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, extname, basename) {
+  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, extname, basename);
+    } else if (entry.isFile() && extname(entry.name).toLowerCase() === ".md") {
+      const content = await rf(fullPath, "utf-8");
+      sources.push({ filename: entry.name, content });
+    }
+  }
+}
+function concatenateSources(sources) {
+  return sources.map((s) => `=== FILE: ${s.filename} ===
+${s.content}`).join("\n\n");
+}
+var NV_WORLD_SPEC = `
+## .nv-world.md Format Specification
+
+A .nv-world.md file is a structured markdown document with YAML frontmatter and H1 sections.
+
+### Frontmatter (required)
+\`\`\`yaml
+---
+world_id: <snake_case_id>
+name: <Human Readable Name>
+version: 1.0.0
+---
+\`\`\`
+
+### Required Sections
+
+# Thesis
+A single paragraph stating the structural claim this world tests. Must be testable and falsifiable.
+
+# Invariants
+Bullet list of non-negotiable constraints.
+
+STRICT FORMAT \u2014 Invariant IDs MUST be wrapped in backticks. Every bullet MUST follow this exact pattern:
+- \\\`invariant_id\\\` \u2014 Description text (enforcement, mutability)
+
+VALID examples:
+- \\\`rage_manifestation\\\` \u2014 Suppressed rage manifests as a physical monster (structural, immutable)
+- \\\`healing_requires_integration\\\` \u2014 Recovery requires emotional integration (operational, immutable)
+
+INVALID examples (these WILL cause parse failures):
+- rage_manifestation \u2014 Suppressed rage manifests as a monster
+- Suppressed rage manifests as a monster (structural, immutable)
+- **rage_manifestation** \u2014 Description
+
+Rules:
+- The ID inside backticks must be snake_case (lowercase with underscores)
+- Use "structural" for constraints derived directly from source material
+- Use "operational" for constraints you inferred
+- Mutability is almost always "immutable"
+
+# State
+H2 sub-sections, each defining a state variable:
+## variable_name
+- type: number | enum | boolean
+- min: <number> (for number type)
+- max: <number> (for number type)
+- step: <number> (for number type)
+- options: option_a, option_b (for enum type)
+- default: <value>
+- label: Human Label
+- description: What this variable represents
+
+IMPORTANT: State variable IDs (the ## heading) must be snake_case. The "default" value MUST be numeric for number types and MUST be one of the declared options for enum types.
+
+# Assumptions
+H2 sub-sections, each defining a scenario profile:
+## profile_id
+- name: Profile Name
+- description: What this profile represents
+- param_key: param_value
+
+# Rules
+H2 sub-sections with this format:
+## rule-001: Rule Label (structural|degradation|advantage)
+Single sentence description.
+
+When field == "value" [state] AND other_field > 50 [state]
+Then target *= 0.30, other_target = false
+Collapse: field < 0.05
+
+> trigger: What triggers this rule
+> rule: What the rule means
+> shift: What changes
+> effect: The concrete effect
+
+Rules must have:
+- A "When" line with triggers referencing [state] or [assumption] sources
+- A "Then" line with effects using =, *=, +=, or -= operators
+- Optional "Collapse:" line for failure conditions
+
+STRICT FORMAT for triggers \u2014 each trigger MUST match: field_name <operator> <value> [state|assumption]
+- Operators: ==, !=, >=, <=, >, <
+- Values must be numeric (50), boolean (true/false), or quoted strings ("value")
+- Source tag [state] or [assumption] is REQUIRED
+
+STRICT FORMAT for effects \u2014 each effect MUST match: target_field <operator> <value>
+- Operators: =, *=, +=, -=
+- Values must be numeric (0.30), boolean (true/false), or quoted strings ("value")
+
+# Gates
+Bullet list of status thresholds (must be monotonically decreasing).
+
+STRICT FORMAT \u2014 Gate thresholds MUST be numeric. Symbolic values like "full", "partial", "escalating" are NOT allowed. Every gate MUST follow this exact pattern:
+- STATUS_NAME: field_name >= <number>
+
+VALID examples:
+- BEST_STATUS: integration_level >= 90
+- GOOD_STATUS: integration_level >= 60
+- WARN_STATUS: monster_rage >= 40
+- BAD_STATUS: monster_rage >= 70
+- WORST_STATUS: josie_endangerment >= 90
+
+INVALID examples (these WILL cause parse failures):
+- BEST_STATUS: integration = full
+- GOOD_STATUS: integration = partial
+- BEST_STATUS: true_integration_state == "complete"
+
+Rules:
+- All gate thresholds must be NUMERIC values (integers or decimals)
+- The field_name must reference a declared State variable or Outcome
+- Operators: >=, <=, >, <, ==, !=
+- Status names should be uppercase with underscores
+- Thresholds must be monotonically decreasing from best to worst status
+
+# Outcomes
+H2 sub-sections defining computed outcomes:
+## outcome_id
+- type: number | enum | boolean
+- range: 0-100 (for numbers)
+- display: percentage | integer | decimal
+- label: Human Label
+- primary: true (for the main metric)
+`.trim();
+async function buildSystemPrompt() {
+  const derivationWorld = await loadDerivationWorld();
+  const invariantLines = derivationWorld.split("\n").filter((l) => l.trim().startsWith("- `")).map((l) => {
+    const match = l.match(/^-\s+`([^`]+)`\s*[—–-]\s*(.+?)(?:\s*\([^)]+\))?\s*$/);
+    return match ? `- ${match[2].trim()}` : null;
+  }).filter(Boolean);
+  return `You are a governance document synthesizer for NeuroVerse OS.
+
+Your task: Given arbitrary markdown source material, synthesize a valid .nv-world.md governance document.
+
+${NV_WORLD_SPEC}
+
+## Synthesis Constraints (from DerivationWorld)
+
+You MUST follow these constraints:
+${invariantLines.join("\n")}
+
+## Critical Rules
+
+1. Output ONLY the .nv-world.md document. No preamble, no explanation, no trailing commentary.
+2. Do not wrap the output in a code fence.
+3. Every invariant derived from explicit source statements must be marked (structural, immutable).
+4. Every invariant you infer that is not directly stated in the source must be marked (operational, immutable).
+5. All state variables, rules, and invariants must trace to concepts present in the input.
+6. Do not invent governance domains beyond what the source material covers.
+7. Every rule must have a When trigger line and a Then effect line.
+8. Gate thresholds must be monotonically decreasing from best to worst status.
+9. The frontmatter must include world_id, name, and version.
+10. Rule descriptions must be a single sentence.
+
+## Syntax Precision (CRITICAL)
+
+The output is parsed by a deterministic regex parser. If the syntax is wrong, the parse FAILS.
+
+INVARIANTS: Every invariant bullet MUST use backtick-wrapped IDs:
+  CORRECT: - \\\`my_invariant_id\\\` \u2014 Description (structural, immutable)
+  WRONG:   - my_invariant_id \u2014 Description
+
+GATES: Every gate MUST use NUMERIC thresholds:
+  CORRECT: - THRIVING: score >= 80
+  WRONG:   - THRIVING: state = optimal
+
+TRIGGERS: Every trigger MUST end with [state] or [assumption]:
+  CORRECT: When score < 25 [state]
+  WRONG:   When score < 25
+
+EFFECTS: Every effect MUST use a recognized operator:
+  CORRECT: Then score *= 0.50, active = false
+  WRONG:   Then score decreases by half`;
+}
+function buildUserPrompt(concatenatedMarkdown) {
+  return `Synthesize a valid .nv-world.md under DerivationWorld constraints from the following source material.
+
+Output ONLY the .nv-world.md content. Start with the --- frontmatter delimiter.
+
+Source material:
+
+${concatenatedMarkdown}`;
+}
+
+// src/providers/ai-provider.ts
+var ChatCompletionsProvider = class {
+  model;
+  apiKey;
+  endpoint;
+  constructor(config) {
+    this.model = config.model;
+    this.apiKey = config.apiKey;
+    this.endpoint = config.endpoint ?? "https://api.openai.com/v1/chat/completions";
+  }
+  async complete(systemPrompt, userPrompt) {
+    const body = {
+      model: this.model,
+      messages: [
+        { role: "system", content: systemPrompt },
+        { role: "user", content: userPrompt }
+      ],
+      temperature: 0.2,
+      max_tokens: 16384
+    };
+    const response = await fetch(this.endpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const text = await response.text().catch(() => "");
+      throw new Error(`Provider returned ${response.status}: ${text.slice(0, 200)}`);
+    }
+    const data = await response.json();
+    const content = data?.choices?.[0]?.message?.content;
+    if (!content) {
+      throw new Error("Provider returned empty response \u2014 no content in choices[0].message.content");
+    }
+    return content;
+  }
+};
+function createProvider(config) {
+  return new ChatCompletionsProvider(config);
+}
+
+// src/providers/config-manager.ts
+var import_promises2 = require("fs/promises");
+var import_path2 = require("path");
+var import_os = require("os");
+function getConfigDir() {
+  const xdg = process.env.XDG_CONFIG_HOME;
+  if (xdg) return (0, import_path2.join)(xdg, "neuroverse");
+  return (0, import_path2.join)((0, import_os.homedir)(), ".neuroverse");
+}
+function getConfigPath() {
+  return (0, import_path2.join)(getConfigDir(), "config.json");
+}
+async function loadConfig() {
+  try {
+    const raw = await (0, import_promises2.readFile)(getConfigPath(), "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!parsed.provider || !parsed.model || !parsed.apiKey) {
+      return null;
+    }
+    return {
+      provider: parsed.provider,
+      model: parsed.model,
+      apiKey: parsed.apiKey,
+      endpoint: parsed.endpoint ?? null
+    };
+  } catch {
+    return null;
+  }
+}
+
+// src/engine/derive-engine.ts
+function extractWorldMarkdown(raw) {
+  let content = raw.trim();
+  const fenceMatch = content.match(/```(?:markdown|md)?\s*\n([\s\S]*?)```/);
+  if (fenceMatch) {
+    content = fenceMatch[1].trim();
+  }
+  const sentinelMatch = content.match(
+    /(?:BEGIN NV WORLD|BEGIN_NV_WORLD)[\s\n]*([\s\S]*?)[\s\n]*(?:END NV WORLD|END_NV_WORLD)/i
+  );
+  if (sentinelMatch) {
+    content = sentinelMatch[1].trim();
+  }
+  if (!content.startsWith("---")) {
+    const fmIndex = content.indexOf("---\n");
+    if (fmIndex >= 0) {
+      content = content.slice(fmIndex);
+    }
+  }
+  if (!content.startsWith("---") && /^# /m.test(content)) {
+    const generated = generateFrontmatter(content);
+    content = generated + "\n" + content;
+  }
+  if (!content.startsWith("---")) return null;
+  const fmEnd = content.indexOf("---", 3);
+  if (fmEnd === -1) return null;
+  const frontmatter = content.slice(3, fmEnd);
+  if (!frontmatter.includes("world_id:")) return null;
+  return content;
+}
+function generateFrontmatter(content) {
+  let name = "Derived World";
+  const thesisMatch = content.match(/^# Thesis\s*\n+(.+)/m);
+  if (thesisMatch) {
+    const firstSentence = thesisMatch[1].replace(/[.!?].*$/, "").trim();
+    if (firstSentence.length >= 3 && firstSentence.length <= 60) {
+      name = firstSentence;
+    }
+  }
+  const worldId = name.toLowerCase().replace(/[^a-z0-9\s]/g, "").replace(/\s+/g, "_").slice(0, 50);
+  return [
+    "---",
+    `world_id: ${worldId}`,
+    `name: ${name}`,
+    "version: 0.1",
+    "runtime_mode: simulation",
+    "---"
+  ].join("\n");
+}
+var GATES = [
+  { status: "FAITHFUL", threshold: 0.85 },
+  { status: "USABLE", threshold: 0.6 },
+  { status: "REVIEWABLE", threshold: 0.4 },
+  { status: "SUSPECT", threshold: 0.15 },
+  { status: "DERIVATION_REJECTED", threshold: 0 }
+];
+function classifyGate(errors, warnings, sectionCount) {
+  const maxSections = 7;
+  const completeness = sectionCount / maxSections;
+  const fidelity = errors === 0 ? Math.max(0, completeness - warnings * 0.05) : 0;
+  for (const gate of GATES) {
+    if (fidelity >= gate.threshold) return gate.status;
+  }
+  return "DERIVATION_REJECTED";
+}
+async function deriveWorld(options) {
+  const startTime = performance.now();
+  const sources = await collectMarkdownSources(options.inputPath);
+  if (sources.length === 0) {
+    throw new DeriveInputError("No markdown files found in input path");
+  }
+  const concatenated = concatenateSources(sources);
+  const systemPrompt = await buildSystemPrompt();
+  const userPrompt = buildUserPrompt(concatenated);
+  if (options.dryRun) {
+    return {
+      result: {
+        success: true,
+        outputPath: options.outputPath,
+        sectionsDetected: [],
+        validationErrors: 0,
+        validationWarnings: 0,
+        findings: [],
+        gate: "DRY_RUN",
+        durationMs: performance.now() - startTime
+      },
+      exitCode: 0,
+      dryRunOutput: { systemPrompt, userPrompt }
+    };
+  }
+  const savedConfig = await loadConfig();
+  const config = {
+    provider: options.providerOverride?.provider ?? savedConfig?.provider ?? "",
+    model: options.providerOverride?.model ?? savedConfig?.model ?? "",
+    apiKey: options.providerOverride?.apiKey ?? savedConfig?.apiKey ?? "",
+    endpoint: options.providerOverride?.endpoint ?? savedConfig?.endpoint ?? null
+  };
+  if (!config.apiKey) {
+    throw new DeriveProviderError("No API key configured. Run: neuroverse configure-ai");
+  }
+  if (!config.model) {
+    throw new DeriveProviderError("No model configured. Run: neuroverse configure-ai");
+  }
+  const provider = createProvider(config);
+  let rawResponse;
+  try {
+    rawResponse = await provider.complete(systemPrompt, userPrompt);
+  } catch (e) {
+    throw new DeriveProviderError(`AI provider failed: ${e instanceof Error ? e.message : String(e)}`);
+  }
+  const extracted = extractWorldMarkdown(rawResponse);
+  if (!extracted) {
+    throw new DeriveProviderError(
+      "Could not extract valid .nv-world.md from AI response. Response must contain frontmatter with world_id."
+    );
+  }
+  const { normalized, fixCount, report: normReport } = normalizeWorldMarkdown(extracted);
+  const { world, issues } = parseWorldMarkdown(normalized);
+  const errors = issues.filter((i) => i.severity === "error");
+  const warnings = issues.filter((i) => i.severity === "warning");
+  const sectionsDetected = world ? Object.keys(world).filter((k) => {
+    const val = world[k];
+    if (Array.isArray(val)) return val.length > 0;
+    if (typeof val === "string") return val.length > 0;
+    return !!val;
+  }) : [];
+  if (world && options.validate) {
+    try {
+      const { world: worldDef } = emitWorldDefinition(world);
+      const report = validateWorld(worldDef);
+      for (const finding2 of report.findings) {
+        if (finding2.severity === "error" || finding2.severity === "warning") {
+          issues.push({
+            line: 0,
+            section: `Validate:${finding2.category}`,
+            message: finding2.message,
+            severity: finding2.severity
+          });
+        }
+      }
+    } catch {
+    }
+  }
+  const allErrors = issues.filter((i) => i.severity === "error");
+  const allWarnings = issues.filter((i) => i.severity === "warning");
+  const gate = classifyGate(allErrors.length, allWarnings.length, sectionsDetected.length);
+  const findings = issues.filter((i) => i.severity === "error" || i.severity === "warning").map((i) => ({
+    severity: i.severity,
+    section: i.section,
+    message: i.message,
+    line: i.line
+  }));
+  let output = normalized;
+  if (findings.length > 0 || fixCount > 0) {
+    const lines = [`<!-- DERIVATION STATUS: ${gate}`];
+    if (fixCount > 0) {
+      const details = [];
+      if (normReport.invariantIds > 0) details.push(`${normReport.invariantIds} invariant ID(s) wrapped`);
+      if (normReport.gateThresholds > 0) details.push(`${normReport.gateThresholds} gate threshold(s) converted`);
+      if (normReport.triggerTags > 0) details.push(`${normReport.triggerTags} trigger(s) tagged with [state]`);
+      lines.push(``, `Normalizer: ${fixCount} fix(es) applied`);
+      for (const d of details) lines.push(`  - ${d}`);
+    }
+    const errs = findings.filter((f) => f.severity === "error");
+    const warns = findings.filter((f) => f.severity === "warning");
+    if (errs.length > 0) {
+      lines.push("", "Errors:");
+      for (const f of errs) lines.push(`- [${f.section}] ${f.message}`);
+    }
+    if (warns.length > 0) {
+      lines.push("", "Warnings:");
+      for (const f of warns) lines.push(`- [${f.section}] ${f.message}`);
+    }
+    lines.push("-->", "");
+    output = lines.join("\n") + normalized;
+  }
+  await (0, import_promises3.writeFile)(options.outputPath, output, "utf-8");
+  const hasErrors = allErrors.length > 0;
+  return {
+    result: {
+      success: !hasErrors,
+      outputPath: options.outputPath,
+      sectionsDetected,
+      validationErrors: allErrors.length,
+      validationWarnings: allWarnings.length,
+      findings,
+      gate,
+      normalization: fixCount > 0 ? {
+        fixCount: normReport.fixCount,
+        invariantIds: normReport.invariantIds,
+        gateThresholds: normReport.gateThresholds,
+        triggerTags: normReport.triggerTags
+      } : void 0,
+      durationMs: performance.now() - startTime
+    },
+    exitCode: hasErrors ? 1 : 0
+  };
+}
+var DeriveInputError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "DeriveInputError";
+  }
+};
+var DeriveProviderError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "DeriveProviderError";
+  }
+};
+
+// src/engine/explain-engine.ts
+function detectTensions(rules) {
+  const increases = /* @__PURE__ */ new Map();
+  const decreases = /* @__PURE__ */ new Map();
+  for (const rule of rules) {
+    const allEffects = collectAllEffects(rule);
+    for (const effect of allEffects) {
+      const target = effect.target;
+      const isIncrease = effect.operation === "add" || effect.operation === "multiply" && typeof effect.value === "number" && effect.value > 1;
+      const isDecrease = effect.operation === "subtract" || effect.operation === "multiply" && typeof effect.value === "number" && effect.value < 1;
+      if (isIncrease) {
+        if (!increases.has(target)) increases.set(target, []);
+        increases.get(target).push(rule.label);
+      }
+      if (isDecrease) {
+        if (!decreases.has(target)) decreases.set(target, []);
+        decreases.get(target).push(rule.label);
+      }
+    }
+  }
+  const tensions = [];
+  for (const [variable, incRules] of increases) {
+    const decRules = decreases.get(variable);
+    if (decRules && decRules.length > 0) {
+      tensions.push({
+        variable,
+        increasedBy: incRules,
+        decreasedBy: decRules
+      });
+    }
+  }
+  return tensions;
+}
+function collectAllEffects(rule) {
+  const effects = [...rule.effects ?? []];
+  for (const ce of rule.effects_conditional ?? []) {
+    effects.push(...ce.effects);
+  }
+  return effects;
+}
+function explainWorld(world) {
+  const dynamics = [...world.rules].sort((a, b) => a.order - b.order).map((rule) => {
+    const allEffects = collectAllEffects(rule);
+    return {
+      ruleId: rule.id,
+      label: rule.label,
+      severity: rule.severity,
+      triggerDescription: rule.causal_translation?.trigger_text ?? describeTriggers(rule),
+      effectDescription: rule.causal_translation?.effect_text ?? describeEffects(allEffects),
+      targets: [...new Set(allEffects.map((e) => e.target))]
+    };
+  });
+  const stateVariables = Object.entries(world.stateSchema.variables ?? {}).map(
+    ([name, v]) => ({
+      name,
+      label: v.label || name,
+      type: v.type,
+      defaultValue: v.default,
+      range: v.type === "number" && v.min !== void 0 && v.max !== void 0 ? `${v.min}\u2013${v.max}` : v.type === "enum" && v.options ? v.options.join(", ") : void 0
+    })
+  );
+  const invariants = world.invariants.map((inv) => ({
+    id: inv.id,
+    label: inv.label,
+    enforcement: inv.enforcement
+  }));
+  const gates = (world.gates.viability_classification ?? []).map((g) => ({
+    status: g.status,
+    field: g.field,
+    threshold: `${g.operator} ${g.value}`
+  }));
+  const tensions = detectTensions(world.rules);
+  const outcomes = (world.outcomes.computed_outcomes ?? []).map((o) => ({
+    id: o.id,
+    label: o.label,
+    type: o.type,
+    primary: o.primary ?? false
+  }));
+  const stats = {
+    invariants: world.invariants.length,
+    stateVariables: Object.keys(world.stateSchema.variables ?? {}).length,
+    rules: world.rules.length,
+    gates: (world.gates.viability_classification ?? []).length,
+    outcomes: (world.outcomes.computed_outcomes ?? []).length,
+    assumptions: Object.keys(world.assumptions.profiles ?? {}).length
+  };
+  return {
+    worldName: world.world.name,
+    worldId: world.world.world_id,
+    thesis: world.world.thesis,
+    dynamics,
+    stateVariables,
+    invariants,
+    gates,
+    tensions,
+    outcomes,
+    stats
+  };
+}
+function describeTriggers(rule) {
+  if (!rule.triggers || rule.triggers.length === 0) return "Always active";
+  return rule.triggers.map((t) => `${t.field} ${t.operator} ${t.value}`).join(" AND ");
+}
+function describeEffects(effects) {
+  if (effects.length === 0) return "No direct effects";
+  return effects.map((e) => {
+    switch (e.operation) {
+      case "multiply":
+        return `${e.target} scaled by ${e.value}`;
+      case "add":
+        return `${e.target} increased by ${e.value}`;
+      case "subtract":
+        return `${e.target} decreased by ${e.value}`;
+      case "set":
+        return `${e.target} set to ${e.value}`;
+      case "set_boolean":
+        return `${e.target} set to ${e.value}`;
+      default:
+        return `${e.target} ${e.operation} ${e.value}`;
+    }
+  }).join("; ");
+}
+function renderExplainText(output) {
+  const lines = [];
+  lines.push(`WORLD: ${output.worldName}`);
+  lines.push(`ID: ${output.worldId}`);
+  lines.push("");
+  if (output.thesis) {
+    lines.push("THESIS");
+    lines.push(`  ${output.thesis}`);
+    lines.push("");
+  }
+  lines.push("STRUCTURE");
+  lines.push(`  ${output.stats.invariants} invariants, ${output.stats.stateVariables} state variables, ${output.stats.rules} rules`);
+  lines.push(`  ${output.stats.gates} viability gates, ${output.stats.outcomes} outcomes, ${output.stats.assumptions} assumption profiles`);
+  lines.push("");
+  if (output.dynamics.length > 0) {
+    lines.push("KEY DYNAMICS");
+    for (const d of output.dynamics) {
+      const severity = d.severity === "structural" ? "[structural]" : d.severity === "advantage" ? "[advantage]" : "[degradation]";
+      lines.push(`  ${d.label} ${severity}`);
+      lines.push(`    When: ${d.triggerDescription}`);
+      lines.push(`    Then: ${d.effectDescription}`);
+    }
+    lines.push("");
+  }
+  if (output.tensions.length > 0) {
+    lines.push("DRAMATIC TENSIONS");
+    for (const t of output.tensions) {
+      lines.push(`  ${t.variable}:`);
+      lines.push(`    Increased by: ${t.increasedBy.join(", ")}`);
+      lines.push(`    Decreased by: ${t.decreasedBy.join(", ")}`);
+    }
+    lines.push("");
+  }
+  if (output.stateVariables.length > 0) {
+    lines.push("STATE VARIABLES");
+    for (const v of output.stateVariables) {
+      const range = v.range ? ` (${v.range})` : "";
+      lines.push(`  ${v.label}: ${v.type}, default ${v.defaultValue}${range}`);
+    }
+    lines.push("");
+  }
+  if (output.invariants.length > 0) {
+    lines.push("INVARIANTS (cannot change)");
+    for (const inv of output.invariants) {
+      lines.push(`  ${inv.label} [${inv.enforcement}]`);
+    }
+    lines.push("");
+  }
+  if (output.gates.length > 0) {
+    lines.push("VIABILITY GATES");
+    for (const g of output.gates) {
+      lines.push(`  ${g.status}: ${g.field} ${g.threshold}`);
+    }
+    lines.push("");
+  }
+  if (output.outcomes.length > 0) {
+    lines.push("OUTCOMES");
+    for (const o of output.outcomes) {
+      const primary = o.primary ? " [primary]" : "";
+      lines.push(`  ${o.label} (${o.type})${primary}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+// src/engine/simulate-engine.ts
+function simulateWorld(world, options = {}) {
+  const steps = Math.max(1, Math.min(options.steps ?? 1, 50));
+  const profileName = options.profile ?? world.world.default_assumption_profile;
+  const state = buildInitialState(world.stateSchema, options.stateOverrides);
+  const assumptions = resolveAssumptions(world.assumptions, profileName);
+  const initialState = { ...state };
+  const simulationSteps = [];
+  let collapsed = false;
+  let collapseStep;
+  let collapseRule;
+  const sortedRules = [...world.rules].sort((a, b) => a.order - b.order);
+  for (let stepNum = 1; stepNum <= steps; stepNum++) {
+    if (collapsed) break;
+    const stepResult = evaluateStep(
+      stepNum,
+      sortedRules,
+      state,
+      assumptions,
+      world
+    );
+    simulationSteps.push(stepResult);
+    if (stepResult.collapsed) {
+      collapsed = true;
+      collapseStep = stepNum;
+      collapseRule = stepResult.rulesEvaluated.find((r) => r.collapsed)?.ruleId;
+    }
+  }
+  const finalViability = classifyViability(state, world);
+  return {
+    worldId: world.world.world_id,
+    worldName: world.world.name,
+    profile: profileName,
+    initialState,
+    steps: simulationSteps,
+    finalState: { ...state },
+    finalViability,
+    collapsed,
+    collapseStep,
+    collapseRule
+  };
+}
+function evaluateStep(stepNum, rules, state, assumptions, world) {
+  const evaluations = [];
+  let rulesFired = 0;
+  let collapsed = false;
+  const firedRuleIds = /* @__PURE__ */ new Set();
+  for (const rule of rules) {
+    if (collapsed) {
+      evaluations.push({
+        ruleId: rule.id,
+        label: rule.label,
+        triggered: false,
+        excluded: true,
+        effects: [],
+        collapsed: false
+      });
+      continue;
+    }
+    const excluded = rule.exclusive_with ? firedRuleIds.has(rule.exclusive_with) : false;
+    if (excluded) {
+      evaluations.push({
+        ruleId: rule.id,
+        label: rule.label,
+        triggered: false,
+        excluded: true,
+        effects: [],
+        collapsed: false
+      });
+      continue;
+    }
+    const triggered = evaluateTriggers(rule.triggers, state, assumptions);
+    if (!triggered) {
+      evaluations.push({
+        ruleId: rule.id,
+        label: rule.label,
+        triggered: false,
+        excluded: false,
+        effects: [],
+        collapsed: false
+      });
+      continue;
+    }
+    firedRuleIds.add(rule.id);
+    rulesFired++;
+    const appliedEffects = [];
+    for (const effect of rule.effects ?? []) {
+      const applied = applyEffect(effect, state);
+      if (applied) appliedEffects.push(applied);
+    }
+    for (const ce of rule.effects_conditional ?? []) {
+      const conditionMet = evaluateSingleTrigger(ce.condition, state, assumptions);
+      const andMet = ce.and ? evaluateSingleTrigger(ce.and, state, assumptions) : true;
+      const orMet = ce.or ? evaluateSingleTrigger(ce.or, state, assumptions) : false;
+      const anyMet = ce.condition_any ? ce.condition_any.some((c2) => evaluateSingleTrigger(c2, state, assumptions)) : false;
+      const shouldApply = conditionMet && andMet || ce.or && orMet || ce.condition_any && anyMet;
+      if (shouldApply) {
+        for (const effect of ce.effects) {
+          const applied = applyEffect(effect, state);
+          if (applied) appliedEffects.push(applied);
+        }
+      }
+    }
+    let ruleCollapsed = false;
+    if (rule.collapse_check) {
+      const fieldVal = typeof state[rule.collapse_check.field] === "number" ? state[rule.collapse_check.field] : 0;
+      if (evaluateOperator(fieldVal, rule.collapse_check.operator, rule.collapse_check.value)) {
+        ruleCollapsed = true;
+        collapsed = true;
+      }
+    }
+    if (!ruleCollapsed && rule.secondary_check) {
+      const fieldVal = typeof state[rule.secondary_check.field] === "number" ? state[rule.secondary_check.field] : 0;
+      if (evaluateOperator(fieldVal, rule.secondary_check.operator, rule.secondary_check.value)) {
+        ruleCollapsed = true;
+        collapsed = true;
+      }
+    }
+    evaluations.push({
+      ruleId: rule.id,
+      label: rule.label,
+      triggered: true,
+      excluded: false,
+      effects: appliedEffects,
+      collapsed: ruleCollapsed,
+      collapseField: ruleCollapsed ? rule.collapse_check?.field ?? rule.secondary_check?.field : void 0
+    });
+  }
+  const viability = classifyViability(state, world);
+  return {
+    step: stepNum,
+    rulesEvaluated: evaluations,
+    rulesFired,
+    stateAfter: { ...state },
+    viability,
+    collapsed
+  };
+}
+function evaluateTriggers(triggers, state, assumptions) {
+  if (!triggers || triggers.length === 0) return true;
+  return triggers.every((t) => evaluateSingleTrigger(t, state, assumptions));
+}
+function evaluateSingleTrigger(trigger, state, assumptions) {
+  const source = trigger.source === "assumption" ? assumptions : state;
+  const fieldValue = source[trigger.field];
+  if (fieldValue === void 0) return false;
+  return evaluateOperator(fieldValue, trigger.operator, trigger.value);
+}
+function evaluateOperator(fieldValue, operator, conditionValue) {
+  switch (operator) {
+    case "==":
+      return fieldValue === conditionValue;
+    case "!=":
+      return fieldValue !== conditionValue;
+    case ">":
+      return typeof fieldValue === "number" && typeof conditionValue === "number" && fieldValue > conditionValue;
+    case "<":
+      return typeof fieldValue === "number" && typeof conditionValue === "number" && fieldValue < conditionValue;
+    case ">=":
+      return typeof fieldValue === "number" && typeof conditionValue === "number" && fieldValue >= conditionValue;
+    case "<=":
+      return typeof fieldValue === "number" && typeof conditionValue === "number" && fieldValue <= conditionValue;
+    case "in":
+      return Array.isArray(conditionValue) && conditionValue.includes(String(fieldValue));
+    default:
+      return false;
+  }
+}
+function applyEffect(effect, state) {
+  const before = state[effect.target];
+  let after;
+  switch (effect.operation) {
+    case "multiply":
+    case "multiply_dynamic": {
+      const current = typeof before === "number" ? before : 0;
+      const factor = typeof effect.value === "number" ? effect.value : 1;
+      after = current * factor;
+      break;
+    }
+    case "add":
+    case "add_dynamic": {
+      const current = typeof before === "number" ? before : 0;
+      const addend = typeof effect.value === "number" ? effect.value : 0;
+      after = current + addend;
+      break;
+    }
+    case "subtract":
+    case "subtract_dynamic": {
+      const current = typeof before === "number" ? before : 0;
+      const subtrahend = typeof effect.value === "number" ? effect.value : 0;
+      after = current - subtrahend;
+      break;
+    }
+    case "set":
+    case "set_dynamic":
+      after = effect.value;
+      break;
+    case "set_boolean":
+      after = !!effect.value;
+      break;
+    default:
+      return null;
+  }
+  state[effect.target] = after;
+  return {
+    target: effect.target,
+    operation: effect.operation,
+    value: effect.value,
+    before: before ?? 0,
+    after
+  };
+}
+function buildInitialState(schema, overrides) {
+  const state = {};
+  for (const [name, variable] of Object.entries(schema.variables ?? {})) {
+    state[name] = variable.default;
+  }
+  if (overrides) {
+    for (const [key, value] of Object.entries(overrides)) {
+      state[key] = value;
+    }
+  }
+  return state;
+}
+function resolveAssumptions(config, profileName) {
+  const profile = config.profiles?.[profileName];
+  return profile?.parameters ?? {};
+}
+function classifyViability(state, world) {
+  const gates = world.gates?.viability_classification ?? [];
+  for (const gate of gates) {
+    const fieldValue = state[gate.field];
+    if (typeof fieldValue !== "number") continue;
+    if (evaluateOperator(fieldValue, gate.operator, gate.value)) {
+      return gate.status;
+    }
+  }
+  return "MODEL_COLLAPSES";
+}
+function renderSimulateText(result) {
+  const lines = [];
+  lines.push(`SIMULATION: ${result.worldName}`);
+  lines.push(`Profile: ${result.profile}`);
+  lines.push(`Steps: ${result.steps.length}`);
+  lines.push("");
+  lines.push("INITIAL STATE");
+  for (const [key, value] of Object.entries(result.initialState)) {
+    lines.push(`  ${key}: ${value}`);
+  }
+  lines.push("");
+  for (const step of result.steps) {
+    lines.push(`STEP ${step.step}`);
+    const fired = step.rulesEvaluated.filter((r) => r.triggered);
+    const skipped = step.rulesEvaluated.filter((r) => !r.triggered && !r.excluded);
+    const excluded = step.rulesEvaluated.filter((r) => r.excluded);
+    if (fired.length === 0) {
+      lines.push("  No rules fired (state unchanged)");
+    } else {
+      for (const rule of fired) {
+        lines.push(`  FIRED: ${rule.label}`);
+        for (const effect of rule.effects) {
+          const beforeStr = formatValue(effect.before);
+          const afterStr = formatValue(effect.after);
+          lines.push(`    ${effect.target}: ${beforeStr} -> ${afterStr}`);
+        }
+        if (rule.collapsed) {
+          lines.push(`    COLLAPSE on ${rule.collapseField}`);
+        }
+      }
+    }
+    if (excluded.length > 0) {
+      lines.push(`  Excluded: ${excluded.map((r) => r.label).join(", ")}`);
+    }
+    lines.push(`  Viability: ${step.viability}`);
+    if (step.collapsed) {
+      lines.push("  ** MODEL COLLAPSED **");
+    }
+    lines.push("");
+  }
+  lines.push("FINAL STATE");
+  for (const [key, value] of Object.entries(result.finalState)) {
+    const initial = result.initialState[key];
+    const changed = initial !== value;
+    const marker = changed ? " (changed)" : "";
+    lines.push(`  ${key}: ${formatValue(value)}${marker}`);
+  }
+  lines.push("");
+  lines.push(`VIABILITY: ${result.finalViability}`);
+  if (result.collapsed) {
+    lines.push(`COLLAPSED at step ${result.collapseStep} (rule: ${result.collapseRule})`);
+  }
+  return lines.join("\n");
+}
+function formatValue(v) {
+  if (typeof v === "number") {
+    return Number.isInteger(v) ? String(v) : v.toFixed(2);
+  }
+  return String(v);
+}
+
+// src/engine/improve-engine.ts
+function improveWorld(world) {
+  const suggestions = [];
+  const report = validateWorld(world);
+  addValidationSuggestions(report.findings, suggestions);
+  analyzeRuleBalance(world, suggestions);
+  analyzeStateCoverage(world, suggestions);
+  analyzeGateCoverage(world, suggestions);
+  analyzeAssumptions(world, suggestions);
+  analyzeSimulationDynamics(world, suggestions);
+  analyzeCompleteness(world, suggestions);
+  const seen = /* @__PURE__ */ new Set();
+  const unique = suggestions.filter((s) => {
+    if (seen.has(s.id)) return false;
+    seen.add(s.id);
+    return true;
+  });
+  const priorityOrder = {
+    critical: 0,
+    high: 1,
+    medium: 2,
+    low: 3
+  };
+  unique.sort((a, b) => priorityOrder[a.priority] - priorityOrder[b.priority]);
+  const score = computeHealthScore(world, unique);
+  return {
+    worldId: world.world.world_id,
+    worldName: world.world.name,
+    score,
+    suggestions: unique,
+    stats: {
+      critical: unique.filter((s) => s.priority === "critical").length,
+      high: unique.filter((s) => s.priority === "high").length,
+      medium: unique.filter((s) => s.priority === "medium").length,
+      low: unique.filter((s) => s.priority === "low").length
+    }
+  };
+}
+function addValidationSuggestions(findings, suggestions) {
+  for (const f of findings) {
+    if (f.severity === "info") continue;
+    const priority = f.severity === "error" ? "critical" : "high";
+    const category = f.severity === "error" ? "fix" : "structure";
+    suggestions.push({
+      id: `validate-${f.id}`,
+      priority,
+      category,
+      title: f.message,
+      description: f.message,
+      action: f.suggestion ?? `Review ${f.affectedBlocks.join(", ")}`,
+      affectedFiles: f.affectedBlocks
+    });
+  }
+}
+function analyzeRuleBalance(world, suggestions) {
+  if (!world.rules || world.rules.length === 0) return;
+  const structural = world.rules.filter((r) => r.severity === "structural");
+  const degradation = world.rules.filter((r) => r.severity === "degradation");
+  const advantage = world.rules.filter((r) => r.severity === "advantage");
+  if (structural.length === 0) {
+    suggestions.push({
+      id: "no-structural-rules",
+      priority: "high",
+      category: "balance",
+      title: "No structural rules",
+      description: "All rules are degradation or advantage. Structural rules define the core mechanics that hold the world together.",
+      action: "Add at least one structural-severity rule that enforces a fundamental world constraint.",
+      affectedFiles: ["rules/"]
+    });
+  }
+  if (advantage.length === 0 && world.rules.length >= 3) {
+    suggestions.push({
+      id: "no-advantage-rules",
+      priority: "medium",
+      category: "balance",
+      title: "No advantage rules",
+      description: "All rules are negative (structural or degradation). Adding advantage rules creates positive feedback loops.",
+      action: 'Add a rule with severity "advantage" that rewards desirable state.',
+      affectedFiles: ["rules/"]
+    });
+  }
+  if (degradation.length === 0 && world.rules.length >= 3) {
+    suggestions.push({
+      id: "no-degradation-rules",
+      priority: "medium",
+      category: "balance",
+      title: "No degradation rules",
+      description: "No rules model gradual decline. Degradation rules create realistic tension.",
+      action: 'Add a rule with severity "degradation" that models gradual state decline.',
+      affectedFiles: ["rules/"]
+    });
+  }
+  const missingTranslation = world.rules.filter(
+    (r) => !r.causal_translation?.trigger_text && !r.causal_translation?.effect_text
+  );
+  if (missingTranslation.length > 0 && missingTranslation.length <= 5) {
+    suggestions.push({
+      id: "missing-causal-translations",
+      priority: "low",
+      category: "completeness",
+      title: `${missingTranslation.length} rule(s) missing causal translations`,
+      description: "Causal translations provide human-readable narratives for rules. They improve explain output.",
+      action: `Add causal_translation to: ${missingTranslation.map((r) => r.id).join(", ")}`,
+      affectedFiles: ["rules/"]
+    });
+  }
+}
+function analyzeStateCoverage(world, suggestions) {
+  if (!world.stateSchema?.variables || !world.rules) return;
+  const variables = Object.keys(world.stateSchema.variables);
+  const ruleTargets = /* @__PURE__ */ new Set();
+  const ruleTriggers = /* @__PURE__ */ new Set();
+  for (const rule of world.rules) {
+    for (const t of rule.triggers) {
+      if (t.source === "state") ruleTriggers.add(t.field);
+    }
+    for (const e of rule.effects ?? []) {
+      ruleTargets.add(e.target);
+    }
+    for (const ce of rule.effects_conditional ?? []) {
+      for (const e of ce.effects) {
+        ruleTargets.add(e.target);
+      }
+    }
+  }
+  const writeOnly = variables.filter((v) => ruleTargets.has(v) && !ruleTriggers.has(v));
+  if (writeOnly.length > 0) {
+    suggestions.push({
+      id: "write-only-variables",
+      priority: "medium",
+      category: "structure",
+      title: `${writeOnly.length} write-only variable(s)`,
+      description: `These variables are modified by rules but never trigger any rule: ${writeOnly.join(", ")}. They may be dead-end state.`,
+      action: "Add rules that trigger on these variables to create feedback loops.",
+      affectedFiles: ["rules/", "state-schema.json"]
+    });
+  }
+  const readOnly = variables.filter((v) => ruleTriggers.has(v) && !ruleTargets.has(v));
+  if (readOnly.length > 0 && readOnly.length <= 3) {
+    suggestions.push({
+      id: "read-only-variables",
+      priority: "low",
+      category: "structure",
+      title: `${readOnly.length} input-only variable(s)`,
+      description: `These variables trigger rules but are never modified: ${readOnly.join(", ")}. They act as fixed inputs.`,
+      action: "This is fine for configuration inputs. If they should evolve, add rules that target them.",
+      affectedFiles: ["state-schema.json"]
+    });
+  }
+}
+function analyzeGateCoverage(world, suggestions) {
+  const gates = world.gates?.viability_classification ?? [];
+  if (gates.length === 0) return;
+  const statuses = new Set(gates.map((g) => g.status));
+  const standard = ["THRIVING", "STABLE", "COMPRESSED", "CRITICAL", "MODEL_COLLAPSES"];
+  const missing = standard.filter((s) => !statuses.has(s));
+  if (missing.length > 0 && missing.length <= 2) {
+    suggestions.push({
+      id: "incomplete-viability-gates",
+      priority: "medium",
+      category: "structure",
+      title: `Missing viability level(s): ${missing.join(", ")}`,
+      description: "A complete viability ladder gives finer-grained status classification.",
+      action: `Add gates for: ${missing.join(", ")}`,
+      affectedFiles: ["gates.json"]
+    });
+  }
+}
+function analyzeAssumptions(world, suggestions) {
+  const profiles = Object.keys(world.assumptions?.profiles ?? {});
+  if (profiles.length === 1) {
+    suggestions.push({
+      id: "single-assumption-profile",
+      priority: "medium",
+      category: "completeness",
+      title: "Only one assumption profile",
+      description: "A single profile means no scenario comparison. Add an alternative profile to enable what-if analysis.",
+      action: "Add a second profile with different parameter values to assumptions.json.",
+      affectedFiles: ["assumptions.json"]
+    });
+  }
+}
+function analyzeSimulationDynamics(world, suggestions) {
+  if (!world.rules || world.rules.length === 0) return;
+  if (!world.stateSchema?.variables || Object.keys(world.stateSchema.variables).length === 0) return;
+  try {
+    const result = simulateWorld(world, { steps: 1 });
+    const step = result.steps[0];
+    if (step && step.rulesFired === 0) {
+      suggestions.push({
+        id: "no-rules-fire-default",
+        priority: "high",
+        category: "balance",
+        title: "No rules fire with default state",
+        description: "With all variables at their defaults, zero rules trigger. The world is inert until state changes.",
+        action: "Adjust rule thresholds or state defaults so at least some rules fire in the baseline scenario.",
+        affectedFiles: ["rules/", "state-schema.json"]
+      });
+    }
+    if (result.collapsed && result.collapseStep === 1) {
+      suggestions.push({
+        id: "immediate-collapse",
+        priority: "critical",
+        category: "balance",
+        title: "World collapses on first step",
+        description: `Rule "${result.collapseRule}" triggers collapse immediately with default state. The world cannot sustain itself.`,
+        action: "Adjust collapse thresholds or state defaults to prevent immediate collapse.",
+        affectedFiles: ["rules/", "state-schema.json"]
+      });
+    }
+    if (!result.collapsed) {
+      const multiStep = simulateWorld(world, { steps: 5 });
+      if (multiStep.collapsed) {
+        suggestions.push({
+          id: "eventual-collapse",
+          priority: "high",
+          category: "balance",
+          title: `World collapses by step ${multiStep.collapseStep}`,
+          description: `Starting from defaults, the world collapses after ${multiStep.collapseStep} steps. Consider adding stabilizing advantage rules.`,
+          action: "Add advantage rules or adjust degradation rates to allow sustainable states.",
+          affectedFiles: ["rules/"]
+        });
+      }
+    }
+  } catch {
+  }
+}
+function analyzeCompleteness(world, suggestions) {
+  if (!world.guards) {
+    suggestions.push({
+      id: "add-guards",
+      priority: "low",
+      category: "completeness",
+      title: "No guards defined",
+      description: "Guards enable runtime enforcement in Action Space. Without them, the world has no runtime protection.",
+      action: "Add guards.json with structural guards backing each invariant.",
+      affectedFiles: ["guards.json"]
+    });
+  }
+  if (!world.roles) {
+    suggestions.push({
+      id: "add-roles",
+      priority: "low",
+      category: "completeness",
+      title: "No roles defined",
+      description: "Roles enable multi-agent governance with different permission levels.",
+      action: "Add roles.json with at least an observer and steward role.",
+      affectedFiles: ["roles.json"]
+    });
+  }
+  if (!world.kernel) {
+    suggestions.push({
+      id: "add-kernel",
+      priority: "low",
+      category: "completeness",
+      title: "No kernel configuration",
+      description: "A kernel config provides Thinking Space governance with forbidden patterns and response vocabulary.",
+      action: "Add kernel.json with input/output boundaries.",
+      affectedFiles: ["kernel.json"]
+    });
+  }
+  const outcomes = world.outcomes?.computed_outcomes ?? [];
+  if (outcomes.length > 0 && !outcomes.some((o) => o.primary)) {
+    suggestions.push({
+      id: "no-primary-outcome",
+      priority: "medium",
+      category: "structure",
+      title: "No primary outcome defined",
+      description: "Marking one outcome as primary helps tools identify the main metric to display.",
+      action: "Set primary: true on the most important computed outcome.",
+      affectedFiles: ["outcomes.json"]
+    });
+  }
+}
+function computeHealthScore(world, suggestions) {
+  let score = 100;
+  for (const s of suggestions) {
+    switch (s.priority) {
+      case "critical":
+        score -= 15;
+        break;
+      case "high":
+        score -= 5;
+        break;
+      case "medium":
+        score -= 2;
+        break;
+      case "low":
+        score -= 1;
+        break;
+    }
+  }
+  return Math.max(0, Math.min(100, score));
+}
+function renderImproveText(report) {
+  const lines = [];
+  lines.push(`IMPROVE: ${report.worldName}`);
+  lines.push(`Health Score: ${report.score}/100`);
+  lines.push("");
+  if (report.suggestions.length === 0) {
+    lines.push("No suggestions \u2014 this world is in great shape.");
+    return lines.join("\n");
+  }
+  const groups = [
+    ["CRITICAL (must fix)", "critical", "x"],
+    ["HIGH PRIORITY", "high", "!"],
+    ["SUGGESTIONS", "medium", "-"],
+    ["NICE TO HAVE", "low", "."]
+  ];
+  for (const [header, priority, icon] of groups) {
+    const items = report.suggestions.filter((s) => s.priority === priority);
+    if (items.length === 0) continue;
+    lines.push(header);
+    for (const s of items) {
+      lines.push(`  ${icon} ${s.title}`);
+      lines.push(`    Action: ${s.action}`);
+    }
+    lines.push("");
+  }
+  const { stats } = report;
+  const parts = [];
+  if (stats.critical > 0) parts.push(`${stats.critical} critical`);
+  if (stats.high > 0) parts.push(`${stats.high} high`);
+  if (stats.medium > 0) parts.push(`${stats.medium} medium`);
+  if (stats.low > 0) parts.push(`${stats.low} low`);
+  lines.push(`Total: ${report.suggestions.length} suggestions (${parts.join(", ")})`);
+  return lines.join("\n");
+}
+
+// src/contracts/derive-contract.ts
+var DERIVE_EXIT_CODES = {
+  SUCCESS: 0,
+  VALIDATION_FAIL: 1,
+  INPUT_ERROR: 2,
+  PROVIDER_ERROR: 3
+};
+var CONFIGURE_AI_EXIT_CODES = {
+  SUCCESS: 0,
+  VALIDATION_FAIL: 1,
+  ERROR: 3
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BOOTSTRAP_EXIT_CODES,
+  CONFIGURE_AI_EXIT_CODES,
+  CompositeAuditLogger,
+  ConsoleAuditLogger,
+  DERIVE_EXIT_CODES,
+  FileAuditLogger,
+  GUARD_EXIT_CODES,
+  VALIDATE_EXIT_CODES,
+  createGovernanceEngine,
+  deriveWorld,
+  emitWorldDefinition,
+  evaluateCondition,
+  evaluateGuard,
+  eventToAllowlistKey,
+  explainWorld,
+  extractWorldMarkdown,
+  formatVerdict,
+  formatVerdictOneLine,
+  generateImpactReport,
+  generateImpactReportFromFile,
+  improveWorld,
+  loadWorld,
+  loadWorldFromDirectory,
+  normalizeWorldMarkdown,
+  parseWorldMarkdown,
+  readAuditLog,
+  renderExplainText,
+  renderImpactReport,
+  renderImproveText,
+  renderSimulateText,
+  simulateWorld,
+  summarizeAuditEvents,
+  validateWorld,
+  verdictToAuditEvent
+});