@neuroverseos/governance 0.3.4 → 0.4.1

package/dist/bootstrap-contract-DcV6t-8M.d.ts

@@ -0,0 +1,216 @@
+/**
+ * Bootstrap Contract — Markdown → WorldDefinition Compilation Types
+ *
+ * Defines the input/output contract for `neuroverse bootstrap`.
+ *
+ * Input:  .nv-world.md file (structured markdown)
+ * Output: WorldDefinition (passed to validate, guard, or compileWorldToZip)
+ *
+ * The markdown format is:
+ *   - YAML frontmatter for world identity and metadata
+ *   - H1 sections for each block (Thesis, Invariants, State, etc.)
+ *   - Structured sub-sections within each block
+ *   - Deterministically parseable — no LLM, no heuristics
+ *
+ * Exit codes:
+ *   0 = SUCCESS  (compiled cleanly)
+ *   1 = FAIL     (parse errors, missing required sections)
+ *   3 = ERROR    (file not found, invalid input)
+ */
+type ParseSeverity = 'error' | 'warning' | 'info';
+/**
+ * A single parse issue found during markdown compilation.
+ */
+interface ParseIssue {
+    /** Line number in the source markdown (1-based) */
+    line: number;
+    /** Which section the issue was found in */
+    section: string;
+    /** Human-readable message */
+    message: string;
+    /** Severity */
+    severity: ParseSeverity;
+}
+/**
+ * The result of parsing a .nv-world.md file.
+ */
+interface BootstrapResult {
+    /** Whether compilation succeeded (no errors) */
+    success: boolean;
+    /** Source file path */
+    sourcePath: string;
+    /** All parse issues */
+    issues: ParseIssue[];
+    /** Parsed sections (for debugging) */
+    parsedSections: string[];
+    /** Duration */
+    durationMs: number;
+}
+/**
+ * YAML frontmatter parsed from the markdown header.
+ */
+interface ParsedFrontmatter {
+    world_id: string;
+    name: string;
+    version?: string;
+    runtime_mode?: string;
+    default_profile?: string;
+    alternative_profile?: string;
+}
+/**
+ * A parsed invariant from the Invariants section.
+ */
+interface ParsedInvariant {
+    id: string;
+    label: string;
+    enforcement: string;
+    mutable: boolean;
+    line: number;
+}
+/**
+ * A parsed state variable from the State section.
+ */
+interface ParsedStateVariable {
+    id: string;
+    type: 'number' | 'enum' | 'boolean';
+    default: string | number | boolean;
+    label: string;
+    description: string;
+    min?: number;
+    max?: number;
+    step?: number;
+    options?: string[];
+    line: number;
+}
+/**
+ * A parsed assumption profile from the Assumptions section.
+ */
+interface ParsedAssumptionProfile {
+    id: string;
+    name: string;
+    description: string;
+    parameters: Record<string, string | number | boolean>;
+    line: number;
+}
+/**
+ * A parsed trigger from a rule.
+ */
+interface ParsedTrigger {
+    field: string;
+    operator: string;
+    value: string | number | boolean;
+    source: 'state' | 'assumption';
+}
+/**
+ * A parsed effect from a rule.
+ */
+interface ParsedEffect {
+    target: string;
+    operation: string;
+    value: number | boolean | string;
+}
+/**
+ * A parsed rule from the Rules section.
+ */
+interface ParsedRule {
+    id: string;
+    label: string;
+    severity: string;
+    description?: string;
+    order: number;
+    triggers: ParsedTrigger[];
+    effects: ParsedEffect[];
+    collapse_check?: {
+        field: string;
+        operator: string;
+        value: number;
+    };
+    causal_translation?: {
+        trigger_text: string;
+        rule_text: string;
+        shift_text: string;
+        effect_text: string;
+    };
+    line: number;
+}
+/**
+ * A parsed gate from the Gates section.
+ */
+interface ParsedGate {
+    status: string;
+    field: string;
+    operator: string;
+    value: number;
+    line: number;
+}
+/**
+ * A parsed outcome from the Outcomes section.
+ */
+interface ParsedOutcome {
+    id: string;
+    type: string;
+    range?: [number, number];
+    display?: string;
+    label: string;
+    primary?: boolean;
+    assignment?: string;
+    line: number;
+}
+/**
+ * A parsed lens directive from the Lenses section.
+ */
+interface ParsedLensDirective {
+    id: string;
+    scope: string;
+    instruction: string;
+    line: number;
+}
+/**
+ * A parsed lens from the Lenses section.
+ * Each lens is an H2 subsection with key-value properties and directives.
+ */
+interface ParsedLens {
+    id: string;
+    name: string;
+    tagline: string;
+    description: string;
+    tags: string[];
+    /** Tone: formality, verbosity, emotion, confidence */
+    formality: string;
+    verbosity: string;
+    emotion: string;
+    confidence: string;
+    /** Which roles this lens is the default for */
+    defaultForRoles: string[];
+    /** Behavioral directives */
+    directives: ParsedLensDirective[];
+    /** Priority when stacking (higher = applied later) */
+    priority: number;
+    /** Whether it can be stacked with other lenses */
+    stackable: boolean;
+    line: number;
+}
+/**
+ * The full parsed intermediate representation.
+ */
+interface ParsedWorld {
+    frontmatter: ParsedFrontmatter;
+    thesis: string;
+    invariants: ParsedInvariant[];
+    stateVariables: ParsedStateVariable[];
+    assumptions: ParsedAssumptionProfile[];
+    rules: ParsedRule[];
+    gates: ParsedGate[];
+    outcomes: ParsedOutcome[];
+    lenses: ParsedLens[];
+    lensPolicy?: 'locked' | 'role_default' | 'user_choice';
+    lensLockPin?: string;
+}
+declare const BOOTSTRAP_EXIT_CODES: {
+    readonly SUCCESS: 0;
+    readonly FAIL: 1;
+    readonly ERROR: 3;
+};
+type BootstrapExitCode = (typeof BOOTSTRAP_EXIT_CODES)[keyof typeof BOOTSTRAP_EXIT_CODES];
+
+export { BOOTSTRAP_EXIT_CODES as B, type ParsedWorld as P, type ParseIssue as a, type BootstrapExitCode as b, type BootstrapResult as c, type ParsedAssumptionProfile as d, type ParsedEffect as e, type ParsedFrontmatter as f, type ParsedGate as g, type ParsedInvariant as h, type ParsedOutcome as i, type ParsedRule as j, type ParsedStateVariable as k, type ParsedTrigger as l };

