@neuroverseos/governance 0.2.2 → 0.2.3

package/dist/cli/neuroverse.cjs

@@ -1975,27 +1975,27 @@ ${candidates.map((c) => `  - ${c}`).join("\n")}`
 }
 async function collectMarkdownSources(inputPath) {
   const { stat, readFile: rf, readdir } = await import("fs/promises");
-  const { join: pathJoin, extname, basename } = await import("path");
+  const { join: pathJoin, extname, basename: basename2 } = await import("path");
   const stats = await stat(inputPath);
   if (stats.isFile()) {
     const content = await rf(inputPath, "utf-8");
-    return [{ filename: basename(inputPath), content }];
+    return [{ filename: basename2(inputPath), content }];
   }
   if (stats.isDirectory()) {
     const sources = [];
-    await collectDir(inputPath, sources, rf, pathJoin, extname, basename);
+    await collectDir(inputPath, sources, rf, pathJoin, extname, basename2);
     sources.sort((a, b) => a.filename.localeCompare(b.filename));
     return sources;
   }
   throw new Error(`Input path is neither a file nor a directory: ${inputPath}`);
 }
-async function collectDir(dir, sources, rf, pathJoin, extname, basename) {
+async function collectDir(dir, sources, rf, pathJoin, extname, basename2) {
   const { readdir } = await import("fs/promises");
   const entries = await readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
     const fullPath = pathJoin(dir, entry.name);
     if (entry.isDirectory()) {
-      await collectDir(fullPath, sources, rf, pathJoin, extname, basename);
+      await collectDir(fullPath, sources, rf, pathJoin, extname, basename2);
     } else if (entry.isFile() && extname(entry.name).toLowerCase() === ".md") {
       const content = await rf(fullPath, "utf-8");
       sources.push({ filename: entry.name, content });
@@ -2653,22 +2653,22 @@ function parseArgs(argv) {
   return { inputPath, outputDir, validate, dryRun, provider, model, endpoint };
 }
 async function writeWorldFiles(outputDir, world) {
-  const { writeFile: writeFile3, mkdir: mkdir2 } = await import("fs/promises");
-  const { join: join6 } = await import("path");
+  const { writeFile: writeFile5, mkdir: mkdir2 } = await import("fs/promises");
+  const { join: join8 } = await import("path");
   await mkdir2(outputDir, { recursive: true });
-  await writeFile3(join6(outputDir, "world.json"), JSON.stringify(world.world, null, 2));
-  await writeFile3(join6(outputDir, "invariants.json"), JSON.stringify({ invariants: world.invariants }, null, 2));
-  await writeFile3(join6(outputDir, "assumptions.json"), JSON.stringify(world.assumptions, null, 2));
-  await writeFile3(join6(outputDir, "state-schema.json"), JSON.stringify(world.stateSchema, null, 2));
-  await writeFile3(join6(outputDir, "gates.json"), JSON.stringify(world.gates, null, 2));
-  await writeFile3(join6(outputDir, "outcomes.json"), JSON.stringify(world.outcomes, null, 2));
-  await writeFile3(join6(outputDir, "metadata.json"), JSON.stringify(world.metadata, null, 2));
-  const rulesDir = join6(outputDir, "rules");
+  await writeFile5(join8(outputDir, "world.json"), JSON.stringify(world.world, null, 2));
+  await writeFile5(join8(outputDir, "invariants.json"), JSON.stringify({ invariants: world.invariants }, null, 2));
+  await writeFile5(join8(outputDir, "assumptions.json"), JSON.stringify(world.assumptions, null, 2));
+  await writeFile5(join8(outputDir, "state-schema.json"), JSON.stringify(world.stateSchema, null, 2));
+  await writeFile5(join8(outputDir, "gates.json"), JSON.stringify(world.gates, null, 2));
+  await writeFile5(join8(outputDir, "outcomes.json"), JSON.stringify(world.outcomes, null, 2));
+  await writeFile5(join8(outputDir, "metadata.json"), JSON.stringify(world.metadata, null, 2));
+  const rulesDir = join8(outputDir, "rules");
   await mkdir2(rulesDir, { recursive: true });
   const sortedRules = [...world.rules].sort((a, b) => a.order - b.order);
   for (let i = 0; i < sortedRules.length; i++) {
     const ruleNum = String(i + 1).padStart(3, "0");
-    await writeFile3(join6(rulesDir, `rule-${ruleNum}.json`), JSON.stringify(sortedRules[i], null, 2));
+    await writeFile5(join8(rulesDir, `rule-${ruleNum}.json`), JSON.stringify(sortedRules[i], null, 2));
   }
 }
 function write(msg) {
@@ -2683,17 +2683,17 @@ function printInsight(finding2) {
 async function main(argv = process.argv.slice(2)) {
   try {
     const args = parseArgs(argv);
-    const { basename } = await import("path");
+    const { basename: basename2 } = await import("path");
     write(`
 NeuroVerse World Builder
 `);
     write(`
