@neuroverseos/governance 0.3.0 → 0.3.3

package/dist/cli/plan.cjs

@@ -30,17 +30,27 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/engine/plan-engine.ts
-function keywordMatch(eventText, step) {
-  const stepText = [
-    step.label,
-    step.description ?? "",
-    ...step.tags ?? []
+// src/engine/text-utils.ts
+function normalizeEventText(event) {
+  return [
+    event.intent,
+    event.tool ?? "",
+    event.scope ?? ""
   ].join(" ").toLowerCase();
-  const keywords = stepText.split(/\s+/).filter((w) => w.length > 3);
+}
+function extractKeywords(text, minLength = 3) {
+  return text.toLowerCase().split(/\s+/).filter((w) => w.length > minLength);
+}
+function matchesAllKeywords(eventText, ruleText) {
+  const keywords = extractKeywords(ruleText);
+  if (keywords.length === 0) return false;
+  return keywords.every((kw) => eventText.includes(kw));
+}
+function matchesKeywordThreshold(eventText, ruleText, threshold = 0.5) {
+  const keywords = extractKeywords(ruleText);
   if (keywords.length === 0) return false;
   const matched = keywords.filter((kw) => eventText.includes(kw));
-  return matched.length >= Math.ceil(keywords.length * 0.5);
+  return matched.length >= Math.ceil(keywords.length * threshold);
 }
 function tokenSimilarity(a, b) {
   const tokensA = new Set(a.toLowerCase().split(/\s+/).filter((w) => w.length > 2));
@@ -53,6 +63,24 @@ function tokenSimilarity(a, b) {
   const union = (/* @__PURE__ */ new Set([...tokensA, ...tokensB])).size;
   return union > 0 ? intersection / union : 0;
 }
+var init_text_utils = __esm({
+  "src/engine/text-utils.ts"() {
+    "use strict";
+  }
+});
+
+// src/engine/plan-engine.ts
+function keywordMatch(eventText, step) {
+  const stepText = [
+    step.label,
+    step.description ?? "",
+    ...step.tags ?? []
+  ].join(" ");
+  return matchesKeywordThreshold(eventText, stepText, 0.5);
+}
+function tokenSimilarity2(a, b) {
+  return tokenSimilarity(a, b);
+}
 function findMatchingStep(eventText, event, steps) {
   const pendingOrActive = steps.filter((s) => s.status === "pending" || s.status === "active");
   if (pendingOrActive.length === 0) {
@@ -71,7 +99,7 @@ function findMatchingStep(eventText, event, steps) {
   let bestScore = 0;
   for (const step of pendingOrActive) {
     const stepText = [step.label, step.description ?? "", ...step.tags ?? []].join(" ");
-    const score = tokenSimilarity(intentText, stepText);
+    const score = tokenSimilarity2(intentText, stepText);
     if (score > bestScore) {
       bestScore = score;
       bestStep = step;
@@ -112,7 +140,7 @@ function checkConstraints(event, eventText, constraints) {
       continue;
     }
     if (constraint.type === "scope" && constraint.trigger) {
-      const keywords = constraint.trigger.split(/\s+/).filter((w) => w.length > 3);
+      const keywords = extractKeywords(constraint.trigger);
       const violated = keywords.length > 0 && keywords.every((kw) => eventText.includes(kw));
       checks.push({
         constraintId: constraint.id,
@@ -193,11 +221,7 @@ function evaluatePlan(event, plan) {
       progress
     };
   }
-  const eventText = [
-    event.intent,
-    event.tool ?? "",
-    event.scope ?? ""
-  ].join(" ").toLowerCase();
+  const eventText = normalizeEventText(event);
   const { matched, closest, closestScore } = findMatchingStep(eventText, event, plan.steps);
   if (!matched) {
     return {
@@ -238,7 +262,7 @@ function evaluatePlan(event, plan) {
   };
 }
 function buildPlanCheck(event, plan, verdict) {
-  const eventText = [event.intent, event.tool ?? "", event.scope ?? ""].join(" ").toLowerCase();
+  const eventText = normalizeEventText(event);
   const { matched, closest, closestScore } = findMatchingStep(eventText, event, plan.steps);
   const { checks: constraintChecks } = checkConstraints(event, eventText, plan.constraints);
   const progress = getPlanProgress(plan);
@@ -258,12 +282,672 @@ function buildPlanCheck(event, plan, verdict) {
 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
 });
@@ -272,10 +956,18 @@ async function loadWorldFromDirectory(dirPath) {
   const { join } = await import("path");
   const { readdirSync } = await import("fs");
   async function readJson(filename) {
+    const filePath = join(dirPath, filename);
     try {
-      const content = await readFile(join(dirPath, filename), "utf-8");
+      const content = await readFile(filePath, "utf-8");
       return JSON.parse(content);
-    } catch {
+    } 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;
     }
   }
@@ -297,10 +989,23 @@ async function loadWorldFromDirectory(dirPath) {
     const rulesDir = join(dirPath, "rules");
     const ruleFiles = readdirSync(rulesDir).filter((f) => f.endsWith(".json")).sort();
     for (const file of ruleFiles) {
-      const content = await readFile(join(rulesDir, file), "utf-8");
-      rules.push(JSON.parse(content));
+      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)}
+`
+      );
     }
-  } catch {
   }
   return {
     world: worldJson,
@@ -335,14 +1040,49 @@ async function loadWorld(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`);
+}
+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(`Cannot load world from: ${worldPath} \u2014 expected a directory or .nv-world.zip`);
+  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";
   }
 });
 
@@ -376,7 +1116,44 @@ function evaluateGuard(event, world, options = {}) {
   const startTime = performance.now();
   const level = options.level ?? "standard";
   const includeTrace = options.trace ?? false;
-  const eventText = (event.intent + " " + (event.tool ?? "") + " " + (event.scope ?? "")).toLowerCase();
+  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;
@@ -389,6 +1166,43 @@ function evaluateGuard(event, world, options = {}) {
   const guardsMatched = [];
   const rulesMatched = [];
   checkInvariantCoverage(world, invariantChecks);
+  if (event.roleId && options.agentStates) {
+    const agentState = options.agentStates.get(event.roleId);
+    if (agentState && agentState.cooldownRemaining > 0) {
+      decidingLayer = "safety";
+      decidingId = `penalize-cooldown-${event.roleId}`;
+      const verdict = buildVerdict(
+        "PENALIZE",
+        `Agent "${event.roleId}" is frozen for ${agentState.cooldownRemaining} more round(s) due to prior penalty.`,
+        `penalize-cooldown-${event.roleId}`,
+        void 0,
+        world,
+        level,
+        invariantChecks,
+        guardsMatched,
+        rulesMatched,
+        includeTrace ? buildTrace(
+          invariantChecks,
+          safetyChecks,
+          planCheckResult,
+          roleChecks,
+          guardChecks,
+          kernelRuleChecks,
+          levelChecks,
+          decidingLayer,
+          decidingId,
+          startTime
+        ) : void 0
+      );
+      verdict.intentRecord = {
+        originalIntent: event.intent,
+        finalAction: "blocked (agent frozen)",
+        enforcement: "PENALIZE",
+        consequence: { type: "freeze", rounds: agentState.cooldownRemaining, description: "Agent still in cooldown from prior penalty" }
+      };
+      return verdict;
+    }
+  }
   if (options.sessionAllowlist) {
     const key = eventToAllowlistKey(event);
     if (options.sessionAllowlist.has(key)) {
@@ -516,7 +1330,16 @@ function evaluateGuard(event, world, options = {}) {
     if (guardVerdict.status !== "ALLOW") {
       decidingLayer = "guard";
       decidingId = guardVerdict.ruleId;
-      return buildVerdict(
+      const intentRecord = {
+        originalIntent: event.intent,
+        finalAction: guardVerdict.status === "MODIFY" ? guardVerdict.modifiedTo ?? "modified" : guardVerdict.status === "PENALIZE" ? "blocked + penalized" : guardVerdict.status === "REWARD" ? event.intent : guardVerdict.status === "NEUTRAL" ? event.intent : guardVerdict.status === "BLOCK" ? "blocked" : "paused",
+        ruleApplied: guardVerdict.ruleId,
+        enforcement: guardVerdict.status,
+        modifiedTo: guardVerdict.modifiedTo,
+        consequence: guardVerdict.consequence,
+        reward: guardVerdict.reward
+      };
+      const verdict = buildVerdict(
         guardVerdict.status,
         guardVerdict.reason,
         guardVerdict.ruleId,
@@ -539,6 +1362,10 @@ function evaluateGuard(event, world, options = {}) {
           startTime
         ) : void 0
       );
+      verdict.intentRecord = intentRecord;
+      if (guardVerdict.consequence) verdict.consequence = guardVerdict.consequence;
+      if (guardVerdict.reward) verdict.reward = guardVerdict.reward;
+      return verdict;
     }
   }
   const kernelVerdict = checkKernelRules(eventText, world, kernelRuleChecks, rulesMatched);
@@ -833,6 +1660,21 @@ function checkGuards(event, eventText, world, checks, guardsMatched) {
     if (actionMode === "pause") {
       return { status: "PAUSE", reason, ruleId: `guard-${guard.id}` };
     }
+    if (actionMode === "penalize") {
+      const consequence = guard.consequence ? { ...guard.consequence } : { type: "freeze", rounds: 1, description: `Penalized for violating: ${guard.label}` };
+      return { status: "PENALIZE", reason, ruleId: `guard-${guard.id}`, consequence };
+    }
+    if (actionMode === "reward") {
+      const reward = guard.reward ? { ...guard.reward } : { type: "boost_influence", magnitude: 0.1, description: `Rewarded for: ${guard.label}` };
+      return { status: "REWARD", reason, ruleId: `guard-${guard.id}`, reward };
+    }
+    if (actionMode === "modify") {
+      const modifiedTo = guard.modify_to ?? guard.redirect ?? "hold";
+      return { status: "MODIFY", reason: `${reason} \u2192 Modified to: ${modifiedTo}`, ruleId: `guard-${guard.id}`, modifiedTo };
+    }
+    if (actionMode === "neutral") {
+      return { status: "NEUTRAL", reason, ruleId: `guard-${guard.id}` };
+    }
     if (actionMode === "warn" && !warnResult) {
       warnResult = { status: "ALLOW", warning: reason, ruleId: `guard-${guard.id}` };
     }
@@ -942,9 +1784,7 @@ function checkLevelConstraints(event, level, checks) {
   return null;
 }
 function matchesKeywords(eventText, ruleText) {
-  const keywords = ruleText.toLowerCase().split(/\s+/).filter((w) => w.length > 3);
-  if (keywords.length === 0) return false;
-  return keywords.every((kw) => eventText.includes(kw));
+  return matchesAllKeywords(eventText, ruleText);
 }
 function eventToAllowlistKey(event) {
   return `${(event.tool ?? "*").toLowerCase()}::${event.intent.toLowerCase().trim()}`;
@@ -1005,11 +1845,12 @@ function buildVerdict(status, reason, ruleId, warning, world, level, invariantCh
   if (trace) verdict.trace = trace;
   return verdict;
 }
-var PROMPT_INJECTION_PATTERNS, EXECUTION_CLAIM_PATTERNS, EXECUTION_INTENT_PATTERNS, SCOPE_ESCAPE_PATTERNS, NEUTRAL_MESSAGES;
+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" },
@@ -1073,6 +1914,7 @@ var init_guard_engine = __esm({
       "network-mutate": "This action would send data to an external service.",
       "credential-access": "This action would access stored credentials."
     };
+    MAX_INPUT_LENGTH = 1e5;
   }
 });
 
@@ -1247,22 +2089,20 @@ var PLAN_EXIT_CODES = {
   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;
 }
-function readStdin() {
-  return new Promise((resolve, reject) => {
-    let data = "";
-    process.stdin.setEncoding("utf-8");
-    process.stdin.on("data", (chunk) => {
-      data += chunk;
-    });
-    process.stdin.on("end", () => resolve(data));
-    process.stdin.on("error", reject);
-  });
-}
 async function compileCommand(args) {
   const inputPath = args.find((a) => !a.startsWith("--"));
   if (!inputPath) {