@neuroverseos/governance 0.5.1 → 0.6.1

package/dist/{chunk-R23T5SZG.js → chunk-B3IIPTY3.js}

@@ -7,7 +7,7 @@ import {
 } from "./chunk-5U2MQO5P.js";
 import {
   loadWorld
-} from "./chunk-EQUAWNXW.js";
+} from "./chunk-I4RTIMLX.js";
 import {
   evaluateGuard
 } from "./chunk-ZAF6JH23.js";

package/dist/chunk-EQR7BGFN.js

@@ -0,0 +1,337 @@
+// src/engine/worldmodel-compiler.ts
+function toSnakeCase(text) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, "");
+}
+function toKebabCase(text) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+function titleCase(text) {
+  return text.split(/[\s_-]+/).map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join(" ");
+}
+function matchSignal(behaviorText, signals) {
+  const lowerText = behaviorText.toLowerCase();
+  for (const signal of signals) {
+    const signalWords = signal.toLowerCase().split("_");
+    if (signalWords.some((w) => w.length > 3 && lowerText.includes(w))) {
+      return signal;
+    }
+  }
+  return "alignment_score";
+}
+function emitWorldMarkdown(model) {
+  const lines = [];
+  const worldId = model.frontmatter.model_id;
+  const worldName = model.frontmatter.name;
+  const version = model.frontmatter.version;
+  lines.push("---");
+  lines.push(`world_id: ${worldId}`);
+  lines.push(`name: ${worldName}`);
+  lines.push(`version: ${version}`);
+  lines.push("runtime_mode: COMPLIANCE");
+  lines.push("default_profile: aligned");
+  lines.push("alternative_profile: drifting");
+  lines.push("---");
+  lines.push("");
+  lines.push("# Thesis");
+  lines.push("");
+  lines.push(model.geometry.mission);
+  if (model.geometry.centerIdentity) {
+    lines.push(
+      `When all domains are aligned, the system operates as: ${model.geometry.centerIdentity}.`
+    );
+  }
+  lines.push("");
+  lines.push("# Invariants");
+  lines.push("");
+  let invariantIdx = 0;
+  for (const domain of model.geometry.domains) {
+    for (const value of domain.values) {
+      invariantIdx++;
+      const invId = `${toSnakeCase(domain.name)}_value_${String(invariantIdx).padStart(2, "0")}`;
+      lines.push(
+        `- \`${invId}\` \u2014 ${value} [${domain.name}] (structural, immutable)`
+      );
+    }
+  }
+  lines.push("");
+  lines.push("# State");
+  lines.push("");
+  lines.push("## alignment_score");
+  lines.push("- type: number");
+  lines.push("- min: 0");
+  lines.push("- max: 100");
+  lines.push("- step: 5");
+  lines.push("- default: 70");
+  lines.push("- label: Alignment Score");
+  lines.push(
+    "- description: Composite behavioral alignment metric derived from all signals"
+  );
+  lines.push("");
+  for (const signal of model.evolution.signals) {
+    const signalId = toSnakeCase(signal);
+    const signalLabel = titleCase(signal);
+    lines.push(`## ${signalId}`);
+    lines.push("- type: number");
+    lines.push("- min: 0");
+    lines.push("- max: 100");
+    lines.push("- step: 5");
+    lines.push("- default: 70");
+    lines.push(`- label: ${signalLabel}`);
+    lines.push(`- description: Behavioral signal measuring ${signal.replace(/_/g, " ")}`);
+    lines.push("");
+  }
+  lines.push("# Assumptions");
+  lines.push("");
+  lines.push("## aligned");
+  lines.push("- name: Aligned");
+  lines.push("- description: All behavioral signals at healthy levels");
+  lines.push("- pressure_level: low");
+  lines.push("");
+  lines.push("## drifting");
+  lines.push("- name: Drifting");
+  lines.push("- description: Behavioral signals under pressure with drift risk");
+  lines.push("- pressure_level: high");
+  lines.push("");
+  lines.push("# Rules");
+  lines.push("");
+  let ruleIdx = 0;
+  for (const drift of model.evolution.driftBehaviors) {
+    ruleIdx++;
+    const ruleId = `rule-${String(ruleIdx).padStart(3, "0")}`;
+    const matchedSignal = matchSignal(drift, model.evolution.signals);
+    const signalId = toSnakeCase(matchedSignal);
+    lines.push(`## ${ruleId}: ${drift} (degradation)`);
+    lines.push(`Drift behavior detected: ${drift}`);
+    lines.push("");
+    lines.push(`When ${signalId} < 50 [state]`);
+    lines.push("Then alignment_score *= 0.80");
+    lines.push("");
+    lines.push(`> trigger: ${signalId} drops below threshold`);
+    lines.push(`> rule: Drift behavior weakens alignment`);
+    lines.push(`> shift: Behavioral alignment decreases`);
+    lines.push(`> effect: Alignment score reduced by 20%`);
+    lines.push("");
+  }
+  for (const aligned of model.evolution.alignedBehaviors) {
+    ruleIdx++;
+    const ruleId = `rule-${String(ruleIdx).padStart(3, "0")}`;
+    const matchedSignal = matchSignal(aligned, model.evolution.signals);
+    const signalId = toSnakeCase(matchedSignal);
+    lines.push(`## ${ruleId}: ${aligned} (advantage)`);
+    lines.push(`Aligned behavior reinforced: ${aligned}`);
+    lines.push("");
+    lines.push(`When ${signalId} >= 70 [state]`);
+    lines.push("Then alignment_score *= 1.10");
+    lines.push("");
+    lines.push(`> trigger: ${signalId} above healthy threshold`);
+    lines.push(`> rule: Aligned behavior strengthens system`);
+    lines.push(`> shift: Behavioral alignment increases`);
+    lines.push(`> effect: Alignment score boosted by 10%`);
+    lines.push("");
+  }
+  for (let i = 0; i < model.evolution.decisionPriorities.length; i++) {
+    ruleIdx++;
+    const priority = model.evolution.decisionPriorities[i];
+    const ruleId = `rule-${String(ruleIdx).padStart(3, "0")}`;
+    lines.push(
+      `## ${ruleId}: ${priority.preferred} over ${priority.over} (structural)`
+    );
+    lines.push(
+      `Priority: ${priority.preferred} takes precedence over ${priority.over} in tradeoff situations.`
+    );
+    lines.push("");
+    lines.push("When alignment_score < 40 [state]");
+    lines.push("Then alignment_score *= 0.70");
+    lines.push("Collapse: alignment_score < 10");
+    lines.push("");
+    lines.push(`> trigger: Alignment score critically low`);
+    lines.push(
+      `> rule: Priority violation \u2014 ${priority.preferred} must outweigh ${priority.over}`
+    );
+    lines.push(`> shift: System enters structural enforcement`);
+    lines.push(`> effect: Alignment sharply reduced; collapse if critical`);
+    lines.push("");
+  }
+  lines.push("# Gates");
+  lines.push("");
+  lines.push("- STRONG: alignment_score >= 85");
+  lines.push("- STABLE: alignment_score >= 65");
+  lines.push("- WATCHING: alignment_score >= 45");
+  lines.push("- FRAGILE: alignment_score > 30");
+  lines.push("- MISALIGNED: alignment_score <= 30");
+  lines.push("");
+  lines.push("# Outcomes");
+  lines.push("");
+  lines.push("## alignment_score");
+  lines.push("- type: number");
+  lines.push("- range: 0-100");
+  lines.push("- display: percentage");
+  lines.push("- label: Alignment Score");
+  lines.push("- primary: true");
+  lines.push("");
+  for (const signal of model.evolution.signals) {
+    const signalId = toSnakeCase(signal);
+    const signalLabel = titleCase(signal);
+    lines.push(`## ${signalId}`);
+    lines.push("- type: number");
+    lines.push("- range: 0-100");
+    lines.push("- display: percentage");
+    lines.push(`- label: ${signalLabel}`);
+    lines.push("");
+  }
+  const lensSuggestions = buildLensSuggestions(model);
+  if (lensSuggestions.length > 0) {
+    lines.push("# Lenses");
+    lines.push("- policy: role_default");
+    lines.push("");
+    for (const lens of lensSuggestions) {
+      lines.push(`## ${lens.id}`);
+      lines.push(`- tagline: ${lens.tagline}`);
+      lines.push(
+        `- description: Lens derived from ${lens.derived_from.domainA} and ${lens.derived_from.domainB} interaction, producing ${lens.derived_from.effect}.`
+      );
+      lines.push(`- formality: ${lens.tone.formality}`);
+      lines.push(`- verbosity: ${lens.tone.verbosity}`);
+      lines.push(`- emotion: ${lens.tone.emotion}`);
+      lines.push(`- confidence: ${lens.tone.confidence}`);
+      lines.push("- tags: behavioral, worldmodel, overlap");
+      lines.push("- default_for_roles: all");
+      lines.push("- priority: 50");
+      lines.push("- stackable: true");
+      lines.push("");
+      for (const directive of lens.directives) {
+        lines.push(`> ${directive.scope}: ${directive.instruction}`);
+      }
+      lines.push("");
+    }
+  }
+  return lines.join("\n");
+}
+function emitSignalSchema(model) {
+  const signals = model.evolution.signals.map((signal) => ({
+    id: toSnakeCase(signal),
+    name: titleCase(signal),
+    type: "number",
+    default: 70
+  }));
+  return {
+    model_id: model.frontmatter.model_id,
+    signals
+  };
+}
+function emitOverlapMap(model) {
+  const pairings = model.geometry.overlapEffects.map((o) => ({
+    domainA: o.domainA,
+    domainB: o.domainB,
+    effect: o.effect
+  }));
+  const matrix = {};
+  for (const overlap of model.geometry.overlapEffects) {
+    const keyA = toKebabCase(overlap.domainA);
+    const keyB = toKebabCase(overlap.domainB);
+    if (!matrix[keyA]) matrix[keyA] = {};
+    matrix[keyA][keyB] = overlap.effect;
+  }
+  return {
+    model_id: model.frontmatter.model_id,
+    pairings,
+    matrix
+  };
+}
+function emitContextsConfig(model) {
+  return {
+    model_id: model.frontmatter.model_id,
+    authority_layers: model.modifiers.authorityLayers,
+    spatial_contexts: model.modifiers.spatialContexts,
+    interpretation_rules: model.modifiers.interpretationRules
+  };
+}
+function deriveTone(domainA, domainB) {
+  const combined = `${domainA} ${domainB}`.toLowerCase();
+  let formality = "neutral";
+  if (/strateg|technic|analytic|research|engineer/.test(combined)) {
+    formality = "professional";
+  } else if (/narrat|story|communi|creative/.test(combined)) {
+    formality = "casual";
+  }
+  let verbosity = "balanced";
+  if (/foresight|scenario|plan|design/.test(combined)) {
+    verbosity = "detailed";
+  } else if (/prosper|negotiat|stakeholder/.test(combined)) {
+    verbosity = "concise";
+  }
+  let emotion = "neutral";
+  if (/empath|emoti|care|safe|trust/.test(combined)) {
+    emotion = "warm";
+  } else if (/analytic|system|data/.test(combined)) {
+    emotion = "clinical";
+  }
+  let confidence = "balanced";
+  if (/lead|command|decis|strateg/.test(combined)) {
+    confidence = "authoritative";
+  } else if (/explor|experiment|creat/.test(combined)) {
+    confidence = "exploratory";
+  }
+  return { formality, verbosity, emotion, confidence };
+}
+function buildLensSuggestions(model) {
+  const lenses = [];
+  const domainMap = new Map(model.geometry.domains.map((d) => [d.name.toLowerCase(), d]));
+  for (const overlap of model.geometry.overlapEffects) {
+    const lensId = toKebabCase(overlap.effect);
+    const tone = deriveTone(overlap.domainA, overlap.domainB);
+    const domainAData = domainMap.get(overlap.domainA.toLowerCase());
+    const domainBData = domainMap.get(overlap.domainB.toLowerCase());
+    const directives = [];
+    if (domainAData && domainAData.skills.length > 0) {
+      directives.push({
+        scope: "response_framing",
+        instruction: `Approach through the lens of ${domainAData.skills.join(", ").toLowerCase()}.`
+      });
+    }
+    if (domainBData && domainBData.values.length > 0) {
+      directives.push({
+        scope: "behavior_shaping",
+        instruction: `Maintain ${domainBData.values.join(", ").toLowerCase()} in all responses.`
+      });
+    }
+    directives.push({
+      scope: "value_emphasis",
+      instruction: `Emphasize ${overlap.effect.toLowerCase()} as the emergent state of aligned behavior.`
+    });
+    lenses.push({
+      id: lensId,
+      name: titleCase(overlap.effect),
+      tagline: `${overlap.effect} through ${overlap.domainA} and ${overlap.domainB}.`,
+      derived_from: {
+        domainA: overlap.domainA,
+        domainB: overlap.domainB,
+        effect: overlap.effect
+      },
+      tone,
+      directives
+    });
+  }
+  return lenses;
+}
+function emitLensSuggestions(model) {
+  return buildLensSuggestions(model);
+}
+function compileWorldModel(model) {
+  return {
+    worldMarkdown: emitWorldMarkdown(model),
+    signalSchema: emitSignalSchema(model),
+    overlapMap: emitOverlapMap(model),
+    contextsConfig: emitContextsConfig(model),
+    lensSuggestions: emitLensSuggestions(model)
+  };
+}
+
+export {
+  emitWorldMarkdown,
+  emitSignalSchema,
+  emitOverlapMap,
+  emitContextsConfig,
+  emitLensSuggestions,
+  compileWorldModel
+};

