@neuroverseos/governance 0.3.0 → 0.3.1

package/dist/chunk-FYS2CBUW.js

@@ -1,304 +0,0 @@
-// 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((c) => evaluateSingleTrigger(c, 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);
-}
-
-export {
-  simulateWorld,
-  renderSimulateText
-};

package/dist/chunk-GR6DGCZ2.js

@@ -1,340 +0,0 @@
-import {
-  simulateWorld
-} from "./chunk-FYS2CBUW.js";
-import {
-  validateWorld
-} from "./chunk-7P3S7MAY.js";
-
-// 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");
-}
-
-export {
-  improveWorld,
-  renderImproveText
-};

package/dist/chunk-I3RRAYK2.js

@@ -1,11 +0,0 @@
-// src/contracts/validate-contract.ts
-var VALIDATE_EXIT_CODES = {
-  PASS: 0,
-  FAIL: 1,
-  WARN: 2,
-  ERROR: 3
-};
-
-export {
-  VALIDATE_EXIT_CODES
-};