@neuroverseos/governance 0.3.4 → 0.4.1

package/dist/adapters/mentraos.cjs

@@ -0,0 +1,2181 @@
+"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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/adapters/mentraos.ts
+var mentraos_exports = {};
+__export(mentraos_exports, {
+  DEFAULT_USER_RULES: () => DEFAULT_USER_RULES,
+  GovernanceBlockedError: () => GovernanceBlockedError,
+  MENTRA_INTENT_MAP: () => MENTRA_INTENT_MAP,
+  MENTRA_INTENT_TAXONOMY: () => MENTRA_INTENT_TAXONOMY,
+  MENTRA_KNOWN_INTENTS: () => MENTRA_KNOWN_INTENTS,
+  MentraGovernedExecutor: () => MentraGovernedExecutor,
+  createMentraGovernedExecutor: () => createMentraGovernedExecutor,
+  createMentraGovernedExecutorFromWorld: () => createMentraGovernedExecutorFromWorld,
+  evaluateUserRules: () => evaluateUserRules,
+  getAIActionIntents: () => getAIActionIntents,
+  getAIDataIntents: () => getAIDataIntents,
+  getAIIntents: () => getAIIntents,
+  getExfiltrationIntents: () => getExfiltrationIntents,
+  getHighRiskIntents: () => getHighRiskIntents,
+  getIntentsByGlasses: () => getIntentsByGlasses,
+  getIntentsByPermission: () => getIntentsByPermission,
+  getMentraIntent: () => getMentraIntent,
+  isAIIntent: () => isAIIntent,
+  isIntentSupported: () => isIntentSupported
+});
+module.exports = __toCommonJS(mentraos_exports);
+
+// 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;
+}
+
+// src/engine/plan-engine.ts
+function keywordMatch(eventText, step) {
+  const stepText = [
+    step.label,
+    step.description ?? "",
+    ...step.tags ?? []
+  ].join(" ");
+  return matchesKeywordThreshold(eventText, stepText, 0.5);
+}
+function tokenSimilarity2(a, b) {
+  return tokenSimilarity(a, b);
+}
+function findMatchingStep(eventText, event, steps) {
+  const pendingOrActive = steps.filter((s) => s.status === "pending" || s.status === "active");
+  if (pendingOrActive.length === 0) {
+    return { matched: null, closest: null, closestScore: 0 };
+  }
+  for (const step of pendingOrActive) {
+    if (keywordMatch(eventText, step)) {
+      if (step.tools && event.tool && !step.tools.includes(event.tool)) {
+        continue;
+      }
+      return { matched: step, closest: step, closestScore: 1 };
+    }
+  }
+  const intentText = [event.intent, event.tool ?? "", event.scope ?? ""].join(" ");
+  let bestStep = null;
+  let bestScore = 0;
+  for (const step of pendingOrActive) {
+    const stepText = [step.label, step.description ?? "", ...step.tags ?? []].join(" ");
+    const score = tokenSimilarity2(intentText, stepText);
+    if (score > bestScore) {
+      bestScore = score;
+      bestStep = step;
+    }
+  }
+  const SIMILARITY_THRESHOLD = 0.35;
+  if (bestScore >= SIMILARITY_THRESHOLD && bestStep) {
+    if (bestStep.tools && event.tool && !bestStep.tools.includes(event.tool)) {
+      return { matched: null, closest: bestStep, closestScore: bestScore };
+    }
+    return { matched: bestStep, closest: bestStep, closestScore: bestScore };
+  }
+  return { matched: null, closest: bestStep, closestScore: bestScore };
+}
+function isSequenceValid(step, plan) {
+  if (!plan.sequential) return true;
+  if (!step.requires || step.requires.length === 0) return true;
+  return step.requires.every((reqId) => {
+    const reqStep = plan.steps.find((s) => s.id === reqId);
+    return reqStep?.status === "completed";
+  });
+}
+function checkConstraints(event, eventText, constraints) {
+  const checks = [];
+  for (const constraint of constraints) {
+    if (constraint.type === "approval") {
+      if (constraint.trigger && eventText.includes(constraint.trigger.substring(0, 10).toLowerCase())) {
+        checks.push({ constraintId: constraint.id, passed: false, reason: constraint.description });
+        return { violated: constraint, checks };
+      }
+      const keywords = constraint.description.toLowerCase().split(/\s+/).filter((w) => w.length > 3);
+      const relevant = keywords.some((kw) => eventText.includes(kw));
+      if (relevant) {
+        checks.push({ constraintId: constraint.id, passed: false, reason: constraint.description });
+        return { violated: constraint, checks };
+      }
+      checks.push({ constraintId: constraint.id, passed: true });
+      continue;
+    }
+    if (constraint.type === "scope" && constraint.trigger) {
+      const keywords = extractKeywords(constraint.trigger);
+      const violated = keywords.length > 0 && keywords.every((kw) => eventText.includes(kw));
+      checks.push({
+        constraintId: constraint.id,
+        passed: !violated,
+        reason: violated ? constraint.description : void 0
+      });
+      if (violated) {
+        return { violated: constraint, checks };
+      }
+      continue;
+    }
+    checks.push({ constraintId: constraint.id, passed: true });
+  }
+  return { violated: null, checks };
+}
+function getPlanProgress(plan) {
+  const completed = plan.steps.filter((s) => s.status === "completed").length;
+  const total = plan.steps.length;
+  return {
+    completed,
+    total,
+    percentage: total > 0 ? Math.round(completed / total * 100) : 0
+  };
+}
+function advancePlan(plan, stepId, evidence) {
+  const step = plan.steps.find((s) => s.id === stepId);
+  if (!step) {
+    return { success: false, reason: `Step "${stepId}" not found in plan.` };
+  }
+  if (step.status === "completed") {
+    return { success: false, reason: `Step "${stepId}" is already completed.` };
+  }
+  const mode = plan.completion ?? "trust";
+  if (mode === "verified" && step.verify) {
+    if (!evidence) {
+      return {
+        success: false,
+        reason: `Step "${step.label}" requires evidence (verify: ${step.verify}). Provide evidence to advance.`
+      };
+    }
+    if (evidence.type !== step.verify) {
+      return {
+        success: false,
+        reason: `Evidence type "${evidence.type}" does not match required verification "${step.verify}".`
+      };
+    }
+  }
+  const updatedPlan = {
+    ...plan,
+    steps: plan.steps.map(
+      (s) => s.id === stepId ? { ...s, status: "completed" } : s
+    )
+  };
+  return {
+    success: true,
+    plan: updatedPlan,
+    evidence: evidence ?? void 0
+  };
+}
+function evaluatePlan(event, plan) {
+  const progress = getPlanProgress(plan);
+  if (plan.expires_at) {
+    const expiresAt = new Date(plan.expires_at).getTime();
+    if (Date.now() > expiresAt) {
+      return {
+        allowed: true,
+        status: "PLAN_COMPLETE",
+        reason: "Plan has expired.",
+        progress
+      };
+    }
+  }
+  if (progress.completed === progress.total) {
+    return {
+      allowed: true,
+      status: "PLAN_COMPLETE",
+      reason: "All plan steps are completed.",
+      progress
+    };
+  }
+  const eventText = normalizeEventText(event);
+  const { matched, closest, closestScore } = findMatchingStep(eventText, event, plan.steps);
+  if (!matched) {
+    return {
+      allowed: false,
+      status: "OFF_PLAN",
+      reason: "Action does not match any plan step.",
+      closestStep: closest?.label,
+      similarityScore: closestScore,
+      progress
+    };
+  }
+  if (!isSequenceValid(matched, plan)) {
+    const pendingDeps = (matched.requires ?? []).filter((reqId) => plan.steps.find((s) => s.id === reqId)?.status !== "completed").join(", ");
+    return {
+      allowed: false,
+      status: "OFF_PLAN",
+      reason: `Step "${matched.label}" requires completion of: ${pendingDeps}`,
+      matchedStep: matched.id,
+      progress
+    };
+  }
+  const { violated } = checkConstraints(event, eventText, plan.constraints);
+  if (violated) {
+    return {
+      allowed: false,
+      status: "CONSTRAINT_VIOLATED",
+      reason: violated.description,
+      matchedStep: matched.id,
+      progress
+    };
+  }
+  return {
+    allowed: true,
+    status: "ON_PLAN",
+    reason: `Matches step: ${matched.label}`,
+    matchedStep: matched.id,
+    progress
+  };
+}
+function buildPlanCheck(event, plan, verdict) {
+  const eventText = normalizeEventText(event);
+  const { matched, closest, closestScore } = findMatchingStep(eventText, event, plan.steps);
+  const { checks: constraintChecks } = checkConstraints(event, eventText, plan.constraints);
+  const progress = getPlanProgress(plan);
+  return {
+    planId: plan.plan_id,
+    matched: !!matched,
+    matchedStepId: matched?.id,
+    matchedStepLabel: matched?.label,
+    closestStepId: !matched ? closest?.id : void 0,
+    closestStepLabel: !matched ? closest?.label : void 0,
+    similarityScore: !matched ? closestScore : void 0,
+    sequenceValid: matched ? isSequenceValid(matched, plan) : void 0,
+    constraintsChecked: constraintChecks,
+    progress: { completed: progress.completed, total: progress.total }
+  };
+}
+
+// src/engine/guard-engine.ts
+var 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" }
+];
+var 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" }
+];
+var 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" }
+];
+var 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" }
+];
+var 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."
+};
+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));
+}
+var MAX_INPUT_LENGTH = 1e5;
+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
+  };
+}
+
+// src/loader/world-loader.ts
+async function loadWorldFromDirectory(dirPath) {
+  const { readFile } = await import("fs/promises");
+  const { join } = await import("path");
+  const { readdirSync } = await import("fs");
+  async function readJson(filename) {
+    const filePath = join(dirPath, filename);
+    try {
+      const content = await readFile(filePath, "utf-8");
+      return JSON.parse(content);
+    } catch (err) {
+      if (err instanceof Error && "code" in err && err.code === "ENOENT") {
+        return void 0;
+      }
+      process.stderr.write(
+        `[neuroverse] Warning: Failed to read ${filename}: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+      return void 0;
+    }
+  }
+  const worldJson = await readJson("world.json");
+  if (!worldJson) {
+    throw new Error(`Cannot read world.json in ${dirPath}`);
+  }
+  const invariantsJson = await readJson("invariants.json");
+  const assumptionsJson = await readJson("assumptions.json");
+  const stateSchemaJson = await readJson("state-schema.json");
+  const gatesJson = await readJson("gates.json");
+  const outcomesJson = await readJson("outcomes.json");
+  const guardsJson = await readJson("guards.json");
+  const rolesJson = await readJson("roles.json");
+  const kernelJson = await readJson("kernel.json");
+  const metadataJson = await readJson("metadata.json");
+  const rules = [];
+  try {
+    const rulesDir = join(dirPath, "rules");
+    const ruleFiles = readdirSync(rulesDir).filter((f) => f.endsWith(".json")).sort();
+    for (const file of ruleFiles) {
+      try {
+        const content = await readFile(join(rulesDir, file), "utf-8");
+        rules.push(JSON.parse(content));
+      } catch (err) {
+        process.stderr.write(
+          `[neuroverse] Warning: Failed to parse rule ${file}: ${err instanceof Error ? err.message : String(err)}
+`
+        );
+      }
+    }
+  } catch (err) {
+    if (!(err instanceof Error && "code" in err && err.code === "ENOENT")) {
+      process.stderr.write(
+        `[neuroverse] Warning: Failed to read rules directory: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+    }
+  }
+  return {
+    world: worldJson,
+    invariants: invariantsJson?.invariants ?? [],
+    assumptions: assumptionsJson ?? { profiles: {}, parameter_definitions: {} },
+    stateSchema: stateSchemaJson ?? { variables: {}, presets: {} },
+    rules,
+    gates: gatesJson ?? {
+      viability_classification: [],
+      structural_override: { description: "", enforcement: "mandatory" },
+      sustainability_threshold: 0,
+      collapse_visual: { background: "", text: "", border: "", label: "" }
+    },
+    outcomes: outcomesJson ?? {
+      computed_outcomes: [],
+      comparison_layout: { primary_card: "", status_badge: "", structural_indicators: [] }
+    },
+    guards: guardsJson,
+    roles: rolesJson,
+    kernel: kernelJson,
+    metadata: metadataJson ?? {
+      format_version: "1.0.0",
+      created_at: "",
+      last_modified: "",
+      authoring_method: "manual-authoring"
+    }
+  };
+}
+async function loadWorld(worldPath) {
+  const { stat } = await import("fs/promises");
+  const info = await stat(worldPath);
+  if (info.isDirectory()) {
+    return loadWorldFromDirectory(worldPath);
+  }
+  throw new Error(`Cannot load world from: ${worldPath} \u2014 expected a directory`);
+}
+
+// src/adapters/shared.ts
+var GovernanceBlockedError = class extends Error {
+  verdict;
+  constructor(verdict, message) {
+    super(message ?? `[NeuroVerse] BLOCKED: ${verdict.reason ?? verdict.ruleId ?? "governance rule"}`);
+    this.name = "GovernanceBlockedError";
+    this.verdict = verdict;
+  }
+};
+function trackPlanProgress(event, state, callbacks) {
+  if (!state.activePlan) return;
+  const planVerdict = evaluatePlan(event, state.activePlan);
+  if (planVerdict.matchedStep) {
+    const advResult = advancePlan(state.activePlan, planVerdict.matchedStep);
+    if (advResult.success && advResult.plan) {
+      state.activePlan = advResult.plan;
+      state.engineOptions.plan = state.activePlan;
+    }
+    const progress = getPlanProgress(state.activePlan);
+    callbacks.onPlanProgress?.(progress);
+    if (progress.completed === progress.total) {
+      callbacks.onPlanComplete?.();
+    }
+  }
+}
+function buildEngineOptions(options, plan) {
+  return {
+    trace: options.trace ?? false,
+    level: options.level,
+    plan: plan ?? options.plan
+  };
+}
+
+// src/worlds/mentraos-intent-taxonomy.ts
+var MENTRA_INTENT_TAXONOMY = [
+  // ── Camera Domain ───────────────────────────────────────────────────────
+  {
+    intent: "camera_photo_capture",
+    description: "Capture a single photo from the glasses camera",
+    sdk_method: "session.camera.requestPhoto()",
+    permission: "CAMERA",
+    domain: "camera",
+    supported_glasses: ["mentra_live"],
+    action_category: "write",
+    base_risk: "high",
+    exfiltration_risk: true,
+    reversible: false
+  },
+  {
+    intent: "camera_stream_start",
+    description: "Start a managed video stream (HLS) from the glasses camera",
+    sdk_method: "session.camera.startManagedStream()",
+    permission: "CAMERA",
+    domain: "camera",
+    supported_glasses: ["mentra_live"],
+    action_category: "write",
+    base_risk: "critical",
+    exfiltration_risk: true,
+    reversible: true
+  },
+  {
+    intent: "camera_stream_stop",
+    description: "Stop an active camera stream",
+    sdk_method: "session.camera.stopStream()",
+    permission: "CAMERA",
+    domain: "camera",
+    supported_glasses: ["mentra_live"],
+    action_category: "write",
+    base_risk: "low",
+    exfiltration_risk: false,
+    reversible: false
+  },
+  {
+    intent: "camera_restream_start",
+    description: "Restream camera feed to an external RTMP destination (e.g., social media)",
+    sdk_method: "session.camera.startRestream()",
+    permission: "CAMERA",
+    domain: "camera",
+    supported_glasses: ["mentra_live"],
+    action_category: "network",
+    base_risk: "critical",
+    exfiltration_risk: true,
+    reversible: true
+  },
+  // ── Microphone Domain ──────────────────────────────────────────────────
+  {
+    intent: "microphone_transcription_start",
+    description: "Start receiving speech-to-text transcription events",
+    sdk_method: "session.events.onTranscription()",
+    permission: "MICROPHONE",
+    domain: "microphone",
+    supported_glasses: ["even_realities_g1", "mentra_live"],
+    action_category: "read",
+    base_risk: "medium",
+    exfiltration_risk: true,
+    reversible: true
+  },
+  {
+    intent: "microphone_translation_start",
+    description: "Start receiving translation events from spoken audio",
+    sdk_method: "session.events.onTranslation()",
+    permission: "MICROPHONE",
+    domain: "microphone",
+    supported_glasses: ["even_realities_g1", "mentra_live"],
+    action_category: "read",
+    base_risk: "medium",
+    exfiltration_risk: true,
+    reversible: true
+  },
+  {
+    intent: "microphone_phone_passthrough",
+    description: "Use phone microphone as audio input (glasses without built-in mic)",
+    sdk_method: "session.audio.startPhoneMic()",
+    permission: "MICROPHONE",
+    domain: "microphone",
+    supported_glasses: ["mentra_mach1", "vuzix_z100"],
+    action_category: "read",
+    base_risk: "medium",
+    exfiltration_risk: true,
+    reversible: true
+  },
+  // ── Display Domain ────────────────────────────────────────────────────
+  {
+    intent: "display_text_wall",
+    description: "Show a single text block on the glasses display",
+    sdk_method: "session.layouts.showTextWall()",
+    permission: "NONE",
+    domain: "display",
+    supported_glasses: ["even_realities_g1", "mentra_mach1", "vuzix_z100"],
+    action_category: "write",
+    base_risk: "low",
+    exfiltration_risk: false,
+    reversible: true
+  },
+  {
+    intent: "display_double_text_wall",
+    description: "Show two text blocks (top/bottom) on the glasses display",
+    sdk_method: "session.layouts.showDoubleTextWall()",
+    permission: "NONE",
+    domain: "display",
+    supported_glasses: ["even_realities_g1", "mentra_mach1", "vuzix_z100"],
+    action_category: "write",
+    base_risk: "low",
+    exfiltration_risk: false,
+    reversible: true
+  },
+  {
+    intent: "display_reference_card",
+    description: "Show a reference card layout with structured content",
+    sdk_method: "session.layouts.showReferenceCard()",
+    permission: "NONE",
+    domain: "display",
+    supported_glasses: ["even_realities_g1"],
+    action_category: "write",
+    base_risk: "low",
+    exfiltration_risk: false,
+    reversible: true
+  },
+  {
+    intent: "display_dashboard_card",
+    description: "Show a dashboard card layout",
+    sdk_method: "session.layouts.showDashboardCard()",
+    permission: "NONE",
+    domain: "display",
+    supported_glasses: ["even_realities_g1"],
+    action_category: "write",
+    base_risk: "low",
+    exfiltration_risk: false,
+    reversible: true
+  },
+  {
+    intent: "display_image",
+    description: "Display an image on the glasses",
+    sdk_method: "session.layouts.showImage()",
+    permission: "NONE",
+    domain: "display",
+    supported_glasses: ["even_realities_g1"],
+    action_category: "write",
+    base_risk: "low",
+    exfiltration_risk: false,
+    reversible: true
+  },
+  // ── Dashboard Domain ──────────────────────────────────────────────────
+  {
+    intent: "dashboard_update_main",
+    description: "Update the persistent dashboard content (compact mode)",
+    sdk_method: "session.dashboard.content.setMain()",
+    permission: "NONE",
+    domain: "dashboard",
+    supported_glasses: ["even_realities_g1", "mentra_mach1", "vuzix_z100"],
+    action_category: "write",
+    base_risk: "low",
+    exfiltration_risk: false,
+    reversible: true
+  },
+  {
+    intent: "dashboard_update_expanded",
+    description: "Update the expanded dashboard content (user-opened mode)",
+    sdk_method: "session.dashboard.content.setExpanded()",
+    permission: "NONE",
+    domain: "dashboard",
+    supported_glasses: ["even_realities_g1", "mentra_mach1", "vuzix_z100"],
+    action_category: "write",
+    base_risk: "low",
+    exfiltration_risk: false,
+    reversible: true
+  },
+  // ── Location Domain ───────────────────────────────────────────────────
+  {
+    intent: "location_access",
+    description: "Access current location data from the paired phone",
+    sdk_method: "session.location.get()",
+    permission: "LOCATION",
+    domain: "location",
+    supported_glasses: ["even_realities_g1", "mentra_live", "mentra_mach1", "vuzix_z100"],
+    action_category: "read",
+    base_risk: "medium",
+    exfiltration_risk: true,
+    reversible: false
+  },
+  {
+    intent: "location_continuous_sharing",
+    description: "Start continuous location updates to the app server",
+    sdk_method: "session.location.startContinuous()",
+    permission: "LOCATION",
+    domain: "location",
+    supported_glasses: ["even_realities_g1", "mentra_live", "mentra_mach1", "vuzix_z100"],
+    action_category: "network",
+    base_risk: "high",
+    exfiltration_risk: true,
+    reversible: true
+  },
+  // ── Calendar & Notifications ──────────────────────────────────────────
+  {
+    intent: "calendar_read",
+    description: "Read calendar events from the paired phone",
+    sdk_method: "session.calendar.getEvents()",
+    permission: "CALENDAR",
+    domain: "calendar",
+    supported_glasses: ["even_realities_g1", "mentra_live", "mentra_mach1", "vuzix_z100"],
+    action_category: "read",
+    base_risk: "low",
+    exfiltration_risk: false,
+    reversible: true
+  },
+  {
+    intent: "notifications_read",
+    description: "Read phone notifications",
+    sdk_method: "session.notifications.getRecent()",
+    permission: "READ_NOTIFICATIONS",
+    domain: "notifications",
+    supported_glasses: ["even_realities_g1", "mentra_live", "mentra_mach1", "vuzix_z100"],
+    action_category: "read",
+    base_risk: "low",
+    exfiltration_risk: false,
+    reversible: true
+  },
+  // ── Audio Domain ──────────────────────────────────────────────────────
+  {
+    intent: "audio_play",
+    description: "Play audio through the glasses speaker",
+    sdk_method: "session.audio.play()",
+    permission: "NONE",
+    domain: "audio",
+    supported_glasses: ["mentra_live"],
+    action_category: "write",
+    base_risk: "low",
+    exfiltration_risk: false,
+    reversible: true
+  },
+  // ── Session Domain ────────────────────────────────────────────────────
+  {
+    intent: "session_data_export",
+    description: "Export session data to external storage or API",
+    sdk_method: "session.export()",
+    permission: "NONE",
+    domain: "session",
+    supported_glasses: ["even_realities_g1", "mentra_live", "mentra_mach1", "vuzix_z100"],
+    action_category: "network",
+    base_risk: "high",
+    exfiltration_risk: true,
+    reversible: false
+  },
+  // ── Tool Call Domain ──────────────────────────────────────────────────
+  {
+    intent: "tool_call_execute",
+    description: "Execute a custom tool call defined by the app via handleToolCall",
+    sdk_method: "AppServer.handleToolCall()",
+    permission: "NONE",
+    domain: "tool_call",
+    supported_glasses: ["even_realities_g1", "mentra_live", "mentra_mach1", "vuzix_z100"],
+    action_category: "other",
+    base_risk: "medium",
+    exfiltration_risk: false,
+    reversible: false
+  },
+  // ── AI Data Flow Domain ─────────────────────────────────────────────────
+  // These intents govern what user data apps send to their AI backends.
+  // They operate at the app server layer (not the glasses hardware layer),
+  // so they work on all glasses models and require no hardware permission.
+  {
+    intent: "ai_send_transcription",
+    description: "Send user speech transcription to an external AI API for processing",
+    sdk_method: "app_server.ai.sendTranscription()",
+    permission: "NONE",
+    domain: "ai_data",
+    supported_glasses: ["even_realities_g1", "mentra_live", "mentra_mach1", "vuzix_z100"],
+    action_category: "network",
+    base_risk: "medium",
+    exfiltration_risk: true,
+    reversible: false
+  },
+  {
+    intent: "ai_send_image",
+    description: "Send a camera-captured image to an external AI API for vision analysis",
+    sdk_method: "app_server.ai.sendImage()",
+    permission: "NONE",
+    domain: "ai_data",
+    supported_glasses: ["even_realities_g1", "mentra_live", "mentra_mach1", "vuzix_z100"],
+    action_category: "network",
+    base_risk: "high",
+    exfiltration_risk: true,
+    reversible: false
+  },
+  {
+    intent: "ai_send_location",
+    description: "Send user location data to an external AI API for context-aware processing",
+    sdk_method: "app_server.ai.sendLocation()",
+    permission: "NONE",
+    domain: "ai_data",
+    supported_glasses: ["even_realities_g1", "mentra_live", "mentra_mach1", "vuzix_z100"],
+    action_category: "network",
+    base_risk: "medium",
+    exfiltration_risk: true,
+    reversible: false
+  },
+  {
+    intent: "ai_send_calendar",
+    description: "Send user calendar data to an external AI API for scheduling assistance",
+    sdk_method: "app_server.ai.sendCalendar()",
+    permission: "NONE",
+    domain: "ai_data",
+    supported_glasses: ["even_realities_g1", "mentra_live", "mentra_mach1", "vuzix_z100"],
+    action_category: "network",
+    base_risk: "medium",
+    exfiltration_risk: true,
+    reversible: false
+  },
+  {
+    intent: "ai_send_notifications",
+    description: "Send user notification data to an external AI API for summarization or triage",
+    sdk_method: "app_server.ai.sendNotifications()",
+    permission: "NONE",
+    domain: "ai_data",
+    supported_glasses: ["even_realities_g1", "mentra_live", "mentra_mach1", "vuzix_z100"],
+    action_category: "network",
+    base_risk: "medium",
+    exfiltration_risk: true,
+    reversible: false
+  },
+  // ── AI Action Domain ──────────────────────────────────────────────────
+  // These intents govern actions AI takes on behalf of the user.
+  // Every action here must be shown on the glasses display before execution.
+  {
+    intent: "ai_auto_respond_message",
+    description: "AI generates and sends a message (email, SMS, chat) on the user's behalf",
+    sdk_method: "app_server.ai.sendMessage()",
+    permission: "NONE",
+    domain: "ai_action",
+    supported_glasses: ["even_realities_g1", "mentra_live", "mentra_mach1", "vuzix_z100"],
+    action_category: "network",
+    base_risk: "high",
+    exfiltration_risk: true,
+    reversible: false
+  },
+  {
+    intent: "ai_auto_purchase",
+    description: "AI initiates a financial transaction (purchase, subscription, tip) on the user's behalf",
+    sdk_method: "app_server.ai.purchase()",
+    permission: "NONE",
+    domain: "ai_action",
+    supported_glasses: ["even_realities_g1", "mentra_live", "mentra_mach1", "vuzix_z100"],
+    action_category: "network",
+    base_risk: "critical",
+    exfiltration_risk: true,
+    reversible: false
+  },
+  {
+    intent: "ai_auto_schedule",
+    description: "AI creates, modifies, or cancels a calendar event on the user's behalf",
+    sdk_method: "app_server.ai.schedule()",
+    permission: "NONE",
+    domain: "ai_action",
+    supported_glasses: ["even_realities_g1", "mentra_live", "mentra_mach1", "vuzix_z100"],
+    action_category: "write",
+    base_risk: "medium",
+    exfiltration_risk: false,
+    reversible: true
+  },
+  {
+    intent: "ai_auto_setting_change",
+    description: "AI changes a user setting or app configuration on the user's behalf",
+    sdk_method: "app_server.ai.changeSetting()",
+    permission: "NONE",
+    domain: "ai_action",
+    supported_glasses: ["even_realities_g1", "mentra_live", "mentra_mach1", "vuzix_z100"],
+    action_category: "write",
+    base_risk: "medium",
+    exfiltration_risk: false,
+    reversible: true
+  },
+  {
+    intent: "ai_retain_session_data",
+    description: "AI or app retains user session data (transcriptions, images, conversation) beyond session end",
+    sdk_method: "app_server.ai.retainData()",
+    permission: "NONE",
+    domain: "ai_data",
+    supported_glasses: ["even_realities_g1", "mentra_live", "mentra_mach1", "vuzix_z100"],
+    action_category: "write",
+    base_risk: "high",
+    exfiltration_risk: true,
+    reversible: false
+  },
+  {
+    intent: "ai_share_with_third_party",
+    description: "AI or app shares user data with a third-party service beyond the declared AI provider",
+    sdk_method: "app_server.ai.shareExternal()",
+    permission: "NONE",
+    domain: "ai_data",
+    supported_glasses: ["even_realities_g1", "mentra_live", "mentra_mach1", "vuzix_z100"],
+    action_category: "network",
+    base_risk: "critical",
+    exfiltration_risk: true,
+    reversible: false
+  }
+];
+var MENTRA_KNOWN_INTENTS = MENTRA_INTENT_TAXONOMY.map((d) => d.intent);
+var MENTRA_INTENT_MAP = new Map(MENTRA_INTENT_TAXONOMY.map((d) => [d.intent, d]));
+function getMentraIntent(intent) {
+  return MENTRA_INTENT_MAP.get(intent);
+}
+function getIntentsByPermission(permission) {
+  return MENTRA_INTENT_TAXONOMY.filter((d) => d.permission === permission);
+}
+function getIntentsByGlasses(model) {
+  return MENTRA_INTENT_TAXONOMY.filter((d) => d.supported_glasses.includes(model));
+}
+function isIntentSupported(intent, model) {
+  const def = MENTRA_INTENT_MAP.get(intent);
+  return def ? def.supported_glasses.includes(model) : false;
+}
+function getHighRiskIntents() {
+  return MENTRA_INTENT_TAXONOMY.filter((d) => d.base_risk === "high" || d.base_risk === "critical");
+}
+function getExfiltrationIntents() {
+  return MENTRA_INTENT_TAXONOMY.filter((d) => d.exfiltration_risk);
+}
+function getAIDataIntents() {
+  return MENTRA_INTENT_TAXONOMY.filter((d) => d.domain === "ai_data");
+}
+function getAIActionIntents() {
+  return MENTRA_INTENT_TAXONOMY.filter((d) => d.domain === "ai_action");
+}
+function getAIIntents() {
+  return MENTRA_INTENT_TAXONOMY.filter((d) => d.domain === "ai_data" || d.domain === "ai_action");
+}
+function isAIIntent(intent) {
+  const def = MENTRA_INTENT_MAP.get(intent);
+  return def ? def.domain === "ai_data" || def.domain === "ai_action" : false;
+}
+
+// src/adapters/mentraos.ts
+var DEFAULT_USER_RULES = {
+  aiDataPolicy: "declared_only",
+  aiActionPolicy: "confirm_all",
+  aiPurchasePolicy: "confirm_each",
+  aiMessagingPolicy: "confirm_each",
+  dataRetentionPolicy: "app_declared",
+  maxAIProviders: 5
+};
+function evaluateUserRules(intent, rules, appContext) {
+  const def = getMentraIntent(intent);
+  if (!def) return null;
+  if (def.domain === "ai_data" && intent !== "ai_retain_session_data") {
+    if (rules.aiDataPolicy === "block_all") {
+      return {
+        verdict: {
+          status: "BLOCK",
+          ruleId: "user-rule-ai-data-block",
+          reason: `User rules block all AI data sends. Intent: ${intent}`,
+          evidence: makeEvidence("user-rule-ai-data-block")
+        },
+        reason: "User has blocked all AI data sends"
+      };
+    }
+    if (rules.aiDataPolicy === "confirm_each") {
+      return {
+        verdict: {
+          status: "PAUSE",
+          ruleId: "user-rule-ai-data-confirm",
+          reason: `User rules require confirmation for every AI data send. Intent: ${intent}`,
+          evidence: makeEvidence("user-rule-ai-data-confirm")
+        },
+        reason: "User requires confirmation for each AI data send"
+      };
+    }
+    if (!appContext.aiProviderDeclared) {
+      return {
+        verdict: {
+          status: "BLOCK",
+          ruleId: "user-rule-undeclared-provider",
+          reason: `App "${appContext.appId}" has not declared its AI provider. User rules require declared providers only.`,
+          evidence: makeEvidence("user-rule-undeclared-provider")
+        },
+        reason: "App has not declared its AI provider"
+      };
+    }
+  }
+  if (intent === "ai_retain_session_data") {
+    if (rules.dataRetentionPolicy === "never") {
+      return {
+        verdict: {
+          status: "BLOCK",
+          ruleId: "user-rule-no-retention",
+          reason: `User rules block all data retention. App "${appContext.appId}" cannot retain session data.`,
+          evidence: makeEvidence("user-rule-no-retention")
+        },
+        reason: "User has blocked all data retention"
+      };
+    }
+    if (!appContext.dataRetentionOptedIn) {
+      return {
+        verdict: {
+          status: "BLOCK",
+          ruleId: "user-rule-retention-no-optin",
+          reason: `User has not opted in to data retention for app "${appContext.appId}".`,
+          evidence: makeEvidence("user-rule-retention-no-optin")
+        },
+        reason: "User has not opted in to data retention for this app"
+      };
+    }
+  }
+  if (intent === "ai_auto_purchase") {
+    if (rules.aiPurchasePolicy === "block_all") {
+      return {
+        verdict: {
+          status: "BLOCK",
+          ruleId: "user-rule-no-purchases",
+          reason: "User rules block all AI-initiated purchases.",
+          evidence: makeEvidence("user-rule-no-purchases")
+        },
+        reason: "User has blocked all AI purchases"
+      };
+    }
+    return {
+      verdict: {
+        status: "PAUSE",
+        ruleId: "user-rule-purchase-confirm",
+        reason: `AI wants to make a purchase. User rules require per-transaction confirmation.`,
+        evidence: makeEvidence("user-rule-purchase-confirm")
+      },
+      reason: "User requires per-transaction confirmation for AI purchases"
+    };
+  }
+  if (intent === "ai_auto_respond_message") {
+    if (rules.aiMessagingPolicy === "block_all") {
+      return {
+        verdict: {
+          status: "BLOCK",
+          ruleId: "user-rule-no-messaging",
+          reason: "User rules block all AI-initiated messaging.",
+          evidence: makeEvidence("user-rule-no-messaging")
+        },
+        reason: "User has blocked all AI messaging"
+      };
+    }
+    return {
+      verdict: {
+        status: "PAUSE",
+        ruleId: "user-rule-message-confirm",
+        reason: `AI wants to send a message on your behalf. User rules require per-message confirmation.`,
+        evidence: makeEvidence("user-rule-message-confirm")
+      },
+      reason: "User requires per-message confirmation for AI messaging"
+    };
+  }
+  if (def.domain === "ai_action" && intent !== "ai_auto_purchase" && intent !== "ai_auto_respond_message") {
+    if (rules.aiActionPolicy === "block_all") {
+      return {
+        verdict: {
+          status: "BLOCK",
+          ruleId: "user-rule-no-ai-actions",
+          reason: `User rules block all AI auto-actions. Intent: ${intent}`,
+          evidence: makeEvidence("user-rule-no-ai-actions")
+        },
+        reason: "User has blocked all AI auto-actions"
+      };
+    }
+    if (rules.aiActionPolicy === "confirm_all") {
+      return {
+        verdict: {
+          status: "PAUSE",
+          ruleId: "user-rule-action-confirm",
+          reason: `AI wants to take action: ${intent}. User rules require confirmation.`,
+          evidence: makeEvidence("user-rule-action-confirm")
+        },
+        reason: "User requires confirmation for all AI actions"
+      };
+    }
+    if (def.base_risk === "high" || def.base_risk === "critical") {
+      return {
+        verdict: {
+          status: "PAUSE",
+          ruleId: "user-rule-high-risk-confirm",
+          reason: `AI wants to take high-risk action: ${intent}. User rules require confirmation for high-risk actions.`,
+          evidence: makeEvidence("user-rule-high-risk-confirm")
+        },
+        reason: "User requires confirmation for high-risk AI actions"
+      };
+    }
+  }
+  if (intent === "ai_share_with_third_party") {
+    return {
+      verdict: {
+        status: "PAUSE",
+        ruleId: "user-rule-third-party-confirm",
+        reason: `App wants to share your data with a third party beyond its declared AI provider. Confirmation required.`,
+        evidence: makeEvidence("user-rule-third-party-confirm")
+      },
+      reason: "Third-party data sharing requires user confirmation"
+    };
+  }
+  return null;
+}
+function makeEvidence(ruleId) {
+  return {
+    worldId: "mentraos-user-rules",
+    worldName: "MentraOS User Rules",
+    worldVersion: "1.0.0",
+    evaluatedAt: Date.now(),
+    invariantsSatisfied: 0,
+    invariantsTotal: 0,
+    guardsMatched: [ruleId],
+    rulesMatched: [],
+    enforcementLevel: "strict"
+  };
+}
+var MentraGovernedExecutor = class {
+  world;
+  engineOptions;
+  options;
+  planState;
+  planCallbacks;
+  _userRules;
+  _emergencyOverride = false;
+  _emergencyActivatedAt = null;
+  _spatialSession = null;
+  constructor(world, options = {}, userRules = DEFAULT_USER_RULES) {
+    this.world = world;
+    this.options = options;
+    this._userRules = userRules;
+    this.engineOptions = buildEngineOptions(options, options.plan);
+    this.planState = { activePlan: options.plan, engineOptions: this.engineOptions };
+    this.planCallbacks = {
+      onPlanProgress: options.onPlanProgress,
+      onPlanComplete: options.onPlanComplete
+    };
+  }
+  /** Get the current user rules */
+  get userRules() {
+    return this._userRules;
+  }
+  /** Update user rules at runtime (e.g., user changes preferences in phone app) */
+  updateUserRules(rules) {
+    this._userRules = { ...this._userRules, ...rules };
+  }
+  /**
+   * Activate emergency override — user is king.
+   *
+   * Bypasses all NeuroVerse governance rules (user rules, platform rules).
+   * Does NOT bypass MentraOS platform constraints (hardware capability,
+   * declared permissions, session isolation). You can't override physics.
+   *
+   * Returns the timestamp of activation for audit trail.
+   */
+  activateEmergencyOverride() {
+    this._emergencyOverride = true;
+    this._emergencyActivatedAt = Date.now();
+    this.engineOptions = { ...this.engineOptions, emergencyOverride: true };
+    return this._emergencyActivatedAt;
+  }
+  /**
+   * Deactivate emergency override — governance resumes.
+   * Returns the duration the override was active (ms).
+   */
+  deactivateEmergencyOverride() {
+    if (!this._emergencyOverride || !this._emergencyActivatedAt) {
+      return 0;
+    }
+    const duration = Date.now() - this._emergencyActivatedAt;
+    this._emergencyOverride = false;
+    this._emergencyActivatedAt = null;
+    this.engineOptions = { ...this.engineOptions, emergencyOverride: false };
+    return duration;
+  }
+  /** Whether emergency override is currently active */
+  get isEmergencyOverrideActive() {
+    return this._emergencyOverride;
+  }
+  /** Timestamp when emergency override was activated, or null */
+  get emergencyActivatedAt() {
+    return this._emergencyActivatedAt;
+  }
+  // ── Spatial Governance (optional) ────────────────────────────────────────
+  /**
+   * Attach a spatial session to this executor.
+   *
+   * When attached, intents are evaluated against the spatial context
+   * (zone rules + handshake rules) AFTER user rules but BEFORE
+   * hardware and platform checks. This is Layer 1.5.
+   *
+   * Pass null to detach (e.g., when leaving a zone).
+   */
+  setSpatialSession(session) {
+    this._spatialSession = session;
+  }
+  /** Whether a spatial session is currently active */
+  get hasSpatialSession() {
+    return this._spatialSession !== null;
+  }
+  /** Get the current spatial session description */
+  get spatialDescription() {
+    return this._spatialSession?.description ?? null;
+  }
+  /**
+   * Evaluate an intent against user rules + platform world.
+   *
+   * Three-layer evaluation:
+   *   0. Emergency override — if active, skip governance (layers 1 + 1.5 + 3),
+   *      but STILL enforce platform constraints (layer 2)
+   *   1. User rules check — personal governance override, can BLOCK or PAUSE
+   *   1.5. Spatial governance — zone + handshake rules (optional, temporary)
+   *      ↑ ONLY ACTIVE when a spatial session is attached
+   *   2. Hardware capability check — validates glasses support
+   *      ↑ THIS IS A PLATFORM CONSTRAINT — never overridden
+   *   3. Platform guard engine — full world rule evaluation
+   */
+  evaluate(intent, appContext) {
+    const intentDef = getMentraIntent(intent);
+    const glassesModel = appContext.glassesModel;
+    if (!this._emergencyOverride) {
+      const userRulesResult = evaluateUserRules(intent, this._userRules, appContext);
+      if (userRulesResult) {
+        const allowed2 = false;
+        const requiresConfirmation2 = userRulesResult.verdict.status === "PAUSE";
+        const result2 = {
+          allowed: requiresConfirmation2 ? false : false,
+          requiresConfirmation: requiresConfirmation2,
+          verdict: userRulesResult.verdict,
+          intentDef,
+          userRulesResult: { reason: userRulesResult.reason },
+          appContext,
+          decidingLayer: "user_rules"
+        };
+        if (requiresConfirmation2) {
+          this.options.onPause?.(result2);
+        } else {
+          this.options.onBlock?.(result2);
+        }
+        this.options.onEvaluate?.(result2);
+        return result2;
+      }
+    }
+    if (!this._emergencyOverride && this._spatialSession) {
+      const spatialResult = this._spatialSession.evaluate(intent);
+      if (!spatialResult.allowed && !spatialResult.requiresConfirmation) {
+        const verdict2 = {
+          status: "BLOCK",
+          ruleId: "spatial-zone-rule",
+          reason: spatialResult.reason,
+          evidence: makeEvidence("spatial-zone-rule")
+        };
+        const result2 = {
+          allowed: false,
+          requiresConfirmation: false,
+          verdict: verdict2,
+          intentDef,
+          appContext,
+          decidingLayer: "spatial"
+        };
+        this.options.onBlock?.(result2);
+        this.options.onEvaluate?.(result2);
+        return result2;
+      }
+      if (spatialResult.requiresConfirmation) {
+        const verdict2 = {
+          status: "PAUSE",
+          ruleId: "spatial-zone-rule",
+          reason: spatialResult.reason,
+          evidence: makeEvidence("spatial-zone-rule")
+        };
+        const result2 = {
+          allowed: false,
+          requiresConfirmation: true,
+          verdict: verdict2,
+          intentDef,
+          appContext,
+          decidingLayer: "spatial"
+        };
+        this.options.onPause?.(result2);
+        this.options.onEvaluate?.(result2);
+        return result2;
+      }
+    }
+    if (intentDef && glassesModel && !intentDef.supported_glasses.includes(glassesModel)) {
+      const verdict2 = {
+        status: "BLOCK",
+        ruleId: "hardware-capability",
+        reason: `${intent} not supported on ${glassesModel} \u2014 requires: ${intentDef.supported_glasses.join(", ")}`,
+        evidence: {
+          worldId: this.world.world?.world_id ?? "unknown",
+          worldName: this.world.world?.name ?? "unknown",
+          worldVersion: this.world.world?.version ?? "unknown",
+          evaluatedAt: Date.now(),
+          invariantsSatisfied: 0,
+          invariantsTotal: 0,
+          guardsMatched: ["hardware-capability"],
+          rulesMatched: [],
+          enforcementLevel: "strict"
+        }
+      };
+      const result2 = {
+        allowed: false,
+        requiresConfirmation: false,
+        verdict: verdict2,
+        intentDef,
+        appContext,
+        decidingLayer: "hardware"
+      };
+      this.options.onBlock?.(result2);
+      this.options.onEvaluate?.(result2);
+      return result2;
+    }
+    const event = {
+      intent,
+      tool: intentDef?.sdk_method ?? intent,
+      scope: intentDef?.domain ?? "unknown",
+      actionCategory: intentDef?.action_category,
+      riskLevel: intentDef?.base_risk ?? "medium",
+      irreversible: intentDef ? !intentDef.reversible : false,
+      args: {
+        app_id: appContext.appId,
+        ai_provider_declared: appContext.aiProviderDeclared ? 1 : 0,
+        ai_data_types_sent: appContext.aiDataTypesSent,
+        ai_retention_opted_in: appContext.dataRetentionOptedIn ? 1 : 0,
+        glasses_model: glassesModel ?? "unknown",
+        is_ai_intent: isAIIntent(intent) ? 1 : 0
+      }
+    };
+    const verdict = evaluateGuard(event, this.world, this.engineOptions);
+    const allowed = verdict.status === "ALLOW" || verdict.status === "REWARD";
+    const requiresConfirmation = verdict.status === "PAUSE";
+    if (allowed) {
+      trackPlanProgress(event, this.planState, this.planCallbacks);
+    }
+    const result = {
+      allowed,
+      requiresConfirmation,
+      verdict,
+      intentDef,
+      appContext,
+      decidingLayer: this._emergencyOverride ? "emergency_override" : "platform"
+    };
+    if (!allowed && !requiresConfirmation) {
+      this.options.onBlock?.(result);
+    }
+    if (requiresConfirmation) {
+      this.options.onPause?.(result);
+    }
+    this.options.onEvaluate?.(result);
+    return result;
+  }
+  /** Get all known intents for this adapter */
+  get knownIntents() {
+    return MENTRA_KNOWN_INTENTS;
+  }
+};
+async function createMentraGovernedExecutor(worldPath, options = {}, userRules = DEFAULT_USER_RULES) {
+  const world = await loadWorld(worldPath);
+  return new MentraGovernedExecutor(world, options, userRules);
+}
+function createMentraGovernedExecutorFromWorld(world, options = {}, userRules = DEFAULT_USER_RULES) {
+  return new MentraGovernedExecutor(world, options, userRules);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_USER_RULES,
+  GovernanceBlockedError,
+  MENTRA_INTENT_MAP,
+  MENTRA_INTENT_TAXONOMY,
+  MENTRA_KNOWN_INTENTS,
+  MentraGovernedExecutor,
+  createMentraGovernedExecutor,
+  createMentraGovernedExecutorFromWorld,
+  evaluateUserRules,
+  getAIActionIntents,
+  getAIDataIntents,
+  getAIIntents,
+  getExfiltrationIntents,
+  getHighRiskIntents,
+  getIntentsByGlasses,
+  getIntentsByPermission,
+  getMentraIntent,
+  isAIIntent,
+  isIntentSupported
+});