@neuroverseos/governance 0.5.1 → 0.6.0

package/dist/worldmodel-contract-BPGhiuW5.d.ts

@@ -0,0 +1,221 @@
+/**
+ * WorldModel Contract — .worldmodel.md → Behavioral World Model Types
+ *
+ * Defines the three-layer intermediate representation produced by the parser
+ * and consumed by the compiler.
+ *
+ * Three Layers:
+ *   1. Core Model Geometry  — mission, domains (skills + values), overlaps, center identity
+ *   2. Contextual Modifiers — authority, spatial contexts, interpretation rules
+ *   3. Evolution Layer      — aligned/drift behaviors, signals, priorities, evolution conditions
+ *
+ * Input:  .worldmodel.md file (structured markdown)
+ * Output: .nv-world.md + signals.json + overlaps.json + contexts.json + lenses.json
+ */
+interface WorldModelFrontmatter {
+    /** Unique identifier derived from name (kebab-case) */
+    model_id: string;
+    /** Human-readable model name */
+    name: string;
+    /** Semantic version */
+    version: string;
+}
+/**
+ * A domain is a mode of operating that carries both skills and values.
+ * Domains are NOT personality traits — they are capability environments.
+ */
+interface ParsedDomain {
+    /** kebab-case identifier derived from name */
+    id: string;
+    /** Human-readable domain name */
+    name: string;
+    /** Skills: capabilities within this domain */
+    skills: string[];
+    /** Values: constraints governing skills in this domain */
+    values: string[];
+    /** Line number in source for error reporting */
+    line: number;
+}
+/**
+ * An overlap effect describes what emerges when two domains interact well.
+ * These are interpretive states, not enforced rules.
+ */
+interface ParsedOverlap {
+    /** First domain name */
+    domainA: string;
+    /** Second domain name */
+    domainB: string;
+    /** Emergent state name (e.g., "Inspiration", "Trust") */
+    effect: string;
+    /** Line number in source */
+    line: number;
+}
+/**
+ * The structural heart of the behavioral model.
+ * Defines what the system is trying to become.
+ */
+interface CoreModelGeometry {
+    /** The core aim — not a slogan */
+    mission: string;
+    /** Major operating domains, each carrying skills and values */
+    domains: ParsedDomain[];
+    /** Emergent states arising between domain pairings */
+    overlapEffects: ParsedOverlap[];
+    /** The identity that emerges when all domains are aligned */
+    centerIdentity: string;
+}
+/**
+ * Defines how behavior is interpreted differently depending on context.
+ * These do NOT define truth — they define how meaning changes depending on
+ * who is acting, where behavior occurs, and what phase the system is in.
+ */
+interface ContextualModifiers {
+    /** Who is acting? (e.g., founder, maintainer, contributor, agent) */
+    authorityLayers: string[];
+    /** Where is behavior happening? (e.g., planning, execution, deployment) */
+    spatialContexts: string[];
+    /** How does context change meaning? Free-form interpretation rules */
+    interpretationRules: string[];
+}
+/**
+ * A decision priority defining tradeoff resolution.
+ * Format: preferred > over
+ */
+interface ParsedPriority {
+    /** What should win in the tradeoff */
+    preferred: string;
+    /** What it wins over */
+    over: string;
+    /** Line number in source */
+    line: number;
+}
+/**
+ * The executable temporal layer.
+ * Defines observable behaviors, signals, and adaptation conditions.
+ */
+interface EvolutionLayer {
+    /** What does success look like in action? */
+    alignedBehaviors: string[];
+    /** What does misalignment look like? */
+    driftBehaviors: string[];
+    /** Observable metrics (snake_case identifiers) */
+    signals: string[];
+    /** Tradeoff resolution rules */
+    decisionPriorities: ParsedPriority[];
+    /** When should the model adapt? */
+    evolutionConditions: string[];
+}
+/**
+ * The complete three-layer behavioral world model.
+ *
+ * Layer 1 (geometry) defines the model.
+ * Layer 2 (modifiers) shapes interpretation.
+ * Layer 3 (evolution) drives executable governance.
+ */
+interface ParsedWorldModel {
+    frontmatter: WorldModelFrontmatter;
+    geometry: CoreModelGeometry;
+    modifiers: ContextualModifiers;
+    evolution: EvolutionLayer;
+}
+/**
+ * Signal schema emitted as signals.json.
+ */
+interface SignalSchema {
+    model_id: string;
+    signals: SignalEntry[];
+}
+interface SignalEntry {
+    id: string;
+    name: string;
+    type: 'number';
+    default: number;
+}
+/**
+ * Overlap map emitted as overlaps.json.
+ * Includes both a flat pairing list and a matrix view.
+ */
+interface OverlapMap {
+    model_id: string;
+    pairings: OverlapPairing[];
+    /** domainA id → domainB id → emergent state name */
+    matrix: Record<string, Record<string, string>>;
+}
+interface OverlapPairing {
+    domainA: string;
+    domainB: string;
+    effect: string;
+}
+/**
+ * Contextual modifiers emitted as contexts.json.
+ */
+interface ContextsConfig {
+    model_id: string;
+    authority_layers: string[];
+    spatial_contexts: string[];
+    interpretation_rules: string[];
+}
+/**
+ * A lens suggestion derived from overlap effects.
+ */
+interface LensSuggestion {
+    id: string;
+    name: string;
+    tagline: string;
+    derived_from: {
+        domainA: string;
+        domainB: string;
+        effect: string;
+    };
+    tone: {
+        formality: string;
+        verbosity: string;
+        emotion: string;
+        confidence: string;
+    };
+    directives: LensDirectiveEntry[];
+}
+interface LensDirectiveEntry {
+    scope: string;
+    instruction: string;
+}
+/**
+ * Complete compiler output bundle.
+ */
+interface WorldModelOutput {
+    /** Complete .nv-world.md content string */
+    worldMarkdown: string;
+    /** Signal schema for signals.json */
+    signalSchema: SignalSchema;
+    /** Overlap map for overlaps.json */
+    overlapMap: OverlapMap;
+    /** Context config for contexts.json */
+    contextsConfig: ContextsConfig;
+    /** Lens suggestions for lenses.json */
+    lensSuggestions: LensSuggestion[];
+}
+type WorldModelIssueSeverity = 'error' | 'warning' | 'info';
+/**
+ * A single issue found during parsing or validation.
+ */
+interface WorldModelIssue {
+    /** Line number in source (1-based, 0 if unknown) */
+    line: number;
+    /** Which section the issue was found in */
+    section: string;
+    /** Human-readable message (designed to teach the method) */
+    message: string;
+    /** Severity level */
+    severity: WorldModelIssueSeverity;
+}
+/**
+ * Result of parsing a .worldmodel.md file.
+ */
+interface WorldModelParseResult {
+    /** The parsed model, or null if parsing failed */
+    model: ParsedWorldModel | null;
+    /** All issues encountered during parsing */
+    issues: WorldModelIssue[];
+}
+
+export type { ContextsConfig as C, LensSuggestion as L, OverlapMap as O, ParsedWorldModel as P, SignalSchema as S, WorldModelOutput as W, WorldModelParseResult as a };

