@neuroverseos/governance 0.1.6 → 0.2.2

package/dist/index.cjs

@@ -37,12 +37,21 @@ __export(index_exports, {
   DERIVE_EXIT_CODES: () => DERIVE_EXIT_CODES,
   FileAuditLogger: () => FileAuditLogger,
   GUARD_EXIT_CODES: () => GUARD_EXIT_CODES,
+  McpGovernanceServer: () => McpGovernanceServer,
+  ModelAdapter: () => ModelAdapter,
+  PLAN_EXIT_CODES: () => PLAN_EXIT_CODES,
+  PROVIDERS: () => PROVIDERS,
+  SessionManager: () => SessionManager,
   VALIDATE_EXIT_CODES: () => VALIDATE_EXIT_CODES,
+  advancePlan: () => advancePlan,
+  buildPlanCheck: () => buildPlanCheck,
   createGovernanceEngine: () => createGovernanceEngine,
   deriveWorld: () => deriveWorld,
+  describeActiveWorld: () => describeActiveWorld,
   emitWorldDefinition: () => emitWorldDefinition,
   evaluateCondition: () => evaluateCondition,
   evaluateGuard: () => evaluateGuard,
+  evaluatePlan: () => evaluatePlan,
   eventToAllowlistKey: () => eventToAllowlistKey,
   explainWorld: () => explainWorld,
   extractWorldMarkdown: () => extractWorldMarkdown,
@@ -50,16 +59,25 @@ __export(index_exports, {
   formatVerdictOneLine: () => formatVerdictOneLine,
   generateImpactReport: () => generateImpactReport,
   generateImpactReportFromFile: () => generateImpactReportFromFile,
+  getActiveWorldName: () => getActiveWorldName,
+  getPlanProgress: () => getPlanProgress,
   improveWorld: () => improveWorld,
+  listWorlds: () => listWorlds,
   loadWorld: () => loadWorld,
   loadWorldFromDirectory: () => loadWorldFromDirectory,
   normalizeWorldMarkdown: () => normalizeWorldMarkdown,
+  parsePlanMarkdown: () => parsePlanMarkdown,
   parseWorldMarkdown: () => parseWorldMarkdown,
   readAuditLog: () => readAuditLog,
   renderExplainText: () => renderExplainText,
   renderImpactReport: () => renderImpactReport,
   renderImproveText: () => renderImproveText,
   renderSimulateText: () => renderSimulateText,
+  resolveProvider: () => resolveProvider,
+  resolveWorldPath: () => resolveWorldPath,
+  runInteractiveMode: () => runInteractiveMode,
+  runPipeMode: () => runPipeMode,
+  setActiveWorld: () => setActiveWorld,
   simulateWorld: () => simulateWorld,
   summarizeAuditEvents: () => summarizeAuditEvents,
   validateWorld: () => validateWorld,
@@ -67,6 +85,232 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
+// src/engine/plan-engine.ts
+function keywordMatch(eventText, step) {
+  const stepText = [
+    step.label,
+    step.description ?? "",
+    ...step.tags ?? []
+  ].join(" ").toLowerCase();
+  const keywords = stepText.split(/\s+/).filter((w) => w.length > 3);
+  if (keywords.length === 0) return false;
+  const matched = keywords.filter((kw) => eventText.includes(kw));
+  return matched.length >= Math.ceil(keywords.length * 0.5);
+}
+function tokenSimilarity(a, b) {
+  const tokensA = new Set(a.toLowerCase().split(/\s+/).filter((w) => w.length > 2));
+  const tokensB = new Set(b.toLowerCase().split(/\s+/).filter((w) => w.length > 2));
+  if (tokensA.size === 0 || tokensB.size === 0) return 0;
+  let intersection = 0;
+  for (const t of tokensA) {
+    if (tokensB.has(t)) intersection++;
+  }
+  const union = (/* @__PURE__ */ new Set([...tokensA, ...tokensB])).size;
+  return union > 0 ? intersection / union : 0;
+}
+function findMatchingStep(eventText, event, steps) {
+  const pendingOrActive = steps.filter((s) => s.status === "pending" || s.status === "active");
+  if (pendingOrActive.length === 0) {
+    return { matched: null, closest: null, closestScore: 0 };
+  }
+  for (const step of pendingOrActive) {
+    if (keywordMatch(eventText, step)) {
+      if (step.tools && event.tool && !step.tools.includes(event.tool)) {
+        continue;
+      }
+      return { matched: step, closest: step, closestScore: 1 };
+    }
+  }
+  const intentText = [event.intent, event.tool ?? "", event.scope ?? ""].join(" ");
+  let bestStep = null;
+  let bestScore = 0;
+  for (const step of pendingOrActive) {
+    const stepText = [step.label, step.description ?? "", ...step.tags ?? []].join(" ");
+    const score = tokenSimilarity(intentText, stepText);
+    if (score > bestScore) {
+      bestScore = score;
+      bestStep = step;
+    }
+  }
+  const SIMILARITY_THRESHOLD = 0.35;
+  if (bestScore >= SIMILARITY_THRESHOLD && bestStep) {
+    if (bestStep.tools && event.tool && !bestStep.tools.includes(event.tool)) {
+      return { matched: null, closest: bestStep, closestScore: bestScore };
+    }
+    return { matched: bestStep, closest: bestStep, closestScore: bestScore };
+  }
+  return { matched: null, closest: bestStep, closestScore: bestScore };
+}
+function isSequenceValid(step, plan) {
+  if (!plan.sequential) return true;
+  if (!step.requires || step.requires.length === 0) return true;
+  return step.requires.every((reqId) => {
+    const reqStep = plan.steps.find((s) => s.id === reqId);
+    return reqStep?.status === "completed";
+  });
+}
+function checkConstraints(event, eventText, constraints) {
+  const checks = [];
+  for (const constraint of constraints) {
+    if (constraint.type === "approval") {
+      if (constraint.trigger && eventText.includes(constraint.trigger.substring(0, 10).toLowerCase())) {
+        checks.push({ constraintId: constraint.id, passed: false, reason: constraint.description });
+        return { violated: constraint, checks };
+      }
+      const keywords = constraint.description.toLowerCase().split(/\s+/).filter((w) => w.length > 3);
+      const relevant = keywords.some((kw) => eventText.includes(kw));
+      if (relevant) {
+        checks.push({ constraintId: constraint.id, passed: false, reason: constraint.description });
+        return { violated: constraint, checks };
+      }
+      checks.push({ constraintId: constraint.id, passed: true });
+      continue;
+    }
+    if (constraint.type === "scope" && constraint.trigger) {
+      const keywords = constraint.trigger.split(/\s+/).filter((w) => w.length > 3);
+      const violated = keywords.length > 0 && keywords.every((kw) => eventText.includes(kw));
+      checks.push({
+        constraintId: constraint.id,
+        passed: !violated,
+        reason: violated ? constraint.description : void 0
+      });
+      if (violated) {
+        return { violated: constraint, checks };
+      }
+      continue;
+    }
+    checks.push({ constraintId: constraint.id, passed: true });
+  }
+  return { violated: null, checks };
+}
+function getPlanProgress(plan) {
+  const completed = plan.steps.filter((s) => s.status === "completed").length;
+  const total = plan.steps.length;
+  return {
+    completed,
+    total,
+    percentage: total > 0 ? Math.round(completed / total * 100) : 0
+  };
+}
+function advancePlan(plan, stepId, evidence) {
+  const step = plan.steps.find((s) => s.id === stepId);
+  if (!step) {
+    return { success: false, reason: `Step "${stepId}" not found in plan.` };
+  }
+  if (step.status === "completed") {
+    return { success: false, reason: `Step "${stepId}" is already completed.` };
+  }
+  const mode = plan.completion ?? "trust";
+  if (mode === "verified" && step.verify) {
+    if (!evidence) {
+      return {
+        success: false,
+        reason: `Step "${step.label}" requires evidence (verify: ${step.verify}). Provide evidence to advance.`
+      };
+    }
+    if (evidence.type !== step.verify) {
+      return {
+        success: false,
+        reason: `Evidence type "${evidence.type}" does not match required verification "${step.verify}".`
+      };
+    }
+  }
+  const updatedPlan = {
+    ...plan,
+    steps: plan.steps.map(
+      (s) => s.id === stepId ? { ...s, status: "completed" } : s
+    )
+  };
+  return {
+    success: true,
+    plan: updatedPlan,
+    evidence: evidence ?? void 0
+  };
+}
+function evaluatePlan(event, plan) {
+  const progress = getPlanProgress(plan);
+  if (plan.expires_at) {
+    const expiresAt = new Date(plan.expires_at).getTime();
+    if (Date.now() > expiresAt) {
+      return {
+        allowed: true,
+        status: "PLAN_COMPLETE",
+        reason: "Plan has expired.",
+        progress
+      };
+    }
+  }
+  if (progress.completed === progress.total) {
+    return {
+      allowed: true,
+      status: "PLAN_COMPLETE",
+      reason: "All plan steps are completed.",
+      progress
+    };
+  }
+  const eventText = [
+    event.intent,
+    event.tool ?? "",
+    event.scope ?? ""
+  ].join(" ").toLowerCase();
+  const { matched, closest, closestScore } = findMatchingStep(eventText, event, plan.steps);
+  if (!matched) {
+    return {
+      allowed: false,
+      status: "OFF_PLAN",
+      reason: "Action does not match any plan step.",
+      closestStep: closest?.label,
+      similarityScore: closestScore,
+      progress
+    };
+  }
+  if (!isSequenceValid(matched, plan)) {
+    const pendingDeps = (matched.requires ?? []).filter((reqId) => plan.steps.find((s) => s.id === reqId)?.status !== "completed").join(", ");
+    return {
+      allowed: false,
+      status: "OFF_PLAN",
+      reason: `Step "${matched.label}" requires completion of: ${pendingDeps}`,
+      matchedStep: matched.id,
+      progress
+    };
+  }
+  const { violated } = checkConstraints(event, eventText, plan.constraints);
+  if (violated) {
+    return {
+      allowed: false,
+      status: "CONSTRAINT_VIOLATED",
+      reason: violated.description,
+      matchedStep: matched.id,
+      progress
+    };
+  }
+  return {
+    allowed: true,
+    status: "ON_PLAN",
+    reason: `Matches step: ${matched.label}`,
+    matchedStep: matched.id,
+    progress
+  };
+}
+function buildPlanCheck(event, plan, verdict) {
+  const eventText = [event.intent, event.tool ?? "", event.scope ?? ""].join(" ").toLowerCase();
+  const { matched, closest, closestScore } = findMatchingStep(eventText, event, plan.steps);
+  const { checks: constraintChecks } = checkConstraints(event, eventText, plan.constraints);
+  const progress = getPlanProgress(plan);
+  return {
+    planId: plan.plan_id,
+    matched: !!matched,
+    matchedStepId: matched?.id,
+    matchedStepLabel: matched?.label,
+    closestStepId: !matched ? closest?.id : void 0,
+    closestStepLabel: !matched ? closest?.label : void 0,
+    similarityScore: !matched ? closestScore : void 0,
+    sequenceValid: matched ? isSequenceValid(matched, plan) : void 0,
+    constraintsChecked: constraintChecks,
+    progress: { completed: progress.completed, total: progress.total }
+  };
+}
+
 // src/engine/guard-engine.ts
 var PROMPT_INJECTION_PATTERNS = [
   // Instruction override
@@ -158,6 +402,7 @@ function evaluateGuard(event, world, options = {}) {
   const eventText = (event.intent + " " + (event.tool ?? "") + " " + (event.scope ?? "")).toLowerCase();
   const invariantChecks = [];
   const safetyChecks = [];
+  let planCheckResult;
   const roleChecks = [];
   const guardChecks = [];
   const kernelRuleChecks = [];
@@ -185,6 +430,7 @@ function evaluateGuard(event, world, options = {}) {
         includeTrace ? buildTrace(
           invariantChecks,
           safetyChecks,
+          planCheckResult,
           roleChecks,
           guardChecks,
           kernelRuleChecks,
@@ -213,6 +459,7 @@ function evaluateGuard(event, world, options = {}) {
       includeTrace ? buildTrace(
         invariantChecks,
         safetyChecks,
+        planCheckResult,
         roleChecks,
         guardChecks,
         kernelRuleChecks,
@@ -223,6 +470,42 @@ function evaluateGuard(event, world, options = {}) {
       ) : void 0
     );
   }
+  if (options.plan) {
+    const planVerdict = evaluatePlan(event, options.plan);
+    planCheckResult = buildPlanCheck(event, options.plan, planVerdict);
+    if (!planVerdict.allowed && planVerdict.status !== "PLAN_COMPLETE") {
+      decidingLayer = "plan-enforcement";
+      decidingId = `plan-${options.plan.plan_id}`;
+      const planStatus = planVerdict.status === "CONSTRAINT_VIOLATED" ? "PAUSE" : "BLOCK";
+      let reason = planVerdict.reason ?? "Action blocked by plan.";
+      if (planVerdict.status === "OFF_PLAN" && planVerdict.closestStep) {
+        reason += ` Closest step: "${planVerdict.closestStep}" (similarity: ${(planVerdict.similarityScore ?? 0).toFixed(2)})`;
+      }
+      return buildVerdict(
+        planStatus,
+        reason,
+        `plan-${options.plan.plan_id}`,
+        void 0,
+        world,
+        level,
+        invariantChecks,
+        guardsMatched,
+        rulesMatched,
+        includeTrace ? buildTrace(
+          invariantChecks,
+          safetyChecks,
+          planCheckResult,
+          roleChecks,
+          guardChecks,
+          kernelRuleChecks,
+          levelChecks,
+          decidingLayer,
+          decidingId,
+          startTime
+        ) : void 0
+      );
+    }
+  }
   const roleVerdict = checkRoleRules(event, eventText, world, roleChecks);
   if (roleVerdict) {
     decidingLayer = "role";
@@ -240,6 +523,7 @@ function evaluateGuard(event, world, options = {}) {
       includeTrace ? buildTrace(
         invariantChecks,
         safetyChecks,
+        planCheckResult,
         roleChecks,
         guardChecks,
         kernelRuleChecks,
@@ -268,6 +552,7 @@ function evaluateGuard(event, world, options = {}) {
         includeTrace ? buildTrace(
           invariantChecks,
           safetyChecks,
+          planCheckResult,
           roleChecks,
           guardChecks,
           kernelRuleChecks,
@@ -296,6 +581,7 @@ function evaluateGuard(event, world, options = {}) {
       includeTrace ? buildTrace(
         invariantChecks,
         safetyChecks,
+        planCheckResult,
         roleChecks,
         guardChecks,
         kernelRuleChecks,
@@ -323,6 +609,7 @@ function evaluateGuard(event, world, options = {}) {
       includeTrace ? buildTrace(
         invariantChecks,
         safetyChecks,
+        planCheckResult,
         roleChecks,
         guardChecks,
         kernelRuleChecks,
@@ -347,6 +634,7 @@ function evaluateGuard(event, world, options = {}) {
     includeTrace ? buildTrace(
       invariantChecks,
       safetyChecks,
+      planCheckResult,
       roleChecks,
       guardChecks,
       kernelRuleChecks,
@@ -684,8 +972,8 @@ function matchesKeywords(eventText, ruleText) {
 function eventToAllowlistKey(event) {
   return `${(event.tool ?? "*").toLowerCase()}::${event.intent.toLowerCase().trim()}`;
 }
-function buildTrace(invariantChecks, safetyChecks, roleChecks, guardChecks, kernelRuleChecks, levelChecks, decidingLayer, decidingId, startTime) {
-  return {
+function buildTrace(invariantChecks, safetyChecks, planCheck, roleChecks, guardChecks, kernelRuleChecks, levelChecks, decidingLayer, decidingId, startTime) {
+  const trace = {
     invariantChecks,
     safetyChecks,
     roleChecks,
@@ -703,6 +991,7 @@ function buildTrace(invariantChecks, safetyChecks, roleChecks, guardChecks, kern
         "safety-scope-escape",
         "safety-execution-claim",
         "safety-execution-intent",
+        "plan-enforcement",
         "role-rules",
         "declarative-guards",
         "kernel-rules",
@@ -712,6 +1001,10 @@ function buildTrace(invariantChecks, safetyChecks, roleChecks, guardChecks, kern
     },
     durationMs: performance.now() - startTime
   };
+  if (planCheck) {
+    trace.planCheck = planCheck;
+  }
+  return trace;
 }
 function buildVerdict(status, reason, ruleId, warning, world, level, invariantChecks, guardsMatched, rulesMatched, trace) {
   const evidence = {
@@ -744,6 +1037,1316 @@ var GUARD_EXIT_CODES = {
   ERROR: 3
 };
 
+// src/engine/plan-parser.ts
+function slugify(text) {
+  return text.toLowerCase().replace(/[^a-z0-9\s]/g, "").trim().replace(/\s+/g, "_");
+}
+function extractBracketAnnotation(line, key) {
+  const regex = new RegExp(`\\[${key}:\\s*([^\\]]+)\\]`, "i");
+  const match = line.match(regex);
+  if (!match) return null;
+  return match[1].split(",").map((s) => s.trim()).filter(Boolean);
+}
+function extractParenAnnotation(line, key) {
+  const regex = new RegExp(`\\(${key}:\\s*([^)]+)\\)`, "i");
+  const match = line.match(regex);
+  if (!match) return null;
+  return match[1].split(",").map((s) => s.trim()).filter(Boolean);
+}
+function stripAnnotations(line) {
+  return line.replace(/\[(?:tools|tag|verify|type):\s*[^\]]+\]/gi, "").replace(/\((?:after):\s*[^)]+\)/gi, "").trim();
+}
+function parseFrontmatter(content) {
+  const frontmatter = {};
+  const fmMatch = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n/);
+  if (!fmMatch) {
+    return { frontmatter, body: content };
+  }
+  const fmBody = fmMatch[1];
+  for (const line of fmBody.split("\n")) {
+    const colonIndex = line.indexOf(":");
+    if (colonIndex > 0) {
+      const key = line.slice(0, colonIndex).trim();
+      const value = line.slice(colonIndex + 1).trim();
+      frontmatter[key] = value;
+    }
+  }
+  return { frontmatter, body: content.slice(fmMatch[0].length) };
+}
+function parseSections(body) {
+  const steps = [];
+  const constraints = [];
+  let currentSection = "none";
+  for (const line of body.split("\n")) {
+    const trimmed = line.trim();
+    if (/^#+\s*Steps/i.test(trimmed)) {
+      currentSection = "steps";
+      continue;
+    }
+    if (/^#+\s*Constraints/i.test(trimmed)) {
+      currentSection = "constraints";
+      continue;
+    }
+    if (/^#+\s/.test(trimmed) && currentSection !== "none") {
+      currentSection = "none";
+      continue;
+    }
+    if (trimmed.startsWith("- ")) {
+      const item = trimmed.slice(2).trim();
+      if (currentSection === "steps") {
+        steps.push(item);
+      } else if (currentSection === "constraints") {
+        constraints.push(item);
+      }
+    }
+  }
+  return { steps, constraints };
+}
+function parseStep(raw) {
+  const label = stripAnnotations(raw);
+  const id = slugify(label);
+  const tools = extractBracketAnnotation(raw, "tools");
+  const tags = extractBracketAnnotation(raw, "tag");
+  const verifyArr = extractBracketAnnotation(raw, "verify");
+  const requires = extractParenAnnotation(raw, "after");
+  return {
+    id,
+    label,
+    tools: tools ?? void 0,
+    tags: tags ?? void 0,
+    verify: verifyArr?.[0] ?? void 0,
+    requires: requires ?? void 0,
+    status: "pending"
+  };
+}
+function parseConstraint(raw, index) {
+  const typeAnnotation = extractBracketAnnotation(raw, "type");
+  const description = stripAnnotations(raw);
+  const id = `constraint_${index}`;
+  let type = "custom";
+  let enforcement = "block";
+  let limit;
+  let unit;
+  if (typeAnnotation?.[0] === "approval") {
+    type = "approval";
+    enforcement = "pause";
+  } else if (/budget|\$|spending|cost/i.test(description)) {
+    type = "budget";
+    const amountMatch = description.match(/\$?([\d,]+)/);
+    if (amountMatch) {
+      limit = parseInt(amountMatch[1].replace(/,/g, ""), 10);
+      unit = "USD";
+    }
+  } else if (/time|hour|minute|day|deadline/i.test(description)) {
+    type = "time";
+  } else if (/scope|access|database|production/i.test(description)) {
+    type = "scope";
+  }
+  const trigger = description.toLowerCase();
+  return {
+    id,
+    type,
+    description,
+    enforcement,
+    limit,
+    unit,
+    trigger
+  };
+}
+function parsePlanMarkdown(markdown) {
+  const errors = [];
+  const { frontmatter, body } = parseFrontmatter(markdown.trim());
+  const { steps: stepLines, constraints: constraintLines } = parseSections(body);
+  if (!frontmatter.plan_id) {
+    errors.push("Missing required field: plan_id");
+  }
+  if (stepLines.length === 0) {
+    errors.push("Plan must have at least one step");
+  }
+  if (errors.length > 0) {
+    return { success: false, errors };
+  }
+  const steps = stepLines.map((line) => parseStep(line));
+  const constraints = constraintLines.map((line, i) => parseConstraint(line, i));
+  let expires_at;
+  if (frontmatter.expires) {
+    expires_at = new Date(frontmatter.expires).toISOString();
+  }
+  const completionRaw = frontmatter.completion?.toLowerCase();
+  const completion = completionRaw === "verified" ? "verified" : "trust";
+  const plan = {
+    plan_id: frontmatter.plan_id,
+    objective: frontmatter.objective ?? "",
+    sequential: frontmatter.sequential === "true",
+    completion,
+    steps,
+    constraints,
+    world_id: frontmatter.world ?? void 0,
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    expires_at
+  };
+  return { success: true, plan, errors: [] };
+}
+
+// src/contracts/plan-contract.ts
+var PLAN_EXIT_CODES = {
+  ON_PLAN: 0,
+  OFF_PLAN: 1,
+  CONSTRAINT_VIOLATED: 2,
+  ERROR: 3,
+  PLAN_COMPLETE: 4
+};
+
+// src/loader/world-loader.ts
+async function loadWorldFromDirectory(dirPath) {
+  const { readFile: readFile3 } = await import("fs/promises");
+  const { join: join5 } = await import("path");
+  const { readdirSync: readdirSync3 } = await import("fs");
+  async function readJson(filename) {
+    try {
+      const content = await readFile3(join5(dirPath, filename), "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return void 0;
+    }
+  }
+  const worldJson = await readJson("world.json");
+  if (!worldJson) {
+    throw new Error(`Cannot read world.json in ${dirPath}`);
+  }
+  const invariantsJson = await readJson("invariants.json");
+  const assumptionsJson = await readJson("assumptions.json");
+  const stateSchemaJson = await readJson("state-schema.json");
+  const gatesJson = await readJson("gates.json");
+  const outcomesJson = await readJson("outcomes.json");
+  const guardsJson = await readJson("guards.json");
+  const rolesJson = await readJson("roles.json");
+  const kernelJson = await readJson("kernel.json");
+  const metadataJson = await readJson("metadata.json");
+  const rules = [];
+  try {
+    const rulesDir = join5(dirPath, "rules");
+    const ruleFiles = readdirSync3(rulesDir).filter((f) => f.endsWith(".json")).sort();
+    for (const file of ruleFiles) {
+      const content = await readFile3(join5(rulesDir, file), "utf-8");
+      rules.push(JSON.parse(content));
+    }
+  } catch {
+  }
+  return {
+    world: worldJson,
+    invariants: invariantsJson?.invariants ?? [],
+    assumptions: assumptionsJson ?? { profiles: {}, parameter_definitions: {} },
+    stateSchema: stateSchemaJson ?? { variables: {}, presets: {} },
+    rules,
+    gates: gatesJson ?? {
+      viability_classification: [],
+      structural_override: { description: "", enforcement: "mandatory" },
+      sustainability_threshold: 0,
+      collapse_visual: { background: "", text: "", border: "", label: "" }
+    },
+    outcomes: outcomesJson ?? {
+      computed_outcomes: [],
+      comparison_layout: { primary_card: "", status_badge: "", structural_indicators: [] }
+    },
+    guards: guardsJson,
+    roles: rolesJson,
+    kernel: kernelJson,
+    metadata: metadataJson ?? {
+      format_version: "1.0.0",
+      created_at: "",
+      last_modified: "",
+      authoring_method: "manual-authoring"
+    }
+  };
+}
+async function loadWorld(worldPath) {
+  const { stat } = await import("fs/promises");
+  const info = await stat(worldPath);
+  if (info.isDirectory()) {
+    return loadWorldFromDirectory(worldPath);
+  }
+  if (worldPath.endsWith(".nv-world.zip")) {
+    throw new Error(".nv-world.zip loading not yet implemented \u2014 use a world directory");
+  }
+  throw new Error(`Cannot load world from: ${worldPath} \u2014 expected a directory or .nv-world.zip`);
+}
+
+// src/runtime/session.ts
+async function defaultToolExecutor(name, args) {
+  return `Tool "${name}" executed successfully with args: ${JSON.stringify(args)}`;
+}
+var SessionManager = class {
+  config;
+  state;
+  engineOptions;
+  executor;
+  constructor(config) {
+    this.config = config;
+    this.executor = config.toolExecutor ?? defaultToolExecutor;
+    this.engineOptions = {
+      trace: config.trace ?? false,
+      level: config.level,
+      plan: config.plan
+    };
+    this.state = {
+      active: false,
+      world: config.world,
+      plan: config.plan,
+      progress: config.plan ? getPlanProgress(config.plan) : void 0,
+      actionsEvaluated: 0,
+      actionsAllowed: 0,
+      actionsBlocked: 0,
+      actionsPaused: 0
+    };
+  }
+  /**
+   * Initialize the session — load world from disk if needed.
+   */
+  async start() {
+    if (this.config.worldPath && !this.config.world) {
+      this.state.world = await loadWorld(this.config.worldPath);
+    }
+    if (!this.state.world) {
+      throw new Error("No world provided. Use --world or pass a world definition.");
+    }
+    this.state.active = true;
+    return this.getState();
+  }
+  /**
+   * Evaluate a single event against governance.
+   * Returns the verdict without executing anything.
+   */
+  evaluate(event) {
+    this.engineOptions.plan = this.state.plan;
+    const verdict = evaluateGuard(event, this.state.world, this.engineOptions);
+    this.state.actionsEvaluated++;
+    if (verdict.status === "ALLOW") this.state.actionsAllowed++;
+    if (verdict.status === "BLOCK") this.state.actionsBlocked++;
+    if (verdict.status === "PAUSE") this.state.actionsPaused++;
+    this.config.onVerdict?.(verdict, event);
+    return verdict;
+  }
+  /**
+   * Evaluate and execute a tool call.
+   * Returns the execution result or block reason.
+   */
+  async executeToolCall(toolCall) {
+    let args;
+    try {
+      args = JSON.parse(toolCall.function.arguments);
+    } catch {
+      args = { raw: toolCall.function.arguments };
+    }
+    const event = {
+      intent: toolCall.function.name,
+      tool: toolCall.function.name,
+      args,
+      direction: "input"
+    };
+    const verdict = this.evaluate(event);
+    if (verdict.status === "BLOCK") {
+      return { allowed: false, verdict };
+    }
+    if (verdict.status === "PAUSE") {
+      return { allowed: false, verdict };
+    }
+    const result = await this.executor(toolCall.function.name, args);
+    this.config.onToolResult?.(toolCall.function.name, result);
+    if (this.state.plan) {
+      const planVerdict = evaluatePlan(event, this.state.plan);
+      if (planVerdict.matchedStep) {
+        const advResult = advancePlan(this.state.plan, planVerdict.matchedStep);
+        if (advResult.success && advResult.plan) {
+          this.state.plan = advResult.plan;
+          this.engineOptions.plan = this.state.plan;
+        }
+        this.state.progress = getPlanProgress(this.state.plan);
+        this.config.onPlanProgress?.(this.state.progress);
+        if (this.state.progress.completed === this.state.progress.total) {
+          this.config.onPlanComplete?.();
+        }
+      }
+    }
+    return { allowed: true, verdict, result };
+  }
+  /**
+   * Process a model response — evaluate and execute all tool calls.
+   * Returns results for each tool call.
+   */
+  async processModelResponse(response, model) {
+    if (response.toolCalls.length === 0) {
+      return response;
+    }
+    for (const toolCall of response.toolCalls) {
+      const { allowed, verdict, result } = await this.executeToolCall(toolCall);
+      if (allowed && result) {
+        const nextResponse = await model.sendToolResult(toolCall.id, result);
+        if (nextResponse.toolCalls.length > 0) {
+          return this.processModelResponse(nextResponse, model);
+        }
+        return nextResponse;
+      } else {
+        const reason = verdict.reason ?? "Action blocked by governance.";
+        const nextResponse = await model.sendBlockedResult(toolCall.id, reason);
+        if (nextResponse.toolCalls.length > 0) {
+          return this.processModelResponse(nextResponse, model);
+        }
+        return nextResponse;
+      }
+    }
+    return response;
+  }
+  /** Get current session state. */
+  getState() {
+    return { ...this.state };
+  }
+  /** Stop the session. */
+  stop() {
+    this.state.active = false;
+    return this.getState();
+  }
+};
+async function runPipeMode(config) {
+  const session = new SessionManager(config);
+  await session.start();
+  const state = session.getState();
+  process.stderr.write(`[neuroverse] Pipe mode active
+`);
+  process.stderr.write(`[neuroverse] World: ${state.world.world.name}
+`);
+  if (state.plan) {
+    process.stderr.write(`[neuroverse] Plan: ${state.plan.plan_id} (${state.plan.objective})
+`);
+  }
+  return new Promise((resolve3, reject) => {
+    let buffer = "";
+    process.stdin.setEncoding("utf-8");
+    process.stdin.on("data", (chunk) => {
+      buffer += chunk;
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        try {
+          const event = JSON.parse(trimmed);
+          if (!event.intent) {
+            process.stderr.write(`[neuroverse] Warning: event missing "intent" field
+`);
+            continue;
+          }
+          const verdict = session.evaluate(event);
+          process.stdout.write(JSON.stringify(verdict) + "\n");
+        } catch (err) {
+          process.stderr.write(`[neuroverse] Error parsing line: ${err}
+`);
+        }
+      }
+    });
+    process.stdin.on("end", () => {
+      if (buffer.trim()) {
+        try {
+          const event = JSON.parse(buffer.trim());
+          if (event.intent) {
+            const verdict = session.evaluate(event);
+            process.stdout.write(JSON.stringify(verdict) + "\n");
+          }
+        } catch {
+        }
+      }
+      const finalState = session.stop();
+      process.stderr.write(
+        `[neuroverse] Session complete: ${finalState.actionsEvaluated} evaluated, ${finalState.actionsAllowed} allowed, ${finalState.actionsBlocked} blocked, ${finalState.actionsPaused} paused
+`
+      );
+      resolve3();
+    });
+    process.stdin.on("error", reject);
+  });
+}
+async function runInteractiveMode(config, model) {
+  const session = new SessionManager(config);
+  await session.start();
+  const state = session.getState();
+  process.stdout.write("\n");
+  process.stdout.write(`  World: ${state.world.world.name}
+`);
+  if (state.plan) {
+    process.stdout.write(`  Plan: ${state.plan.plan_id}
+`);
+    process.stdout.write(`  Goal: ${state.plan.objective}
+`);
+    process.stdout.write(`  Steps: ${state.progress?.total ?? 0}
+`);
+  }
+  process.stdout.write(`  Type "exit" to end session.
+`);
+  process.stdout.write("\n");
+  const readline = await import("readline");
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: "> "
+  });
+  const printProgress = () => {
+    const s = session.getState();
+    if (s.progress) {
+      process.stdout.write(
+        `  [plan: ${s.progress.completed}/${s.progress.total} (${s.progress.percentage}%)]
+`
+      );
+    }
+  };
+  rl.prompt();
+  rl.on("line", async (input) => {
+    const trimmed = input.trim();
+    if (!trimmed) {
+      rl.prompt();
+      return;
+    }
+    if (trimmed === "exit" || trimmed === "quit") {
+      const finalState = session.stop();
+      process.stdout.write("\n");
+      process.stdout.write(`  Session complete.
+`);
+      process.stdout.write(`  Actions: ${finalState.actionsEvaluated} evaluated`);
+      process.stdout.write(`, ${finalState.actionsAllowed} allowed`);
+      process.stdout.write(`, ${finalState.actionsBlocked} blocked
+`);
+      if (finalState.progress) {
+        process.stdout.write(
+          `  Plan: ${finalState.progress.completed}/${finalState.progress.total} steps completed
+`
+        );
+      }
+      process.stdout.write("\n");
+      rl.close();
+      return;
+    }
+    if (trimmed === "status") {
+      const s = session.getState();
+      process.stdout.write(`
+  World: ${s.world.world.name}
+`);
+      process.stdout.write(`  Actions: ${s.actionsEvaluated} evaluated
+`);
+      process.stdout.write(`  Allowed: ${s.actionsAllowed} | Blocked: ${s.actionsBlocked} | Paused: ${s.actionsPaused}
+`);
+      if (s.progress && s.plan) {
+        process.stdout.write(`  Plan: ${s.plan.plan_id} \u2014 ${s.progress.completed}/${s.progress.total} (${s.progress.percentage}%)
+`);
+        for (const step of s.plan.steps) {
+          const icon = step.status === "completed" ? "[x]" : "[ ]";
+          process.stdout.write(`    ${icon} ${step.label}
+`);
+        }
+      }
+      process.stdout.write("\n");
+      rl.prompt();
+      return;
+    }
+    try {
+      const response = await model.chat(trimmed);
+      if (response.toolCalls.length > 0) {
+        const finalResponse = await session.processModelResponse(response, model);
+        if (finalResponse.content) {
+          process.stdout.write(`
+${finalResponse.content}
+
+`);
+        }
+        printProgress();
+      } else if (response.content) {
+        process.stdout.write(`
+${response.content}
+
+`);
+      }
+    } catch (err) {
+      process.stderr.write(`
+  Error: ${err}
+
+`);
+    }
+    rl.prompt();
+  });
+  rl.on("close", () => {
+    session.stop();
+  });
+  return new Promise((resolve3) => {
+    rl.on("close", resolve3);
+  });
+}
+
+// src/runtime/model-adapter.ts
+var DEFAULT_SYSTEM_PROMPT = `You are an AI assistant operating under NeuroVerse governance.
+All your tool calls are evaluated against governance rules before execution.
+If an action is blocked, you will be told why. Adjust your approach accordingly.
+Do not attempt to bypass governance rules.`;
+var ModelAdapter = class {
+  config;
+  messages;
+  tools;
+  constructor(config, tools = []) {
+    this.config = config;
+    this.tools = tools;
+    this.messages = [];
+    const systemPrompt = config.systemPrompt ?? DEFAULT_SYSTEM_PROMPT;
+    this.messages.push({ role: "system", content: systemPrompt });
+  }
+  /**
+   * Send a user message and get the model's response.
+   */
+  async chat(userMessage) {
+    this.messages.push({ role: "user", content: userMessage });
+    return this.complete();
+  }
+  /**
+   * Send a tool result back to the model and get the next response.
+   */
+  async sendToolResult(toolCallId, result) {
+    this.messages.push({
+      role: "tool",
+      content: result,
+      tool_call_id: toolCallId
+    });
+    return this.complete();
+  }
+  /**
+   * Send a governance block message as a tool result.
+   */
+  async sendBlockedResult(toolCallId, reason) {
+    return this.sendToolResult(
+      toolCallId,
+      `[GOVERNANCE BLOCKED] ${reason}. Please adjust your approach.`
+    );
+  }
+  /**
+   * Call the model API and parse the response.
+   */
+  async complete() {
+    const url = `${this.config.baseUrl}/chat/completions`;
+    const body = {
+      model: this.config.model,
+      messages: this.messages,
+      max_tokens: this.config.maxTokens ?? 4096
+    };
+    if (this.tools.length > 0) {
+      body.tools = this.tools;
+    }
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${this.config.apiKey}`
+      },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`Model API error ${response.status}: ${text}`);
+    }
+    const data = await response.json();
+    const choice = data.choices?.[0];
+    if (!choice) {
+      throw new Error("Model returned no choices");
+    }
+    const message = choice.message;
+    this.messages.push(message);
+    return {
+      content: message.content ?? null,
+      toolCalls: message.tool_calls ?? [],
+      finishReason: choice.finish_reason ?? "stop"
+    };
+  }
+  /** Get current message count (for context tracking). */
+  get messageCount() {
+    return this.messages.length;
+  }
+};
+var PROVIDERS = {
+  openai: {
+    baseUrl: "https://api.openai.com/v1",
+    defaultModel: "gpt-4o",
+    envVar: "OPENAI_API_KEY"
+  },
+  anthropic: {
+    baseUrl: "https://api.anthropic.com/v1",
+    defaultModel: "claude-sonnet-4-20250514",
+    envVar: "ANTHROPIC_API_KEY"
+  },
+  ollama: {
+    baseUrl: "http://localhost:11434/v1",
+    defaultModel: "llama3",
+    envVar: ""
+  }
+};
+function resolveProvider(provider, overrides) {
+  const preset = PROVIDERS[provider];
+  if (!preset) {
+    throw new Error(
+      `Unknown provider: "${provider}". Available: ${Object.keys(PROVIDERS).join(", ")}`
+    );
+  }
+  const apiKey = overrides?.apiKey ?? (preset.envVar ? process.env[preset.envVar] : "") ?? "";
+  if (!apiKey && preset.envVar) {
+    throw new Error(
+      `Missing API key. Set ${preset.envVar} or pass --api-key.`
+    );
+  }
+  return {
+    baseUrl: overrides?.baseUrl ?? preset.baseUrl,
+    apiKey,
+    model: overrides?.model ?? preset.defaultModel,
+    systemPrompt: overrides?.systemPrompt,
+    maxTokens: overrides?.maxTokens
+  };
+}
+
+// src/loader/world-resolver.ts
+var import_fs = require("fs");
+var import_path = require("path");
+var WORLDS_DIR = ".neuroverse/worlds";
+var ACTIVE_WORLD_FILE = ".neuroverse/active_world";
+function listWorlds(cwd = process.cwd()) {
+  const worldsDir = (0, import_path.join)(cwd, WORLDS_DIR);
+  if (!(0, import_fs.existsSync)(worldsDir)) return [];
+  const activeName = getActiveWorldName(cwd);
+  const entries = (0, import_fs.readdirSync)(worldsDir);
+  return entries.filter((name) => {
+    const worldJson = (0, import_path.join)(worldsDir, name, "world.json");
+    return (0, import_fs.existsSync)(worldJson);
+  }).map((name) => ({
+    name,
+    path: (0, import_path.join)(worldsDir, name),
+    active: name === activeName
+  })).sort((a, b) => a.name.localeCompare(b.name));
+}
+function getActiveWorldName(cwd = process.cwd()) {
+  const filePath = (0, import_path.join)(cwd, ACTIVE_WORLD_FILE);
+  try {
+    return (0, import_fs.readFileSync)(filePath, "utf-8").trim() || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function setActiveWorld(name, cwd = process.cwd()) {
+  const worldsDir = (0, import_path.join)(cwd, WORLDS_DIR);
+  const worldPath = (0, import_path.join)(worldsDir, name, "world.json");
+  if (!(0, import_fs.existsSync)(worldPath)) {
+    const available = listWorlds(cwd);
+    const names = available.map((w) => w.name).join(", ");
+    throw new Error(
+      `World "${name}" not found in ${WORLDS_DIR}/
+` + (names ? `Available: ${names}` : "No worlds found. Run `neuroverse build` first.")
+    );
+  }
+  const dir = (0, import_path.join)(cwd, ".neuroverse");
+  if (!(0, import_fs.existsSync)(dir)) (0, import_fs.mkdirSync)(dir, { recursive: true });
+  (0, import_fs.writeFileSync)((0, import_path.join)(cwd, ACTIVE_WORLD_FILE), name + "\n", "utf-8");
+}
+function resolveWorldPath(explicit, cwd = process.cwd()) {
+  if (explicit) {
+    return resolveNameOrPath(explicit, cwd);
+  }
+  const envWorld = process.env.NEUROVERSE_WORLD;
+  if (envWorld) {
+    return resolveNameOrPath(envWorld, cwd);
+  }
+  const activeName = getActiveWorldName(cwd);
+  if (activeName) {
+    return resolveNameOrPath(activeName, cwd);
+  }
+  const worlds = listWorlds(cwd);
+  if (worlds.length === 1) {
+    return (0, import_path.resolve)(worlds[0].path);
+  }
+  return void 0;
+}
+function describeActiveWorld(explicit, cwd = process.cwd()) {
+  if (explicit) {
+    return { name: explicit, source: "--world flag" };
+  }
+  const envWorld = process.env.NEUROVERSE_WORLD;
+  if (envWorld) {
+    return { name: envWorld, source: "NEUROVERSE_WORLD env var" };
+  }
+  const activeName = getActiveWorldName(cwd);
+  if (activeName) {
+    return { name: activeName, source: ".neuroverse/active_world" };
+  }
+  const worlds = listWorlds(cwd);
+  if (worlds.length === 1) {
+    return { name: worlds[0].name, source: "auto-detected (only world)" };
+  }
+  return void 0;
+}
+function resolveNameOrPath(ref, cwd) {
+  if (ref.includes("/") || ref.includes("\\") || ref.startsWith(".") || (0, import_path.isAbsolute)(ref)) {
+    return (0, import_path.resolve)(cwd, ref);
+  }
+  const namedPath = (0, import_path.join)(cwd, WORLDS_DIR, ref);
+  if ((0, import_fs.existsSync)((0, import_path.join)(namedPath, "world.json"))) {
+    return (0, import_path.resolve)(namedPath);
+  }
+  return (0, import_path.resolve)(cwd, ref);
+}
+
+// src/runtime/mcp-server.ts
+var import_child_process = require("child_process");
+var import_fs2 = require("fs");
+var import_path2 = require("path");
+var GOVERNED_TOOLS = [
+  {
+    name: "governed_shell",
+    description: "Execute a shell command. This command is evaluated against governance rules before execution.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        command: { type: "string", description: "The shell command to execute" }
+      },
+      required: ["command"]
+    }
+  },
+  {
+    name: "governed_read_file",
+    description: "Read a file. This action is evaluated against governance rules before execution.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "File path to read" }
+      },
+      required: ["path"]
+    }
+  },
+  {
+    name: "governed_write_file",
+    description: "Write content to a file. This action is evaluated against governance rules before execution.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "File path to write" },
+        content: { type: "string", description: "Content to write" }
+      },
+      required: ["path", "content"]
+    }
+  },
+  {
+    name: "governed_list_directory",
+    description: "List files in a directory. This action is evaluated against governance rules.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Directory path to list" }
+      },
+      required: ["path"]
+    }
+  },
+  {
+    name: "governed_http_request",
+    description: "Make an HTTP request. This action is evaluated against governance rules before execution.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        url: { type: "string", description: "URL to request" },
+        method: { type: "string", description: "HTTP method (GET, POST, PUT, DELETE)", default: "GET" },
+        body: { type: "string", description: "Request body (for POST/PUT)" },
+        headers: { type: "object", description: "Request headers" }
+      },
+      required: ["url"]
+    }
+  },
+  // Governance introspection tools — always available
+  {
+    name: "governance_check",
+    description: "Check if an action would be allowed by governance rules without executing it.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        intent: { type: "string", description: "What the action intends to do" },
+        tool: { type: "string", description: "Tool name (shell, http, file, etc.)" },
+        scope: { type: "string", description: "Scope (file path, URL, etc.)" }
+      },
+      required: ["intent"]
+    }
+  },
+  {
+    name: "governance_plan_status",
+    description: "Show current plan progress and remaining steps.",
+    inputSchema: {
+      type: "object",
+      properties: {}
+    }
+  },
+  {
+    name: "governance_plan_advance",
+    description: "Mark a plan step as completed.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        step_id: { type: "string", description: "ID of the step to mark as completed" }
+      },
+      required: ["step_id"]
+    }
+  }
+];
+function executeShell(command, workingDir) {
+  try {
+    const result = (0, import_child_process.execSync)(command, {
+      cwd: workingDir,
+      encoding: "utf-8",
+      timeout: 3e4,
+      maxBuffer: 1024 * 1024
+    });
+    return result;
+  } catch (err) {
+    return `Error: ${err.message}
+${err.stderr ?? ""}`;
+  }
+}
+function executeReadFile(path, workingDir) {
+  const fullPath = (0, import_path2.resolve)(workingDir ?? ".", path);
+  return (0, import_fs2.readFileSync)(fullPath, "utf-8");
+}
+function executeWriteFile(path, content, workingDir) {
+  const fullPath = (0, import_path2.resolve)(workingDir ?? ".", path);
+  (0, import_fs2.writeFileSync)(fullPath, content);
+  return `File written: ${fullPath}`;
+}
+function executeListDir(path, workingDir) {
+  const fullPath = (0, import_path2.resolve)(workingDir ?? ".", path);
+  const entries = (0, import_fs2.readdirSync)(fullPath);
+  return entries.map((e) => {
+    try {
+      const stat = (0, import_fs2.statSync)((0, import_path2.join)(fullPath, e));
+      return `${stat.isDirectory() ? "d" : "-"} ${e}`;
+    } catch {
+      return `? ${e}`;
+    }
+  }).join("\n");
+}
+async function executeHttpRequest(url, method, body, headers) {
+  const response = await fetch(url, {
+    method: method || "GET",
+    body: body || void 0,
+    headers: { "Content-Type": "application/json", ...headers }
+  });
+  const text = await response.text();
+  return `HTTP ${response.status}
+${text}`;
+}
+var McpGovernanceServer = class {
+  world;
+  plan;
+  config;
+  engineOptions;
+  initialized = false;
+  // Stats
+  actionsEvaluated = 0;
+  actionsAllowed = 0;
+  actionsBlocked = 0;
+  constructor(config) {
+    this.config = config;
+    this.plan = config.plan;
+    this.engineOptions = {
+      trace: config.trace ?? false,
+      level: config.level,
+      plan: this.plan
+    };
+  }
+  /**
+   * Start the MCP server — reads JSON-RPC from stdin, writes to stdout.
+   */
+  async start() {
+    if (this.config.worldPath) {
+      this.world = await loadWorld(this.config.worldPath);
+    } else if (this.config.world) {
+      this.world = this.config.world;
+    } else {
+      throw new Error("No world provided");
+    }
+    if (this.config.planPath && !this.plan) {
+      this.plan = JSON.parse((0, import_fs2.readFileSync)(this.config.planPath, "utf-8"));
+      this.engineOptions.plan = this.plan;
+    }
+    process.stderr.write(`[neuroverse-mcp] Server starting
+`);
+    process.stderr.write(`[neuroverse-mcp] World: ${this.world.world.name}
+`);
+    if (this.plan) {
+      process.stderr.write(`[neuroverse-mcp] Plan: ${this.plan.plan_id}
+`);
+    }
+    let buffer = "";
+    process.stdin.setEncoding("utf-8");
+    process.stdin.on("data", (chunk) => {
+      buffer += chunk;
+      while (buffer.length > 0) {
+        const headerEnd = buffer.indexOf("\r\n\r\n");
+        if (headerEnd === -1) break;
+        const header = buffer.slice(0, headerEnd);
+        const contentLengthMatch = header.match(/Content-Length:\s*(\d+)/i);
+        if (!contentLengthMatch) {
+          const newlineIdx = buffer.indexOf("\n");
+          if (newlineIdx === -1) break;
+          const line = buffer.slice(0, newlineIdx).trim();
+          buffer = buffer.slice(newlineIdx + 1);
+          if (line) this.handleRawLine(line);
+          continue;
+        }
+        const contentLength = parseInt(contentLengthMatch[1], 10);
+        const bodyStart = headerEnd + 4;
+        const bodyEnd = bodyStart + contentLength;
+        if (buffer.length < bodyEnd) break;
+        const body = buffer.slice(bodyStart, bodyEnd);
+        buffer = buffer.slice(bodyEnd);
+        this.handleRawLine(body);
+      }
+    });
+    process.stdin.on("end", () => {
+      process.stderr.write(
+        `[neuroverse-mcp] Server stopped. Evaluated: ${this.actionsEvaluated}, Allowed: ${this.actionsAllowed}, Blocked: ${this.actionsBlocked}
+`
+      );
+    });
+    await new Promise(() => {
+    });
+  }
+  handleRawLine(line) {
+    try {
+      const msg = JSON.parse(line);
+      if (msg.method) {
+        if (msg.id !== void 0) {
+          this.handleRequest(msg);
+        } else {
+          this.handleNotification(msg);
+        }
+      }
+    } catch (err) {
+      process.stderr.write(`[neuroverse-mcp] Parse error: ${err}
+`);
+    }
+  }
+  send(msg) {
+    const json = JSON.stringify(msg);
+    const header = `Content-Length: ${Buffer.byteLength(json)}\r
+\r
+`;
+    process.stdout.write(header + json);
+  }
+  sendResult(id, result) {
+    this.send({ jsonrpc: "2.0", id, result });
+  }
+  sendError(id, code, message) {
+    this.send({ jsonrpc: "2.0", id, error: { code, message } });
+  }
+  // ─── Request Handlers ───────────────────────────────────────────────────
+  handleRequest(request) {
+    switch (request.method) {
+      case "initialize":
+        this.handleInitialize(request);
+        break;
+      case "tools/list":
+        this.handleToolsList(request);
+        break;
+      case "tools/call":
+        this.handleToolsCall(request);
+        break;
+      case "ping":
+        this.sendResult(request.id, {});
+        break;
+      default:
+        this.sendError(request.id, -32601, `Method not found: ${request.method}`);
+    }
+  }
+  handleNotification(notification) {
+    switch (notification.method) {
+      case "notifications/initialized":
+        this.initialized = true;
+        process.stderr.write(`[neuroverse-mcp] Client initialized
+`);
+        break;
+      case "notifications/cancelled":
+        break;
+      default:
+        process.stderr.write(`[neuroverse-mcp] Unknown notification: ${notification.method}
+`);
+    }
+  }
+  handleInitialize(request) {
+    this.sendResult(request.id, {
+      protocolVersion: "2024-11-05",
+      capabilities: {
+        tools: {}
+      },
+      serverInfo: {
+        name: "neuroverse-governance",
+        version: "0.2.0"
+      }
+    });
+  }
+  handleToolsList(request) {
+    const tools = [];
+    if (this.config.enableShell !== false) {
+      tools.push(GOVERNED_TOOLS.find((t) => t.name === "governed_shell"));
+    }
+    if (this.config.enableFiles !== false) {
+      tools.push(GOVERNED_TOOLS.find((t) => t.name === "governed_read_file"));
+      tools.push(GOVERNED_TOOLS.find((t) => t.name === "governed_write_file"));
+      tools.push(GOVERNED_TOOLS.find((t) => t.name === "governed_list_directory"));
+    }
+    if (this.config.enableHttp !== false) {
+      tools.push(GOVERNED_TOOLS.find((t) => t.name === "governed_http_request"));
+    }
+    tools.push(GOVERNED_TOOLS.find((t) => t.name === "governance_check"));
+    tools.push(GOVERNED_TOOLS.find((t) => t.name === "governance_plan_status"));
+    if (this.plan) {
+      tools.push(GOVERNED_TOOLS.find((t) => t.name === "governance_plan_advance"));
+    }
+    this.sendResult(request.id, { tools });
+  }
+  async handleToolsCall(request) {
+    const params = request.params;
+    const toolName = params.name;
+    const args = params.arguments ?? {};
+    try {
+      const result = await this.executeTool(toolName, args);
+      this.sendResult(request.id, result);
+    } catch (err) {
+      this.sendResult(request.id, {
+        content: [{ type: "text", text: `Error: ${err.message}` }],
+        isError: true
+      });
+    }
+  }
+  // ─── Tool Execution with Governance ─────────────────────────────────────
+  async executeTool(name, args) {
+    if (name === "governance_check") {
+      return this.toolGovernanceCheck(args);
+    }
+    if (name === "governance_plan_status") {
+      return this.toolPlanStatus();
+    }
+    if (name === "governance_plan_advance") {
+      return this.toolPlanAdvance(args);
+    }
+    const event = this.buildEvent(name, args);
+    this.engineOptions.plan = this.plan;
+    const verdict = evaluateGuard(event, this.world, this.engineOptions);
+    this.actionsEvaluated++;
+    if (verdict.status === "BLOCK") {
+      this.actionsBlocked++;
+      let reason = `[GOVERNANCE BLOCKED] ${verdict.reason ?? "Action blocked by governance rules."}`;
+      if (verdict.ruleId) reason += ` (Rule: ${verdict.ruleId})`;
+      if (verdict.trace?.planCheck && !verdict.trace.planCheck.matched) {
+        const pc = verdict.trace.planCheck;
+        if (pc.closestStepLabel) {
+          reason += `
+Closest plan step: "${pc.closestStepLabel}"`;
+        }
+      }
+      process.stderr.write(`[neuroverse-mcp] BLOCKED: ${event.intent}
+`);
+      return { content: [{ type: "text", text: reason }], isError: true };
+    }
+    if (verdict.status === "PAUSE") {
+      this.actionsBlocked++;
+      const reason = `[GOVERNANCE PAUSED] ${verdict.reason ?? "Action requires human approval."}`;
+      process.stderr.write(`[neuroverse-mcp] PAUSED: ${event.intent}
+`);
+      return { content: [{ type: "text", text: reason }], isError: true };
+    }
+    this.actionsAllowed++;
+    process.stderr.write(`[neuroverse-mcp] ALLOWED: ${event.intent}
+`);
+    const result = await this.executeActualTool(name, args);
+    if (this.plan) {
+      const planVerdict = evaluatePlan(event, this.plan);
+      if (planVerdict.matchedStep) {
+        const advResult = advancePlan(this.plan, planVerdict.matchedStep);
+        if (advResult.success && advResult.plan) {
+          this.plan = advResult.plan;
+          this.engineOptions.plan = this.plan;
+        }
+        const progress = getPlanProgress(this.plan);
+        process.stderr.write(
+          `[neuroverse-mcp] Plan: ${progress.completed}/${progress.total} (${progress.percentage}%)
+`
+        );
+        if (progress.completed === progress.total) {
+          process.stderr.write(`[neuroverse-mcp] Plan complete!
+`);
+        }
+      }
+    }
+    return result;
+  }
+  buildEvent(toolName, args) {
+    switch (toolName) {
+      case "governed_shell":
+        return {
+          intent: `execute shell command: ${args.command}`,
+          tool: "shell",
+          scope: String(args.command ?? ""),
+          actionCategory: "shell",
+          args,
+          direction: "input"
+        };
+      case "governed_read_file":
+        return {
+          intent: `read file: ${args.path}`,
+          tool: "fs",
+          scope: String(args.path ?? ""),
+          actionCategory: "read",
+          args,
+          direction: "input"
+        };
+      case "governed_write_file":
+        return {
+          intent: `write file: ${args.path}`,
+          tool: "fs",
+          scope: String(args.path ?? ""),
+          actionCategory: "write",
+          args,
+          direction: "input"
+        };
+      case "governed_list_directory":
+        return {
+          intent: `list directory: ${args.path}`,
+          tool: "fs",
+          scope: String(args.path ?? ""),
+          actionCategory: "read",
+          args,
+          direction: "input"
+        };
+      case "governed_http_request":
+        return {
+          intent: `http ${args.method ?? "GET"} ${args.url}`,
+          tool: "http",
+          scope: String(args.url ?? ""),
+          actionCategory: "network",
+          args,
+          direction: "input"
+        };
+      default:
+        return {
+          intent: `${toolName}: ${JSON.stringify(args)}`,
+          tool: toolName,
+          args,
+          direction: "input"
+        };
+    }
+  }
+  async executeActualTool(name, args) {
+    const workingDir = this.config.workingDir;
+    switch (name) {
+      case "governed_shell": {
+        const output = executeShell(String(args.command), workingDir);
+        return { content: [{ type: "text", text: output }] };
+      }
+      case "governed_read_file": {
+        const content = executeReadFile(String(args.path), workingDir);
+        return { content: [{ type: "text", text: content }] };
+      }
+      case "governed_write_file": {
+        const result = executeWriteFile(String(args.path), String(args.content), workingDir);
+        return { content: [{ type: "text", text: result }] };
+      }
+      case "governed_list_directory": {
+        const listing = executeListDir(String(args.path), workingDir);
+        return { content: [{ type: "text", text: listing }] };
+      }
+      case "governed_http_request": {
+        const result = await executeHttpRequest(
+          String(args.url),
+          String(args.method ?? "GET"),
+          args.body,
+          args.headers
+        );
+        return { content: [{ type: "text", text: result }] };
+      }
+      default:
+        return { content: [{ type: "text", text: `Unknown tool: ${name}` }], isError: true };
+    }
+  }
+  // ─── Governance Introspection Tools ─────────────────────────────────────
+  toolGovernanceCheck(args) {
+    const event = {
+      intent: String(args.intent ?? ""),
+      tool: args.tool,
+      scope: args.scope,
+      direction: "input"
+    };
+    this.engineOptions.plan = this.plan;
+    const verdict = evaluateGuard(event, this.world, this.engineOptions);
+    const lines = [
+      `Verdict: ${verdict.status}`,
+      verdict.reason ? `Reason: ${verdict.reason}` : null,
+      verdict.ruleId ? `Rule: ${verdict.ruleId}` : null,
+      verdict.warning ? `Warning: ${verdict.warning}` : null
+    ].filter(Boolean).join("\n");
+    return { content: [{ type: "text", text: lines }] };
+  }
+  toolPlanStatus() {
+    if (!this.plan) {
+      return { content: [{ type: "text", text: "No active plan." }] };
+    }
+    const progress = getPlanProgress(this.plan);
+    const lines = [
+      `Plan: ${this.plan.plan_id}`,
+      `Objective: ${this.plan.objective}`,
+      `Progress: ${progress.completed}/${progress.total} (${progress.percentage}%)`,
+      "",
+      "Steps:",
+      ...this.plan.steps.map((s) => {
+        const icon = s.status === "completed" ? "[x]" : s.status === "active" ? "[>]" : "[ ]";
+        return `  ${icon} ${s.label} (${s.id})`;
+      })
+    ];
+    if (this.plan.constraints.length > 0) {
+      lines.push("", "Constraints:");
+      for (const c2 of this.plan.constraints) {
+        lines.push(`  - ${c2.description} [${c2.type}]`);
+      }
+    }
+    return { content: [{ type: "text", text: lines.join("\n") }] };
+  }
+  toolPlanAdvance(args) {
+    if (!this.plan) {
+      return { content: [{ type: "text", text: "No active plan." }], isError: true };
+    }
+    const stepId = String(args.step_id ?? "");
+    const step = this.plan.steps.find((s) => s.id === stepId);
+    if (!step) {
+      const ids = this.plan.steps.map((s) => s.id).join(", ");
+      return {
+        content: [{ type: "text", text: `Step "${stepId}" not found. Available: ${ids}` }],
+        isError: true
+      };
+    }
+    if (step.status === "completed") {
+      return { content: [{ type: "text", text: `Step "${stepId}" is already completed.` }] };
+    }
+    const advResult = advancePlan(this.plan, stepId);
+    if (!advResult.success) {
+      return { content: [{ type: "text", text: `Cannot advance: ${advResult.reason}` }] };
+    }
+    this.plan = advResult.plan;
+    this.engineOptions.plan = this.plan;
+    const progress = getPlanProgress(this.plan);
+    let text = `Step completed: ${step.label}
+Progress: ${progress.completed}/${progress.total} (${progress.percentage}%)`;
+    if (progress.completed === progress.total) {
+      text += "\n\nPlan complete!";
+    }
+    if (this.config.planPath) {
+      (0, import_fs2.writeFileSync)(this.config.planPath, JSON.stringify(this.plan, null, 2) + "\n");
+    }
+    return { content: [{ type: "text", text }] };
+  }
+};
+
 // src/engine/audit-logger.ts
 var FileAuditLogger = class {
   logPath;
@@ -1223,81 +2826,6 @@ function emptyReport() {
   };
 }
 
-// src/loader/world-loader.ts
-async function loadWorldFromDirectory(dirPath) {
-  const { readFile: readFile3 } = await import("fs/promises");
-  const { join: join3 } = await import("path");
-  const { readdirSync } = await import("fs");
-  async function readJson(filename) {
-    try {
-      const content = await readFile3(join3(dirPath, filename), "utf-8");
-      return JSON.parse(content);
-    } catch {
-      return void 0;
-    }
-  }
-  const worldJson = await readJson("world.json");
-  if (!worldJson) {
-    throw new Error(`Cannot read world.json in ${dirPath}`);
-  }
-  const invariantsJson = await readJson("invariants.json");
-  const assumptionsJson = await readJson("assumptions.json");
-  const stateSchemaJson = await readJson("state-schema.json");
-  const gatesJson = await readJson("gates.json");
-  const outcomesJson = await readJson("outcomes.json");
-  const guardsJson = await readJson("guards.json");
-  const rolesJson = await readJson("roles.json");
-  const kernelJson = await readJson("kernel.json");
-  const metadataJson = await readJson("metadata.json");
-  const rules = [];
-  try {
-    const rulesDir = join3(dirPath, "rules");
-    const ruleFiles = readdirSync(rulesDir).filter((f) => f.endsWith(".json")).sort();
-    for (const file of ruleFiles) {
-      const content = await readFile3(join3(rulesDir, file), "utf-8");
-      rules.push(JSON.parse(content));
-    }
-  } catch {
-  }
-  return {
-    world: worldJson,
-    invariants: invariantsJson?.invariants ?? [],
-    assumptions: assumptionsJson ?? { profiles: {}, parameter_definitions: {} },
-    stateSchema: stateSchemaJson ?? { variables: {}, presets: {} },
-    rules,
-    gates: gatesJson ?? {
-      viability_classification: [],
-      structural_override: { description: "", enforcement: "mandatory" },
-      sustainability_threshold: 0,
-      collapse_visual: { background: "", text: "", border: "", label: "" }
-    },
-    outcomes: outcomesJson ?? {
-      computed_outcomes: [],
-      comparison_layout: { primary_card: "", status_badge: "", structural_indicators: [] }
-    },
-    guards: guardsJson,
-    roles: rolesJson,
-    kernel: kernelJson,
-    metadata: metadataJson ?? {
-      format_version: "1.0.0",
-      created_at: "",
-      last_modified: "",
-      authoring_method: "manual-authoring"
-    }
-  };
-}
-async function loadWorld(worldPath) {
-  const { stat } = await import("fs/promises");
-  const info = await stat(worldPath);
-  if (info.isDirectory()) {
-    return loadWorldFromDirectory(worldPath);
-  }
-  if (worldPath.endsWith(".nv-world.zip")) {
-    throw new Error(".nv-world.zip loading not yet implemented \u2014 use a world directory");
-  }
-  throw new Error(`Cannot load world from: ${worldPath} \u2014 expected a directory or .nv-world.zip`);
-}
-
 // src/engine/condition-engine.ts
 function getFieldValue(event, field) {
   if (field.startsWith("args.")) {
@@ -1444,15 +2972,39 @@ function evaluateEndsWith(fieldValue, conditionValue) {
 }
 
 // src/engine/validate-engine.ts
-function validateWorld(world) {
+function validateWorld(world, mode = "standard") {
   const startTime = performance.now();
   const findings = [];
   checkCompleteness(world, findings);
   checkReferentialIntegrity(world, findings);
   checkGuardCoverage(world, findings);
+  checkSemanticCoverage(world, findings);
   checkContradictions(world, findings);
+  checkGuardShadows(world, findings);
+  checkFailClosedSurfaces(world, findings);
+  checkReachability(world, findings);
+  checkStateCoverage(world, findings);
   checkOrphans(world, findings);
   checkSchemaViolations(world, findings);
+  const governanceCategories = /* @__PURE__ */ new Set([
+    "guard-coverage",
+    "contradiction",
+    "semantic-tension",
+    "orphan"
+  ]);
+  if (mode === "dev") {
+    for (const f of findings) {
+      if (governanceCategories.has(f.category) && f.severity === "warning") {
+        f.severity = "info";
+      }
+    }
+  } else if (mode === "strict") {
+    for (const f of findings) {
+      if (governanceCategories.has(f.category) && f.severity === "info") {
+        f.severity = "warning";
+      }
+    }
+  }
   const severityOrder = { error: 0, warning: 1, info: 2 };
   findings.sort((a, b) => severityOrder[a.severity] - severityOrder[b.severity]);
   const errors = findings.filter((f) => f.severity === "error").length;
@@ -1460,6 +3012,7 @@ function validateWorld(world) {
   const info = findings.filter((f) => f.severity === "info").length;
   const completenessScore = computeCompletenessScore(world);
   const invariantCoverage = computeInvariantCoverage(world);
+  const governanceHealth = computeGovernanceHealth(world, findings);
   const summary = {
     errors,
     warnings,
@@ -1467,7 +3020,8 @@ function validateWorld(world) {
     completenessScore,
     invariantCoverage,
     canRun: errors === 0,
-    isHealthy: errors === 0 && warnings === 0
+    isHealthy: errors === 0 && warnings === 0,
+    governanceHealth
   };
   return {
     worldId: world.world.world_id,
@@ -1475,6 +3029,7 @@ function validateWorld(world) {
     worldVersion: world.world.version,
     validatedAt: Date.now(),
     durationMs: performance.now() - startTime,
+    validationMode: mode,
     summary,
     findings
   };
@@ -1657,6 +3212,183 @@ function checkGuardCoverage(world, findings) {
     }
   }
 }
+function checkSemanticCoverage(world, findings) {
+  if (!world.invariants || world.invariants.length === 0) return;
+  const hasGuards = (world.guards?.guards?.length ?? 0) > 0;
+  const hasKernel = (world.kernel?.input_boundaries?.forbidden_patterns?.length ?? 0) > 0 || (world.kernel?.output_boundaries?.forbidden_patterns?.length ?? 0) > 0;
+  if (!hasGuards && !hasKernel) return;
+  const guards = world.guards?.guards ?? [];
+  const vocabEntries = world.guards?.intent_vocabulary ?? {};
+  const kernelInput = world.kernel?.input_boundaries?.forbidden_patterns ?? [];
+  const kernelOutput = world.kernel?.output_boundaries?.forbidden_patterns ?? [];
+  const allKernelRules = [...kernelInput, ...kernelOutput];
+  const guardSearchTexts = guards.map((g) => {
+    const parts = [];
+    for (const patternKey of g.intent_patterns) {
+      parts.push(patternKey.toLowerCase());
+      const vocab = vocabEntries[patternKey];
+      if (vocab) {
+        parts.push(vocab.label.toLowerCase());
+        parts.push(vocab.pattern.toLowerCase());
+      }
+    }
+    parts.push(g.description.toLowerCase());
+    return { guard: g, text: parts.join(" ") };
+  });
+  const kernelSearchTexts = allKernelRules.map((k) => ({
+    rule: k,
+    text: `${k.id} ${k.reason} ${k.pattern ?? ""}`.toLowerCase()
+  }));
+  for (const invariant of world.invariants) {
+    if (invariant.enforcement === "prompt") continue;
+    const tokens = extractActionTokens(invariant.id, invariant.label);
+    if (tokens.length === 0) continue;
+    const coveringGuards = guardSearchTexts.filter((gs) => {
+      const enabled = gs.guard.immutable || gs.guard.default_enabled !== false;
+      if (!enabled) return false;
+      return tokens.some((token) => gs.text.includes(token));
+    });
+    const coveringKernel = kernelSearchTexts.filter(
+      (ks) => tokens.some((token) => ks.text.includes(token))
+    );
+    const hasStructuralGuard = guards.some(
+      (g) => g.invariant_ref === invariant.id && g.immutable
+    );
+    if (coveringGuards.length === 0 && coveringKernel.length === 0) {
+      if (hasStructuralGuard) {
+        findings.push(finding(
+          `weak-coverage-${invariant.id}`,
+          `Invariant "${invariant.id}" has a structural guard but no guard's intent patterns match its action class [${tokens.join(", ")}] \u2014 the guard may not intercept violations`,
+          "warning",
+          "guard-coverage",
+          ["invariants.json", "guards.json"],
+          invariant.id,
+          `Ensure the backing guard's intent_patterns include patterns that can detect "${invariant.label}"`
+        ));
+      } else {
+        findings.push(finding(
+          `unenforced-invariant-${invariant.id}`,
+          `Invariant "${invariant.id}" has no guard or kernel rule capable of enforcing it \u2014 no interceptor matches action class [${tokens.join(", ")}]`,
+          "warning",
+          "guard-coverage",
+          ["invariants.json", "guards.json"],
+          invariant.id,
+          `Add a guard with intent_patterns that can intercept "${invariant.label}", or add a kernel forbidden_pattern`
+        ));
+      }
+    }
+  }
+}
+function extractActionTokens(id, label) {
+  const stopWords = /* @__PURE__ */ new Set([
+    "a",
+    "an",
+    "the",
+    "is",
+    "are",
+    "was",
+    "were",
+    "be",
+    "been",
+    "being",
+    "have",
+    "has",
+    "had",
+    "do",
+    "does",
+    "did",
+    "will",
+    "would",
+    "could",
+    "should",
+    "may",
+    "might",
+    "must",
+    "shall",
+    "can",
+    "need",
+    "dare",
+    "to",
+    "of",
+    "in",
+    "for",
+    "on",
+    "with",
+    "at",
+    "by",
+    "from",
+    "as",
+    "into",
+    "through",
+    "during",
+    "before",
+    "after",
+    "above",
+    "below",
+    "between",
+    "out",
+    "off",
+    "over",
+    "under",
+    "again",
+    "further",
+    "then",
+    "once",
+    "that",
+    "than",
+    "too",
+    "very",
+    "just",
+    "only",
+    "not",
+    "no",
+    "all",
+    "any",
+    "both",
+    "each",
+    "every",
+    "few",
+    "more",
+    "most",
+    "other",
+    "some",
+    "such",
+    "and",
+    "but",
+    "or",
+    "nor",
+    "so",
+    "yet",
+    "if",
+    "it",
+    "its",
+    "they",
+    "them",
+    "their",
+    "this",
+    "these",
+    "those",
+    "which",
+    "who",
+    "whom",
+    "what",
+    "where",
+    "when",
+    "how",
+    "why"
+  ]);
+  const idTokens = id.toLowerCase().split(/[_\-]+/);
+  const labelTokens = label.toLowerCase().split(/[\s\-—:,;.!?()[\]{}]+/);
+  const allTokens = [...idTokens, ...labelTokens];
+  const unique = /* @__PURE__ */ new Set();
+  for (const token of allTokens) {
+    const clean = token.replace(/[^a-z0-9]/g, "");
+    if (clean.length >= 3 && !stopWords.has(clean)) {
+      unique.add(clean);
+    }
+  }
+  return [...unique];
+}
 function checkContradictions(world, findings) {
   if (!world.rules || world.rules.length < 2) return;
   checkCircularExclusiveWith(world.rules, findings);
@@ -1862,6 +3594,251 @@ function describeEffect(effect) {
       return `${effect.operation} ${effect.value}`;
   }
 }
+function checkGuardShadows(world, findings) {
+  if (!world.guards?.guards || world.guards.guards.length < 2) return;
+  const guards = world.guards.guards;
+  for (let i = 0; i < guards.length; i++) {
+    const guardA = guards[i];
+    const enabledA = guardA.immutable || guardA.default_enabled !== false;
+    if (!enabledA) continue;
+    if (guardA.enforcement !== "block" && guardA.enforcement !== "pause") continue;
+    for (let j = i + 1; j < guards.length; j++) {
+      const guardB = guards[j];
+      const enabledB = guardB.immutable || guardB.default_enabled !== false;
+      if (!enabledB) continue;
+      const overlap = guardA.intent_patterns.filter(
+        (p) => guardB.intent_patterns.includes(p)
+      );
+      if (overlap.length === 0) continue;
+      if (guardA.appliesTo?.length && guardB.appliesTo?.length) {
+        const toolsA = new Set(guardA.appliesTo.map((t) => t.toLowerCase()));
+        const toolsB = new Set(guardB.appliesTo.map((t) => t.toLowerCase()));
+        const toolOverlap = [...toolsA].some((t) => toolsB.has(t));
+        if (!toolOverlap) continue;
+      }
+      if (guardA.required_roles?.length && guardB.required_roles?.length) {
+        const rolesA = new Set(guardA.required_roles);
+        const rolesB = new Set(guardB.required_roles);
+        const roleOverlap = [...rolesA].some((r) => rolesB.has(r));
+        if (!roleOverlap) continue;
+      }
+      const patternsStr = overlap.join(", ");
+      if (guardB.enforcement === guardA.enforcement) {
+        findings.push(finding(
+          `guard-shadow-${guardA.id}-${guardB.id}`,
+          `Guard "${guardB.label}" (${guardB.id}) is shadowed by "${guardA.label}" (${guardA.id}) \u2014 both ${guardA.enforcement.toUpperCase()} on patterns [${patternsStr}] but "${guardA.label}" appears first and will always win`,
+          "warning",
+          "contradiction",
+          ["guards/"],
+          `${guardA.id}, ${guardB.id}`,
+          `Remove "${guardB.label}", merge its patterns into "${guardA.label}", or reorder guards`
+        ));
+      } else {
+        findings.push(finding(
+          `guard-conflict-${guardA.id}-${guardB.id}`,
+          `Guards "${guardA.label}" (${guardA.enforcement.toUpperCase()}) and "${guardB.label}" (${guardB.enforcement.toUpperCase()}) share patterns [${patternsStr}] \u2014 "${guardA.label}" always wins because it appears first`,
+          "warning",
+          "contradiction",
+          ["guards/"],
+          `${guardA.id}, ${guardB.id}`,
+          `If "${guardB.label}" should take precedence, move it before "${guardA.label}" in guards.json`
+        ));
+      }
+    }
+  }
+}
+function checkFailClosedSurfaces(world, findings) {
+  const declaredSurfaces = world.guards?.tool_surfaces;
+  if (!declaredSurfaces || declaredSurfaces.length === 0) return;
+  const guards = world.guards?.guards ?? [];
+  const guardedSurfaces = /* @__PURE__ */ new Set();
+  let hasCatchAllGuard = false;
+  for (const guard of guards) {
+    const enabled = guard.immutable || guard.default_enabled !== false;
+    if (!enabled) continue;
+    if (!guard.appliesTo || guard.appliesTo.length === 0) {
+      hasCatchAllGuard = true;
+    } else {
+      for (const tool of guard.appliesTo) {
+        guardedSurfaces.add(tool.toLowerCase());
+      }
+    }
+  }
+  if (hasCatchAllGuard) return;
+  for (const surface of declaredSurfaces) {
+    if (!guardedSurfaces.has(surface.toLowerCase())) {
+      findings.push(finding(
+        `fail-open-surface-${surface.toLowerCase()}`,
+        `Action surface "${surface}" has no governing guard \u2014 actions on this surface bypass governance entirely`,
+        "warning",
+        "guard-coverage",
+        ["guards.json"],
+        void 0,
+        `Add a guard with appliesTo including "${surface}", or add a catch-all guard (no appliesTo) to cover all surfaces`
+      ));
+    }
+  }
+}
+function checkReachability(world, findings) {
+  if (!world.stateSchema?.variables) return;
+  const vars = world.stateSchema.variables;
+  for (const rule of world.rules ?? []) {
+    for (const trigger of rule.triggers) {
+      if (trigger.source !== "state") continue;
+      const unreachable = isTriggerUnreachable(trigger, vars);
+      if (unreachable) {
+        findings.push(finding(
+          `unreachable-rule-${rule.id}-${trigger.field}`,
+          `Rule "${rule.id}" has unreachable trigger: ${trigger.field} ${trigger.operator} ${JSON.stringify(trigger.value)} \u2014 ${unreachable}`,
+          "warning",
+          "contradiction",
+          ["rules/", "state-schema.json"],
+          rule.id,
+          `Remove this rule or adjust the trigger condition to match the schema constraints for "${trigger.field}"`
+        ));
+      }
+    }
+    if (rule.collapse_check) {
+      const cc = rule.collapse_check;
+      const unreachable = isTriggerUnreachable(
+        { field: cc.field, operator: cc.operator, value: cc.value },
+        vars
+      );
+      if (unreachable) {
+        findings.push(finding(
+          `unreachable-collapse-${rule.id}`,
+          `Rule "${rule.id}" has unreachable collapse_check: ${cc.field} ${cc.operator} ${cc.value} \u2014 ${unreachable}`,
+          "warning",
+          "contradiction",
+          ["rules/", "state-schema.json"],
+          rule.id
+        ));
+      }
+    }
+  }
+  for (const gate of world.gates?.viability_classification ?? []) {
+    const unreachable = isTriggerUnreachable(
+      { field: gate.field, operator: gate.operator, value: gate.value },
+      vars
+    );
+    if (unreachable) {
+      findings.push(finding(
+        `unreachable-gate-${gate.status}`,
+        `Viability gate "${gate.status}" has unreachable condition: ${gate.field} ${gate.operator} ${gate.value} \u2014 ${unreachable}`,
+        "warning",
+        "contradiction",
+        ["gates.json", "state-schema.json"],
+        `gate-${gate.status}`
+      ));
+    }
+  }
+}
+function isTriggerUnreachable(trigger, vars) {
+  const variable = vars[trigger.field];
+  if (!variable) return null;
+  const { operator, value } = trigger;
+  if (variable.type === "number") {
+    const numVal = typeof value === "number" ? value : Number(value);
+    if (isNaN(numVal)) return null;
+    const min = variable.min;
+    const max = variable.max;
+    if (operator === ">" || operator === ">=") {
+      if (max !== void 0 && numVal >= max && operator === ">") {
+        return `schema declares max=${max}, so ${trigger.field} can never exceed ${max}`;
+      }
+      if (max !== void 0 && numVal > max && operator === ">=") {
+        return `schema declares max=${max}, so ${trigger.field} can never reach ${numVal}`;
+      }
+    }
+    if (operator === "<" || operator === "<=") {
+      if (min !== void 0 && numVal <= min && operator === "<") {
+        return `schema declares min=${min}, so ${trigger.field} can never go below ${min}`;
+      }
+      if (min !== void 0 && numVal < min && operator === "<=") {
+        return `schema declares min=${min}, so ${trigger.field} can never reach ${numVal}`;
+      }
+    }
+    if (operator === "==") {
+      if (min !== void 0 && numVal < min) {
+        return `schema declares min=${min}, so ${trigger.field} can never equal ${numVal}`;
+      }
+      if (max !== void 0 && numVal > max) {
+        return `schema declares max=${max}, so ${trigger.field} can never equal ${numVal}`;
+      }
+    }
+  }
+  if (variable.type === "enum" && variable.options) {
+    if (operator === "==" && typeof value === "string") {
+      if (!variable.options.includes(value)) {
+        return `"${value}" is not in enum options [${variable.options.join(", ")}]`;
+      }
+    }
+    if (operator === "!=" && typeof value === "string") {
+      if (variable.options.length === 1 && variable.options[0] === value) {
+        return `enum has only option "${value}", so != "${value}" can never be true`;
+      }
+    }
+    if (operator === "in" && Array.isArray(value)) {
+      const validValues = value.filter((v) => variable.options.includes(v));
+      if (validValues.length === 0) {
+        return `none of [${value.join(", ")}] are in enum options [${variable.options.join(", ")}]`;
+      }
+    }
+  }
+  if (variable.type === "boolean") {
+    if (operator === "==" && typeof value !== "boolean" && value !== "true" && value !== "false") {
+      return `boolean variable compared to non-boolean value "${value}"`;
+    }
+  }
+  return null;
+}
+function checkStateCoverage(world, findings) {
+  if (!world.stateSchema?.variables) return;
+  const vars = world.stateSchema.variables;
+  for (const [varId, variable] of Object.entries(vars)) {
+    if (variable.type !== "enum" || !variable.options || variable.options.length <= 1) continue;
+    const allOptions = new Set(variable.options);
+    const coveredOptions = /* @__PURE__ */ new Set();
+    for (const rule of world.rules ?? []) {
+      for (const trigger of rule.triggers) {
+        if (trigger.field !== varId || trigger.source !== "state") continue;
+        if (trigger.operator === "==" && typeof trigger.value === "string") {
+          coveredOptions.add(trigger.value);
+        }
+        if (trigger.operator === "in" && Array.isArray(trigger.value)) {
+          for (const v of trigger.value) coveredOptions.add(v);
+        }
+        if (trigger.operator === "!=") {
+          for (const opt of allOptions) {
+            if (opt !== trigger.value) coveredOptions.add(opt);
+          }
+        }
+      }
+    }
+    for (const gate of world.gates?.viability_classification ?? []) {
+      if (gate.field !== varId) continue;
+      if (gate.operator === "==" && typeof gate.value === "string") {
+        coveredOptions.add(gate.value);
+      }
+      if (gate.operator === "in" && Array.isArray(gate.value)) {
+        for (const v of gate.value) coveredOptions.add(v);
+      }
+    }
+    if (coveredOptions.size === 0) continue;
+    const uncovered = [...allOptions].filter((opt) => !coveredOptions.has(opt));
+    if (uncovered.length > 0 && uncovered.length < allOptions.size) {
+      findings.push(finding(
+        `incomplete-state-coverage-${varId}`,
+        `Enum variable "${varId}" has ${uncovered.length} uncovered state${uncovered.length > 1 ? "s" : ""}: [${uncovered.join(", ")}] \u2014 rules/gates handle [${[...coveredOptions].join(", ")}] but not all ${allOptions.size} declared options`,
+        "warning",
+        "guard-coverage",
+        ["state-schema.json", "rules/", "gates.json"],
+        varId,
+        `Add rules or gates that handle ${uncovered.map((u) => `"${u}"`).join(", ")} for variable "${varId}"`
+      ));
+    }
+  }
+}
 function checkOrphans(world, findings) {
   if (!world.stateSchema?.variables || !world.rules) return;
   const referencedVars = /* @__PURE__ */ new Set();
@@ -2023,6 +4000,57 @@ function computeInvariantCoverage(world) {
   }
   return Math.round(covered / world.invariants.length * 100);
 }
+function computeGovernanceHealth(world, findings) {
+  const guards = world.guards?.guards ?? [];
+  if (guards.length === 0 && !world.kernel) return void 0;
+  const declaredSurfaces = world.guards?.tool_surfaces ?? [];
+  const guardedSurfaces = /* @__PURE__ */ new Set();
+  let hasCatchAll = false;
+  for (const guard of guards) {
+    const enabled = guard.immutable || guard.default_enabled !== false;
+    if (!enabled) continue;
+    if (!guard.appliesTo || guard.appliesTo.length === 0) {
+      hasCatchAll = true;
+    } else {
+      for (const t of guard.appliesTo) guardedSurfaces.add(t.toLowerCase());
+    }
+  }
+  const allSurfaces = /* @__PURE__ */ new Set();
+  for (const s of declaredSurfaces) allSurfaces.add(s.toLowerCase());
+  for (const s of guardedSurfaces) allSurfaces.add(s);
+  const surfaces = [...allSurfaces].map((name) => ({
+    name,
+    governed: hasCatchAll || guardedSurfaces.has(name)
+  }));
+  const surfacesCovered = hasCatchAll ? allSurfaces.size : guardedSurfaces.size;
+  const structuralInvariants = (world.invariants ?? []).filter((i) => i.enforcement === "structural");
+  let invariantsEnforced = 0;
+  for (const inv of structuralInvariants) {
+    const hasGuard = guards.some((g) => g.invariant_ref === inv.id && g.immutable);
+    if (hasGuard) invariantsEnforced++;
+  }
+  const shadowedGuards = findings.filter((f) => f.id.startsWith("guard-shadow-")).length;
+  const unenforcedInvariants = findings.filter((f) => f.id.startsWith("unenforced-invariant-")).length;
+  const unreachableRules = findings.filter((f) => f.id.startsWith("unreachable-")).length;
+  const incompleteStateCoverage = findings.filter((f) => f.id.startsWith("incomplete-state-coverage-")).length;
+  const failOpenCount = findings.filter((f) => f.id.startsWith("fail-open-surface-")).length;
+  let riskLevel = "low";
+  const totalIssues = unenforcedInvariants + failOpenCount + incompleteStateCoverage;
+  if (totalIssues > 0 || unreachableRules > 0) riskLevel = "moderate";
+  if (totalIssues > 2 || unenforcedInvariants > 0 && failOpenCount > 0 || incompleteStateCoverage > 2) riskLevel = "high";
+  return {
+    surfacesCovered,
+    surfacesTotal: allSurfaces.size,
+    surfaces,
+    invariantsEnforced,
+    invariantsTotal: structuralInvariants.length,
+    shadowedGuards,
+    unenforcedInvariants,
+    unreachableRules,
+    incompleteStateCoverage,
+    riskLevel
+  };
+}
 function finding(id, message, severity, category, affectedBlocks, source, suggestion) {
   const f = { id, message, severity, category, affectedBlocks };
   if (source) f.source = source;
@@ -2077,7 +4105,7 @@ function splitSections(markdown) {
   }
   return { frontmatter, sections };
 }
-function parseFrontmatter(yaml, issues) {
+function parseFrontmatter2(yaml, issues) {
   const result = {};
   for (const line of yaml.split("\n")) {
     const trimmed = line.trim();
@@ -2426,7 +4454,7 @@ function parseValueLiteral(raw) {
 function parseWorldMarkdown(markdown) {
   const issues = [];
   const { frontmatter: fmRaw, sections } = splitSections(markdown);
-  const frontmatter = parseFrontmatter(fmRaw, issues);
+  const frontmatter = parseFrontmatter2(fmRaw, issues);
   const findSection = (name) => sections.find((s) => s.name.toLowerCase() === name.toLowerCase());
   const thesisSection = findSection("Thesis");
   const thesis = thesisSection ? parseThesis(thesisSection.content, thesisSection.startLine, issues) : "";
@@ -2831,12 +4859,12 @@ function normalizeWorldMarkdown(markdown) {
 
 // src/engine/derive-prompt.ts
 var import_promises = require("fs/promises");
-var import_path = require("path");
+var import_path3 = require("path");
 var import_meta = {};
 var WORLD_FILENAME = "derivation-world.nv-world.md";
 function getModuleDir() {
   try {
-    return (0, import_path.dirname)(new URL(import_meta.url).pathname);
+    return (0, import_path3.dirname)(new URL(import_meta.url).pathname);
   } catch {
     return __dirname;
   }
@@ -2844,8 +4872,8 @@ function getModuleDir() {
 async function loadDerivationWorld() {
   const moduleDir = getModuleDir();
   const candidates = [
-    (0, import_path.join)(moduleDir, "..", "worlds", WORLD_FILENAME),
-    (0, import_path.join)(moduleDir, "worlds", WORLD_FILENAME)
+    (0, import_path3.join)(moduleDir, "..", "worlds", WORLD_FILENAME),
+    (0, import_path3.join)(moduleDir, "worlds", WORLD_FILENAME)
   ];
   for (const candidate of candidates) {
     try {
@@ -3120,15 +5148,15 @@ function createProvider(config) {
 
 // src/providers/config-manager.ts
 var import_promises2 = require("fs/promises");
-var import_path2 = require("path");
+var import_path4 = require("path");
 var import_os = require("os");
 function getConfigDir() {
   const xdg = process.env.XDG_CONFIG_HOME;
-  if (xdg) return (0, import_path2.join)(xdg, "neuroverse");
-  return (0, import_path2.join)((0, import_os.homedir)(), ".neuroverse");
+  if (xdg) return (0, import_path4.join)(xdg, "neuroverse");
+  return (0, import_path4.join)((0, import_os.homedir)(), ".neuroverse");
 }
 function getConfigPath() {
-  return (0, import_path2.join)(getConfigDir(), "config.json");
+  return (0, import_path4.join)(getConfigDir(), "config.json");
 }
 async function loadConfig() {
   try {
@@ -4197,12 +6225,21 @@ var CONFIGURE_AI_EXIT_CODES = {
   DERIVE_EXIT_CODES,
   FileAuditLogger,
   GUARD_EXIT_CODES,
+  McpGovernanceServer,
+  ModelAdapter,
+  PLAN_EXIT_CODES,
+  PROVIDERS,
+  SessionManager,
   VALIDATE_EXIT_CODES,
+  advancePlan,
+  buildPlanCheck,
   createGovernanceEngine,
   deriveWorld,
+  describeActiveWorld,
   emitWorldDefinition,
   evaluateCondition,
   evaluateGuard,
+  evaluatePlan,
   eventToAllowlistKey,
   explainWorld,
   extractWorldMarkdown,
@@ -4210,16 +6247,25 @@ var CONFIGURE_AI_EXIT_CODES = {
   formatVerdictOneLine,
   generateImpactReport,
   generateImpactReportFromFile,
+  getActiveWorldName,
+  getPlanProgress,
   improveWorld,
+  listWorlds,
   loadWorld,
   loadWorldFromDirectory,
   normalizeWorldMarkdown,
+  parsePlanMarkdown,
   parseWorldMarkdown,
   readAuditLog,
   renderExplainText,
   renderImpactReport,
   renderImproveText,
   renderSimulateText,
+  resolveProvider,
+  resolveWorldPath,
+  runInteractiveMode,
+  runPipeMode,
+  setActiveWorld,
   simulateWorld,
   summarizeAuditEvents,
   validateWorld,