@neuroverseos/governance 0.6.0 → 0.7.0

package/dist/radiant/index.js

@@ -0,0 +1,90 @@
+import {
+  DEFAULT_EVIDENCE_GATE,
+  DEFAULT_SIGNAL_EXTRACTORS,
+  auditGovernance,
+  checkForbiddenPhrases,
+  classifyActorDomain,
+  classifyEvents,
+  composeSystemPrompt,
+  computePersistence,
+  createAnthropicAI,
+  createMockAI,
+  createMockGitHubAdapter,
+  emergent,
+  extractSignals,
+  fetchGitHubActivity,
+  formatExocortexForPrompt,
+  formatPriorReadsForPrompt,
+  formatScope,
+  interpretPatterns,
+  isPresent,
+  isScored,
+  isSentinel,
+  loadPriorReads,
+  parseRepoScope,
+  presenceAverage,
+  readExocortex,
+  render,
+  scoreComposite,
+  scoreCyber,
+  scoreLife,
+  scoreNeuroVerse,
+  summarizeExocortex,
+  think,
+  updateKnowledge,
+  writeRead
+} from "../chunk-T6EQ7ZBG.js";
+import {
+  LENSES,
+  aukiBuilderLens,
+  getLens,
+  listLenses
+} from "../chunk-VGFDMPVB.js";
+import "../chunk-I4RTIMLX.js";
+import "../chunk-ZAF6JH23.js";
+import "../chunk-QLPTHTVB.js";
+import "../chunk-QWGCMQQD.js";
+
+// src/radiant/index.ts
+var RADIANT_PACKAGE_VERSION = "0.0.0";
+export {
+  DEFAULT_EVIDENCE_GATE,
+  DEFAULT_SIGNAL_EXTRACTORS,
+  LENSES,
+  RADIANT_PACKAGE_VERSION,
+  auditGovernance,
+  aukiBuilderLens,
+  checkForbiddenPhrases,
+  classifyActorDomain,
+  classifyEvents,
+  composeSystemPrompt,
+  computePersistence,
+  createAnthropicAI,
+  createMockAI,
+  createMockGitHubAdapter,
+  emergent,
+  extractSignals,
+  fetchGitHubActivity,
+  formatExocortexForPrompt,
+  formatPriorReadsForPrompt,
+  formatScope,
+  getLens,
+  interpretPatterns,
+  isPresent,
+  isScored,
+  isSentinel,
+  listLenses,
+  loadPriorReads,
+  parseRepoScope,
+  presenceAverage,
+  readExocortex,
+  render,
+  scoreComposite,
+  scoreCyber,
+  scoreLife,
+  scoreNeuroVerse,
+  summarizeExocortex,
+  think,
+  updateKnowledge,
+  writeRead
+};

package/dist/server-BXMC5NOE.js

