@neuroverseos/governance 0.1.5 → 0.2.1

package/dist/adapters/openclaw.cjs

@@ -37,6 +37,205 @@ __export(openclaw_exports, {
 });
 module.exports = __toCommonJS(openclaw_exports);
 
+// src/engine/plan-engine.ts
+function keywordMatch(eventText, step) {
+  const stepText = [
+    step.label,
+    step.description ?? "",
+    ...step.tags ?? []
+  ].join(" ").toLowerCase();
+  const keywords = stepText.split(/\s+/).filter((w) => w.length > 3);
+  if (keywords.length === 0) return false;
+  const matched = keywords.filter((kw) => eventText.includes(kw));
+  return matched.length >= Math.ceil(keywords.length * 0.5);
+}
+function tokenSimilarity(a, b) {
+  const tokensA = new Set(a.toLowerCase().split(/\s+/).filter((w) => w.length > 2));
+  const tokensB = new Set(b.toLowerCase().split(/\s+/).filter((w) => w.length > 2));
+  if (tokensA.size === 0 || tokensB.size === 0) return 0;
+  let intersection = 0;
+  for (const t of tokensA) {
+    if (tokensB.has(t)) intersection++;
+  }
+  const union = (/* @__PURE__ */ new Set([...tokensA, ...tokensB])).size;
+  return union > 0 ? intersection / union : 0;
+}
+function findMatchingStep(eventText, event, steps) {
+  const pendingOrActive = steps.filter((s) => s.status === "pending" || s.status === "active");
+  if (pendingOrActive.length === 0) {
+    return { matched: null, closest: null, closestScore: 0 };
+  }
+  for (const step of pendingOrActive) {
+    if (keywordMatch(eventText, step)) {
+      if (step.tools && event.tool && !step.tools.includes(event.tool)) {
+        continue;
+      }
+      return { matched: step, closest: step, closestScore: 1 };
+    }
+  }
+  const intentText = [event.intent, event.tool ?? "", event.scope ?? ""].join(" ");
+  let bestStep = null;
+  let bestScore = 0;
+  for (const step of pendingOrActive) {
+    const stepText = [step.label, step.description ?? "", ...step.tags ?? []].join(" ");
+    const score = tokenSimilarity(intentText, stepText);
+    if (score > bestScore) {
+      bestScore = score;
+      bestStep = step;
+    }
+  }
+  const SIMILARITY_THRESHOLD = 0.35;
+  if (bestScore >= SIMILARITY_THRESHOLD && bestStep) {
+    if (bestStep.tools && event.tool && !bestStep.tools.includes(event.tool)) {
+      return { matched: null, closest: bestStep, closestScore: bestScore };
+    }
+    return { matched: bestStep, closest: bestStep, closestScore: bestScore };
+  }
+  return { matched: null, closest: bestStep, closestScore: bestScore };
+}
+function isSequenceValid(step, plan) {
+  if (!plan.sequential) return true;
+  if (!step.requires || step.requires.length === 0) return true;
+  return step.requires.every((reqId) => {
+    const reqStep = plan.steps.find((s) => s.id === reqId);
+    return reqStep?.status === "completed";
+  });
+}
+function checkConstraints(event, eventText, constraints) {
+  const checks = [];
+  for (const constraint of constraints) {
+    if (constraint.type === "approval") {
+      if (constraint.trigger && eventText.includes(constraint.trigger.substring(0, 10).toLowerCase())) {
+        checks.push({ constraintId: constraint.id, passed: false, reason: constraint.description });
+        return { violated: constraint, checks };
+      }
+      const keywords = constraint.description.toLowerCase().split(/\s+/).filter((w) => w.length > 3);
+      const relevant = keywords.some((kw) => eventText.includes(kw));
+      if (relevant) {
+        checks.push({ constraintId: constraint.id, passed: false, reason: constraint.description });
+        return { violated: constraint, checks };
+      }
+      checks.push({ constraintId: constraint.id, passed: true });
+      continue;
+    }
+    if (constraint.type === "scope" && constraint.trigger) {
+      const keywords = constraint.trigger.split(/\s+/).filter((w) => w.length > 3);
+      const violated = keywords.length > 0 && keywords.every((kw) => eventText.includes(kw));
+      checks.push({
+        constraintId: constraint.id,
+        passed: !violated,
+        reason: violated ? constraint.description : void 0
+      });
+      if (violated) {
+        return { violated: constraint, checks };
+      }
+      continue;
+    }
+    checks.push({ constraintId: constraint.id, passed: true });
+  }
+  return { violated: null, checks };
+}
+function getPlanProgress(plan) {
+  const completed = plan.steps.filter((s) => s.status === "completed").length;
+  const total = plan.steps.length;
+  return {
+    completed,
+    total,
+    percentage: total > 0 ? Math.round(completed / total * 100) : 0
+  };
+}
+function advancePlan(plan, stepId) {
+  return {
+    ...plan,
+    steps: plan.steps.map(
+      (s) => s.id === stepId ? { ...s, status: "completed" } : s
+    )
+  };
+}
+function evaluatePlan(event, plan) {
+  const progress = getPlanProgress(plan);
+  if (plan.expires_at) {
+    const expiresAt = new Date(plan.expires_at).getTime();
+    if (Date.now() > expiresAt) {
+      return {
+        allowed: true,
+        status: "PLAN_COMPLETE",
+        reason: "Plan has expired.",
+        progress
+      };
+    }
+  }
+  if (progress.completed === progress.total) {
+    return {
+      allowed: true,
+      status: "PLAN_COMPLETE",
+      reason: "All plan steps are completed.",
+      progress
+    };
+  }
+  const eventText = [
+    event.intent,
+    event.tool ?? "",
+    event.scope ?? ""
+  ].join(" ").toLowerCase();
+  const { matched, closest, closestScore } = findMatchingStep(eventText, event, plan.steps);
+  if (!matched) {
+    return {
+      allowed: false,
+      status: "OFF_PLAN",
+      reason: "Action does not match any plan step.",
+      closestStep: closest?.label,
+      similarityScore: closestScore,
+      progress
+    };
+  }
+  if (!isSequenceValid(matched, plan)) {
+    const pendingDeps = (matched.requires ?? []).filter((reqId) => plan.steps.find((s) => s.id === reqId)?.status !== "completed").join(", ");
+    return {
+      allowed: false,
+      status: "OFF_PLAN",
+      reason: `Step "${matched.label}" requires completion of: ${pendingDeps}`,
+      matchedStep: matched.id,
+      progress
+    };
+  }
+  const { violated } = checkConstraints(event, eventText, plan.constraints);
+  if (violated) {
+    return {
+      allowed: false,
+      status: "CONSTRAINT_VIOLATED",
+      reason: violated.description,
+      matchedStep: matched.id,
+      progress
+    };
+  }
+  return {
+    allowed: true,
+    status: "ON_PLAN",
+    reason: `Matches step: ${matched.label}`,
+    matchedStep: matched.id,
+    progress
+  };
+}
+function buildPlanCheck(event, plan, verdict) {
+  const eventText = [event.intent, event.tool ?? "", event.scope ?? ""].join(" ").toLowerCase();
+  const { matched, closest, closestScore } = findMatchingStep(eventText, event, plan.steps);
+  const { checks: constraintChecks } = checkConstraints(event, eventText, plan.constraints);
+  const progress = getPlanProgress(plan);
+  return {
+    planId: plan.plan_id,
+    matched: !!matched,
+    matchedStepId: matched?.id,
+    matchedStepLabel: matched?.label,
+    closestStepId: !matched ? closest?.id : void 0,
+    closestStepLabel: !matched ? closest?.label : void 0,
+    similarityScore: !matched ? closestScore : void 0,
+    sequenceValid: matched ? isSequenceValid(matched, plan) : void 0,
+    constraintsChecked: constraintChecks,
+    progress: { completed: progress.completed, total: progress.total }
+  };
+}
+
 // src/engine/guard-engine.ts
 var PROMPT_INJECTION_PATTERNS = [
   // Instruction override
@@ -128,6 +327,7 @@ function evaluateGuard(event, world, options = {}) {
   const eventText = (event.intent + " " + (event.tool ?? "") + " " + (event.scope ?? "")).toLowerCase();
   const invariantChecks = [];
   const safetyChecks = [];
+  let planCheckResult;
   const roleChecks = [];
   const guardChecks = [];
   const kernelRuleChecks = [];
@@ -155,6 +355,7 @@ function evaluateGuard(event, world, options = {}) {
         includeTrace ? buildTrace(
           invariantChecks,
           safetyChecks,
+          planCheckResult,
           roleChecks,
           guardChecks,
           kernelRuleChecks,
@@ -183,6 +384,7 @@ function evaluateGuard(event, world, options = {}) {
       includeTrace ? buildTrace(
         invariantChecks,
         safetyChecks,
+        planCheckResult,
         roleChecks,
         guardChecks,
         kernelRuleChecks,
@@ -193,6 +395,42 @@ function evaluateGuard(event, world, options = {}) {
       ) : void 0
     );
   }
+  if (options.plan) {
+    const planVerdict = evaluatePlan(event, options.plan);
+    planCheckResult = buildPlanCheck(event, options.plan, planVerdict);
+    if (!planVerdict.allowed && planVerdict.status !== "PLAN_COMPLETE") {
+      decidingLayer = "plan-enforcement";
+      decidingId = `plan-${options.plan.plan_id}`;
+      const planStatus = planVerdict.status === "CONSTRAINT_VIOLATED" ? "PAUSE" : "BLOCK";
+      let reason = planVerdict.reason ?? "Action blocked by plan.";
+      if (planVerdict.status === "OFF_PLAN" && planVerdict.closestStep) {
+        reason += ` Closest step: "${planVerdict.closestStep}" (similarity: ${(planVerdict.similarityScore ?? 0).toFixed(2)})`;
+      }
+      return buildVerdict(
+        planStatus,
+        reason,
+        `plan-${options.plan.plan_id}`,
+        void 0,
+        world,
+        level,
+        invariantChecks,
+        guardsMatched,
+        rulesMatched,
+        includeTrace ? buildTrace(
+          invariantChecks,
+          safetyChecks,
+          planCheckResult,
+          roleChecks,
+          guardChecks,
+          kernelRuleChecks,
+          levelChecks,
+          decidingLayer,
+          decidingId,
+          startTime
+        ) : void 0
+      );
+    }
+  }
   const roleVerdict = checkRoleRules(event, eventText, world, roleChecks);
   if (roleVerdict) {
     decidingLayer = "role";
@@ -210,6 +448,7 @@ function evaluateGuard(event, world, options = {}) {
       includeTrace ? buildTrace(
         invariantChecks,
         safetyChecks,
+        planCheckResult,
         roleChecks,
         guardChecks,
         kernelRuleChecks,
@@ -238,6 +477,7 @@ function evaluateGuard(event, world, options = {}) {
         includeTrace ? buildTrace(
           invariantChecks,
           safetyChecks,
+          planCheckResult,
           roleChecks,
           guardChecks,
           kernelRuleChecks,
@@ -266,6 +506,7 @@ function evaluateGuard(event, world, options = {}) {
       includeTrace ? buildTrace(
         invariantChecks,
         safetyChecks,
+        planCheckResult,
         roleChecks,
         guardChecks,
         kernelRuleChecks,
@@ -293,6 +534,7 @@ function evaluateGuard(event, world, options = {}) {
       includeTrace ? buildTrace(
         invariantChecks,
         safetyChecks,
+        planCheckResult,
         roleChecks,
         guardChecks,
         kernelRuleChecks,
@@ -317,6 +559,7 @@ function evaluateGuard(event, world, options = {}) {
     includeTrace ? buildTrace(
       invariantChecks,
       safetyChecks,
+      planCheckResult,
       roleChecks,
       guardChecks,
       kernelRuleChecks,
@@ -654,8 +897,8 @@ function matchesKeywords(eventText, ruleText) {
 function eventToAllowlistKey(event) {
   return `${(event.tool ?? "*").toLowerCase()}::${event.intent.toLowerCase().trim()}`;
 }
-function buildTrace(invariantChecks, safetyChecks, roleChecks, guardChecks, kernelRuleChecks, levelChecks, decidingLayer, decidingId, startTime) {
-  return {
+function buildTrace(invariantChecks, safetyChecks, planCheck, roleChecks, guardChecks, kernelRuleChecks, levelChecks, decidingLayer, decidingId, startTime) {
+  const trace = {
     invariantChecks,
     safetyChecks,
     roleChecks,
@@ -673,6 +916,7 @@ function buildTrace(invariantChecks, safetyChecks, roleChecks, guardChecks, kern
         "safety-scope-escape",
         "safety-execution-claim",
         "safety-execution-intent",
+        "plan-enforcement",
         "role-rules",
         "declarative-guards",
         "kernel-rules",
@@ -682,6 +926,10 @@ function buildTrace(invariantChecks, safetyChecks, roleChecks, guardChecks, kern
     },
     durationMs: performance.now() - startTime
   };
+  if (planCheck) {
+    trace.planCheck = planCheck;
+  }
+  return trace;
 }
 function buildVerdict(status, reason, ruleId, warning, world, level, invariantChecks, guardsMatched, rulesMatched, trace) {
   const evidence = {
@@ -807,12 +1055,15 @@ var NeuroVersePlugin = class {
   options;
   engineOptions;
   mapAction;
+  activePlan;
   constructor(world, options = {}) {
     this.world = world;
     this.options = options;
+    this.activePlan = options.plan;
     this.engineOptions = {
       trace: options.trace ?? false,
-      level: options.level
+      level: options.level,
+      plan: this.activePlan
     };
     this.mapAction = options.mapAction ?? defaultMapAction;
   }
@@ -824,6 +1075,7 @@ var NeuroVersePlugin = class {
    */
   beforeAction(action) {
     const event = this.mapAction(action, "input");
+    this.engineOptions.plan = this.activePlan;
     const verdict = evaluateGuard(event, this.world, this.engineOptions);
     const result = {
       allowed: verdict.status === "ALLOW",
@@ -834,6 +1086,18 @@ var NeuroVersePlugin = class {
     if (verdict.status === "BLOCK") {
       throw new GovernanceBlockedError(verdict, action);
     }
+    if (verdict.status === "ALLOW" && this.activePlan) {
+      const planVerdict = evaluatePlan(event, this.activePlan);
+      if (planVerdict.matchedStep) {
+        this.activePlan = advancePlan(this.activePlan, planVerdict.matchedStep);
+        this.engineOptions.plan = this.activePlan;
+        const progress = getPlanProgress(this.activePlan);
+        this.options.onPlanProgress?.(progress);
+        if (progress.completed === progress.total) {
+          this.options.onPlanComplete?.();
+        }
+      }
+    }
     return result;
   }
   /**

package/dist/adapters/openclaw.d.cts

@@ -1,4 +1,4 @@
-import { G as GuardVerdict, W as WorldDefinition, a as GuardEvent } from '../guard-contract-D_RQz9kt.cjs';
+import { G as GuardVerdict, W as WorldDefinition, a as GuardEvent, P as PlanDefinition, b as PlanProgress } from '../guard-contract-D-2LQInm.cjs';
 
 /**
  * NeuroVerse Adapter — OpenClaw
@@ -38,6 +38,12 @@ interface NeuroVersePluginOptions {
     mapAction?: (action: AgentAction, direction: 'input' | 'output') => GuardEvent;
     /** Whether to evaluate output actions (post-action). Default: false. */
     evaluateOutputs?: boolean;
+    /** Active plan overlay for task-scoped governance. */
+    plan?: PlanDefinition;
+    /** Called when plan progress changes. */
+    onPlanProgress?: (progress: PlanProgress) => void;
+    /** Called when all plan steps are completed. */
+    onPlanComplete?: () => void;
 }
 declare class GovernanceBlockedError extends Error {
     readonly verdict: GuardVerdict;
@@ -57,6 +63,7 @@ declare class NeuroVersePlugin {
     private options;
     private engineOptions;
     private mapAction;
+    private activePlan?;
     constructor(world: WorldDefinition, options?: NeuroVersePluginOptions);
     /**
      * Evaluate an action before execution.

package/dist/adapters/openclaw.d.ts

@@ -1,4 +1,4 @@
-import { G as GuardVerdict, W as WorldDefinition, a as GuardEvent } from '../guard-contract-D_RQz9kt.js';
+import { G as GuardVerdict, W as WorldDefinition, a as GuardEvent, P as PlanDefinition, b as PlanProgress } from '../guard-contract-D-2LQInm.js';
 
 /**
  * NeuroVerse Adapter — OpenClaw
@@ -38,6 +38,12 @@ interface NeuroVersePluginOptions {
     mapAction?: (action: AgentAction, direction: 'input' | 'output') => GuardEvent;
     /** Whether to evaluate output actions (post-action). Default: false. */
     evaluateOutputs?: boolean;
+    /** Active plan overlay for task-scoped governance. */
+    plan?: PlanDefinition;
+    /** Called when plan progress changes. */
+    onPlanProgress?: (progress: PlanProgress) => void;
+    /** Called when all plan steps are completed. */
+    onPlanComplete?: () => void;
 }
 declare class GovernanceBlockedError extends Error {
     readonly verdict: GuardVerdict;
@@ -57,6 +63,7 @@ declare class NeuroVersePlugin {
     private options;
     private engineOptions;
     private mapAction;
+    private activePlan?;
     constructor(world: WorldDefinition, options?: NeuroVersePluginOptions);
     /**
      * Evaluate an action before execution.

package/dist/adapters/openclaw.js

@@ -3,9 +3,11 @@ import {
   NeuroVersePlugin,
   createNeuroVersePlugin,
   createNeuroVersePluginFromWorld
-} from "../chunk-CROPZ75A.js";
-import "../chunk-B4NF3OLW.js";
-import "../chunk-M3TZFGHO.js";
+} from "../chunk-UPJNTSVM.js";
+import "../chunk-PQBJBVSW.js";
+import "../chunk-JZPQGIKR.js";
+import "../chunk-P74Y66ZV.js";
+import "../chunk-YZFATT7X.js";
 export {
   GovernanceBlockedError,
   NeuroVersePlugin,

package/dist/{bootstrap-H4HHKQ5G.js → bootstrap-GXVDZNF7.js}

@@ -5,6 +5,7 @@ import {
   emitWorldDefinition,
   parseWorldMarkdown
 } from "./chunk-XPDMYECO.js";
+import "./chunk-YZFATT7X.js";
 
 // src/cli/bootstrap.ts
 function parseArgs(argv) {
@@ -81,7 +82,7 @@ async function main(argv = process.argv.slice(2)) {
     await writeWorldFiles(args.outputPath, emitResult.world);
     let validateReport;
     if (args.validate) {
-      const { validateWorld } = await import("./validate-engine-657D75OG.js");
+      const { validateWorld } = await import("./validate-engine-UIABSIHD.js");
       validateReport = validateWorld(emitResult.world);
     }
     const result = {

package/dist/{build-73KAVHEY.js → build-P42YFKQV.js}

@@ -2,15 +2,17 @@ import {
   DeriveInputError,
   DeriveProviderError,
   deriveWorld
-} from "./chunk-D7BGWV2J.js";
+} from "./chunk-NF5POFCI.js";
 import {
   DERIVE_EXIT_CODES
-} from "./chunk-T4X42QXC.js";
+} from "./chunk-Q6O7ZLO2.js";
+import "./chunk-OT6PXH54.js";
 import {
   emitWorldDefinition,
   parseWorldMarkdown
 } from "./chunk-XPDMYECO.js";
-import "./chunk-O5OMJMIE.js";
+import "./chunk-7P3S7MAY.js";
+import "./chunk-YZFATT7X.js";
 
 // src/cli/build.ts
 var FINDING_LABELS = {
@@ -74,6 +76,34 @@ function traceCausalChains(rules) {
   }
   return unique.slice(0, 3);
 }
+function renderGovernanceHealth(health) {
+  const lines = [];
+  lines.push("GOVERNANCE HEALTH");
+  lines.push(`  Coverage: ${health.surfacesCovered} / ${health.surfacesTotal} action surfaces governed`);
+  lines.push(`  Invariants enforced: ${health.invariantsEnforced} / ${health.invariantsTotal}`);
+  if (health.shadowedGuards > 0) {
+    lines.push(`  Shadowed guards: ${health.shadowedGuards}`);
+  }
+  if (health.unenforcedInvariants > 0) {
+    lines.push(`  Unenforced invariants: ${health.unenforcedInvariants}`);
+  }
+  if (health.unreachableRules > 0) {
+    lines.push(`  Unreachable rules: ${health.unreachableRules}`);
+  }
+  if (health.incompleteStateCoverage > 0) {
+    lines.push(`  Incomplete state coverage: ${health.incompleteStateCoverage}`);
+  }
+  if (health.surfaces.length > 0) {
+    lines.push("");
+    lines.push("  Surfaces:");
+    for (const s of health.surfaces) {
+      lines.push(`    ${s.name}: ${s.governed ? "governed" : "unguarded"}`);
+    }
+  }
+  lines.push("");
+  lines.push(`  Risk level: ${health.riskLevel.charAt(0).toUpperCase() + health.riskLevel.slice(1)}`);
+  return lines.join("\n");
+}
 function parseArgs(argv) {
   let inputPath = "";
   let outputDir;
@@ -304,5 +334,6 @@ Next steps:
 export {
   humanLabel,
   main,
+  renderGovernanceHealth,
   traceCausalChains
 };

package/dist/{chunk-FYPYZFV5.js → chunk-2JQJ5U5X.js}

@@ -1,6 +1,6 @@
 import {
   evaluateGuard
-} from "./chunk-B4NF3OLW.js";
+} from "./chunk-PQBJBVSW.js";
 
 // src/engine/audit-logger.ts
 var FileAuditLogger = class {

package/dist/chunk-37JG24WH.js

@@ -0,0 +1,161 @@
+// src/engine/plan-parser.ts
+function slugify(text) {
+  return text.toLowerCase().replace(/[^a-z0-9\s]/g, "").trim().replace(/\s+/g, "_");
+}
+function extractBracketAnnotation(line, key) {
+  const regex = new RegExp(`\\[${key}:\\s*([^\\]]+)\\]`, "i");
+  const match = line.match(regex);
+  if (!match) return null;
+  return match[1].split(",").map((s) => s.trim()).filter(Boolean);
+}
+function extractParenAnnotation(line, key) {
+  const regex = new RegExp(`\\(${key}:\\s*([^)]+)\\)`, "i");
+  const match = line.match(regex);
+  if (!match) return null;
+  return match[1].split(",").map((s) => s.trim()).filter(Boolean);
+}
+function stripAnnotations(line) {
+  return line.replace(/\[(?:tools|tag|verify|type):\s*[^\]]+\]/gi, "").replace(/\((?:after):\s*[^)]+\)/gi, "").trim();
+}
+function parseFrontmatter(content) {
+  const frontmatter = {};
+  const fmMatch = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n/);
+  if (!fmMatch) {
+    return { frontmatter, body: content };
+  }
+  const fmBody = fmMatch[1];
+  for (const line of fmBody.split("\n")) {
+    const colonIndex = line.indexOf(":");
+    if (colonIndex > 0) {
+      const key = line.slice(0, colonIndex).trim();
+      const value = line.slice(colonIndex + 1).trim();
+      frontmatter[key] = value;
+    }
+  }
+  return { frontmatter, body: content.slice(fmMatch[0].length) };
+}
+function parseSections(body) {
+  const steps = [];
+  const constraints = [];
+  let currentSection = "none";
+  for (const line of body.split("\n")) {
+    const trimmed = line.trim();
+    if (/^#+\s*Steps/i.test(trimmed)) {
+      currentSection = "steps";
+      continue;
+    }
+    if (/^#+\s*Constraints/i.test(trimmed)) {
+      currentSection = "constraints";
+      continue;
+    }
+    if (/^#+\s/.test(trimmed) && currentSection !== "none") {
+      currentSection = "none";
+      continue;
+    }
+    if (trimmed.startsWith("- ")) {
+      const item = trimmed.slice(2).trim();
+      if (currentSection === "steps") {
+        steps.push(item);
+      } else if (currentSection === "constraints") {
+        constraints.push(item);
+      }
+    }
+  }
+  return { steps, constraints };
+}
+function parseStep(raw) {
+  const label = stripAnnotations(raw);
+  const id = slugify(label);
+  const tools = extractBracketAnnotation(raw, "tools");
+  const tags = extractBracketAnnotation(raw, "tag");
+  const verifyArr = extractBracketAnnotation(raw, "verify");
+  const requires = extractParenAnnotation(raw, "after");
+  return {
+    id,
+    label,
+    tools: tools ?? void 0,
+    tags: tags ?? void 0,
+    verify: verifyArr?.[0] ?? void 0,
+    requires: requires ?? void 0,
+    status: "pending"
+  };
+}
+function parseConstraint(raw, index) {
+  const typeAnnotation = extractBracketAnnotation(raw, "type");
+  const description = stripAnnotations(raw);
+  const id = `constraint_${index}`;
+  let type = "custom";
+  let enforcement = "block";
+  let limit;
+  let unit;
+  if (typeAnnotation?.[0] === "approval") {
+    type = "approval";
+    enforcement = "pause";
+  } else if (/budget|\$|spending|cost/i.test(description)) {
+    type = "budget";
+    const amountMatch = description.match(/\$?([\d,]+)/);
+    if (amountMatch) {
+      limit = parseInt(amountMatch[1].replace(/,/g, ""), 10);
+      unit = "USD";
+    }
+  } else if (/time|hour|minute|day|deadline/i.test(description)) {
+    type = "time";
+  } else if (/scope|access|database|production/i.test(description)) {
+    type = "scope";
+  }
+  const trigger = description.toLowerCase();
+  return {
+    id,
+    type,
+    description,
+    enforcement,
+    limit,
+    unit,
+    trigger
+  };
+}
+function parsePlanMarkdown(markdown) {
+  const errors = [];
+  const { frontmatter, body } = parseFrontmatter(markdown.trim());
+  const { steps: stepLines, constraints: constraintLines } = parseSections(body);
+  if (!frontmatter.plan_id) {
+    errors.push("Missing required field: plan_id");
+  }
+  if (stepLines.length === 0) {
+    errors.push("Plan must have at least one step");
+  }
+  if (errors.length > 0) {
+    return { success: false, errors };
+  }
+  const steps = stepLines.map((line) => parseStep(line));
+  const constraints = constraintLines.map((line, i) => parseConstraint(line, i));
+  let expires_at;
+  if (frontmatter.expires) {
+    expires_at = new Date(frontmatter.expires).toISOString();
+  }
+  const plan = {
+    plan_id: frontmatter.plan_id,
+    objective: frontmatter.objective ?? "",
+    sequential: frontmatter.sequential === "true",
+    steps,
+    constraints,
+    world_id: frontmatter.world ?? void 0,
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    expires_at
+  };
+  return { success: true, plan, errors: [] };
+}
+
+// src/contracts/plan-contract.ts
+var PLAN_EXIT_CODES = {
+  ON_PLAN: 0,
+  OFF_PLAN: 1,
+  CONSTRAINT_VIOLATED: 2,
+  ERROR: 3,
+  PLAN_COMPLETE: 4
+};
+
+export {
+  parsePlanMarkdown,
+  PLAN_EXIT_CODES
+};