@neuroverseos/governance 0.5.1 → 0.6.0

package/dist/{demo-N5K4VXJW.js → demo-6W3YXLAX.js}

@@ -6,7 +6,7 @@ import {
   handleListPresets,
   handleReasonRequest,
   writeTempWorld
-} from "./chunk-TZBERHFM.js";
+} from "./chunk-7FL3U7Z5.js";
 import {
   adaptationFromVerdict,
   detectBehavioralPatterns,
@@ -19,7 +19,7 @@ import {
   DEFAULT_BUNDLED_WORLD,
   loadBundledWorld,
   loadWorld
-} from "./chunk-EQUAWNXW.js";
+} from "./chunk-I4RTIMLX.js";
 import "./chunk-ZAF6JH23.js";
 import "./chunk-QLPTHTVB.js";
 import {

package/dist/{derive-5LOMN7GO.js → derive-42IJW7JI.js}

@@ -2,15 +2,15 @@ import {
   DeriveInputError,
   DeriveProviderError,
   deriveWorld
-} from "./chunk-QZ666FCV.js";
+} from "./chunk-735Z3HA4.js";
 import {
   DERIVE_EXIT_CODES
 } from "./chunk-FMSTRBBS.js";
 import "./chunk-OT6PXH54.js";
 import "./chunk-INWQHLPS.js";
 import "./chunk-7P3S7MAY.js";
-import "./chunk-3NZMMSOW.js";
 import "./chunk-YPCVY4GS.js";
+import "./chunk-3NZMMSOW.js";
 import "./chunk-QWGCMQQD.js";
 
 // src/cli/derive.ts
@@ -121,7 +121,7 @@ Normalization: ${n.fixCount} fix(es) applied
       process.stderr.write(`
 Bootstrapping to ${args.bootstrapDir}...
 `);
-      const { main: bootstrapMain } = await import("./bootstrap-IP5QMC3Q.js");
+      const { main: bootstrapMain } = await import("./bootstrap-2OW5ZLBL.js");
       await bootstrapMain([
         "--input",
         result.outputPath,

package/dist/engine/worldmodel-compiler.cjs

@@ -0,0 +1,366 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/engine/worldmodel-compiler.ts
+var worldmodel_compiler_exports = {};
+__export(worldmodel_compiler_exports, {
+  compileWorldModel: () => compileWorldModel,
+  emitContextsConfig: () => emitContextsConfig,
+  emitLensSuggestions: () => emitLensSuggestions,
+  emitOverlapMap: () => emitOverlapMap,
+  emitSignalSchema: () => emitSignalSchema,
+  emitWorldMarkdown: () => emitWorldMarkdown
+});
+module.exports = __toCommonJS(worldmodel_compiler_exports);
+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)
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  compileWorldModel,
+  emitContextsConfig,
+  emitLensSuggestions,
+  emitOverlapMap,
+  emitSignalSchema,
+  emitWorldMarkdown
+});

package/dist/engine/worldmodel-compiler.d.cts