@@ -0,0 +1,271 @@
+import {
+  createAnthropicAI,
+  emergent,
+  parseRepoScope,
+  think
+} from "./chunk-T6EQ7ZBG.js";
+import "./chunk-VGFDMPVB.js";
+import "./chunk-I4RTIMLX.js";
+import "./chunk-ZAF6JH23.js";
+import "./chunk-QLPTHTVB.js";
+import "./chunk-QWGCMQQD.js";
+
+// src/radiant/mcp/server.ts
+import { readFileSync, readdirSync, statSync, existsSync } from "fs";
+import { resolve, join, extname } from "path";
+var TOOLS = [
+  {
+    name: "radiant_think",
+    description: "Send a query through the loaded worldmodel + rendering lens and get an Auki-framed response. Use this for strategic questions, decision evaluation, or any question that should be interpreted through the organization's behavioral model.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "The question or prompt to interpret through the worldmodel + lens."
+        }
+      },
+      required: ["query"]
+    }
+  },
+  {
+    name: "radiant_emergent",
+    description: "Run a behavioral read on a GitHub repository. Fetches recent activity, classifies events, extracts signals, identifies patterns, computes alignment scores, and produces the EMERGENT / MEANING / MOVE / ALIGNMENT output. Use this when asked about team activity, coordination patterns, or alignment with the worldmodel.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        scope: {
+          type: "string",
+          description: 'GitHub repository in "owner/repo" format (e.g. "aukiverse/posemesh").'
+        },
+        exocortex_dir: {
+          type: "string",
+          description: "Optional path to an exocortex directory for stated-intent-vs-observed-behavior comparison."
+        }
+      },
+      required: ["scope"]
+    }
+  }
+];
+var RadiantMcpServer = class {
+  config;
+  worldmodelContent;
+  buffer = "";
+  constructor(config) {
+    this.config = config;
+    this.worldmodelContent = loadWorldmodelContent(config.worldsPath);
+  }
+  async start() {
+    process.stderr.write(
+      `Radiant MCP server starting
+  Worlds: ${this.config.worldsPath}
+  Lens:   ${this.config.lensId}
+  Tools:  radiant_think, radiant_emergent
+`
+    );
+    process.stdin.setEncoding("utf-8");
+    process.stdin.on("data", (chunk) => {
+      this.buffer += chunk;
+      this.processBuffer();
+    });
+    process.stdin.on("end", () => {
+      process.exit(0);
+    });
+  }
+  processBuffer() {
+    const lines = this.buffer.split("\n");
+    this.buffer = lines.pop() ?? "";
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        const request = JSON.parse(trimmed);
+        this.handleRequest(request).catch((err) => {
+          this.sendError(request.id, -32603, String(err));
+        });
+      } catch {
+      }
+    }
+  }
+  async handleRequest(req) {
+    switch (req.method) {
+      case "initialize":
+        this.sendResult(req.id, {
+          protocolVersion: "2024-11-05",
+          capabilities: { tools: {} },
+          serverInfo: {
+            name: "radiant",
+            version: "0.6.1"
+          }
+        });
+        break;
+      case "notifications/initialized":
+        break;
+      case "tools/list":
+        this.sendResult(req.id, { tools: TOOLS });
+        break;
+      case "tools/call":
+        await this.handleToolCall(req);
+        break;
+      default:
+        this.sendError(req.id, -32601, `Unknown method: ${req.method}`);
+    }
+  }
+  async handleToolCall(req) {
+    const params = req.params;
+    if (!params?.name) {
+      this.sendError(req.id, -32602, "Missing tool name");
+      return;
+    }
+    const args = params.arguments ?? {};
+    try {
+      switch (params.name) {
+        case "radiant_think":
+          await this.handleThink(req.id, args);
+          break;
+        case "radiant_emergent":
+          await this.handleEmergent(req.id, args);
+          break;
+        default:
+          this.sendError(req.id, -32602, `Unknown tool: ${params.name}`);
+      }
+    } catch (err) {
+      this.sendResult(req.id, {
+        content: [{ type: "text", text: `Error: ${err}` }],
+        isError: true
+      });
+    }
+  }
+  async handleThink(id, args) {
+    const query = String(args.query ?? "");
+    if (!query) {
+      this.sendResult(id, {
+        content: [{ type: "text", text: "Error: query is required" }],
+        isError: true
+      });
+      return;
+    }
+    const apiKey = process.env.ANTHROPIC_API_KEY;
+    if (!apiKey) {
+      this.sendResult(id, {
+        content: [{ type: "text", text: "Error: ANTHROPIC_API_KEY not set" }],
+        isError: true
+      });
+      return;
+    }
+    const ai = createAnthropicAI(apiKey, this.config.model || void 0);
+    const result = await think({
+      worldmodelContent: this.worldmodelContent,
+      lensId: this.config.lensId,
+      query,
+      ai
+    });
+    let text = result.response;
+    if (!result.voiceClean) {
+      text += `
+
+\u26A0 Voice violations detected: ${result.voiceViolations.map((v) => v.phrase).join(", ")}`;
+    }
+    this.sendResult(id, {
+      content: [{ type: "text", text }]
+    });
+  }
+  async handleEmergent(id, args) {
+    const scopeStr = String(args.scope ?? "");
+    if (!scopeStr) {
+      this.sendResult(id, {
+        content: [{ type: "text", text: 'Error: scope is required (e.g. "aukiverse/posemesh")' }],
+        isError: true
+      });
+      return;
+    }
+    const apiKey = process.env.ANTHROPIC_API_KEY;
+    const githubToken = process.env.GITHUB_TOKEN;
+    if (!apiKey) {
+      this.sendResult(id, {
+        content: [{ type: "text", text: "Error: ANTHROPIC_API_KEY not set" }],
+        isError: true
+      });
+      return;
+    }
+    if (!githubToken) {
+      this.sendResult(id, {
+        content: [{ type: "text", text: "Error: GITHUB_TOKEN not set" }],
+        isError: true
+      });
+      return;
+    }
+    const scope = parseRepoScope(scopeStr);
+    const ai = createAnthropicAI(apiKey, this.config.model || void 0);
+    const exocortexPath = args.exocortex_dir ? String(args.exocortex_dir) : void 0;
+    const result = await emergent({
+      scope,
+      githubToken,
+      worldmodelContent: this.worldmodelContent,
+      lensId: this.config.lensId,
+      ai,
+      windowDays: 14,
+      exocortexPath
+    });
+    let text = result.text;
+    if (!result.voiceClean) {
+      text += `
+
+\u26A0 Voice violations: ${result.voiceViolations.map((v) => v.phrase).join(", ")}`;
+    }
+    this.sendResult(id, {
+      content: [{ type: "text", text }]
+    });
+  }
+  sendResult(id, result) {
+    const response = { jsonrpc: "2.0", id, result };
+    process.stdout.write(JSON.stringify(response) + "\n");
+  }
+  sendError(id, code, message) {
+    const response = {
+      jsonrpc: "2.0",
+      id: id ?? null,
+      error: { code, message }
+    };
+    process.stdout.write(JSON.stringify(response) + "\n");
+  }
+};
+function loadWorldmodelContent(worldsPath) {
+  const resolved = resolve(worldsPath);
+  if (!existsSync(resolved)) {
+    throw new Error(`Worlds path not found: ${resolved}`);
+  }
+  const stat = statSync(resolved);
+  if (stat.isFile()) {
+    return readFileSync(resolved, "utf-8");
+  }
+  if (stat.isDirectory()) {
+    const files = readdirSync(resolved).filter(
+      (f) => extname(f) === ".md" && (f.endsWith(".worldmodel.md") || f.endsWith(".nv-world.md"))
+    ).sort();
+    if (files.length === 0) {
+      throw new Error(`No worldmodel files found in ${resolved}`);
+    }
+    return files.map((f) => readFileSync(join(resolved, f), "utf-8")).join("\n\n---\n\n");
+  }
+  throw new Error(`Worlds path is neither a file nor directory: ${resolved}`);
+}
+async function startRadiantMcp(args) {
+  function parseArg(flag) {
+    const idx = args.indexOf(flag);
+    return idx >= 0 && idx + 1 < args.length ? args[idx + 1] : void 0;
+  }
+  const worldsPath = parseArg("--worlds") ?? process.env.RADIANT_WORLDS;
+  const lensId = parseArg("--lens") ?? process.env.RADIANT_LENS ?? "auki-builder";
+  const model = parseArg("--model") ?? process.env.RADIANT_MODEL;
+  if (!worldsPath) {
+    process.stderr.write("Error: --worlds <dir> or RADIANT_WORLDS required.\n");
+    process.exit(1);
+  }
+  const server = new RadiantMcpServer({ worldsPath, lensId, model });
+  await server.start();
+}
+export {
+  RadiantMcpServer,
+  startRadiantMcp
+};

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

