@neuroverseos/governance 0.6.1 → 0.7.0

package/dist/cli/radiant.cjs

@@ -1,7 +1,9 @@
 "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;
@@ -18,6 +20,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   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/radiant/lenses/auki-builder.ts
@@ -471,18 +481,6 @@ var init_lenses = __esm({
   }
 });
 
-// src/cli/radiant.ts
-var radiant_exports = {};
-__export(radiant_exports, {
-  main: () => main
-});
-module.exports = __toCommonJS(radiant_exports);
-var import_fs2 = require("fs");
-var import_path2 = require("path");
-
-// src/radiant/commands/think.ts
-init_lenses();
-
 // src/radiant/core/prompt.ts
 function composeSystemPrompt(worldmodelContent, lens) {
   const sections = [];
@@ -569,6 +567,11 @@ explicitly and propose an alternative that honors the invariant.`
   );
   return sections.join("\n\n---\n\n");
 }
+var init_prompt = __esm({
+  "src/radiant/core/prompt.ts"() {
+    "use strict";
+  }
+});
 
 // src/radiant/core/voice-check.ts
 function checkForbiddenPhrases(lens, text) {
@@ -587,6 +590,11 @@ function checkForbiddenPhrases(lens, text) {
   violations.sort((a, b) => a.offset - b.offset);
   return violations;
 }
+var init_voice_check = __esm({
+  "src/radiant/core/voice-check.ts"() {
+    "use strict";
+  }
+});
 
 // src/radiant/commands/think.ts
 async function think(input) {
@@ -618,9 +626,14 @@ function resolveLens(id) {
   }
   return lens;
 }
-
-// src/radiant/commands/emergent.ts
-init_lenses();
+var init_think = __esm({
+  "src/radiant/commands/think.ts"() {
+    "use strict";
+    init_lenses();
+    init_prompt();
+    init_voice_check();
+  }
+});
 
 // src/radiant/core/scopes.ts
 function parseRepoScope(scope) {
@@ -636,6 +649,11 @@ function parseRepoScope(scope) {
 function formatScope(scope) {
   return `${scope.owner}/${scope.repo}`;
 }
+var init_scopes = __esm({
+  "src/radiant/core/scopes.ts"() {
+    "use strict";
+  }
+});
 
 // src/radiant/adapters/github.ts
 async function fetchGitHubActivity(scope, token, options = {}) {
@@ -745,20 +763,6 @@ function mapComment(comment, scope) {
   };
   return event;
 }
-var KNOWN_AI_LOGINS = /* @__PURE__ */ new Set([
-  "github-actions[bot]",
-  "dependabot[bot]",
-  "renovate[bot]",
-  "copilot"
-]);
-var KNOWN_AI_CO_AUTHOR_NAMES = /* @__PURE__ */ new Set([
-  "claude",
-  "copilot",
-  "cursor",
-  "codeium",
-  "tabnine",
-  "codex"
-]);
 function mapUser(ghUser, fallbackName) {
   if (!ghUser) {
     return {
@@ -817,10 +821,29 @@ async function fetchJSON(url, headers) {
   }
   return await res.json();
 }
+var KNOWN_AI_LOGINS, KNOWN_AI_CO_AUTHOR_NAMES;
+var init_github = __esm({
+  "src/radiant/adapters/github.ts"() {
+    "use strict";
+    init_scopes();
+    KNOWN_AI_LOGINS = /* @__PURE__ */ new Set([
+      "github-actions[bot]",
+      "dependabot[bot]",
+      "renovate[bot]",
+      "copilot"
+    ]);
+    KNOWN_AI_CO_AUTHOR_NAMES = /* @__PURE__ */ new Set([
+      "claude",
+      "copilot",
+      "cursor",
+      "codeium",
+      "tabnine",
+      "codex"
+    ]);
+  }
+});
 
 // src/radiant/adapters/exocortex.ts
-var import_fs = require("fs");
-var import_path = require("path");
 function readExocortex(dirPath) {
   const dir = (0, import_path.resolve)(dirPath);
   let filesLoaded = 0;
@@ -901,6 +924,1526 @@ function summarizeExocortex(ctx) {
   if (ctx.methods) loaded.push("methods");
   return `${loaded.join(", ")} (${ctx.filesLoaded} files)`;
 }
+var import_fs, import_path;
+var init_exocortex = __esm({
+  "src/radiant/adapters/exocortex.ts"() {
+    "use strict";
+    import_fs = require("fs");
+    import_path = require("path");
+  }
+});
+
+// src/radiant/memory/palace.ts
+function writeRead(exocortexDir, frontmatter, text) {
+  const dir = (0, import_path2.resolve)(exocortexDir, "radiant", "reads");
+  (0, import_fs2.mkdirSync)(dir, { recursive: true });
+  const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const filename = `${date}.md`;
+  const filepath = (0, import_path2.join)(dir, filename);
+  const content = `${frontmatter}
+
+${text}
+`;
+  (0, import_fs2.writeFileSync)(filepath, content, "utf-8");
+  return filepath;
+}
+function updateKnowledge(exocortexDir, persistence, options) {
+  const dir = (0, import_path2.resolve)(exocortexDir, "radiant");
+  (0, import_fs2.mkdirSync)(dir, { recursive: true });
+  const filepath = (0, import_path2.join)(dir, "knowledge.md");
+  const totalReads = options?.totalReads ?? 0;
+  const existingUntriggered = loadUntriggeredCounts(filepath);
+  const lines = [
+    "# Radiant \u2014 Accumulated Behavioral Knowledge",
+    "",
+    `Last updated: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}`,
+    `Total reads: ${totalReads}`,
+    "",
+    "---",
+    "",
+    "## Evolution proposals",
+    ""
+  ];
+  const addCandidates = persistence.filter((p) => p.occurrences >= 3);
+  if (addCandidates.length > 0) {
+    lines.push("### Consider adding");
+    lines.push("");
+    lines.push("These candidate patterns keep recurring. They are not yet in the worldmodel.");
+    lines.push("If they represent real behavioral patterns worth tracking, add them.");
+    lines.push("If they were temporary, dismiss them.");
+    lines.push("");
+    for (const p of addCandidates) {
+      lines.push(
+        `- **${p.name}** \u2014 observed ${p.occurrences} times (${p.dates.join(", ")}). Add to auki-strategy.worldmodel.md \u2192 Evolution Layer \u2192 Drift Behaviors (if concerning) or Aligned Behaviors (if healthy).`
+      );
+    }
+    lines.push("");
+  }
+  if (options?.declaredItems && options.declaredItems.length > 0) {
+    const triggered = new Set(options.triggeredItems ?? []);
+    const removeCandidates = [];
+    for (const item of options.declaredItems) {
+      if (!triggered.has(item.name)) {
+        const prior = existingUntriggered.get(item.name) ?? 0;
+        const count = prior + 1;
+        existingUntriggered.set(item.name, count);
+        if (count >= 4) {
+          removeCandidates.push({ item, weeksSilent: count });
+        }
+      } else {
+        existingUntriggered.set(item.name, 0);
+      }
+    }
+    if (removeCandidates.length > 0) {
+      lines.push("### Consider removing");
+      lines.push("");
+      lines.push("These items are declared in the worldmodel but haven't triggered in multiple reads.");
+      lines.push("Either the team has internalized them (the rule is redundant) or they haven't been tested.");
+      lines.push("A lean worldmodel with 5 sharp invariants is stronger than a bloated one with 20.");
+      lines.push("");
+      for (const { item, weeksSilent } of removeCandidates) {
+        lines.push(
+          `- **${item.name}** (${item.type}) \u2014 hasn't triggered in ${weeksSilent} reads. Internalized or untested? Review whether it still earns its place.`
+        );
+      }
+      lines.push("");
+    }
+  }
+  if (options?.triggeredItems && options.triggeredItems.length > 0) {
+    lines.push("### Keep (recently active)");
+    lines.push("");
+    lines.push("These worldmodel items triggered governance in the most recent read. They're earning their place.");
+    lines.push("");
+    for (const name of options.triggeredItems) {
+      lines.push(`- **${name}** \u2014 triggered this read. Holding.`);
+    }
+    lines.push("");
+  }
+  lines.push("---");
+  lines.push("");
+  lines.push("## Pattern persistence (all observed)");
+  lines.push("");
+  for (const p of persistence) {
+    const status = p.occurrences >= 4 ? "**persistent**" : p.occurrences >= 2 ? "recurring" : "observed once";
+    lines.push(`### ${p.name}`);
+    lines.push(`- Status: ${status}`);
+    lines.push(`- Observed ${p.occurrences} time${p.occurrences > 1 ? "s" : ""}: ${p.dates.join(", ")}`);
+    lines.push("");
+  }
+  lines.push("---");
+  lines.push("");
+  lines.push("<!-- untriggered_counts (machine-readable, do not edit)");
+  for (const [name, count] of existingUntriggered.entries()) {
+    lines.push(`${name}=${count}`);
+  }
+  lines.push("-->");
+  (0, import_fs2.writeFileSync)(filepath, lines.join("\n"), "utf-8");
+  return filepath;
+}
+function loadUntriggeredCounts(filepath) {
+  const counts = /* @__PURE__ */ new Map();
+  if (!(0, import_fs2.existsSync)(filepath)) return counts;
+  try {
+    const content = (0, import_fs2.readFileSync)(filepath, "utf-8");
+    const match = content.match(
+      /<!-- untriggered_counts[\s\S]*?-->/
+    );
+    if (match) {
+      const lines = match[0].split("\n");
+      for (const line of lines) {
+        const eq = line.match(/^([^=]+)=(\d+)$/);
+        if (eq) {
+          counts.set(eq[1], parseInt(eq[2], 10));
+        }
+      }
+    }
+  } catch {
+  }
+  return counts;
+}
+function loadPriorReads(exocortexDir) {
+  const dir = (0, import_path2.resolve)(exocortexDir, "radiant", "reads");
+  if (!(0, import_fs2.existsSync)(dir)) return [];
+  const files = (0, import_fs2.readdirSync)(dir).filter((f) => f.endsWith(".md")).sort();
+  const reads = [];
+  for (const filename of files) {
+    const filepath = (0, import_path2.join)(dir, filename);
+    const content = (0, import_fs2.readFileSync)(filepath, "utf-8");
+    const date = filename.replace(".md", "");
+    const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    const frontmatter = fmMatch ? fmMatch[1] : "";
+    const patternNames = [];
+    const nameMatches = frontmatter.matchAll(/- name: ["']?([^"'\n]+)["']?/g);
+    for (const m of nameMatches) {
+      patternNames.push(m[1].trim());
+    }
+    reads.push({ date, filename, patternNames, frontmatter });
+  }
+  return reads;
+}
+function computePersistence(priorReads, currentPatternNames) {
+  const allPatterns = /* @__PURE__ */ new Map();
+  for (const read of priorReads) {
+    for (const name of read.patternNames) {
+      const dates = allPatterns.get(name) ?? [];
+      if (!dates.includes(read.date)) dates.push(read.date);
+      allPatterns.set(name, dates);
+    }
+  }
+  const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  for (const name of currentPatternNames) {
+    const dates = allPatterns.get(name) ?? [];
+    if (!dates.includes(today)) dates.push(today);
+    allPatterns.set(name, dates);
+  }
+  return Array.from(allPatterns.entries()).map(([name, dates]) => ({
+    name,
+    occurrences: dates.length,
+    dates: dates.sort()
+  })).sort((a, b) => b.occurrences - a.occurrences);
+}
+function formatPriorReadsForPrompt(priorReads) {
+  if (priorReads.length === 0) return "";
+  const lines = [
+    "## Prior Radiant reads (history)",
+    "",
+    `Radiant has run ${priorReads.length} time${priorReads.length > 1 ? "s" : ""} before on this scope.`,
+    "If you see patterns that appeared in prior reads, note their persistence.",
+    "Patterns that recur across 3+ reads are strong candidates for declaration in the strategy file.",
+    ""
+  ];
+  for (const read of priorReads.slice(-4)) {
+    lines.push(`### Read from ${read.date}`);
+    if (read.patternNames.length > 0) {
+      lines.push(`Patterns observed: ${read.patternNames.join(", ")}`);
+    } else {
+      lines.push("No patterns extracted from frontmatter.");
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+var import_fs2, import_path2;
+var init_palace = __esm({
+  "src/radiant/memory/palace.ts"() {
+    "use strict";
+    import_fs2 = require("fs");
+    import_path2 = require("path");
+  }
+});
+
+// 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 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/guard-engine.ts
+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 = [];
+  if (options.emergencyOverride) {
+    checkInvariantCoverage(world, invariantChecks);
+    return buildVerdict(
+      "ALLOW",
+      void 0,
+      "emergency-override",
+      "Emergency override active \u2014 all governance rules suspended. Platform constraints still apply.",
+      world,
+      level,
+      invariantChecks,
+      guardsMatched,
+      rulesMatched,
+      includeTrace ? buildTrace(
+        invariantChecks,
+        safetyChecks,
+        planCheckResult,
+        roleChecks,
+        guardChecks,
+        kernelRuleChecks,
+        levelChecks,
+        "session-allowlist",
+        "emergency-override",
+        startTime
+      ) : void 0,
+      event.intent
+    );
+  }
+  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,
+        event.intent
+      );
+    }
+  }
+  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,
+      event.intent
+    );
+  }
+  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,
+        event.intent
+      );
+    }
+  }
+  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,
+      event.intent
+    );
+  }
+  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,
+        event.intent
+      );
+      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,
+      event.intent
+    );
+  }
+  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,
+      event.intent
+    );
+  }
+  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,
+    event.intent
+  );
+}
+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, eventIntent) {
+  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;
+  verdict.event = verdictToEvent(status, eventIntent);
+  return verdict;
+}
+function verdictToEvent(status, intent) {
+  const statusEventMap = {
+    ALLOW: "action_allowed",
+    BLOCK: "action_blocked",
+    PAUSE: "action_paused",
+    MODIFY: "action_modified",
+    PENALIZE: "action_penalized",
+    REWARD: "action_rewarded",
+    NEUTRAL: "action_neutral"
+  };
+  return {
+    type: intent || statusEventMap[status] || "unknown_action",
+    actor: "agent",
+    source: "guard",
+    timestamp: Date.now(),
+    guardStatus: status
+  };
+}
+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/loader/world-loader.ts
+async function loadWorldFromDirectory(dirPath) {
+  const { readFile } = await import("fs/promises");
+  const { join: join5 } = await import("path");
+  const { readdirSync: readdirSync4 } = await import("fs");
+  async function readJson(filename) {
+    const filePath = join5(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 = join5(dirPath, "rules");
+    const ruleFiles = readdirSync4(rulesDir).filter((f) => f.endsWith(".json")).sort();
+    for (const file of ruleFiles) {
+      try {
+        const content = await readFile(join5(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`);
+}
+var init_world_loader = __esm({
+  "src/loader/world-loader.ts"() {
+    "use strict";
+  }
+});
+
+// src/radiant/core/governance.ts
+async function auditGovernance(events, worldPath) {
+  let world;
+  try {
+    world = await loadWorld(worldPath);
+  } catch {
+    return emptyAudit(events.length, "Could not load compiled worldmodel for governance audit.");
+  }
+  const verdicts = [];
+  for (const ce of events) {
+    const intent = ce.event.content?.slice(0, 500) || ce.event.kind || "activity";
+    const scope = ce.event.metadata?.scope || void 0;
+    try {
+      const result = evaluateGuard(
+        {
+          intent,
+          scope,
+          actionCategory: mapKindToCategory(ce.event.kind)
+        },
+        world
+      );
+      verdicts.push({
+        eventId: ce.event.id,
+        domain: ce.domain,
+        status: result.status,
+        reason: result.reason,
+        ruleId: result.ruleId,
+        warning: result.warning
+      });
+    } catch {
+      verdicts.push({
+        eventId: ce.event.id,
+        domain: ce.domain,
+        status: "ALLOW",
+        reason: "guard evaluation skipped (error)"
+      });
+    }
+  }
+  const human = bucketVerdicts(verdicts.filter((v) => v.domain === "life"));
+  const cyber = bucketVerdicts(verdicts.filter((v) => v.domain === "cyber"));
+  const joint = bucketVerdicts(verdicts.filter((v) => v.domain === "joint"));
+  const summary = buildSummary(human, cyber, joint, events.length);
+  return {
+    totalEvents: events.length,
+    human,
+    cyber,
+    joint,
+    summary
+  };
+}
+function bucketVerdicts(verdicts) {
+  const nonAllow = verdicts.filter((v) => v.status !== "ALLOW");
+  return {
+    allow: verdicts.filter((v) => v.status === "ALLOW").length,
+    modify: verdicts.filter((v) => v.status === "MODIFY").length,
+    block: verdicts.filter((v) => v.status === "BLOCK").length,
+    details: nonAllow
+  };
+}
+function buildSummary(human, cyber, joint, total) {
+  const humanTriggered = human.modify + human.block;
+  const cyberTriggered = cyber.modify + cyber.block;
+  const jointTriggered = joint.modify + joint.block;
+  const totalTriggered = humanTriggered + cyberTriggered + jointTriggered;
+  if (totalTriggered === 0) {
+    return `${total} events evaluated. All passed. The cocoon held \u2014 no governance triggered.`;
+  }
+  const parts = [];
+  parts.push(`${total} events evaluated. ${totalTriggered} triggered governance.`);
+  if (humanTriggered > 0) {
+    parts.push(`Human side: ${humanTriggered} (${human.block} blocked, ${human.modify} modified).`);
+  }
+  if (cyberTriggered > 0) {
+    parts.push(`AI side: ${cyberTriggered} (${cyber.block} blocked, ${cyber.modify} modified).`);
+  }
+  if (jointTriggered > 0) {
+    parts.push(`Joint work: ${jointTriggered} (${joint.block} blocked, ${joint.modify} modified).`);
+  }
+  if (humanTriggered > 0 && cyberTriggered > 0) {
+    const ratio = humanTriggered / cyberTriggered;
+    if (ratio > 2) {
+      parts.push("Human side is testing the frame more than AI. Either the worldmodel needs calibrating for human workflows, or humans are genuinely drifting.");
+    } else if (ratio < 0.5) {
+      parts.push("AI side is testing the frame more than humans. Check whether the AI's output patterns match the declared invariants.");
+    } else {
+      parts.push("Roughly balanced between human and AI \u2014 both sides are testing the frame.");
+    }
+  }
+  return parts.join(" ");
+}
+function mapKindToCategory(kind) {
+  if (!kind) return "other";
+  if (kind.includes("commit") || kind.includes("merge")) return "write";
+  if (kind.includes("review") || kind.includes("comment")) return "read";
+  return "other";
+}
+function emptyAudit(total, reason) {
+  return {
+    totalEvents: total,
+    human: { allow: 0, modify: 0, block: 0, details: [] },
+    cyber: { allow: 0, modify: 0, block: 0, details: [] },
+    joint: { allow: 0, modify: 0, block: 0, details: [] },
+    summary: reason
+  };
+}
+var init_governance = __esm({
+  "src/radiant/core/governance.ts"() {
+    "use strict";
+    init_guard_engine();
+    init_world_loader();
+  }
+});
 
 // src/radiant/core/domain.ts
 function isLifeSide(k) {
@@ -926,6 +2469,11 @@ function classifyActorDomain(event) {
   }
   return isCyberSide(primaryKind) ? "cyber" : "life";
 }
+var init_domain = __esm({
+  "src/radiant/core/domain.ts"() {
+    "use strict";
+  }
+});
 
 // src/radiant/core/signals.ts
 function classifyEvents(events) {
@@ -951,7 +2499,6 @@ function extractSignals(events, extractors = DEFAULT_SIGNAL_EXTRACTORS) {
   }
   return out;
 }
-var ZERO = { score: 0, eventCount: 0, confidence: 0 };
 function inDomain(events, domain) {
   return events.filter((e) => e.domain === domain);
 }
@@ -963,110 +2510,124 @@ function clamp100(n) {
   if (n > 100) return 100;
   return n;
 }
-var CLARITY_EXTRACTOR = {
-  id: "clarity",
-  description: "Informativeness of event content \u2014 commit messages, PR bodies, review text",
-  extract(events, domain) {
-    const sub = inDomain(events, domain);
-    if (sub.length === 0) return ZERO;
-    const totalScore = sub.reduce((acc, e) => {
-      const len = (e.event.content ?? "").length;
-      const norm = Math.min(len, 200) / 200;
-      return acc + norm * 100;
-    }, 0);
-    return {
-      score: clamp100(totalScore / sub.length),
-      eventCount: sub.length,
-      confidence: confidenceFromCount(sub.length)
+var ZERO, CLARITY_EXTRACTOR, OWNERSHIP_EXTRACTOR, FOLLOW_THROUGH_EXTRACTOR, ALIGNMENT_EXTRACTOR, DECISION_MOMENTUM_EXTRACTOR, DEFAULT_SIGNAL_EXTRACTORS;
+var init_signals = __esm({
+  "src/radiant/core/signals.ts"() {
+    "use strict";
+    init_domain();
+    ZERO = { score: 0, eventCount: 0, confidence: 0 };
+    CLARITY_EXTRACTOR = {
+      id: "clarity",
+      description: "Informativeness of event content \u2014 commit messages, PR bodies, review text",
+      extract(events, domain) {
+        const sub = inDomain(events, domain);
+        if (sub.length === 0) return ZERO;
+        const totalScore = sub.reduce((acc, e) => {
+          const len = (e.event.content ?? "").length;
+          const norm = Math.min(len, 200) / 200;
+          return acc + norm * 100;
+        }, 0);
+        return {
+          score: clamp100(totalScore / sub.length),
+          eventCount: sub.length,
+          confidence: confidenceFromCount(sub.length)
+        };
+      }
     };
-  }
-};
-var OWNERSHIP_EXTRACTOR = {
-  id: "ownership",
-  description: "Clarity of accountability \u2014 fraction of events with a known primary actor",
-  extract(events, domain) {
-    const sub = inDomain(events, domain);
-    if (sub.length === 0) return ZERO;
-    const attributed = sub.filter((e) => e.event.actor.kind !== "unknown").length;
-    return {
-      score: clamp100(attributed / sub.length * 100),
-      eventCount: sub.length,
-      confidence: confidenceFromCount(sub.length)
+    OWNERSHIP_EXTRACTOR = {
+      id: "ownership",
+      description: "Clarity of accountability \u2014 fraction of events with a known primary actor",
+      extract(events, domain) {
+        const sub = inDomain(events, domain);
+        if (sub.length === 0) return ZERO;
+        const attributed = sub.filter((e) => e.event.actor.kind !== "unknown").length;
+        return {
+          score: clamp100(attributed / sub.length * 100),
+          eventCount: sub.length,
+          confidence: confidenceFromCount(sub.length)
+        };
+      }
     };
-  }
-};
-var FOLLOW_THROUGH_EXTRACTOR = {
-  id: "follow_through",
-  description: "Fraction of events that were followed up \u2014 i.e. referenced by a later event",
-  extract(events, domain) {
-    const sub = inDomain(events, domain);
-    if (sub.length === 0) return ZERO;
-    const referencedIds = /* @__PURE__ */ new Set();
-    for (const e of events) {
-      const ref = e.event.respondsTo?.eventId;
-      if (ref) referencedIds.add(ref);
-    }
-    const followedUp = sub.filter((e) => referencedIds.has(e.event.id)).length;
-    return {
-      score: clamp100(followedUp / sub.length * 100),
-      eventCount: sub.length,
-      confidence: confidenceFromCount(sub.length)
+    FOLLOW_THROUGH_EXTRACTOR = {
+      id: "follow_through",
+      description: "Fraction of events that were followed up \u2014 i.e. referenced by a later event",
+      extract(events, domain) {
+        const sub = inDomain(events, domain);
+        if (sub.length === 0) return ZERO;
+        const referencedIds = /* @__PURE__ */ new Set();
+        for (const e of events) {
+          const ref = e.event.respondsTo?.eventId;
+          if (ref) referencedIds.add(ref);
+        }
+        const followedUp = sub.filter((e) => referencedIds.has(e.event.id)).length;
+        return {
+          score: clamp100(followedUp / sub.length * 100),
+          eventCount: sub.length,
+          confidence: confidenceFromCount(sub.length)
+        };
+      }
     };
-  }
-};
-var ALIGNMENT_EXTRACTOR = {
-  id: "alignment",
-  description: "Coordination pressure \u2014 fraction of events that reference a prior event",
-  extract(events, domain) {
-    const sub = inDomain(events, domain);
-    if (sub.length === 0) return ZERO;
-    const referencing = sub.filter((e) => e.event.respondsTo !== void 0).length;
-    return {
-      score: clamp100(referencing / sub.length * 100),
-      eventCount: sub.length,
-      confidence: confidenceFromCount(sub.length)
+    ALIGNMENT_EXTRACTOR = {
+      id: "alignment",
+      description: "Coordination pressure \u2014 fraction of events that reference a prior event",
+      extract(events, domain) {
+        const sub = inDomain(events, domain);
+        if (sub.length === 0) return ZERO;
+        const referencing = sub.filter((e) => e.event.respondsTo !== void 0).length;
+        return {
+          score: clamp100(referencing / sub.length * 100),
+          eventCount: sub.length,
+          confidence: confidenceFromCount(sub.length)
+        };
+      }
     };
-  }
-};
-var DECISION_MOMENTUM_EXTRACTOR = {
-  id: "decision_momentum",
-  description: "Rate of activity in this domain \u2014 events per day, capped at 10/day",
-  extract(events, domain) {
-    const sub = inDomain(events, domain);
-    if (sub.length === 0) return ZERO;
-    if (sub.length < 2) {
-      return {
-        score: 20,
-        // token non-zero score — single event = some motion
-        eventCount: sub.length,
-        confidence: confidenceFromCount(sub.length)
-      };
-    }
-    const ts = sub.map((e) => Date.parse(e.event.timestamp)).sort((a, b) => a - b);
-    const spanMs = ts[ts.length - 1] - ts[0];
-    const spanDays = Math.max(spanMs / (24 * 60 * 60 * 1e3), 1 / 24);
-    const perDay = sub.length / spanDays;
-    const normalized = Math.min(perDay, 10) / 10;
-    return {
-      score: clamp100(normalized * 100),
-      eventCount: sub.length,
-      confidence: confidenceFromCount(sub.length)
+    DECISION_MOMENTUM_EXTRACTOR = {
+      id: "decision_momentum",
+      description: "Rate of activity in this domain \u2014 events per day, capped at 10/day",
+      extract(events, domain) {
+        const sub = inDomain(events, domain);
+        if (sub.length === 0) return ZERO;
+        if (sub.length < 2) {
+          return {
+            score: 20,
+            // token non-zero score — single event = some motion
+            eventCount: sub.length,
+            confidence: confidenceFromCount(sub.length)
+          };
+        }
+        const ts = sub.map((e) => Date.parse(e.event.timestamp)).sort((a, b) => a - b);
+        const spanMs = ts[ts.length - 1] - ts[0];
+        const spanDays = Math.max(spanMs / (24 * 60 * 60 * 1e3), 1 / 24);
+        const perDay = sub.length / spanDays;
+        const normalized = Math.min(perDay, 10) / 10;
+        return {
+          score: clamp100(normalized * 100),
+          eventCount: sub.length,
+          confidence: confidenceFromCount(sub.length)
+        };
+      }
     };
+    DEFAULT_SIGNAL_EXTRACTORS = Object.freeze([
+      CLARITY_EXTRACTOR,
+      OWNERSHIP_EXTRACTOR,
+      FOLLOW_THROUGH_EXTRACTOR,
+      ALIGNMENT_EXTRACTOR,
+      DECISION_MOMENTUM_EXTRACTOR
+    ]);
   }
-};
-var DEFAULT_SIGNAL_EXTRACTORS = Object.freeze([
-  CLARITY_EXTRACTOR,
-  OWNERSHIP_EXTRACTOR,
-  FOLLOW_THROUGH_EXTRACTOR,
-  ALIGNMENT_EXTRACTOR,
-  DECISION_MOMENTUM_EXTRACTOR
-]);
+});
 
 // src/radiant/types.ts
-var DEFAULT_EVIDENCE_GATE = { k: 3, c: 0.5 };
 function isScored(s) {
   return typeof s === "number";
 }
+var DEFAULT_EVIDENCE_GATE;
+var init_types = __esm({
+  "src/radiant/types.ts"() {
+    "use strict";
+    DEFAULT_EVIDENCE_GATE = { k: 3, c: 0.5 };
+  }
+});
 
 // src/radiant/core/math.ts
 function isPresent(o, gate = DEFAULT_EVIDENCE_GATE) {
@@ -1096,6 +2657,12 @@ function scoreComposite(a_L, a_C, a_N) {
   if (available.length === 0) return "INSUFFICIENT_EVIDENCE";
   return available.reduce((a, b) => a + b, 0) / available.length;
 }
+var init_math = __esm({
+  "src/radiant/core/math.ts"() {
+    "use strict";
+    init_types();
+  }
+});
 
 // src/radiant/core/patterns.ts
 async function interpretPatterns(input) {
@@ -1196,7 +2763,7 @@ Only recommend a move when the evidence actually calls for one.
     }
   ],
   "meaning": "3-5 sentences. Weave the patterns into ONE strategic thesis. Compress. The reader should finish this paragraph and understand the one thing that matters most in this read. Plain English \u2014 no system jargon.",
-  "move": "1-3 direct imperatives, OR explicit 'nothing to act on' if the read is healthy. Do not fabricate urgency. Examples: 'Force cross-module ownership this sprint.' / 'Nothing's broken. Keep shipping.' / 'If you want future reads to track this pattern by name, add a line to your strategy file.'"
+  "move": "1-3 direct imperatives, OR explicit 'nothing to act on' if the read is healthy. Do not fabricate urgency. When a candidate pattern has high confidence (>0.6), tell the reader EXACTLY where to declare it: 'If you want Radiant to track [pattern_name] over time, add it to auki-strategy.worldmodel.md under Evolution Layer \u2192 Drift Behaviors (or Aligned Behaviors if it is positive). If you don't, Radiant will rediscover it from scratch next run.' Be specific about the file and section \u2014 don't make them guess."
 }
 \`\`\`
 
@@ -1290,6 +2857,11 @@ function parseInterpretation(raw, canonicalNames) {
 function isPatternLike(x) {
   return typeof x === "object" && x !== null && "name" in x;
 }
+var init_patterns = __esm({
+  "src/radiant/core/patterns.ts"() {
+    "use strict";
+  }
+});
 
 // src/radiant/core/renderer.ts
 function render(input) {
@@ -1352,6 +2924,27 @@ Lens:   ${input.lens.name}`
     `  Composite:                 ${formatScore(input.scores.R)}`
   ].join("\n");
   sections.push(alignBlock);
+  if (input.governance && input.governance.totalEvents > 0) {
+    const gov = input.governance;
+    const govLines = ["GOVERNANCE", "", `  ${gov.summary}`];
+    const showSide = (label, side) => {
+      if (side.allow + side.modify + side.block === 0) return;
+      govLines.push("");
+      govLines.push(`  ${label}:`);
+      govLines.push(`    ${side.allow} ALLOW \xB7 ${side.modify} MODIFY \xB7 ${side.block} BLOCK`);
+      for (const d of side.details.slice(0, 3)) {
+        const reason = d.reason ? ` \u2192 ${d.reason}` : "";
+        govLines.push(`    ${d.status}: ${d.eventId}${reason}`);
+      }
+      if (side.details.length > 3) {
+        govLines.push(`    ... and ${side.details.length - 3} more`);
+      }
+    };
+    showSide("Human side", gov.human);
+    showSide("AI side", gov.cyber);
+    showSide("Human\u2013AI joint", gov.joint);
+    sections.push(govLines.join("\n"));
+  }
   sections.push(renderDepth(input.priorReadCount ?? 0, input.windowDays));
   return sections.join("\n\n");
 }
@@ -1514,6 +3107,13 @@ function serializeYAML(obj, indent = 0) {
   return `${obj}
 `;
 }
+var init_renderer = __esm({
+  "src/radiant/core/renderer.ts"() {
+    "use strict";
+    init_types();
+    init_scopes();
+  }
+});
 
 // src/radiant/commands/emergent.ts
 async function emergent(input) {
@@ -1521,10 +3121,15 @@ async function emergent(input) {
   const windowDays = input.windowDays ?? 14;
   let statedIntent;
   let exocortexContext;
+  let priorReadContext = "";
   if (input.exocortexPath) {
     exocortexContext = readExocortex(input.exocortexPath);
     const formatted = formatExocortexForPrompt(exocortexContext);
     if (formatted) statedIntent = formatted;
+    const priorReads = loadPriorReads(input.exocortexPath);
+    if (priorReads.length > 0) {
+      priorReadContext = formatPriorReadsForPrompt(priorReads);
+    }
   }
   const events = await fetchGitHubActivity(input.scope, input.githubToken, {
     windowDays
@@ -1539,11 +3144,18 @@ async function emergent(input) {
     lens,
     ai: input.ai,
     canonicalPatterns: input.canonicalPatterns,
-    statedIntent
+    statedIntent: statedIntent ? statedIntent + (priorReadContext ? "\n\n" + priorReadContext : "") : priorReadContext || void 0
   });
   const rewrittenPatterns = patterns.map((p) => lens.rewrite(p));
   const allDescriptions = rewrittenPatterns.map((p) => p.description).join("\n");
   const voiceViolations = checkForbiddenPhrases(lens, allDescriptions);
+  let governance;
+  if (input.worldPath) {
+    try {
+      governance = await auditGovernance(classified, input.worldPath);
+    } catch {
+    }
+  }
   const rendered = render({
     scope: input.scope,
     windowDays,
@@ -1553,8 +3165,27 @@ async function emergent(input) {
     scores,
     lens,
     meaning: meaning || void 0,
-    move: move || void 0
+    move: move || void 0,
+    governance
   });
+  if (input.exocortexPath) {
+    try {
+      const readPath = writeRead(input.exocortexPath, rendered.frontmatter, rendered.text);
+      const priorReads = loadPriorReads(input.exocortexPath);
+      const currentPatternNames = rewrittenPatterns.map((p) => p.name);
+      const persistence = computePersistence(priorReads, currentPatternNames);
+      const triggeredItems = governance ? [
+        ...governance.human.details.map((d) => d.ruleId).filter(Boolean),
+        ...governance.cyber.details.map((d) => d.ruleId).filter(Boolean),
+        ...governance.joint.details.map((d) => d.ruleId).filter(Boolean)
+      ] : [];
+      updateKnowledge(input.exocortexPath, persistence, {
+        triggeredItems,
+        totalReads: priorReads.length + 1
+      });
+    } catch {
+    }
+  }
   return {
     text: rendered.text,
     frontmatter: rendered.frontmatter,
@@ -1612,6 +3243,22 @@ function resolveLens2(id) {
   }
   return lens;
 }
+var init_emergent = __esm({
+  "src/radiant/commands/emergent.ts"() {
+    "use strict";
+    init_lenses();
+    init_github();
+    init_exocortex();
+    init_palace();
+    init_governance();
+    init_signals();
+    init_math();
+    init_patterns();
+    init_renderer();
+    init_voice_check();
+    init_types();
+  }
+});
 
 // src/radiant/core/ai.ts
 function createAnthropicAI(apiKey, model = "claude-sonnet-4-20250514", maxTokens = 4096) {
@@ -1646,8 +3293,296 @@ function createAnthropicAI(apiKey, model = "claude-sonnet-4-20250514", maxTokens
     }
   };
 }
+var init_ai = __esm({
+  "src/radiant/core/ai.ts"() {
+    "use strict";
+  }
+});
+
+// src/radiant/mcp/server.ts
+var server_exports = {};
+__export(server_exports, {
+  RadiantMcpServer: () => RadiantMcpServer,
+  startRadiantMcp: () => startRadiantMcp
+});
+function loadWorldmodelContent(worldsPath) {
+  const resolved = (0, import_path3.resolve)(worldsPath);
+  if (!(0, import_fs3.existsSync)(resolved)) {
+    throw new Error(`Worlds path not found: ${resolved}`);
+  }
+  const stat = (0, import_fs3.statSync)(resolved);
+  if (stat.isFile()) {
+    return (0, import_fs3.readFileSync)(resolved, "utf-8");
+  }
+  if (stat.isDirectory()) {
+    const files = (0, import_fs3.readdirSync)(resolved).filter(
+      (f) => (0, import_path3.extname)(f) === ".md" && (f.endsWith(".worldmodel.md") || f.endsWith(".nv-world.md"))
+    ).sort();
+    if (files.length === 0) {
+      throw new Error(`No worldmodel files found in ${resolved}`);
+    }
+    return files.map((f) => (0, import_fs3.readFileSync)((0, import_path3.join)(resolved, f), "utf-8")).join("\n\n---\n\n");
+  }
+  throw new Error(`Worlds path is neither a file nor directory: ${resolved}`);
+}
+async function startRadiantMcp(args) {
+  function parseArg(flag) {
+    const idx = args.indexOf(flag);
+    return idx >= 0 && idx + 1 < args.length ? args[idx + 1] : void 0;
+  }
+  const worldsPath = parseArg("--worlds") ?? process.env.RADIANT_WORLDS;
+  const lensId = parseArg("--lens") ?? process.env.RADIANT_LENS ?? "auki-builder";
+  const model = parseArg("--model") ?? process.env.RADIANT_MODEL;
+  if (!worldsPath) {
+    process.stderr.write("Error: --worlds <dir> or RADIANT_WORLDS required.\n");
+    process.exit(1);
+  }
+  const server = new RadiantMcpServer({ worldsPath, lensId, model });
+  await server.start();
+}
+var import_fs3, import_path3, TOOLS, RadiantMcpServer;
+var init_server = __esm({
+  "src/radiant/mcp/server.ts"() {
+    "use strict";
+    import_fs3 = require("fs");
+    import_path3 = require("path");
+    init_think();
+    init_emergent();
+    init_ai();
+    init_scopes();
+    TOOLS = [
+      {
+        name: "radiant_think",
+        description: "Send a query through the loaded worldmodel + rendering lens and get an Auki-framed response. Use this for strategic questions, decision evaluation, or any question that should be interpreted through the organization's behavioral model.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            query: {
+              type: "string",
+              description: "The question or prompt to interpret through the worldmodel + lens."
+            }
+          },
+          required: ["query"]
+        }
+      },
+      {
+        name: "radiant_emergent",
+        description: "Run a behavioral read on a GitHub repository. Fetches recent activity, classifies events, extracts signals, identifies patterns, computes alignment scores, and produces the EMERGENT / MEANING / MOVE / ALIGNMENT output. Use this when asked about team activity, coordination patterns, or alignment with the worldmodel.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            scope: {
+              type: "string",
+              description: 'GitHub repository in "owner/repo" format (e.g. "aukiverse/posemesh").'
+            },
+            exocortex_dir: {
+              type: "string",
+              description: "Optional path to an exocortex directory for stated-intent-vs-observed-behavior comparison."
+            }
+          },
+          required: ["scope"]
+        }
+      }
+    ];
+    RadiantMcpServer = class {
+      config;
+      worldmodelContent;
+      buffer = "";
+      constructor(config) {
+        this.config = config;
+        this.worldmodelContent = loadWorldmodelContent(config.worldsPath);
+      }
+      async start() {
+        process.stderr.write(
+          `Radiant MCP server starting
+  Worlds: ${this.config.worldsPath}
+  Lens:   ${this.config.lensId}
+  Tools:  radiant_think, radiant_emergent
+`
+        );
+        process.stdin.setEncoding("utf-8");
+        process.stdin.on("data", (chunk) => {
+          this.buffer += chunk;
+          this.processBuffer();
+        });
+        process.stdin.on("end", () => {
+          process.exit(0);
+        });
+      }
+      processBuffer() {
+        const lines = this.buffer.split("\n");
+        this.buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed) continue;
+          try {
+            const request = JSON.parse(trimmed);
+            this.handleRequest(request).catch((err) => {
+              this.sendError(request.id, -32603, String(err));
+            });
+          } catch {
+          }
+        }
+      }
+      async handleRequest(req) {
+        switch (req.method) {
+          case "initialize":
+            this.sendResult(req.id, {
+              protocolVersion: "2024-11-05",
+              capabilities: { tools: {} },
+              serverInfo: {
+                name: "radiant",
+                version: "0.6.1"
+              }
+            });
+            break;
+          case "notifications/initialized":
+            break;
+          case "tools/list":
+            this.sendResult(req.id, { tools: TOOLS });
+            break;
+          case "tools/call":
+            await this.handleToolCall(req);
+            break;
+          default:
+            this.sendError(req.id, -32601, `Unknown method: ${req.method}`);
+        }
+      }
+      async handleToolCall(req) {
+        const params = req.params;
+        if (!params?.name) {
+          this.sendError(req.id, -32602, "Missing tool name");
+          return;
+        }
+        const args = params.arguments ?? {};
+        try {
+          switch (params.name) {
+            case "radiant_think":
+              await this.handleThink(req.id, args);
+              break;
+            case "radiant_emergent":
+              await this.handleEmergent(req.id, args);
+              break;
+            default:
+              this.sendError(req.id, -32602, `Unknown tool: ${params.name}`);
+          }
+        } catch (err) {
+          this.sendResult(req.id, {
+            content: [{ type: "text", text: `Error: ${err}` }],
+            isError: true
+          });
+        }
+      }
+      async handleThink(id, args) {
+        const query = String(args.query ?? "");
+        if (!query) {
+          this.sendResult(id, {
+            content: [{ type: "text", text: "Error: query is required" }],
+            isError: true
+          });
+          return;
+        }
+        const apiKey = process.env.ANTHROPIC_API_KEY;
+        if (!apiKey) {
+          this.sendResult(id, {
+            content: [{ type: "text", text: "Error: ANTHROPIC_API_KEY not set" }],
+            isError: true
+          });
+          return;
+        }
+        const ai = createAnthropicAI(apiKey, this.config.model || void 0);
+        const result = await think({
+          worldmodelContent: this.worldmodelContent,
+          lensId: this.config.lensId,
+          query,
+          ai
+        });
+        let text = result.response;
+        if (!result.voiceClean) {
+          text += `
+
+\u26A0 Voice violations detected: ${result.voiceViolations.map((v) => v.phrase).join(", ")}`;
+        }
+        this.sendResult(id, {
+          content: [{ type: "text", text }]
+        });
+      }
+      async handleEmergent(id, args) {
+        const scopeStr = String(args.scope ?? "");
+        if (!scopeStr) {
+          this.sendResult(id, {
+            content: [{ type: "text", text: 'Error: scope is required (e.g. "aukiverse/posemesh")' }],
+            isError: true
+          });
+          return;
+        }
+        const apiKey = process.env.ANTHROPIC_API_KEY;
+        const githubToken = process.env.GITHUB_TOKEN;
+        if (!apiKey) {
+          this.sendResult(id, {
+            content: [{ type: "text", text: "Error: ANTHROPIC_API_KEY not set" }],
+            isError: true
+          });
+          return;
+        }
+        if (!githubToken) {
+          this.sendResult(id, {
+            content: [{ type: "text", text: "Error: GITHUB_TOKEN not set" }],
+            isError: true
+          });
+          return;
+        }
+        const scope = parseRepoScope(scopeStr);
+        const ai = createAnthropicAI(apiKey, this.config.model || void 0);
+        const exocortexPath = args.exocortex_dir ? String(args.exocortex_dir) : void 0;
+        const result = await emergent({
+          scope,
+          githubToken,
+          worldmodelContent: this.worldmodelContent,
+          lensId: this.config.lensId,
+          ai,
+          windowDays: 14,
+          exocortexPath
+        });
+        let text = result.text;
+        if (!result.voiceClean) {
+          text += `
+
+\u26A0 Voice violations: ${result.voiceViolations.map((v) => v.phrase).join(", ")}`;
+        }
+        this.sendResult(id, {
+          content: [{ type: "text", text }]
+        });
+      }
+      sendResult(id, result) {
+        const response = { jsonrpc: "2.0", id, result };
+        process.stdout.write(JSON.stringify(response) + "\n");
+      }
+      sendError(id, code, message) {
+        const response = {
+          jsonrpc: "2.0",
+          id: id ?? null,
+          error: { code, message }
+        };
+        process.stdout.write(JSON.stringify(response) + "\n");
+      }
+    };
+  }
+});
 
 // src/cli/radiant.ts