-Analyzing: ${basename(args.inputPath)}
+Analyzing: ${basename2(args.inputPath)}
 `);
     const derivedPath = args.outputDir ? `${args.outputDir}/source.nv-world.md` : ".neuroverse/build-output.nv-world.md";
     const { mkdir: mkdir2 } = await import("fs/promises");
-    const { dirname: dirname2 } = await import("path");
-    await mkdir2(dirname2(derivedPath), { recursive: true });
+    const { dirname: dirname3 } = await import("path");
+    await mkdir2(dirname3(derivedPath), { recursive: true });
     const { result, exitCode, dryRunOutput } = await deriveWorld({
       inputPath: args.inputPath,
       outputPath: derivedPath,
@@ -2799,9 +2799,9 @@ World source written to: ${derivedPath}
     try {
       const emitResult = emitWorldDefinition(parseResult.world);
       await writeWorldFiles(outputDir, emitResult.world);
-      const { join: join6 } = await import("path");
+      const { join: join8 } = await import("path");
       const { copyFile } = await import("fs/promises");
-      const sourceDest = join6(outputDir, "source.nv-world.md");
+      const sourceDest = join8(outputDir, "source.nv-world.md");
       if (derivedPath !== sourceDest) {
         await copyFile(derivedPath, sourceDest);
       }
@@ -2878,11 +2878,11 @@ __export(world_loader_exports, {
 });
 async function loadWorldFromDirectory(dirPath) {
   const { readFile: readFile3 } = await import("fs/promises");
-  const { join: join6 } = await import("path");
-  const { readdirSync: readdirSync4 } = await import("fs");
+  const { join: join8 } = await import("path");
+  const { readdirSync: readdirSync5 } = await import("fs");
   async function readJson(filename) {
     try {
-      const content = await readFile3(join6(dirPath, filename), "utf-8");
+      const content = await readFile3(join8(dirPath, filename), "utf-8");
       return JSON.parse(content);
     } catch {
       return void 0;
@@ -2903,10 +2903,10 @@ async function loadWorldFromDirectory(dirPath) {
   const metadataJson = await readJson("metadata.json");
   const rules = [];
   try {
-    const rulesDir = join6(dirPath, "rules");
-    const ruleFiles = readdirSync4(rulesDir).filter((f) => f.endsWith(".json")).sort();
+    const rulesDir = join8(dirPath, "rules");
+    const ruleFiles = readdirSync5(rulesDir).filter((f) => f.endsWith(".json")).sort();
     for (const file of ruleFiles) {
-      const content = await readFile3(join6(rulesDir, file), "utf-8");
+      const content = await readFile3(join8(rulesDir, file), "utf-8");
       rules.push(JSON.parse(content));
     }
   } catch {
@@ -2955,6 +2955,20 @@ var init_world_loader = __esm({
   }
 });
 
+// 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;
+}
+var init_rule_utils = __esm({
+  "src/engine/rule-utils.ts"() {
+    "use strict";
+  }
+});
+
 // src/engine/explain-engine.ts
 function detectTensions(rules) {
   const increases = /* @__PURE__ */ new Map();
@@ -2988,13 +3002,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);
@@ -3145,30 +3152,11 @@ function renderExplainText(output) {
 var init_explain_engine = __esm({
   "src/engine/explain-engine.ts"() {
     "use strict";
+    init_rule_utils();
   }
 });
 
-// src/cli/explain.ts
-var explain_exports = {};
-__export(explain_exports, {
-  main: () => main2
-});
-function parseArgs2(argv) {
-  let worldPath = "";
-  let json = false;
-  for (let i = 0; i < argv.length; i++) {
-    const arg = argv[i];
-    if (arg === "--json") {
-      json = true;
-    } else if (!arg.startsWith("--") && !worldPath) {
-      worldPath = arg;
-    }
-  }
-  if (!worldPath) {
-    throw new Error("Usage: neuroverse explain <world-path-or-id>");
-  }
-  return { worldPath, json };
-}
+// src/cli/cli-utils.ts
 async function resolveWorldPath(input) {
   const { stat } = await import("fs/promises");
   try {
@@ -3191,6 +3179,47 @@ Tried:
 Build a world first: neuroverse build <input.md>`
   );
 }
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString("utf-8");
+}
+function parseCliValue(raw) {
+  if (raw === "true") return true;
+  if (raw === "false") return false;
+  const num = Number(raw);
+  if (!isNaN(num) && raw.trim() !== "") return num;
+  return raw;
+}
+var init_cli_utils = __esm({
+  "src/cli/cli-utils.ts"() {
+    "use strict";
+  }
+});
+
+// src/cli/explain.ts
+var explain_exports = {};
+__export(explain_exports, {
+  main: () => main2
+});
+function parseArgs2(argv) {
+  let worldPath = "";
+  let json = false;
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--json") {
+      json = true;
+    } else if (!arg.startsWith("--") && !worldPath) {
+      worldPath = arg;
+    }
+  }
+  if (!worldPath) {
+    throw new Error("Usage: neuroverse explain <world-path-or-id>");
+  }
+  return { worldPath, json };
+}
 async function main2(argv = process.argv.slice(2)) {
   try {
     const args = parseArgs2(argv);
@@ -3215,6 +3244,7 @@ var init_explain = __esm({
     "use strict";
     init_world_loader();
     init_explain_engine();
+    init_cli_utils();
   }
 });
 
@@ -3550,7 +3580,7 @@ function parseArgs3(argv) {
       if (eqIdx > 0) {
         const key = pair.slice(0, eqIdx);
         const rawValue = pair.slice(eqIdx + 1);
-        stateOverrides[key] = parseValue(rawValue);
+        stateOverrides[key] = parseCliValue(rawValue);
       }
     } else if (!arg.startsWith("--") && !worldPath) {
       worldPath = arg;
@@ -3561,39 +3591,10 @@ function parseArgs3(argv) {
   }
   return { worldPath, steps, stateOverrides, profile, json };
 }
-function parseValue(raw) {
-  if (raw === "true") return true;
-  if (raw === "false") return false;
-  const num = Number(raw);
-  if (!isNaN(num) && raw.trim() !== "") return num;
-  return raw;
-}
-async function resolveWorldPath2(input) {
-  const { stat } = await import("fs/promises");
-  try {
-    const info = await stat(input);
-    if (info.isDirectory()) return input;
-  } catch {
-  }
-  const neuroversePath = `.neuroverse/worlds/${input}`;
-  try {
-    const info = await stat(neuroversePath);
-    if (info.isDirectory()) return neuroversePath;
-  } catch {
-  }
-  throw new Error(
-    `World not found: "${input}"
-Tried:
-  ${input}
-  ${neuroversePath}
-
-Build a world first: neuroverse build <input.md>`
-  );
-}
 async function main3(argv = process.argv.slice(2)) {
   try {
     const args = parseArgs3(argv);
-    const resolvedPath = await resolveWorldPath2(args.worldPath);
+    const resolvedPath = await resolveWorldPath(args.worldPath);
     const world = await loadWorld(resolvedPath);
     const result = simulateWorld(world, {
       steps: args.steps,
@@ -3628,6 +3629,7 @@ var init_simulate = __esm({
     "use strict";
     init_world_loader();
     init_simulate_engine();
+    init_cli_utils();
   }
 });
 
@@ -3988,32 +3990,10 @@ function parseArgs4(argv) {
   }
   return { worldPath, json };
 }
-async function resolveWorldPath3(input) {
-  const { stat } = await import("fs/promises");
-  try {
-    const info = await stat(input);
-    if (info.isDirectory()) return input;
-  } catch {
-  }
-  const neuroversePath = `.neuroverse/worlds/${input}`;
-  try {
-    const info = await stat(neuroversePath);
-    if (info.isDirectory()) return neuroversePath;
-  } catch {
-  }
-  throw new Error(
-    `World not found: "${input}"
-Tried:
-  ${input}
-  ${neuroversePath}
-
-Build a world first: neuroverse build <input.md>`
-  );
-}
 async function main4(argv = process.argv.slice(2)) {
   try {
     const args = parseArgs4(argv);
-    const resolvedPath = await resolveWorldPath3(args.worldPath);
+    const resolvedPath = await resolveWorldPath(args.worldPath);
     const world = await loadWorld(resolvedPath);
     const report = improveWorld(world);
     if (args.json) {
@@ -4047,6 +4027,7 @@ var init_improve = __esm({
     "use strict";
     init_world_loader();
     init_improve_engine();
+    init_cli_utils();
   }
 });
 
@@ -4164,9 +4145,9 @@ function parseArgs5(argv) {
 async function main5(argv = process.argv.slice(2)) {
   try {
     const args = parseArgs5(argv);
-    const { writeFile: writeFile3 } = await import("fs/promises");
-    const { existsSync: existsSync3 } = await import("fs");
-    if (existsSync3(args.outputPath)) {
+    const { writeFile: writeFile5 } = await import("fs/promises");
+    const { existsSync: existsSync5 } = await import("fs");
+    if (existsSync5(args.outputPath)) {
       process.stderr.write(`File already exists: ${args.outputPath}
 `);
       process.stderr.write("Use a different --output path or remove the existing file.\n");
@@ -4174,7 +4155,7 @@ async function main5(argv = process.argv.slice(2)) {
       return;
     }
     const template = generateTemplate(args.name);
-    await writeFile3(args.outputPath, template, "utf-8");
+    await writeFile5(args.outputPath, template, "utf-8");
     const result = {
       created: args.outputPath,
       worldName: args.name,
@@ -4199,119 +4180,898 @@ var init_init = __esm({
   }
 });
 
-// src/contracts/bootstrap-contract.ts
-var BOOTSTRAP_EXIT_CODES;
-var init_bootstrap_contract = __esm({
-  "src/contracts/bootstrap-contract.ts"() {
-    "use strict";
-    BOOTSTRAP_EXIT_CODES = {
-      SUCCESS: 0,
-      FAIL: 1,
-      ERROR: 3
-    };
-  }
-});
-
-// src/cli/bootstrap.ts
-var bootstrap_exports = {};
-__export(bootstrap_exports, {
+// src/cli/init-world.ts
+var init_world_exports = {};
+__export(init_world_exports, {
   main: () => main6
 });
 function parseArgs6(argv) {
-  let inputPath = "";
+  const template = argv[0] || "";
   let outputPath = "";
-  let validate = false;
-  let format = "full";
-  for (let i = 0; i < argv.length; i++) {
+  const config = {};
+  for (let i = 1; i < argv.length; i++) {
     const arg = argv[i];
-    if (arg === "--input" && i + 1 < argv.length) {
-      inputPath = argv[++i];
+    if (arg === "--context" && i + 1 < argv.length) {
+      config.context = argv[++i];
+    } else if (arg === "--dataset" && i + 1 < argv.length) {
+      config.dataset = argv[++i];
+    } else if (arg === "--goal" && i + 1 < argv.length) {
+      config.goal = argv[++i];
+    } else if (arg === "--metric" && i + 1 < argv.length) {
+      config.metric = argv[++i];
+    } else if (arg === "--optimize" && i + 1 < argv.length) {
+      const dir = argv[++i];
+      if (dir === "minimize" || dir === "maximize") {
+        config.optimize = dir;
+      }
+    } else if (arg === "--compute" && i + 1 < argv.length) {
+      config.computeBudgetMinutes = parseInt(argv[++i], 10);
     } else if (arg === "--output" && i + 1 < argv.length) {
       outputPath = argv[++i];
-    } else if (arg === "--validate") {
-      validate = true;
-    } else if (arg === "--format" && i + 1 < argv.length) {
-      const val = argv[++i];
-      if (val === "full" || val === "summary") format = val;
     }
   }
-  if (!inputPath) throw new Error("--input <path> is required");
-  if (!outputPath) throw new Error("--output <path> is required");
-  return { inputPath, outputPath, validate, format };
+  return { template, config, outputPath };
 }
-async function writeWorldFiles2(outputDir, world) {
-  const { writeFile: writeFile3, mkdir: mkdir2 } = await import("fs/promises");
-  const { join: join6 } = await import("path");
-  await mkdir2(outputDir, { recursive: true });
-  await writeFile3(join6(outputDir, "world.json"), JSON.stringify(world.world, null, 2));
-  await writeFile3(join6(outputDir, "invariants.json"), JSON.stringify({ invariants: world.invariants }, null, 2));
-  await writeFile3(join6(outputDir, "assumptions.json"), JSON.stringify(world.assumptions, null, 2));
-  await writeFile3(join6(outputDir, "state-schema.json"), JSON.stringify(world.stateSchema, null, 2));
-  const rulesDir = join6(outputDir, "rules");
-  await mkdir2(rulesDir, { recursive: true });
-  const sortedRules = [...world.rules].sort((a, b) => a.order - b.order);
-  for (let i = 0; i < sortedRules.length; i++) {
-    const ruleNum = String(i + 1).padStart(3, "0");
-    await writeFile3(join6(rulesDir, `rule-${ruleNum}.json`), JSON.stringify(sortedRules[i], null, 2));
+function loadBaseTemplate(template) {
+  let currentDir;
+  try {
+    currentDir = (0, import_path3.dirname)((0, import_url.fileURLToPath)(import_meta2.url));
+  } catch {
+    currentDir = __dirname;
+  }
+  const candidates = [
+    (0, import_path3.join)(currentDir, "..", "worlds", `${template}.nv-world.md`),
+    (0, import_path3.join)(currentDir, "worlds", `${template}.nv-world.md`),
+    // Fallback: resolve from process.cwd()
+    (0, import_path3.join)(process.cwd(), "src", "worlds", `${template}.nv-world.md`)
+  ];
+  for (const candidate of candidates) {
+    if ((0, import_fs.existsSync)(candidate)) {
+      return (0, import_fs.readFileSync)(candidate, "utf-8");
+    }
+  }
+  throw new Error(`Template "${template}" not found. Available: ${AVAILABLE_TEMPLATES.join(", ")}`);
+}
+function customizeAutoresearchWorld(baseTemplate, config) {
+  let output = baseTemplate;
+  if (config.context) {
+    const worldId = config.context.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, "").slice(0, 40);
+    output = output.replace(/^world_id: autoresearch$/m, `world_id: ${worldId}_research`);
+    output = output.replace(/^name: Autoresearch Governance$/m, `name: ${config.context} Research`);
+  }
+  if (config.context) {
+    const customThesis = `Autonomous AI research loops investigating ${config.context} must operate within structured governance: experiments are reproducible, metrics are tracked, compute budgets are enforced, and agents cannot drift beyond their declared research context. A research world without constraints produces noise, not knowledge.`;
+    output = output.replace(
+      /^Autonomous AI research loops must operate.*$/m,
+      customThesis
+    );
+  }
+  if (config.dataset) {
+    output = output.replace(
+      /- `dataset_must_be_declared`[^\n]+/,
+      `- \`dataset_must_be_declared\` \u2014 The dataset "${config.dataset}" must be used for training and evaluation and never changed without governance approval (structural, immutable)`
+    );
+  }
+  if (config.context && config.constraints && config.constraints.length > 0) {
+    const constraintInvariants = config.constraints.map(
+      (c, i) => `- \`custom_constraint_${i + 1}\` \u2014 ${c} (prompt, immutable)`
+    ).join("\n");
+    output = output.replace(
+      /- `architecture_constraints_honored`[^\n]+/,
+      `- \`architecture_constraints_honored\` \u2014 If the research context declares architectural constraints, experiments must satisfy them (prompt, immutable)
+${constraintInvariants}`
+    );
+  }
+  if (config.metric) {
+    output = output.replace(
+      /Best value achieved for the primary evaluation metric/g,
+      `Best value achieved for ${config.metric}`
+    );
+  }
+  if (config.computeBudgetMinutes) {
+    output = output.replace(
+      /- default: 1440\n- label: Compute Budget/,
+      `- default: ${config.computeBudgetMinutes}
+- label: Compute Budget`
+    );
+  }
+  if (config.optimize === "maximize") {
+    output = output.replace(
+      /- default: 100\n- label: Best Metric Value/,
+      "- default: -1000\n- label: Best Metric Value"
+    );
   }
-  await writeFile3(join6(outputDir, "gates.json"), JSON.stringify(world.gates, null, 2));
-  await writeFile3(join6(outputDir, "outcomes.json"), JSON.stringify(world.outcomes, null, 2));
-  await writeFile3(join6(outputDir, "metadata.json"), JSON.stringify(world.metadata, null, 2));
+  return output;
+}
+function generateResearchContext(config) {
+  const context = {
+    research: {
+      context: config.context || "Define your research context",
+      dataset: config.dataset || "Define your dataset",
+      goal: config.goal || "Define your optimization goal",
+      metric: {
+        name: config.metric || "val_bpb",
+        optimization: config.optimize || "minimize"
+      }
+    },
+    roles: config.roles || [
+      "hypothesis_generator",
+      "experiment_runner",
+      "result_evaluator",
+      "critic"
+    ],
+    experiment_loop: {
+      generate_architecture: true,
+      train_model: true,
+      evaluate_results: true,
+      iterate: true
+    },
+    state: {
+      experiments_run: 0,
+      best_result: null,
+      architectures_tested: []
+    }
+  };
+  return JSON.stringify(context, null, 2);
 }
 async function main6(argv = process.argv.slice(2)) {
-  const startTime = performance.now();
   try {
     const args = parseArgs6(argv);
-    const { readFile: readFile3 } = await import("fs/promises");
-    let markdown;
-    try {
-      markdown = await readFile3(args.inputPath, "utf-8");
-    } catch {
-      const errorResult = { error: `Cannot read file: ${args.inputPath}` };
-      process.stderr.write(JSON.stringify(errorResult, null, 2) + "\n");
-      process.exit(BOOTSTRAP_EXIT_CODES.ERROR);
+    if (!args.template) {
+      process.stderr.write("Usage: neuroverse init-world <template> [options]\n\n");
+      process.stderr.write("Available templates:\n");
+      for (const t of AVAILABLE_TEMPLATES) {
+        process.stderr.write(`  ${t}    Generate a governed research world for autonomous AI experiments
+`);
+      }
+      process.stderr.write("\nExample:\n");
+      process.stderr.write('  neuroverse init-world autoresearch --context "attention-free LLM architectures" --dataset "TinyStories"\n');
+      process.exit(1);
       return;
     }
-    const parseResult = parseWorldMarkdown(markdown);
-    const parseErrors = parseResult.issues.filter((i) => i.severity === "error");
-    if (parseErrors.length > 0 || !parseResult.world) {
-      const result2 = {
-        success: false,
-        sourcePath: args.inputPath,
-        issues: parseResult.issues,
-        parsedSections: [],
-        durationMs: performance.now() - startTime
-      };
-      process.stdout.write(JSON.stringify(result2, null, 2) + "\n");
-      process.exit(BOOTSTRAP_EXIT_CODES.FAIL);
+    if (!AVAILABLE_TEMPLATES.includes(args.template)) {
+      process.stderr.write(`Unknown template: "${args.template}"
+`);
+      process.stderr.write(`Available: ${AVAILABLE_TEMPLATES.join(", ")}
+`);
+      process.exit(1);
       return;
     }
-    const emitResult = emitWorldDefinition(parseResult.world);
-    const allIssues = [...parseResult.issues, ...emitResult.issues];
-    await writeWorldFiles2(args.outputPath, emitResult.world);
-    let validateReport;
-    if (args.validate) {
-      const { validateWorld: validateWorld2 } = await Promise.resolve().then(() => (init_validate_engine(), validate_engine_exports));
-      validateReport = validateWorld2(emitResult.world);
+    const worldFileName = args.config.context ? args.config.context.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 40) + ".nv-world.md" : "research.nv-world.md";
+    const outputPath = args.outputPath || `./${worldFileName}`;
+    if ((0, import_fs.existsSync)(outputPath)) {
+      process.stderr.write(`File already exists: ${outputPath}
+`);
+      process.stderr.write("Use --output to specify a different path.\n");
+      process.exit(2);
+      return;
     }
+    const baseTemplate = loadBaseTemplate(args.template);
+    const customized = customizeAutoresearchWorld(baseTemplate, args.config);
+    await (0, import_promises4.writeFile)(outputPath, customized, "utf-8");
+    const contextPath = outputPath.replace(/\.nv-world\.md$/, ".research.json");
+    await (0, import_promises4.writeFile)(contextPath, generateResearchContext(args.config), "utf-8");
     const result = {
-      success: true,
-      sourcePath: args.inputPath,
-      issues: allIssues,
-      parsedSections: Object.keys(parseResult.world).filter((k) => {
-        const val = parseResult.world[k];
-        if (Array.isArray(val)) return val.length > 0;
-        if (typeof val === "string") return val.length > 0;
-        return !!val;
-      }),
-      durationMs: performance.now() - startTime
+      created: {
+        world: outputPath,
+        context: contextPath
+      },
+      template: args.template,
+      config: {
+        context: args.config.context || null,
+        dataset: args.config.dataset || null,
+        goal: args.config.goal || null,
+        metric: args.config.metric || "val_bpb",
+        optimize: args.config.optimize || "minimize",
+        computeBudgetMinutes: args.config.computeBudgetMinutes || 1440
+      },
+      nextSteps: [
+        `Edit ${outputPath} to refine governance rules for your research`,
+        `neuroverse bootstrap --input ${outputPath} --output ./world/ --validate`,
+        `neuroverse simulate ${outputPath} --steps 5`,
+        `neuroverse guard --world ./world/ < experiment.json`,
+        `npx autoresearch run --world ${contextPath}`
+      ]
     };
-    if (validateReport) {
-      result.validateReport = args.format === "summary" ? { summary: validateReport.summary } : validateReport;
-    }
     process.stdout.write(JSON.stringify(result, null, 2) + "\n");
-    const hasErrors = allIssues.some((i) => i.severity === "error");
-    process.exit(hasErrors ? BOOTSTRAP_EXIT_CODES.FAIL : BOOTSTRAP_EXIT_CODES.SUCCESS);
+    process.stderr.write("\n");
+    process.stderr.write(`\u2713 World created: ${outputPath}
+`);
+    process.stderr.write(`\u2713 Research context: ${contextPath}
+`);
+    process.stderr.write("\n");
+    process.stderr.write("Next steps:\n");
+    process.stderr.write(`  Compile world      neuroverse bootstrap --input ${outputPath} --output ./world/ --validate
+`);
+    process.stderr.write(`  Simulate           neuroverse simulate ${outputPath} --steps 5
+`);
+    process.stderr.write(`  Run autoresearch   npx autoresearch run --world ${contextPath}
+`);
+    process.stderr.write(`  Launch dashboard   make dashboard
+`);
+    process.stderr.write("\n");
+    process.exit(0);
+  } catch (e) {
+    process.stderr.write(`init-world failed: ${e instanceof Error ? e.message : e}
+`);
+    process.exit(3);
+  }
+}
+var import_fs, import_promises4, import_path3, import_url, import_meta2, AVAILABLE_TEMPLATES;
+var init_init_world = __esm({
+  "src/cli/init-world.ts"() {
+    "use strict";
+    import_fs = require("fs");
+    import_promises4 = require("fs/promises");
+    import_path3 = require("path");
+    import_url = require("url");
+    import_meta2 = {};
+    AVAILABLE_TEMPLATES = ["autoresearch"];
+  }
+});
+
+// src/cli/infer-world.ts
+var infer_world_exports = {};
+__export(infer_world_exports, {
+  main: () => main7
+});
+function scanRepo(repoPath) {
+  const signals = [];
+  let entries;
+  try {
+    entries = (0, import_fs2.readdirSync)(repoPath);
+  } catch {
+    return signals;
+  }
+  for (const entry of entries) {
+    const lower = entry.toLowerCase();
+    const fullPath = (0, import_path4.join)(repoPath, entry);
+    if (SCAN_PATTERNS[lower]) {
+      signals.push({
+        path: entry,
+        signal: SCAN_PATTERNS[lower].signal,
+        confidence: SCAN_PATTERNS[lower].confidence
+      });
+    }
+    if (entry !== lower && SCAN_PATTERNS[entry]) {
+      signals.push({
+        path: entry,
+        signal: SCAN_PATTERNS[entry].signal,
+        confidence: SCAN_PATTERNS[entry].confidence
+      });
+    }
+    if (lower === "readme.md" || lower === "readme.rst" || lower === "readme.txt") {
+      signals.push({ path: entry, signal: "documentation", confidence: 0.3 });
+    }
+    if (lower === "package.json" || lower === "cargo.toml" || lower === "go.mod") {
+      signals.push({ path: entry, signal: "project manifest", confidence: 0.4 });
+    }
+    try {
+      if ((0, import_fs2.statSync)(fullPath).isDirectory() && RESEARCH_DIRECTORIES.includes(lower)) {
+        signals.push({
+          path: entry + "/",
+          signal: `${lower} directory`,
+          confidence: 0.6
+        });
+      }
+    } catch {
+    }
+  }
+  return signals;
+}
+function readFileContent(path, maxBytes = 5e4) {
+  try {
+    const stat = (0, import_fs2.statSync)(path);
+    if (stat.size > maxBytes) {
+      return (0, import_fs2.readFileSync)(path, { encoding: "utf-8", flag: "r" }).slice(0, maxBytes);
+    }
+    return (0, import_fs2.readFileSync)(path, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function extractFromContent(repoPath, signals) {
+  const result = {
+    architectures: [],
+    constraints: [],
+    goals: []
+  };
+  const filesToRead = [
+    "program.md",
+    "train.py",
+    "train.js",
+    "train.ts",
+    "prepare.py",
+    "config.yaml",
+    "config.json",
+    "dataset.yaml",
+    "dataset.json",
+    "README.md",
+    "readme.md"
+  ];
+  const allContent = [];
+  for (const file of filesToRead) {
+    const content = readFileContent((0, import_path4.join)(repoPath, file));
+    if (content) {
+      allContent.push(content);
+    }
+  }
+  const combined = allContent.join("\n");
+  if (!combined) return result;
+  for (const pattern of DATASET_PATTERNS) {
+    const match = combined.match(pattern);
+    if (match) {
+      result.dataset = match[1] || match[0].trim();
+      break;
+    }
+  }
+  for (const pattern of METRIC_PATTERNS) {
+    const match = combined.match(pattern);
+    if (match) {
+      result.metric = match[0].trim().toLowerCase().replace(/\s+/g, "_");
+      break;
+    }
+  }
+  if (result.metric) {
+    const lossLike = /loss|bpb|perplexity|mse|rmse|mae|error/i.test(result.metric);
+    result.optimization = lossLike ? "minimize" : "maximize";
+  }
+  const archs = /* @__PURE__ */ new Set();
+  for (const pattern of ARCHITECTURE_PATTERNS) {
+    const match = combined.match(pattern);
+    if (match) {
+      archs.add(match[0].trim());
+    }
+  }
+  result.architectures = [...archs];
+  for (const [pattern, framework] of FRAMEWORK_PATTERNS) {
+    if (pattern.test(combined)) {
+      result.framework = framework;
+      break;
+    }
+  }
+  const programContent = readFileContent((0, import_path4.join)(repoPath, "program.md"));
+  if (programContent) {
+    result.hasProgram = true;
+    const lines = programContent.split("\n");
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if ((trimmed.startsWith("- ") || trimmed.startsWith("* ")) && trimmed.length > 10 && trimmed.length < 200) {
+        result.goals.push(trimmed.slice(2).trim());
+      }
+    }
+  }
+  result.hasExperimentLoop = /experiment|loop|iteration|epoch|trial|run|sweep/i.test(combined) && /result|metric|eval|score|loss|accuracy/i.test(combined);
+  return result;
+}
+function classifyEnvironment(signals, extracted) {
+  let type = "unknown";
+  let confidence = 0;
+  const hasTrainCode = signals.some((s) => s.signal.includes("training code"));
+  const hasDataset = !!extracted.dataset;
+  const hasMetric = !!extracted.metric;
+  const hasExperimentLoop = !!extracted.hasExperimentLoop;
+  const hasResearchDirs = signals.some(
+    (s) => ["experiments directory", "results directory", "notebooks directory", "models directory"].includes(s.signal)
+  );
+  const researchScore = (hasTrainCode ? 30 : 0) + (hasDataset ? 20 : 0) + (hasMetric ? 20 : 0) + (hasExperimentLoop ? 15 : 0) + (hasResearchDirs ? 10 : 0) + (extracted.hasProgram ? 15 : 0);
+  if (researchScore >= 40) {
+    type = "research";
+    confidence = Math.min(researchScore, 100);
+  } else if (signals.length > 0) {
+    type = "application";
+    confidence = 30;
+  }
+  return {
+    type,
+    confidence,
+    dataset: extracted.dataset || null,
+    metric: extracted.metric || null,
+    optimization: extracted.optimization || null,
+    framework: extracted.framework || null,
+    architectures: extracted.architectures || [],
+    constraints: extracted.constraints || [],
+    hasExperimentLoop,
+    hasProgram: !!extracted.hasProgram,
+    goals: extracted.goals || [],
+    files: signals
+  };
+}
+function generateWorldFromDetection(env, repoName) {
+  const worldId = repoName.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, "");
+  const dataset = env.dataset || "UNDETECTED";
+  const metric = env.metric || "val_loss";
+  const optimization = env.optimization || "minimize";
+  const framework = env.framework || "Unknown";
+  const architectures = env.architectures.length > 0 ? env.architectures.join(", ") : "not detected";
+  const contextDescription = env.type === "research" ? `ML research using ${framework} on ${dataset}` : `AI application with governance requirements`;
+  const goals = env.goals.length > 0 ? env.goals.slice(0, 3).map((g) => `  - ${g}`).join("\n") : "  - Define research goals here";
+  return `---
+world_id: ${worldId}
+name: ${repoName} Research World
+version: 1.0.0
+runtime_mode: SIMULATION
+default_profile: inferred
+alternative_profile: strict
+---
+
+# Thesis
+
+${contextDescription}. Experiments must be reproducible, metrics must be tracked, and agents must operate within the declared research context. This world was inferred from repository structure \u2014 review and refine the constraints below.
+
+# Invariants
+
+- \`experiments_must_be_reproducible\` \u2014 Every experiment must log architecture, hyperparameters, dataset, and training config sufficient to reproduce results (structural, immutable)
+- \`metrics_must_be_recorded\` \u2014 Every training run must produce the primary evaluation metric (${metric}); runs without metrics are invalid (structural, immutable)
+- \`dataset_is_${dataset.toLowerCase().replace(/[^a-z0-9]+/g, "_")}\` \u2014 The dataset "${dataset}" must be used for training and evaluation (structural, immutable)
+- \`compute_budget_enforced\` \u2014 Experiments must respect declared compute limits (structural, immutable)
+
+# State
+
+## experiments_run
+- type: number
+- min: 0
+- max: 10000
+- step: 1
+- default: 0
+- label: Experiments Run
+- description: Total number of experiments completed
+
+## best_metric_value
+- type: number
+- min: -1000
+- max: 1000
+- step: 0.01
+- default: ${optimization === "minimize" ? "100" : "-1000"}
+- label: Best ${metric}
+- description: Best value achieved for ${metric}
+
+## keep_rate
+- type: number
+- min: 0
+- max: 100
+- step: 1
+- default: 0
+- label: Keep Rate
+- description: Percentage of experiments that improved on the best result
+
+## compute_used_minutes
+- type: number
+- min: 0
+- max: 100000
+- step: 1
+- default: 0
+- label: Compute Used (minutes)
+- description: Total wall-clock training time consumed
+
+## compute_budget_minutes
+- type: number
+- min: 0
+- max: 100000
+- step: 60
+- default: 1440
+- label: Compute Budget (minutes)
+- description: Maximum allowed compute time
+
+## failed_experiments
+- type: number
+- min: 0
+- max: 10000
+- step: 1
+- default: 0
+- label: Failed Experiments
+- description: Number of experiments that failed to produce valid results
+
+# Assumptions
+
+## inferred
+- name: Inferred Configuration
+- description: Configuration inferred from repository structure. Framework: ${framework}. Architectures: ${architectures}.
+- framework: ${framework.toLowerCase().replace(/\s+/g, "_")}
+- dataset: ${dataset.toLowerCase()}
+- metric: ${metric}
+
+## strict
+- name: Strict Configuration
+- description: Conservative settings with tight compute limits and strict reproducibility requirements.
+- framework: ${framework.toLowerCase().replace(/\s+/g, "_")}
+- dataset: ${dataset.toLowerCase()}
+- metric: ${metric}
+
+# Rules
+
+## rule-001: Compute Budget Exhausted (structural)
+When compute budget is exceeded, the research loop must halt.
+
+When compute_used_minutes > compute_budget_minutes [state]
+Then research_viability *= 0.00
+Collapse: research_viability < 0.05
+
+> trigger: Compute usage exceeds declared budget.
+> rule: Compute budget is a hard constraint. Exceeding it halts all experiments.
+> shift: Research loop terminates. Final results are reported.
+> effect: Research viability set to zero.
+
+## rule-002: High Failure Rate (degradation)
+Too many failed experiments indicate a systemic problem.
+
+When failed_experiments > 5 [state] AND experiments_run > 0 [state]
+Then research_viability *= 0.50
+
+> trigger: More than 5 experiments have failed.
+> rule: High failure rates waste compute and signal infrastructure problems.
+> shift: Research viability degrades. Investigation needed.
+> effect: Research viability reduced to 50%.
+
+## rule-003: No Metrics Recorded (structural)
+Experiments without metrics are invalid.
+
+When experiments_run > 0 [state] AND best_metric_value == ${optimization === "minimize" ? "100" : "-1000"} [state]
+Then research_viability *= 0.30
+Collapse: research_viability < 0.05
+
+> trigger: Experiments ran but no metric improvement from default.
+> rule: Research without measurement is not research.
+> shift: Research viability drops sharply.
+> effect: Research viability reduced to 30%.
+
+## rule-004: Strong Progress (advantage)
+Consistent metric improvement validates the research approach.
+
+When keep_rate > 20 [state] AND experiments_run > 5 [state]
+Then research_viability *= 1.20
+
+> trigger: Keep rate above 20% after 5+ experiments.
+> rule: Productive research should be encouraged.
+> shift: Research viability improves.
+> effect: Research viability boosted by 20%.
+
+# Gates
+
+- BREAKTHROUGH: research_viability >= 90
+- PRODUCTIVE: research_viability >= 60
+- ONGOING: research_viability >= 35
+- STRUGGLING: research_viability > 10
+- HALTED: research_viability <= 10
+
+# Outcomes
+
+## research_viability
+- type: number
+- range: 0-100
+- display: percentage
+- label: Research Viability
+- primary: true
+
+## best_metric_value
+- type: number
+- range: -1000-1000
+- display: decimal
+- label: Best ${metric}
+
+## keep_rate
+- type: number
+- range: 0-100
+- display: percentage
+- label: Keep Rate
+`;
+}
+function parseArgs7(argv) {
+  let repoPath = "";
+  let outputPath = "";
+  let json = false;
+  let dryRun = false;
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--output" && i + 1 < argv.length) {
+      outputPath = argv[++i];
+    } else if (arg === "--json") {
+      json = true;
+    } else if (arg === "--dry-run") {
+      dryRun = true;
+    } else if (!arg.startsWith("-") && !repoPath) {
+      repoPath = arg;
+    }
+  }
+  return { repoPath, outputPath, json, dryRun };
+}
+async function main7(argv = process.argv.slice(2)) {
+  try {
+    const args = parseArgs7(argv);
+    if (!args.repoPath) {
+      process.stderr.write("Usage: neuroverse infer-world <repo-path> [options]\n\n");
+      process.stderr.write("Scans an existing repository and generates a governance world file.\n\n");
+      process.stderr.write("Options:\n");
+      process.stderr.write("  --output <path>   Output file path\n");
+      process.stderr.write("  --json            Output detection results as JSON\n");
+      process.stderr.write("  --dry-run         Show detections without writing\n");
+      process.stderr.write("\nExample:\n");
+      process.stderr.write("  neuroverse infer-world ./my-research-repo\n");
+      process.exit(1);
+      return;
+    }
+    const repoPath = (0, import_path4.resolve)(args.repoPath);
+    if (!(0, import_fs2.existsSync)(repoPath)) {
+      process.stderr.write(`Repository not found: ${repoPath}
+`);
+      process.exit(1);
+      return;
+    }
+    process.stderr.write(`Scanning ${repoPath}...
+`);
+    const signals = scanRepo(repoPath);
+    if (signals.length === 0) {
+      process.stderr.write("No recognizable project structure detected.\n");
+      process.exit(2);
+      return;
+    }
+    const extracted = extractFromContent(repoPath, signals);
+    const env = classifyEnvironment(signals, extracted);
+    if (args.json) {
+      process.stdout.write(JSON.stringify(env, null, 2) + "\n");
+      process.exit(0);
+      return;
+    }
+    process.stderr.write("\n");
+    process.stderr.write(`Detected: ${env.type} environment (${env.confidence}% confidence)
+`);
+    if (env.dataset) process.stderr.write(`  Dataset:       ${env.dataset}
+`);
+    if (env.metric) process.stderr.write(`  Metric:        ${env.metric} (${env.optimization})
+`);
+    if (env.framework) process.stderr.write(`  Framework:     ${env.framework}
+`);
+    if (env.architectures.length > 0) process.stderr.write(`  Architectures: ${env.architectures.join(", ")}
+`);
+    if (env.hasExperimentLoop) process.stderr.write(`  Experiment loop detected
+`);
+    if (env.hasProgram) process.stderr.write(`  Program file found (agent instructions)
+`);
+    process.stderr.write("\n");
+    process.stderr.write("  Files analyzed:\n");
+    for (const s of env.files) {
+      process.stderr.write(`    ${s.path} \u2014 ${s.signal}
+`);
+    }
+    process.stderr.write("\n");
+    if (args.dryRun) {
+      process.stderr.write("Dry run \u2014 no files written.\n");
+      process.exit(0);
+      return;
+    }
+    const repoName = (0, import_path4.basename)(repoPath);
+    const worldContent = generateWorldFromDetection(env, repoName);
+    const outputPath = args.outputPath || (0, import_path4.join)(repoPath, "inferred.nv-world.md");
+    if ((0, import_fs2.existsSync)(outputPath)) {
+      process.stderr.write(`File already exists: ${outputPath}
+`);
+      process.stderr.write("Use --output to specify a different path.\n");
+      process.exit(1);
+      return;
+    }
+    await (0, import_promises5.writeFile)(outputPath, worldContent, "utf-8");
+    process.stderr.write(`\u2713 World created: ${outputPath}
+
+`);
+    process.stderr.write("Next steps:\n");
+    process.stderr.write(`  Review and refine   Edit ${outputPath}
+`);
+    process.stderr.write(`  Compile             neuroverse bootstrap --input ${outputPath} --output ./world/ --validate
+`);
+    process.stderr.write(`  Simulate            neuroverse simulate ${outputPath} --steps 5
+`);
+    process.stderr.write("\n");
+    const result = {
+      created: outputPath,
+      environment: env,
+      nextSteps: [
+        `Edit ${outputPath} to refine inferred governance rules`,
+        `neuroverse bootstrap --input ${outputPath} --output ./world/ --validate`,
+        `neuroverse simulate ${outputPath} --steps 5`
+      ]
+    };
+    process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+    process.exit(0);
+  } catch (e) {
+    process.stderr.write(`infer-world failed: ${e instanceof Error ? e.message : e}
+`);
+    process.exit(3);
+  }
+}
+var import_fs2, import_promises5, import_path4, SCAN_PATTERNS, RESEARCH_DIRECTORIES, DATASET_PATTERNS, METRIC_PATTERNS, ARCHITECTURE_PATTERNS, FRAMEWORK_PATTERNS;
+var init_infer_world = __esm({
+  "src/cli/infer-world.ts"() {
+    "use strict";
+    import_fs2 = require("fs");
+    import_promises5 = require("fs/promises");
+    import_path4 = require("path");
+    SCAN_PATTERNS = {
+      "program.md": { signal: "experiment goals / agent instructions", confidence: 0.9 },
+      "train.py": { signal: "model training code", confidence: 0.8 },
+      "train.js": { signal: "model training code", confidence: 0.8 },
+      "train.ts": { signal: "model training code", confidence: 0.8 },
+      "prepare.py": { signal: "data preparation", confidence: 0.7 },
+      "dataset.yaml": { signal: "dataset configuration", confidence: 0.8 },
+      "dataset.json": { signal: "dataset configuration", confidence: 0.8 },
+      "config.yaml": { signal: "project configuration", confidence: 0.5 },
+      "config.json": { signal: "project configuration", confidence: 0.5 },
+      "pyproject.toml": { signal: "Python project", confidence: 0.4 },
+      "requirements.txt": { signal: "Python dependencies", confidence: 0.5 },
+      "setup.py": { signal: "Python package", confidence: 0.4 },
+      "Makefile": { signal: "build automation", confidence: 0.3 },
+      "docker-compose.yml": { signal: "containerized environment", confidence: 0.4 },
+      "Dockerfile": { signal: "containerized environment", confidence: 0.4 }
+    };
+    RESEARCH_DIRECTORIES = ["experiments", "results", "notebooks", "models", "checkpoints", "logs", "data", "eval"];
+    DATASET_PATTERNS = [
+      /dataset\s*[:=]\s*["']?([A-Za-z0-9_\-]+)/i,
+      /--dataset\s+["']?([A-Za-z0-9_\-]+)/i,
+      /load_dataset\(["']([^"']+)/i,
+      /TinyStories/i,
+      /OpenWebText/i,
+      /WikiText/i,
+      /C4/i,
+      /The\s*Pile/i,
+      /MNIST/i,
+      /CIFAR/i,
+      /ImageNet/i
+    ];
+    METRIC_PATTERNS = [
+      /val_bpb/i,
+      /val_loss/i,
+      /val_acc(?:uracy)?/i,
+      /test_acc(?:uracy)?/i,
+      /perplexity/i,
+      /bleu/i,
+      /rouge/i,
+      /f1[_\s]?score/i,
+      /auc/i,
+      /mse/i,
+      /rmse/i,
+      /mae/i
+    ];
+    ARCHITECTURE_PATTERNS = [
+      /transformer/i,
+      /RWKV/i,
+      /SSM/i,
+      /Mamba/i,
+      /linear\s*attention/i,
+      /GPT/i,
+      /BERT/i,
+      /ResNet/i,
+      /CNN/i,
+      /RNN/i,
+      /LSTM/i,
+      /GRU/i,
+      /ViT/i,
+      /diffusion/i,
+      /autoencoder/i,
+      /GAN/i
+    ];
+    FRAMEWORK_PATTERNS = [
+      [/import\s+torch|from\s+torch/i, "PyTorch"],
+      [/import\s+tensorflow|from\s+tensorflow/i, "TensorFlow"],
+      [/import\s+jax|from\s+jax/i, "JAX"],
+      [/from\s+transformers\s+import/i, "HuggingFace Transformers"],
+      [/import\s+keras|from\s+keras/i, "Keras"],
+      [/torch/i, "PyTorch"]
+    ];
+  }
+});
+
+// src/contracts/bootstrap-contract.ts
+var BOOTSTRAP_EXIT_CODES;
+var init_bootstrap_contract = __esm({
+  "src/contracts/bootstrap-contract.ts"() {
+    "use strict";
+    BOOTSTRAP_EXIT_CODES = {
+      SUCCESS: 0,
+      FAIL: 1,
+      ERROR: 3
+    };
+  }
+});
+
+// src/cli/bootstrap.ts
+var bootstrap_exports = {};
+__export(bootstrap_exports, {
+  main: () => main8
+});
+function parseArgs8(argv) {
+  let inputPath = "";
+  let outputPath = "";
+  let validate = false;
+  let format = "full";
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--input" && i + 1 < argv.length) {
+      inputPath = argv[++i];
+    } else if (arg === "--output" && i + 1 < argv.length) {
+      outputPath = argv[++i];
+    } else if (arg === "--validate") {
+      validate = true;
+    } else if (arg === "--format" && i + 1 < argv.length) {
+      const val = argv[++i];
+      if (val === "full" || val === "summary") format = val;
+    }
+  }
+  if (!inputPath) throw new Error("--input <path> is required");
+  if (!outputPath) throw new Error("--output <path> is required");
+  return { inputPath, outputPath, validate, format };
+}
+async function writeWorldFiles2(outputDir, world) {
+  const { writeFile: writeFile5, mkdir: mkdir2 } = await import("fs/promises");
+  const { join: join8 } = await import("path");
+  await mkdir2(outputDir, { recursive: true });
+  await writeFile5(join8(outputDir, "world.json"), JSON.stringify(world.world, null, 2));
+  await writeFile5(join8(outputDir, "invariants.json"), JSON.stringify({ invariants: world.invariants }, null, 2));
+  await writeFile5(join8(outputDir, "assumptions.json"), JSON.stringify(world.assumptions, null, 2));
+  await writeFile5(join8(outputDir, "state-schema.json"), JSON.stringify(world.stateSchema, null, 2));
+  const rulesDir = join8(outputDir, "rules");
+  await mkdir2(rulesDir, { recursive: true });
+  const sortedRules = [...world.rules].sort((a, b) => a.order - b.order);
+  for (let i = 0; i < sortedRules.length; i++) {
+    const ruleNum = String(i + 1).padStart(3, "0");
+    await writeFile5(join8(rulesDir, `rule-${ruleNum}.json`), JSON.stringify(sortedRules[i], null, 2));
+  }
+  await writeFile5(join8(outputDir, "gates.json"), JSON.stringify(world.gates, null, 2));
+  await writeFile5(join8(outputDir, "outcomes.json"), JSON.stringify(world.outcomes, null, 2));
+  await writeFile5(join8(outputDir, "metadata.json"), JSON.stringify(world.metadata, null, 2));
+}
+async function main8(argv = process.argv.slice(2)) {
+  const startTime = performance.now();
+  try {
+    const args = parseArgs8(argv);
+    const { readFile: readFile3 } = await import("fs/promises");
+    let markdown;
+    try {
+      markdown = await readFile3(args.inputPath, "utf-8");
+    } catch {
+      const errorResult = { error: `Cannot read file: ${args.inputPath}` };
+      process.stderr.write(JSON.stringify(errorResult, null, 2) + "\n");
+      process.exit(BOOTSTRAP_EXIT_CODES.ERROR);
+      return;
+    }
+    const parseResult = parseWorldMarkdown(markdown);
+    const parseErrors = parseResult.issues.filter((i) => i.severity === "error");
+    if (parseErrors.length > 0 || !parseResult.world) {
+      const result2 = {
+        success: false,
+        sourcePath: args.inputPath,
+        issues: parseResult.issues,
+        parsedSections: [],
+        durationMs: performance.now() - startTime
+      };
+      process.stdout.write(JSON.stringify(result2, null, 2) + "\n");
+      process.exit(BOOTSTRAP_EXIT_CODES.FAIL);
+      return;
+    }
+    const emitResult = emitWorldDefinition(parseResult.world);
+    const allIssues = [...parseResult.issues, ...emitResult.issues];
+    await writeWorldFiles2(args.outputPath, emitResult.world);
+    let validateReport;
+    if (args.validate) {
+      const { validateWorld: validateWorld2 } = await Promise.resolve().then(() => (init_validate_engine(), validate_engine_exports));
+      validateReport = validateWorld2(emitResult.world);
+    }
+    const result = {
+      success: true,
+      sourcePath: args.inputPath,
+      issues: allIssues,
+      parsedSections: Object.keys(parseResult.world).filter((k) => {
+        const val = parseResult.world[k];
+        if (Array.isArray(val)) return val.length > 0;
+        if (typeof val === "string") return val.length > 0;
+        return !!val;
+      }),
+      durationMs: performance.now() - startTime
+    };
+    if (validateReport) {
+      result.validateReport = args.format === "summary" ? { summary: validateReport.summary } : validateReport;
+    }
+    process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+    const hasErrors = allIssues.some((i) => i.severity === "error");
+    process.exit(hasErrors ? BOOTSTRAP_EXIT_CODES.FAIL : BOOTSTRAP_EXIT_CODES.SUCCESS);
   } catch (e) {
     const errorResult = { error: "Bootstrap failed", detail: String(e) };
     process.stderr.write(JSON.stringify(errorResult, null, 2) + "\n");
@@ -4344,9 +5104,9 @@ var init_validate_contract = __esm({
 // src/cli/validate.ts
 var validate_exports = {};
 __export(validate_exports, {
-  main: () => main7
+  main: () => main9
 });
-function parseArgs7(argv) {
+function parseArgs9(argv) {
   let worldPath = "";
   let format = "full";
   let mode = "standard";
@@ -4391,9 +5151,9 @@ function formatOutput(report, format) {
   }
   return JSON.stringify(report, null, 2);
 }
-async function main7(argv = process.argv.slice(2)) {
+async function main9(argv = process.argv.slice(2)) {
   try {
-    const args = parseArgs7(argv);
+    const args = parseArgs9(argv);
     const world = await loadWorld(args.worldPath);
     const report = validateWorld(world, args.mode);
     process.stdout.write(formatOutput(report, args.format) + "\n");
@@ -4421,17 +5181,27 @@ var init_validate = __esm({
   }
 });
 
-// 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));
@@ -4444,6 +5214,24 @@ function tokenSimilarity(a, b) {
   const union = (/* @__PURE__ */ new Set([...tokensA, ...tokensB])).size;
   return union > 0 ? intersection / union : 0;
 }
+var init_text_utils = __esm({
+  "src/engine/text-utils.ts"() {
+    "use strict";
+  }
+});
+
+// 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) {
@@ -4462,7 +5250,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;
@@ -4503,7 +5291,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,
@@ -4584,11 +5372,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 {
@@ -4629,7 +5413,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);
@@ -4649,6 +5433,7 @@ function buildPlanCheck(event, plan, verdict) {
 var init_plan_engine = __esm({
   "src/engine/plan-engine.ts"() {
     "use strict";
+    init_text_utils();
   }
 });
 
@@ -4682,7 +5467,7 @@ 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();
+  const eventText = normalizeEventText(event);
   const invariantChecks = [];
   const safetyChecks = [];
   let planCheckResult;
@@ -4695,6 +5480,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)) {
@@ -4822,7 +5644,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,
@@ -4845,6 +5676,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);
@@ -5139,6 +5974,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}` };
     }
@@ -5248,9 +6098,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()}`;
@@ -5316,6 +6164,7 @@ var init_guard_engine = __esm({
   "src/engine/guard-engine.ts"() {
     "use strict";
     init_plan_engine();
+    init_text_utils();
     PROMPT_INJECTION_PATTERNS = [
       // Instruction override
       { pattern: /ignore\s+(previous|all|prior|above)\s+(instructions?|rules?)/i, label: "ignore-instructions" },
@@ -5384,31 +6233,31 @@ var init_guard_engine = __esm({
 
 // src/loader/world-resolver.ts
 function listWorlds(cwd = process.cwd()) {
-  const worldsDir = (0, import_path3.join)(cwd, WORLDS_DIR);
-  if (!(0, import_fs.existsSync)(worldsDir)) return [];
+  const worldsDir = (0, import_path5.join)(cwd, WORLDS_DIR);
+  if (!(0, import_fs3.existsSync)(worldsDir)) return [];
   const activeName = getActiveWorldName(cwd);
-  const entries = (0, import_fs.readdirSync)(worldsDir);
+  const entries = (0, import_fs3.readdirSync)(worldsDir);
   return entries.filter((name) => {
-    const worldJson = (0, import_path3.join)(worldsDir, name, "world.json");
-    return (0, import_fs.existsSync)(worldJson);
+    const worldJson = (0, import_path5.join)(worldsDir, name, "world.json");
+    return (0, import_fs3.existsSync)(worldJson);
   }).map((name) => ({
     name,
-    path: (0, import_path3.join)(worldsDir, name),
+    path: (0, import_path5.join)(worldsDir, name),
     active: name === activeName
   })).sort((a, b) => a.name.localeCompare(b.name));
 }
 function getActiveWorldName(cwd = process.cwd()) {
-  const filePath = (0, import_path3.join)(cwd, ACTIVE_WORLD_FILE);
+  const filePath = (0, import_path5.join)(cwd, ACTIVE_WORLD_FILE);
   try {
-    return (0, import_fs.readFileSync)(filePath, "utf-8").trim() || void 0;
+    return (0, import_fs3.readFileSync)(filePath, "utf-8").trim() || void 0;
   } catch {
     return void 0;
   }
 }
 function setActiveWorld(name, cwd = process.cwd()) {
-  const worldsDir = (0, import_path3.join)(cwd, WORLDS_DIR);
-  const worldPath = (0, import_path3.join)(worldsDir, name, "world.json");
-  if (!(0, import_fs.existsSync)(worldPath)) {
+  const worldsDir = (0, import_path5.join)(cwd, WORLDS_DIR);
+  const worldPath = (0, import_path5.join)(worldsDir, name, "world.json");
+  if (!(0, import_fs3.existsSync)(worldPath)) {
     const available = listWorlds(cwd);
     const names = available.map((w) => w.name).join(", ");
     throw new Error(
@@ -5416,11 +6265,11 @@ function setActiveWorld(name, cwd = process.cwd()) {
 ` + (names ? `Available: ${names}` : "No worlds found. Run `neuroverse build` first.")
     );
   }
-  const dir = (0, import_path3.join)(cwd, ".neuroverse");
-  if (!(0, import_fs.existsSync)(dir)) (0, import_fs.mkdirSync)(dir, { recursive: true });
-  (0, import_fs.writeFileSync)((0, import_path3.join)(cwd, ACTIVE_WORLD_FILE), name + "\n", "utf-8");
+  const dir = (0, import_path5.join)(cwd, ".neuroverse");
+  if (!(0, import_fs3.existsSync)(dir)) (0, import_fs3.mkdirSync)(dir, { recursive: true });
+  (0, import_fs3.writeFileSync)((0, import_path5.join)(cwd, ACTIVE_WORLD_FILE), name + "\n", "utf-8");
 }
-function resolveWorldPath4(explicit, cwd = process.cwd()) {
+function resolveWorldPath2(explicit, cwd = process.cwd()) {
   if (explicit) {
     return resolveNameOrPath(explicit, cwd);
   }
@@ -5434,7 +6283,7 @@ function resolveWorldPath4(explicit, cwd = process.cwd()) {
   }
   const worlds = listWorlds(cwd);
   if (worlds.length === 1) {
-    return (0, import_path3.resolve)(worlds[0].path);
+    return (0, import_path5.resolve)(worlds[0].path);
   }
   return void 0;
 }
@@ -5457,21 +6306,21 @@ function describeActiveWorld(explicit, cwd = process.cwd()) {
   return void 0;
 }
 function resolveNameOrPath(ref, cwd) {
-  if (ref.includes("/") || ref.includes("\\") || ref.startsWith(".") || (0, import_path3.isAbsolute)(ref)) {
-    return (0, import_path3.resolve)(cwd, ref);
+  if (ref.includes("/") || ref.includes("\\") || ref.startsWith(".") || (0, import_path5.isAbsolute)(ref)) {
+    return (0, import_path5.resolve)(cwd, ref);
   }
-  const namedPath = (0, import_path3.join)(cwd, WORLDS_DIR, ref);
-  if ((0, import_fs.existsSync)((0, import_path3.join)(namedPath, "world.json"))) {
-    return (0, import_path3.resolve)(namedPath);
+  const namedPath = (0, import_path5.join)(cwd, WORLDS_DIR, ref);
+  if ((0, import_fs3.existsSync)((0, import_path5.join)(namedPath, "world.json"))) {
+    return (0, import_path5.resolve)(namedPath);
   }
-  return (0, import_path3.resolve)(cwd, ref);
+  return (0, import_path5.resolve)(cwd, ref);
 }
-var import_fs, import_path3, WORLDS_DIR, ACTIVE_WORLD_FILE;
+var import_fs3, import_path5, WORLDS_DIR, ACTIVE_WORLD_FILE;
 var init_world_resolver = __esm({
   "src/loader/world-resolver.ts"() {
     "use strict";
-    import_fs = require("fs");
-    import_path3 = require("path");
+    import_fs3 = require("fs");
+    import_path5 = require("path");
     WORLDS_DIR = ".neuroverse/worlds";
     ACTIVE_WORLD_FILE = ".neuroverse/active_world";
   }
@@ -5486,7 +6335,11 @@ var init_guard_contract = __esm({
       ALLOW: 0,
       BLOCK: 1,
       PAUSE: 2,
-      ERROR: 3
+      ERROR: 3,
+      MODIFY: 4,
+      PENALIZE: 5,
+      REWARD: 6,
+      NEUTRAL: 7
     };
   }
 });
@@ -5494,9 +6347,9 @@ var init_guard_contract = __esm({
 // src/cli/guard.ts
 var guard_exports = {};
 __export(guard_exports, {
-  main: () => main8
+  main: () => main10
 });
-function parseArgs8(argv) {
+function parseArgs10(argv) {
   let worldPath = "";
   let trace = false;
   let level;
@@ -5517,17 +6370,10 @@ function parseArgs8(argv) {
   }
   return { worldPath, trace, level };
 }
-async function readStdin() {
-  const chunks = [];
-  for await (const chunk of process.stdin) {
-    chunks.push(chunk);
-  }
-  return Buffer.concat(chunks).toString("utf-8");
-}
-async function main8(argv = process.argv.slice(2)) {
+async function main10(argv = process.argv.slice(2)) {
   try {
-    const args = parseArgs8(argv);
-    const worldPath = resolveWorldPath4(args.worldPath);
+    const args = parseArgs10(argv);
+    const worldPath = resolveWorldPath2(args.worldPath);
     if (!worldPath) {
       throw new Error(
         "No world specified. Use --world <path>, set NEUROVERSE_WORLD, or run `neuroverse world use <name>`"
@@ -5579,13 +6425,14 @@ var init_guard = __esm({
     init_world_loader();
     init_world_resolver();
     init_guard_contract();
+    init_cli_utils();
   }
 });
 
 // src/cli/test.ts
 var test_exports = {};
 __export(test_exports, {
-  main: () => main9
+  main: () => main11
 });
 function generateFuzzEvent() {
   const verb = FUZZ_VERBS[Math.floor(Math.random() * FUZZ_VERBS.length)];
@@ -5603,7 +6450,7 @@ function generateFuzzEvent() {
     }
   };
 }
-function parseArgs9(argv) {
+function parseArgs11(argv) {
   let worldPath;
   let fuzz = false;
   let count = 20;
@@ -5619,8 +6466,8 @@ function parseArgs9(argv) {
   }
   return { worldPath, fuzz, count, json, level };
 }
-async function main9(argv) {
-  const args = parseArgs9(argv);
+async function main11(argv) {
+  const args = parseArgs11(argv);
   if (!args.worldPath) {
     process.stderr.write("Usage: neuroverse test --world <dir> [--fuzz] [--count N] [--json]\n");
     process.exit(1);
@@ -5803,9 +6650,9 @@ var init_test = __esm({
 // src/cli/redteam.ts
 var redteam_exports = {};
 __export(redteam_exports, {
-  main: () => main10
+  main: () => main12
 });
-function parseArgs10(argv) {
+function parseArgs12(argv) {
   let worldPath;
   let level = "standard";
   let json = false;
@@ -5817,8 +6664,8 @@ function parseArgs10(argv) {
   }
   return { worldPath, level, json };
 }
-async function main10(argv) {
-  const args = parseArgs10(argv);
+async function main12(argv) {
+  const args = parseArgs12(argv);
   if (!args.worldPath) {
     process.stderr.write("Usage: neuroverse redteam --world <dir> [--level basic|standard|strict] [--json]\n");
     process.exit(1);
@@ -6158,6 +7005,552 @@ var init_redteam = __esm({
   }
 });
 
+// src/adapters/autoresearch.ts
+var autoresearch_exports = {};
+__export(autoresearch_exports, {
+  AutoresearchGovernor: () => AutoresearchGovernor
+});
+var AutoresearchGovernor;
+var init_autoresearch = __esm({
+  "src/adapters/autoresearch.ts"() {
+    "use strict";
+    AutoresearchGovernor = class {
+      config;
+      state;
+      constructor(config) {
+        this.config = config;
+        this.state = {
+          experiments_run: 0,
+          best_result: null,
+          architectures_tested: [],
+          experiment_log: [],
+          total_compute_minutes: 0,
+          keep_count: 0
+        };
+      }
+      /**
+       * Convert an experiment proposal into a GuardEvent for governance evaluation.
+       */
+      proposalToGuardEvent(proposal) {
+        return {
+          intent: `run experiment: ${proposal.description}`,
+          tool: "experiment_runner",
+          scope: "experiment",
+          roleId: "experiment_runner",
+          direction: "output",
+          actionCategory: "shell",
+          args: {
+            experiment_id: String(proposal.experiment_id),
+            architecture: proposal.architecture,
+            estimated_minutes: String(proposal.estimated_minutes || 5)
+          }
+        };
+      }
+      /**
+       * Evaluate an experiment proposal against governance rules.
+       * Returns a simplified verdict without requiring the full guard engine.
+       */
+      evaluateProposal(proposal) {
+        const warnings = [];
+        const estimatedMinutes = proposal.estimated_minutes || 5;
+        if (this.state.total_compute_minutes + estimatedMinutes > this.config.computeBudgetMinutes) {
+          return {
+            allowed: false,
+            reason: `Compute budget exhausted: ${this.state.total_compute_minutes}/${this.config.computeBudgetMinutes} minutes used`,
+            warnings
+          };
+        }
+        if (this.config.constraints) {
+          for (const constraint of this.config.constraints) {
+            const lower = constraint.toLowerCase();
+            const archLower = proposal.architecture.toLowerCase();
+            const descLower = proposal.description.toLowerCase();
+            if (lower.startsWith("no ")) {
+              const forbidden = lower.slice(3).trim();
+              if (archLower.includes(forbidden) || descLower.includes(forbidden)) {
+                return {
+                  allowed: false,
+                  reason: `Architecture constraint violated: ${constraint}`,
+                  warnings
+                };
+              }
+            }
+          }
+        }
+        const failureCount = this.state.experiment_log.filter((e) => !e.success).length;
+        if (failureCount > 5) {
+          warnings.push(`High failure rate: ${failureCount} failed experiments. Consider investigating root cause.`);
+        }
+        const recentArchitectures = this.state.experiment_log.slice(-5).map((e) => e.architecture);
+        const uniqueRecent = new Set(recentArchitectures).size;
+        if (recentArchitectures.length >= 5 && uniqueRecent === 1) {
+          warnings.push("Research may be stuck: last 5 experiments used the same architecture.");
+        }
+        return { allowed: true, reason: "Experiment approved", warnings };
+      }
+      /**
+       * Record an experiment result and update research state.
+       */
+      recordResult(result) {
+        this.state.experiments_run++;
+        this.state.total_compute_minutes += result.wall_clock_minutes;
+        this.state.experiment_log.push(result);
+        if (!this.state.architectures_tested.includes(result.architecture)) {
+          this.state.architectures_tested.push(result.architecture);
+        }
+        if (!result.success) {
+          return { kept: false, improvement: null, state: { ...this.state } };
+        }
+        let kept = false;
+        let improvement = null;
+        if (this.state.best_result === null) {
+          kept = true;
+          this.state.best_result = result;
+          this.state.keep_count++;
+        } else {
+          const prev = this.state.best_result.metric_value;
+          const curr = result.metric_value;
+          if (this.config.optimize === "minimize") {
+            kept = curr < prev;
+            improvement = kept ? prev - curr : null;
+          } else {
+            kept = curr > prev;
+            improvement = kept ? curr - prev : null;
+          }
+          if (kept) {
+            this.state.best_result = result;
+            this.state.keep_count++;
+          }
+        }
+        return { kept, improvement, state: { ...this.state } };
+      }
+      /**
+       * Export current state as a state snapshot compatible with the world file.
+       */
+      toWorldState() {
+        const successfulExperiments = this.state.experiment_log.filter((e) => e.success);
+        const failedCount = this.state.experiment_log.filter((e) => !e.success).length;
+        const keepRate = this.state.experiments_run > 0 ? Math.round(this.state.keep_count / this.state.experiments_run * 100) : 0;
+        let improvementRate = 0;
+        if (successfulExperiments.length >= 2) {
+          const recent = successfulExperiments.slice(-10);
+          let improvements = 0;
+          for (let i = 1; i < recent.length; i++) {
+            const prev = recent[i - 1].metric_value;
+            const curr = recent[i].metric_value;
+            if (this.config.optimize === "minimize" ? curr < prev : curr > prev) {
+              improvements++;
+            }
+          }
+          improvementRate = Math.round(improvements / (recent.length - 1) * 100);
+        }
+        return {
+          experiments_run: this.state.experiments_run,
+          best_metric_value: this.state.best_result?.metric_value ?? (this.config.optimize === "minimize" ? 100 : -1e3),
+          keep_rate: keepRate,
+          compute_used_minutes: Math.round(this.state.total_compute_minutes),
+          compute_budget_minutes: this.config.computeBudgetMinutes,
+          failed_experiments: failedCount,
+          metric_improvement_rate: improvementRate,
+          research_context_drift: 0
+          // would need NLP to compute properly
+        };
+      }
+      /**
+       * Get a summary of the current research state.
+       */
+      getSummary() {
+        return {
+          experiments_run: this.state.experiments_run,
+          best_result: this.state.best_result,
+          keep_rate: this.state.experiments_run > 0 ? Math.round(this.state.keep_count / this.state.experiments_run * 100) : 0,
+          compute_remaining_minutes: this.config.computeBudgetMinutes - this.state.total_compute_minutes,
+          architectures_tested: [...this.state.architectures_tested]
+        };
+      }
+      /**
+       * Load state from a persisted research context file.
+       */
+      loadState(state) {
+        this.state = { ...state };
+      }
+      /**
+       * Export state for persistence.
+       */
+      exportState() {
+        return { ...this.state };
+      }
+    };
+  }
+});
+
+// src/adapters/shared.ts
+var shared_exports = {};
+__export(shared_exports, {
+  GovernanceBlockedError: () => GovernanceBlockedError,
+  buildEngineOptions: () => buildEngineOptions,
+  defaultBlockMessage: () => defaultBlockMessage,
+  extractScope: () => extractScope,
+  trackPlanProgress: () => trackPlanProgress
+});
+function trackPlanProgress(event, state, callbacks) {
+  if (!state.activePlan) return;
+  const planVerdict = evaluatePlan(event, state.activePlan);
+  if (planVerdict.matchedStep) {
+    const advResult = advancePlan(state.activePlan, planVerdict.matchedStep);
+    if (advResult.success && advResult.plan) {
+      state.activePlan = advResult.plan;
+      state.engineOptions.plan = state.activePlan;
+    }
+    const progress = getPlanProgress(state.activePlan);
+    callbacks.onPlanProgress?.(progress);
+    if (progress.completed === progress.total) {
+      callbacks.onPlanComplete?.();
+    }
+  }
+}
+function extractScope(args) {
+  if (typeof args.path === "string") return args.path;
+  if (typeof args.file_path === "string") return args.file_path;
+  if (typeof args.filename === "string") return args.filename;
+  if (typeof args.url === "string") return args.url;
+  if (typeof args.command === "string") return args.command;
+  return void 0;
+}
+function buildEngineOptions(options, plan) {
+  return {
+    trace: options.trace ?? false,
+    level: options.level,
+    plan: plan ?? options.plan
+  };
+}
+function defaultBlockMessage(verdict) {
+  return `Action blocked by governance policy: ${verdict.reason ?? "rule violation"}. Rule: ${verdict.ruleId ?? "unknown"}.`;
+}
+var GovernanceBlockedError;
+var init_shared = __esm({
+  "src/adapters/shared.ts"() {
+    "use strict";
+    init_plan_engine();
+    GovernanceBlockedError = class extends Error {
+      verdict;
+      constructor(verdict, message) {
+        super(message ?? `[NeuroVerse] BLOCKED: ${verdict.reason ?? verdict.ruleId ?? "governance rule"}`);
+        this.name = "GovernanceBlockedError";
+        this.verdict = verdict;
+      }
+    };
+  }
+});
+
+// src/engine/tool-classifier.ts
+function classifyTool(toolName) {
+  const normalized = toolName.toLowerCase().replace(/[-\s]/g, "_");
+  return TOOL_CATEGORY_MAP[normalized] ?? "unknown";
+}
+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";
+}
+var TOOL_CATEGORY_MAP, DANGEROUS_SHELL_PATTERNS, DANGEROUS_GIT_PATTERNS;
+var init_tool_classifier = __esm({
+  "src/engine/tool-classifier.ts"() {
+    "use strict";
+    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"
+    };
+    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" }
+    ];
+    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" }
+    ];
+  }
+});
+
+// src/adapters/deep-agents.ts
+var deep_agents_exports = {};
+__export(deep_agents_exports, {
+  DeepAgentsGuard: () => DeepAgentsGuard,
+  GovernanceBlockedError: () => GovernanceBlockedError2,
+  createDeepAgentsGuard: () => createDeepAgentsGuard,
+  createDeepAgentsGuardFromWorld: () => createDeepAgentsGuardFromWorld
+});
+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
+  };
+}
+async function createDeepAgentsGuard(worldPath, options) {
+  const world = await loadWorld(worldPath);
+  return new DeepAgentsGuard(world, options);
+}
+function createDeepAgentsGuardFromWorld(world, options) {
+  return new DeepAgentsGuard(world, options);
+}
+var GovernanceBlockedError2, DeepAgentsGuard;
+var init_deep_agents = __esm({
+  "src/adapters/deep-agents.ts"() {
+    "use strict";
+    init_guard_engine();
+    init_world_loader();
+    init_shared();
+    init_tool_classifier();
+    GovernanceBlockedError2 = class extends GovernanceBlockedError {
+      toolCall;
+      category;
+      constructor(verdict, toolCall, category) {
+        super(verdict);
+        this.toolCall = toolCall;
+        this.category = category;
+      }
+    };
+    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);
+      }
+    };
+  }
+});
+
 // src/adapters/express.ts
 var express_exports = {};
 __export(express_exports, {
@@ -6262,16 +7655,16 @@ var init_express = __esm({
 // src/adapters/langchain.ts
 var langchain_exports = {};
 __export(langchain_exports, {
-  GovernanceBlockedError: () => GovernanceBlockedError,
+  GovernanceBlockedError: () => GovernanceBlockedError3,
   NeuroVerseCallbackHandler: () => NeuroVerseCallbackHandler,
   createNeuroVerseCallbackHandler: () => createNeuroVerseCallbackHandler,
   createNeuroVerseCallbackHandlerFromWorld: () => createNeuroVerseCallbackHandlerFromWorld
 });
-function defaultMapToolCall(toolName, toolInput) {
+function defaultMapToolCall2(toolName, toolInput) {
   return {
     intent: toolName,
     tool: toolName,
-    scope: typeof toolInput.path === "string" ? toolInput.path : typeof toolInput.url === "string" ? toolInput.url : void 0,
+    scope: extractScope(toolInput),
     args: toolInput,
     direction: "input"
   };
@@ -6283,20 +7676,17 @@ async function createNeuroVerseCallbackHandler(worldPath, options) {
 function createNeuroVerseCallbackHandlerFromWorld(world, options) {
   return new NeuroVerseCallbackHandler(world, options);
 }
-var GovernanceBlockedError, NeuroVerseCallbackHandler;
+var GovernanceBlockedError3, NeuroVerseCallbackHandler;
 var init_langchain = __esm({
   "src/adapters/langchain.ts"() {
     "use strict";
     init_guard_engine();
-    init_plan_engine();
     init_world_loader();
-    GovernanceBlockedError = class extends Error {
-      verdict;
+    init_shared();
+    GovernanceBlockedError3 = class extends GovernanceBlockedError {
       event;
       constructor(verdict, event) {
-        super(`[NeuroVerse] BLOCKED: ${verdict.reason ?? verdict.ruleId ?? "governance rule"}`);
-        this.name = "GovernanceBlockedError";
-        this.verdict = verdict;
+        super(verdict);
         this.event = event;
       }
     };
@@ -6311,12 +7701,8 @@ var init_langchain = __esm({
         this.world = world;
         this.options = options;
         this.activePlan = options.plan;
-        this.engineOptions = {
-          trace: options.trace ?? false,
-          level: options.level,
-          plan: this.activePlan
-        };
-        this.mapToolCall = options.mapToolCall ?? defaultMapToolCall;
+        this.engineOptions = buildEngineOptions(options, this.activePlan);
+        this.mapToolCall = options.mapToolCall ?? defaultMapToolCall2;
       }
       /**
        * Called before a tool is executed.
@@ -6338,28 +7724,16 @@ var init_langchain = __esm({
         this.options.onEvaluate?.(verdict, event);
         if (verdict.status === "BLOCK") {
           this.options.onBlock?.(verdict, event);
-          throw new GovernanceBlockedError(verdict, event);
+          throw new GovernanceBlockedError3(verdict, event);
         }
         if (verdict.status === "PAUSE") {
           const approved = await this.options.onPause?.(verdict, event);
           if (!approved) {
-            throw new GovernanceBlockedError(verdict, event);
+            throw new GovernanceBlockedError3(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?.();
-            }
-          }
+        if (verdict.status === "ALLOW") {
+          trackPlanProgress(event, this, this.options);
         }
       }
     };
@@ -6369,7 +7743,7 @@ var init_langchain = __esm({
 // src/adapters/openai.ts
 var openai_exports = {};
 __export(openai_exports, {
-  GovernanceBlockedError: () => GovernanceBlockedError2,
+  GovernanceBlockedError: () => GovernanceBlockedError4,
   GovernedToolExecutor: () => GovernedToolExecutor,
   createGovernedToolExecutor: () => createGovernedToolExecutor,
   createGovernedToolExecutorFromWorld: () => createGovernedToolExecutorFromWorld
@@ -6378,14 +7752,11 @@ function defaultMapFunctionCall(name, args) {
   return {
     intent: name,
     tool: name,
-    scope: typeof args.path === "string" ? args.path : typeof args.url === "string" ? args.url : void 0,
+    scope: extractScope(args),
     args,
     direction: "input"
   };
 }
-function defaultBlockMessage(verdict) {
-  return `Action blocked by governance policy: ${verdict.reason ?? "rule violation"}. Rule: ${verdict.ruleId ?? "unknown"}.`;
-}
 async function createGovernedToolExecutor(worldPath, options) {
   const world = await loadWorld(worldPath);
   return new GovernedToolExecutor(world, options);
@@ -6393,20 +7764,17 @@ async function createGovernedToolExecutor(worldPath, options) {
 function createGovernedToolExecutorFromWorld(world, options) {
   return new GovernedToolExecutor(world, options);
 }
-var GovernanceBlockedError2, GovernedToolExecutor;
+var GovernanceBlockedError4, GovernedToolExecutor;
 var init_openai = __esm({
   "src/adapters/openai.ts"() {
     "use strict";
     init_guard_engine();
-    init_plan_engine();
     init_world_loader();
-    GovernanceBlockedError2 = class extends Error {
-      verdict;
+    init_shared();
+    GovernanceBlockedError4 = class extends GovernanceBlockedError {
       toolCallId;
       constructor(verdict, toolCallId) {
-        super(`[NeuroVerse] BLOCKED: ${verdict.reason ?? verdict.ruleId ?? "governance rule"}`);
-        this.name = "GovernanceBlockedError";
-        this.verdict = verdict;
+        super(verdict);
         this.toolCallId = toolCallId;
       }
     };
@@ -6421,11 +7789,7 @@ var init_openai = __esm({
         this.world = world;
         this.options = options;
         this.activePlan = options.plan;
-        this.engineOptions = {
-          trace: options.trace ?? false,
-          level: options.level,
-          plan: this.activePlan
-        };
+        this.engineOptions = buildEngineOptions(options, this.activePlan);
         this.mapFn = options.mapFunctionCall ?? defaultMapFunctionCall;
         this.blockMsg = options.blockMessage ?? defaultBlockMessage;
       }
@@ -6444,20 +7808,8 @@ var init_openai = __esm({
         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?.();
-            }
-          }
+        if (verdict.status === "ALLOW") {
+          trackPlanProgress(event, this, this.options);
         }
         return verdict;
       }
@@ -6483,7 +7835,7 @@ var init_openai = __esm({
           };
         }
         if (verdict.status === "PAUSE") {
-          throw new GovernanceBlockedError2(verdict, toolCall.id);
+          throw new GovernanceBlockedError4(verdict, toolCall.id);
         }
         let args;
         try {
@@ -6506,7 +7858,7 @@ var init_openai = __esm({
 // src/adapters/openclaw.ts
 var openclaw_exports = {};
 __export(openclaw_exports, {
-  GovernanceBlockedError: () => GovernanceBlockedError3,
+  GovernanceBlockedError: () => GovernanceBlockedError5,
   NeuroVersePlugin: () => NeuroVersePlugin,
   createNeuroVersePlugin: () => createNeuroVersePlugin,
   createNeuroVersePluginFromWorld: () => createNeuroVersePluginFromWorld
@@ -6517,7 +7869,7 @@ function defaultMapAction(action, direction) {
     tool: action.tool ?? action.type,
     args: action.input,
     direction,
-    scope: typeof action.input?.path === "string" ? action.input.path : typeof action.input?.url === "string" ? action.input.url : void 0
+    scope: action.input ? extractScope(action.input) : void 0
   };
 }
 async function createNeuroVersePlugin(worldPath, options) {
@@ -6527,20 +7879,17 @@ async function createNeuroVersePlugin(worldPath, options) {
 function createNeuroVersePluginFromWorld(world, options) {
   return new NeuroVersePlugin(world, options);
 }
-var GovernanceBlockedError3, NeuroVersePlugin;
+var GovernanceBlockedError5, NeuroVersePlugin;
 var init_openclaw = __esm({
   "src/adapters/openclaw.ts"() {
     "use strict";
     init_guard_engine();
-    init_plan_engine();
     init_world_loader();
-    GovernanceBlockedError3 = class extends Error {
-      verdict;
+    init_shared();
+    GovernanceBlockedError5 = class extends GovernanceBlockedError {
       action;
       constructor(verdict, action) {
-        super(`[NeuroVerse] BLOCKED: ${verdict.reason ?? verdict.ruleId ?? "governance rule"}`);
-        this.name = "GovernanceBlockedError";
-        this.verdict = verdict;
+        super(verdict);
         this.action = action;
       }
     };
@@ -6555,11 +7904,7 @@ var init_openclaw = __esm({
         this.world = world;
         this.options = options;
         this.activePlan = options.plan;
-        this.engineOptions = {
-          trace: options.trace ?? false,
-          level: options.level,
-          plan: this.activePlan
-        };
+        this.engineOptions = buildEngineOptions(options, this.activePlan);
         this.mapAction = options.mapAction ?? defaultMapAction;
       }
       /**
@@ -6579,22 +7924,10 @@ var init_openclaw = __esm({
         };
         this.options.onEvaluate?.(result);
         if (verdict.status === "BLOCK") {
-          throw new GovernanceBlockedError3(verdict, action);
+          throw new GovernanceBlockedError5(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?.();
-            }
-          }
+        if (verdict.status === "ALLOW") {
+          trackPlanProgress(event, this, this.options);
         }
         return result;
       }
@@ -6615,7 +7948,7 @@ var init_openclaw = __esm({
         };
         this.options.onEvaluate?.(result);
         if (verdict.status === "BLOCK") {
-          throw new GovernanceBlockedError3(verdict, action);
+          throw new GovernanceBlockedError5(verdict, action);
         }
         return result;
       }
@@ -6635,12 +7968,19 @@ var init_openclaw = __esm({
 // src/adapters/index.ts
 var adapters_exports = {};
 __export(adapters_exports, {
+  AutoresearchGovernor: () => AutoresearchGovernor,
+  DeepAgentsGovernanceBlockedError: () => GovernanceBlockedError2,
+  DeepAgentsGuard: () => DeepAgentsGuard,
+  GovernanceBlockedError: () => GovernanceBlockedError,
   GovernedToolExecutor: () => GovernedToolExecutor,
-  LangChainGovernanceBlockedError: () => GovernanceBlockedError,
+  LangChainGovernanceBlockedError: () => GovernanceBlockedError3,
   NeuroVerseCallbackHandler: () => NeuroVerseCallbackHandler,
   NeuroVersePlugin: () => NeuroVersePlugin,
-  OpenAIGovernanceBlockedError: () => GovernanceBlockedError2,
-  OpenClawGovernanceBlockedError: () => GovernanceBlockedError3,
+  OpenAIGovernanceBlockedError: () => GovernanceBlockedError4,
+  OpenClawGovernanceBlockedError: () => GovernanceBlockedError5,
+  buildEngineOptions: () => buildEngineOptions,
+  createDeepAgentsGuard: () => createDeepAgentsGuard,
+  createDeepAgentsGuardFromWorld: () => createDeepAgentsGuardFromWorld,
   createGovernanceMiddleware: () => createGovernanceMiddleware,
   createGovernanceMiddlewareFromWorld: () => createGovernanceMiddlewareFromWorld,
   createGovernedToolExecutor: () => createGovernedToolExecutor,
@@ -6648,15 +7988,21 @@ __export(adapters_exports, {
   createNeuroVerseCallbackHandler: () => createNeuroVerseCallbackHandler,
   createNeuroVerseCallbackHandlerFromWorld: () => createNeuroVerseCallbackHandlerFromWorld,
   createNeuroVersePlugin: () => createNeuroVersePlugin,
-  createNeuroVersePluginFromWorld: () => createNeuroVersePluginFromWorld
+  createNeuroVersePluginFromWorld: () => createNeuroVersePluginFromWorld,
+  defaultBlockMessage: () => defaultBlockMessage,
+  extractScope: () => extractScope,
+  trackPlanProgress: () => trackPlanProgress
 });
 var init_adapters = __esm({
   "src/adapters/index.ts"() {
     "use strict";
+    init_shared();
     init_langchain();
     init_openai();
     init_openclaw();
     init_express();
+    init_autoresearch();
+    init_deep_agents();
   }
 });
 
@@ -6665,11 +8011,14 @@ var globImport_adapters;
 var init_ = __esm({
   'import("../adapters/**/*") in src/cli/doctor.ts'() {
     globImport_adapters = __glob({
+      "../adapters/autoresearch.ts": () => Promise.resolve().then(() => (init_autoresearch(), autoresearch_exports)),
+      "../adapters/deep-agents.ts": () => Promise.resolve().then(() => (init_deep_agents(), deep_agents_exports)),
       "../adapters/express.ts": () => Promise.resolve().then(() => (init_express(), express_exports)),
       "../adapters/index.ts": () => Promise.resolve().then(() => (init_adapters(), adapters_exports)),
       "../adapters/langchain.ts": () => Promise.resolve().then(() => (init_langchain(), langchain_exports)),
       "../adapters/openai.ts": () => Promise.resolve().then(() => (init_openai(), openai_exports)),
-      "../adapters/openclaw.ts": () => Promise.resolve().then(() => (init_openclaw(), openclaw_exports))
+      "../adapters/openclaw.ts": () => Promise.resolve().then(() => (init_openclaw(), openclaw_exports)),
+      "../adapters/shared.ts": () => Promise.resolve().then(() => (init_shared(), shared_exports))
     });
   }
 });
@@ -6677,9 +8026,9 @@ var init_ = __esm({
 // src/cli/doctor.ts
 var doctor_exports = {};
 __export(doctor_exports, {
-  main: () => main11
+  main: () => main13
 });
-async function main11(argv) {
+async function main13(argv) {
   const json = argv.includes("--json");
   let worldPath;
   for (let i = 0; i < argv.length; i++) {
@@ -6727,9 +8076,9 @@ async function main11(argv) {
   }
   if (worldPath) {
     try {
-      const { existsSync: existsSync3 } = await import("fs");
-      const { join: join6 } = await import("path");
-      const hasWorld = existsSync3(join6(worldPath, "world.json"));
+      const { existsSync: existsSync5 } = await import("fs");
+      const { join: join8 } = await import("path");
+      const hasWorld = existsSync5(join8(worldPath, "world.json"));
       checks.push({
         label: "World file detected",
         status: hasWorld ? "pass" : "fail",
@@ -6744,12 +8093,12 @@ async function main11(argv) {
       });
     }
   } else {
-    const { existsSync: existsSync3 } = await import("fs");
-    const { join: join6 } = await import("path");
+    const { existsSync: existsSync5 } = await import("fs");
+    const { join: join8 } = await import("path");
     const candidates = ["./world", "./.neuroverse", "./worlds"];
     let found;
     for (const dir of candidates) {
-      if (existsSync3(join6(dir, "world.json"))) {
+      if (existsSync5(join8(dir, "world.json"))) {
         found = dir;
         break;
       }
@@ -6841,7 +8190,7 @@ var init_doctor = __esm({
 // src/cli/playground.ts
 var playground_exports = {};
 __export(playground_exports, {
-  main: () => main12
+  main: () => main14
 });
 function buildPlaygroundHtml(world, healthSummary) {
   const worldName = world.world.name;
@@ -7267,7 +8616,7 @@ function esc(s) {
 function esc(s) {
   return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 }
-function parseArgs11(argv) {
+function parseArgs13(argv) {
   let worldPath;
   let port = 4242;
   for (let i = 0; i < argv.length; i++) {
@@ -7277,8 +8626,8 @@ function parseArgs11(argv) {
   }
   return { worldPath, port };
 }
-async function main12(argv) {
-  const args = parseArgs11(argv);
+async function main14(argv) {
+  const args = parseArgs13(argv);
   if (!args.worldPath) {
     process.stderr.write("Usage: neuroverse playground --world <dir> [--port N]\n");
     process.exit(1);
@@ -7561,23 +8910,12 @@ var init_plan_contract = __esm({
 // src/cli/plan.ts
 var plan_exports = {};
 __export(plan_exports, {
-  main: () => main13
+  main: () => main15
 });
 function parseArg(args, flag) {
   const idx = args.indexOf(flag);
   return idx >= 0 && idx + 1 < args.length ? args[idx + 1] : void 0;
 }
-function readStdin2() {
-  return new Promise((resolve3, reject) => {
-    let data = "";
-    process.stdin.setEncoding("utf-8");
-    process.stdin.on("data", (chunk) => {
-      data += chunk;
-    });
-    process.stdin.on("end", () => resolve3(data));
-    process.stdin.on("error", reject);
-  });
-}
 async function compileCommand(args) {
   const inputPath = args.find((a) => !a.startsWith("--"));
   if (!inputPath) {
@@ -7588,7 +8926,7 @@ async function compileCommand(args) {
   const outputPath = parseArg(args, "--output") ?? inputPath.replace(/\.md$/, ".json");
   let markdown;
   try {
-    markdown = (0, import_fs2.readFileSync)(inputPath, "utf-8");
+    markdown = (0, import_fs4.readFileSync)(inputPath, "utf-8");
   } catch (err) {
     process.stderr.write(`Error reading ${inputPath}: ${err}
 `);
@@ -7606,7 +8944,7 @@ async function compileCommand(args) {
     process.exit(PLAN_EXIT_CODES.ERROR);
     return;
   }
-  (0, import_fs2.writeFileSync)(outputPath, JSON.stringify(result.plan, null, 2) + "\n");
+  (0, import_fs4.writeFileSync)(outputPath, JSON.stringify(result.plan, null, 2) + "\n");
   const plan = result.plan;
   process.stdout.write(`Plan compiled: ${plan.plan_id}
 `);
@@ -7637,14 +8975,14 @@ async function checkCommand(args) {
   }
   let plan;
   try {
-    plan = JSON.parse((0, import_fs2.readFileSync)(planPath, "utf-8"));
+    plan = JSON.parse((0, import_fs4.readFileSync)(planPath, "utf-8"));
   } catch (err) {
     process.stderr.write(`Error reading plan: ${err}
 `);
     process.exit(PLAN_EXIT_CODES.ERROR);
     return;
   }
-  const stdinData = await readStdin2();
+  const stdinData = await readStdin();
   let event;
   try {
     event = JSON.parse(stdinData);
@@ -7683,7 +9021,7 @@ async function statusCommand(args) {
   }
   let plan;
   try {
-    plan = JSON.parse((0, import_fs2.readFileSync)(planPath, "utf-8"));
+    plan = JSON.parse((0, import_fs4.readFileSync)(planPath, "utf-8"));
   } catch (err) {
     process.stderr.write(`Error reading plan: ${err}
 `);
@@ -7730,7 +9068,7 @@ async function advanceCommand(args) {
   }
   let plan;
   try {
-    plan = JSON.parse((0, import_fs2.readFileSync)(planPath, "utf-8"));
+    plan = JSON.parse((0, import_fs4.readFileSync)(planPath, "utf-8"));
   } catch (err) {
     process.stderr.write(`Error reading plan: ${err}
 `);
@@ -7758,7 +9096,7 @@ async function advanceCommand(args) {
     process.exit(PLAN_EXIT_CODES.ERROR);
     return;
   }
-  (0, import_fs2.writeFileSync)(planPath, JSON.stringify(result.plan, null, 2) + "\n");
+  (0, import_fs4.writeFileSync)(planPath, JSON.stringify(result.plan, null, 2) + "\n");
   const progress = getPlanProgress(result.plan);
   const step = plan.steps.find((s) => s.id === stepId);
   process.stdout.write(`Step completed: ${step.label}
@@ -7785,7 +9123,7 @@ async function deriveCommand(args) {
   const outputDir = parseArg(args, "--output") ?? "./derived-world/";
   let markdown;
   try {
-    markdown = (0, import_fs2.readFileSync)(inputPath, "utf-8");
+    markdown = (0, import_fs4.readFileSync)(inputPath, "utf-8");
   } catch (err) {
     process.stderr.write(`Error reading ${inputPath}: ${err}
 `);
@@ -7848,9 +9186,9 @@ async function deriveCommand(args) {
       description: step.label
     };
   }
-  (0, import_fs2.writeFileSync)(`${outputDir}/world.json`, JSON.stringify(worldJson, null, 2) + "\n");
-  (0, import_fs2.writeFileSync)(`${outputDir}/invariants.json`, JSON.stringify(invariants, null, 2) + "\n");
-  (0, import_fs2.writeFileSync)(`${outputDir}/guards.json`, JSON.stringify(guards, null, 2) + "\n");
+  (0, import_fs4.writeFileSync)(`${outputDir}/world.json`, JSON.stringify(worldJson, null, 2) + "\n");
+  (0, import_fs4.writeFileSync)(`${outputDir}/invariants.json`, JSON.stringify(invariants, null, 2) + "\n");
+  (0, import_fs4.writeFileSync)(`${outputDir}/guards.json`, JSON.stringify(guards, null, 2) + "\n");
   process.stdout.write(`World derived from plan: ${plan.plan_id}
 `);
   process.stdout.write(`  Output: ${outputDir}
@@ -7862,7 +9200,7 @@ async function deriveCommand(args) {
   process.stdout.write(`  Invariants: ${plan.constraints.length} (one per constraint)
 `);
 }
-async function main13(args) {
+async function main15(args) {
   const subcommand = args[0];
   const subArgs = args.slice(1);
   switch (subcommand) {
@@ -7891,14 +9229,15 @@ async function main13(args) {
       process.exit(1);
   }
 }
-var import_fs2, PLAN_USAGE;
+var import_fs4, PLAN_USAGE;
 var init_plan = __esm({
   "src/cli/plan.ts"() {
     "use strict";
-    import_fs2 = require("fs");
+    import_fs4 = require("fs");
     init_plan_parser();
     init_plan_engine();
     init_plan_contract();
+    init_cli_utils();
     PLAN_USAGE = `
 neuroverse plan \u2014 Plan enforcement for AI agents.
 
@@ -8056,6 +9395,329 @@ Do not attempt to bypass governance rules.`;
   }
 });
 
+// src/engine/decision-flow-engine.ts
+function generateDecisionFlow(events) {
+  if (events.length === 0) {
+    return emptyFlow();
+  }
+  const intentMap = /* @__PURE__ */ new Map();
+  for (const e of events) {
+    const intentKey = normalizeIntent(e.intent);
+    const entry = intentMap.get(intentKey) ?? { agents: /* @__PURE__ */ new Set(), count: 0 };
+    entry.count++;
+    entry.agents.add(e.actor ?? "unknown");
+    intentMap.set(intentKey, entry);
+  }
+  const maxCount = Math.max(...[...intentMap.values()].map((v) => v.count), 1);
+  const intents = [...intentMap.entries()].map(([intent, data]) => ({
+    intent,
+    agentCount: data.count,
+    intensity: data.count / maxCount,
+    agents: [...data.agents]
+  })).sort((a, b) => b.agentCount - a.agentCount);
+  const ruleMap = /* @__PURE__ */ new Map();
+  for (const e of events) {
+    if (!e.ruleId && e.guardsMatched.length === 0) continue;
+    const ruleIds = [e.ruleId, ...e.guardsMatched].filter(Boolean);
+    for (const rId of new Set(ruleIds)) {
+      const existing = ruleMap.get(rId) ?? {
+        ruleId: rId,
+        label: rId,
+        interceptCount: 0,
+        enforcements: { blocked: 0, modified: 0, penalized: 0, paused: 0, rewarded: 0 }
+      };
+      existing.interceptCount++;
+      switch (e.decision) {
+        case "BLOCK":
+          existing.enforcements.blocked++;
+          break;
+        case "PAUSE":
+          existing.enforcements.paused++;
+          break;
+        case "MODIFY":
+          existing.enforcements.modified++;
+          break;
+        case "PENALIZE":
+          existing.enforcements.penalized++;
+          break;
+        case "REWARD":
+          existing.enforcements.rewarded++;
+          break;
+      }
+      ruleMap.set(rId, existing);
+    }
+  }
+  const rules = [...ruleMap.values()].sort((a, b) => b.interceptCount - a.interceptCount);
+  const outcomeMap = /* @__PURE__ */ new Map();
+  for (const e of events) {
+    const key = e.decision;
+    const entry = outcomeMap.get(key) ?? { agents: /* @__PURE__ */ new Set(), count: 0 };
+    entry.count++;
+    entry.agents.add(e.actor ?? "unknown");
+    outcomeMap.set(key, entry);
+  }
+  const outcomes = [...outcomeMap.entries()].map(([enforcement, data]) => ({
+    enforcement,
+    agentCount: data.count,
+    agents: [...data.agents],
+    style: enforcementToStyle(enforcement)
+  })).sort((a, b) => b.agentCount - a.agentCount);
+  const paths = events.map((e) => ({
+    intent: normalizeIntent(e.intent),
+    ruleId: e.ruleId ?? e.guardsMatched[0],
+    enforcement: e.decision,
+    agentId: e.actor ?? "unknown",
+    originalAction: e.intent,
+    finalAction: e.decision === "ALLOW" ? e.intent : e.decision === "BLOCK" ? "blocked" : e.decision === "PENALIZE" ? "blocked + penalized" : e.decision === "REWARD" ? e.intent + " (rewarded)" : e.decision === "MODIFY" ? "modified" : e.decision === "NEUTRAL" ? e.intent : "paused"
+  }));
+  const totalIntents = events.length;
+  const allowed = events.filter((e) => e.decision === "ALLOW" || e.decision === "REWARD" || e.decision === "NEUTRAL").length;
+  const totalRedirected = totalIntents - allowed;
+  const totalPenalties = events.filter((e) => e.decision === "PENALIZE").length;
+  const totalRewards = events.filter((e) => e.decision === "REWARD").length;
+  const byEnforcement = {};
+  for (const e of events) {
+    byEnforcement[e.decision] = (byEnforcement[e.decision] ?? 0) + 1;
+  }
+  const metrics = {
+    totalIntents,
+    totalRedirected,
+    redirectionRate: totalIntents > 0 ? totalRedirected / totalIntents : 0,
+    byEnforcement,
+    totalPenalties,
+    totalRewards,
+    netBehavioralPressure: totalRewards - totalPenalties
+  };
+  return {
+    intents,
+    rules,
+    outcomes,
+    paths,
+    metrics,
+    periodStart: events[0]?.timestamp ?? "",
+    periodEnd: events[events.length - 1]?.timestamp ?? "",
+    worldName: events[0]?.worldName ?? "unknown"
+  };
+}
+function createAgentState(agentId) {
+  return {
+    agentId,
+    cooldownRemaining: 0,
+    influence: 1,
+    rewardMultiplier: 1,
+    totalPenalties: 0,
+    totalRewards: 0,
+    consequenceHistory: [],
+    rewardHistory: []
+  };
+}
+function applyConsequence(state, consequence, ruleId) {
+  const updated = { ...state };
+  updated.totalPenalties++;
+  updated.consequenceHistory = [
+    ...state.consequenceHistory,
+    { ruleId, consequence, appliedAt: Date.now() }
+  ];
+  switch (consequence.type) {
+    case "freeze":
+    case "cooldown":
+      updated.cooldownRemaining = Math.max(
+        state.cooldownRemaining,
+        consequence.rounds ?? 1
+      );
+      break;
+    case "reduce_influence":
+      updated.influence = Math.max(0, state.influence - (consequence.magnitude ?? 0.1));
+      break;
+    case "increase_risk":
+      break;
+    case "custom":
+      break;
+  }
+  return updated;
+}
+function applyReward(state, reward, ruleId) {
+  const updated = { ...state };
+  updated.totalRewards++;
+  updated.rewardHistory = [
+    ...state.rewardHistory,
+    { ruleId, reward, appliedAt: Date.now() }
+  ];
+  switch (reward.type) {
+    case "boost_influence":
+      updated.influence = Math.min(2, state.influence + (reward.magnitude ?? 0.1));
+      break;
+    case "weight_increase":
+      updated.rewardMultiplier = Math.min(3, state.rewardMultiplier + (reward.magnitude ?? 0.1));
+      break;
+    case "priority":
+    case "faster_execution":
+      break;
+    case "custom":
+      break;
+  }
+  return updated;
+}
+function tickAgentStates(states) {
+  const updated = /* @__PURE__ */ new Map();
+  for (const [id, state] of states) {
+    updated.set(id, {
+      ...state,
+      cooldownRemaining: Math.max(0, state.cooldownRemaining - 1)
+    });
+  }
+  return updated;
+}
+function renderDecisionFlow(flow) {
+  const lines = [];
+  lines.push("DECISION FLOW \u2014 Intent \u2192 Rule \u2192 Outcome");
+  lines.push("\u2550".repeat(60));
+  lines.push("");
+  lines.push(`  World: ${flow.worldName}`);
+  lines.push(`  Period: ${flow.periodStart.split("T")[0] ?? "\u2014"} \u2192 ${flow.periodEnd.split("T")[0] ?? "\u2014"}`);
+  lines.push("");
+  lines.push(`  "${(flow.metrics.redirectionRate * 100).toFixed(1)}% of agent intent was redirected by governance"`);
+  lines.push("");
+  lines.push("INTENT POOL (what agents wanted)");
+  lines.push("\u2500".repeat(60));
+  for (const cluster of flow.intents.slice(0, 15)) {
+    const bar = "\u2588".repeat(Math.max(1, Math.round(cluster.intensity * 20)));
+    lines.push(`  ${cluster.intent.padEnd(25)} ${String(cluster.agentCount).padStart(5)} agents  ${bar}`);
+  }
+  lines.push("");
+  lines.push("RULE OBSTACLES (what intercepted)");
+  lines.push("\u2500".repeat(60));
+  for (const rule of flow.rules.slice(0, 10)) {
+    const parts = [];
+    if (rule.enforcements.blocked > 0) parts.push(`${rule.enforcements.blocked} blocked`);
+    if (rule.enforcements.modified > 0) parts.push(`${rule.enforcements.modified} modified`);
+    if (rule.enforcements.penalized > 0) parts.push(`${rule.enforcements.penalized} penalized`);
+    if (rule.enforcements.paused > 0) parts.push(`${rule.enforcements.paused} paused`);
+    if (rule.enforcements.rewarded > 0) parts.push(`${rule.enforcements.rewarded} rewarded`);
+    lines.push(`  ${rule.ruleId.padEnd(30)} ${String(rule.interceptCount).padStart(5)} intercepts  (${parts.join(", ")})`);
+  }
+  lines.push("");
+  lines.push("OUTCOME POOL (what actually happened)");
+  lines.push("\u2500".repeat(60));
+  for (const outcome of flow.outcomes) {
+    const icon = outcomeIcon(outcome.enforcement);
+    lines.push(`  ${icon} ${outcome.enforcement.padEnd(12)} ${String(outcome.agentCount).padStart(5)} agents`);
+  }
+  lines.push("");
+  if (flow.metrics.totalPenalties > 0 || flow.metrics.totalRewards > 0) {
+    lines.push("BEHAVIORAL ECONOMY");
+    lines.push("\u2500".repeat(60));
+    lines.push(`  Penalties applied:       ${flow.metrics.totalPenalties}`);
+    lines.push(`  Rewards applied:         ${flow.metrics.totalRewards}`);
+    lines.push(`  Net behavioral pressure: ${flow.metrics.netBehavioralPressure > 0 ? "+" : ""}${flow.metrics.netBehavioralPressure}`);
+    lines.push("");
+  }
+  lines.push("ENFORCEMENT BREAKDOWN");
+  lines.push("\u2500".repeat(60));
+  for (const [enforcement, count] of Object.entries(flow.metrics.byEnforcement)) {
+    const pct = (count / flow.metrics.totalIntents * 100).toFixed(1);
+    lines.push(`  ${enforcement.padEnd(12)} ${String(count).padStart(5)} (${pct}%)`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function normalizeIntent(intent) {
+  const lower = intent.toLowerCase().trim();
+  const verbs = [
+    "sell",
+    "buy",
+    "trade",
+    "publish",
+    "delete",
+    "create",
+    "modify",
+    "send",
+    "withdraw",
+    "transfer",
+    "attack",
+    "deploy",
+    "execute",
+    "read",
+    "write",
+    "hold",
+    "stake",
+    "approve",
+    "reject",
+    "escalate"
+  ];
+  for (const verb of verbs) {
+    if (lower.startsWith(verb) || lower.includes(verb)) {
+      return verb;
+    }
+  }
+  return lower.split(/\s+/)[0] ?? lower;
+}
+function enforcementToStyle(enforcement) {
+  switch (enforcement) {
+    case "ALLOW":
+      return "green";
+    case "MODIFY":
+      return "yellow";
+    case "BLOCK":
+      return "red";
+    case "PENALIZE":
+      return "gray";
+    case "REWARD":
+      return "blue";
+    case "NEUTRAL":
+      return "white";
+    case "PAUSE":
+      return "yellow";
+    default:
+      return "white";
+  }
+}
+function outcomeIcon(enforcement) {
+  switch (enforcement) {
+    case "ALLOW":
+      return "\u25CF";
+    case "MODIFY":
+      return "\u25D0";
+    case "BLOCK":
+      return "\u25CB";
+    case "PENALIZE":
+      return "\u25CC";
+    case "REWARD":
+      return "\u25C9";
+    case "NEUTRAL":
+      return "\u25EF";
+    case "PAUSE":
+      return "\u25D1";
+    default:
+      return "\xB7";
+  }
+}
+function emptyFlow() {
+  return {
+    intents: [],
+    rules: [],
+    outcomes: [],
+    paths: [],
+    metrics: {
+      totalIntents: 0,
+      totalRedirected: 0,
+      redirectionRate: 0,
+      byEnforcement: {},
+      totalPenalties: 0,
+      totalRewards: 0,
+      netBehavioralPressure: 0
+    },
+    periodStart: "",
+    periodEnd: "",
+    worldName: "unknown"
+  };
+}
+var init_decision_flow_engine = __esm({
+  "src/engine/decision-flow-engine.ts"() {
+    "use strict";
+  }
+});
+
 // src/runtime/session.ts
 var session_exports = {};
 __export(session_exports, {
@@ -8078,7 +9740,7 @@ async function runPipeMode(config) {
     process.stderr.write(`[neuroverse] Plan: ${state.plan.plan_id} (${state.plan.objective})
 `);
   }
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve5, reject) => {
     let buffer = "";
     process.stdin.setEncoding("utf-8");
     process.stdin.on("data", (chunk) => {
@@ -8119,7 +9781,7 @@ async function runPipeMode(config) {
         `[neuroverse] Session complete: ${finalState.actionsEvaluated} evaluated, ${finalState.actionsAllowed} allowed, ${finalState.actionsBlocked} blocked, ${finalState.actionsPaused} paused
 `
       );
-      resolve3();
+      resolve5();
     });
     process.stdin.on("error", reject);
   });
@@ -8190,7 +9852,9 @@ async function runInteractiveMode(config, model) {
 `);
       process.stdout.write(`  Actions: ${s.actionsEvaluated} evaluated
 `);
-      process.stdout.write(`  Allowed: ${s.actionsAllowed} | Blocked: ${s.actionsBlocked} | Paused: ${s.actionsPaused}
+      process.stdout.write(`  Allowed: ${s.actionsAllowed} | Blocked: ${s.actionsBlocked} | Modified: ${s.actionsModified} | Paused: ${s.actionsPaused}
+`);
+      process.stdout.write(`  Penalized: ${s.actionsPenalized} | Rewarded: ${s.actionsRewarded}
 `);
       if (s.progress && s.plan) {
         process.stdout.write(`  Plan: ${s.plan.plan_id} \u2014 ${s.progress.completed}/${s.progress.total} (${s.progress.percentage}%)
@@ -8233,8 +9897,8 @@ ${response.content}
   rl.on("close", () => {
     session.stop();
   });
-  return new Promise((resolve3) => {
-    rl.on("close", resolve3);
+  return new Promise((resolve5) => {
+    rl.on("close", resolve5);
   });
 }
 var SessionManager;
@@ -8244,6 +9908,7 @@ var init_session = __esm({
     init_guard_engine();
     init_plan_engine();
     init_world_loader();
+    init_decision_flow_engine();
     SessionManager = class {
       config;
       state;
@@ -8265,7 +9930,11 @@ var init_session = __esm({
           actionsEvaluated: 0,
           actionsAllowed: 0,
           actionsBlocked: 0,
-          actionsPaused: 0
+          actionsPaused: 0,
+          actionsModified: 0,
+          actionsPenalized: 0,
+          actionsRewarded: 0,
+          agentStates: /* @__PURE__ */ new Map()
         };
       }
       /**
@@ -8287,14 +9956,41 @@ var init_session = __esm({
        */
       evaluate(event) {
         this.engineOptions.plan = this.state.plan;
+        this.engineOptions.agentStates = this.state.agentStates;
         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++;
+        if (verdict.status === "MODIFY") this.state.actionsModified++;
+        if (verdict.status === "PENALIZE") this.state.actionsPenalized++;
+        if (verdict.status === "REWARD") this.state.actionsRewarded++;
+        if (event.roleId) {
+          let agentState = this.state.agentStates.get(event.roleId) ?? createAgentState(event.roleId);
+          if (verdict.status === "PENALIZE" && verdict.consequence) {
+            agentState = applyConsequence(agentState, verdict.consequence, verdict.ruleId ?? "unknown");
+          }
+          if (verdict.status === "REWARD" && verdict.reward) {
+            agentState = applyReward(agentState, verdict.reward, verdict.ruleId ?? "unknown");
+          }
+          this.state.agentStates.set(event.roleId, agentState);
+        }
         this.config.onVerdict?.(verdict, event);
         return verdict;
       }
+      /**
+       * Advance all agent states by one round.
+       * Call this at the end of each simulation round to decrement cooldowns.
+       */
+      tickRound() {
+        this.state.agentStates = tickAgentStates(this.state.agentStates);
+      }
+      /**
+       * Get the behavior state for a specific agent.
+       */
+      getAgentState(agentId) {
+        return this.state.agentStates.get(agentId);
+      }
       /**
        * Evaluate and execute a tool call.
        * Returns the execution result or block reason.
@@ -8313,7 +10009,7 @@ var init_session = __esm({
           direction: "input"
         };
         const verdict = this.evaluate(event);
-        if (verdict.status === "BLOCK") {
+        if (verdict.status === "BLOCK" || verdict.status === "PENALIZE") {
           return { allowed: false, verdict };
         }
         if (verdict.status === "PAUSE") {
@@ -8381,7 +10077,7 @@ var init_session = __esm({
 // src/cli/run.ts
 var run_exports = {};
 __export(run_exports, {
-  main: () => main14
+  main: () => main16
 });
 function parseArg2(args, flag) {
   const idx = args.indexOf(flag);
@@ -8392,11 +10088,11 @@ function hasFlag(args, flag) {
 }
 function autoDetectPlan() {
   const nvDir = ".neuroverse/plans";
-  if (!(0, import_fs3.existsSync)(nvDir)) return void 0;
-  const entries = (0, import_fs3.readdirSync)(nvDir).filter((e) => e.endsWith(".json"));
+  if (!(0, import_fs5.existsSync)(nvDir)) return void 0;
+  const entries = (0, import_fs5.readdirSync)(nvDir).filter((e) => e.endsWith(".json"));
   if (entries.length === 1) {
     try {
-      return JSON.parse((0, import_fs3.readFileSync)((0, import_path4.join)(nvDir, entries[0]), "utf-8"));
+      return JSON.parse((0, import_fs5.readFileSync)((0, import_path6.join)(nvDir, entries[0]), "utf-8"));
     } catch {
       return void 0;
     }
@@ -8404,15 +10100,15 @@ function autoDetectPlan() {
   return void 0;
 }
 function loadPlan(path) {
-  return JSON.parse((0, import_fs3.readFileSync)(path, "utf-8"));
+  return JSON.parse((0, import_fs5.readFileSync)(path, "utf-8"));
 }
-async function main14(args) {
+async function main16(args) {
   if (hasFlag(args, "--help") || hasFlag(args, "-h")) {
     process.stdout.write(RUN_USAGE + "\n");
     process.exit(0);
     return;
   }
-  const worldPath = resolveWorldPath4(parseArg2(args, "--world"));
+  const worldPath = resolveWorldPath2(parseArg2(args, "--world"));
   if (!worldPath) {
     process.stderr.write(
       "Error: No world found.\nUse --world <path>, set NEUROVERSE_WORLD, or run `neuroverse world use <name>`\n"
@@ -8488,12 +10184,12 @@ async function main14(args) {
     process.exit(0);
   }
 }
-var import_fs3, import_path4, RUN_USAGE;
+var import_fs5, import_path6, RUN_USAGE;
 var init_run = __esm({
   "src/cli/run.ts"() {
     "use strict";
-    import_fs3 = require("fs");
-    import_path4 = require("path");
+    import_fs5 = require("fs");
+    import_path6 = require("path");
     init_world_resolver();
     RUN_USAGE = `
 neuroverse run \u2014 Governed runtime for AI agents.
@@ -8545,20 +10241,20 @@ ${err.stderr ?? ""}`;
   }
 }
 function executeReadFile(path, workingDir) {
-  const fullPath = (0, import_path5.resolve)(workingDir ?? ".", path);
-  return (0, import_fs4.readFileSync)(fullPath, "utf-8");
+  const fullPath = (0, import_path7.resolve)(workingDir ?? ".", path);
+  return (0, import_fs6.readFileSync)(fullPath, "utf-8");
 }
 function executeWriteFile(path, content, workingDir) {
-  const fullPath = (0, import_path5.resolve)(workingDir ?? ".", path);
-  (0, import_fs4.writeFileSync)(fullPath, content);
+  const fullPath = (0, import_path7.resolve)(workingDir ?? ".", path);
+  (0, import_fs6.writeFileSync)(fullPath, content);
   return `File written: ${fullPath}`;
 }
 function executeListDir(path, workingDir) {
-  const fullPath = (0, import_path5.resolve)(workingDir ?? ".", path);
-  const entries = (0, import_fs4.readdirSync)(fullPath);
+  const fullPath = (0, import_path7.resolve)(workingDir ?? ".", path);
+  const entries = (0, import_fs6.readdirSync)(fullPath);
   return entries.map((e) => {
     try {
-      const stat = (0, import_fs4.statSync)((0, import_path5.join)(fullPath, e));
+      const stat = (0, import_fs6.statSync)((0, import_path7.join)(fullPath, e));
       return `${stat.isDirectory() ? "d" : "-"} ${e}`;
     } catch {
       return `? ${e}`;
@@ -8580,7 +10276,7 @@ async function startMcpServer(args) {
     const idx = args.indexOf(flag);
     return idx >= 0 && idx + 1 < args.length ? args[idx + 1] : void 0;
   }
-  const worldPath = resolveWorldPath4(parseArg3("--world"));
+  const worldPath = resolveWorldPath2(parseArg3("--world"));
   const planPath = parseArg3("--plan");
   const level = parseArg3("--level");
   const trace = args.includes("--trace");
@@ -8609,7 +10305,7 @@ async function startMcpServer(args) {
   });
   await server.start();
 }
-var import_child_process, import_fs4, import_path5, GOVERNED_TOOLS, McpGovernanceServer;
+var import_child_process, import_fs6, import_path7, GOVERNED_TOOLS, McpGovernanceServer;
 var init_mcp_server = __esm({
   "src/runtime/mcp-server.ts"() {
     "use strict";
@@ -8618,8 +10314,8 @@ var init_mcp_server = __esm({
     init_world_loader();
     init_world_resolver();
     import_child_process = require("child_process");
-    import_fs4 = require("fs");
-    import_path5 = require("path");
+    import_fs6 = require("fs");
+    import_path7 = require("path");
     GOVERNED_TOOLS = [
       {
         name: "governed_shell",
@@ -8745,7 +10441,7 @@ var init_mcp_server = __esm({
           throw new Error("No world provided");
         }
         if (this.config.planPath && !this.plan) {
-          this.plan = JSON.parse((0, import_fs4.readFileSync)(this.config.planPath, "utf-8"));
+          this.plan = JSON.parse((0, import_fs6.readFileSync)(this.config.planPath, "utf-8"));
           this.engineOptions.plan = this.plan;
         }
         process.stderr.write(`[neuroverse-mcp] Server starting
@@ -9119,7 +10815,7 @@ Progress: ${progress.completed}/${progress.total} (${progress.percentage}%)`;
           text += "\n\nPlan complete!";
         }
         if (this.config.planPath) {
-          (0, import_fs4.writeFileSync)(this.config.planPath, JSON.stringify(this.plan, null, 2) + "\n");
+          (0, import_fs6.writeFileSync)(this.config.planPath, JSON.stringify(this.plan, null, 2) + "\n");
         }
         return { content: [{ type: "text", text }] };
       }
@@ -9130,9 +10826,9 @@ Progress: ${progress.completed}/${progress.total} (${progress.percentage}%)`;
 // src/cli/world.ts
 var world_exports = {};
 __export(world_exports, {
-  main: () => main15
+  main: () => main17
 });
-function parseArgs12(argv) {
+function parseArgs14(argv) {
   const subcommand = argv[0];
   const paths = [];
   const flags = {};
@@ -9273,28 +10969,28 @@ function computeWorldDiff(a, b) {
   return { changes };
 }
 async function worldSnapshot(worldPath) {
-  const { readdir, readFile: readFile3, mkdir: mkdir2, writeFile: writeFile3 } = await import("fs/promises");
-  const { join: join6 } = await import("path");
+  const { readdir, readFile: readFile3, mkdir: mkdir2, writeFile: writeFile5 } = await import("fs/promises");
+  const { join: join8 } = await import("path");
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-  const snapshotDir = join6(worldPath, ".snapshots", timestamp);
+  const snapshotDir = join8(worldPath, ".snapshots", timestamp);
   await mkdir2(snapshotDir, { recursive: true });
   const files = await readdir(worldPath);
   let copied = 0;
   for (const file of files) {
     if (file.endsWith(".json")) {
-      const content = await readFile3(join6(worldPath, file), "utf-8");
-      await writeFile3(join6(snapshotDir, file), content, "utf-8");
+      const content = await readFile3(join8(worldPath, file), "utf-8");
+      await writeFile5(join8(snapshotDir, file), content, "utf-8");
       copied++;
     }
   }
   try {
-    const rulesDir = join6(worldPath, "rules");
+    const rulesDir = join8(worldPath, "rules");
     const ruleFiles = await readdir(rulesDir);
-    await mkdir2(join6(snapshotDir, "rules"), { recursive: true });
+    await mkdir2(join8(snapshotDir, "rules"), { recursive: true });
     for (const file of ruleFiles) {
       if (file.endsWith(".json")) {
-        const content = await readFile3(join6(rulesDir, file), "utf-8");
-        await writeFile3(join6(snapshotDir, "rules", file), content, "utf-8");
+        const content = await readFile3(join8(rulesDir, file), "utf-8");
+        await writeFile5(join8(snapshotDir, "rules", file), content, "utf-8");
         copied++;
       }
     }
@@ -9306,9 +11002,9 @@ async function worldSnapshot(worldPath) {
 `);
 }
 async function worldRollback(worldPath) {
-  const { readdir, readFile: readFile3, writeFile: writeFile3, mkdir: mkdir2 } = await import("fs/promises");
-  const { join: join6 } = await import("path");
-  const snapshotsDir = join6(worldPath, ".snapshots");
+  const { readdir, readFile: readFile3, writeFile: writeFile5, mkdir: mkdir2 } = await import("fs/promises");
+  const { join: join8 } = await import("path");
+  const snapshotsDir = join8(worldPath, ".snapshots");
   let snapshots;
   try {
     snapshots = (await readdir(snapshotsDir)).sort();
@@ -9323,34 +11019,34 @@ async function worldRollback(worldPath) {
     return;
   }
   const latest = snapshots[snapshots.length - 1];
-  const snapshotDir = join6(snapshotsDir, latest);
+  const snapshotDir = join8(snapshotsDir, latest);
   const backupTimestamp = "pre-rollback-" + (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-  const backupDir = join6(snapshotsDir, backupTimestamp);
+  const backupDir = join8(snapshotsDir, backupTimestamp);
   await mkdir2(backupDir, { recursive: true });
   const currentFiles = await readdir(worldPath);
   for (const file of currentFiles) {
     if (file.endsWith(".json")) {
-      const content = await readFile3(join6(worldPath, file), "utf-8");
-      await writeFile3(join6(backupDir, file), content, "utf-8");
+      const content = await readFile3(join8(worldPath, file), "utf-8");
+      await writeFile5(join8(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 readFile3(join6(snapshotDir, file), "utf-8");
-      await writeFile3(join6(worldPath, file), content, "utf-8");
+      const content = await readFile3(join8(snapshotDir, file), "utf-8");
+      await writeFile5(join8(worldPath, file), content, "utf-8");
       restored++;
     }
   }
   try {
-    const rulesDir = join6(snapshotDir, "rules");
+    const rulesDir = join8(snapshotDir, "rules");
     const ruleFiles = await readdir(rulesDir);
-    await mkdir2(join6(worldPath, "rules"), { recursive: true });
+    await mkdir2(join8(worldPath, "rules"), { recursive: true });
     for (const file of ruleFiles) {
       if (file.endsWith(".json")) {
-        const content = await readFile3(join6(rulesDir, file), "utf-8");
-        await writeFile3(join6(worldPath, "rules", file), content, "utf-8");
+        const content = await readFile3(join8(rulesDir, file), "utf-8");
+        await writeFile5(join8(worldPath, "rules", file), content, "utf-8");
         restored++;
       }
     }
@@ -9412,8 +11108,8 @@ function worldCurrent(json) {
   process.stdout.write(`Source: ${info.source}
 `);
 }
-async function main15(argv = process.argv.slice(2)) {
-  const { subcommand, paths, flags } = parseArgs12(argv);
+async function main17(argv = process.argv.slice(2)) {
+  const { subcommand, paths, flags } = parseArgs14(argv);
   if (flags.help || !subcommand) {
     process.stdout.write(USAGE + "\n");
     process.exit(0);
@@ -9435,7 +11131,7 @@ async function main15(argv = process.argv.slice(2)) {
     }
     case "status": {
       const ref = paths[0];
-      const resolved = ref ? resolveWorldPath4(ref) : resolveWorldPath4();
+      const resolved = ref ? resolveWorldPath2(ref) : resolveWorldPath2();
       if (!resolved) {
         process.stderr.write("Usage: neuroverse world status <path|name>\n");
         process.stderr.write("Or set an active world: neuroverse world use <name>\n");
@@ -9502,6 +11198,41 @@ Options:
 });
 
 // src/engine/audit-logger.ts
+function verdictToAuditEvent(event, verdict) {
+  const auditEvent = {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    worldId: verdict.evidence.worldId,
+    worldName: verdict.evidence.worldName,
+    worldVersion: verdict.evidence.worldVersion,
+    intent: event.intent,
+    tool: event.tool,
+    scope: event.scope,
+    actor: event.roleId,
+    direction: event.direction,
+    decision: verdict.status,
+    reason: verdict.reason,
+    ruleId: verdict.ruleId,
+    warning: verdict.warning,
+    guardsMatched: verdict.evidence.guardsMatched,
+    rulesMatched: verdict.evidence.rulesMatched,
+    invariantsSatisfied: verdict.evidence.invariantsSatisfied,
+    invariantsTotal: verdict.evidence.invariantsTotal,
+    enforcementLevel: verdict.evidence.enforcementLevel,
+    durationMs: verdict.trace?.durationMs,
+    args: event.args
+  };
+  if (verdict.consequence) {
+    auditEvent.consequence = verdict.consequence;
+  }
+  if (verdict.reward) {
+    auditEvent.reward = verdict.reward;
+  }
+  if (verdict.intentRecord) {
+    auditEvent.originalIntent = verdict.intentRecord.originalIntent;
+    auditEvent.finalAction = verdict.intentRecord.finalAction;
+  }
+  return auditEvent;
+}
 async function readAuditLog(logPath, filter) {
   const { readFile: readFile3 } = await import("fs/promises");
   let content;
@@ -9528,16 +11259,22 @@ function summarizeAuditEvents(events) {
   const allowed = events.filter((e) => e.decision === "ALLOW").length;
   const blocked = events.filter((e) => e.decision === "BLOCK").length;
   const paused = events.filter((e) => e.decision === "PAUSE").length;
+  const modified = events.filter((e) => e.decision === "MODIFY").length;
+  const penalized = events.filter((e) => e.decision === "PENALIZE").length;
+  const rewarded = events.filter((e) => e.decision === "REWARD").length;
+  const neutral = events.filter((e) => e.decision === "NEUTRAL").length;
   const actorSet = /* @__PURE__ */ new Set();
   for (const e of events) {
     if (e.actor) actorSet.add(e.actor);
   }
   const intentMap = /* @__PURE__ */ new Map();
   for (const e of events) {
-    const entry = intentMap.get(e.intent) ?? { count: 0, blocked: 0, paused: 0 };
+    const entry = intentMap.get(e.intent) ?? { count: 0, blocked: 0, paused: 0, penalized: 0, rewarded: 0 };
     entry.count++;
     if (e.decision === "BLOCK") entry.blocked++;
     if (e.decision === "PAUSE") entry.paused++;
+    if (e.decision === "PENALIZE") entry.penalized++;
+    if (e.decision === "REWARD") entry.rewarded++;
     intentMap.set(e.intent, entry);
   }
   const topIntents = [...intentMap.entries()].map(([intent, data]) => ({ intent, ...data })).sort((a, b) => b.count - a.count);
@@ -9551,16 +11288,28 @@ function summarizeAuditEvents(events) {
     }
   }
   const topRules = [...ruleMap.entries()].map(([ruleId, count]) => ({ ruleId, count })).sort((a, b) => b.count - a.count);
+  const redirected = blocked + paused + modified + penalized;
+  const total = events.length;
   return {
-    totalActions: events.length,
+    totalActions: total,
     allowed,
     blocked,
     paused,
+    modified,
+    penalized,
+    rewarded,
+    neutral,
     actors: [...actorSet],
     topIntents,
     topRules,
     firstEvent: events[0]?.timestamp ?? "",
-    lastEvent: events[events.length - 1]?.timestamp ?? ""
+    lastEvent: events[events.length - 1]?.timestamp ?? "",
+    behavioralEconomy: {
+      totalPenalties: penalized,
+      totalRewards: rewarded,
+      netPressure: rewarded - penalized,
+      redirectionRate: total > 0 ? redirected / total : 0
+    }
   };
 }
 var init_audit_logger = __esm({
@@ -9573,9 +11322,9 @@ var init_audit_logger = __esm({
 // src/cli/trace.ts
 var trace_exports = {};
 __export(trace_exports, {
-  main: () => main16
+  main: () => main18
 });
-function parseArgs13(argv) {
+function parseArgs15(argv) {
   const args = {};
   for (let i = 0; i < argv.length; i++) {
     const arg = argv[i];
@@ -9659,8 +11408,8 @@ function formatSummary(events) {
   }
   return lines.join("\n");
 }
-async function main16(argv = process.argv.slice(2)) {
-  const args = parseArgs13(argv);
+async function main18(argv = process.argv.slice(2)) {
+  const args = parseArgs15(argv);
   if (args.help) {
     process.stdout.write(USAGE2 + "\n");
     process.exit(0);
@@ -9744,7 +11493,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);
@@ -9829,6 +11582,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,
@@ -9837,8 +11592,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,
@@ -9877,8 +11637,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");
@@ -9939,7 +11704,12 @@ function emptyReport() {
     totalBlocked: 0,
     totalPaused: 0,
     totalAllowed: 0,
+    totalModified: 0,
+    totalPenalized: 0,
+    totalRewarded: 0,
+    totalNeutral: 0,
     preventionRate: 0,
+    redirectionRate: 0,
     preventedByCategory: [],
     topPreventedIntents: [],
     hotActors: [],
@@ -9958,9 +11728,9 @@ var init_impact_report = __esm({
 // src/cli/impact.ts
 var impact_exports = {};
 __export(impact_exports, {
-  main: () => main17
+  main: () => main19
 });
-function parseArgs14(argv) {
+function parseArgs16(argv) {
   const args = {};
   for (let i = 0; i < argv.length; i++) {
     const arg = argv[i];
@@ -9970,8 +11740,8 @@ function parseArgs14(argv) {
   }
   return args;
 }
-async function main17(argv = process.argv.slice(2)) {
-  const args = parseArgs14(argv);
+async function main19(argv = process.argv.slice(2)) {
+  const args = parseArgs16(argv);
   if (args.help) {
     process.stdout.write(USAGE3 + "\n");
     process.exit(0);
@@ -10016,9 +11786,9 @@ repeat violations, and actor behavior patterns.
 // src/cli/derive.ts
 var derive_exports = {};
 __export(derive_exports, {
-  main: () => main18
+  main: () => main20
 });
-function parseArgs15(argv) {
+function parseArgs17(argv) {
   let inputPath = "";
   let outputPath = "./derived.nv-world.md";
   let validate = true;
@@ -10052,9 +11822,9 @@ function parseArgs15(argv) {
   if (!inputPath) throw new DeriveInputError("--input <path> is required");
   return { inputPath, outputPath, validate, dryRun, bootstrapDir, provider, model, endpoint };
 }
-async function main18(argv = process.argv.slice(2)) {
+async function main20(argv = process.argv.slice(2)) {
   try {
-    const args = parseArgs15(argv);
+    const args = parseArgs17(argv);
     const { result, exitCode, dryRunOutput } = await deriveWorld({
       inputPath: args.inputPath,
       outputPath: args.outputPath,
@@ -10161,12 +11931,307 @@ var init_derive = __esm({
   }
 });
 
+// src/cli/decision-flow.ts
+var decision_flow_exports = {};
+__export(decision_flow_exports, {
+  main: () => main21
+});
+async function main21(args) {
+  let logPath = ".neuroverse/audit.ndjson";
+  let jsonOutput = false;
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--log" && args[i + 1]) {
+      logPath = args[++i];
+    }
+    if (args[i] === "--json") {
+      jsonOutput = true;
+    }
+    if (args[i] === "--help" || args[i] === "-h") {
+      process.stdout.write(`
+neuroverse decision-flow \u2014 Visualize Intent \u2192 Rule \u2192 Outcome
+
+Usage:
+  neuroverse decision-flow [--log <path>] [--json]
+
+Options:
+  --log <path>   Path to audit log (default: .neuroverse/audit.ndjson)
+  --json         Output as JSON instead of text
+
+Shows:
+  - What agents WANTED to do (Intent Pool)
+  - What rules INTERCEPTED (Rule Obstacles)
+  - What actually HAPPENED (Outcome Pool)
+  - Behavioral economy (penalties vs rewards)
+
+Headline metric: "X% of agent intent was redirected by governance"
+`.trim() + "\n");
+      return;
+    }
+  }
+  const events = await readAuditLog(logPath);
+  if (events.length === 0) {
+    process.stderr.write("No audit events found. Run governed actions first.\n");
+    process.stderr.write(`Looking in: ${logPath}
+`);
+    process.exit(1);
+  }
+  const flow = generateDecisionFlow(events);
+  if (jsonOutput) {
+    process.stdout.write(JSON.stringify(flow, null, 2) + "\n");
+  } else {
+    process.stdout.write(renderDecisionFlow(flow) + "\n");
+  }
+}
+var init_decision_flow = __esm({
+  "src/cli/decision-flow.ts"() {
+    "use strict";
+    init_audit_logger();
+    init_decision_flow_engine();
+  }
+});
+
+// src/cli/equity-penalties.ts
+var equity_penalties_exports = {};
+__export(equity_penalties_exports, {
+  main: () => main22
+});
+function generateActionsForRound(agents, round) {
+  const actions = [];
+  for (const agent of agents) {
+    if (agent.strategy === "aggressive") {
+      if (round % 2 === 0) {
+        actions.push({
+          intent: `sell Fortune 500 equity AAPL position for ${agent.name}`,
+          tool: "trade",
+          roleId: agent.id,
+          actionCategory: "write"
+        });
+      } else {
+        actions.push({
+          intent: `sell Fortune 500 equity MSFT shares for ${agent.name}`,
+          tool: "trade",
+          roleId: agent.id,
+          actionCategory: "write"
+        });
+      }
+    }
+    if (agent.strategy === "conservative") {
+      actions.push({
+        intent: `hold current position during market volatility for ${agent.name}`,
+        tool: "trade",
+        roleId: agent.id,
+        actionCategory: "read"
+      });
+    }
+    if (agent.strategy === "balanced") {
+      if (round % 3 === 0) {
+        actions.push({
+          intent: `sell Fortune 500 equity GOOGL for ${agent.name}`,
+          tool: "trade",
+          roleId: agent.id,
+          actionCategory: "write"
+        });
+      } else if (round % 3 === 1) {
+        actions.push({
+          intent: `buy non-F500 small cap equity for ${agent.name}`,
+          tool: "trade",
+          roleId: agent.id,
+          actionCategory: "write"
+        });
+      } else {
+        actions.push({
+          intent: `hold position during volatility for ${agent.name}`,
+          tool: "trade",
+          roleId: agent.id,
+          actionCategory: "read"
+        });
+      }
+    }
+  }
+  return actions;
+}
+async function main22(args) {
+  let worldPath = "";
+  let agentCount = 8;
+  let rounds = 5;
+  let jsonOutput = false;
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--world" && args[i + 1]) {
+      worldPath = args[++i];
+    }
+    if (args[i] === "--agents" && args[i + 1]) {
+      agentCount = Math.min(parseInt(args[++i], 10), AGENTS.length);
+    }
+    if (args[i] === "--rounds" && args[i + 1]) {
+      rounds = parseInt(args[++i], 10);
+    }
+    if (args[i] === "--json") {
+      jsonOutput = true;
+    }
+    if (args[i] === "--help" || args[i] === "-h") {
+      process.stdout.write(`
+neuroverse equity-penalties \u2014 Behavioral enforcement simulation
+
+Usage:
+  neuroverse equity-penalties --world <dir> [--agents N] [--rounds N] [--json]
+
+Options:
+  --world <dir>  Path to world directory (required)
+  --agents N     Number of agents (default: 8, max: 8)
+  --rounds N     Number of simulation rounds (default: 5)
+  --json         Output as JSON
+
+Simulates Fortune 500 equity trading with PENALIZE/REWARD governance:
+  - SELL F500 equity \u2192 PENALIZED (agent frozen 1 round)
+  - HOLD during volatility \u2192 REWARDED (+10% influence)
+  - BUY non-F500 \u2192 ALLOWED
+  - Unauthorized actions \u2192 BLOCKED
+`.trim() + "\n");
+      return;
+    }
+  }
+  if (!worldPath) {
+    process.stderr.write("Error: --world <dir> is required\n");
+    process.exit(1);
+  }
+  let world;
+  try {
+    world = await loadWorld(worldPath);
+  } catch (e) {
+    process.stderr.write(`Error loading world: ${e}
+`);
+    process.exit(1);
+    return;
+  }
+  const agents = AGENTS.slice(0, agentCount);
+  let agentStates = /* @__PURE__ */ new Map();
+  for (const agent of agents) {
+    agentStates.set(agent.id, createAgentState(agent.id));
+  }
+  const allAuditEvents = [];
+  const engineOptions = {
+    trace: false,
+    level: "standard",
+    agentStates
+  };
+  process.stdout.write("\n");
+  process.stdout.write("EQUITY PENALTY SIMULATION\n");
+  process.stdout.write("\u2550".repeat(60) + "\n");
+  process.stdout.write(`  World: ${world.world.name}
+`);
+  process.stdout.write(`  Agents: ${agents.length}
+`);
+  process.stdout.write(`  Rounds: ${rounds}
+`);
+  process.stdout.write("\n");
+  for (let round = 0; round < rounds; round++) {
+    process.stdout.write(`\u2500\u2500 Round ${round + 1} \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+`);
+    const actions = generateActionsForRound(agents, round);
+    for (const action of actions) {
+      const event = {
+        intent: action.intent,
+        tool: action.tool,
+        roleId: action.roleId,
+        actionCategory: action.actionCategory,
+        direction: "input"
+      };
+      const agentState = agentStates.get(action.roleId);
+      if (agentState && agentState.cooldownRemaining > 0) {
+        process.stdout.write(`  \u25CC ${action.roleId.padEnd(10)} FROZEN (${agentState.cooldownRemaining} rounds) \u2014 ${action.intent.slice(0, 40)}
+`);
+        const frozenEvent = {
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          worldId: world.world.world_id,
+          worldName: world.world.name,
+          worldVersion: world.world.version,
+          intent: action.intent,
+          tool: action.tool,
+          actor: action.roleId,
+          direction: "input",
+          decision: "PENALIZE",
+          reason: `Agent frozen for ${agentState.cooldownRemaining} more round(s)`,
+          guardsMatched: [],
+          rulesMatched: [],
+          invariantsSatisfied: 0,
+          invariantsTotal: 0,
+          enforcementLevel: "standard",
+          originalIntent: action.intent,
+          finalAction: "blocked (agent frozen)"
+        };
+        allAuditEvents.push(frozenEvent);
+        continue;
+      }
+      const verdict = evaluateGuard(event, world, engineOptions);
+      let state = agentStates.get(action.roleId) ?? createAgentState(action.roleId);
+      if (verdict.status === "PENALIZE" && verdict.consequence) {
+        state = applyConsequence(state, verdict.consequence, verdict.ruleId ?? "unknown");
+      }
+      if (verdict.status === "REWARD" && verdict.reward) {
+        state = applyReward(state, verdict.reward, verdict.ruleId ?? "unknown");
+      }
+      agentStates.set(action.roleId, state);
+      const icon = verdict.status === "ALLOW" ? "\u25CF" : verdict.status === "BLOCK" ? "\u25CB" : verdict.status === "PENALIZE" ? "\u25CC" : verdict.status === "REWARD" ? "\u25C9" : verdict.status === "MODIFY" ? "\u25D0" : verdict.status === "NEUTRAL" ? "\u25EF" : "\u25D1";
+      process.stdout.write(`  ${icon} ${action.roleId.padEnd(10)} ${verdict.status.padEnd(10)} ${action.intent.slice(0, 40)}
+`);
+      if (verdict.consequence) {
+        process.stdout.write(`    \u2192 ${verdict.consequence.description}
+`);
+      }
+      if (verdict.reward) {
+        process.stdout.write(`    \u2192 ${verdict.reward.description}
+`);
+      }
+      allAuditEvents.push(verdictToAuditEvent(event, verdict));
+    }
+    agentStates = tickAgentStates(agentStates);
+    engineOptions.agentStates = agentStates;
+    process.stdout.write("\n");
+    process.stdout.write("  Agent States:\n");
+    for (const agent of agents) {
+      const s = agentStates.get(agent.id);
+      if (!s) continue;
+      const frozen = s.cooldownRemaining > 0 ? ` [FROZEN ${s.cooldownRemaining}r]` : "";
+      const influence = s.influence !== 1 ? ` influence=${s.influence.toFixed(2)}` : "";
+      process.stdout.write(`    ${agent.id.padEnd(10)} penalties=${s.totalPenalties} rewards=${s.totalRewards}${frozen}${influence}
+`);
+    }
+    process.stdout.write("\n");
+  }
+  const flow = generateDecisionFlow(allAuditEvents);
+  if (jsonOutput) {
+    process.stdout.write(JSON.stringify({ flow, agentStates: Object.fromEntries(agentStates) }, null, 2) + "\n");
+  } else {
+    process.stdout.write(renderDecisionFlow(flow) + "\n");
+  }
+}
+var AGENTS;
+var init_equity_penalties = __esm({
+  "src/cli/equity-penalties.ts"() {
+    "use strict";
+    init_guard_engine();
+    init_world_loader();
+    init_decision_flow_engine();
+    init_audit_logger();
+    AGENTS = [
+      { id: "alpha", name: "Alpha Fund", strategy: "aggressive" },
+      { id: "beta", name: "Beta Holdings", strategy: "conservative" },
+      { id: "gamma", name: "Gamma Capital", strategy: "balanced" },
+      { id: "delta", name: "Delta Quant", strategy: "aggressive" },
+      { id: "epsilon", name: "Epsilon Value", strategy: "conservative" },
+      { id: "zeta", name: "Zeta Momentum", strategy: "aggressive" },
+      { id: "eta", name: "Eta Growth", strategy: "balanced" },
+      { id: "theta", name: "Theta Macro", strategy: "conservative" }
+    ];
+  }
+});
+
 // src/cli/configure-ai.ts
 var configure_ai_exports = {};
 __export(configure_ai_exports, {
-  main: () => main19
+  main: () => main23
 });
-function parseArgs16(argv) {
+function parseArgs18(argv) {
   let provider;
   let model;
   let apiKey;
@@ -10191,9 +12256,9 @@ function parseArgs16(argv) {
   }
   return { provider, model, apiKey, endpoint, show, test };
 }
-async function main19(argv = process.argv.slice(2)) {
+async function main23(argv = process.argv.slice(2)) {
   try {
-    const args = parseArgs16(argv);
+    const args = parseArgs18(argv);
     if (args.show) {
       const config2 = await loadConfig();
       if (!config2) {
@@ -10301,6 +12366,8 @@ Commands:
   simulate       Step-by-step state evolution
   improve        Actionable suggestions for strengthening a world
   init           Scaffold a new .nv-world.md template
+  init-world     Generate a governed world from a template (e.g., autoresearch)
+  infer-world    Scan a repo and infer a governance world from its structure
   validate       Static analysis on world files
   guard          Runtime governance evaluation (stdin \u2192 stdout)
   test           Run guard simulation suite against a world
@@ -10313,6 +12380,8 @@ Commands:
   worlds         List available worlds (alias for world list)
   trace          Runtime action audit log
   impact         Counterfactual governance impact report
+  decision-flow  Intent \u2192 Rule \u2192 Outcome visualization (behavioral governance)
+  equity-penalties  Fortune 500 equity PENALIZE/REWARD simulation
   world          World management (status, diff, snapshot, rollback)
   derive         AI-assisted synthesis of .nv-world.md from markdown
   bootstrap      Compile .nv-world.md \u2192 world JSON files
@@ -10324,6 +12393,8 @@ Usage:
   neuroverse simulate <world-path-or-id> [--steps N] [--set key=value] [--profile name]
   neuroverse improve <world-path-or-id> [--json]
   neuroverse init [--name "World Name"] [--output path]
+  neuroverse init-world autoresearch [--context "topic"] [--dataset "name"] [--goal "goal"]
+  neuroverse infer-world ./repo [--output path] [--json] [--dry-run]
   neuroverse validate --world <dir> [--format full|summary|findings]
   neuroverse guard --world <dir> [--trace] [--level basic|standard|strict]
   neuroverse test --world <dir> [--fuzz] [--count N]
@@ -10338,6 +12409,8 @@ Usage:
   neuroverse world rollback <path>
   neuroverse derive --input <path> [--output <path>] [--dry-run]
   neuroverse bootstrap --input <.md> --output <dir> [--validate]
+  neuroverse decision-flow [--log <path>] [--json]
+  neuroverse equity-penalties --world <dir> [--agents N] [--rounds N] [--json]
   neuroverse configure-ai --provider <name> --model <name> --api-key <key>
 
 Examples:
@@ -10362,7 +12435,7 @@ Examples:
   neuroverse doctor
   neuroverse playground --world ./world/
 `.trim();
-async function main20() {
+async function main24() {
   const args = process.argv.slice(2);
   const command = args[0];
   const subArgs = args.slice(1);
@@ -10387,6 +12460,14 @@ async function main20() {
       const { main: initMain } = await Promise.resolve().then(() => (init_init(), init_exports));
       return initMain(subArgs);
     }
+    case "init-world": {
+      const { main: initWorldMain } = await Promise.resolve().then(() => (init_init_world(), init_world_exports));
+      return initWorldMain(subArgs);
+    }
+    case "infer-world": {
+      const { main: inferWorldMain } = await Promise.resolve().then(() => (init_infer_world(), infer_world_exports));
+      return inferWorldMain(subArgs);
+    }
     case "bootstrap": {
       const { main: bootstrapMain } = await Promise.resolve().then(() => (init_bootstrap(), bootstrap_exports));
       return bootstrapMain(subArgs);
@@ -10447,6 +12528,14 @@ async function main20() {
       const { main: deriveMain } = await Promise.resolve().then(() => (init_derive(), derive_exports));
       return deriveMain(subArgs);
     }
+    case "decision-flow": {
+      const { main: decisionFlowMain } = await Promise.resolve().then(() => (init_decision_flow(), decision_flow_exports));
+      return decisionFlowMain(subArgs);
+    }
+    case "equity-penalties": {
+      const { main: equityPenaltiesMain } = await Promise.resolve().then(() => (init_equity_penalties(), equity_penalties_exports));
+      return equityPenaltiesMain(subArgs);
+    }
     case "configure-ai": {
       const { main: configureAiMain } = await Promise.resolve().then(() => (init_configure_ai(), configure_ai_exports));
       return configureAiMain(subArgs);
@@ -10468,7 +12557,7 @@ async function main20() {
     }
   }
 }
-main20().catch((e) => {
+main24().catch((e) => {
   process.stderr.write(`Fatal: ${e}
 `);
   process.exit(3);