@neuroverseos/governance 0.3.1 → 0.3.3

package/dist/cli/plan.cjs

@@ -0,0 +1,2439 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/engine/text-utils.ts
+function normalizeEventText(event) {
+  return [
+    event.intent,
+    event.tool ?? "",
+    event.scope ?? ""
+  ].join(" ").toLowerCase();
+}
+function extractKeywords(text, minLength = 3) {
+  return text.toLowerCase().split(/\s+/).filter((w) => w.length > minLength);
+}
+function matchesAllKeywords(eventText, ruleText) {
+  const keywords = extractKeywords(ruleText);
+  if (keywords.length === 0) return false;
+  return keywords.every((kw) => eventText.includes(kw));
+}
+function matchesKeywordThreshold(eventText, ruleText, threshold = 0.5) {
+  const keywords = extractKeywords(ruleText);
+  if (keywords.length === 0) return false;
+  const matched = keywords.filter((kw) => eventText.includes(kw));
+  return matched.length >= Math.ceil(keywords.length * threshold);
+}
+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;
+}
+var init_text_utils = __esm({
+  "src/engine/text-utils.ts"() {
+    "use strict";
+  }
+});
+
+// src/engine/plan-engine.ts
+function keywordMatch(eventText, step) {
+  const stepText = [
+    step.label,
+    step.description ?? "",
+    ...step.tags ?? []
+  ].join(" ");
+  return matchesKeywordThreshold(eventText, stepText, 0.5);
+}
+function tokenSimilarity2(a, b) {
+  return tokenSimilarity(a, b);
+}
+function findMatchingStep(eventText, event, steps) {
+  const pendingOrActive = steps.filter((s) => s.status === "pending" || s.status === "active");
+  if (pendingOrActive.length === 0) {
+    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 = tokenSimilarity2(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 = extractKeywords(constraint.trigger);
+      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 = normalizeEventText(event);
+  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 = normalizeEventText(event);
+  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 }
+  };
+}
+var init_plan_engine = __esm({
+  "src/engine/plan-engine.ts"() {
+    "use strict";
+    init_text_utils();
+  }
+});
+
+// src/engine/bootstrap-parser.ts
+var bootstrap_parser_exports = {};
+__export(bootstrap_parser_exports, {
+  parseWorldMarkdown: () => parseWorldMarkdown
+});
+function splitSections(markdown) {
+  const lines = markdown.split("\n");
+  let frontmatter = "";
+  let bodyStart = 0;
+  if (lines[0]?.trim() === "---") {
+    const endIdx = lines.indexOf("---", 1);
+    if (endIdx > 0) {
+      frontmatter = lines.slice(1, endIdx).join("\n");
+      bodyStart = endIdx + 1;
+    }
+  }
+  const sections = [];
+  let currentSection = null;
+  const contentLines = [];
+  for (let i = bodyStart; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.startsWith("# ")) {
+      if (currentSection) {
+        currentSection.content = contentLines.join("\n").trim();
+        sections.push(currentSection);
+        contentLines.length = 0;
+      }
+      currentSection = {
+        name: line.replace(/^#\s+/, "").trim(),
+        content: "",
+        startLine: i + 1
+        // 1-based
+      };
+    } else if (currentSection) {
+      contentLines.push(line);
+    }
+  }
+  if (currentSection) {
+    currentSection.content = contentLines.join("\n").trim();
+    sections.push(currentSection);
+  }
+  return { frontmatter, sections };
+}
+function parseFrontmatter2(yaml, issues) {
+  const result = {};
+  for (const line of yaml.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const colonIdx = trimmed.indexOf(":");
+    if (colonIdx === -1) continue;
+    const key = trimmed.slice(0, colonIdx).trim();
+    const value = trimmed.slice(colonIdx + 1).trim();
+    result[key] = value;
+  }
+  if (!result.world_id) {
+    issues.push({ line: 1, section: "frontmatter", message: "Missing world_id in frontmatter", severity: "error" });
+  }
+  if (!result.name) {
+    issues.push({ line: 1, section: "frontmatter", message: "Missing name in frontmatter", severity: "error" });
+  }
+  return {
+    world_id: result.world_id ?? "",
+    name: result.name ?? "",
+    version: result.version,
+    runtime_mode: result.runtime_mode,
+    default_profile: result.default_profile,
+    alternative_profile: result.alternative_profile
+  };
+}
+function parseThesis(content, startLine, issues) {
+  const thesis = content.trim();
+  if (!thesis) {
+    issues.push({ line: startLine, section: "Thesis", message: "Thesis section is empty", severity: "error" });
+  }
+  return thesis;
+}
+function parseInvariants(content, startLine, issues) {
+  const invariants = [];
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (!line.startsWith("- ")) continue;
+    const lineNum = startLine + i + 1;
+    const match = line.match(
+      /^-\s+`([^`]+)`\s*[—–-]\s*(.+?)(?:\s*\(([^)]+)\))?\s*$/
+    );
+    if (match) {
+      const id = match[1];
+      const label = match[2].trim();
+      const parens = match[3] ?? "structural, immutable";
+      const enforcement = parens.includes("prompt") ? "prompt" : parens.includes("operational") ? "operational" : "structural";
+      const mutable = parens.includes("mutable") && !parens.includes("immutable");
+      invariants.push({ id, label, enforcement, mutable, line: lineNum });
+    } else {
+      const fallback = line.match(/^-\s+\*\*([^*]+)\*\*\s*[—–-]\s*(.+)/);
+      if (fallback) {
+        const id = fallback[1].toLowerCase().replace(/\s+/g, "_");
+        const label = fallback[2].trim();
+        invariants.push({ id, label, enforcement: "structural", mutable: false, line: lineNum });
+      } else {
+        issues.push({ line: lineNum, section: "Invariants", message: `Could not parse invariant: "${line}"`, severity: "warning" });
+      }
+    }
+  }
+  if (invariants.length === 0) {
+    issues.push({ line: startLine, section: "Invariants", message: "No invariants found", severity: "error" });
+  }
+  return invariants;
+}
+function parseStateVariables(content, startLine, issues) {
+  const variables = [];
+  const subSections = splitH2Sections(content, startLine);
+  for (const sub of subSections) {
+    const props = parseKeyValueBullets(sub.content);
+    const lineNum = sub.startLine;
+    const type = props.type;
+    if (!type) {
+      issues.push({ line: lineNum, section: "State", message: `Variable "${sub.name}" missing type`, severity: "error" });
+      continue;
+    }
+    let defaultVal = props.default ?? "";
+    if (type === "number") {
+      defaultVal = parseFloat(String(defaultVal)) || 0;
+    } else if (type === "boolean") {
+      defaultVal = String(defaultVal).toLowerCase() === "true";
+    }
+    const variable = {
+      id: sub.name,
+      type,
+      default: defaultVal,
+      label: props.label ?? sub.name,
+      description: props.description ?? "",
+      line: lineNum
+    };
+    if (type === "number") {
+      if (props.min !== void 0) variable.min = parseFloat(props.min);
+      if (props.max !== void 0) variable.max = parseFloat(props.max);
+      if (props.step !== void 0) variable.step = parseFloat(props.step);
+    }
+    if (type === "enum" && props.options) {
+      variable.options = props.options.split(",").map((s) => s.trim());
+    }
+    variables.push(variable);
+  }
+  return variables;
+}
+function parseAssumptions(content, startLine, issues) {
+  const profiles = [];
+  const subSections = splitH2Sections(content, startLine);
+  for (const sub of subSections) {
+    const props = parseKeyValueBullets(sub.content);
+    const name = props.name ?? sub.name;
+    const description = props.description ?? "";
+    const parameters = {};
+    for (const [key, val] of Object.entries(props)) {
+      if (key === "name" || key === "description") continue;
+      if (val === "true") parameters[key] = true;
+      else if (val === "false") parameters[key] = false;
+      else if (!isNaN(Number(val)) && val.trim() !== "") parameters[key] = Number(val);
+      else parameters[key] = val;
+    }
+    profiles.push({
+      id: sub.name,
+      name,
+      description,
+      parameters,
+      line: sub.startLine
+    });
+  }
+  return profiles;
+}
+function parseRules(content, startLine, issues) {
+  const rules = [];
+  const subSections = splitH2Sections(content, startLine);
+  for (let ruleIdx = 0; ruleIdx < subSections.length; ruleIdx++) {
+    const sub = subSections[ruleIdx];
+    const lineNum = sub.startLine;
+    const headingMatch = sub.name.match(/^([^:]+):\s*(.+?)(?:\s*\(([^)]+)\))?\s*$/);
+    const id = headingMatch ? headingMatch[1].trim() : `rule-${String(ruleIdx + 1).padStart(3, "0")}`;
+    const label = headingMatch ? headingMatch[2].trim() : sub.name;
+    const severity = headingMatch?.[3]?.trim() ?? "degradation";
+    const lines = sub.content.split("\n");
+    let description = "";
+    const triggers = [];
+    const effects = [];
+    let collapseCheck;
+    const causalParts = {};
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+      if (line.startsWith("When ")) {
+        const triggerStr = line.slice(5);
+        const parts = triggerStr.split(/\s+AND\s+/i);
+        for (const part of parts) {
+          const trigger = parseTriggerExpression(part.trim());
+          if (trigger) triggers.push(trigger);
+          else issues.push({ line: lineNum + i, section: "Rules", message: `Could not parse trigger: "${part}"`, severity: "warning" });
+        }
+      } else if (line.startsWith("Then ")) {
+        const effectStr = line.slice(5);
+        const parts = effectStr.split(",");
+        for (const part of parts) {
+          const effect = parseEffectExpression(part.trim());
+          if (effect) effects.push(effect);
+          else issues.push({ line: lineNum + i, section: "Rules", message: `Could not parse effect: "${part}"`, severity: "warning" });
+        }
+      } else if (line.startsWith("Collapse:")) {
+        const collapseStr = line.slice(9).trim();
+        const collapse = parseCollapseExpression(collapseStr);
+        if (collapse) collapseCheck = collapse;
+        else issues.push({ line: lineNum + i, section: "Rules", message: `Could not parse collapse: "${collapseStr}"`, severity: "warning" });
+      } else if (line.startsWith("> ")) {
+        const causalMatch = line.match(/^>\s*(trigger|rule|shift|effect):\s*(.+)/i);
+        if (causalMatch) {
+          causalParts[causalMatch[1].toLowerCase()] = causalMatch[2].trim();
+        }
+      } else if (line && !line.startsWith("-") && !line.startsWith("#")) {
+        if (!description) description = line;
+        else description += " " + line;
+      }
+    }
+    if (triggers.length === 0) {
+      issues.push({ line: lineNum, section: "Rules", message: `Rule "${id}" has no triggers (missing "When" line)`, severity: "warning" });
+    }
+    if (effects.length === 0) {
+      issues.push({ line: lineNum, section: "Rules", message: `Rule "${id}" has no effects (missing "Then" line)`, severity: "warning" });
+    }
+    const causal_translation = Object.keys(causalParts).length > 0 ? {
+      trigger_text: causalParts.trigger ?? "",
+      rule_text: causalParts.rule ?? "",
+      shift_text: causalParts.shift ?? "",
+      effect_text: causalParts.effect ?? ""
+    } : void 0;
+    rules.push({
+      id,
+      label,
+      severity,
+      description: description || void 0,
+      order: ruleIdx + 1,
+      triggers,
+      effects,
+      collapse_check: collapseCheck,
+      causal_translation,
+      line: lineNum
+    });
+  }
+  return rules;
+}
+function parseTriggerExpression(expr) {
+  const match = expr.match(
+    /^(\w+)\s*(==|!=|>=|<=|>|<|in)\s*(.+?)\s*\[(state|assumption)\]\s*$/
+  );
+  if (!match) return null;
+  const field = match[1];
+  const operator = match[2];
+  let value = match[3].trim();
+  const source = match[4];
+  value = parseValueLiteral(value);
+  return { field, operator, value, source };
+}
+function parseEffectExpression(expr) {
+  const compound = expr.match(/^(\w+)\s*(\*=|\+=|-=)\s*(.+)$/);
+  if (compound) {
+    const target = compound[1];
+    const op = compound[2];
+    const value = parseValueLiteral(compound[3].trim());
+    const operationMap = {
+      "*=": "multiply",
+      "+=": "add",
+      "-=": "subtract"
+    };
+    return { target, operation: operationMap[op], value };
+  }
+  const assignment = expr.match(/^(\w+)\s*=\s*(.+)$/);
+  if (assignment) {
+    const target = assignment[1];
+    const value = parseValueLiteral(assignment[2].trim());
+    const operation = typeof value === "boolean" ? "set_boolean" : "set";
+    return { target, operation, value };
+  }
+  return null;
+}
+function parseCollapseExpression(expr) {
+  const cleaned = expr.replace(/\s*→.*$/, "").trim();
+  const match = cleaned.match(/^(\w+)\s*(==|!=|>=|<=|>|<)\s*([\d.]+)$/);
+  if (!match) return null;
+  return {
+    field: match[1],
+    operator: match[2],
+    value: parseFloat(match[3])
+  };
+}
+function parseGates(content, startLine, issues) {
+  const gates = [];
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (!line.startsWith("- ")) continue;
+    const lineNum = startLine + i + 1;
+    const match = line.match(/^-\s+(\w+):\s*(\w+)\s*(==|!=|>=|<=|>|<)\s*([\d.]+)/);
+    if (match) {
+      gates.push({
+        status: match[1],
+        field: match[2],
+        operator: match[3],
+        value: parseFloat(match[4]),
+        line: lineNum
+      });
+    } else {
+      issues.push({ line: lineNum, section: "Gates", message: `Could not parse gate: "${line}"`, severity: "warning" });
+    }
+  }
+  if (gates.length === 0) {
+    issues.push({ line: startLine, section: "Gates", message: "No gates found", severity: "error" });
+  }
+  return gates;
+}
+function parseOutcomes(content, startLine, issues) {
+  const outcomes = [];
+  const subSections = splitH2Sections(content, startLine);
+  for (const sub of subSections) {
+    const props = parseKeyValueBullets(sub.content);
+    const outcome = {
+      id: sub.name,
+      type: props.type ?? "number",
+      label: props.label ?? sub.name,
+      line: sub.startLine
+    };
+    if (props.range) {
+      const rangeParts = props.range.split("-").map(Number);
+      if (rangeParts.length === 2 && !isNaN(rangeParts[0]) && !isNaN(rangeParts[1])) {
+        outcome.range = [rangeParts[0], rangeParts[1]];
+      }
+    }
+    if (props.display) outcome.display = props.display;
+    if (props.primary) outcome.primary = props.primary === "true";
+    if (props.assignment) outcome.assignment = props.assignment;
+    outcomes.push(outcome);
+  }
+  return outcomes;
+}
+function splitH2Sections(content, baseStartLine) {
+  const lines = content.split("\n");
+  const sections = [];
+  let current = null;
+  const contentLines = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.startsWith("## ")) {
+      if (current) {
+        current.content = contentLines.join("\n").trim();
+        sections.push(current);
+        contentLines.length = 0;
+      }
+      current = {
+        name: line.replace(/^##\s+/, "").trim(),
+        content: "",
+        startLine: baseStartLine + i + 1
+      };
+    } else if (current) {
+      contentLines.push(line);
+    }
+  }
+  if (current) {
+    current.content = contentLines.join("\n").trim();
+    sections.push(current);
+  }
+  return sections;
+}
+function parseKeyValueBullets(content) {
+  const result = {};
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    const match = trimmed.match(/^-\s+(\w[\w\s]*?):\s*(.+)$/);
+    if (match) {
+      result[match[1].trim().toLowerCase().replace(/\s+/g, "_")] = match[2].trim();
+    }
+  }
+  return result;
+}
+function parseValueLiteral(raw) {
+  if (raw === "true") return true;
+  if (raw === "false") return false;
+  if (raw.startsWith('"') && raw.endsWith('"') || raw.startsWith("'") && raw.endsWith("'")) {
+    return raw.slice(1, -1);
+  }
+  const num = Number(raw);
+  if (!isNaN(num) && raw.trim() !== "") return num;
+  return raw;
+}
+function parseWorldMarkdown(markdown) {
+  const issues = [];
+  const { frontmatter: fmRaw, sections } = splitSections(markdown);
+  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) : "";
+  if (!thesisSection) {
+    issues.push({ line: 0, section: "Thesis", message: "Missing # Thesis section", severity: "error" });
+  }
+  const invariantsSection = findSection("Invariants");
+  const invariants = invariantsSection ? parseInvariants(invariantsSection.content, invariantsSection.startLine, issues) : [];
+  if (!invariantsSection) {
+    issues.push({ line: 0, section: "Invariants", message: "Missing # Invariants section", severity: "error" });
+  }
+  const stateSection = findSection("State");
+  const stateVariables = stateSection ? parseStateVariables(stateSection.content, stateSection.startLine, issues) : [];
+  if (!stateSection) {
+    issues.push({ line: 0, section: "State", message: "Missing # State section", severity: "warning" });
+  }
+  const assumptionsSection = findSection("Assumptions");
+  const assumptions = assumptionsSection ? parseAssumptions(assumptionsSection.content, assumptionsSection.startLine, issues) : [];
+  if (!assumptionsSection) {
+    issues.push({ line: 0, section: "Assumptions", message: "Missing # Assumptions section", severity: "warning" });
+  }
+  const rulesSection = findSection("Rules");
+  const rules = rulesSection ? parseRules(rulesSection.content, rulesSection.startLine, issues) : [];
+  if (!rulesSection) {
+    issues.push({ line: 0, section: "Rules", message: "Missing # Rules section", severity: "warning" });
+  }
+  const gatesSection = findSection("Gates");
+  const gates = gatesSection ? parseGates(gatesSection.content, gatesSection.startLine, issues) : [];
+  if (!gatesSection) {
+    issues.push({ line: 0, section: "Gates", message: "Missing # Gates section", severity: "warning" });
+  }
+  const outcomesSection = findSection("Outcomes");
+  const outcomes = outcomesSection ? parseOutcomes(outcomesSection.content, outcomesSection.startLine, issues) : [];
+  const parsedSections = sections.map((s) => s.name);
+  const knownSections = /* @__PURE__ */ new Set(["thesis", "invariants", "state", "assumptions", "rules", "gates", "outcomes"]);
+  for (const section of sections) {
+    if (!knownSections.has(section.name.toLowerCase())) {
+      issues.push({
+        line: section.startLine,
+        section: section.name,
+        message: `Unrecognized section "${section.name}" \u2014 will be ignored`,
+        severity: "info"
+      });
+    }
+  }
+  const hasErrors = issues.some((i) => i.severity === "error");
+  if (!frontmatter.world_id || !thesis) {
+    if (hasErrors) {
+      return { world: null, issues };
+    }
+  }
+  return {
+    world: {
+      frontmatter,
+      thesis,
+      invariants,
+      stateVariables,
+      assumptions,
+      rules,
+      gates,
+      outcomes
+    },
+    issues
+  };
+}
+var init_bootstrap_parser = __esm({
+  "src/engine/bootstrap-parser.ts"() {
+    "use strict";
+  }
+});
+
+// src/engine/bootstrap-emitter.ts
+var bootstrap_emitter_exports = {};
+__export(bootstrap_emitter_exports, {
+  emitWorldDefinition: () => emitWorldDefinition
+});
+function emitWorldDefinition(parsed) {
+  const issues = [];
+  const fm = parsed.frontmatter;
+  const defaultProfile = fm.default_profile ?? parsed.assumptions[0]?.id ?? "baseline";
+  const altProfile = fm.alternative_profile ?? parsed.assumptions[1]?.id ?? "alternative";
+  const world = {
+    world_id: fm.world_id,
+    name: fm.name,
+    thesis: parsed.thesis,
+    version: fm.version ?? "1.0.0",
+    runtime_mode: fm.runtime_mode ?? "SIMULATION",
+    default_assumption_profile: defaultProfile,
+    default_alternative_profile: altProfile,
+    modules: parsed.rules.map((r) => r.id),
+    players: {
+      thinking_space: true,
+      experience_space: true,
+      action_space: true
+    }
+  };
+  const invariants = parsed.invariants.map((inv) => ({
+    id: inv.id,
+    label: inv.label,
+    enforcement: inv.enforcement === "prompt" ? "prompt" : "structural",
+    mutable: false
+  }));
+  const profiles = {};
+  const parameterDefinitions = {};
+  for (let i = 0; i < parsed.assumptions.length; i++) {
+    const profile = parsed.assumptions[i];
+    const params = {};
+    for (const [key, val] of Object.entries(profile.parameters)) {
+      params[key] = String(val);
+      if (!parameterDefinitions[key]) {
+        parameterDefinitions[key] = {
+          type: typeof val === "boolean" ? "boolean" : typeof val === "number" ? "number" : "enum",
+          label: key.replace(/_/g, " ").replace(/\b\w/g, (c) => c.toUpperCase()),
+          description: `Parameter: ${key}`
+        };
+      }
+    }
+    profiles[profile.id] = {
+      name: profile.name,
+      description: profile.description,
+      is_default_baseline: i === 0 || profile.id === defaultProfile,
+      is_default_alternative: i === 1 || profile.id === altProfile,
+      parameters: params
+    };
+  }
+  const assumptions = { profiles, parameter_definitions: parameterDefinitions };
+  const variables = {};
+  for (const v of parsed.stateVariables) {
+    const stateVar = {
+      type: v.type,
+      default: v.default,
+      mutable: true,
+      label: v.label,
+      description: v.description
+    };
+    if (v.type === "number") {
+      if (v.min !== void 0) stateVar.min = v.min;
+      if (v.max !== void 0) stateVar.max = v.max;
+      if (v.step !== void 0) stateVar.step = v.step;
+    }
+    if (v.type === "enum" && v.options) {
+      stateVar.options = v.options;
+    }
+    variables[v.id] = stateVar;
+  }
+  const stateSchema = { variables, presets: {} };
+  const rules = parsed.rules.map((r) => {
+    const triggers = r.triggers.map((t) => ({
+      field: t.field,
+      operator: t.operator,
+      value: t.value,
+      source: t.source
+    }));
+    const effects = r.effects.map((e) => ({
+      target: e.target,
+      operation: e.operation,
+      value: e.value
+    }));
+    let collapse_check;
+    if (r.collapse_check) {
+      collapse_check = {
+        field: r.collapse_check.field,
+        operator: r.collapse_check.operator,
+        value: r.collapse_check.value,
+        result: "MODEL_COLLAPSES"
+      };
+    }
+    const causal_translation = r.causal_translation ?? {
+      trigger_text: "",
+      rule_text: "",
+      shift_text: "",
+      effect_text: ""
+    };
+    const rule = {
+      id: r.id,
+      severity: r.severity,
+      label: r.label,
+      description: r.description ?? r.label,
+      order: r.order,
+      triggers,
+      effects: effects.length > 0 ? effects : void 0,
+      collapse_check,
+      causal_translation
+    };
+    return rule;
+  });
+  const viabilityClassification = parsed.gates.map((g) => {
+    const defaults = GATE_DEFAULTS[g.status] ?? { color: "#5c5a52", icon: "\u25CF" };
+    return {
+      status: g.status,
+      field: g.field,
+      operator: g.operator,
+      value: g.value,
+      color: defaults.color,
+      icon: defaults.icon
+    };
+  });
+  const gates = {
+    viability_classification: viabilityClassification,
+    structural_override: {
+      description: "Rules with severity=structural and triggered collapse_check force MODEL_COLLAPSES regardless of final margin.",
+      enforcement: "mandatory"
+    },
+    sustainability_threshold: 0.1,
+    collapse_visual: {
+      background: "#1c1917",
+      text: "#fef2f2",
+      border: "#b91c1c",
+      label: "Structural Failure"
+    }
+  };
+  const computedOutcomes = parsed.outcomes.map((o) => {
+    const outcome = {
+      id: o.id,
+      type: o.type,
+      label: o.label,
+      show_in_comparison: true
+    };
+    if (o.range) outcome.range = o.range;
+    if (o.display) outcome.display_as = o.display;
+    if (o.primary) outcome.primary = o.primary;
+    if (o.assignment) outcome.assignment = o.assignment;
+    return outcome;
+  });
+  const outcomes = {
+    computed_outcomes: computedOutcomes,
+    comparison_layout: {
+      primary_card: computedOutcomes.find((o) => o.primary)?.id ?? computedOutcomes[0]?.id ?? "",
+      status_badge: "viability_status",
+      structural_indicators: rules.filter((r) => r.severity === "structural").map((r) => r.id)
+    }
+  };
+  const metadata = {
+    format_version: "1.0.0",
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    last_modified: (/* @__PURE__ */ new Date()).toISOString(),
+    authoring_method: "manual-authoring"
+  };
+  const worldDefinition = {
+    world,
+    invariants,
+    assumptions,
+    stateSchema,
+    rules,
+    gates,
+    outcomes,
+    metadata
+  };
+  return { world: worldDefinition, issues };
+}
+var GATE_DEFAULTS;
+var init_bootstrap_emitter = __esm({
+  "src/engine/bootstrap-emitter.ts"() {
+    "use strict";
+    GATE_DEFAULTS = {
+      THRIVING: { color: "#0f6b3a", icon: "\u2726" },
+      STABLE: { color: "#1856b8", icon: "\u25CF" },
+      COMPRESSED: { color: "#a16207", icon: "\u25B2" },
+      CRITICAL: { color: "#b91c1c", icon: "\u26A0" },
+      MODEL_COLLAPSES: { color: "#7f1d1d", icon: "\u2715" }
+    };
+  }
+});
+
+// src/loader/world-loader.ts
+var world_loader_exports = {};
+__export(world_loader_exports, {
+  DEFAULT_BUNDLED_WORLD: () => DEFAULT_BUNDLED_WORLD,
+  loadBundledWorld: () => loadBundledWorld,
+  loadWorld: () => loadWorld,
+  loadWorldFromDirectory: () => loadWorldFromDirectory
+});
+async function loadWorldFromDirectory(dirPath) {
+  const { readFile } = await import("fs/promises");
+  const { join } = await import("path");
+  const { readdirSync } = await import("fs");
+  async function readJson(filename) {
+    const filePath = join(dirPath, filename);
+    try {
+      const content = await readFile(filePath, "utf-8");
+      return JSON.parse(content);
+    } catch (err) {
+      if (err instanceof Error && "code" in err && err.code === "ENOENT") {
+        return void 0;
+      }
+      process.stderr.write(
+        `[neuroverse] Warning: Failed to read ${filename}: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+      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 = join(dirPath, "rules");
+    const ruleFiles = readdirSync(rulesDir).filter((f) => f.endsWith(".json")).sort();
+    for (const file of ruleFiles) {
+      try {
+        const content = await readFile(join(rulesDir, file), "utf-8");
+        rules.push(JSON.parse(content));
+      } catch (err) {
+        process.stderr.write(
+          `[neuroverse] Warning: Failed to parse rule ${file}: ${err instanceof Error ? err.message : String(err)}
+`
+        );
+      }
+    }
+  } catch (err) {
+    if (!(err instanceof Error && "code" in err && err.code === "ENOENT")) {
+      process.stderr.write(
+        `[neuroverse] Warning: Failed to read rules directory: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+    }
+  }
+  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);
+  }
+  throw new Error(`Cannot load world from: ${worldPath} \u2014 expected a directory`);
+}
+async function loadBundledWorld(name = DEFAULT_BUNDLED_WORLD) {
+  const { readFile } = await import("fs/promises");
+  const { join, dirname } = await import("path");
+  const { existsSync } = await import("fs");
+  const { fileURLToPath } = await import("url");
+  const { parseWorldMarkdown: parseWorldMarkdown2 } = await Promise.resolve().then(() => (init_bootstrap_parser(), bootstrap_parser_exports));
+  const { emitWorldDefinition: emitWorldDefinition2 } = await Promise.resolve().then(() => (init_bootstrap_emitter(), bootstrap_emitter_exports));
+  const filename = `${name}.nv-world.md`;
+  let packageRoot;
+  try {
+    const thisFile = typeof __dirname !== "undefined" ? __dirname : dirname(fileURLToPath(import_meta.url));
+    packageRoot = join(thisFile, "..", "..");
+  } catch {
+    packageRoot = process.cwd();
+  }
+  const candidates = [
+    join(packageRoot, "dist", "worlds", filename),
+    join(packageRoot, "src", "worlds", filename)
+  ];
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) {
+      const markdown = await readFile(candidate, "utf-8");
+      const parsed = parseWorldMarkdown2(markdown);
+      if (!parsed.world) {
+        throw new Error(`Failed to parse bundled world: ${candidate}`);
+      }
+      const { world } = emitWorldDefinition2(parsed.world);
+      return world;
+    }
+  }
+  throw new Error(
+    `Bundled world "${name}" not found. Searched:
+` + candidates.map((c) => `  ${c}`).join("\n")
+  );
+}
+var import_meta, DEFAULT_BUNDLED_WORLD;
+var init_world_loader = __esm({
+  "src/loader/world-loader.ts"() {
+    "use strict";
+    import_meta = {};
+    DEFAULT_BUNDLED_WORLD = "coding-agent";
+  }
+});
+
+// src/engine/guard-engine.ts
+var guard_engine_exports = {};
+__export(guard_engine_exports, {
+  evaluateGuard: () => evaluateGuard,
+  eventToAllowlistKey: () => eventToAllowlistKey
+});
+function levelRequiresConfirmation(level, actionType) {
+  if (level === "strict") return true;
+  if (level === "standard") {
+    return actionType === "delete" || actionType === "credential-access";
+  }
+  return false;
+}
+function isExternalScope(scope) {
+  const internalPatterns = [
+    /^\.?\/?src\//i,
+    /^\.?\/?lib\//i,
+    /^\.?\/?app\//i,
+    /^\.?\/?components\//i,
+    /^\.?\/?pages\//i,
+    /^\.?\/?public\//i,
+    /^\.?\/?assets\//i,
+    /^\.\//
+  ];
+  return !internalPatterns.some((p) => p.test(scope));
+}
+function evaluateGuard(event, world, options = {}) {
+  const startTime = performance.now();
+  const level = options.level ?? "standard";
+  const includeTrace = options.trace ?? false;
+  if (!event.intent || typeof event.intent !== "string") {
+    return {
+      status: "BLOCK",
+      reason: "GuardEvent.intent is required and must be a string",
+      ruleId: "safety-input-validation",
+      evidence: {
+        worldId: world.world?.world_id ?? "",
+        worldName: world.world?.name ?? "",
+        worldVersion: world.world?.version ?? "",
+        evaluatedAt: Date.now(),
+        invariantsSatisfied: 0,
+        invariantsTotal: 0,
+        guardsMatched: [],
+        rulesMatched: [],
+        enforcementLevel: level
+      }
+    };
+  }
+  const inputLength = event.intent.length + (event.tool?.length ?? 0) + (event.scope?.length ?? 0) + (event.payload ? JSON.stringify(event.payload).length : 0);
+  if (inputLength > MAX_INPUT_LENGTH) {
+    return {
+      status: "BLOCK",
+      reason: `Input exceeds maximum allowed length (${MAX_INPUT_LENGTH} characters)`,
+      ruleId: "safety-input-length",
+      evidence: {
+        worldId: world.world?.world_id ?? "",
+        worldName: world.world?.name ?? "",
+        worldVersion: world.world?.version ?? "",
+        evaluatedAt: Date.now(),
+        invariantsSatisfied: 0,
+        invariantsTotal: 0,
+        guardsMatched: [],
+        rulesMatched: [],
+        enforcementLevel: level
+      }
+    };
+  }
+  const eventText = normalizeEventText(event);
+  const invariantChecks = [];
+  const safetyChecks = [];
+  let planCheckResult;
+  const roleChecks = [];
+  const guardChecks = [];
+  const kernelRuleChecks = [];
+  const levelChecks = [];
+  let decidingLayer = "default-allow";
+  let decidingId;
+  const guardsMatched = [];
+  const rulesMatched = [];
+  checkInvariantCoverage(world, invariantChecks);
+  if (event.roleId && options.agentStates) {
+    const agentState = options.agentStates.get(event.roleId);
+    if (agentState && agentState.cooldownRemaining > 0) {
+      decidingLayer = "safety";
+      decidingId = `penalize-cooldown-${event.roleId}`;
+      const verdict = buildVerdict(
+        "PENALIZE",
+        `Agent "${event.roleId}" is frozen for ${agentState.cooldownRemaining} more round(s) due to prior penalty.`,
+        `penalize-cooldown-${event.roleId}`,
+        void 0,
+        world,
+        level,
+        invariantChecks,
+        guardsMatched,
+        rulesMatched,
+        includeTrace ? buildTrace(
+          invariantChecks,
+          safetyChecks,
+          planCheckResult,
+          roleChecks,
+          guardChecks,
+          kernelRuleChecks,
+          levelChecks,
+          decidingLayer,
+          decidingId,
+          startTime
+        ) : void 0
+      );
+      verdict.intentRecord = {
+        originalIntent: event.intent,
+        finalAction: "blocked (agent frozen)",
+        enforcement: "PENALIZE",
+        consequence: { type: "freeze", rounds: agentState.cooldownRemaining, description: "Agent still in cooldown from prior penalty" }
+      };
+      return verdict;
+    }
+  }
+  if (options.sessionAllowlist) {
+    const key = eventToAllowlistKey(event);
+    if (options.sessionAllowlist.has(key)) {
+      decidingLayer = "session-allowlist";
+      decidingId = `allowlist:${key}`;
+      return buildVerdict(
+        "ALLOW",
+        void 0,
+        `allowlist:${key}`,
+        void 0,
+        world,
+        level,
+        invariantChecks,
+        guardsMatched,
+        rulesMatched,
+        includeTrace ? buildTrace(
+          invariantChecks,
+          safetyChecks,
+          planCheckResult,
+          roleChecks,
+          guardChecks,
+          kernelRuleChecks,
+          levelChecks,
+          decidingLayer,
+          decidingId,
+          startTime
+        ) : void 0
+      );
+    }
+  }
+  const safetyVerdict = checkSafety(event, eventText, safetyChecks);
+  if (safetyVerdict) {
+    decidingLayer = "safety";
+    decidingId = safetyVerdict.ruleId;
+    return buildVerdict(
+      safetyVerdict.status,
+      safetyVerdict.reason,
+      safetyVerdict.ruleId,
+      void 0,
+      world,
+      level,
+      invariantChecks,
+      guardsMatched,
+      rulesMatched,
+      includeTrace ? buildTrace(
+        invariantChecks,
+        safetyChecks,
+        planCheckResult,
+        roleChecks,
+        guardChecks,
+        kernelRuleChecks,
+        levelChecks,
+        decidingLayer,
+        decidingId,
+        startTime
+      ) : 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";
+    decidingId = roleVerdict.ruleId;
+    return buildVerdict(
+      roleVerdict.status,
+      roleVerdict.reason,
+      roleVerdict.ruleId,
+      void 0,
+      world,
+      level,
+      invariantChecks,
+      guardsMatched,
+      rulesMatched,
+      includeTrace ? buildTrace(
+        invariantChecks,
+        safetyChecks,
+        planCheckResult,
+        roleChecks,
+        guardChecks,
+        kernelRuleChecks,
+        levelChecks,
+        decidingLayer,
+        decidingId,
+        startTime
+      ) : void 0
+    );
+  }
+  const guardVerdict = checkGuards(event, eventText, world, guardChecks, guardsMatched);
+  if (guardVerdict) {
+    if (guardVerdict.status !== "ALLOW") {
+      decidingLayer = "guard";
+      decidingId = guardVerdict.ruleId;
+      const intentRecord = {
+        originalIntent: event.intent,
+        finalAction: guardVerdict.status === "MODIFY" ? guardVerdict.modifiedTo ?? "modified" : guardVerdict.status === "PENALIZE" ? "blocked + penalized" : guardVerdict.status === "REWARD" ? event.intent : guardVerdict.status === "NEUTRAL" ? event.intent : guardVerdict.status === "BLOCK" ? "blocked" : "paused",
+        ruleApplied: guardVerdict.ruleId,
+        enforcement: guardVerdict.status,
+        modifiedTo: guardVerdict.modifiedTo,
+        consequence: guardVerdict.consequence,
+        reward: guardVerdict.reward
+      };
+      const verdict = buildVerdict(
+        guardVerdict.status,
+        guardVerdict.reason,
+        guardVerdict.ruleId,
+        void 0,
+        world,
+        level,
+        invariantChecks,
+        guardsMatched,
+        rulesMatched,
+        includeTrace ? buildTrace(
+          invariantChecks,
+          safetyChecks,
+          planCheckResult,
+          roleChecks,
+          guardChecks,
+          kernelRuleChecks,
+          levelChecks,
+          decidingLayer,
+          decidingId,
+          startTime
+        ) : void 0
+      );
+      verdict.intentRecord = intentRecord;
+      if (guardVerdict.consequence) verdict.consequence = guardVerdict.consequence;
+      if (guardVerdict.reward) verdict.reward = guardVerdict.reward;
+      return verdict;
+    }
+  }
+  const kernelVerdict = checkKernelRules(eventText, world, kernelRuleChecks, rulesMatched);
+  if (kernelVerdict) {
+    decidingLayer = "kernel-rule";
+    decidingId = kernelVerdict.ruleId;
+    return buildVerdict(
+      kernelVerdict.status,
+      kernelVerdict.reason,
+      kernelVerdict.ruleId,
+      void 0,
+      world,
+      level,
+      invariantChecks,
+      guardsMatched,
+      rulesMatched,
+      includeTrace ? buildTrace(
+        invariantChecks,
+        safetyChecks,
+        planCheckResult,
+        roleChecks,
+        guardChecks,
+        kernelRuleChecks,
+        levelChecks,
+        decidingLayer,
+        decidingId,
+        startTime
+      ) : void 0
+    );
+  }
+  const levelVerdict = checkLevelConstraints(event, level, levelChecks);
+  if (levelVerdict) {
+    decidingLayer = "level-constraint";
+    decidingId = levelVerdict.ruleId;
+    return buildVerdict(
+      levelVerdict.status,
+      levelVerdict.reason,
+      levelVerdict.ruleId,
+      void 0,
+      world,
+      level,
+      invariantChecks,
+      guardsMatched,
+      rulesMatched,
+      includeTrace ? buildTrace(
+        invariantChecks,
+        safetyChecks,
+        planCheckResult,
+        roleChecks,
+        guardChecks,
+        kernelRuleChecks,
+        levelChecks,
+        decidingLayer,
+        decidingId,
+        startTime
+      ) : void 0
+    );
+  }
+  const warning = guardVerdict?.warning;
+  return buildVerdict(
+    "ALLOW",
+    void 0,
+    void 0,
+    warning,
+    world,
+    level,
+    invariantChecks,
+    guardsMatched,
+    rulesMatched,
+    includeTrace ? buildTrace(
+      invariantChecks,
+      safetyChecks,
+      planCheckResult,
+      roleChecks,
+      guardChecks,
+      kernelRuleChecks,
+      levelChecks,
+      decidingLayer,
+      decidingId,
+      startTime
+    ) : void 0
+  );
+}
+function checkInvariantCoverage(world, checks) {
+  const invariants = world.invariants ?? [];
+  const guards = world.guards?.guards ?? [];
+  for (const invariant of invariants) {
+    const coveringGuard = guards.find(
+      (g) => g.invariant_ref === invariant.id && g.immutable
+    );
+    checks.push({
+      invariantId: invariant.id,
+      label: invariant.label,
+      hasGuardCoverage: !!coveringGuard,
+      coveringGuardId: coveringGuard?.id
+    });
+  }
+}
+function checkSafety(event, eventText, checks) {
+  const textToCheck = event.intent + (event.payload ? JSON.stringify(event.payload) : "");
+  for (const { pattern, label } of PROMPT_INJECTION_PATTERNS) {
+    const triggered = pattern.test(textToCheck);
+    checks.push({
+      checkType: "prompt-injection",
+      triggered,
+      matchedPattern: triggered ? label : void 0
+    });
+    if (triggered) {
+      for (const remaining of PROMPT_INJECTION_PATTERNS.filter((p) => p.label !== label)) {
+        checks.push({
+          checkType: "prompt-injection",
+          triggered: remaining.pattern.test(textToCheck),
+          matchedPattern: remaining.pattern.test(textToCheck) ? remaining.label : void 0
+        });
+      }
+      return {
+        status: "PAUSE",
+        reason: NEUTRAL_MESSAGES["prompt-injection"],
+        ruleId: `safety-injection-${label}`
+      };
+    }
+  }
+  const scopeToCheck = event.scope ?? event.intent;
+  for (const { pattern, label } of SCOPE_ESCAPE_PATTERNS) {
+    const triggered = pattern.test(scopeToCheck);
+    checks.push({
+      checkType: "scope-escape",
+      triggered,
+      matchedPattern: triggered ? label : void 0
+    });
+    if (triggered) {
+      for (const remaining of SCOPE_ESCAPE_PATTERNS.filter((p) => p.label !== label)) {
+        checks.push({
+          checkType: "scope-escape",
+          triggered: remaining.pattern.test(scopeToCheck),
+          matchedPattern: remaining.pattern.test(scopeToCheck) ? remaining.label : void 0
+        });
+      }
+      return {
+        status: "PAUSE",
+        reason: NEUTRAL_MESSAGES["scope-escape"],
+        ruleId: `safety-scope-${label}`
+      };
+    }
+  }
+  if (event.direction === "output") {
+    for (const { pattern, label } of EXECUTION_CLAIM_PATTERNS) {
+      const triggered = pattern.test(textToCheck);
+      checks.push({
+        checkType: "execution-claim",
+        triggered,
+        matchedPattern: triggered ? label : void 0
+      });
+      if (triggered) {
+        for (const remaining of EXECUTION_CLAIM_PATTERNS.filter((p) => p.label !== label)) {
+          checks.push({
+            checkType: "execution-claim",
+            triggered: remaining.pattern.test(textToCheck),
+            matchedPattern: remaining.pattern.test(textToCheck) ? remaining.label : void 0
+          });
+        }
+        return {
+          status: "PAUSE",
+          reason: NEUTRAL_MESSAGES["execution-claim"],
+          ruleId: `safety-execution-claim-${label}`
+        };
+      }
+    }
+  }
+  if (event.direction === "input") {
+    const intentTrimmed = event.intent.trim();
+    for (const { pattern, label } of EXECUTION_INTENT_PATTERNS) {
+      const triggered = pattern.test(intentTrimmed);
+      checks.push({
+        checkType: "execution-intent",
+        triggered,
+        matchedPattern: triggered ? label : void 0
+      });
+      if (triggered) {
+        for (const remaining of EXECUTION_INTENT_PATTERNS.filter((p) => p.label !== label)) {
+          checks.push({
+            checkType: "execution-intent",
+            triggered: remaining.pattern.test(intentTrimmed),
+            matchedPattern: remaining.pattern.test(intentTrimmed) ? remaining.label : void 0
+          });
+        }
+        return {
+          status: "PAUSE",
+          reason: NEUTRAL_MESSAGES["execution-intent"],
+          ruleId: `safety-execution-intent-${label}`
+        };
+      }
+    }
+  }
+  return null;
+}
+function checkRoleRules(event, eventText, world, checks) {
+  if (!event.roleId || !world.roles) return null;
+  const role = world.roles.roles.find((r) => r.id === event.roleId);
+  if (!role) return null;
+  if (role.requiresApproval) {
+    checks.push({
+      roleId: role.id,
+      roleName: role.name,
+      rule: "All actions require approval",
+      ruleType: "requiresApproval",
+      matched: true
+    });
+    return {
+      status: "PAUSE",
+      reason: `Role "${role.name}" requires approval for all actions.`,
+      ruleId: `role-${role.id}-requires-approval`
+    };
+  }
+  for (const rule of role.cannotDo) {
+    const matched = matchesKeywords(eventText, rule);
+    checks.push({
+      roleId: role.id,
+      roleName: role.name,
+      rule,
+      ruleType: "cannotDo",
+      matched
+    });
+    if (matched) {
+      return {
+        status: "BLOCK",
+        reason: `Role "${role.name}" cannot: ${rule}`,
+        ruleId: `role-${role.id}-cannotdo`
+      };
+    }
+  }
+  for (const rule of role.canDo) {
+    checks.push({
+      roleId: role.id,
+      roleName: role.name,
+      rule,
+      ruleType: "canDo",
+      matched: matchesKeywords(eventText, rule)
+    });
+  }
+  return null;
+}
+function checkGuards(event, eventText, world, checks, guardsMatched) {
+  if (!world.guards) return null;
+  const guardsConfig = world.guards;
+  let warnResult = null;
+  const compiledPatterns = /* @__PURE__ */ new Map();
+  for (const [key, def] of Object.entries(guardsConfig.intent_vocabulary)) {
+    try {
+      compiledPatterns.set(key, new RegExp(def.pattern, "i"));
+    } catch {
+    }
+  }
+  const eventTool = (event.tool ?? "").toLowerCase();
+  for (const guard of guardsConfig.guards) {
+    if (guard.appliesTo && guard.appliesTo.length > 0) {
+      const normalizedAppliesTo = guard.appliesTo.map((t) => t.toLowerCase());
+      if (!normalizedAppliesTo.includes(eventTool)) {
+        continue;
+      }
+    }
+    const enabled = guard.immutable || guard.default_enabled !== false;
+    const matchedPatterns = [];
+    for (const patternKey of guard.intent_patterns) {
+      const regex = compiledPatterns.get(patternKey);
+      if (regex?.test(eventText)) {
+        matchedPatterns.push(patternKey);
+      }
+    }
+    const matched = matchedPatterns.length > 0 && enabled;
+    let roleGated = false;
+    if (matched && guard.required_roles && guard.required_roles.length > 0 && event.roleId && guard.required_roles.includes(event.roleId)) {
+      roleGated = true;
+    }
+    checks.push({
+      guardId: guard.id,
+      label: guard.label,
+      category: guard.category,
+      enabled,
+      matched: matched && !roleGated,
+      enforcement: guard.enforcement,
+      matchedPatterns,
+      roleGated
+    });
+    if (!matched || roleGated) continue;
+    guardsMatched.push(guard.id);
+    const actionMode = guard.player_modes?.action ?? guard.enforcement;
+    const reason = guard.redirect ? `${guard.description} \u2014 ${guard.redirect}` : guard.description;
+    if (actionMode === "block") {
+      return { status: "BLOCK", reason, ruleId: `guard-${guard.id}` };
+    }
+    if (actionMode === "pause") {
+      return { status: "PAUSE", reason, ruleId: `guard-${guard.id}` };
+    }
+    if (actionMode === "penalize") {
+      const consequence = guard.consequence ? { ...guard.consequence } : { type: "freeze", rounds: 1, description: `Penalized for violating: ${guard.label}` };
+      return { status: "PENALIZE", reason, ruleId: `guard-${guard.id}`, consequence };
+    }
+    if (actionMode === "reward") {
+      const reward = guard.reward ? { ...guard.reward } : { type: "boost_influence", magnitude: 0.1, description: `Rewarded for: ${guard.label}` };
+      return { status: "REWARD", reason, ruleId: `guard-${guard.id}`, reward };
+    }
+    if (actionMode === "modify") {
+      const modifiedTo = guard.modify_to ?? guard.redirect ?? "hold";
+      return { status: "MODIFY", reason: `${reason} \u2192 Modified to: ${modifiedTo}`, ruleId: `guard-${guard.id}`, modifiedTo };
+    }
+    if (actionMode === "neutral") {
+      return { status: "NEUTRAL", reason, ruleId: `guard-${guard.id}` };
+    }
+    if (actionMode === "warn" && !warnResult) {
+      warnResult = { status: "ALLOW", warning: reason, ruleId: `guard-${guard.id}` };
+    }
+  }
+  return warnResult;
+}
+function checkKernelRules(eventText, world, checks, rulesMatched) {
+  if (!world.kernel) return null;
+  const forbidden = world.kernel.input_boundaries?.forbidden_patterns ?? [];
+  const output = world.kernel.output_boundaries?.forbidden_patterns ?? [];
+  for (const rule of forbidden) {
+    let matched = false;
+    let matchMethod = "none";
+    if (rule.pattern) {
+      try {
+        matched = new RegExp(rule.pattern, "i").test(eventText);
+        matchMethod = "pattern";
+      } catch {
+      }
+    }
+    if (!matched && rule.reason) {
+      matched = matchesKeywords(eventText, rule.reason);
+      if (matched) matchMethod = "keyword";
+    }
+    checks.push({
+      ruleId: rule.id,
+      text: rule.reason,
+      category: "forbidden",
+      matched,
+      matchMethod
+    });
+    if (matched) {
+      rulesMatched.push(rule.id);
+      if (rule.action === "BLOCK") {
+        return {
+          status: "BLOCK",
+          reason: rule.reason,
+          ruleId: `kernel-${rule.id}`
+        };
+      }
+    }
+  }
+  return null;
+}
+function checkLevelConstraints(event, level, checks) {
+  if (level === "basic") return null;
+  const intent = event.intent.toLowerCase();
+  const tool = (event.tool ?? "").toLowerCase();
+  const isDelete = intent.includes("delete") || intent.includes("remove") || intent.includes("rm ") || tool === "delete";
+  const deleteTriggered = isDelete && levelRequiresConfirmation(level, "delete");
+  checks.push({
+    checkType: "delete",
+    level,
+    triggered: deleteTriggered,
+    reason: deleteTriggered ? NEUTRAL_MESSAGES["delete"] : void 0
+  });
+  if (deleteTriggered) {
+    return { status: "PAUSE", reason: NEUTRAL_MESSAGES["delete"], ruleId: "level-delete-check" };
+  }
+  const isExternal = event.scope ? isExternalScope(event.scope) : false;
+  const externalTriggered = isExternal && levelRequiresConfirmation(level, "write-external");
+  checks.push({
+    checkType: "write-external",
+    level,
+    triggered: externalTriggered,
+    reason: externalTriggered ? NEUTRAL_MESSAGES["write-external"] : void 0
+  });
+  if (externalTriggered) {
+    return { status: "PAUSE", reason: NEUTRAL_MESSAGES["write-external"], ruleId: "level-external-write-check" };
+  }
+  const isNetwork = tool === "http" || tool === "fetch" || tool === "request" || intent.includes("post ") || intent.includes("sending");
+  const networkTriggered = isNetwork && levelRequiresConfirmation(level, "network-mutate");
+  checks.push({
+    checkType: "network-mutate",
+    level,
+    triggered: networkTriggered,
+    reason: networkTriggered ? NEUTRAL_MESSAGES["network-mutate"] : void 0
+  });
+  if (networkTriggered) {
+    return { status: "PAUSE", reason: NEUTRAL_MESSAGES["network-mutate"], ruleId: "level-network-mutate-check" };
+  }
+  const isCredential = intent.includes("credential") || intent.includes("password") || intent.includes("secret") || intent.includes("api key") || intent.includes("token");
+  const credentialTriggered = isCredential && levelRequiresConfirmation(level, "credential-access");
+  checks.push({
+    checkType: "credential-access",
+    level,
+    triggered: credentialTriggered,
+    reason: credentialTriggered ? NEUTRAL_MESSAGES["credential-access"] : void 0
+  });
+  if (credentialTriggered) {
+    return { status: "PAUSE", reason: NEUTRAL_MESSAGES["credential-access"], ruleId: "level-credential-check" };
+  }
+  const irreversibleTriggered = !!event.irreversible && level !== "basic";
+  checks.push({
+    checkType: "irreversible",
+    level,
+    triggered: irreversibleTriggered,
+    reason: irreversibleTriggered ? "This action is marked as irreversible." : void 0
+  });
+  if (irreversibleTriggered) {
+    return {
+      status: "PAUSE",
+      reason: "This action is marked as irreversible.",
+      ruleId: "level-irreversible-check"
+    };
+  }
+  return null;
+}
+function matchesKeywords(eventText, ruleText) {
+  return matchesAllKeywords(eventText, ruleText);
+}
+function eventToAllowlistKey(event) {
+  return `${(event.tool ?? "*").toLowerCase()}::${event.intent.toLowerCase().trim()}`;
+}
+function buildTrace(invariantChecks, safetyChecks, planCheck, roleChecks, guardChecks, kernelRuleChecks, levelChecks, decidingLayer, decidingId, startTime) {
+  const trace = {
+    invariantChecks,
+    safetyChecks,
+    roleChecks,
+    guardChecks,
+    kernelRuleChecks,
+    levelChecks,
+    precedenceResolution: {
+      decidingLayer,
+      decidingId,
+      strategy: "first-match-wins",
+      chainOrder: [
+        "invariant-coverage",
+        "session-allowlist",
+        "safety-injection",
+        "safety-scope-escape",
+        "safety-execution-claim",
+        "safety-execution-intent",
+        "plan-enforcement",
+        "role-rules",
+        "declarative-guards",
+        "kernel-rules",
+        "level-constraints",
+        "default-allow"
+      ]
+    },
+    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 = {
+    worldId: world.world.world_id,
+    worldName: world.world.name,
+    worldVersion: world.world.version,
+    evaluatedAt: Date.now(),
+    invariantsSatisfied: invariantChecks.filter((c) => c.hasGuardCoverage).length,
+    invariantsTotal: invariantChecks.length,
+    guardsMatched,
+    rulesMatched,
+    enforcementLevel: level
+  };
+  const verdict = {
+    status,
+    evidence
+  };
+  if (reason) verdict.reason = reason;
+  if (ruleId) verdict.ruleId = ruleId;
+  if (warning) verdict.warning = warning;
+  if (trace) verdict.trace = trace;
+  return verdict;
+}
+var PROMPT_INJECTION_PATTERNS, EXECUTION_CLAIM_PATTERNS, EXECUTION_INTENT_PATTERNS, SCOPE_ESCAPE_PATTERNS, NEUTRAL_MESSAGES, MAX_INPUT_LENGTH;
+var init_guard_engine = __esm({
+  "src/engine/guard-engine.ts"() {
+    "use strict";
+    init_plan_engine();
+    init_text_utils();
+    PROMPT_INJECTION_PATTERNS = [
+      // Instruction override
+      { pattern: /ignore\s+(previous|all|prior|above)\s+(instructions?|rules?)/i, label: "ignore-instructions" },
+      { pattern: /disregard\s+(your|the)\s+(rules|constraints)/i, label: "disregard-rules" },
+      { pattern: /new\s+instructions?:/i, label: "new-instructions" },
+      // Identity manipulation
+      { pattern: /you\s+are\s+now/i, label: "identity-override" },
+      { pattern: /new\s+persona/i, label: "new-persona" },
+      { pattern: /act\s+as\s+if/i, label: "act-as-if" },
+      { pattern: /pretend\s+(you|to\s+be|you\s+are\s+unrestricted)/i, label: "pretend-to-be" },
+      // Context reset
+      { pattern: /forget\s+(everything|all|your)/i, label: "forget-context" },
+      { pattern: /system\s*:\s*override/i, label: "system-override" },
+      // Constraint bypass
+      { pattern: /override\s+(your|the)\s+(programming|constraints)/i, label: "override-constraints" },
+      { pattern: /bypass\s+(your|the)\s+(filters|constraints|rules)/i, label: "bypass-filters" },
+      // Prompt extraction
+      { pattern: /system\s+prompt/i, label: "system-prompt-probe" },
+      { pattern: /reveal\s+your\s+(instructions?|prompt|rules)/i, label: "reveal-instructions" },
+      // Known jailbreak terms
+      { pattern: /jailbreak/i, label: "jailbreak" },
+      { pattern: /DAN\s+mode/i, label: "dan-mode" },
+      { pattern: /developer\s+mode/i, label: "developer-mode" }
+    ];
+    EXECUTION_CLAIM_PATTERNS = [
+      { pattern: /I have (executed|completed|performed|done|made|created|sent|deleted|modified|updated)/i, label: "claim-i-have" },
+      { pattern: /Successfully (created|deleted|modified|updated|sent|executed|performed)/i, label: "claim-successfully" },
+      { pattern: /The file has been/i, label: "claim-file-modified" },
+      { pattern: /I've made the changes/i, label: "claim-made-changes" },
+      { pattern: /I('ve| have) (sent|posted|submitted|uploaded|downloaded)/i, label: "claim-sent" },
+      { pattern: /Your (email|message|file|request) has been (sent|submitted)/i, label: "claim-your-sent" },
+      { pattern: /Transaction complete/i, label: "claim-transaction" },
+      { pattern: /Order placed/i, label: "claim-order" },
+      { pattern: /Payment processed/i, label: "claim-payment" }
+    ];
+    EXECUTION_INTENT_PATTERNS = [
+      { pattern: /^(execute|run|perform|do this)/i, label: "intent-execute" },
+      { pattern: /^(create|write|delete|modify) (a |the )?(file|folder|document)/i, label: "intent-file-ops" },
+      { pattern: /^(send|post|submit) (a |an |the )?(email|message|tweet|post)/i, label: "intent-send" },
+      { pattern: /^(search|look up|browse) (the )?web/i, label: "intent-web-search" },
+      { pattern: /^(make|call|invoke) (a |an )?(api|http|rest) (call|request)/i, label: "intent-api-call" },
+      { pattern: /^(buy|purchase|order|pay|transfer|send money)/i, label: "intent-financial" },
+      { pattern: /^(book|schedule|reserve)/i, label: "intent-booking" },
+      { pattern: /^(download|upload|save to|export to)/i, label: "intent-transfer" }
+    ];
+    SCOPE_ESCAPE_PATTERNS = [
+      { pattern: /\.\.\//, label: "parent-traversal" },
+      { pattern: /^\/(?!home|project|workspace)/i, label: "absolute-path-outside-safe" },
+      { pattern: /~\//, label: "home-directory" },
+      { pattern: /\/etc\//i, label: "system-config" },
+      { pattern: /\/usr\//i, label: "system-binaries" },
+      { pattern: /\/var\//i, label: "system-variable-data" }
+    ];
+    NEUTRAL_MESSAGES = {
+      "prompt-injection": "This input contains patterns that could alter agent behavior.",
+      "scope-escape": "This action would affect resources outside the declared scope.",
+      "execution-claim": "This response claims to have performed an action.",
+      "execution-intent": "This input requests execution in a thinking-only environment.",
+      "delete": "This action would remove files. Confirmation needed.",
+      "write-external": "This action would write outside the project folder.",
+      "network-mutate": "This action would send data to an external service.",
+      "credential-access": "This action would access stored credentials."
+    };
+    MAX_INPUT_LENGTH = 1e5;
+  }
+});
+
+// src/cli/plan.ts
+var plan_exports = {};
+__export(plan_exports, {
+  main: () => main
+});
+module.exports = __toCommonJS(plan_exports);
+var import_fs = require("fs");
+
+// 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/cli/plan.ts
+init_plan_engine();
+
+// src/contracts/plan-contract.ts
+var PLAN_EXIT_CODES = {
+  ON_PLAN: 0,
+  OFF_PLAN: 1,
+  CONSTRAINT_VIOLATED: 2,
+  ERROR: 3,
+  PLAN_COMPLETE: 4
+};
+
+// src/cli/cli-utils.ts
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString("utf-8");
+}
+
+// src/cli/plan.ts
+function parseArg(args, flag) {
+  const idx = args.indexOf(flag);
+  return idx >= 0 && idx + 1 < args.length ? args[idx + 1] : void 0;
+}
+async function compileCommand(args) {
+  const inputPath = args.find((a) => !a.startsWith("--"));
+  if (!inputPath) {
+    process.stderr.write("Usage: neuroverse plan compile <plan.md> [--output plan.json]\n");
+    process.exit(PLAN_EXIT_CODES.ERROR);
+    return;
+  }
+  const outputPath = parseArg(args, "--output") ?? inputPath.replace(/\.md$/, ".json");
+  let markdown;
+  try {
+    markdown = (0, import_fs.readFileSync)(inputPath, "utf-8");
+  } catch (err) {
+    process.stderr.write(`Error reading ${inputPath}: ${err}
+`);
+    process.exit(PLAN_EXIT_CODES.ERROR);
+    return;
+  }
+  const result = parsePlanMarkdown(markdown);
+  if (!result.success || !result.plan) {
+    process.stderr.write(`Parse errors:
+`);
+    for (const error of result.errors) {
+      process.stderr.write(`  - ${error}
+`);
+    }
+    process.exit(PLAN_EXIT_CODES.ERROR);
+    return;
+  }
+  (0, import_fs.writeFileSync)(outputPath, JSON.stringify(result.plan, null, 2) + "\n");
+  const plan = result.plan;
+  process.stdout.write(`Plan compiled: ${plan.plan_id}
+`);
+  process.stdout.write(`  Objective: ${plan.objective}
+`);
+  process.stdout.write(`  Steps: ${plan.steps.length}
+`);
+  process.stdout.write(`  Constraints: ${plan.constraints.length}
+`);
+  process.stdout.write(`  Sequential: ${plan.sequential}
+`);
+  process.stdout.write(`  Completion: ${plan.completion}
+`);
+  if (plan.world_id) process.stdout.write(`  World: ${plan.world_id}
+`);
+  if (plan.expires_at) process.stdout.write(`  Expires: ${plan.expires_at}
+`);
+  process.stdout.write(`  Output: ${outputPath}
+`);
+}
+async function checkCommand(args) {
+  const planPath = parseArg(args, "--plan");
+  if (!planPath) {
+    process.stderr.write(`Usage: echo '{"intent":"..."}' | neuroverse plan check --plan plan.json
+`);
+    process.exit(PLAN_EXIT_CODES.ERROR);
+    return;
+  }
+  let plan;
+  try {
+    plan = JSON.parse((0, import_fs.readFileSync)(planPath, "utf-8"));
+  } catch (err) {
+    process.stderr.write(`Error reading plan: ${err}
+`);
+    process.exit(PLAN_EXIT_CODES.ERROR);
+    return;
+  }
+  const stdinData = await readStdin();
+  let event;
+  try {
+    event = JSON.parse(stdinData);
+  } catch {
+    process.stderr.write('Error: stdin must be valid JSON with an "intent" field.\n');
+    process.exit(PLAN_EXIT_CODES.ERROR);
+    return;
+  }
+  if (!event.intent) {
+    process.stderr.write('Error: event must have an "intent" field.\n');
+    process.exit(PLAN_EXIT_CODES.ERROR);
+    return;
+  }
+  const worldPath = parseArg(args, "--world");
+  if (worldPath) {
+    const { loadWorld: loadWorld2 } = await Promise.resolve().then(() => (init_world_loader(), world_loader_exports));
+    const { evaluateGuard: evaluateGuard2 } = await Promise.resolve().then(() => (init_guard_engine(), guard_engine_exports));
+    const world = await loadWorld2(worldPath);
+    const verdict2 = evaluateGuard2(event, world, { plan });
+    process.stdout.write(JSON.stringify(verdict2, null, 2) + "\n");
+    const exitCode2 = verdict2.status === "ALLOW" ? 0 : verdict2.status === "BLOCK" ? 1 : 2;
+    process.exit(exitCode2);
+    return;
+  }
+  const verdict = evaluatePlan(event, plan);
+  process.stdout.write(JSON.stringify(verdict, null, 2) + "\n");
+  const exitCode = PLAN_EXIT_CODES[verdict.status] ?? PLAN_EXIT_CODES.ERROR;
+  process.exit(exitCode);
+}
+async function statusCommand(args) {
+  const planPath = parseArg(args, "--plan");
+  if (!planPath) {
+    process.stderr.write("Usage: neuroverse plan status --plan plan.json\n");
+    process.exit(PLAN_EXIT_CODES.ERROR);
+    return;
+  }
+  let plan;
+  try {
+    plan = JSON.parse((0, import_fs.readFileSync)(planPath, "utf-8"));
+  } catch (err) {
+    process.stderr.write(`Error reading plan: ${err}
+`);
+    process.exit(PLAN_EXIT_CODES.ERROR);
+    return;
+  }
+  const progress = getPlanProgress(plan);
+  process.stdout.write(`Plan: ${plan.plan_id}
+`);
+  process.stdout.write(`Objective: ${plan.objective}
+`);
+  process.stdout.write(`Completion: ${plan.completion ?? "trust"}
+`);
+  process.stdout.write(`Progress: ${progress.completed}/${progress.total} (${progress.percentage}%)
+`);
+  process.stdout.write(`
+Steps:
+`);
+  for (const step of plan.steps) {
+    const status = step.status === "completed" ? "[x]" : step.status === "active" ? "[>]" : step.status === "skipped" ? "[-]" : "[ ]";
+    let line = `  ${status} ${step.label}`;
+    if (step.tags?.length) line += ` [tag: ${step.tags.join(", ")}]`;
+    if (step.verify) line += ` [verify: ${step.verify}]`;
+    if (step.requires?.length) line += ` (after: ${step.requires.join(", ")})`;
+    process.stdout.write(line + "\n");
+  }
+  if (plan.constraints.length > 0) {
+    process.stdout.write(`
+Constraints:
+`);
+    for (const c of plan.constraints) {
+      process.stdout.write(`  - ${c.description} [${c.type}/${c.enforcement}]
+`);
+    }
+  }
+}
+async function advanceCommand(args) {
+  const stepId = args.find((a) => !a.startsWith("--"));
+  const planPath = parseArg(args, "--plan");
+  if (!stepId || !planPath) {
+    process.stderr.write("Usage: neuroverse plan advance <step_id> --plan plan.json [--evidence <type> --proof <proof>]\n");
+    process.exit(PLAN_EXIT_CODES.ERROR);
+    return;
+  }
+  let plan;
+  try {
+    plan = JSON.parse((0, import_fs.readFileSync)(planPath, "utf-8"));
+  } catch (err) {
+    process.stderr.write(`Error reading plan: ${err}
+`);
+    process.exit(PLAN_EXIT_CODES.ERROR);
+    return;
+  }
+  const evidenceType = parseArg(args, "--evidence");
+  const evidenceProof = parseArg(args, "--proof");
+  let evidence;
+  if (evidenceType && evidenceProof) {
+    evidence = {
+      type: evidenceType,
+      proof: evidenceProof,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  } else if (evidenceType || evidenceProof) {
+    process.stderr.write("Error: --evidence and --proof must both be provided.\n");
+    process.exit(PLAN_EXIT_CODES.ERROR);
+    return;
+  }
+  const result = advancePlan(plan, stepId, evidence);
+  if (!result.success) {
+    process.stderr.write(`Error: ${result.reason}
+`);
+    process.exit(PLAN_EXIT_CODES.ERROR);
+    return;
+  }
+  (0, import_fs.writeFileSync)(planPath, JSON.stringify(result.plan, null, 2) + "\n");
+  const progress = getPlanProgress(result.plan);
+  const step = plan.steps.find((s) => s.id === stepId);
+  process.stdout.write(`Step completed: ${step.label}
+`);
+  if (result.evidence) {
+    process.stdout.write(`Evidence: ${result.evidence.type} = ${result.evidence.proof}
+`);
+  }
+  process.stdout.write(`Progress: ${progress.completed}/${progress.total} (${progress.percentage}%)
+`);
+  if (progress.completed === progress.total) {
+    process.stdout.write(`
+Plan complete!
+`);
+  }
+}
+async function deriveCommand(args) {
+  const inputPath = args.find((a) => !a.startsWith("--"));
+  if (!inputPath) {
+    process.stderr.write("Usage: neuroverse plan derive <plan.md> [--output ./world/]\n");
+    process.exit(PLAN_EXIT_CODES.ERROR);
+    return;
+  }
+  const outputDir = parseArg(args, "--output") ?? "./derived-world/";
+  let markdown;
+  try {
+    markdown = (0, import_fs.readFileSync)(inputPath, "utf-8");
+  } catch (err) {
+    process.stderr.write(`Error reading ${inputPath}: ${err}
+`);
+    process.exit(PLAN_EXIT_CODES.ERROR);
+    return;
+  }
+  const result = parsePlanMarkdown(markdown);
+  if (!result.success || !result.plan) {
+    process.stderr.write(`Parse errors:
+`);
+    for (const error of result.errors) {
+      process.stderr.write(`  - ${error}
+`);
+    }
+    process.exit(PLAN_EXIT_CODES.ERROR);
+    return;
+  }
+  const plan = result.plan;
+  const { mkdirSync } = await import("fs");
+  mkdirSync(outputDir, { recursive: true });
+  const worldJson = {
+    world_id: `plan_${plan.plan_id}`,
+    name: `Derived: ${plan.objective}`,
+    thesis: plan.objective,
+    version: "1.0.0",
+    runtime_mode: "COMPLIANCE",
+    default_assumption_profile: "default",
+    default_alternative_profile: "default",
+    modules: ["governance"],
+    players: { thinking_space: true, experience_space: false, action_space: true }
+  };
+  const invariants = plan.constraints.map((c, i) => ({
+    id: `inv_${c.id}`,
+    label: c.description,
+    type: "structural",
+    enforcement: c.enforcement === "block" ? "hard" : "soft"
+  }));
+  const guards = {
+    intent_vocabulary: {},
+    guards: plan.steps.map((step) => {
+      const patternKey = `plan_step_${step.id}`;
+      return {
+        id: `guard_${step.id}`,
+        label: `Plan step: ${step.label}`,
+        description: `Governs execution of plan step: ${step.label}`,
+        category: "operational",
+        enforcement: "warn",
+        intent_patterns: [patternKey],
+        appliesTo: step.tools ?? [],
+        default_enabled: true,
+        immutable: false
+      };
+    })
+  };
+  for (const step of plan.steps) {
+    const keywords = step.label.toLowerCase().split(/\s+/).filter((w) => w.length > 3);
+    const pattern = keywords.map((k) => `(?=.*${k})`).join("") + ".*";
+    guards.intent_vocabulary[`plan_step_${step.id}`] = {
+      pattern,
+      description: step.label
+    };
+  }
+  (0, import_fs.writeFileSync)(`${outputDir}/world.json`, JSON.stringify(worldJson, null, 2) + "\n");
+  (0, import_fs.writeFileSync)(`${outputDir}/invariants.json`, JSON.stringify(invariants, null, 2) + "\n");
+  (0, import_fs.writeFileSync)(`${outputDir}/guards.json`, JSON.stringify(guards, null, 2) + "\n");
+  process.stdout.write(`World derived from plan: ${plan.plan_id}
+`);
+  process.stdout.write(`  Output: ${outputDir}
+`);
+  process.stdout.write(`  Files: world.json, invariants.json, guards.json
+`);
+  process.stdout.write(`  Guards: ${plan.steps.length} (one per step)
+`);
+  process.stdout.write(`  Invariants: ${plan.constraints.length} (one per constraint)
+`);
+}
+var PLAN_USAGE = `
+neuroverse plan \u2014 Plan enforcement for AI agents.
+
+Subcommands:
+  compile   Parse plan markdown into plan.json
+  check     Check an action against a plan (stdin \u2192 stdout)
+  status    Show plan progress
+  advance   Mark a step as completed
+  derive    Generate a full world from a plan
+
+Usage:
+  neuroverse plan compile <plan.md> [--output plan.json]
+  echo '{"intent":"..."}' | neuroverse plan check --plan plan.json [--world ./world/]
+  neuroverse plan status --plan plan.json
+  neuroverse plan advance <step_id> --plan plan.json
+  neuroverse plan derive <plan.md> [--output ./world/]
+`.trim();
+async function main(args) {
+  const subcommand = args[0];
+  const subArgs = args.slice(1);
+  switch (subcommand) {
+    case "compile":
+      return compileCommand(subArgs);
+    case "check":
+      return checkCommand(subArgs);
+    case "status":
+      return statusCommand(subArgs);
+    case "advance":
+      return advanceCommand(subArgs);
+    case "derive":
+      return deriveCommand(subArgs);
+    case "--help":
+    case "-h":
+    case "help":
+    case void 0:
+      process.stdout.write(PLAN_USAGE + "\n");
+      process.exit(0);
+      break;
+    default:
+      process.stderr.write(`Unknown plan subcommand: "${subcommand}"
+
+`);
+      process.stdout.write(PLAN_USAGE + "\n");
+      process.exit(1);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  main
+});