@neuroverseos/governance 0.3.0 → 0.3.3

package/dist/chunk-O5ABKEA7.js

@@ -0,0 +1,304 @@
+import {
+  GovernanceBlockedError,
+  buildEngineOptions,
+  extractScope,
+  trackPlanProgress
+} from "./chunk-5U2MQO5P.js";
+import {
+  evaluateGuard
+} from "./chunk-W7LLXRGY.js";
+import {
+  loadWorld
+} from "./chunk-CTZHONLA.js";
+
+// src/engine/tool-classifier.ts
+var TOOL_CATEGORY_MAP = {
+  // File operations
+  read_file: "file_read",
+  read: "file_read",
+  glob: "file_read",
+  grep: "file_read",
+  list_files: "file_read",
+  write_file: "file_write",
+  write: "file_write",
+  create_file: "file_write",
+  edit_file: "file_write",
+  edit: "file_write",
+  patch: "file_write",
+  delete_file: "file_delete",
+  remove_file: "file_delete",
+  // Shell
+  shell: "shell",
+  bash: "shell",
+  execute: "shell",
+  run_command: "shell",
+  terminal: "shell",
+  // Git
+  git: "git",
+  git_commit: "git",
+  git_push: "git",
+  git_checkout: "git",
+  // Network
+  http: "network",
+  fetch: "network",
+  curl: "network",
+  web_search: "network",
+  // Sub-agents
+  sub_agent: "sub_agent",
+  spawn_agent: "sub_agent",
+  delegate: "sub_agent",
+  // Context management
+  summarize: "context",
+  compress_context: "context"
+};
+function classifyTool(toolName) {
+  const normalized = toolName.toLowerCase().replace(/[-\s]/g, "_");
+  return TOOL_CATEGORY_MAP[normalized] ?? "unknown";
+}
+var DANGEROUS_SHELL_PATTERNS = [
+  { pattern: /rm\s+(-[a-zA-Z]*f[a-zA-Z]*\s+|.*-rf\s+|.*--force)/, label: "force-delete" },
+  { pattern: /rm\s+-[a-zA-Z]*r/, label: "recursive-delete" },
+  { pattern: />\s*\/dev\/sd/, label: "disk-overwrite" },
+  { pattern: /mkfs\./, label: "format-disk" },
+  { pattern: /dd\s+if=/, label: "disk-dump" },
+  { pattern: /chmod\s+(-R\s+)?777/, label: "world-writable" },
+  { pattern: /curl\s+.*\|\s*(bash|sh|zsh)/, label: "pipe-to-shell" },
+  { pattern: /wget\s+.*\|\s*(bash|sh|zsh)/, label: "pipe-to-shell" },
+  { pattern: /:(){ :\|:& };:/, label: "fork-bomb" },
+  { pattern: />\s*\/etc\//, label: "system-config-overwrite" },
+  { pattern: /shutdown|reboot|halt|poweroff/, label: "system-shutdown" },
+  { pattern: /kill\s+-9\s+1\b/, label: "kill-init" }
+];
+var DANGEROUS_GIT_PATTERNS = [
+  { pattern: /push\s+.*--force/, label: "force-push" },
+  { pattern: /push\s+.*-f\b/, label: "force-push" },
+  { pattern: /push\s+(origin\s+)?main\b/, label: "push-main" },
+  { pattern: /push\s+(origin\s+)?master\b/, label: "push-master" },
+  { pattern: /reset\s+--hard/, label: "hard-reset" },
+  { pattern: /clean\s+-fd/, label: "clean-force" },
+  { pattern: /branch\s+-D/, label: "force-delete-branch" }
+];
+function isDangerousCommand(command) {
+  const matched = DANGEROUS_SHELL_PATTERNS.filter((p) => p.pattern.test(command)).map((p) => p.label);
+  return { dangerous: matched.length > 0, labels: matched };
+}
+function isDangerousGitCommand(command) {
+  const matched = DANGEROUS_GIT_PATTERNS.filter((p) => p.pattern.test(command)).map((p) => p.label);
+  return { dangerous: matched.length > 0, labels: matched };
+}
+function assessRiskLevel(category) {
+  if (category === "file_read" || category === "context") return "low";
+  if (category === "file_write" || category === "sub_agent") return "medium";
+  if (category === "shell" || category === "file_delete" || category === "git" || category === "network") return "high";
+  return void 0;
+}
+function categoryToActionCategory(category) {
+  if (category === "file_read" || category === "context") return "read";
+  if (category === "file_write") return "write";
+  if (category === "file_delete") return "delete";
+  if (category === "shell") return "shell";
+  if (category === "network") return "network";
+  return "other";
+}
+
+// src/adapters/deep-agents.ts
+var GovernanceBlockedError2 = class extends GovernanceBlockedError {
+  toolCall;
+  category;
+  constructor(verdict, toolCall, category) {
+    super(verdict);
+    this.toolCall = toolCall;
+    this.category = category;
+  }
+};
+function defaultMapToolCall(toolCall) {
+  const category = classifyTool(toolCall.tool);
+  const args = toolCall.args;
+  const scope = extractScope(args);
+  let intent = toolCall.tool;
+  if (category === "shell" && typeof args.command === "string") {
+    intent = `shell: ${args.command}`;
+  } else if (category === "git" && typeof args.command === "string") {
+    intent = `git ${args.command}`;
+  } else if (category === "file_write" && scope) {
+    intent = `write ${scope}`;
+  } else if (category === "file_delete" && scope) {
+    intent = `delete ${scope}`;
+  }
+  const riskLevel = assessRiskLevel(category);
+  let irreversible = false;
+  if (category === "shell" && typeof args.command === "string") {
+    irreversible = DANGEROUS_SHELL_PATTERNS.some((p) => p.pattern.test(args.command));
+  } else if (category === "git" && typeof args.command === "string") {
+    irreversible = DANGEROUS_GIT_PATTERNS.some((p) => p.pattern.test(args.command));
+  } else if (category === "file_delete") {
+    irreversible = true;
+  }
+  return {
+    intent,
+    tool: toolCall.tool,
+    scope,
+    args,
+    direction: "input",
+    actionCategory: categoryToActionCategory(category),
+    riskLevel,
+    irreversible
+  };
+}
+var DeepAgentsGuard = class {
+  name = "neuroverse-deep-agents-guard";
+  world;
+  options;
+  engineOptions;
+  mapToolCall;
+  activePlan;
+  constructor(world, options = {}) {
+    this.world = world;
+    this.options = options;
+    this.activePlan = options.plan;
+    this.engineOptions = buildEngineOptions(options, this.activePlan);
+    this.mapToolCall = options.mapToolCall ?? defaultMapToolCall;
+  }
+  /**
+   * Evaluate a tool call against governance rules.
+   * Returns the result without side effects.
+   */
+  evaluate(toolCall) {
+    const event = this.mapToolCall(toolCall);
+    this.engineOptions.plan = this.activePlan;
+    const verdict = evaluateGuard(event, this.world, this.engineOptions);
+    const category = classifyTool(toolCall.tool);
+    const result = {
+      allowed: verdict.status === "ALLOW",
+      verdict,
+      toolCall,
+      category
+    };
+    this.options.onEvaluate?.(result);
+    if (verdict.status === "ALLOW" && this.activePlan) {
+      this.trackPlanProgressInternal(event);
+    }
+    return result;
+  }
+  /**
+   * Evaluate and enforce governance on a tool call.
+   *
+   * @throws GovernanceBlockedError if BLOCKED
+   * @throws GovernanceBlockedError if PAUSED and onPause returns false
+   * @returns DeepAgentsGuardResult on ALLOW
+   */
+  async enforce(toolCall) {
+    const result = this.evaluate(toolCall);
+    if (result.verdict.status === "BLOCK") {
+      this.options.onBlock?.(result);
+      throw new GovernanceBlockedError2(result.verdict, toolCall, result.category);
+    }
+    if (result.verdict.status === "PAUSE") {
+      const approved = await this.options.onPause?.(result);
+      if (!approved) {
+        throw new GovernanceBlockedError2(result.verdict, toolCall, result.category);
+      }
+    }
+    return result;
+  }
+  /**
+   * Evaluate and execute a tool call with governance enforcement.
+   *
+   * If ALLOW: runs the executor and returns its result.
+   * If BLOCK: returns a governance-blocked message.
+   * If PAUSE: calls onPause; blocks if not approved.
+   *
+   * @param toolCall - The Deep Agents tool call to evaluate
+   * @param executor - The actual tool execution function
+   * @returns The tool execution result or a blocked message
+   */
+  async execute(toolCall, executor) {
+    const guardResult = this.evaluate(toolCall);
+    if (guardResult.verdict.status === "BLOCK") {
+      this.options.onBlock?.(guardResult);
+      return {
+        blocked: true,
+        verdict: guardResult.verdict,
+        reason: guardResult.verdict.reason ?? "Action blocked by governance policy."
+      };
+    }
+    if (guardResult.verdict.status === "PAUSE") {
+      const approved = await this.options.onPause?.(guardResult);
+      if (!approved) {
+        return {
+          blocked: true,
+          verdict: guardResult.verdict,
+          reason: guardResult.verdict.reason ?? "Action requires approval."
+        };
+      }
+    }
+    const result = await executor(toolCall);
+    return { result, verdict: guardResult.verdict };
+  }
+  /**
+   * Returns a middleware function compatible with Deep Agents' tool pipeline.
+   *
+   * The middleware intercepts tool calls before execution:
+   *   agent.use(guard.middleware());
+   */
+  middleware() {
+    return async (toolCall, next) => {
+      await this.enforce(toolCall);
+      return next();
+    };
+  }
+  /**
+   * Returns a callback-handler-style object for LangChain integration.
+   * Compatible with Deep Agents' callback system.
+   */
+  callbacks() {
+    return {
+      handleToolStart: async (tool, input) => {
+        let parsedInput;
+        try {
+          parsedInput = typeof input === "string" ? JSON.parse(input) : input;
+        } catch {
+          parsedInput = { raw: input };
+        }
+        await this.enforce({ tool: tool.name, args: parsedInput });
+      }
+    };
+  }
+  /**
+   * Check if a shell command contains dangerous patterns.
+   * Useful for pre-screening before full governance evaluation.
+   */
+  static isDangerousCommand(command) {
+    return isDangerousCommand(command);
+  }
+  /**
+   * Check if a git command contains dangerous patterns.
+   */
+  static isDangerousGitCommand(command) {
+    return isDangerousGitCommand(command);
+  }
+  /**
+   * Classify a tool name into a category.
+   */
+  static classifyTool(toolName) {
+    return classifyTool(toolName);
+  }
+  // ─── Private ──────────────────────────────────────────────────────────────
+  trackPlanProgressInternal(event) {
+    trackPlanProgress(event, this, this.options);
+  }
+};
+async function createDeepAgentsGuard(worldPath, options) {
+  const world = await loadWorld(worldPath);
+  return new DeepAgentsGuard(world, options);
+}
+function createDeepAgentsGuardFromWorld(world, options) {
+  return new DeepAgentsGuard(world, options);
+}
+
+export {
+  GovernanceBlockedError2 as GovernanceBlockedError,
+  DeepAgentsGuard,
+  createDeepAgentsGuard,
+  createDeepAgentsGuardFromWorld
+};

package/dist/chunk-PVTQQS3Y.js

@@ -0,0 +1,186 @@
+// src/engine/bootstrap-emitter.ts
+var GATE_DEFAULTS = {
+  THRIVING: { color: "#0f6b3a", icon: "\u2726" },
+  STABLE: { color: "#1856b8", icon: "\u25CF" },
+  COMPRESSED: { color: "#a16207", icon: "\u25B2" },
+  CRITICAL: { color: "#b91c1c", icon: "\u26A0" },
+  MODEL_COLLAPSES: { color: "#7f1d1d", icon: "\u2715" }
+};
+function emitWorldDefinition(parsed) {
+  const issues = [];
+  const fm = parsed.frontmatter;
+  const defaultProfile = fm.default_profile ?? parsed.assumptions[0]?.id ?? "baseline";
+  const altProfile = fm.alternative_profile ?? parsed.assumptions[1]?.id ?? "alternative";
+  const world = {
+    world_id: fm.world_id,
+    name: fm.name,
+    thesis: parsed.thesis,
+    version: fm.version ?? "1.0.0",
+    runtime_mode: fm.runtime_mode ?? "SIMULATION",
+    default_assumption_profile: defaultProfile,
+    default_alternative_profile: altProfile,
+    modules: parsed.rules.map((r) => r.id),
+    players: {
+      thinking_space: true,
+      experience_space: true,
+      action_space: true
+    }
+  };
+  const invariants = parsed.invariants.map((inv) => ({
+    id: inv.id,
+    label: inv.label,
+    enforcement: inv.enforcement === "prompt" ? "prompt" : "structural",
+    mutable: false
+  }));
+  const profiles = {};
+  const parameterDefinitions = {};
+  for (let i = 0; i < parsed.assumptions.length; i++) {
+    const profile = parsed.assumptions[i];
+    const params = {};
+    for (const [key, val] of Object.entries(profile.parameters)) {
+      params[key] = String(val);
+      if (!parameterDefinitions[key]) {
+        parameterDefinitions[key] = {
+          type: typeof val === "boolean" ? "boolean" : typeof val === "number" ? "number" : "enum",
+          label: key.replace(/_/g, " ").replace(/\b\w/g, (c) => c.toUpperCase()),
+          description: `Parameter: ${key}`
+        };
+      }
+    }
+    profiles[profile.id] = {
+      name: profile.name,
+      description: profile.description,
+      is_default_baseline: i === 0 || profile.id === defaultProfile,
+      is_default_alternative: i === 1 || profile.id === altProfile,
+      parameters: params
+    };
+  }
+  const assumptions = { profiles, parameter_definitions: parameterDefinitions };
+  const variables = {};
+  for (const v of parsed.stateVariables) {
+    const stateVar = {
+      type: v.type,
+      default: v.default,
+      mutable: true,
+      label: v.label,
+      description: v.description
+    };
+    if (v.type === "number") {
+      if (v.min !== void 0) stateVar.min = v.min;
+      if (v.max !== void 0) stateVar.max = v.max;
+      if (v.step !== void 0) stateVar.step = v.step;
+    }
+    if (v.type === "enum" && v.options) {
+      stateVar.options = v.options;
+    }
+    variables[v.id] = stateVar;
+  }
+  const stateSchema = { variables, presets: {} };
+  const rules = parsed.rules.map((r) => {
+    const triggers = r.triggers.map((t) => ({
+      field: t.field,
+      operator: t.operator,
+      value: t.value,
+      source: t.source
+    }));
+    const effects = r.effects.map((e) => ({
+      target: e.target,
+      operation: e.operation,
+      value: e.value
+    }));
+    let collapse_check;
+    if (r.collapse_check) {
+      collapse_check = {
+        field: r.collapse_check.field,
+        operator: r.collapse_check.operator,
+        value: r.collapse_check.value,
+        result: "MODEL_COLLAPSES"
+      };
+    }
+    const causal_translation = r.causal_translation ?? {
+      trigger_text: "",
+      rule_text: "",
+      shift_text: "",
+      effect_text: ""
+    };
+    const rule = {
+      id: r.id,
+      severity: r.severity,
+      label: r.label,
+      description: r.description ?? r.label,
+      order: r.order,
+      triggers,
+      effects: effects.length > 0 ? effects : void 0,
+      collapse_check,
+      causal_translation
+    };
+    return rule;
+  });
+  const viabilityClassification = parsed.gates.map((g) => {
+    const defaults = GATE_DEFAULTS[g.status] ?? { color: "#5c5a52", icon: "\u25CF" };
+    return {
+      status: g.status,
+      field: g.field,
+      operator: g.operator,
+      value: g.value,
+      color: defaults.color,
+      icon: defaults.icon
+    };
+  });
+  const gates = {
+    viability_classification: viabilityClassification,
+    structural_override: {
+      description: "Rules with severity=structural and triggered collapse_check force MODEL_COLLAPSES regardless of final margin.",
+      enforcement: "mandatory"
+    },
+    sustainability_threshold: 0.1,
+    collapse_visual: {
+      background: "#1c1917",
+      text: "#fef2f2",
+      border: "#b91c1c",
+      label: "Structural Failure"
+    }
+  };
+  const computedOutcomes = parsed.outcomes.map((o) => {
+    const outcome = {
+      id: o.id,
+      type: o.type,
+      label: o.label,
+      show_in_comparison: true
+    };
+    if (o.range) outcome.range = o.range;
+    if (o.display) outcome.display_as = o.display;
+    if (o.primary) outcome.primary = o.primary;
+    if (o.assignment) outcome.assignment = o.assignment;
+    return outcome;
+  });
+  const outcomes = {
+    computed_outcomes: computedOutcomes,
+    comparison_layout: {
+      primary_card: computedOutcomes.find((o) => o.primary)?.id ?? computedOutcomes[0]?.id ?? "",
+      status_badge: "viability_status",
+      structural_indicators: rules.filter((r) => r.severity === "structural").map((r) => r.id)
+    }
+  };
+  const metadata = {
+    format_version: "1.0.0",
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    last_modified: (/* @__PURE__ */ new Date()).toISOString(),
+    authoring_method: "manual-authoring"
+  };
+  const worldDefinition = {
+    world,
+    invariants,
+    assumptions,
+    stateSchema,
+    rules,
+    gates,
+    outcomes,
+    metadata
+  };
+  return { world: worldDefinition, issues };
+}
+
+export {
+  emitWorldDefinition
+};

package/dist/{chunk-4QXB6PEO.js → chunk-QLPTHTVB.js}

@@ -1,14 +1,24 @@
-// src/engine/plan-engine.ts
-function keywordMatch(eventText, step) {
-  const stepText = [
-    step.label,
-    step.description ?? "",
-    ...step.tags ?? []
+// src/engine/text-utils.ts
+function normalizeEventText(event) {
+  return [
+    event.intent,
+    event.tool ?? "",
+    event.scope ?? ""
   ].join(" ").toLowerCase();
-  const keywords = stepText.split(/\s+/).filter((w) => w.length > 3);
+}
+function extractKeywords(text, minLength = 3) {
+  return text.toLowerCase().split(/\s+/).filter((w) => w.length > minLength);
+}
+function matchesAllKeywords(eventText, ruleText) {
+  const keywords = extractKeywords(ruleText);
+  if (keywords.length === 0) return false;
+  return keywords.every((kw) => eventText.includes(kw));
+}
+function matchesKeywordThreshold(eventText, ruleText, threshold = 0.5) {
+  const keywords = extractKeywords(ruleText);
   if (keywords.length === 0) return false;
   const matched = keywords.filter((kw) => eventText.includes(kw));
-  return matched.length >= Math.ceil(keywords.length * 0.5);
+  return matched.length >= Math.ceil(keywords.length * threshold);
 }
 function tokenSimilarity(a, b) {
   const tokensA = new Set(a.toLowerCase().split(/\s+/).filter((w) => w.length > 2));
@@ -21,6 +31,19 @@ function tokenSimilarity(a, b) {
   const union = (/* @__PURE__ */ new Set([...tokensA, ...tokensB])).size;
   return union > 0 ? intersection / union : 0;
 }
+
+// src/engine/plan-engine.ts
+function keywordMatch(eventText, step) {
+  const stepText = [
+    step.label,
+    step.description ?? "",
+    ...step.tags ?? []
+  ].join(" ");
+  return matchesKeywordThreshold(eventText, stepText, 0.5);
+}
+function tokenSimilarity2(a, b) {
+  return tokenSimilarity(a, b);
+}
 function findMatchingStep(eventText, event, steps) {
   const pendingOrActive = steps.filter((s) => s.status === "pending" || s.status === "active");
   if (pendingOrActive.length === 0) {
@@ -39,7 +62,7 @@ function findMatchingStep(eventText, event, steps) {
   let bestScore = 0;
   for (const step of pendingOrActive) {
     const stepText = [step.label, step.description ?? "", ...step.tags ?? []].join(" ");
-    const score = tokenSimilarity(intentText, stepText);
+    const score = tokenSimilarity2(intentText, stepText);
     if (score > bestScore) {
       bestScore = score;
       bestStep = step;
@@ -80,7 +103,7 @@ function checkConstraints(event, eventText, constraints) {
       continue;
     }
     if (constraint.type === "scope" && constraint.trigger) {
-      const keywords = constraint.trigger.split(/\s+/).filter((w) => w.length > 3);
+      const keywords = extractKeywords(constraint.trigger);
       const violated = keywords.length > 0 && keywords.every((kw) => eventText.includes(kw));
       checks.push({
         constraintId: constraint.id,
@@ -161,11 +184,7 @@ function evaluatePlan(event, plan) {
       progress
     };
   }
-  const eventText = [
-    event.intent,
-    event.tool ?? "",
-    event.scope ?? ""
-  ].join(" ").toLowerCase();
+  const eventText = normalizeEventText(event);
   const { matched, closest, closestScore } = findMatchingStep(eventText, event, plan.steps);
   if (!matched) {
     return {
@@ -206,7 +225,7 @@ function evaluatePlan(event, plan) {
   };
 }
 function buildPlanCheck(event, plan, verdict) {
-  const eventText = [event.intent, event.tool ?? "", event.scope ?? ""].join(" ").toLowerCase();
+  const eventText = normalizeEventText(event);
   const { matched, closest, closestScore } = findMatchingStep(eventText, event, plan.steps);
   const { checks: constraintChecks } = checkConstraints(event, eventText, plan.constraints);
   const progress = getPlanProgress(plan);
@@ -225,6 +244,8 @@ function buildPlanCheck(event, plan, verdict) {
 }
 
 export {
+  normalizeEventText,
+  matchesAllKeywords,
   getPlanProgress,
   advancePlan,
   evaluatePlan,

package/dist/chunk-QWGCMQQD.js

@@ -0,0 +1,16 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __glob = (map) => (path) => {
+  var fn = map[path];
+  if (fn) return fn();
+  throw new Error("Module not found in bundle: " + path);
+};
+
+export {
+  __require,
+  __glob
+};

package/dist/{chunk-T5EUJQE5.js → chunk-QXBFT7NI.js}

@@ -1,9 +1,20 @@
+import {
+  evaluateGuard
+} from "./chunk-W7LLXRGY.js";
+import {
+  loadWorldFromDirectory
+} from "./chunk-CTZHONLA.js";
+
 // src/adapters/autoresearch.ts
 var AutoresearchGovernor = class {
   config;
   state;
+  world;
+  engineOptions;
   constructor(config) {
     this.config = config;
+    this.world = config.world;
+    this.engineOptions = { trace: true };
     this.state = {
       experiments_run: 0,
       best_result: null,
@@ -33,10 +44,23 @@ var AutoresearchGovernor = class {
   }
   /**
    * Evaluate an experiment proposal against governance rules.
-   * Returns a simplified verdict without requiring the full guard engine.
+   * Routes through the guard engine when a world is loaded,
+   * then layers on research-specific checks (budget, constraints, drift).
    */
   evaluateProposal(proposal) {
     const warnings = [];
+    const event = this.proposalToGuardEvent(proposal);
+    if (this.world) {
+      const verdict = evaluateGuard(event, this.world, this.engineOptions);
+      if (verdict.status === "BLOCK" || verdict.status === "PAUSE") {
+        return {
+          allowed: false,
+          reason: verdict.reason ?? `Governance ${verdict.status}: ${verdict.ruleId ?? "unknown rule"}`,
+          warnings,
+          verdict
+        };
+      }
+    }
     const estimatedMinutes = proposal.estimated_minutes || 5;
     if (this.state.total_compute_minutes + estimatedMinutes > this.config.computeBudgetMinutes) {
       return {
@@ -166,7 +190,12 @@ var AutoresearchGovernor = class {
     return { ...this.state };
   }
 };
+async function createAutoresearchGovernor(worldPath, config) {
+  const world = await loadWorldFromDirectory(worldPath);
+  return new AutoresearchGovernor({ ...config, world, worldPath });
+}
 
 export {
-  AutoresearchGovernor
+  AutoresearchGovernor,
+  createAutoresearchGovernor
 };