@@ -1,19 +1,20 @@
 ---
 world_id: behavioral-demo
-name: Behavioral Demo
-version: 1.0.0
+name: Behavioral Governance Runtime
+version: 2.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.
+Behavior should be interpreted through repeated action, clarity of ownership, and consistency between stated intent and follow-through. Decisions are governed by observed alignment, not stated confidence. When the system must choose — ship, delay, or escalate — it reads behavior, not promises.
 
 # 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)
+- `decisions_follow_alignment` — Decisions must reflect measured alignment, not declared readiness (structural, immutable)
 
 # State
 
@@ -44,6 +45,13 @@ Behavior should be interpreted through repeated action, clarity of ownership, an
 - label: Alignment Score
 - description: Measures consistency between stated priorities and actual behavior
 
+## decision
+- type: enum
+- options: no_decision, ship_now, delay, escalate
+- default: no_decision
+- label: Decision
+- description: Governed output — what the system recommends based on behavioral alignment
+
 # Assumptions
 
 ## baseline
@@ -92,6 +100,39 @@ Then alignment_score *= 1.10
 > shift: Interpretation becomes more confident.
 > effect: Alignment score improves.
 
+## rule-004: alignment supports shipping (advantage)
+Strong alignment produces a ship decision.
+
+When alignment_score >= 75 [state]
+Then decision = "ship_now"
+
+> trigger: Behavioral alignment is strong enough to act.
+> rule: When actions match intent consistently, the system recommends execution.
+> shift: Decision moves to ship.
+> effect: Decision set to ship_now.
+
+## rule-005: ambiguity requires delay (degradation)
+Moderate alignment produces a delay decision.
+
+When alignment_score < 75 [state] AND alignment_score >= 45 [state]
+Then decision = "delay"
+
+> trigger: Alignment is uncertain — behavior and intent are not fully consistent.
+> rule: When signals are mixed, the system recommends waiting for clarity.
+> shift: Decision moves to delay.
+> effect: Decision set to delay.
+
+## rule-006: misalignment triggers escalation (structural)
+Weak alignment produces an escalate decision.
+
+When alignment_score < 45 [state]
+Then decision = "escalate"
+
+> trigger: Behavioral alignment has degraded below acceptable threshold.
+> rule: When actions consistently contradict stated intent, the system escalates.
+> shift: Decision moves to escalate.
+> effect: Decision set to escalate.
+
 # Gates
 
 - STRONG: alignment_score >= 85
