@neuroverseos/governance 0.1.0 → 0.1.2

package/dist/world-WLNHL5XC.js

@@ -0,0 +1,298 @@
+import {
+  loadWorld
+} from "./chunk-M3TZFGHO.js";
+import {
+  validateWorld
+} from "./chunk-O5OMJMIE.js";
+
+// src/cli/world.ts
+var USAGE = `
+neuroverse world \u2014 World management
+
+Usage:
+  neuroverse world status <path>           Show world identity and health
+  neuroverse world diff <path1> <path2>    Compare two world versions
+  neuroverse world snapshot <path>         Save a timestamped snapshot
+  neuroverse world rollback <path>         Restore the previous snapshot
+
+Options:
+  --json    Output as JSON
+`.trim();
+function parseArgs(argv) {
+  const subcommand = argv[0];
+  const paths = [];
+  const flags = {};
+  for (let i = 1; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--json") flags.json = true;
+    else if (arg === "--help" || arg === "-h") flags.help = true;
+    else paths.push(arg);
+  }
+  return { subcommand, paths, flags };
+}
+async function worldStatus(worldPath, json) {
+  const world = await loadWorld(worldPath);
+  const report = validateWorld(world);
+  if (json) {
+    process.stdout.write(JSON.stringify({
+      world: world.world,
+      metadata: world.metadata,
+      guards: world.guards?.guards.length ?? 0,
+      invariants: world.invariants.length,
+      rules: world.rules.length,
+      roles: world.roles?.roles.length ?? 0,
+      kernel: world.kernel ? {
+        allowedInputs: world.kernel.allowed_inputs?.length ?? 0,
+        forbiddenInputs: world.kernel.forbidden_inputs?.length ?? 0,
+        allowedOutputs: world.kernel.allowed_outputs?.length ?? 0,
+        forbiddenOutputs: world.kernel.forbidden_outputs?.length ?? 0
+      } : null,
+      validation: report.summary
+    }, null, 2) + "\n");
+    return;
+  }
+  const lines = [];
+  lines.push("WORLD STATUS");
+  lines.push("\u2500".repeat(40));
+  lines.push(`  Name:       ${world.world.name}`);
+  lines.push(`  ID:         ${world.world.id}`);
+  lines.push(`  Version:    ${world.world.version}`);
+  lines.push(`  Created:    ${world.metadata.created_at || "\u2014"}`);
+  lines.push(`  Modified:   ${world.metadata.last_modified || "\u2014"}`);
+  lines.push(`  Authoring:  ${world.metadata.authoring_method}`);
+  lines.push("");
+  lines.push("COMPONENTS");
+  lines.push("\u2500".repeat(40));
+  lines.push(`  Invariants:  ${world.invariants.length}`);
+  lines.push(`  Guards:      ${world.guards?.guards.length ?? 0}`);
+  lines.push(`  Rules:       ${world.rules.length}`);
+  lines.push(`  Roles:       ${world.roles?.roles.length ?? 0}`);
+  if (world.kernel) {
+    const k = world.kernel;
+    const totalRules = (k.allowed_inputs?.length ?? 0) + (k.forbidden_inputs?.length ?? 0) + (k.allowed_outputs?.length ?? 0) + (k.forbidden_outputs?.length ?? 0);
+    lines.push(`  Kernel:      ${totalRules} rules`);
+  }
+  lines.push("");
+  lines.push("HEALTH");
+  lines.push("\u2500".repeat(40));
+  const sev = report.summary;
+  const healthIcon = sev.errors === 0 && sev.warnings === 0 ? "HEALTHY" : sev.errors > 0 ? "ISSUES FOUND" : "WARNINGS";
+  lines.push(`  Status:    ${healthIcon}`);
+  lines.push(`  Errors:    ${sev.errors}`);
+  lines.push(`  Warnings:  ${sev.warnings}`);
+  lines.push(`  Info:      ${sev.info}`);
+  if (report.findings.length > 0) {
+    lines.push("");
+    lines.push("  Top findings:");
+    for (const f of report.findings.slice(0, 5)) {
+      const icon = f.severity === "error" ? "!" : f.severity === "warning" ? "?" : "-";
+      lines.push(`    [${icon}] ${f.message}`);
+    }
+  }
+  process.stdout.write(lines.join("\n") + "\n");
+}
+async function worldDiff(path1, path2, json) {
+  const world1 = await loadWorld(path1);
+  const world2 = await loadWorld(path2);
+  const diff = computeWorldDiff(world1, world2);
+  if (json) {
+    process.stdout.write(JSON.stringify(diff, null, 2) + "\n");
+    return;
+  }
+  const lines = [];
+  lines.push("WORLD DIFF");
+  lines.push("\u2550".repeat(50));
+  lines.push(`  A: ${world1.world.name} v${world1.world.version}`);
+  lines.push(`  B: ${world2.world.name} v${world2.world.version}`);
+  lines.push("");
+  for (const change of diff.changes) {
+    const icon = change.type === "added" ? "+" : change.type === "removed" ? "-" : "~";
+    lines.push(`  [${icon}] ${change.component}: ${change.description}`);
+  }
+  if (diff.changes.length === 0) {
+    lines.push("  No differences found.");
+  }
+  process.stdout.write(lines.join("\n") + "\n");
+}
+function computeWorldDiff(a, b) {
+  const changes = [];
+  if (a.world.version !== b.world.version) {
+    changes.push({ type: "changed", component: "version", description: `${a.world.version} \u2192 ${b.world.version}` });
+  }
+  const aInvIds = new Set(a.invariants.map((i) => i.id));
+  const bInvIds = new Set(b.invariants.map((i) => i.id));
+  for (const id of bInvIds) {
+    if (!aInvIds.has(id)) changes.push({ type: "added", component: "invariant", description: id });
+  }
+  for (const id of aInvIds) {
+    if (!bInvIds.has(id)) changes.push({ type: "removed", component: "invariant", description: id });
+  }
+  const aGuardIds = new Set((a.guards?.guards ?? []).map((g) => g.id));
+  const bGuardIds = new Set((b.guards?.guards ?? []).map((g) => g.id));
+  for (const id of bGuardIds) {
+    if (!aGuardIds.has(id)) changes.push({ type: "added", component: "guard", description: id });
+  }
+  for (const id of aGuardIds) {
+    if (!bGuardIds.has(id)) changes.push({ type: "removed", component: "guard", description: id });
+  }
+  const aRuleIds = new Set(a.rules.map((r) => r.id));
+  const bRuleIds = new Set(b.rules.map((r) => r.id));
+  for (const id of bRuleIds) {
+    if (!aRuleIds.has(id)) changes.push({ type: "added", component: "rule", description: id });
+  }
+  for (const id of aRuleIds) {
+    if (!bRuleIds.has(id)) changes.push({ type: "removed", component: "rule", description: id });
+  }
+  const aRoleIds = new Set((a.roles?.roles ?? []).map((r) => r.id));
+  const bRoleIds = new Set((b.roles?.roles ?? []).map((r) => r.id));
+  for (const id of bRoleIds) {
+    if (!aRoleIds.has(id)) changes.push({ type: "added", component: "role", description: id });
+  }
+  for (const id of aRoleIds) {
+    if (!bRoleIds.has(id)) changes.push({ type: "removed", component: "role", description: id });
+  }
+  const aGuardCount = a.guards?.guards.length ?? 0;
+  const bGuardCount = b.guards?.guards.length ?? 0;
+  if (aGuardCount !== bGuardCount && changes.filter((c) => c.component === "guard").length === 0) {
+    changes.push({ type: "changed", component: "guards", description: `${aGuardCount} \u2192 ${bGuardCount}` });
+  }
+  return { changes };
+}
+async function worldSnapshot(worldPath) {
+  const { readdir, readFile, mkdir, writeFile } = await import("fs/promises");
+  const { join } = await import("path");
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
+  const snapshotDir = join(worldPath, ".snapshots", timestamp);
+  await mkdir(snapshotDir, { recursive: true });
+  const files = await readdir(worldPath);
+  let copied = 0;
+  for (const file of files) {
+    if (file.endsWith(".json")) {
+      const content = await readFile(join(worldPath, file), "utf-8");
+      await writeFile(join(snapshotDir, file), content, "utf-8");
+      copied++;
+    }
+  }
+  try {
+    const rulesDir = join(worldPath, "rules");
+    const ruleFiles = await readdir(rulesDir);
+    await mkdir(join(snapshotDir, "rules"), { recursive: true });
+    for (const file of ruleFiles) {
+      if (file.endsWith(".json")) {
+        const content = await readFile(join(rulesDir, file), "utf-8");
+        await writeFile(join(snapshotDir, "rules", file), content, "utf-8");
+        copied++;
+      }
+    }
+  } catch {
+  }
+  process.stdout.write(`Snapshot saved: ${snapshotDir}
+`);
+  process.stdout.write(`Files: ${copied}
+`);
+}
+async function worldRollback(worldPath) {
+  const { readdir, readFile, writeFile, mkdir } = await import("fs/promises");
+  const { join } = await import("path");
+  const snapshotsDir = join(worldPath, ".snapshots");
+  let snapshots;
+  try {
+    snapshots = (await readdir(snapshotsDir)).sort();
+  } catch {
+    process.stderr.write("No snapshots found. Run `neuroverse world snapshot` first.\n");
+    process.exit(1);
+    return;
+  }
+  if (snapshots.length === 0) {
+    process.stderr.write("No snapshots found. Run `neuroverse world snapshot` first.\n");
+    process.exit(1);
+    return;
+  }
+  const latest = snapshots[snapshots.length - 1];
+  const snapshotDir = join(snapshotsDir, latest);
+  const backupTimestamp = "pre-rollback-" + (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
+  const backupDir = join(snapshotsDir, backupTimestamp);
+  await mkdir(backupDir, { recursive: true });
+  const currentFiles = await readdir(worldPath);
+  for (const file of currentFiles) {
+    if (file.endsWith(".json")) {
+      const content = await readFile(join(worldPath, file), "utf-8");
+      await writeFile(join(backupDir, file), content, "utf-8");
+    }
+  }
+  const snapshotFiles = await readdir(snapshotDir);
+  let restored = 0;
+  for (const file of snapshotFiles) {
+    if (file.endsWith(".json")) {
+      const content = await readFile(join(snapshotDir, file), "utf-8");
+      await writeFile(join(worldPath, file), content, "utf-8");
+      restored++;
+    }
+  }
+  try {
+    const rulesDir = join(snapshotDir, "rules");
+    const ruleFiles = await readdir(rulesDir);
+    await mkdir(join(worldPath, "rules"), { recursive: true });
+    for (const file of ruleFiles) {
+      if (file.endsWith(".json")) {
+        const content = await readFile(join(rulesDir, file), "utf-8");
+        await writeFile(join(worldPath, "rules", file), content, "utf-8");
+        restored++;
+      }
+    }
+  } catch {
+  }
+  process.stdout.write(`Rolled back to: ${latest}
+`);
+  process.stdout.write(`Restored: ${restored} files
+`);
+  process.stdout.write(`Backup saved: ${backupDir}
+`);
+}
+async function main(argv = process.argv.slice(2)) {
+  const { subcommand, paths, flags } = parseArgs(argv);
+  if (flags.help || !subcommand) {
+    process.stdout.write(USAGE + "\n");
+    process.exit(0);
+  }
+  switch (subcommand) {
+    case "status": {
+      if (!paths[0]) {
+        process.stderr.write("Usage: neuroverse world status <path>\n");
+        process.exit(1);
+      }
+      return worldStatus(paths[0], !!flags.json);
+    }
+    case "diff": {
+      if (!paths[0] || !paths[1]) {
+        process.stderr.write("Usage: neuroverse world diff <path1> <path2>\n");
+        process.exit(1);
+      }
+      return worldDiff(paths[0], paths[1], !!flags.json);
+    }
+    case "snapshot": {
+      if (!paths[0]) {
+        process.stderr.write("Usage: neuroverse world snapshot <path>\n");
+        process.exit(1);
+      }
+      return worldSnapshot(paths[0]);
+    }
+    case "rollback": {
+      if (!paths[0]) {
+        process.stderr.write("Usage: neuroverse world rollback <path>\n");
+        process.exit(1);
+      }
+      return worldRollback(paths[0]);
+    }
+    default: {
+      process.stderr.write(`Unknown world subcommand: "${subcommand}"
+
+`);
+      process.stdout.write(USAGE + "\n");
+      process.exit(1);
+    }
+  }
+}
+export {
+  main
+};

package/dist/worlds/derivation-world.nv-world.md

@@ -0,0 +1,278 @@
+---
+world_id: derivationworld
+name: DerivationWorld
+version: 1.0.0
+runtime_mode: synthesis
+default_profile: strict_synthesis
+alternative_profile: permissive_synthesis
+---
+
+# Thesis
+
+AI-synthesized governance documents must be structurally valid, epistemically honest, and deterministically verifiable. A derived .nv-world.md is only legitimate if it satisfies the same parser constraints as a hand-authored world, distinguishes declared facts from inferred claims, and never introduces governance domains beyond the source material.
+
+# Invariants
+
+- `output_must_be_valid_nv_world` — Synthesized output must parse successfully under parseWorldMarkdown with zero errors (prompt, immutable)
+- `must_include_required_sections` — Output must contain Thesis, Invariants, State, Rules, Gates, and Outcomes sections (prompt, immutable)
+- `must_distinguish_declared_vs_inferred` — Invariants derived from explicit source statements must be marked structural; those inferred by the model must be marked operational (prompt, immutable)
+- `must_not_invent_external_domains` — All state variables, rules, and invariants must trace to concepts present in the input markdown (prompt, immutable)
+- `invariants_must_be_enforceable_or_marked` — Every invariant must be structurally enforceable via rules, or explicitly tagged as non-enforceable with rationale (prompt, immutable)
+- `no_json_output` — Output must be .nv-world.md markdown only, never JSON (prompt, immutable)
+- `no_extra_commentary` — Output must contain only the .nv-world.md document, no preamble, explanation, or trailing commentary (prompt, immutable)
+- `frontmatter_must_be_complete` — Output frontmatter must include world_id, name, and version fields (prompt, immutable)
+- `rules_must_have_triggers_and_effects` — Every rule must include a When trigger line and a Then effect line (prompt, immutable)
+- `gate_thresholds_must_be_ordered` — Gate thresholds must be monotonically decreasing from best to worst status (prompt, immutable)
+
+# State
+
+## source_section_count
+- type: number
+- min: 0
+- max: 100
+- step: 1
+- default: 5
+- label: Source Section Count
+- description: Number of distinct sections or files in the input markdown. More sections generally means richer synthesis material.
+
+## source_token_estimate
+- type: number
+- min: 0
+- max: 200000
+- step: 100
+- default: 2000
+- label: Source Token Estimate
+- description: Approximate token count of concatenated input. Determines whether context window constraints may truncate material.
+
+## declared_concept_count
+- type: number
+- min: 0
+- max: 200
+- step: 1
+- default: 10
+- label: Declared Concept Count
+- description: Number of distinct governance concepts explicitly named in source material. Drives state variable and rule generation.
+
+## concept_specificity
+- type: number
+- min: 0
+- max: 100
+- default: 50
+- label: Concept Specificity
+- description: How precisely the source material defines its governance concepts. 0 = vague aspirations. 100 = precise structural claims with measurable criteria.
+
+## domain_coherence
+- type: number
+- min: 0
+- max: 100
+- default: 60
+- label: Domain Coherence
+- description: How well source sections relate to a single governance domain. Low coherence indicates conflicting or unrelated source material.
+
+## synthesis_fidelity
+- type: number
+- min: 0.00
+- max: 1.00
+- step: 0.01
+- default: 0.70
+- label: Synthesis Fidelity
+- description: Measure of how faithfully the derived world represents the source material. Primary outcome metric.
+
+## structural_completeness
+- type: number
+- min: 0
+- max: 100
+- default: 60
+- label: Structural Completeness
+- description: Percentage of required .nv-world.md sections that contain meaningful content rather than stubs.
+
+## epistemic_honesty
+- type: number
+- min: 0
+- max: 100
+- default: 70
+- label: Epistemic Honesty
+- description: Degree to which the output correctly distinguishes source-declared constraints from model-inferred constraints. 0 = everything claimed as declared. 100 = perfect attribution.
+
+## invention_ratio
+- type: number
+- min: 0.00
+- max: 1.00
+- step: 0.01
+- default: 0.10
+- label: Invention Ratio
+- description: Fraction of output concepts that have no traceable origin in the source material. Should be near zero. Above 0.30 indicates hallucination.
+
+# Assumptions
+
+## strict_synthesis
+- name: Strict Synthesis
+- description: Conservative derivation that only produces governance elements with clear source basis. Prefers omission over invention. Marks all inferred elements as operational.
+- invention_tolerance: minimal
+- attribution_mode: strict
+- completeness_priority: low
+- fidelity_priority: high
+
+## permissive_synthesis
+- name: Permissive Synthesis
+- description: Broader derivation that fills structural gaps with reasonable inferences. Produces more complete worlds but with higher invention ratio. All inferences are still marked operational.
+- invention_tolerance: moderate
+- attribution_mode: standard
+- completeness_priority: high
+- fidelity_priority: moderate
+
+# Rules
+
+## rule-001: Empty Source Rejection (structural)
+Synthesis from empty or trivially short input cannot produce meaningful governance. The derivation must fail rather than fabricate.
+
+When source_section_count < 1 [state]
+Then synthesis_fidelity *= 0.00
+Collapse: synthesis_fidelity < 0.05
+
+> trigger: Source input contains no sections — nothing to derive from.
+> rule: A world cannot be synthesized from nothing. Empty input must produce a clear failure, not a fabricated world.
+> shift: Derivation halts. No output file is written.
+> effect: Synthesis fidelity set to zero. Derivation rejected.
+
+## rule-002: Sparse Source Warning (degradation)
+Minimal source material limits the quality of derived governance. Output will be structurally thin.
+
+When source_section_count < 3 [state] AND source_token_estimate < 500 [state]
+Then synthesis_fidelity *= 0.50, structural_completeness *= 0.60
+
+> trigger: Source has fewer than 3 sections and under 500 tokens — sparse material.
+> rule: Sparse input yields sparse governance. The model cannot reliably infer structure from fragments.
+> shift: Output quality degrades. State variables and rules will be minimal.
+> effect: Synthesis fidelity reduced to 50%. Structural completeness reduced to 60%.
+
+## rule-003: Concept Vagueness Penalty (degradation)
+Source material with low concept specificity produces invariants and rules that are aspirational rather than structural.
+
+When concept_specificity < 25 [state]
+Then synthesis_fidelity *= 0.60, epistemic_honesty *= 0.70
+
+> trigger: Source concept specificity below 25% — governance concepts are vague.
+> rule: Vague concepts cannot produce structural invariants. The model must either invent specificity or produce unenforceable constraints.
+> shift: Output invariants trend toward aspiration. Rules lack deterministic triggers.
+> effect: Synthesis fidelity reduced to 60%. Epistemic honesty reduced to 70%.
+
+## rule-004: Domain Incoherence Penalty (degradation)
+Source material spanning unrelated domains produces a world with conflicting governance logic.
+
+When domain_coherence < 30 [state]
+Then synthesis_fidelity *= 0.55
+
+> trigger: Domain coherence below 30% — source material is internally contradictory or covers unrelated domains.
+> rule: A single .nv-world.md should govern a coherent domain. Mixed domains produce conflicting rules and meaningless invariants.
+> shift: Output becomes structurally confused. State variables may not relate to each other.
+> effect: Synthesis fidelity reduced to 55%.
+
+## rule-005: Invention Threshold Breach (structural)
+Excessive invention without source basis constitutes fabrication, not derivation.
+
+When invention_ratio > 0.30 [state]
+Then synthesis_fidelity *= 0.30, epistemic_honesty *= 0.40
+Collapse: synthesis_fidelity < 0.05
+
+> trigger: Invention ratio exceeds 30% — more than a third of output has no source basis.
+> rule: Derivation must be grounded. A world that is mostly invented does not represent the user's governance intent.
+> shift: Output crosses from synthesis to hallucination. Fidelity drops below usable threshold.
+> effect: Synthesis fidelity reduced to 30%. Epistemic honesty reduced to 40%.
+
+## rule-006: High Fidelity Source (advantage)
+Rich, specific, coherent source material enables high-quality derivation.
+
+When concept_specificity > 70 [state] AND domain_coherence > 70 [state] AND declared_concept_count > 8 [state]
+Then synthesis_fidelity *= 1.20, structural_completeness *= 1.15
+
+> trigger: High concept specificity, strong domain coherence, and rich concept count.
+> rule: Quality source material produces quality governance. The model has enough structure to derive rather than invent.
+> shift: Output is well-grounded. Most invariants and rules trace directly to source.
+> effect: Synthesis fidelity boosted by 20%. Structural completeness boosted by 15%.
+
+## rule-007: Structural Completeness Gate (degradation)
+A derived world missing critical sections is not usable regardless of quality in present sections.
+
+When structural_completeness < 40 [state]
+Then synthesis_fidelity *= 0.50
+
+> trigger: Structural completeness below 40% — too many required sections are empty or stub.
+> rule: A partial world is not a valid world. Missing sections mean missing governance.
+> shift: The output may parse but cannot function as meaningful governance.
+> effect: Synthesis fidelity reduced to 50%.
+
+## rule-008: Epistemic Honesty Reward (advantage)
+Correct attribution of declared versus inferred constraints makes output trustworthy and auditable.
+
+When epistemic_honesty > 80 [state]
+Then synthesis_fidelity *= 1.10
+
+> trigger: Epistemic honesty above 80% — model correctly attributes constraint origins.
+> rule: Honest attribution makes governance auditable. Users can verify which constraints they declared versus which the model suggested.
+> shift: Output gains trust. Declared constraints can be relied upon; inferred ones can be reviewed.
+> effect: Synthesis fidelity boosted by 10%.
+
+## rule-009: Context Window Overflow Risk (degradation)
+Extremely large source material risks truncation and missed governance concepts.
+
+When source_token_estimate > 100000 [state]
+Then synthesis_fidelity *= 0.75
+
+> trigger: Source material exceeds 100k tokens — likely to be truncated.
+> rule: Truncated input means incomplete synthesis. The model may miss governance concepts that appear late in the concatenation.
+> shift: Output may be partial. Critical sections from later source files may be absent.
+> effect: Synthesis fidelity reduced to 75% due to truncation risk.
+
+## rule-010: Derivation Coherence Reward (advantage)
+Aligned quality metrics across fidelity, honesty, and invention produce a genuine governance document.
+
+When synthesis_fidelity > 0.80 [state] AND epistemic_honesty > 75 [state] AND invention_ratio < 0.15 [state]
+Then synthesis_fidelity *= 1.15
+Collapse: synthesis_fidelity < 0.05
+
+> trigger: Synthesis fidelity above 80%, epistemic honesty above 75%, and invention ratio below 15%.
+> rule: Coherent derivation across all metrics indicates a faithful, usable governance document.
+> shift: The derived world moves from draft to production-quality. Suitable for bootstrap and validation.
+> effect: Synthesis fidelity boosted by 15%. Derivation coherence achieved.
+
+# Gates
+
+- FAITHFUL: synthesis_fidelity >= 0.85
+- USABLE: synthesis_fidelity >= 0.60
+- REVIEWABLE: synthesis_fidelity >= 0.40
+- SUSPECT: synthesis_fidelity > 0.15
+- DERIVATION_REJECTED: synthesis_fidelity <= 0.15
+
+# Outcomes
+
+## synthesis_fidelity
+- type: number
+- range: 0-1
+- display: percentage
+- label: Synthesis Fidelity
+- primary: true
+
+## structural_completeness
+- type: number
+- range: 0-100
+- display: percentage
+- label: Structural Completeness
+
+## epistemic_honesty
+- type: number
+- range: 0-100
+- display: percentage
+- label: Epistemic Honesty
+
+## invention_ratio
+- type: number
+- range: 0-1
+- display: percentage
+- label: Invention Ratio
+- assignment: external
+
+## derivation_status
+- type: enum
+- label: Derivation Status
+- assignment: external

package/package.json

@@ -1,36 +1,84 @@
 {
   "name": "@neuroverseos/governance",
-  "version": "0.1.0",
-  "description": "Deterministic constitutional enforcement layer for agent runtimes.",
-  "author": "NeuroVerseOS",
-  "license": "MIT",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "openclaw": {
-    "extensions": ["./dist/index.js"]
+  "version": "0.1.2",
+  "description": "Deterministic governance engine for AI agents — evaluate events against world definitions with full audit trace",
+  "license": "Apache-2.0",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./adapters": {
+      "types": "./dist/adapters/index.d.ts",
+      "import": "./dist/adapters/index.js",
+      "require": "./dist/adapters/index.cjs"
+    },
+    "./adapters/langchain": {
+      "types": "./dist/adapters/langchain.d.ts",
+      "import": "./dist/adapters/langchain.js",
+      "require": "./dist/adapters/langchain.cjs"
+    },
+    "./adapters/openai": {
+      "types": "./dist/adapters/openai.d.ts",
+      "import": "./dist/adapters/openai.js",
+      "require": "./dist/adapters/openai.cjs"
+    },
+    "./adapters/openclaw": {
+      "types": "./dist/adapters/openclaw.d.ts",
+      "import": "./dist/adapters/openclaw.js",
+      "require": "./dist/adapters/openclaw.cjs"
+    },
+    "./adapters/express": {
+      "types": "./dist/adapters/express.d.ts",
+      "import": "./dist/adapters/express.js",
+      "require": "./dist/adapters/express.cjs"
+    }
   },
-  "scripts": {
-    "build": "tsc",
-    "prepublishOnly": "npm run build"
-  },
-  "devDependencies": {
-    "typescript": "^5.0.0"
-  },
-  "peerDependencies": {
-    "openclaw": "*"
+  "bin": {
+    "neuroverse": "dist/cli/neuroverse.js"
   },
   "files": [
     "dist",
-    "openclaw.plugin.json",
-    "README.md",
-    "LICENSE"
+    "dist/worlds",
+    "LICENSE.md",
+    "README.md"
   ],
+  "scripts": {
+    "build": "tsup src/index.ts src/cli/neuroverse.ts src/adapters/index.ts src/adapters/langchain.ts src/adapters/openai.ts src/adapters/openclaw.ts src/adapters/express.ts --format esm,cjs --dts --clean && cp src/worlds/derivation-world.nv-world.md dist/worlds/derivation-world.nv-world.md",
+    "prebuild": "mkdir -p dist/worlds",
+    "dev": "tsup src/index.ts src/cli/neuroverse.ts --format esm,cjs --dts --watch",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "devDependencies": {
+    "@types/node": "^25.3.3",
+    "tsup": "^8.0.0",
+    "typescript": "^5.3.0",
+    "vitest": "^2.0.0"
+  },
   "keywords": [
-    "ai",
+    "neuroverse",
     "governance",
-    "agents",
-    "openclaw",
-    "constitutional",
-    "guardrails"
-  ]
+    "guard",
+    "deterministic",
+    "rule-engine",
+    "ai-governance",
+    "ai-agents",
+    "compliance",
+    "audit",
+    "world-engine"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/neuroverseos/neuroverseos-governance.git"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "homepage": "https://neuroverseos.com"
 }