package/dist/worlds/auki-vanguard.worldmodel.md

@@ -0,0 +1,116 @@
+---
+name: Auki Vanguard
+version: 1.0.0
+---
+
+# Core Model Geometry
+
+## Mission
+Build and maintain the real world web while preserving long-term mission alignment across human-AI collaboration.
+
+## Domains
+
+### Future Foresight
+
+#### Skills
+- Strategic Thinking
+- Systems Design
+- Scenario Planning
+- Long-range Architecture
+
+#### Values
+- Long-term thinking over short-term convenience
+- Intellectual honesty about uncertainty
+- Openness to emerging possibilities
+
+### Narrative Dynamics
+
+#### Skills
+- Storytelling
+- Emotional Intelligence
+- Communication Design
+- Shared Context Building
+
+#### Values
+- Authenticity in messaging
+- Clarity of intent
+- Emotional truth over performative optimism
+
+### Shared Prosperity
+
+#### Skills
+- Stakeholder Alignment
+- Incentive Design
+- Community Building
+- Negotiation
+
+#### Values
+- Fairness in distribution
+- Shared benefit over individual extraction
+- Transparency of process and outcome
+
+## Overlap Effects
+- Future Foresight + Narrative Dynamics = Inspiration
+- Narrative Dynamics + Shared Prosperity = Trust
+- Shared Prosperity + Future Foresight = Hope
+
+## Center Identity
+Collective Vanguard Leader
+
+# Contextual Modifiers
+
+## Authority Layers
+- founder
+- core team
+- contributor
+- agent
+
+## Spatial Contexts
+- strategy
+- execution
+- deployment
+- governance
+- community
+
+## Interpretation Rules
+- ambiguity from a founder carries more system-wide risk than ambiguity from a contributor
+- weak ownership in deployment is more serious than weak ownership in strategy
+- high clarity in governance contexts increases trust weighting across the system
+- narrative inconsistency from core team erodes inspiration faster than from agents
+- shared prosperity signals from founders amplify hope across all authority layers
+
+# Evolution Layer
+
+## Aligned Behaviors
+- communicates future direction in ways others can act on
+- makes decisions that strengthen long-term ecosystem health
+- maintains clarity of purpose while moving quickly
+- distributes opportunity and responsibility coherently
+- aligns incentives with shared progress rather than individual gain
+
+## Drift Behaviors
+- ambiguity around who owns important work
+- mission language disconnected from execution
+- repeated implicit decisions instead of explicit ones
+- shipping without shared understanding
+- execution that erodes trust in the name of speed
+
+## Signals
+- clarity
+- ownership
+- follow_through
+- alignment
+- decision_momentum
+
+## Decision Priorities
+- long_term_ecosystem > short_term_convenience
+- trust_preservation > performative_speed
+- explicit_decision > silent_delay
+- shared_clarity > local_optimization
+
+## Evolution Conditions
+- propose model updates when repeated successful behavior contradicts a current assumption
+- increase confidence in patterns that validate across multiple scopes
+- require human review before changing constitutional assumptions
+- when narrative and execution diverge persistently, trigger alignment review
+- when new contributors consistently succeed outside defined domains, consider domain expansion

