@neuroverseos/governance 0.3.4 → 0.4.1

package/dist/{decision-flow-M63D47LO.js → decision-flow-3K4D72G4.js}

@@ -1,11 +1,11 @@
 import {
   readAuditLog
-} from "./chunk-A7GKPPU7.js";
+} from "./chunk-2VAWP6FI.js";
 import {
   generateDecisionFlow,
   renderDecisionFlow
 } from "./chunk-D2UCV5AK.js";
-import "./chunk-W7LLXRGY.js";
+import "./chunk-ZAF6JH23.js";
 import "./chunk-QLPTHTVB.js";
 import "./chunk-QWGCMQQD.js";
 

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

@@ -6,7 +6,7 @@ import {
   handleListPresets,
   handleReasonRequest,
   writeTempWorld
-} from "./chunk-U6U7EJZL.js";
+} from "./chunk-AV7XJJWK.js";
 import {
   adaptationFromVerdict,
   detectBehavioralPatterns,
@@ -15,13 +15,13 @@ import {
 import {
   resolveWorldPath
 } from "./chunk-AKW5YVCE.js";
-import "./chunk-W7LLXRGY.js";
-import "./chunk-QLPTHTVB.js";
+import "./chunk-ZAF6JH23.js";
 import {
   DEFAULT_BUNDLED_WORLD,
   loadBundledWorld,
   loadWorld
-} from "./chunk-CTZHONLA.js";
+} from "./chunk-I4RTIMLX.js";
+import "./chunk-QLPTHTVB.js";
 import {
   __require
 } from "./chunk-QWGCMQQD.js";

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

@@ -2,15 +2,15 @@ import {
   DeriveInputError,
   DeriveProviderError,
   deriveWorld
-} from "./chunk-YEKMVDWK.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-EMQDLDAF.js";
-import "./chunk-PVTQQS3Y.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-CQRZVOXK.js");
+      const { main: bootstrapMain } = await import("./bootstrap-2OW5ZLBL.js");
       await bootstrapMain([
         "--input",
         result.outputPath,

package/dist/{doctor-6BC6X2VO.js → doctor-NHXI7OQW.js}

@@ -10,8 +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("./adapters/mentraos.js"),
   "../adapters/openai.ts": () => import("./adapters/openai.js"),
   "../adapters/openclaw.ts": () => import("./adapters/openclaw.js"),
   "../adapters/shared.ts": () => import("./shared-7RLUHNMU.js")
@@ -103,7 +105,7 @@ async function main(argv) {
     });
   }
   try {
-    const { evaluateGuard } = await import("./guard-engine-PNR6MHCM.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-Q7UIJZ2O.js → engine/bootstrap-emitter.js}

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