@neuroverseos/governance 0.4.0 → 0.4.1

package/dist/cli/neuroverse.js

@@ -100,23 +100,23 @@ async function main() {
   const subArgs = args.slice(1);
   switch (command) {
     case "add": {
-      const { main: addMain } = await import("../add-LYHDZ5RL.js");
+      const { main: addMain } = await import("../add-XSANI3FK.js");
       return addMain(subArgs);
     }
     case "build": {
-      const { main: buildMain } = await import("../build-THUEYMVT.js");
+      const { main: buildMain } = await import("../build-EGBGZFIJ.js");
       return buildMain(subArgs);
     }
     case "explain": {
-      const { main: explainMain } = await import("../explain-MUSGDT67.js");
+      const { main: explainMain } = await import("../explain-HDFN4ION.js");
       return explainMain(subArgs);
     }
     case "simulate": {
-      const { main: simulateMain } = await import("../simulate-FGXKIH7V.js");
+      const { main: simulateMain } = await import("../simulate-VT437EEL.js");
       return simulateMain(subArgs);
     }
     case "improve": {
-      const { main: improveMain } = await import("../improve-PJDAWW4Q.js");
+      const { main: improveMain } = await import("../improve-2PWGGO5B.js");
       return improveMain(subArgs);
     }
     case "init": {
@@ -132,35 +132,35 @@ async function main() {
       return inferWorldMain(subArgs);
     }
     case "bootstrap": {
-      const { main: bootstrapMain } = await import("../bootstrap-IP5QMC3Q.js");
+      const { main: bootstrapMain } = await import("../bootstrap-2OW5ZLBL.js");
       return bootstrapMain(subArgs);
     }
     case "validate": {
-      const { main: validateMain } = await import("../validate-Q5O5TGLT.js");
+      const { main: validateMain } = await import("../validate-M52DX22Y.js");
       return validateMain(subArgs);
     }
     case "guard": {
-      const { main: guardMain } = await import("../guard-W3BMQPBJ.js");
+      const { main: guardMain } = await import("../guard-6KSCWT2W.js");
       return guardMain(subArgs);
     }
     case "test": {
-      const { main: testMain } = await import("../test-PT44BSYG.js");
+      const { main: testMain } = await import("../test-4WTX6RKQ.js");
       return testMain(subArgs);
     }
     case "redteam": {
-      const { main: redteamMain } = await import("../redteam-BRZALBPP.js");
+      const { main: redteamMain } = await import("../redteam-HV6LMKEH.js");
       return redteamMain(subArgs);
     }
     case "demo": {
-      const { main: demoMain } = await import("../demo-66MMJTEH.js");
+      const { main: demoMain } = await import("../demo-6OQYWRR6.js");
       return demoMain(subArgs);
     }
     case "doctor": {
-      const { main: doctorMain } = await import("../doctor-WIO4FLA3.js");
+      const { main: doctorMain } = await import("../doctor-NHXI7OQW.js");
       return doctorMain(subArgs);
     }
     case "playground": {
-      const { main: playgroundMain } = await import("../playground-4BK2XQ47.js");
+      const { main: playgroundMain } = await import("../playground-3FLDGBET.js");
       return playgroundMain(subArgs);
     }
     case "plan": {
@@ -172,11 +172,11 @@ async function main() {
       return runMain(subArgs);
     }
     case "mcp": {
-      const { startMcpServer } = await import("../mcp-server-OG3PPVD2.js");
+      const { startMcpServer } = await import("../mcp-server-TNIWZ7B5.js");
       return startMcpServer(subArgs);
     }
     case "worlds": {
-      const { main: worldMain } = await import("../world-V52ZMH26.js");
+      const { main: worldMain } = await import("../world-O4HTQPDP.js");
       return worldMain(["list", ...subArgs]);
     }
     case "trace": {
@@ -188,15 +188,15 @@ async function main() {
       return impactMain(subArgs);
     }
     case "behavioral": {
-      const { main: behavioralMain } = await import("../behavioral-SPWPGYXL.js");
+      const { main: behavioralMain } = await import("../behavioral-SLW7ALEK.js");
       return behavioralMain(subArgs);
     }
     case "world": {
-      const { main: worldMain } = await import("../world-V52ZMH26.js");
+      const { main: worldMain } = await import("../world-O4HTQPDP.js");
       return worldMain(subArgs);
     }
     case "derive": {
-      const { main: deriveMain } = await import("../derive-5LOMN7GO.js");
+      const { main: deriveMain } = await import("../derive-7Y7YWVLU.js");
       return deriveMain(subArgs);
     }
     case "decision-flow": {
@@ -204,11 +204,11 @@ async function main() {
       return decisionFlowMain(subArgs);
     }
     case "equity-penalties": {
-      const { main: equityPenaltiesMain } = await import("../equity-penalties-WWC7UDQD.js");
+      const { main: equityPenaltiesMain } = await import("../equity-penalties-NVBAB5WL.js");
       return equityPenaltiesMain(subArgs);
     }
     case "configure-ai": {
-      const { main: configureAiMain } = await import("../configure-ai-5MP5DWTT.js");
+      const { main: configureAiMain } = await import("../configure-ai-LL3VAPQW.js");
       return configureAiMain(subArgs);
     }
     case "configure-world": {
@@ -216,7 +216,7 @@ async function main() {
       return configureWorldMain(subArgs);
     }
     case "lens": {
-      const { main: lensMain } = await import("../lens-IP6GIZ2Q.js");
+      const { main: lensMain } = await import("../lens-MHMUDCMQ.js");
       return lensMain(subArgs);
     }
     case "--help":

package/dist/cli/plan.js

@@ -100,8 +100,8 @@ async function checkCommand(args) {
   }
   const worldPath = parseArg(args, "--world");
   if (worldPath) {
-    const { loadWorld } = await import("../world-loader-C4D3VPP3.js");
-    const { evaluateGuard } = await import("../guard-engine-N7TUIUU7.js");
+    const { loadWorld } = await import("../world-loader-YTYFOP7D.js");
+    const { evaluateGuard } = await import("../engine/guard-engine.js");
     const world = await loadWorld(worldPath);
     const verdict2 = evaluateGuard(event, world, { plan });
     process.stdout.write(JSON.stringify(verdict2, null, 2) + "\n");

package/dist/cli/run.js

@@ -92,7 +92,7 @@ async function main(args) {
       return;
     }
     const { resolveProvider, ModelAdapter } = await import("../model-adapter-VXEKB4LS.js");
-    const { runInteractiveMode } = await import("../session-SGRUT2UH.js");
+    const { runInteractiveMode } = await import("../session-XZP2754M.js");
     const modelConfig = resolveProvider(providerName, {
       model: parseArg(args, "--model"),
       apiKey: parseArg(args, "--api-key")
@@ -126,7 +126,7 @@ async function main(args) {
       model
     );
   } else if (isPipeMode) {
-    const { runPipeMode } = await import("../session-SGRUT2UH.js");
+    const { runPipeMode } = await import("../session-XZP2754M.js");
     await runPipeMode({
       worldPath,
       plan,

package/dist/{demo-66MMJTEH.js → demo-6OQYWRR6.js}

@@ -6,7 +6,7 @@ import {
   handleListPresets,
   handleReasonRequest,
   writeTempWorld
-} from "./chunk-JKGPSFGH.js";
+} from "./chunk-AV7XJJWK.js";
 import {
   adaptationFromVerdict,
   detectBehavioralPatterns,
@@ -16,12 +16,12 @@ import {
   resolveWorldPath
 } from "./chunk-AKW5YVCE.js";
 import "./chunk-ZAF6JH23.js";
-import "./chunk-QLPTHTVB.js";
 import {
   DEFAULT_BUNDLED_WORLD,
   loadBundledWorld,
   loadWorld
-} from "./chunk-BXLTEUS4.js";
+} from "./chunk-I4RTIMLX.js";
+import "./chunk-QLPTHTVB.js";
 import {
   __require
 } from "./chunk-QWGCMQQD.js";

package/dist/{derive-5LOMN7GO.js → derive-7Y7YWVLU.js}

@@ -2,15 +2,15 @@ import {
   DeriveInputError,
   DeriveProviderError,
   deriveWorld
-} from "./chunk-QZ666FCV.js";
+} from "./chunk-FHXXD2TI.js";
 import {
   DERIVE_EXIT_CODES
 } from "./chunk-FMSTRBBS.js";
-import "./chunk-OT6PXH54.js";
 import "./chunk-INWQHLPS.js";
+import "./chunk-OT6PXH54.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/{doctor-WIO4FLA3.js → doctor-NHXI7OQW.js}

@@ -10,9 +10,10 @@ var globImport_adapters = __glob({
   "../adapters/autoresearch.ts": () => import("./adapters/autoresearch.js"),
   "../adapters/deep-agents.ts": () => import("./adapters/deep-agents.js"),
   "../adapters/express.ts": () => import("./adapters/express.js"),
+  "../adapters/github.ts": () => import("./github-TIKTWOGU.js"),
   "../adapters/index.ts": () => import("./adapters/index.js"),
   "../adapters/langchain.ts": () => import("./adapters/langchain.js"),
-  "../adapters/mentraos.ts": () => import("./mentraos-YFS7FMJH.js"),
+  "../adapters/mentraos.ts": () => import("./adapters/mentraos.js"),
   "../adapters/openai.ts": () => import("./adapters/openai.js"),
   "../adapters/openclaw.ts": () => import("./adapters/openclaw.js"),
   "../adapters/shared.ts": () => import("./shared-7RLUHNMU.js")
@@ -104,7 +105,7 @@ async function main(argv) {
     });
   }
   try {
-    const { evaluateGuard } = await import("./guard-engine-N7TUIUU7.js");
+    const { evaluateGuard } = await import("./engine/guard-engine.js");
     checks.push({
       label: "Guard engine",
       status: typeof evaluateGuard === "function" ? "pass" : "fail",

package/dist/engine/bootstrap-emitter.cjs

@@ -0,0 +1,241 @@
+"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/bootstrap-emitter.ts
+var bootstrap_emitter_exports = {};
+__export(bootstrap_emitter_exports, {
+  emitWorldDefinition: () => emitWorldDefinition
+});
+module.exports = __toCommonJS(bootstrap_emitter_exports);
+var GATE_DEFAULTS = {
+  THRIVING: { color: "#0f6b3a", icon: "\u2726" },
+  STABLE: { color: "#1856b8", icon: "\u25CF" },
+  COMPRESSED: { color: "#a16207", icon: "\u25B2" },
+  CRITICAL: { color: "#b91c1c", icon: "\u26A0" },
+  MODEL_COLLAPSES: { color: "#7f1d1d", icon: "\u2715" }
+};
+function emitWorldDefinition(parsed) {
+  const issues = [];
+  const fm = parsed.frontmatter;
+  const defaultProfile = fm.default_profile ?? parsed.assumptions[0]?.id ?? "baseline";
+  const altProfile = fm.alternative_profile ?? parsed.assumptions[1]?.id ?? "alternative";
+  const world = {
+    world_id: fm.world_id,
+    name: fm.name,
+    thesis: parsed.thesis,
+    version: fm.version ?? "1.0.0",
+    runtime_mode: fm.runtime_mode ?? "SIMULATION",
+    default_assumption_profile: defaultProfile,
+    default_alternative_profile: altProfile,
+    modules: parsed.rules.map((r) => r.id),
+    players: {
+      thinking_space: true,
+      experience_space: true,
+      action_space: true
+    }
+  };
+  const invariants = parsed.invariants.map((inv) => ({
+    id: inv.id,
+    label: inv.label,
+    enforcement: inv.enforcement === "prompt" ? "prompt" : "structural",
+    mutable: false
+  }));
+  const profiles = {};
+  const parameterDefinitions = {};
+  for (let i = 0; i < parsed.assumptions.length; i++) {
+    const profile = parsed.assumptions[i];
+    const params = {};
+    for (const [key, val] of Object.entries(profile.parameters)) {
+      params[key] = String(val);
+      if (!parameterDefinitions[key]) {
+        parameterDefinitions[key] = {
+          type: typeof val === "boolean" ? "boolean" : typeof val === "number" ? "number" : "enum",
+          label: key.replace(/_/g, " ").replace(/\b\w/g, (c) => c.toUpperCase()),
+          description: `Parameter: ${key}`
+        };
+      }
+    }
+    profiles[profile.id] = {
+      name: profile.name,
+      description: profile.description,
+      is_default_baseline: i === 0 || profile.id === defaultProfile,
+      is_default_alternative: i === 1 || profile.id === altProfile,
+      parameters: params
+    };
+  }
+  const assumptions = { profiles, parameter_definitions: parameterDefinitions };
+  const variables = {};
+  for (const v of parsed.stateVariables) {
+    const stateVar = {
+      type: v.type,
+      default: v.default,
+      mutable: true,
+      label: v.label,
+      description: v.description
+    };
+    if (v.type === "number") {
+      if (v.min !== void 0) stateVar.min = v.min;
+      if (v.max !== void 0) stateVar.max = v.max;
+      if (v.step !== void 0) stateVar.step = v.step;
+    }
+    if (v.type === "enum" && v.options) {
+      stateVar.options = v.options;
+    }
+    variables[v.id] = stateVar;
+  }
+  const stateSchema = { variables, presets: {} };
+  const rules = parsed.rules.map((r) => {
+    const triggers = r.triggers.map((t) => ({
+      field: t.field,
+      operator: t.operator,
+      value: t.value,
+      source: t.source
+    }));
+    const effects = r.effects.map((e) => ({
+      target: e.target,
+      operation: e.operation,
+      value: e.value
+    }));
+    let collapse_check;
+    if (r.collapse_check) {
+      collapse_check = {
+        field: r.collapse_check.field,
+        operator: r.collapse_check.operator,
+        value: r.collapse_check.value,
+        result: "MODEL_COLLAPSES"
+      };
+    }
+    const causal_translation = r.causal_translation ?? {
+      trigger_text: "",
+      rule_text: "",
+      shift_text: "",
+      effect_text: ""
+    };
+    const rule = {
+      id: r.id,
+      severity: r.severity,
+      label: r.label,
+      description: r.description ?? r.label,
+      order: r.order,
+      triggers,
+      effects: effects.length > 0 ? effects : void 0,
+      collapse_check,
+      causal_translation
+    };
+    return rule;
+  });
+  const viabilityClassification = parsed.gates.map((g) => {
+    const defaults = GATE_DEFAULTS[g.status] ?? { color: "#5c5a52", icon: "\u25CF" };
+    return {
+      status: g.status,
+      field: g.field,
+      operator: g.operator,
+      value: g.value,
+      color: defaults.color,
+      icon: defaults.icon
+    };
+  });
+  const gates = {
+    viability_classification: viabilityClassification,
+    structural_override: {
+      description: "Rules with severity=structural and triggered collapse_check force MODEL_COLLAPSES regardless of final margin.",
+      enforcement: "mandatory"
+    },
+    sustainability_threshold: 0.1,
+    collapse_visual: {
+      background: "#1c1917",
+      text: "#fef2f2",
+      border: "#b91c1c",
+      label: "Structural Failure"
+    }
+  };
+  const computedOutcomes = parsed.outcomes.map((o) => {
+    const outcome = {
+      id: o.id,
+      type: o.type,
+      label: o.label,
+      show_in_comparison: true
+    };
+    if (o.range) outcome.range = o.range;
+    if (o.display) outcome.display_as = o.display;
+    if (o.primary) outcome.primary = o.primary;
+    if (o.assignment) outcome.assignment = o.assignment;
+    return outcome;
+  });
+  const outcomes = {
+    computed_outcomes: computedOutcomes,
+    comparison_layout: {
+      primary_card: computedOutcomes.find((o) => o.primary)?.id ?? computedOutcomes[0]?.id ?? "",
+      status_badge: "viability_status",
+      structural_indicators: rules.filter((r) => r.severity === "structural").map((r) => r.id)
+    }
+  };
+  const validScopes = /* @__PURE__ */ new Set(["response_framing", "language_style", "content_filtering", "value_emphasis", "behavior_shaping"]);
+  const lensConfigs = parsed.lenses.map((pl) => {
+    const directives = pl.directives.map((d) => ({
+      id: d.id,
+      scope: validScopes.has(d.scope) ? d.scope : "behavior_shaping",
+      instruction: d.instruction
+    }));
+    return {
+      id: pl.id,
+      name: pl.name,
+      tagline: pl.tagline,
+      description: pl.description,
+      tags: pl.tags,
+      tone: {
+        formality: pl.formality || "neutral",
+        verbosity: pl.verbosity || "balanced",
+        emotion: pl.emotion || "neutral",
+        confidence: pl.confidence || "balanced"
+      },
+      directives,
+      defaultForRoles: pl.defaultForRoles,
+      priority: pl.priority,
+      stackable: pl.stackable
+    };
+  });
+  const lensesConfig = lensConfigs.length > 0 ? {
+    lenses: lensConfigs,
+    ...parsed.lensPolicy ? { policy: parsed.lensPolicy } : {},
+    ...parsed.lensLockPin ? { lockPin: parsed.lensLockPin } : {}
+  } : void 0;
+  const metadata = {
+    format_version: "1.0.0",
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    last_modified: (/* @__PURE__ */ new Date()).toISOString(),
+    authoring_method: "manual-authoring"
+  };
+  const worldDefinition = {
+    world,
+    invariants,
+    assumptions,
+    stateSchema,
+    rules,
+    gates,
+    outcomes,
+    ...lensesConfig ? { lenses: lensesConfig } : {},
+    metadata
+  };
+  return { world: worldDefinition, issues };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  emitWorldDefinition
+});

package/dist/engine/bootstrap-emitter.d.cts

@@ -0,0 +1,27 @@
+import { P as ParsedWorld, a as ParseIssue } from '../bootstrap-contract-DcV6t-8M.cjs';
+import { WorldDefinition } from '../types.cjs';
+
+/**
+ * Bootstrap Emitter — ParsedWorld → WorldDefinition
+ *
+ * Converts the intermediate representation from the parser
+ * into a proper WorldDefinition that the guard engine, validate engine,
+ * and compileWorldToZip() all consume.
+ *
+ * Fills in sensible defaults for optional fields.
+ * Reports issues when the parsed data can't cleanly map to the target type.
+ *
+ * Deterministic. Same parsed input → same WorldDefinition output.
+ */
+
+/**
+ * Convert a ParsedWorld into a WorldDefinition.
+ *
+ * Returns the world definition and any issues encountered during emission.
+ */
+declare function emitWorldDefinition(parsed: ParsedWorld): {
+    world: WorldDefinition;
+    issues: ParseIssue[];
+};
+
+export { emitWorldDefinition };

package/dist/engine/bootstrap-emitter.d.ts

@@ -0,0 +1,27 @@
+import { P as ParsedWorld, a as ParseIssue } from '../bootstrap-contract-DcV6t-8M.js';
+import { WorldDefinition } from '../types.js';
+
+/**
+ * Bootstrap Emitter — ParsedWorld → WorldDefinition
+ *
+ * Converts the intermediate representation from the parser
+ * into a proper WorldDefinition that the guard engine, validate engine,
+ * and compileWorldToZip() all consume.
+ *
+ * Fills in sensible defaults for optional fields.
+ * Reports issues when the parsed data can't cleanly map to the target type.
+ *
+ * Deterministic. Same parsed input → same WorldDefinition output.
+ */
+
+/**
+ * Convert a ParsedWorld into a WorldDefinition.
+ *
+ * Returns the world definition and any issues encountered during emission.
+ */
+declare function emitWorldDefinition(parsed: ParsedWorld): {
+    world: WorldDefinition;
+    issues: ParseIssue[];
+};
+
+export { emitWorldDefinition };

package/dist/{bootstrap-emitter-GIMOJFOC.js → engine/bootstrap-emitter.js}

@@ -1,7 +1,7 @@
 import {
   emitWorldDefinition
-} from "./chunk-YPCVY4GS.js";
-import "./chunk-QWGCMQQD.js";
+} from "../chunk-YPCVY4GS.js";
+import "../chunk-QWGCMQQD.js";
 export {
   emitWorldDefinition
 };