package/dist/worlds/behavioral-demo.nv-world.md

@@ -0,0 +1,130 @@
+---
+world_id: behavioral-demo
+name: Behavioral Demo
+version: 1.0.0
+default_profile: baseline
+alternative_profile: pressure
+---
+
+# Thesis
+
+Behavior should be interpreted through repeated action, clarity of ownership, and consistency between stated intent and follow-through. Actions are stronger evidence than promises. Ambiguity is a signal, not noise. Alignment is measured by what people do, not what they say.
+
+# Invariants
+
+- `behavior_over_promises` — Repeated action is stronger evidence than stated intent (structural, immutable)
+- `clarity_matters` — Ambiguity and ownership diffusion are meaningful behavioral signals (structural, immutable)
+
+# State
+
+## follow_through
+- type: number
+- min: 0
+- max: 100
+- step: 5
+- default: 70
+- label: Follow Through
+- description: Measures how consistently actions match stated commitments
+
+## clarity
+- type: number
+- min: 0
+- max: 100
+- step: 5
+- default: 75
+- label: Clarity
+- description: Measures directness and explicitness of communication
+
+## alignment_score
+- type: number
+- min: 0
+- max: 100
+- step: 5
+- default: 80
+- label: Alignment Score
+- description: Measures consistency between stated priorities and actual behavior
+
+# Assumptions
+
+## baseline
+- name: Baseline
+- description: Normal operating conditions
+- pressure_level: medium
+
+## pressure
+- name: Pressure
+- description: Higher stress and ambiguity environment
+- pressure_level: high
+
+# Rules
+
+## rule-001: ambiguity erodes alignment (degradation)
+Repeated ambiguity weakens trust in stated intent.
+
+When clarity < 50 [state]
+Then alignment_score *= 0.80
+
+> trigger: Communication becomes vague or indirect.
+> rule: Reduced clarity lowers confidence in alignment.
+> shift: Interpretation becomes more cautious.
+> effect: Alignment score declines.
+
+## rule-002: weak follow-through erodes alignment (degradation)
+Failure to follow through consistently weakens credibility.
+
+When follow_through < 60 [state]
+Then alignment_score *= 0.75
+Collapse: alignment_score < 30
+
+> trigger: Commitments are not consistently honored.
+> rule: Action matters more than promises.
+> shift: Behavior is interpreted as misaligned.
+> effect: Alignment score drops sharply.
+
+## rule-003: strong execution reinforces alignment (advantage)
+Consistent action strengthens trust in intent.
+
+When follow_through >= 85 [state] AND clarity >= 80 [state]
+Then alignment_score *= 1.10
+
+> trigger: Clear communication and strong execution occur together.
+> rule: Consistency strengthens alignment.
+> shift: Interpretation becomes more confident.
+> effect: Alignment score improves.
+
+# Gates
+
+- STRONG: alignment_score >= 85
+- STABLE: alignment_score >= 65
+- WATCHING: alignment_score >= 45
+- FRAGILE: alignment_score > 30
+- MISALIGNED: alignment_score <= 30
+
+# Outcomes
+
+## alignment_score
+- type: number
+- range: 0-100
+- display: percentage
+- label: Alignment Score
+- primary: true
+
+# Lenses
+- policy: role_default
+
+## behavioral-interpreter
+- tagline: Read patterns, not promises.
+- description: Interprets actions as signals, prioritizes repeated behavior over stated intent, and flags ambiguity, ownership diffusion, and misalignment.
+- formality: neutral
+- verbosity: concise
+- emotion: neutral
+- confidence: balanced
+- tags: behavior, signals, alignment, analysis
+- default_for_roles: all
+- priority: 65
+- stackable: true
+
+> response_framing: Prioritize observed behavior and follow-through over stated intent.
+> behavior_shaping: Look for repeated ambiguity, delay, or ownership diffusion as meaningful signals.
+> value_emphasis: Name alignment or misalignment between words and actions clearly.
+> content_filtering: Distinguish observed behavior from inference and speculation.