+var radiant_exports = {};
+__export(radiant_exports, {
+  main: () => main
+});
+module.exports = __toCommonJS(radiant_exports);
+var import_fs4 = require("fs");
+var import_path4 = require("path");
+init_think();
+init_emergent();
+init_ai();
+init_scopes();
+init_exocortex();
 init_lenses();
 var RED = "\x1B[31m";
 var DIM = "\x1B[2m";
@@ -1731,18 +3666,18 @@ function parseArgs(argv) {
   }
   return result;
 }
-function loadWorldmodelContent(worldsPath) {
-  const resolved = (0, import_path2.resolve)(worldsPath);
-  if (!(0, import_fs2.existsSync)(resolved)) {
+function loadWorldmodelContent2(worldsPath) {
+  const resolved = (0, import_path4.resolve)(worldsPath);
+  if (!(0, import_fs4.existsSync)(resolved)) {
     throw new Error(`Worlds path not found: ${resolved}`);
   }
-  const stat = (0, import_fs2.statSync)(resolved);
+  const stat = (0, import_fs4.statSync)(resolved);
   if (stat.isFile()) {
-    return (0, import_fs2.readFileSync)(resolved, "utf-8");
+    return (0, import_fs4.readFileSync)(resolved, "utf-8");
   }
   if (stat.isDirectory()) {
-    const files = (0, import_fs2.readdirSync)(resolved).filter(
-      (f) => (0, import_path2.extname)(f) === ".md" && (f.endsWith(".worldmodel.md") || f.endsWith(".nv-world.md"))
+    const files = (0, import_fs4.readdirSync)(resolved).filter(
+      (f) => (0, import_path4.extname)(f) === ".md" && (f.endsWith(".worldmodel.md") || f.endsWith(".nv-world.md"))
     ).sort();
     if (files.length === 0) {
       throw new Error(
@@ -1750,7 +3685,7 @@ function loadWorldmodelContent(worldsPath) {
       );
     }
     return files.map((f) => {
-      const content = (0, import_fs2.readFileSync)((0, import_path2.join)(resolved, f), "utf-8");
+      const content = (0, import_fs4.readFileSync)((0, import_path4.join)(resolved, f), "utf-8");
       return `<!-- worldmodel: ${f} -->
 ${content}`;
     }).join("\n\n---\n\n");
@@ -1789,7 +3724,7 @@ ${DIM}Set it to your Anthropic API key to use Radiant's AI features.${RESET}
     query = args.rest.join(" ");
   }
   if (!query && !process.stdin.isTTY) {
-    query = (0, import_fs2.readFileSync)(0, "utf-8").trim();
+    query = (0, import_fs4.readFileSync)(0, "utf-8").trim();
   }
   if (!query) {
     process.stderr.write(
@@ -1799,7 +3734,7 @@ ${DIM}Use --query "...", pass as trailing args, or pipe via stdin.${RESET}
     );
     process.exit(1);
   }
-  const worldmodelContent = loadWorldmodelContent(worldsPath);
+  const worldmodelContent = loadWorldmodelContent2(worldsPath);
   const model = args.model ?? process.env.RADIANT_MODEL;
   const ai = createAnthropicAI(apiKey, model || void 0);
   process.stderr.write(
@@ -1892,7 +3827,7 @@ ${DIM}Set it to a GitHub PAT with repo read access.${RESET}
     );
     process.exit(1);
   }
-  const worldmodelContent = loadWorldmodelContent(worldsPath);
+  const worldmodelContent = loadWorldmodelContent2(worldsPath);
   const model = args.model ?? process.env.RADIANT_MODEL;
   const ai = createAnthropicAI(anthropicKey, model || void 0);
   const exocortexPath = args.exocortex ?? process.env.RADIANT_EXOCORTEX;
@@ -2032,6 +3967,10 @@ async function main(argv) {
       return cmdLenses(args);
     case "emergent":
       return cmdEmergent(args);
+    case "mcp": {
+      const { startRadiantMcp: startRadiantMcp2 } = await Promise.resolve().then(() => (init_server(), server_exports));
+      return startRadiantMcp2(argv);
+    }
     case "decision":
     case "signals":
     case "drift":