@@ -0,0 +1,46 @@
+import { P as ParsedWorldModel, W as WorldModelOutput, C as ContextsConfig, L as LensSuggestion, O as OverlapMap, S as SignalSchema } from '../worldmodel-contract-BPGhiuW5.cjs';
+
+/**
+ * WorldModel Compiler — ParsedWorldModel → .nv-world.md + Artifacts
+ *
+ * Deterministic compiler that transforms a three-layer behavioral model
+ * into executable NeuroVerse governance artifacts.
+ *
+ * Layer Mapping:
+ *   Core Model Geometry   → thesis, invariants, lenses, overlaps.json
+ *   Contextual Modifiers  → contexts.json
+ *   Evolution Layer        → state, rules, gates, outcomes, signals.json
+ *
+ * The generated .nv-world.md is valid for bootstrap-parser.ts (round-trip safe).
+ */
+
+/**
+ * Compile ParsedWorldModel into a valid .nv-world.md string.
+ *
+ * The output is designed to parse cleanly through bootstrap-parser.ts.
+ */
+declare function emitWorldMarkdown(model: ParsedWorldModel): string;
+/**
+ * Emit the signal schema as a structured JSON-serializable object.
+ */
+declare function emitSignalSchema(model: ParsedWorldModel): SignalSchema;
+/**
+ * Emit the overlap map as a structured JSON-serializable object.
+ */
+declare function emitOverlapMap(model: ParsedWorldModel): OverlapMap;
+/**
+ * Emit the contextual modifiers as a structured JSON-serializable object.
+ */
+declare function emitContextsConfig(model: ParsedWorldModel): ContextsConfig;
+/**
+ * Emit lens suggestions as a structured JSON-serializable array.
+ */
+declare function emitLensSuggestions(model: ParsedWorldModel): LensSuggestion[];
+/**
+ * Compile a ParsedWorldModel into all output artifacts.
+ *
+ * Deterministic. Same input → same output. No LLM calls.
+ */
+declare function compileWorldModel(model: ParsedWorldModel): WorldModelOutput;
+
+export { compileWorldModel, emitContextsConfig, emitLensSuggestions, emitOverlapMap, emitSignalSchema, emitWorldMarkdown };

package/dist/engine/worldmodel-compiler.d.ts

@@ -0,0 +1,46 @@
+import { P as ParsedWorldModel, W as WorldModelOutput, C as ContextsConfig, L as LensSuggestion, O as OverlapMap, S as SignalSchema } from '../worldmodel-contract-BPGhiuW5.js';
+
+/**
+ * WorldModel Compiler — ParsedWorldModel → .nv-world.md + Artifacts
+ *
+ * Deterministic compiler that transforms a three-layer behavioral model
+ * into executable NeuroVerse governance artifacts.
+ *
+ * Layer Mapping:
+ *   Core Model Geometry   → thesis, invariants, lenses, overlaps.json
+ *   Contextual Modifiers  → contexts.json
+ *   Evolution Layer        → state, rules, gates, outcomes, signals.json
+ *
+ * The generated .nv-world.md is valid for bootstrap-parser.ts (round-trip safe).
+ */
+
+/**
+ * Compile ParsedWorldModel into a valid .nv-world.md string.
+ *
+ * The output is designed to parse cleanly through bootstrap-parser.ts.
+ */
+declare function emitWorldMarkdown(model: ParsedWorldModel): string;
+/**
+ * Emit the signal schema as a structured JSON-serializable object.
+ */
+declare function emitSignalSchema(model: ParsedWorldModel): SignalSchema;
+/**
+ * Emit the overlap map as a structured JSON-serializable object.
+ */
+declare function emitOverlapMap(model: ParsedWorldModel): OverlapMap;
+/**
+ * Emit the contextual modifiers as a structured JSON-serializable object.
+ */
+declare function emitContextsConfig(model: ParsedWorldModel): ContextsConfig;
+/**
+ * Emit lens suggestions as a structured JSON-serializable array.
+ */
+declare function emitLensSuggestions(model: ParsedWorldModel): LensSuggestion[];
+/**
+ * Compile a ParsedWorldModel into all output artifacts.
+ *
+ * Deterministic. Same input → same output. No LLM calls.
+ */
+declare function compileWorldModel(model: ParsedWorldModel): WorldModelOutput;
+
+export { compileWorldModel, emitContextsConfig, emitLensSuggestions, emitOverlapMap, emitSignalSchema, emitWorldMarkdown };

package/dist/engine/worldmodel-compiler.js

@@ -0,0 +1,17 @@
+import {
+  compileWorldModel,
+  emitContextsConfig,
+  emitLensSuggestions,
+  emitOverlapMap,
+  emitSignalSchema,
+  emitWorldMarkdown
+} from "../chunk-EQR7BGFN.js";
+import "../chunk-QWGCMQQD.js";
+export {
+  compileWorldModel,
+  emitContextsConfig,
+  emitLensSuggestions,
+  emitOverlapMap,
+  emitSignalSchema,
+  emitWorldMarkdown
+};