@neuroverseos/governance 0.1.6 → 0.2.2

package/dist/chunk-KEST3MWO.js

@@ -0,0 +1,324 @@
+import {
+  evaluateGuard
+} from "./chunk-4JRYGIO7.js";
+import {
+  loadWorld
+} from "./chunk-JZPQGIKR.js";
+import {
+  advancePlan,
+  evaluatePlan,
+  getPlanProgress
+} from "./chunk-4QXB6PEO.js";
+
+// src/runtime/session.ts
+async function defaultToolExecutor(name, args) {
+  return `Tool "${name}" executed successfully with args: ${JSON.stringify(args)}`;
+}
+var SessionManager = class {
+  config;
+  state;
+  engineOptions;
+  executor;
+  constructor(config) {
+    this.config = config;
+    this.executor = config.toolExecutor ?? defaultToolExecutor;
+    this.engineOptions = {
+      trace: config.trace ?? false,
+      level: config.level,
+      plan: config.plan
+    };
+    this.state = {
+      active: false,
+      world: config.world,
+      plan: config.plan,
+      progress: config.plan ? getPlanProgress(config.plan) : void 0,
+      actionsEvaluated: 0,
+      actionsAllowed: 0,
+      actionsBlocked: 0,
+      actionsPaused: 0
+    };
+  }
+  /**
+   * Initialize the session — load world from disk if needed.
+   */
+  async start() {
+    if (this.config.worldPath && !this.config.world) {
+      this.state.world = await loadWorld(this.config.worldPath);
+    }
+    if (!this.state.world) {
+      throw new Error("No world provided. Use --world or pass a world definition.");
+    }
+    this.state.active = true;
+    return this.getState();
+  }
+  /**
+   * Evaluate a single event against governance.
+   * Returns the verdict without executing anything.
+   */
+  evaluate(event) {
+    this.engineOptions.plan = this.state.plan;
+    const verdict = evaluateGuard(event, this.state.world, this.engineOptions);
+    this.state.actionsEvaluated++;
+    if (verdict.status === "ALLOW") this.state.actionsAllowed++;
+    if (verdict.status === "BLOCK") this.state.actionsBlocked++;
+    if (verdict.status === "PAUSE") this.state.actionsPaused++;
+    this.config.onVerdict?.(verdict, event);
+    return verdict;
+  }
+  /**
+   * Evaluate and execute a tool call.
+   * Returns the execution result or block reason.
+   */
+  async executeToolCall(toolCall) {
+    let args;
+    try {
+      args = JSON.parse(toolCall.function.arguments);
+    } catch {
+      args = { raw: toolCall.function.arguments };
+    }
+    const event = {
+      intent: toolCall.function.name,
+      tool: toolCall.function.name,
+      args,
+      direction: "input"
+    };
+    const verdict = this.evaluate(event);
+    if (verdict.status === "BLOCK") {
+      return { allowed: false, verdict };
+    }
+    if (verdict.status === "PAUSE") {
+      return { allowed: false, verdict };
+    }
+    const result = await this.executor(toolCall.function.name, args);
+    this.config.onToolResult?.(toolCall.function.name, result);
+    if (this.state.plan) {
+      const planVerdict = evaluatePlan(event, this.state.plan);
+      if (planVerdict.matchedStep) {
+        const advResult = advancePlan(this.state.plan, planVerdict.matchedStep);
+        if (advResult.success && advResult.plan) {
+          this.state.plan = advResult.plan;
+          this.engineOptions.plan = this.state.plan;
+        }
+        this.state.progress = getPlanProgress(this.state.plan);
+        this.config.onPlanProgress?.(this.state.progress);
+        if (this.state.progress.completed === this.state.progress.total) {
+          this.config.onPlanComplete?.();
+        }
+      }
+    }
+    return { allowed: true, verdict, result };
+  }
+  /**
+   * Process a model response — evaluate and execute all tool calls.
+   * Returns results for each tool call.
+   */
+  async processModelResponse(response, model) {
+    if (response.toolCalls.length === 0) {
+      return response;
+    }
+    for (const toolCall of response.toolCalls) {
+      const { allowed, verdict, result } = await this.executeToolCall(toolCall);
+      if (allowed && result) {
+        const nextResponse = await model.sendToolResult(toolCall.id, result);
+        if (nextResponse.toolCalls.length > 0) {
+          return this.processModelResponse(nextResponse, model);
+        }
+        return nextResponse;
+      } else {
+        const reason = verdict.reason ?? "Action blocked by governance.";
+        const nextResponse = await model.sendBlockedResult(toolCall.id, reason);
+        if (nextResponse.toolCalls.length > 0) {
+          return this.processModelResponse(nextResponse, model);
+        }
+        return nextResponse;
+      }
+    }
+    return response;
+  }
+  /** Get current session state. */
+  getState() {
+    return { ...this.state };
+  }
+  /** Stop the session. */
+  stop() {
+    this.state.active = false;
+    return this.getState();
+  }
+};
+async function runPipeMode(config) {
+  const session = new SessionManager(config);
+  await session.start();
+  const state = session.getState();
+  process.stderr.write(`[neuroverse] Pipe mode active
+`);
+  process.stderr.write(`[neuroverse] World: ${state.world.world.name}
+`);
+  if (state.plan) {
+    process.stderr.write(`[neuroverse] Plan: ${state.plan.plan_id} (${state.plan.objective})
+`);
+  }
+  return new Promise((resolve, reject) => {
+    let buffer = "";
+    process.stdin.setEncoding("utf-8");
+    process.stdin.on("data", (chunk) => {
+      buffer += chunk;
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        try {
+          const event = JSON.parse(trimmed);
+          if (!event.intent) {
+            process.stderr.write(`[neuroverse] Warning: event missing "intent" field
+`);
+            continue;
+          }
+          const verdict = session.evaluate(event);
+          process.stdout.write(JSON.stringify(verdict) + "\n");
+        } catch (err) {
+          process.stderr.write(`[neuroverse] Error parsing line: ${err}
+`);
+        }
+      }
+    });
+    process.stdin.on("end", () => {
+      if (buffer.trim()) {
+        try {
+          const event = JSON.parse(buffer.trim());
+          if (event.intent) {
+            const verdict = session.evaluate(event);
+            process.stdout.write(JSON.stringify(verdict) + "\n");
+          }
+        } catch {
+        }
+      }
+      const finalState = session.stop();
+      process.stderr.write(
+        `[neuroverse] Session complete: ${finalState.actionsEvaluated} evaluated, ${finalState.actionsAllowed} allowed, ${finalState.actionsBlocked} blocked, ${finalState.actionsPaused} paused
+`
+      );
+      resolve();
+    });
+    process.stdin.on("error", reject);
+  });
+}
+async function runInteractiveMode(config, model) {
+  const session = new SessionManager(config);
+  await session.start();
+  const state = session.getState();
+  process.stdout.write("\n");
+  process.stdout.write(`  World: ${state.world.world.name}
+`);
+  if (state.plan) {
+    process.stdout.write(`  Plan: ${state.plan.plan_id}
+`);
+    process.stdout.write(`  Goal: ${state.plan.objective}
+`);
+    process.stdout.write(`  Steps: ${state.progress?.total ?? 0}
+`);
+  }
+  process.stdout.write(`  Type "exit" to end session.
+`);
+  process.stdout.write("\n");
+  const readline = await import("readline");
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: "> "
+  });
+  const printProgress = () => {
+    const s = session.getState();
+    if (s.progress) {
+      process.stdout.write(
+        `  [plan: ${s.progress.completed}/${s.progress.total} (${s.progress.percentage}%)]
+`
+      );
+    }
+  };
+  rl.prompt();
+  rl.on("line", async (input) => {
+    const trimmed = input.trim();
+    if (!trimmed) {
+      rl.prompt();
+      return;
+    }
+    if (trimmed === "exit" || trimmed === "quit") {
+      const finalState = session.stop();
+      process.stdout.write("\n");
+      process.stdout.write(`  Session complete.
+`);
+      process.stdout.write(`  Actions: ${finalState.actionsEvaluated} evaluated`);
+      process.stdout.write(`, ${finalState.actionsAllowed} allowed`);
+      process.stdout.write(`, ${finalState.actionsBlocked} blocked
+`);
+      if (finalState.progress) {
+        process.stdout.write(
+          `  Plan: ${finalState.progress.completed}/${finalState.progress.total} steps completed
+`
+        );
+      }
+      process.stdout.write("\n");
+      rl.close();
+      return;
+    }
+    if (trimmed === "status") {
+      const s = session.getState();
+      process.stdout.write(`
+  World: ${s.world.world.name}
+`);
+      process.stdout.write(`  Actions: ${s.actionsEvaluated} evaluated
+`);
+      process.stdout.write(`  Allowed: ${s.actionsAllowed} | Blocked: ${s.actionsBlocked} | Paused: ${s.actionsPaused}
+`);
+      if (s.progress && s.plan) {
+        process.stdout.write(`  Plan: ${s.plan.plan_id} \u2014 ${s.progress.completed}/${s.progress.total} (${s.progress.percentage}%)
+`);
+        for (const step of s.plan.steps) {
+          const icon = step.status === "completed" ? "[x]" : "[ ]";
+          process.stdout.write(`    ${icon} ${step.label}
+`);
+        }
+      }
+      process.stdout.write("\n");
+      rl.prompt();
+      return;
+    }
+    try {
+      const response = await model.chat(trimmed);
+      if (response.toolCalls.length > 0) {
+        const finalResponse = await session.processModelResponse(response, model);
+        if (finalResponse.content) {
+          process.stdout.write(`
+${finalResponse.content}
+
+`);
+        }
+        printProgress();
+      } else if (response.content) {
+        process.stdout.write(`
+${response.content}
+
+`);
+      }
+    } catch (err) {
+      process.stderr.write(`
+  Error: ${err}
+
+`);
+    }
+    rl.prompt();
+  });
+  rl.on("close", () => {
+    session.stop();
+  });
+  return new Promise((resolve) => {
+    rl.on("close", resolve);
+  });
+}
+
+export {
+  SessionManager,
+  runPipeMode,
+  runInteractiveMode
+};

