@neuroverseos/governance 0.3.0 → 0.3.3

package/dist/{chunk-PDOZHZWL.js → chunk-TG6SEF24.js}

@@ -1,6 +1,6 @@
 import {
   readAuditLog
-} from "./chunk-QPASI2BR.js";
+} from "./chunk-A7GKPPU7.js";
 
 // src/engine/impact-report.ts
 function generateImpactReport(events) {
@@ -9,7 +9,11 @@ function generateImpactReport(events) {
   }
   const blocked = events.filter((e) => e.decision === "BLOCK");
   const paused = events.filter((e) => e.decision === "PAUSE");
-  const prevented = [...blocked, ...paused];
+  const modified = events.filter((e) => e.decision === "MODIFY");
+  const penalized = events.filter((e) => e.decision === "PENALIZE");
+  const rewarded = events.filter((e) => e.decision === "REWARD");
+  const neutralEvents = events.filter((e) => e.decision === "NEUTRAL");
+  const prevented = [...blocked, ...paused, ...modified, ...penalized];
   const categoryMap = /* @__PURE__ */ new Map();
   for (const e of prevented) {
     const cat = classifyPreventionCategory(e);
@@ -94,6 +98,8 @@ function generateImpactReport(events) {
     violationMap.set(key, entry);
   }
   const repeatViolations = [...violationMap.values()].filter((v) => v.attempts > 1).sort((a, b) => b.attempts - a.attempts).slice(0, 10);
+  const allowedCount = events.filter((e) => e.decision === "ALLOW").length;
+  const redirected = events.length - allowedCount - neutralEvents.length;
   return {
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     periodStart: events[0].timestamp,
@@ -102,8 +108,13 @@ function generateImpactReport(events) {
     totalEvaluations: events.length,
     totalBlocked: blocked.length,
     totalPaused: paused.length,
-    totalAllowed: events.length - blocked.length - paused.length,
-    preventionRate: prevented.length / events.length,
+    totalAllowed: allowedCount,
+    totalModified: modified.length,
+    totalPenalized: penalized.length,
+    totalRewarded: rewarded.length,
+    totalNeutral: neutralEvents.length,
+    preventionRate: events.length > 0 ? prevented.length / events.length : 0,
+    redirectionRate: events.length > 0 ? redirected / events.length : 0,
     preventedByCategory,
     topPreventedIntents,
     hotActors,
@@ -142,8 +153,13 @@ function renderImpactReport(report) {
   lines.push(`  Total evaluations:   ${report.totalEvaluations}`);
   lines.push(`  Allowed:             ${report.totalAllowed}`);
   lines.push(`  Blocked:             ${report.totalBlocked}`);
+  lines.push(`  Modified:            ${report.totalModified}`);
   lines.push(`  Paused:              ${report.totalPaused}`);
+  lines.push(`  Penalized:           ${report.totalPenalized}`);
+  lines.push(`  Rewarded:            ${report.totalRewarded}`);
+  lines.push(`  Neutral:             ${report.totalNeutral}`);
   lines.push(`  Prevention rate:     ${(report.preventionRate * 100).toFixed(1)}%`);
+  lines.push(`  Redirection rate:    ${(report.redirectionRate * 100).toFixed(1)}%`);
   lines.push("");
   if (report.totalBlocked > 0 || report.totalPaused > 0) {
     lines.push("WITHOUT GOVERNANCE");
@@ -208,7 +224,12 @@ function emptyReport() {
     totalBlocked: 0,
     totalPaused: 0,
     totalAllowed: 0,
+    totalModified: 0,
+    totalPenalized: 0,
+    totalRewarded: 0,
+    totalNeutral: 0,
     preventionRate: 0,
+    redirectionRate: 0,
     preventedByCategory: [],
     topPreventedIntents: [],
     hotActors: [],

package/dist/chunk-U6U7EJZL.js

@@ -0,0 +1,177 @@
+import {
+  evaluateGuard
+} from "./chunk-W7LLXRGY.js";
+import {
+  loadWorld
+} from "./chunk-CTZHONLA.js";
+
+// src/runtime/govern.ts
+function actionToGuardEvent(action) {
+  return {
+    intent: action.description,
+    tool: action.type,
+    roleId: action.agentId,
+    riskLevel: magnitudeToRisk(action.magnitude),
+    args: action.context
+  };
+}
+function magnitudeToRisk(magnitude) {
+  if (magnitude === void 0) return void 0;
+  if (magnitude < 0.25) return "low";
+  if (magnitude < 0.5) return "medium";
+  if (magnitude < 0.75) return "high";
+  return "critical";
+}
+function govern(action, world, options) {
+  const event = actionToGuardEvent(action);
+  return evaluateGuard(event, world, options);
+}
+async function createGovernor(config) {
+  const worldPath = config.worldPath;
+  if (!worldPath) {
+    throw new Error("Governor requires a worldPath");
+  }
+  const options = {
+    trace: config.trace,
+    level: config.level
+  };
+  let world = await loadWorld(worldPath);
+  return {
+    evaluate(action) {
+      return govern(action, world, options);
+    },
+    async reload() {
+      world = await loadWorld(worldPath);
+    },
+    get world() {
+      return world;
+    }
+  };
+}
+async function writeTempWorld(dir, policyLines) {
+  const { writeFile, mkdir } = await import("fs/promises");
+  const { join } = await import("path");
+  await mkdir(dir, { recursive: true });
+  const worldJson = {
+    world_id: "demo-live",
+    name: "Live Demo World",
+    thesis: "Interactive governance demo",
+    version: "0.1.0",
+    runtime_mode: "COMPLIANCE",
+    default_assumption_profile: "baseline",
+    default_alternative_profile: "baseline",
+    modules: [],
+    players: { thinking_space: false, experience_space: false, action_space: true }
+  };
+  const forbiddenPatterns = policyLines.filter((line) => line.trim().length > 0).map((line, i) => ({
+    id: `demo-rule-${i + 1}`,
+    pattern: line.trim(),
+    reason: line.trim(),
+    action: "BLOCK"
+  }));
+  const kernelJson = {
+    artifact_type: "kernel",
+    kernel_id: "demo-kernel",
+    version: "0.1.0",
+    domain: "demo",
+    enforcement_level: "standard",
+    input_boundaries: { forbidden_patterns: forbiddenPatterns },
+    output_boundaries: { forbidden_patterns: [] },
+    response_vocabulary: {},
+    metadata: {
+      compiled_by: "neuroverse-demo",
+      compiled_at: (/* @__PURE__ */ new Date()).toISOString(),
+      source_hash: "live-edit",
+      compiler_version: "0.2.2"
+    }
+  };
+  const metadataJson = {
+    format_version: "1.0.0",
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    last_modified: (/* @__PURE__ */ new Date()).toISOString(),
+    authoring_method: "manual-authoring"
+  };
+  await Promise.all([
+    writeFile(join(dir, "world.json"), JSON.stringify(worldJson, null, 2)),
+    writeFile(join(dir, "kernel.json"), JSON.stringify(kernelJson, null, 2)),
+    writeFile(join(dir, "metadata.json"), JSON.stringify(metadataJson, null, 2))
+  ]);
+}
+
+// src/engine/api.ts
+function handleHealthCheck() {
+  return {
+    status: "ok",
+    engine: "@neuroverseos/governance",
+    version: "0.2.2",
+    capabilities: [
+      "guard",
+      "simulate",
+      "validate",
+      "bootstrap",
+      "decision-flow",
+      "impact-report",
+      "behavioral-analysis"
+    ]
+  };
+}
+async function handleListPresets(policiesDir) {
+  const { readdir, readFile } = await import("fs/promises");
+  const { join } = await import("path");
+  const dir = policiesDir ?? join(process.cwd(), "policies");
+  const presets = [];
+  try {
+    const files = await readdir(dir);
+    for (const file of files.filter((f) => f.endsWith(".txt")).sort()) {
+      const content = await readFile(join(dir, file), "utf-8");
+      const id = file.replace(".txt", "");
+      const name = id.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+      const firstLine = content.split("\n").find((l) => l.trim().length > 0) ?? "";
+      presets.push({ id, name, description: firstLine, rules: content });
+    }
+  } catch {
+  }
+  return { presets };
+}
+async function handleReasonRequest(body) {
+  const intent = body.intent ?? body.scenario;
+  if (!intent) {
+    return { status: "error", error: "intent or scenario is required" };
+  }
+  const event = {
+    intent,
+    tool: body.tool,
+    roleId: body.roleId
+  };
+  if (body.worldPath) {
+    try {
+      const world = await loadWorld(body.worldPath);
+      const verdict = evaluateGuard(event, world);
+      return { status: "ok", verdict };
+    } catch (err) {
+      return { status: "error", error: `Failed to load world: ${err}` };
+    }
+  }
+  return { status: "error", error: "worldPath is required" };
+}
+function handleCreateCapsule(body) {
+  const capsuleId = `cap_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+  return {
+    capsuleId,
+    scenario: body.scenario ?? "Untitled scenario",
+    rules: body.rules ?? [],
+    events: body.events ?? [],
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
+export {
+  actionToGuardEvent,
+  govern,
+  createGovernor,
+  writeTempWorld,
+  handleHealthCheck,
+  handleListPresets,
+  handleReasonRequest,
+  handleCreateCapsule
+};

package/dist/{chunk-4JRYGIO7.js → chunk-W7LLXRGY.js}

@@ -1,7 +1,9 @@
 import {
   buildPlanCheck,
-  evaluatePlan
-} from "./chunk-4QXB6PEO.js";
+  evaluatePlan,
+  matchesAllKeywords,
+  normalizeEventText
+} from "./chunk-QLPTHTVB.js";
 
 // src/engine/guard-engine.ts
 var PROMPT_INJECTION_PATTERNS = [
@@ -87,11 +89,49 @@ function isExternalScope(scope) {
   ];
   return !internalPatterns.some((p) => p.test(scope));
 }
+var MAX_INPUT_LENGTH = 1e5;
 function evaluateGuard(event, world, options = {}) {
   const startTime = performance.now();
   const level = options.level ?? "standard";
   const includeTrace = options.trace ?? false;
-  const eventText = (event.intent + " " + (event.tool ?? "") + " " + (event.scope ?? "")).toLowerCase();
+  if (!event.intent || typeof event.intent !== "string") {
+    return {
+      status: "BLOCK",
+      reason: "GuardEvent.intent is required and must be a string",
+      ruleId: "safety-input-validation",
+      evidence: {
+        worldId: world.world?.world_id ?? "",
+        worldName: world.world?.name ?? "",
+        worldVersion: world.world?.version ?? "",
+        evaluatedAt: Date.now(),
+        invariantsSatisfied: 0,
+        invariantsTotal: 0,
+        guardsMatched: [],
+        rulesMatched: [],
+        enforcementLevel: level
+      }
+    };
+  }
+  const inputLength = event.intent.length + (event.tool?.length ?? 0) + (event.scope?.length ?? 0) + (event.payload ? JSON.stringify(event.payload).length : 0);
+  if (inputLength > MAX_INPUT_LENGTH) {
+    return {
+      status: "BLOCK",
+      reason: `Input exceeds maximum allowed length (${MAX_INPUT_LENGTH} characters)`,
+      ruleId: "safety-input-length",
+      evidence: {
+        worldId: world.world?.world_id ?? "",
+        worldName: world.world?.name ?? "",
+        worldVersion: world.world?.version ?? "",
+        evaluatedAt: Date.now(),
+        invariantsSatisfied: 0,
+        invariantsTotal: 0,
+        guardsMatched: [],
+        rulesMatched: [],
+        enforcementLevel: level
+      }
+    };
+  }
+  const eventText = normalizeEventText(event);
   const invariantChecks = [];
   const safetyChecks = [];
   let planCheckResult;
@@ -104,6 +144,43 @@ function evaluateGuard(event, world, options = {}) {
   const guardsMatched = [];
   const rulesMatched = [];
   checkInvariantCoverage(world, invariantChecks);
+  if (event.roleId && options.agentStates) {
+    const agentState = options.agentStates.get(event.roleId);
+    if (agentState && agentState.cooldownRemaining > 0) {
+      decidingLayer = "safety";
+      decidingId = `penalize-cooldown-${event.roleId}`;
+      const verdict = buildVerdict(
+        "PENALIZE",
+        `Agent "${event.roleId}" is frozen for ${agentState.cooldownRemaining} more round(s) due to prior penalty.`,
+        `penalize-cooldown-${event.roleId}`,
+        void 0,
+        world,
+        level,
+        invariantChecks,
+        guardsMatched,
+        rulesMatched,
+        includeTrace ? buildTrace(
+          invariantChecks,
+          safetyChecks,
+          planCheckResult,
+          roleChecks,
+          guardChecks,
+          kernelRuleChecks,
+          levelChecks,
+          decidingLayer,
+          decidingId,
+          startTime
+        ) : void 0
+      );
+      verdict.intentRecord = {
+        originalIntent: event.intent,
+        finalAction: "blocked (agent frozen)",
+        enforcement: "PENALIZE",
+        consequence: { type: "freeze", rounds: agentState.cooldownRemaining, description: "Agent still in cooldown from prior penalty" }
+      };
+      return verdict;
+    }
+  }
   if (options.sessionAllowlist) {
     const key = eventToAllowlistKey(event);
     if (options.sessionAllowlist.has(key)) {
@@ -231,7 +308,16 @@ function evaluateGuard(event, world, options = {}) {
     if (guardVerdict.status !== "ALLOW") {
       decidingLayer = "guard";
       decidingId = guardVerdict.ruleId;
-      return buildVerdict(
+      const intentRecord = {
+        originalIntent: event.intent,
+        finalAction: guardVerdict.status === "MODIFY" ? guardVerdict.modifiedTo ?? "modified" : guardVerdict.status === "PENALIZE" ? "blocked + penalized" : guardVerdict.status === "REWARD" ? event.intent : guardVerdict.status === "NEUTRAL" ? event.intent : guardVerdict.status === "BLOCK" ? "blocked" : "paused",
+        ruleApplied: guardVerdict.ruleId,
+        enforcement: guardVerdict.status,
+        modifiedTo: guardVerdict.modifiedTo,
+        consequence: guardVerdict.consequence,
+        reward: guardVerdict.reward
+      };
+      const verdict = buildVerdict(
         guardVerdict.status,
         guardVerdict.reason,
         guardVerdict.ruleId,
@@ -254,6 +340,10 @@ function evaluateGuard(event, world, options = {}) {
           startTime
         ) : void 0
       );
+      verdict.intentRecord = intentRecord;
+      if (guardVerdict.consequence) verdict.consequence = guardVerdict.consequence;
+      if (guardVerdict.reward) verdict.reward = guardVerdict.reward;
+      return verdict;
     }
   }
   const kernelVerdict = checkKernelRules(eventText, world, kernelRuleChecks, rulesMatched);
@@ -548,6 +638,21 @@ function checkGuards(event, eventText, world, checks, guardsMatched) {
     if (actionMode === "pause") {
       return { status: "PAUSE", reason, ruleId: `guard-${guard.id}` };
     }
+    if (actionMode === "penalize") {
+      const consequence = guard.consequence ? { ...guard.consequence } : { type: "freeze", rounds: 1, description: `Penalized for violating: ${guard.label}` };
+      return { status: "PENALIZE", reason, ruleId: `guard-${guard.id}`, consequence };
+    }
+    if (actionMode === "reward") {
+      const reward = guard.reward ? { ...guard.reward } : { type: "boost_influence", magnitude: 0.1, description: `Rewarded for: ${guard.label}` };
+      return { status: "REWARD", reason, ruleId: `guard-${guard.id}`, reward };
+    }
+    if (actionMode === "modify") {
+      const modifiedTo = guard.modify_to ?? guard.redirect ?? "hold";
+      return { status: "MODIFY", reason: `${reason} \u2192 Modified to: ${modifiedTo}`, ruleId: `guard-${guard.id}`, modifiedTo };
+    }
+    if (actionMode === "neutral") {
+      return { status: "NEUTRAL", reason, ruleId: `guard-${guard.id}` };
+    }
     if (actionMode === "warn" && !warnResult) {
       warnResult = { status: "ALLOW", warning: reason, ruleId: `guard-${guard.id}` };
     }
@@ -657,9 +762,7 @@ function checkLevelConstraints(event, level, checks) {
   return null;
 }
 function matchesKeywords(eventText, ruleText) {
-  const keywords = ruleText.toLowerCase().split(/\s+/).filter((w) => w.length > 3);
-  if (keywords.length === 0) return false;
-  return keywords.every((kw) => eventText.includes(kw));
+  return matchesAllKeywords(eventText, ruleText);
 }
 function eventToAllowlistKey(event) {
   return `${(event.tool ?? "*").toLowerCase()}::${event.intent.toLowerCase().trim()}`;

package/dist/{chunk-BUWWN2NX.js → chunk-ZJTDUCC2.js}

@@ -1,3 +1,12 @@
+// src/engine/rule-utils.ts
+function collectAllEffects(rule) {
+  const effects = [...rule.effects ?? []];
+  for (const ce of rule.effects_conditional ?? []) {
+    effects.push(...ce.effects);
+  }
+  return effects;
+}
+
 // src/engine/explain-engine.ts
 function detectTensions(rules) {
   const increases = /* @__PURE__ */ new Map();
@@ -31,13 +40,6 @@ function detectTensions(rules) {
   }
   return tensions;
 }
-function collectAllEffects(rule) {
-  const effects = [...rule.effects ?? []];
-  for (const ce of rule.effects_conditional ?? []) {
-    effects.push(...ce.effects);
-  }
-  return effects;
-}
 function explainWorld(world) {
   const dynamics = [...world.rules].sort((a, b) => a.order - b.order).map((rule) => {
     const allEffects = collectAllEffects(rule);

package/dist/{chunk-FYS2CBUW.js → chunk-ZWI3NIXK.js}

@@ -1,8 +1,18 @@
 // src/engine/simulate-engine.ts
 function simulateWorld(world, options = {}) {
+  if (!world || !world.world) {
+    throw new Error(
+      'World definition required. simulateWorld() cannot run without a world.\nLoad one with: loadWorld("./world/") or parseWorldMarkdown(markdown)'
+    );
+  }
   const steps = Math.max(1, Math.min(options.steps ?? 1, 50));
   const profileName = options.profile ?? world.world.default_assumption_profile;
   const state = buildInitialState(world.stateSchema, options.stateOverrides);
+  for (const outcome of world.outcomes?.computed_outcomes ?? []) {
+    if (!(outcome.id in state)) {
+      state[outcome.id] = outcome.primary ? 100 : 0;
+    }
+  }
   const assumptions = resolveAssumptions(world.assumptions, profileName);
   const initialState = { ...state };
   const simulationSteps = [];