@neuroverseos/governance 0.3.4 → 0.4.0

package/dist/configure-world-XU2COHOZ.js

@@ -0,0 +1,705 @@
+import "./chunk-QWGCMQQD.js";
+
+// src/cli/prompt-utils.ts
+import * as readline from "readline";
+var rl = null;
+function getRL() {
+  if (!rl) {
+    rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stderr,
+      // prompts go to stderr, data to stdout
+      terminal: true
+    });
+  }
+  return rl;
+}
+function closePrompts() {
+  if (rl) {
+    rl.close();
+    rl = null;
+  }
+}
+function ask(question, defaultValue) {
+  const suffix = defaultValue ? ` [${defaultValue}]` : "";
+  return new Promise((resolve) => {
+    getRL().question(`
+  ${question}${suffix}: `, (answer) => {
+      const val = answer.trim();
+      resolve(val || defaultValue || "");
+    });
+  });
+}
+function confirm(question, defaultYes = true) {
+  const hint = defaultYes ? "[Y/n]" : "[y/N]";
+  return new Promise((resolve) => {
+    getRL().question(`
+  ${question} ${hint}: `, (answer) => {
+      const val = answer.trim().toLowerCase();
+      if (val === "") resolve(defaultYes);
+      else resolve(val === "y" || val === "yes");
+    });
+  });
+}
+function choose(question, options) {
+  return new Promise((resolve) => {
+    const r = getRL();
+    r.write(`
+  ${question}
+`);
+    options.forEach((opt, i) => r.write(`    ${i + 1}. ${opt}
+`));
+    r.question(`  Choice [1-${options.length}]: `, (answer) => {
+      const idx = parseInt(answer.trim(), 10) - 1;
+      if (idx >= 0 && idx < options.length) {
+        resolve(options[idx]);
+      } else {
+        resolve(options[0]);
+      }
+    });
+  });
+}
+async function askMany(question, hint) {
+  const items = [];
+  const hintText = hint ? ` (${hint})` : "";
+  process.stderr.write(`
+  ${question}${hintText}
+`);
+  process.stderr.write("  Enter items one at a time. Empty line to finish.\n");
+  while (true) {
+    const item = await ask(`  ${items.length + 1}.`);
+    if (!item) break;
+    items.push(item);
+  }
+  return items;
+}
+function heading(text) {
+  process.stderr.write(`
+${"\u2500".repeat(60)}
+`);
+  process.stderr.write(`  ${text}
+`);
+  process.stderr.write(`${"\u2500".repeat(60)}
+`);
+}
+function summary(label, items) {
+  process.stderr.write(`
+  ${label}:
+`);
+  items.forEach((item) => process.stderr.write(`    \u2022 ${item}
+`));
+}
+function info(text) {
+  process.stderr.write(`  ${text}
+`);
+}
+
+// src/cli/configure-world.ts
+var DOMAIN_TEMPLATES = {
+  "Customer service": {
+    label: "Customer service",
+    healthMetrics: ["customer_satisfaction", "trust_score", "resolution_rate"],
+    negativDrivers: ["complaints", "slow_responses", "escalations"],
+    positiveDrivers: ["fast_responses", "positive_feedback", "first_contact_resolution"],
+    blockActions: ["share customer PII", "issue unauthorized refunds", "make legal promises"],
+    reviewActions: ["escalations", "large refund requests", "account closures"]
+  },
+  "Trading system": {
+    label: "Trading system",
+    healthMetrics: ["portfolio_health", "risk_score", "compliance_rate"],
+    negativDrivers: ["losses", "risk_violations", "unauthorized_trades"],
+    positiveDrivers: ["profitable_trades", "risk_compliance", "diversification"],
+    blockActions: ["exceed risk limits", "trade restricted securities", "bypass compliance"],
+    reviewActions: ["large positions", "new asset classes", "margin changes"]
+  },
+  "Content moderation": {
+    label: "Content moderation",
+    healthMetrics: ["content_quality", "safety_score", "creator_trust"],
+    negativDrivers: ["policy_violations", "false_positives", "user_reports"],
+    positiveDrivers: ["clean_content", "accurate_moderation", "appeal_resolutions"],
+    blockActions: ["approve harmful content", "ban without review", "ignore reports"],
+    reviewActions: ["borderline content", "repeat offenders", "appeal requests"]
+  },
+  "Research agent": {
+    label: "Research agent",
+    healthMetrics: ["accuracy_score", "source_quality", "output_reliability"],
+    negativDrivers: ["hallucinations", "unsourced_claims", "bias_incidents"],
+    positiveDrivers: ["verified_findings", "diverse_sources", "peer_validation"],
+    blockActions: ["fabricate citations", "present opinion as fact", "ignore contradicting evidence"],
+    reviewActions: ["novel conclusions", "controversial topics", "policy recommendations"]
+  }
+};
+function metricToStateVariable(metric) {
+  const id = metric.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, "");
+  return {
+    id,
+    variable: {
+      type: "number",
+      min: 0,
+      max: 100,
+      step: 5,
+      default: 70,
+      mutable: true,
+      label: metric.replace(/\b\w/g, (c) => c.toUpperCase()),
+      description: `Measures ${metric.toLowerCase()} on a 0-100 scale`,
+      display_as: "integer"
+    }
+  };
+}
+function negativeDriverToRule(driver, healthMetrics, ruleIndex) {
+  const driverId = driver.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, "");
+  const primaryTarget = healthMetrics[0]?.id || "system_health";
+  const eventRuleId = `rule-${String(ruleIndex).padStart(3, "0")}`;
+  const stateRuleId = `rule-${String(ruleIndex).padStart(3, "0")}-threshold`;
+  const counterId = `${driverId}_count`;
+  const stateVar = {
+    type: "number",
+    min: 0,
+    max: 100,
+    step: 1,
+    default: 0,
+    mutable: true,
+    label: `${driver.replace(/\b\w/g, (c) => c.toUpperCase())} Count`,
+    description: `Number of ${driver.toLowerCase()} events (0 = none)`,
+    display_as: "integer"
+  };
+  const eventRule = {
+    id: eventRuleId,
+    severity: "degradation",
+    label: `${driver} event degrades ${primaryTarget.replace(/_/g, " ")}`,
+    description: `Each ${driver.toLowerCase()} event reduces ${primaryTarget.replace(/_/g, " ")} by 5 and increments the counter.`,
+    order: ruleIndex,
+    triggers: [{
+      field: "event",
+      operator: "==",
+      value: driverId,
+      source: "state"
+    }],
+    effects: [
+      { target: primaryTarget, operation: "subtract", value: 5 },
+      { target: counterId, operation: "add", value: 1 }
+    ],
+    causal_translation: {
+      trigger_text: `A ${driver.toLowerCase()} event occurs`,
+      rule_text: `Each ${driver.toLowerCase()} chips away at system health`,
+      shift_text: `${primaryTarget.replace(/_/g, " ")} decreases incrementally`,
+      effect_text: `${primaryTarget.replace(/_/g, " ")} reduced by 5 points per event`
+    }
+  };
+  const stateRule = {
+    id: stateRuleId,
+    severity: "degradation",
+    label: `${driver} accumulation compounds damage`,
+    description: `When ${driver.toLowerCase()} count exceeds threshold, ${primaryTarget.replace(/_/g, " ")} suffers compounding loss.`,
+    order: ruleIndex + 100,
+    triggers: [{
+      field: counterId,
+      operator: ">",
+      value: 30,
+      source: "state"
+    }],
+    effects: [
+      { target: primaryTarget, operation: "multiply", value: 0.7 }
+    ],
+    causal_translation: {
+      trigger_text: `${driver} count exceeds safe threshold (30)`,
+      rule_text: `Accumulated ${driver.toLowerCase()} creates compounding pressure`,
+      shift_text: `${primaryTarget.replace(/_/g, " ")} begins accelerating decline`,
+      effect_text: `${primaryTarget.replace(/_/g, " ")} multiplied by 0.7 (30% loss)`
+    }
+  };
+  return { id: eventRuleId, rules: [eventRule, stateRule], stateVar: { id: counterId, variable: stateVar } };
+}
+function positiveDriverToRule(driver, healthMetrics, ruleIndex) {
+  const driverId = driver.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, "");
+  const primaryTarget = healthMetrics[0]?.id || "system_health";
+  const eventRuleId = `rule-${String(ruleIndex).padStart(3, "0")}`;
+  const stateRuleId = `rule-${String(ruleIndex).padStart(3, "0")}-threshold`;
+  const counterId = `${driverId}_count`;
+  const stateVar = {
+    type: "number",
+    min: 0,
+    max: 100,
+    step: 1,
+    default: 0,
+    mutable: true,
+    label: `${driver.replace(/\b\w/g, (c) => c.toUpperCase())} Count`,
+    description: `Number of ${driver.toLowerCase()} events (0 = none)`,
+    display_as: "integer"
+  };
+  const eventRule = {
+    id: eventRuleId,
+    severity: "advantage",
+    label: `${driver} event improves ${primaryTarget.replace(/_/g, " ")}`,
+    description: `Each ${driver.toLowerCase()} event increases ${primaryTarget.replace(/_/g, " ")} by 3 and increments the counter.`,
+    order: ruleIndex,
+    triggers: [{
+      field: "event",
+      operator: "==",
+      value: driverId,
+      source: "state"
+    }],
+    effects: [
+      { target: primaryTarget, operation: "add", value: 3 },
+      { target: counterId, operation: "add", value: 1 }
+    ],
+    causal_translation: {
+      trigger_text: `A ${driver.toLowerCase()} event occurs`,
+      rule_text: `Each ${driver.toLowerCase()} reinforces system health`,
+      shift_text: `${primaryTarget.replace(/_/g, " ")} improves incrementally`,
+      effect_text: `${primaryTarget.replace(/_/g, " ")} increased by 3 points per event`
+    }
+  };
+  const stateRule = {
+    id: stateRuleId,
+    severity: "advantage",
+    label: `${driver} momentum amplifies improvement`,
+    description: `When ${driver.toLowerCase()} count exceeds threshold, ${primaryTarget.replace(/_/g, " ")} gets a compounding boost.`,
+    order: ruleIndex + 100,
+    triggers: [{
+      field: counterId,
+      operator: ">",
+      value: 20,
+      source: "state"
+    }],
+    effects: [
+      { target: primaryTarget, operation: "multiply", value: 1.15 }
+    ],
+    causal_translation: {
+      trigger_text: `${driver} count exceeds momentum threshold (20)`,
+      rule_text: `Sustained ${driver.toLowerCase()} creates compounding improvement`,
+      shift_text: `${primaryTarget.replace(/_/g, " ")} begins accelerating growth`,
+      effect_text: `${primaryTarget.replace(/_/g, " ")} multiplied by 1.15 (15% boost)`
+    }
+  };
+  return { id: eventRuleId, rules: [eventRule, stateRule], stateVar: { id: counterId, variable: stateVar } };
+}
+function blockActionToGuard(action, index) {
+  const id = `guard_block_${String(index).padStart(3, "0")}`;
+  const words = action.toLowerCase().replace(/[^a-z0-9\s]/g, "").split(/\s+/).filter((w) => w.length > 2);
+  const pattern = `*${words.join("*")}*`;
+  return {
+    id,
+    label: `Block: ${action}`,
+    description: `Prevents the system from attempting to ${action.toLowerCase()}.`,
+    category: "structural",
+    enforcement: "block",
+    immutable: false,
+    intent_patterns: [pattern]
+  };
+}
+function reviewActionToGuard(action, index) {
+  const id = `guard_pause_${String(index).padStart(3, "0")}`;
+  const words = action.toLowerCase().replace(/[^a-z0-9\s]/g, "").split(/\s+/).filter((w) => w.length > 2);
+  const pattern = `*${words.join("*")}*`;
+  return {
+    id,
+    label: `Review: ${action}`,
+    description: `Requires human review before the system can ${action.toLowerCase()}.`,
+    category: "operational",
+    enforcement: "pause",
+    immutable: false,
+    intent_patterns: [pattern]
+  };
+}
+function generateGates(primaryMetricId) {
+  const gates = [
+    { status: "THRIVING", field: primaryMetricId, operator: ">=", value: 80, color: "#22c55e", icon: "\u25C6" },
+    { status: "STABLE", field: primaryMetricId, operator: ">=", value: 60, color: "#3b82f6", icon: "\u25CF" },
+    { status: "COMPRESSED", field: primaryMetricId, operator: ">=", value: 40, color: "#f59e0b", icon: "\u25B2" },
+    { status: "CRITICAL", field: primaryMetricId, operator: ">=", value: 20, color: "#ef4444", icon: "\u2726" },
+    { status: "MODEL_COLLAPSES", field: primaryMetricId, operator: "<", value: 20, color: "#7f1d1d", icon: "\u2715" }
+  ];
+  return {
+    viability_classification: gates,
+    structural_override: {
+      description: "System collapse when primary health metric falls below critical threshold",
+      enforcement: "mandatory"
+    },
+    sustainability_threshold: 40,
+    collapse_visual: {
+      background: "#7f1d1d",
+      text: "#fecaca",
+      border: "#ef4444",
+      label: "SYSTEM COLLAPSED"
+    }
+  };
+}
+async function phaseContext() {
+  heading("Let's define your system");
+  info("We'll do two things:");
+  info("  1. Control what actions are allowed");
+  info("  2. Model what happens over time");
+  const domain = await choose("What are you building?", [
+    ...Object.keys(DOMAIN_TEMPLATES),
+    "Something else"
+  ]);
+  const worldName = await ask("Give your world a name", domain === "Something else" ? "My System" : `${domain} Governance`);
+  const worldId = worldName.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, "");
+  const thesis = await ask(
+    "In one sentence, what does this system govern?",
+    domain !== "Something else" ? `Governance model for ${domain.toLowerCase()} operations` : void 0
+  );
+  return { worldName, worldId, thesis, domain };
+}
+async function phaseGuard(domain) {
+  heading("Layer 1: Action Control");
+  info("What should this system NOT do?");
+  const template = DOMAIN_TEMPLATES[domain];
+  let blockActions;
+  let reviewActions;
+  if (template) {
+    info(`
+  Suggested for ${domain}:`);
+    template.blockActions.forEach((a) => info(`    BLOCK: ${a}`));
+    const useSuggested = await confirm("Use these suggestions?");
+    if (useSuggested) {
+      blockActions = [...template.blockActions];
+    } else {
+      blockActions = await askMany("What should be BLOCKED?", "actions the system must never do");
+    }
+    info("\n  What should require human review?");
+    if (useSuggested) {
+      template.reviewActions.forEach((a) => info(`    REVIEW: ${a}`));
+      const useReviewSuggested = await confirm("Use these suggestions?");
+      reviewActions = useReviewSuggested ? [...template.reviewActions] : await askMany("What needs human REVIEW?");
+    } else {
+      reviewActions = await askMany("What needs human REVIEW?", "actions that need approval");
+    }
+  } else {
+    blockActions = await askMany("What should be BLOCKED?", "actions the system must never do");
+    reviewActions = await askMany("What needs human REVIEW?", "actions that need approval");
+  }
+  if (blockActions.length > 0 || reviewActions.length > 0) {
+    summary("Actions configured", [
+      ...blockActions.map((a) => `BLOCK: ${a}`),
+      ...reviewActions.map((a) => `REVIEW: ${a}`)
+    ]);
+  }
+  return { blockActions, reviewActions };
+}
+async function phaseSystem(domain) {
+  heading("Layer 2: System Dynamics");
+  info("Now let's define what a healthy system looks like over time.\n");
+  const template = DOMAIN_TEMPLATES[domain];
+  let healthMetrics;
+  let negativeDrivers;
+  let positiveDrivers;
+  info("What are you trying to protect or optimize?");
+  if (template) {
+    info("  Examples:");
+    template.healthMetrics.forEach((m) => info(`    \u2022 ${m.replace(/_/g, " ")}`));
+    const useSuggested = await confirm("Use these suggestions?");
+    if (useSuggested) {
+      healthMetrics = [...template.healthMetrics];
+    } else {
+      healthMetrics = await askMany("What metrics define system health?", "e.g., customer satisfaction, trust, revenue");
+    }
+  } else {
+    healthMetrics = await askMany("What metrics define system health?", "e.g., customer satisfaction, trust, revenue");
+  }
+  if (healthMetrics.length === 0) {
+    healthMetrics = ["system_health"];
+    info('  Defaulting to "system_health" as primary metric.');
+  }
+  info("\n  What makes this worse?");
+  if (template) {
+    info("  Examples:");
+    template.negativDrivers.forEach((d) => info(`    \u2022 ${d.replace(/_/g, " ")}`));
+    const useSuggested = await confirm("Use these suggestions?");
+    negativeDrivers = useSuggested ? [...template.negativDrivers] : await askMany("What degrades your system?");
+  } else {
+    negativeDrivers = await askMany("What degrades your system?", "e.g., complaints, errors, delays");
+  }
+  info("\n  What makes this better?");
+  if (template) {
+    info("  Examples:");
+    template.positiveDrivers.forEach((d) => info(`    \u2022 ${d.replace(/_/g, " ")}`));
+    const useSuggested = await confirm("Use these suggestions?");
+    positiveDrivers = useSuggested ? [...template.positiveDrivers] : await askMany("What improves your system?");
+  } else {
+    positiveDrivers = await askMany("What improves your system?", "e.g., fast responses, positive feedback");
+  }
+  summary("System dynamics", [
+    `Health: ${healthMetrics.join(", ")}`,
+    `Degrades from: ${negativeDrivers.join(", ") || "(none)"}`,
+    `Improves from: ${positiveDrivers.join(", ") || "(none)"}`
+  ]);
+  return { healthMetrics, negativeDrivers, positiveDrivers };
+}
+function generateWorld(state) {
+  const worldJson = {
+    world_id: state.worldId,
+    name: state.worldName,
+    thesis: state.thesis,
+    version: "1.0.0",
+    runtime_mode: "SIMULATION",
+    default_assumption_profile: "baseline",
+    default_alternative_profile: "stress",
+    modules: [],
+    players: { thinking_space: true, experience_space: true, action_space: true }
+  };
+  const variables = {};
+  const metricIds = [];
+  for (const metric of state.healthMetrics) {
+    const { id, variable } = metricToStateVariable(metric);
+    variables[id] = variable;
+    metricIds.push({ id });
+  }
+  const rules = [];
+  let ruleIdx = 1;
+  for (const driver of state.negativeDrivers) {
+    const result = negativeDriverToRule(driver, metricIds, ruleIdx++);
+    rules.push(...result.rules);
+    if (!variables[result.stateVar.id]) {
+      variables[result.stateVar.id] = result.stateVar.variable;
+    }
+  }
+  for (const driver of state.positiveDrivers) {
+    const result = positiveDriverToRule(driver, metricIds, ruleIdx++);
+    rules.push(...result.rules);
+    if (!variables[result.stateVar.id]) {
+      variables[result.stateVar.id] = result.stateVar.variable;
+    }
+  }
+  const stateSchema = {
+    variables,
+    presets: {
+      "Healthy": {
+        description: "System operating normally",
+        values: Object.fromEntries(
+          Object.entries(variables).map(([id, v]) => [id, v.default])
+        )
+      },
+      "Stressed": {
+        description: "System under pressure",
+        values: Object.fromEntries(
+          Object.entries(variables).map(([id, v]) => {
+            if (id.endsWith("_count") && state.negativeDrivers.some((d) => id.startsWith(d.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, "")))) {
+              return [id, 40];
+            }
+            if (state.healthMetrics.some((m) => m.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, "") === id)) {
+              return [id, 40];
+            }
+            return [id, v.default];
+          })
+        )
+      }
+    }
+  };
+  const guards = [];
+  state.blockActions.forEach((action, i) => {
+    guards.push(blockActionToGuard(action, i + 1));
+  });
+  state.reviewActions.forEach((action, i) => {
+    guards.push(reviewActionToGuard(action, i + 1));
+  });
+  const guardsJson = {
+    guards,
+    intent_vocabulary: {}
+  };
+  const primaryMetricId = metricIds[0]?.id || "system_health";
+  const gatesJson = generateGates(primaryMetricId);
+  const invariants = [
+    {
+      id: "system_must_remain_governable",
+      label: "System must remain under governance at all times",
+      enforcement: "structural",
+      mutable: false
+    }
+  ];
+  const primaryOutcome = {
+    id: primaryMetricId,
+    type: "number",
+    range: [0, 100],
+    display_as: "integer",
+    label: variables[primaryMetricId]?.label || "System Health",
+    primary: true,
+    show_in_comparison: true
+  };
+  const outcomes = {
+    computed_outcomes: [
+      primaryOutcome,
+      ...metricIds.slice(1).map((m) => ({
+        id: m.id,
+        type: "number",
+        range: [0, 100],
+        display_as: "integer",
+        label: variables[m.id]?.label || m.id,
+        primary: false,
+        show_in_comparison: true
+      }))
+    ],
+    comparison_layout: {
+      primary_card: primaryMetricId,
+      status_badge: primaryMetricId,
+      structural_indicators: metricIds.map((m) => m.id)
+    }
+  };
+  const metadata = {
+    format_version: "1.0.0",
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    last_modified: (/* @__PURE__ */ new Date()).toISOString(),
+    authoring_method: "configurator-ai"
+  };
+  return { worldJson, stateSchema, guardsJson, rules, gatesJson, invariants, outcomes, metadata };
+}
+async function writeWorld(outputDir, world) {
+  const { mkdirSync, existsSync } = await import("fs");
+  const { writeFile } = await import("fs/promises");
+  const { join } = await import("path");
+  const files = [];
+  if (!existsSync(outputDir)) mkdirSync(outputDir, { recursive: true });
+  const rulesDir = join(outputDir, "rules");
+  if (!existsSync(rulesDir)) mkdirSync(rulesDir, { recursive: true });
+  const writeJson = async (name, data) => {
+    const path = join(outputDir, name);
+    await writeFile(path, JSON.stringify(data, null, 2) + "\n", "utf-8");
+    files.push(path);
+  };
+  await writeJson("world.json", world.worldJson);
+  await writeJson("state-schema.json", world.stateSchema);
+  await writeJson("guards.json", world.guardsJson);
+  await writeJson("gates.json", world.gatesJson);
+  await writeJson("invariants.json", world.invariants);
+  await writeJson("outcomes.json", world.outcomes);
+  await writeJson("metadata.json", world.metadata);
+  for (const rule of world.rules) {
+    const rulePath = join(rulesDir, `${rule.id}.json`);
+    await writeFile(rulePath, JSON.stringify(rule, null, 2) + "\n", "utf-8");
+    files.push(rulePath);
+  }
+  return files;
+}
+function parseArgs(argv) {
+  let outputDir = "./world/";
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if ((arg === "--output" || arg === "-o") && i + 1 < argv.length) {
+      outputDir = argv[++i];
+    }
+  }
+  return { outputDir };
+}
+async function main(argv = process.argv.slice(2)) {
+  try {
+    const args = parseArgs(argv);
+    const context = await phaseContext();
+    const guardState = await phaseGuard(context.domain);
+    const systemState = await phaseSystem(context.domain);
+    const wizardState = {
+      ...context,
+      ...guardState,
+      ...systemState
+    };
+    heading("Summary");
+    info(`World: ${wizardState.worldName}`);
+    info(`Thesis: ${wizardState.thesis}`);
+    summary("Guard rules", [
+      ...wizardState.blockActions.map((a) => `BLOCK: ${a}`),
+      ...wizardState.reviewActions.map((a) => `REVIEW: ${a}`)
+    ]);
+    summary("System dynamics", [
+      `Health metrics: ${wizardState.healthMetrics.join(", ")}`,
+      `Degrades from: ${wizardState.negativeDrivers.join(", ") || "(none)"}`,
+      `Improves from: ${wizardState.positiveDrivers.join(", ") || "(none)"}`
+    ]);
+    const proceed = await confirm("\nCreate world?");
+    if (!proceed) {
+      info("Aborted.");
+      closePrompts();
+      process.exit(0);
+      return;
+    }
+    info("\nGenerating world...");
+    const world = generateWorld(wizardState);
+    const files = await writeWorld(args.outputDir, world);
+    heading("World created");
+    info(`Output: ${args.outputDir}`);
+    info(`Files: ${files.length}`);
+    summary("Generated", [
+      `${Object.keys(world.stateSchema.variables).length} state variables`,
+      `${world.rules.length} rules (${world.rules.filter((r) => r.severity === "degradation").length} degradation, ${world.rules.filter((r) => r.severity === "advantage").length} advantage)`,
+      `${world.guardsJson.guards.length} guards (${world.guardsJson.guards.filter((g) => g.enforcement === "block").length} block, ${world.guardsJson.guards.filter((g) => g.enforcement === "pause").length} pause)`,
+      `5 viability gates (THRIVING \u2192 MODEL_COLLAPSES)`
+    ]);
+    info("\nNext steps:");
+    info(`  neuroverse validate --world ${args.outputDir}`);
+    info(`  neuroverse simulate ${args.outputDir} --steps 5`);
+    info(`  neuroverse explain ${args.outputDir}`);
+    const refine = await confirm("\nWant to refine thresholds and collapse rules?", false);
+    if (refine) {
+      await phaseRefine(args.outputDir, world);
+    }
+    closePrompts();
+    const result = {
+      created: args.outputDir,
+      worldName: wizardState.worldName,
+      files: files.length,
+      stateVariables: Object.keys(world.stateSchema.variables).length,
+      rules: world.rules.length,
+      guards: world.guardsJson.guards.length,
+      gates: 5
+    };
+    process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+    process.exit(0);
+  } catch (e) {
+    closePrompts();
+    process.stderr.write(`Error: ${e instanceof Error ? e.message : String(e)}
+`);
+    process.exit(3);
+  }
+}
+async function phaseRefine(outputDir, world) {
+  const { writeFile } = await import("fs/promises");
+  const { join } = await import("path");
+  heading("Refinement: Thresholds & Collapse");
+  const primaryMetric = world.gatesJson.viability_classification[0]?.field || "system_health";
+  info(`
+  Primary health metric: ${primaryMetric}`);
+  info("  Current gate thresholds:");
+  for (const gate of world.gatesJson.viability_classification) {
+    info(`    ${gate.status}: ${gate.field} ${gate.operator} ${gate.value}`);
+  }
+  const changeGates = await confirm("Adjust gate thresholds?", false);
+  if (changeGates) {
+    for (const gate of world.gatesJson.viability_classification) {
+      const newVal = await ask(`  ${gate.status} threshold (${gate.operator})`, String(gate.value));
+      const parsed = parseInt(newVal, 10);
+      if (!isNaN(parsed)) gate.value = parsed;
+    }
+    await writeFile(
+      join(outputDir, "gates.json"),
+      JSON.stringify(world.gatesJson, null, 2) + "\n",
+      "utf-8"
+    );
+    info("  Gates updated.");
+  }
+  const addCollapse = await confirm("Add collapse conditions to degradation rules?", false);
+  if (addCollapse) {
+    for (const rule of world.rules.filter((r) => r.severity === "degradation")) {
+      info(`
+  Rule: ${rule.label}`);
+      const target = rule.effects?.[0]?.target || primaryMetric;
+      const collapseVal = await ask(`  ${target} collapses below what value?`, "10");
+      const parsed = parseInt(collapseVal, 10);
+      if (!isNaN(parsed)) {
+        rule.collapse_check = {
+          field: target,
+          operator: "<",
+          value: parsed,
+          result: "MODEL_COLLAPSES"
+        };
+        await writeFile(
+          join(outputDir, "rules", `${rule.id}.json`),
+          JSON.stringify(rule, null, 2) + "\n",
+          "utf-8"
+        );
+        info(`  Collapse condition added: ${target} < ${parsed}`);
+      }
+    }
+  }
+}
+export {
+  main
+};