package/dist/worlds/neuroverse-governance.worldmodel.md

@@ -0,0 +1,115 @@
+---
+name: NeuroVerse Governance
+version: 1.0.0
+---
+
+# Core Model Geometry
+
+## Mission
+Provide trustworthy, deterministic, and composable AI governance that any system can adopt, inspect, and evolve.
+
+## Domains
+
+### World Building
+
+#### Skills
+- Constitutional Design
+- State Modeling
+- Rule Authoring
+- Invariant Definition
+
+#### Values
+- Determinism over heuristics
+- Inspectability of all governance logic
+- Composability across systems
+
+### Behavioral Interpretation
+
+#### Skills
+- Signal Detection
+- Drift Analysis
+- Alignment Measurement
+- Emergence Recognition
+
+#### Values
+- Behavior over promises
+- Observation over inference
+- Patterns over isolated events
+
+### Governance Evolution
+
+#### Skills
+- Assumption Testing
+- Model Adaptation
+- Controlled Rollout
+- Impact Assessment
+
+#### Values
+- Stability before change
+- Evidence-based evolution
+- Human review of constitutional changes
+
+## Overlap Effects
+- World Building + Behavioral Interpretation = Structural Clarity
+- Behavioral Interpretation + Governance Evolution = Adaptive Trust
+- Governance Evolution + World Building = Principled Progress
+
+## Center Identity
+Trustworthy Governance Engine
+
+# Contextual Modifiers
+
+## Authority Layers
+- platform maintainer
+- world author
+- agent runtime
+- external consumer
+
+## Spatial Contexts
+- authoring
+- compilation
+- runtime evaluation
+- simulation
+- evolution
+
+## Interpretation Rules
+- governance failures in runtime evaluation are more critical than in simulation
+- world authors carry constitutional responsibility for invariant design
+- agent runtime behavior must be fully traceable to declared rules
+- external consumers should experience governance as transparent constraint, not black box
+- evolution proposals from simulation contexts require human confirmation before promotion
+
+# Evolution Layer
+
+## Aligned Behaviors
+- every guard verdict traces to a declared rule or invariant
+- world files remain human-readable and deterministically parseable
+- governance logic compiles without LLM dependency
+- changes to constitutional assumptions go through explicit review
+- new features compose with existing worlds without breaking them
+
+## Drift Behaviors
+- governance decisions that cannot be traced to source rules
+- world files that require AI to interpret
+- silent changes to invariants or thresholds
+- validation logic that produces different results on repeated runs
+- features that break existing world compatibility
+
+## Signals
+- determinism
+- traceability
+- composability
+- human_readability
+- backward_compatibility
+
+## Decision Priorities
+- correctness > convenience
+- determinism > expressiveness
+- backward_compatibility > new_features
+- traceability > performance
+
+## Evolution Conditions
+- when a world pattern appears in three or more independent adoptions, consider promoting to built-in
+- when validation rules produce false positives across multiple worlds, refine the rule
+- when new governance needs emerge that existing sections cannot express, propose a schema extension
+- require changelog entry for every constitutional change

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neuroverseos/governance",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "description": "Deterministic governance engine for AI agents — enforce worlds (permanent rules) and plans (mission constraints) with full audit trace",
   "license": "Apache-2.0",
   "type": "module",