package/dist/{chunk-LAKUB76X.js → chunk-FDPPZLSQ.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-AKW5YVCE.js";
 import {
   loadWorld
-} from "./chunk-EQUAWNXW.js";
+} from "./chunk-I4RTIMLX.js";
 import {
   evaluateGuard
 } from "./chunk-ZAF6JH23.js";

package/dist/{chunk-UZBW44KD.js → chunk-FKQCPRKI.js}

@@ -6,7 +6,7 @@ import {
 } from "./chunk-5U2MQO5P.js";
 import {
   loadWorld
-} from "./chunk-EQUAWNXW.js";
+} from "./chunk-I4RTIMLX.js";
 import {
   evaluateGuard
 } from "./chunk-ZAF6JH23.js";

package/dist/{chunk-XPMZB46F.js → chunk-FS2UUJJO.js}

@@ -35,7 +35,7 @@ async function addGuard(worldDir, input) {
   };
   config.guards.push(guard);
   await writeFile(guardsPath, JSON.stringify(config, null, 2) + "\n");
-  const { loadWorldFromDirectory } = await import("./world-loader-J47PCPDZ.js");
+  const { loadWorldFromDirectory } = await import("./world-loader-YTYFOP7D.js");
   const world = await loadWorldFromDirectory(worldDir);
   const report = validateWorld(world);
   return {
@@ -83,7 +83,7 @@ async function addRule(worldDir, input) {
   };
   const rulePath = join(rulesDir, `rule-${ruleNum}.json`);
   await writeFile(rulePath, JSON.stringify(rule, null, 2) + "\n");
-  const { loadWorldFromDirectory } = await import("./world-loader-J47PCPDZ.js");
+  const { loadWorldFromDirectory } = await import("./world-loader-YTYFOP7D.js");
   const world = await loadWorldFromDirectory(worldDir);
   const report = validateWorld(world);
   return {
@@ -118,7 +118,7 @@ async function addInvariant(worldDir, input) {
   };
   config.invariants.push(invariant);
   await writeFile(invariantsPath, JSON.stringify(config, null, 2) + "\n");
-  const { loadWorldFromDirectory } = await import("./world-loader-J47PCPDZ.js");
+  const { loadWorldFromDirectory } = await import("./world-loader-YTYFOP7D.js");
   const world = await loadWorldFromDirectory(worldDir);
   const report = validateWorld(world);
   return {

package/dist/{chunk-6UPEUMJ2.js → chunk-HDNDL6D5.js}

@@ -1,6 +1,6 @@
 import {
   loadWorld
-} from "./chunk-EQUAWNXW.js";
+} from "./chunk-I4RTIMLX.js";
 import {
   evaluateGuard
 } from "./chunk-ZAF6JH23.js";

package/dist/{chunk-7UU7V3AD.js → chunk-IOVXB6QN.js}

@@ -9,7 +9,7 @@ import {
 } from "./chunk-5U2MQO5P.js";
 import {
   loadWorld
-} from "./chunk-EQUAWNXW.js";
+} from "./chunk-I4RTIMLX.js";
 import {
   evaluateGuard
 } from "./chunk-ZAF6JH23.js";

package/dist/{chunk-EK77AJAH.js → chunk-OTZU76DH.js}

@@ -6,7 +6,7 @@ import {
 } from "./chunk-D2UCV5AK.js";
 import {
   loadWorld
-} from "./chunk-EQUAWNXW.js";
+} from "./chunk-I4RTIMLX.js";
 import {
   evaluateGuard
 } from "./chunk-ZAF6JH23.js";

package/dist/{chunk-5RAQ5DZW.js → chunk-T6GMRZWC.js}

@@ -6,7 +6,7 @@ import {
 } from "./chunk-5U2MQO5P.js";
 import {
   loadWorld
-} from "./chunk-EQUAWNXW.js";
+} from "./chunk-I4RTIMLX.js";
 import {
   evaluateGuard
 } from "./chunk-ZAF6JH23.js";

package/dist/{chunk-RF2L5SYG.js → chunk-TIXVEPS2.js}

@@ -6,7 +6,7 @@ import {
 } from "./chunk-5U2MQO5P.js";
 import {
   loadWorld
-} from "./chunk-EQUAWNXW.js";
+} from "./chunk-I4RTIMLX.js";
 import {
   evaluateGuard
 } from "./chunk-ZAF6JH23.js";

package/dist/{chunk-TL4DLMMW.js → chunk-TJ5L2UTE.js}

@@ -1,6 +1,6 @@
 import {
   loadWorldFromDirectory
-} from "./chunk-EQUAWNXW.js";
+} from "./chunk-I4RTIMLX.js";
 import {
   evaluateGuard
 } from "./chunk-ZAF6JH23.js";