@neuroverseos/governance 0.3.1 → 0.3.4

package/dist/chunk-7P3S7MAY.js

@@ -0,0 +1,1090 @@
+// src/engine/validate-engine.ts
+function validateWorld(world, mode = "standard") {
+  const startTime = performance.now();
+  const findings = [];
+  checkCompleteness(world, findings);
+  checkReferentialIntegrity(world, findings);
+  checkGuardCoverage(world, findings);
+  checkSemanticCoverage(world, findings);
+  checkContradictions(world, findings);
+  checkGuardShadows(world, findings);
+  checkFailClosedSurfaces(world, findings);
+  checkReachability(world, findings);
+  checkStateCoverage(world, findings);
+  checkOrphans(world, findings);
+  checkSchemaViolations(world, findings);
+  const governanceCategories = /* @__PURE__ */ new Set([
+    "guard-coverage",
+    "contradiction",
+    "semantic-tension",
+    "orphan"
+  ]);
+  if (mode === "dev") {
+    for (const f of findings) {
+      if (governanceCategories.has(f.category) && f.severity === "warning") {
+        f.severity = "info";
+      }
+    }
+  } else if (mode === "strict") {
+    for (const f of findings) {
+      if (governanceCategories.has(f.category) && f.severity === "info") {
+        f.severity = "warning";
+      }
+    }
+  }
+  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 governanceHealth = computeGovernanceHealth(world, findings);
+  const summary = {
+    errors,
+    warnings,
+    info,
+    completenessScore,
+    invariantCoverage,
+    canRun: errors === 0,
+    isHealthy: errors === 0 && warnings === 0,
+    governanceHealth
+  };
+  return {
+    worldId: world.world.world_id,
+    worldName: world.world.name,
+    worldVersion: world.world.version,
+    validatedAt: Date.now(),
+    durationMs: performance.now() - startTime,
+    validationMode: mode,
+    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 checkSemanticCoverage(world, findings) {
+  if (!world.invariants || world.invariants.length === 0) return;
+  const hasGuards = (world.guards?.guards?.length ?? 0) > 0;
+  const hasKernel = (world.kernel?.input_boundaries?.forbidden_patterns?.length ?? 0) > 0 || (world.kernel?.output_boundaries?.forbidden_patterns?.length ?? 0) > 0;
+  if (!hasGuards && !hasKernel) return;
+  const guards = world.guards?.guards ?? [];
+  const vocabEntries = world.guards?.intent_vocabulary ?? {};
+  const kernelInput = world.kernel?.input_boundaries?.forbidden_patterns ?? [];
+  const kernelOutput = world.kernel?.output_boundaries?.forbidden_patterns ?? [];
+  const allKernelRules = [...kernelInput, ...kernelOutput];
+  const guardSearchTexts = guards.map((g) => {
+    const parts = [];
+    for (const patternKey of g.intent_patterns) {
+      parts.push(patternKey.toLowerCase());
+      const vocab = vocabEntries[patternKey];
+      if (vocab) {
+        parts.push(vocab.label.toLowerCase());
+        parts.push(vocab.pattern.toLowerCase());
+      }
+    }
+    parts.push(g.description.toLowerCase());
+    return { guard: g, text: parts.join(" ") };
+  });
+  const kernelSearchTexts = allKernelRules.map((k) => ({
+    rule: k,
+    text: `${k.id} ${k.reason} ${k.pattern ?? ""}`.toLowerCase()
+  }));
+  for (const invariant of world.invariants) {
+    if (invariant.enforcement === "prompt") continue;
+    const tokens = extractActionTokens(invariant.id, invariant.label);
+    if (tokens.length === 0) continue;
+    const coveringGuards = guardSearchTexts.filter((gs) => {
+      const enabled = gs.guard.immutable || gs.guard.default_enabled !== false;
+      if (!enabled) return false;
+      return tokens.some((token) => gs.text.includes(token));
+    });
+    const coveringKernel = kernelSearchTexts.filter(
+      (ks) => tokens.some((token) => ks.text.includes(token))
+    );
+    const hasStructuralGuard = guards.some(
+      (g) => g.invariant_ref === invariant.id && g.immutable
+    );
+    if (coveringGuards.length === 0 && coveringKernel.length === 0) {
+      if (hasStructuralGuard) {
+        findings.push(finding(
+          `weak-coverage-${invariant.id}`,
+          `Invariant "${invariant.id}" has a structural guard but no guard's intent patterns match its action class [${tokens.join(", ")}] \u2014 the guard may not intercept violations`,
+          "warning",
+          "guard-coverage",
+          ["invariants.json", "guards.json"],
+          invariant.id,
+          `Ensure the backing guard's intent_patterns include patterns that can detect "${invariant.label}"`
+        ));
+      } else {
+        findings.push(finding(
+          `unenforced-invariant-${invariant.id}`,
+          `Invariant "${invariant.id}" has no guard or kernel rule capable of enforcing it \u2014 no interceptor matches action class [${tokens.join(", ")}]`,
+          "warning",
+          "guard-coverage",
+          ["invariants.json", "guards.json"],
+          invariant.id,
+          `Add a guard with intent_patterns that can intercept "${invariant.label}", or add a kernel forbidden_pattern`
+        ));
+      }
+    }
+  }
+}
+function extractActionTokens(id, label) {
+  const stopWords = /* @__PURE__ */ new Set([
+    "a",
+    "an",
+    "the",
+    "is",
+    "are",
+    "was",
+    "were",
+    "be",
+    "been",
+    "being",
+    "have",
+    "has",
+    "had",
+    "do",
+    "does",
+    "did",
+    "will",
+    "would",
+    "could",
+    "should",
+    "may",
+    "might",
+    "must",
+    "shall",
+    "can",
+    "need",
+    "dare",
+    "to",
+    "of",
+    "in",
+    "for",
+    "on",
+    "with",
+    "at",
+    "by",
+    "from",
+    "as",
+    "into",
+    "through",
+    "during",
+    "before",
+    "after",
+    "above",
+    "below",
+    "between",
+    "out",
+    "off",
+    "over",
+    "under",
+    "again",
+    "further",
+    "then",
+    "once",
+    "that",
+    "than",
+    "too",
+    "very",
+    "just",
+    "only",
+    "not",
+    "no",
+    "all",
+    "any",
+    "both",
+    "each",
+    "every",
+    "few",
+    "more",
+    "most",
+    "other",
+    "some",
+    "such",
+    "and",
+    "but",
+    "or",
+    "nor",
+    "so",
+    "yet",
+    "if",
+    "it",
+    "its",
+    "they",
+    "them",
+    "their",
+    "this",
+    "these",
+    "those",
+    "which",
+    "who",
+    "whom",
+    "what",
+    "where",
+    "when",
+    "how",
+    "why"
+  ]);
+  const idTokens = id.toLowerCase().split(/[_\-]+/);
+  const labelTokens = label.toLowerCase().split(/[\s\-—:,;.!?()[\]{}]+/);
+  const allTokens = [...idTokens, ...labelTokens];
+  const unique = /* @__PURE__ */ new Set();
+  for (const token of allTokens) {
+    const clean = token.replace(/[^a-z0-9]/g, "");
+    if (clean.length >= 3 && !stopWords.has(clean)) {
+      unique.add(clean);
+    }
+  }
+  return [...unique];
+}
+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((c) => c.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((c) => c.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 checkGuardShadows(world, findings) {
+  if (!world.guards?.guards || world.guards.guards.length < 2) return;
+  const guards = world.guards.guards;
+  for (let i = 0; i < guards.length; i++) {
+    const guardA = guards[i];
+    const enabledA = guardA.immutable || guardA.default_enabled !== false;
+    if (!enabledA) continue;
+    if (guardA.enforcement !== "block" && guardA.enforcement !== "pause") continue;
+    for (let j = i + 1; j < guards.length; j++) {
+      const guardB = guards[j];
+      const enabledB = guardB.immutable || guardB.default_enabled !== false;
+      if (!enabledB) continue;
+      const overlap = guardA.intent_patterns.filter(
+        (p) => guardB.intent_patterns.includes(p)
+      );
+      if (overlap.length === 0) continue;
+      if (guardA.appliesTo?.length && guardB.appliesTo?.length) {
+        const toolsA = new Set(guardA.appliesTo.map((t) => t.toLowerCase()));
+        const toolsB = new Set(guardB.appliesTo.map((t) => t.toLowerCase()));
+        const toolOverlap = [...toolsA].some((t) => toolsB.has(t));
+        if (!toolOverlap) continue;
+      }
+      if (guardA.required_roles?.length && guardB.required_roles?.length) {
+        const rolesA = new Set(guardA.required_roles);
+        const rolesB = new Set(guardB.required_roles);
+        const roleOverlap = [...rolesA].some((r) => rolesB.has(r));
+        if (!roleOverlap) continue;
+      }
+      const patternsStr = overlap.join(", ");
+      if (guardB.enforcement === guardA.enforcement) {
+        findings.push(finding(
+          `guard-shadow-${guardA.id}-${guardB.id}`,
+          `Guard "${guardB.label}" (${guardB.id}) is shadowed by "${guardA.label}" (${guardA.id}) \u2014 both ${guardA.enforcement.toUpperCase()} on patterns [${patternsStr}] but "${guardA.label}" appears first and will always win`,
+          "warning",
+          "contradiction",
+          ["guards/"],
+          `${guardA.id}, ${guardB.id}`,
+          `Remove "${guardB.label}", merge its patterns into "${guardA.label}", or reorder guards`
+        ));
+      } else {
+        findings.push(finding(
+          `guard-conflict-${guardA.id}-${guardB.id}`,
+          `Guards "${guardA.label}" (${guardA.enforcement.toUpperCase()}) and "${guardB.label}" (${guardB.enforcement.toUpperCase()}) share patterns [${patternsStr}] \u2014 "${guardA.label}" always wins because it appears first`,
+          "warning",
+          "contradiction",
+          ["guards/"],
+          `${guardA.id}, ${guardB.id}`,
+          `If "${guardB.label}" should take precedence, move it before "${guardA.label}" in guards.json`
+        ));
+      }
+    }
+  }
+}
+function checkFailClosedSurfaces(world, findings) {
+  const declaredSurfaces = world.guards?.tool_surfaces;
+  if (!declaredSurfaces || declaredSurfaces.length === 0) return;
+  const guards = world.guards?.guards ?? [];
+  const guardedSurfaces = /* @__PURE__ */ new Set();
+  let hasCatchAllGuard = false;
+  for (const guard of guards) {
+    const enabled = guard.immutable || guard.default_enabled !== false;
+    if (!enabled) continue;
+    if (!guard.appliesTo || guard.appliesTo.length === 0) {
+      hasCatchAllGuard = true;
+    } else {
+      for (const tool of guard.appliesTo) {
+        guardedSurfaces.add(tool.toLowerCase());
+      }
+    }
+  }
+  if (hasCatchAllGuard) return;
+  for (const surface of declaredSurfaces) {
+    if (!guardedSurfaces.has(surface.toLowerCase())) {
+      findings.push(finding(
+        `fail-open-surface-${surface.toLowerCase()}`,
+        `Action surface "${surface}" has no governing guard \u2014 actions on this surface bypass governance entirely`,
+        "warning",
+        "guard-coverage",
+        ["guards.json"],
+        void 0,
+        `Add a guard with appliesTo including "${surface}", or add a catch-all guard (no appliesTo) to cover all surfaces`
+      ));
+    }
+  }
+}
+function checkReachability(world, findings) {
+  if (!world.stateSchema?.variables) return;
+  const vars = world.stateSchema.variables;
+  for (const rule of world.rules ?? []) {
+    for (const trigger of rule.triggers) {
+      if (trigger.source !== "state") continue;
+      const unreachable = isTriggerUnreachable(trigger, vars);
+      if (unreachable) {
+        findings.push(finding(
+          `unreachable-rule-${rule.id}-${trigger.field}`,
+          `Rule "${rule.id}" has unreachable trigger: ${trigger.field} ${trigger.operator} ${JSON.stringify(trigger.value)} \u2014 ${unreachable}`,
+          "warning",
+          "contradiction",
+          ["rules/", "state-schema.json"],
+          rule.id,
+          `Remove this rule or adjust the trigger condition to match the schema constraints for "${trigger.field}"`
+        ));
+      }
+    }
+    if (rule.collapse_check) {
+      const cc = rule.collapse_check;
+      const unreachable = isTriggerUnreachable(
+        { field: cc.field, operator: cc.operator, value: cc.value },
+        vars
+      );
+      if (unreachable) {
+        findings.push(finding(
+          `unreachable-collapse-${rule.id}`,
+          `Rule "${rule.id}" has unreachable collapse_check: ${cc.field} ${cc.operator} ${cc.value} \u2014 ${unreachable}`,
+          "warning",
+          "contradiction",
+          ["rules/", "state-schema.json"],
+          rule.id
+        ));
+      }
+    }
+  }
+  for (const gate of world.gates?.viability_classification ?? []) {
+    const unreachable = isTriggerUnreachable(
+      { field: gate.field, operator: gate.operator, value: gate.value },
+      vars
+    );
+    if (unreachable) {
+      findings.push(finding(
+        `unreachable-gate-${gate.status}`,
+        `Viability gate "${gate.status}" has unreachable condition: ${gate.field} ${gate.operator} ${gate.value} \u2014 ${unreachable}`,
+        "warning",
+        "contradiction",
+        ["gates.json", "state-schema.json"],
+        `gate-${gate.status}`
+      ));
+    }
+  }
+}
+function isTriggerUnreachable(trigger, vars) {
+  const variable = vars[trigger.field];
+  if (!variable) return null;
+  const { operator, value } = trigger;
+  if (variable.type === "number") {
+    const numVal = typeof value === "number" ? value : Number(value);
+    if (isNaN(numVal)) return null;
+    const min = variable.min;
+    const max = variable.max;
+    if (operator === ">" || operator === ">=") {
+      if (max !== void 0 && numVal >= max && operator === ">") {
+        return `schema declares max=${max}, so ${trigger.field} can never exceed ${max}`;
+      }
+      if (max !== void 0 && numVal > max && operator === ">=") {
+        return `schema declares max=${max}, so ${trigger.field} can never reach ${numVal}`;
+      }
+    }
+    if (operator === "<" || operator === "<=") {
+      if (min !== void 0 && numVal <= min && operator === "<") {
+        return `schema declares min=${min}, so ${trigger.field} can never go below ${min}`;
+      }
+      if (min !== void 0 && numVal < min && operator === "<=") {
+        return `schema declares min=${min}, so ${trigger.field} can never reach ${numVal}`;
+      }
+    }
+    if (operator === "==") {
+      if (min !== void 0 && numVal < min) {
+        return `schema declares min=${min}, so ${trigger.field} can never equal ${numVal}`;
+      }
+      if (max !== void 0 && numVal > max) {
+        return `schema declares max=${max}, so ${trigger.field} can never equal ${numVal}`;
+      }
+    }
+  }
+  if (variable.type === "enum" && variable.options) {
+    if (operator === "==" && typeof value === "string") {
+      if (!variable.options.includes(value)) {
+        return `"${value}" is not in enum options [${variable.options.join(", ")}]`;
+      }
+    }
+    if (operator === "!=" && typeof value === "string") {
+      if (variable.options.length === 1 && variable.options[0] === value) {
+        return `enum has only option "${value}", so != "${value}" can never be true`;
+      }
+    }
+    if (operator === "in" && Array.isArray(value)) {
+      const validValues = value.filter((v) => variable.options.includes(v));
+      if (validValues.length === 0) {
+        return `none of [${value.join(", ")}] are in enum options [${variable.options.join(", ")}]`;
+      }
+    }
+  }
+  if (variable.type === "boolean") {
+    if (operator === "==" && typeof value !== "boolean" && value !== "true" && value !== "false") {
+      return `boolean variable compared to non-boolean value "${value}"`;
+    }
+  }
+  return null;
+}
+function checkStateCoverage(world, findings) {
+  if (!world.stateSchema?.variables) return;
+  const vars = world.stateSchema.variables;
+  for (const [varId, variable] of Object.entries(vars)) {
+    if (variable.type !== "enum" || !variable.options || variable.options.length <= 1) continue;
+    const allOptions = new Set(variable.options);
+    const coveredOptions = /* @__PURE__ */ new Set();
+    for (const rule of world.rules ?? []) {
+      for (const trigger of rule.triggers) {
+        if (trigger.field !== varId || trigger.source !== "state") continue;
+        if (trigger.operator === "==" && typeof trigger.value === "string") {
+          coveredOptions.add(trigger.value);
+        }
+        if (trigger.operator === "in" && Array.isArray(trigger.value)) {
+          for (const v of trigger.value) coveredOptions.add(v);
+        }
+        if (trigger.operator === "!=") {
+          for (const opt of allOptions) {
+            if (opt !== trigger.value) coveredOptions.add(opt);
+          }
+        }
+      }
+    }
+    for (const gate of world.gates?.viability_classification ?? []) {
+      if (gate.field !== varId) continue;
+      if (gate.operator === "==" && typeof gate.value === "string") {
+        coveredOptions.add(gate.value);
+      }
+      if (gate.operator === "in" && Array.isArray(gate.value)) {
+        for (const v of gate.value) coveredOptions.add(v);
+      }
+    }
+    if (coveredOptions.size === 0) continue;
+    const uncovered = [...allOptions].filter((opt) => !coveredOptions.has(opt));
+    if (uncovered.length > 0 && uncovered.length < allOptions.size) {
+      findings.push(finding(
+        `incomplete-state-coverage-${varId}`,
+        `Enum variable "${varId}" has ${uncovered.length} uncovered state${uncovered.length > 1 ? "s" : ""}: [${uncovered.join(", ")}] \u2014 rules/gates handle [${[...coveredOptions].join(", ")}] but not all ${allOptions.size} declared options`,
+        "warning",
+        "guard-coverage",
+        ["state-schema.json", "rules/", "gates.json"],
+        varId,
+        `Add rules or gates that handle ${uncovered.map((u) => `"${u}"`).join(", ")} for variable "${varId}"`
+      ));
+    }
+  }
+}
+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 computeGovernanceHealth(world, findings) {
+  const guards = world.guards?.guards ?? [];
+  if (guards.length === 0 && !world.kernel) return void 0;
+  const declaredSurfaces = world.guards?.tool_surfaces ?? [];
+  const guardedSurfaces = /* @__PURE__ */ new Set();
+  let hasCatchAll = false;
+  for (const guard of guards) {
+    const enabled = guard.immutable || guard.default_enabled !== false;
+    if (!enabled) continue;
+    if (!guard.appliesTo || guard.appliesTo.length === 0) {
+      hasCatchAll = true;
+    } else {
+      for (const t of guard.appliesTo) guardedSurfaces.add(t.toLowerCase());
+    }
+  }
+  const allSurfaces = /* @__PURE__ */ new Set();
+  for (const s of declaredSurfaces) allSurfaces.add(s.toLowerCase());
+  for (const s of guardedSurfaces) allSurfaces.add(s);
+  const surfaces = [...allSurfaces].map((name) => ({
+    name,
+    governed: hasCatchAll || guardedSurfaces.has(name)
+  }));
+  const surfacesCovered = hasCatchAll ? allSurfaces.size : guardedSurfaces.size;
+  const structuralInvariants = (world.invariants ?? []).filter((i) => i.enforcement === "structural");
+  let invariantsEnforced = 0;
+  for (const inv of structuralInvariants) {
+    const hasGuard = guards.some((g) => g.invariant_ref === inv.id && g.immutable);
+    if (hasGuard) invariantsEnforced++;
+  }
+  const shadowedGuards = findings.filter((f) => f.id.startsWith("guard-shadow-")).length;
+  const unenforcedInvariants = findings.filter((f) => f.id.startsWith("unenforced-invariant-")).length;
+  const unreachableRules = findings.filter((f) => f.id.startsWith("unreachable-")).length;
+  const incompleteStateCoverage = findings.filter((f) => f.id.startsWith("incomplete-state-coverage-")).length;
+  const failOpenCount = findings.filter((f) => f.id.startsWith("fail-open-surface-")).length;
+  let riskLevel = "low";
+  const totalIssues = unenforcedInvariants + failOpenCount + incompleteStateCoverage;
+  if (totalIssues > 0 || unreachableRules > 0) riskLevel = "moderate";
+  if (totalIssues > 2 || unenforcedInvariants > 0 && failOpenCount > 0 || incompleteStateCoverage > 2) riskLevel = "high";
+  return {
+    surfacesCovered,
+    surfacesTotal: allSurfaces.size,
+    surfaces,
+    invariantsEnforced,
+    invariantsTotal: structuralInvariants.length,
+    shadowedGuards,
+    unenforcedInvariants,
+    unreachableRules,
+    incompleteStateCoverage,
+    riskLevel
+  };
+}
+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;
+}
+
+export {
+  validateWorld
+};