@@ -109,6 +150,12 @@ Then alignment_score *= 1.10
 - label: Alignment Score
 - primary: true
 
+## decision
+- type: enum
+- range: ship_now, delay, escalate, no_decision
+- display: label
+- label: Decision
+
 # Lenses
 - policy: role_default
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neuroverseos/governance",
-  "version": "0.6.0",
+  "version": "0.7.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",
@@ -97,6 +97,11 @@
       "types": "./dist/admin/index.d.ts",
       "import": "./dist/admin/index.js",
       "require": "./dist/admin/index.cjs"
+    },
+    "./radiant": {
+      "types": "./dist/radiant/index.d.ts",
+      "import": "./dist/radiant/index.js",
+      "require": "./dist/radiant/index.cjs"
     }
   },
   "bin": {
@@ -119,7 +124,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/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": "tsup src/index.ts src/types.ts src/cli/neuroverse.ts src/cli/plan.ts src/cli/run.ts src/cli/worldmodel.ts src/cli/radiant.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 src/radiant/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/{chunk-735Z3HA4.js → chunk-FHXXD2TI.js}

@@ -1,9 +1,9 @@
-import {
-  loadConfig
-} from "./chunk-OT6PXH54.js";
 import {
   createProvider
 } from "./chunk-INWQHLPS.js";
+import {
+  loadConfig
+} from "./chunk-OT6PXH54.js";
 import {
   validateWorld
 } from "./chunk-7P3S7MAY.js";

package/dist/{configure-ai-5MP5DWTT.js → configure-ai-LL3VAPQW.js}

@@ -1,15 +1,15 @@
 import {
   CONFIGURE_AI_EXIT_CODES
 } from "./chunk-FMSTRBBS.js";
+import {
+  createProvider
+} from "./chunk-INWQHLPS.js";
 import {
   getConfigPath,
   loadConfig,
   redactConfig,
   saveConfig
 } from "./chunk-OT6PXH54.js";
-import {
-  createProvider
-} from "./chunk-INWQHLPS.js";
 import "./chunk-QWGCMQQD.js";
 
 // src/cli/configure-ai.ts