package/dist/{chunk-D7BGWV2J.js → chunk-NF5POFCI.js}

@@ -1,14 +1,16 @@
 import {
-  createProvider,
+  createProvider
+} from "./chunk-Q6O7ZLO2.js";
+import {
   loadConfig
-} from "./chunk-T4X42QXC.js";
+} from "./chunk-OT6PXH54.js";
 import {
   emitWorldDefinition,
   parseWorldMarkdown
 } from "./chunk-XPDMYECO.js";
 import {
   validateWorld
-} from "./chunk-O5OMJMIE.js";
+} from "./chunk-7P3S7MAY.js";
 
 // src/engine/derive-normalizer.ts
 function findSections(lines) {

package/dist/{chunk-FZQCRGUU.js → chunk-OHAC6HJE.js}

@@ -1,9 +1,14 @@
 import {
   evaluateGuard
-} from "./chunk-B4NF3OLW.js";
+} from "./chunk-4JRYGIO7.js";
 import {
   loadWorld
-} from "./chunk-M3TZFGHO.js";
+} from "./chunk-JZPQGIKR.js";
+import {
+  advancePlan,
+  evaluatePlan,
+  getPlanProgress
+} from "./chunk-4QXB6PEO.js";
 
 // src/adapters/openai.ts
 var GovernanceBlockedError = class extends Error {
@@ -34,12 +39,15 @@ var GovernedToolExecutor = class {
   engineOptions;
   mapFn;
   blockMsg;
+  activePlan;
   constructor(world, options = {}) {
     this.world = world;
     this.options = options;
+    this.activePlan = options.plan;
     this.engineOptions = {
       trace: options.trace ?? false,
-      level: options.level
+      level: options.level,
+      plan: this.activePlan
     };
     this.mapFn = options.mapFunctionCall ?? defaultMapFunctionCall;
     this.blockMsg = options.blockMessage ?? defaultBlockMessage;
@@ -56,8 +64,24 @@ var GovernedToolExecutor = class {
       args = { raw: toolCall.function.arguments };
     }
     const event = this.mapFn(toolCall.function.name, args);
+    this.engineOptions.plan = this.activePlan;
     const verdict = evaluateGuard(event, this.world, this.engineOptions);
     this.options.onEvaluate?.(verdict, event);
+    if (verdict.status === "ALLOW" && this.activePlan) {
+      const planVerdict = evaluatePlan(event, this.activePlan);
+      if (planVerdict.matchedStep) {
+        const advResult = advancePlan(this.activePlan, planVerdict.matchedStep);
+        if (advResult.success && advResult.plan) {
+          this.activePlan = advResult.plan;
+          this.engineOptions.plan = this.activePlan;
+        }
+        const progress = getPlanProgress(this.activePlan);
+        this.options.onPlanProgress?.(progress);
+        if (progress.completed === progress.total) {
+          this.options.onPlanComplete?.();
+        }
+      }
+    }
     return verdict;
   }
   /**

package/dist/chunk-OT6PXH54.js

@@ -0,0 +1,61 @@
+// src/providers/config-manager.ts
+import { readFile, writeFile, mkdir, chmod } from "fs/promises";
+import { join } from "path";
+import { homedir } from "os";
+function getConfigDir() {
+  const xdg = process.env.XDG_CONFIG_HOME;
+  if (xdg) return join(xdg, "neuroverse");
+  return join(homedir(), ".neuroverse");
+}
+function getConfigPath() {
+  return join(getConfigDir(), "config.json");
+}
+async function loadConfig() {
+  try {
+    const raw = await readFile(getConfigPath(), "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!parsed.provider || !parsed.model || !parsed.apiKey) {
+      return null;
+    }
+    return {
+      provider: parsed.provider,
+      model: parsed.model,
+      apiKey: parsed.apiKey,
+      endpoint: parsed.endpoint ?? null
+    };
+  } catch {
+    return null;
+  }
+}
+async function saveConfig(config) {
+  const dir = getConfigDir();
+  await mkdir(dir, { recursive: true });
+  const configPath = getConfigPath();
+  const content = JSON.stringify(
+    {
+      provider: config.provider,
+      model: config.model,
+      apiKey: config.apiKey,
+      endpoint: config.endpoint
+    },
+    null,
+    2
+  );
+  await writeFile(configPath, content, { mode: 384 });
+  await chmod(configPath, 384);
+}
+function redactConfig(config) {
+  return {
+    provider: config.provider,
+    model: config.model,
+    apiKey: config.apiKey ? `${config.apiKey.slice(0, 4)}...${config.apiKey.slice(-4)}` : "(not set)",
+    endpoint: config.endpoint
+  };
+}
+
+export {
+  getConfigPath,
+  loadConfig,
+  saveConfig,
+  redactConfig
+};

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

@@ -1,6 +1,6 @@
 import {
   readAuditLog
-} from "./chunk-FYPYZFV5.js";
+} from "./chunk-QPASI2BR.js";
 
 // src/engine/impact-report.ts
 function generateImpactReport(events) {

package/dist/{chunk-T4X42QXC.js → chunk-Q6O7ZLO2.js}

@@ -42,61 +42,6 @@ function createProvider(config) {
   return new ChatCompletionsProvider(config);
 }
 
-// src/providers/config-manager.ts
-import { readFile, writeFile, mkdir, chmod } from "fs/promises";
-import { join } from "path";
-import { homedir } from "os";
-function getConfigDir() {
-  const xdg = process.env.XDG_CONFIG_HOME;
-  if (xdg) return join(xdg, "neuroverse");
-  return join(homedir(), ".neuroverse");
-}
-function getConfigPath() {
-  return join(getConfigDir(), "config.json");
-}
-async function loadConfig() {
-  try {
-    const raw = await readFile(getConfigPath(), "utf-8");
-    const parsed = JSON.parse(raw);
-    if (!parsed.provider || !parsed.model || !parsed.apiKey) {
-      return null;
-    }
-    return {
-      provider: parsed.provider,
-      model: parsed.model,
-      apiKey: parsed.apiKey,
-      endpoint: parsed.endpoint ?? null
-    };
-  } catch {
-    return null;
-  }
-}
-async function saveConfig(config) {
-  const dir = getConfigDir();
-  await mkdir(dir, { recursive: true });
-  const configPath = getConfigPath();
-  const content = JSON.stringify(
-    {
-      provider: config.provider,
-      model: config.model,
-      apiKey: config.apiKey,
-      endpoint: config.endpoint
-    },
-    null,
-    2
-  );
-  await writeFile(configPath, content, { mode: 384 });
-  await chmod(configPath, 384);
-}
-function redactConfig(config) {
-  return {
-    provider: config.provider,
-    model: config.model,
-    apiKey: config.apiKey ? `${config.apiKey.slice(0, 4)}...${config.apiKey.slice(-4)}` : "(not set)",
-    endpoint: config.endpoint
-  };
-}
-
 // src/contracts/derive-contract.ts
 var DERIVE_EXIT_CODES = {
   SUCCESS: 0,
@@ -112,10 +57,6 @@ var CONFIGURE_AI_EXIT_CODES = {
 
 export {
   createProvider,
-  getConfigPath,
-  loadConfig,
-  saveConfig,
-  redactConfig,
   DERIVE_EXIT_CODES,
   CONFIGURE_AI_EXIT_CODES
 };

package/dist/{chunk-FYPYZFV5.js → chunk-QPASI2BR.js}

@@ -1,6 +1,6 @@
 import {
   evaluateGuard
-} from "./chunk-B4NF3OLW.js";
+} from "./chunk-4JRYGIO7.js";
 
 // src/engine/audit-logger.ts
 var FileAuditLogger = class {

package/dist/{chunk-EQXFOKH2.js → chunk-RWXVAH6P.js}

@@ -1,9 +1,14 @@
 import {
   evaluateGuard
-} from "./chunk-B4NF3OLW.js";
+} from "./chunk-4JRYGIO7.js";
 import {
   loadWorld
-} from "./chunk-M3TZFGHO.js";
+} from "./chunk-JZPQGIKR.js";
+import {
+  advancePlan,
+  evaluatePlan,
+  getPlanProgress
+} from "./chunk-4QXB6PEO.js";
 
 // src/adapters/langchain.ts
 var GovernanceBlockedError = class extends Error {
@@ -31,12 +36,15 @@ var NeuroVerseCallbackHandler = class {
   options;
   engineOptions;
   mapToolCall;
+  activePlan;
   constructor(world, options = {}) {
     this.world = world;
     this.options = options;
+    this.activePlan = options.plan;
     this.engineOptions = {
       trace: options.trace ?? false,
-      level: options.level
+      level: options.level,
+      plan: this.activePlan
     };
     this.mapToolCall = options.mapToolCall ?? defaultMapToolCall;
   }
@@ -55,6 +63,7 @@ var NeuroVerseCallbackHandler = class {
       parsedInput = { raw: input };
     }
     const event = this.mapToolCall(tool.name, parsedInput);
+    this.engineOptions.plan = this.activePlan;
     const verdict = evaluateGuard(event, this.world, this.engineOptions);
     this.options.onEvaluate?.(verdict, event);
     if (verdict.status === "BLOCK") {
@@ -67,6 +76,21 @@ var NeuroVerseCallbackHandler = class {
         throw new GovernanceBlockedError(verdict, event);
       }
     }
+    if (verdict.status === "ALLOW" && this.activePlan) {
+      const planVerdict = evaluatePlan(event, this.activePlan);
+      if (planVerdict.matchedStep) {
+        const advResult = advancePlan(this.activePlan, planVerdict.matchedStep);
+        if (advResult.success && advResult.plan) {
+          this.activePlan = advResult.plan;
+          this.engineOptions.plan = this.activePlan;
+        }
+        const progress = getPlanProgress(this.activePlan);
+        this.options.onPlanProgress?.(progress);
+        if (progress.completed === progress.total) {
+          this.options.onPlanComplete?.();
+        }
+      }
+    }
   }
 };
 async function createNeuroVerseCallbackHandler(worldPath, options) {

package/dist/{chunk-CROPZ75A.js → chunk-SKU3GAPD.js}

@@ -1,9 +1,14 @@
 import {
   evaluateGuard
-} from "./chunk-B4NF3OLW.js";
+} from "./chunk-4JRYGIO7.js";
 import {
   loadWorld
-} from "./chunk-M3TZFGHO.js";
+} from "./chunk-JZPQGIKR.js";
+import {
+  advancePlan,
+  evaluatePlan,
+  getPlanProgress
+} from "./chunk-4QXB6PEO.js";
 
 // src/adapters/openclaw.ts
 var GovernanceBlockedError = class extends Error {
@@ -31,12 +36,15 @@ var NeuroVersePlugin = class {
   options;
   engineOptions;
   mapAction;
+  activePlan;
   constructor(world, options = {}) {
     this.world = world;
     this.options = options;
+    this.activePlan = options.plan;
     this.engineOptions = {
       trace: options.trace ?? false,
-      level: options.level
+      level: options.level,
+      plan: this.activePlan
     };
     this.mapAction = options.mapAction ?? defaultMapAction;
   }
@@ -48,6 +56,7 @@ var NeuroVersePlugin = class {
    */
   beforeAction(action) {
     const event = this.mapAction(action, "input");
+    this.engineOptions.plan = this.activePlan;
     const verdict = evaluateGuard(event, this.world, this.engineOptions);
     const result = {
       allowed: verdict.status === "ALLOW",
@@ -58,6 +67,21 @@ var NeuroVersePlugin = class {
     if (verdict.status === "BLOCK") {
       throw new GovernanceBlockedError(verdict, action);
     }
+    if (verdict.status === "ALLOW" && this.activePlan) {
+      const planVerdict = evaluatePlan(event, this.activePlan);
+      if (planVerdict.matchedStep) {
+        const advResult = advancePlan(this.activePlan, planVerdict.matchedStep);
+        if (advResult.success && advResult.plan) {
+          this.activePlan = advResult.plan;
+          this.engineOptions.plan = this.activePlan;
+        }
+        const progress = getPlanProgress(this.activePlan);
+        this.options.onPlanProgress?.(progress);
+        if (progress.completed === progress.total) {
+          this.options.onPlanComplete?.();
+        }
+      }
+    }
     return result;
   }
   /**

package/dist/chunk-YZFATT7X.js

@@ -0,0 +1,9 @@
+var __glob = (map) => (path) => {
+  var fn = map[path];
+  if (fn) return fn();
+  throw new Error("Module not found in bundle: " + path);
+};
+
+export {
+  __glob
+};