@@ -119,7 +119,7 @@
   ],
   "scripts": {
     "prepare": "npm run build",
-    "build": "tsup src/index.ts src/types.ts src/cli/neuroverse.ts src/cli/plan.ts src/cli/run.ts src/adapters/index.ts src/adapters/langchain.ts src/adapters/openai.ts src/adapters/openclaw.ts src/adapters/express.ts src/adapters/autoresearch.ts src/adapters/deep-agents.ts src/adapters/mentraos.ts src/adapters/github.ts src/engine/guard-engine.ts src/engine/simulate-engine.ts src/engine/bootstrap-parser.ts src/engine/bootstrap-emitter.ts src/spatial/index.ts src/admin/index.ts --format esm,cjs --dts --clean && npm run build:browser && cp src/worlds/*.nv-world.md dist/worlds/ && cp src/spatial/zones/*.nv-world.md dist/worlds/ && npm run build:viz",
+    "build": "tsup src/index.ts src/types.ts src/cli/neuroverse.ts src/cli/plan.ts src/cli/run.ts src/cli/worldmodel.ts src/adapters/index.ts src/adapters/langchain.ts src/adapters/openai.ts src/adapters/openclaw.ts src/adapters/express.ts src/adapters/autoresearch.ts src/adapters/deep-agents.ts src/adapters/mentraos.ts src/adapters/github.ts src/engine/guard-engine.ts src/engine/simulate-engine.ts src/engine/bootstrap-parser.ts src/engine/bootstrap-emitter.ts src/engine/worldmodel-parser.ts src/engine/worldmodel-compiler.ts src/spatial/index.ts src/admin/index.ts --format esm,cjs --dts --clean && npm run build:browser && cp src/worlds/*.nv-world.md dist/worlds/ && cp src/worlds/*.worldmodel.md dist/worlds/ && cp src/spatial/zones/*.nv-world.md dist/worlds/ && npm run build:viz",
     "build:browser": "tsup src/browser.ts --format iife --global-name NeuroVerse --outDir dist --no-dts",
     "build:viz": "vite build",
     "dev:viz": "vite dev",

package/dist/{bootstrap-IP5QMC3Q.js → bootstrap-2OW5ZLBL.js}

@@ -1,12 +1,12 @@
 import {
   BOOTSTRAP_EXIT_CODES
 } from "./chunk-4NGDRRQH.js";
-import {
-  parseWorldMarkdown
-} from "./chunk-3NZMMSOW.js";
 import {
   emitWorldDefinition
 } from "./chunk-YPCVY4GS.js";
+import {
+  parseWorldMarkdown
+} from "./chunk-3NZMMSOW.js";
 import "./chunk-QWGCMQQD.js";
 
 // src/cli/bootstrap.ts

package/dist/{chunk-QZ666FCV.js → chunk-735Z3HA4.js}

@@ -7,12 +7,12 @@ import {
 import {
   validateWorld
 } from "./chunk-7P3S7MAY.js";
-import {
-  parseWorldMarkdown
-} from "./chunk-3NZMMSOW.js";
 import {
   emitWorldDefinition
 } from "./chunk-YPCVY4GS.js";
+import {
+  parseWorldMarkdown
+} from "./chunk-3NZMMSOW.js";
 
 // src/engine/derive-normalizer.ts
 function findSections(lines) {