package/dist/browser.global.js

@@ -49,15 +49,25 @@ var NeuroVerse = (() => {
     let collapseStep;
     let collapseRule;
     const sortedRules = [...world.rules].sort((a, b) => a.order - b.order);
+    const allEvents = options.events ?? [];
+    const eventsByStep = Array.from({ length: steps }, () => []);
+    for (let i = 0; i < allEvents.length; i++) {
+      const stepIdx = Math.min(i, steps - 1);
+      eventsByStep[stepIdx].push(allEvents[i]);
+    }
+    let totalEventsConsumed = 0;
     for (let stepNum = 1; stepNum <= steps; stepNum++) {
       if (collapsed) break;
+      const stepEvents = eventsByStep[stepNum - 1];
       const stepResult = evaluateStep(
         stepNum,
         sortedRules,
         state,
         assumptions,
-        world
+        world,
+        stepEvents
       );
+      totalEventsConsumed += stepResult.eventsApplied.length;
       simulationSteps.push(stepResult);
       if (stepResult.collapsed) {
         collapsed = true;
@@ -76,14 +86,38 @@ var NeuroVerse = (() => {
       finalViability,
       collapsed,
       collapseStep,
-      collapseRule
+      collapseRule,
+      eventsConsumed: totalEventsConsumed
     };
   }
-  function evaluateStep(stepNum, rules, state, assumptions, world) {
+  function evaluateStep(stepNum, rules, state, assumptions, world, events = []) {
     const evaluations = [];
+    const eventApplications = [];
     let rulesFired = 0;
     let collapsed = false;
     const firedRuleIds = /* @__PURE__ */ new Set();
+    for (const evt of events) {
+      const application = {
+        eventType: evt.type,
+        rulesTriggered: [],
+        effects: []
+      };
+      for (const rule of rules) {
+        const eventTrigger = rule.triggers.find(
+          (t) => t.field === "event" && t.source === "state"
+        );
+        if (!eventTrigger) continue;
+        const matches = evaluateOperator(evt.type, eventTrigger.operator, eventTrigger.value);
+        if (!matches) continue;
+        application.rulesTriggered.push(rule.id);
+        firedRuleIds.add(rule.id);
+        for (const effect of rule.effects ?? []) {
+          const applied = applyEffect(effect, state);
+          if (applied) application.effects.push(applied);
+        }
+      }
+      eventApplications.push(application);
+    }
     for (const rule of rules) {
       if (collapsed) {
         evaluations.push({
@@ -168,6 +202,7 @@ var NeuroVerse = (() => {
     const viability = classifyViability(state, world);
     return {
       step: stepNum,
+      eventsApplied: eventApplications,
       rulesEvaluated: evaluations,
       rulesFired,
       stateAfter: { ...state },
@@ -662,6 +697,67 @@ var NeuroVerse = (() => {
     if (!isNaN(num) && raw.trim() !== "") return num;
     return raw;
   }
+  function parseLenses(content, startLine, issues) {
+    const lenses = [];
+    const subSections = splitH2Sections(content, startLine);
+    for (const sub of subSections) {
+      const props = parseKeyValueBullets(sub.content);
+      const lineNum = sub.startLine;
+      const directives = [];
+      const lines = sub.content.split("\n");
+      let directiveIndex = 0;
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+        if (line.startsWith(">")) {
+          const blockContent = line.slice(1).trim();
+          const colonIdx = blockContent.indexOf(":");
+          if (colonIdx > 0) {
+            const scope = blockContent.slice(0, colonIdx).trim();
+            let instruction = blockContent.slice(colonIdx + 1).trim();
+            for (let j = i + 1; j < lines.length; j++) {
+              const nextLine = lines[j].trim();
+              if (nextLine.startsWith(">")) {
+                const nextContent = nextLine.slice(1).trim();
+                const nextColon = nextContent.indexOf(":");
+                if (nextColon > 0 && !nextContent.slice(0, nextColon).includes(" ")) {
+                  break;
+                }
+                instruction += " " + nextContent;
+                i = j;
+              } else {
+                break;
+              }
+            }
+            directives.push({
+              id: `${sub.name}_directive_${directiveIndex++}`,
+              scope,
+              instruction,
+              line: startLine + i
+            });
+          }
+        }
+      }
+      const tags = (props.tags ?? "").split(",").map((s) => s.trim()).filter(Boolean);
+      const defaultForRoles = (props.default_for_roles ?? props.roles ?? "").split(",").map((s) => s.trim()).filter(Boolean);
+      lenses.push({
+        id: sub.name,
+        name: props.name ?? sub.name,
+        tagline: props.tagline ?? "",
+        description: props.description ?? "",
+        tags,
+        formality: props.formality ?? "neutral",
+        verbosity: props.verbosity ?? "balanced",
+        emotion: props.emotion ?? "neutral",
+        confidence: props.confidence ?? "balanced",
+        defaultForRoles,
+        directives,
+        priority: props.priority ? parseInt(props.priority, 10) : 50,
+        stackable: props.stackable === "false" ? false : true,
+        line: lineNum
+      });
+    }
+    return lenses;
+  }
   function parseWorldMarkdown(markdown) {
     const issues = [];
     const { frontmatter: fmRaw, sections } = splitSections(markdown);
@@ -699,8 +795,22 @@ var NeuroVerse = (() => {
     }
     const outcomesSection = findSection("Outcomes");
     const outcomes = outcomesSection ? parseOutcomes(outcomesSection.content, outcomesSection.startLine, issues) : [];
+    const lensesSection = findSection("Lenses");
+    const lenses = lensesSection ? parseLenses(lensesSection.content, lensesSection.startLine, issues) : [];
+    let lensPolicy;
+    let lensLockPin;
+    if (lensesSection) {
+      const topContent = lensesSection.content.split(/^##\s/m)[0];
+      const topProps = parseKeyValueBullets(topContent);
+      if (topProps.policy === "locked" || topProps.policy === "role_default" || topProps.policy === "user_choice") {
+        lensPolicy = topProps.policy;
+      }
+      if (topProps.lock_pin) {
+        lensLockPin = topProps.lock_pin;
+      }
+    }
     const parsedSections = sections.map((s) => s.name);
-    const knownSections = /* @__PURE__ */ new Set(["thesis", "invariants", "state", "assumptions", "rules", "gates", "outcomes"]);
+    const knownSections = /* @__PURE__ */ new Set(["thesis", "invariants", "state", "assumptions", "rules", "gates", "outcomes", "lenses"]);
     for (const section of sections) {
       if (!knownSections.has(section.name.toLowerCase())) {
         issues.push({
@@ -726,7 +836,10 @@ var NeuroVerse = (() => {
         assumptions,
         rules,
         gates,
-        outcomes
+        outcomes,
+        lenses,
+        lensPolicy,
+        lensLockPin
       },
       issues
     };
@@ -896,6 +1009,36 @@ var NeuroVerse = (() => {
         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(),
@@ -910,6 +1053,7 @@ var NeuroVerse = (() => {
       rules,
       gates,
       outcomes,
+      ...lensesConfig ? { lenses: lensesConfig } : {},
       metadata
     };
     return { world: worldDefinition, issues };

package/dist/{build-ZHPMX5AZ.js → build-EGBGZFIJ.js}

@@ -2,19 +2,19 @@ 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 {
-  parseWorldMarkdown
-} from "./chunk-EMQDLDAF.js";
 import {
   emitWorldDefinition
-} from "./chunk-PVTQQS3Y.js";
+} from "./chunk-YPCVY4GS.js";
+import {
+  parseWorldMarkdown
+} from "./chunk-3NZMMSOW.js";
 import "./chunk-QWGCMQQD.js";
 
 // src/cli/build.ts

package/dist/{chunk-A7GKPPU7.js → chunk-2VAWP6FI.js}

@@ -1,6 +1,6 @@
 import {
   evaluateGuard
-} from "./chunk-W7LLXRGY.js";
+} from "./chunk-ZAF6JH23.js";
 
 // src/engine/audit-logger.ts
 var FileAuditLogger = class {

package/dist/{chunk-3WQLXYTP.js → chunk-3AYKQHYI.js}

@@ -6,10 +6,10 @@ import {
 } from "./chunk-5U2MQO5P.js";
 import {
   evaluateGuard
-} from "./chunk-W7LLXRGY.js";
+} from "./chunk-ZAF6JH23.js";
 import {
   loadWorld
-} from "./chunk-CTZHONLA.js";
+} from "./chunk-I4RTIMLX.js";
 
 // src/adapters/langchain.ts
 var GovernanceBlockedError2 = class extends GovernanceBlockedError {

package/dist/{chunk-EMQDLDAF.js → chunk-3NZMMSOW.js}

@@ -383,6 +383,67 @@ function parseValueLiteral(raw) {
   if (!isNaN(num) && raw.trim() !== "") return num;
   return raw;
 }
+function parseLenses(content, startLine, issues) {
+  const lenses = [];
+  const subSections = splitH2Sections(content, startLine);
+  for (const sub of subSections) {
+    const props = parseKeyValueBullets(sub.content);
+    const lineNum = sub.startLine;
+    const directives = [];
+    const lines = sub.content.split("\n");
+    let directiveIndex = 0;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+      if (line.startsWith(">")) {
+        const blockContent = line.slice(1).trim();
+        const colonIdx = blockContent.indexOf(":");
+        if (colonIdx > 0) {
+          const scope = blockContent.slice(0, colonIdx).trim();
+          let instruction = blockContent.slice(colonIdx + 1).trim();
+          for (let j = i + 1; j < lines.length; j++) {
+            const nextLine = lines[j].trim();
+            if (nextLine.startsWith(">")) {
+              const nextContent = nextLine.slice(1).trim();
+              const nextColon = nextContent.indexOf(":");
+              if (nextColon > 0 && !nextContent.slice(0, nextColon).includes(" ")) {
+                break;
+              }
+              instruction += " " + nextContent;
+              i = j;
+            } else {
+              break;
+            }
+          }
+          directives.push({
+            id: `${sub.name}_directive_${directiveIndex++}`,
+            scope,
+            instruction,
+            line: startLine + i
+          });
+        }
+      }
+    }
+    const tags = (props.tags ?? "").split(",").map((s) => s.trim()).filter(Boolean);
+    const defaultForRoles = (props.default_for_roles ?? props.roles ?? "").split(",").map((s) => s.trim()).filter(Boolean);
+    lenses.push({
+      id: sub.name,
+      name: props.name ?? sub.name,
+      tagline: props.tagline ?? "",
+      description: props.description ?? "",
+      tags,
+      formality: props.formality ?? "neutral",
+      verbosity: props.verbosity ?? "balanced",
+      emotion: props.emotion ?? "neutral",
+      confidence: props.confidence ?? "balanced",
+      defaultForRoles,
+      directives,
+      priority: props.priority ? parseInt(props.priority, 10) : 50,
+      stackable: props.stackable === "false" ? false : true,
+      line: lineNum
+    });
+  }
+  return lenses;
+}
 function parseWorldMarkdown(markdown) {
   const issues = [];
   const { frontmatter: fmRaw, sections } = splitSections(markdown);
@@ -420,8 +481,22 @@ function parseWorldMarkdown(markdown) {
   }
   const outcomesSection = findSection("Outcomes");
   const outcomes = outcomesSection ? parseOutcomes(outcomesSection.content, outcomesSection.startLine, issues) : [];
+  const lensesSection = findSection("Lenses");
+  const lenses = lensesSection ? parseLenses(lensesSection.content, lensesSection.startLine, issues) : [];
+  let lensPolicy;
+  let lensLockPin;
+  if (lensesSection) {
+    const topContent = lensesSection.content.split(/^##\s/m)[0];
+    const topProps = parseKeyValueBullets(topContent);
+    if (topProps.policy === "locked" || topProps.policy === "role_default" || topProps.policy === "user_choice") {
+      lensPolicy = topProps.policy;
+    }
+    if (topProps.lock_pin) {
+      lensLockPin = topProps.lock_pin;
+    }
+  }
   const parsedSections = sections.map((s) => s.name);
-  const knownSections = /* @__PURE__ */ new Set(["thesis", "invariants", "state", "assumptions", "rules", "gates", "outcomes"]);
+  const knownSections = /* @__PURE__ */ new Set(["thesis", "invariants", "state", "assumptions", "rules", "gates", "outcomes", "lenses"]);
   for (const section of sections) {
     if (!knownSections.has(section.name.toLowerCase())) {
       issues.push({
@@ -447,7 +522,10 @@ function parseWorldMarkdown(markdown) {
       assumptions,
       rules,
       gates,
-      outcomes
+      outcomes,
+      lenses,
+      lensPolicy,
+      lensLockPin
     },
     issues
   };