@neuroverseos/governance 0.5.1 → 0.6.0

package/README.md

@@ -388,6 +388,61 @@ const overlay = compileLensOverlay([lens]);      // System prompt string
 | `role_default` | Starts as role default. User can override. |
 | `user_choice` | No default. User picks freely. |
 
+### Behavioral Lenses
+
+Lenses are not limited to tone and style. A **behavioral lens** interprets actions, flags patterns, and shapes how the system reads situations — not just how it speaks.
+
+The built-in `behavioral-interpreter` lens is the first behavioral governance overlay:
+
+```typescript
+import { BEHAVIORAL_INTERPRETER_LENS, compileLensOverlay } from '@neuroverseos/governance';
+
+const overlay = compileLensOverlay([BEHAVIORAL_INTERPRETER_LENS]);
+// → Directives that prioritize observed behavior over stated intent,
+//   flag ambiguity and ownership diffusion, and distinguish
+//   observed facts from inference and speculation.
+```
+
+Behavioral lenses can also be declared in world files:
+
+```markdown
+# Lenses
+- policy: role_default
+
+## behavioral-interpreter
+- tagline: Read patterns, not promises.
+- formality: neutral
+- verbosity: concise
+- emotion: neutral
+- confidence: balanced
+- tags: behavior, signals, alignment, analysis
+- default_for_roles: all
+- priority: 65
+
+> response_framing: Prioritize observed behavior over stated intent.
+> behavior_shaping: Detect repeated ambiguity, delay, or ownership diffusion.
+> value_emphasis: Name alignment or misalignment between words and actions.
+> content_filtering: Distinguish observed behavior from inference and speculation.
+```
+
+To extract and compile a behavioral lens from a world file:
+
+```typescript
+import { loadBundledWorld } from '@neuroverseos/governance/loader/world-loader';
+import { lensesFromWorld, compileLensOverlay } from '@neuroverseos/governance';
+
+const world = await loadBundledWorld('behavioral-demo');
+const lenses = lensesFromWorld(world);
+const overlay = compileLensOverlay(lenses);
+console.log(overlay.systemPromptAddition);
+```
+
+Run the end-to-end demo:
+
+```bash
+npx tsx examples/behavioral-lens-demo/demo.ts
+```
+
 ---
 
 ## Worlds: The Universal Container

package/dist/adapters/autoresearch.js

@@ -1,8 +1,8 @@
 import {
   AutoresearchGovernor,
   createAutoresearchGovernor
-} from "../chunk-TL4DLMMW.js";
-import "../chunk-EQUAWNXW.js";
+} from "../chunk-TJ5L2UTE.js";
+import "../chunk-I4RTIMLX.js";
 import "../chunk-ZAF6JH23.js";
 import "../chunk-QLPTHTVB.js";
 import "../chunk-QWGCMQQD.js";

package/dist/adapters/deep-agents.js

@@ -3,9 +3,9 @@ import {
   GovernanceBlockedError,
   createDeepAgentsGuard,
   createDeepAgentsGuardFromWorld
-} from "../chunk-5RAQ5DZW.js";
+} from "../chunk-T6GMRZWC.js";
 import "../chunk-5U2MQO5P.js";
-import "../chunk-EQUAWNXW.js";
+import "../chunk-I4RTIMLX.js";
 import "../chunk-ZAF6JH23.js";
 import "../chunk-QLPTHTVB.js";
 import "../chunk-QWGCMQQD.js";

package/dist/adapters/express.js

@@ -1,8 +1,8 @@
 import {
   createGovernanceMiddleware,
   createGovernanceMiddlewareFromWorld
-} from "../chunk-6UPEUMJ2.js";
-import "../chunk-EQUAWNXW.js";
+} from "../chunk-HDNDL6D5.js";
+import "../chunk-I4RTIMLX.js";
 import "../chunk-ZAF6JH23.js";
 import "../chunk-QLPTHTVB.js";
 import "../chunk-QWGCMQQD.js";

package/dist/adapters/github.js

@@ -8,9 +8,9 @@ import {
   createGitHubWebhookHandlerFromWorld,
   formatForActions,
   formatPRComment
-} from "../chunk-FGOSKQDE.js";
+} from "../chunk-A2UZTLRV.js";
 import "../chunk-5U2MQO5P.js";
-import "../chunk-EQUAWNXW.js";
+import "../chunk-I4RTIMLX.js";
 import "../chunk-ZAF6JH23.js";
 import "../chunk-QLPTHTVB.js";
 import "../chunk-QWGCMQQD.js";

package/dist/adapters/index.js

@@ -4,19 +4,19 @@ import {
   createMentraGovernedExecutor,
   createMentraGovernedExecutorFromWorld,
   evaluateUserRules
-} from "../chunk-7UU7V3AD.js";
+} from "../chunk-IOVXB6QN.js";
 import {
   GovernanceBlockedError as GovernanceBlockedError4,
   GovernedToolExecutor,
   createGovernedToolExecutor,
   createGovernedToolExecutorFromWorld
-} from "../chunk-R23T5SZG.js";
+} from "../chunk-B3IIPTY3.js";
 import {
   GovernanceBlockedError as GovernanceBlockedError5,
   NeuroVersePlugin,
   createNeuroVersePlugin,
   createNeuroVersePluginFromWorld
-} from "../chunk-RF2L5SYG.js";
+} from "../chunk-TIXVEPS2.js";
 import {
   MENTRA_INTENT_TAXONOMY,
   MENTRA_KNOWN_INTENTS,
@@ -33,23 +33,23 @@ import {
 } from "../chunk-GJ6LM4JZ.js";
 import {
   AutoresearchGovernor
-} from "../chunk-TL4DLMMW.js";
+} from "../chunk-TJ5L2UTE.js";
 import {
   DeepAgentsGuard,
   GovernanceBlockedError as GovernanceBlockedError2,
   createDeepAgentsGuard,
   createDeepAgentsGuardFromWorld
-} from "../chunk-5RAQ5DZW.js";
+} from "../chunk-T6GMRZWC.js";
 import {
   createGovernanceMiddleware,
   createGovernanceMiddlewareFromWorld
-} from "../chunk-6UPEUMJ2.js";
+} from "../chunk-HDNDL6D5.js";
 import {
   GovernanceBlockedError as GovernanceBlockedError3,
   NeuroVerseCallbackHandler,
   createNeuroVerseCallbackHandler,
   createNeuroVerseCallbackHandlerFromWorld
-} from "../chunk-UZBW44KD.js";
+} from "../chunk-FKQCPRKI.js";
 import {
   GovernanceBlockedError,
   buildEngineOptions,
@@ -57,7 +57,7 @@ import {
   extractScope,
   trackPlanProgress
 } from "../chunk-5U2MQO5P.js";
-import "../chunk-EQUAWNXW.js";
+import "../chunk-I4RTIMLX.js";
 import "../chunk-ZAF6JH23.js";
 import "../chunk-QLPTHTVB.js";
 import "../chunk-QWGCMQQD.js";

package/dist/adapters/langchain.js

@@ -3,9 +3,9 @@ import {
   NeuroVerseCallbackHandler,
   createNeuroVerseCallbackHandler,
   createNeuroVerseCallbackHandlerFromWorld
-} from "../chunk-UZBW44KD.js";
+} from "../chunk-FKQCPRKI.js";
 import "../chunk-5U2MQO5P.js";
-import "../chunk-EQUAWNXW.js";
+import "../chunk-I4RTIMLX.js";
 import "../chunk-ZAF6JH23.js";
 import "../chunk-QLPTHTVB.js";
 import "../chunk-QWGCMQQD.js";

package/dist/adapters/mentraos.js

@@ -4,7 +4,7 @@ import {
   createMentraGovernedExecutor,
   createMentraGovernedExecutorFromWorld,
   evaluateUserRules
-} from "../chunk-7UU7V3AD.js";
+} from "../chunk-IOVXB6QN.js";
 import {
   MENTRA_INTENT_MAP,
   MENTRA_INTENT_TAXONOMY,
@@ -23,7 +23,7 @@ import {
 import {
   GovernanceBlockedError
 } from "../chunk-5U2MQO5P.js";
-import "../chunk-EQUAWNXW.js";
+import "../chunk-I4RTIMLX.js";
 import "../chunk-ZAF6JH23.js";
 import "../chunk-QLPTHTVB.js";
 import "../chunk-QWGCMQQD.js";

package/dist/adapters/openai.js

@@ -3,9 +3,9 @@ import {
   GovernedToolExecutor,
   createGovernedToolExecutor,
   createGovernedToolExecutorFromWorld
-} from "../chunk-R23T5SZG.js";
+} from "../chunk-B3IIPTY3.js";
 import "../chunk-5U2MQO5P.js";
-import "../chunk-EQUAWNXW.js";
+import "../chunk-I4RTIMLX.js";
 import "../chunk-ZAF6JH23.js";
 import "../chunk-QLPTHTVB.js";
 import "../chunk-QWGCMQQD.js";

package/dist/adapters/openclaw.js

@@ -3,9 +3,9 @@ import {
   NeuroVersePlugin,
   createNeuroVersePlugin,
   createNeuroVersePluginFromWorld
-} from "../chunk-RF2L5SYG.js";
+} from "../chunk-TIXVEPS2.js";
 import "../chunk-5U2MQO5P.js";
-import "../chunk-EQUAWNXW.js";
+import "../chunk-I4RTIMLX.js";
 import "../chunk-ZAF6JH23.js";
 import "../chunk-QLPTHTVB.js";
 import "../chunk-QWGCMQQD.js";

package/dist/{add-JP7TC2K3.js → add-XSANI3FK.js}

@@ -4,7 +4,7 @@ import {
   addRule,
   classifyIntent,
   parseGuardDescription
-} from "./chunk-XPMZB46F.js";
+} from "./chunk-FS2UUJJO.js";
 import "./chunk-7P3S7MAY.js";
 import {
   describeActiveWorld,

package/dist/{build-THUEYMVT.js → build-UTVDGHB3.js}

@@ -2,19 +2,19 @@ import {
   DeriveInputError,
   DeriveProviderError,
   deriveWorld
-} from "./chunk-QZ666FCV.js";
+} from "./chunk-735Z3HA4.js";
 import {
   DERIVE_EXIT_CODES
 } from "./chunk-FMSTRBBS.js";
 import "./chunk-OT6PXH54.js";
 import "./chunk-INWQHLPS.js";
 import "./chunk-7P3S7MAY.js";
-import {
-  parseWorldMarkdown
-} from "./chunk-3NZMMSOW.js";
 import {
   emitWorldDefinition
 } from "./chunk-YPCVY4GS.js";
+import {
+  parseWorldMarkdown
+} from "./chunk-3NZMMSOW.js";
 import "./chunk-QWGCMQQD.js";
 
 // src/cli/build.ts

package/dist/{chunk-TZBERHFM.js → chunk-7FL3U7Z5.js}

@@ -1,6 +1,6 @@
 import {
   loadWorld
-} from "./chunk-EQUAWNXW.js";
+} from "./chunk-I4RTIMLX.js";
 import {
   evaluateGuard
 } from "./chunk-ZAF6JH23.js";

package/dist/{chunk-FGOSKQDE.js → chunk-A2UZTLRV.js}

@@ -5,7 +5,7 @@ import {
 } from "./chunk-5U2MQO5P.js";
 import {
   loadWorld
-} from "./chunk-EQUAWNXW.js";
+} from "./chunk-I4RTIMLX.js";
 import {
   evaluateGuard
 } from "./chunk-ZAF6JH23.js";

package/dist/{chunk-R23T5SZG.js → chunk-B3IIPTY3.js}

@@ -7,7 +7,7 @@ import {
 } from "./chunk-5U2MQO5P.js";
 import {
   loadWorld
-} from "./chunk-EQUAWNXW.js";
+} from "./chunk-I4RTIMLX.js";
 import {
   evaluateGuard
 } from "./chunk-ZAF6JH23.js";

package/dist/chunk-EQR7BGFN.js

@@ -0,0 +1,337 @@
+// src/engine/worldmodel-compiler.ts
+function toSnakeCase(text) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, "");
+}
+function toKebabCase(text) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+function titleCase(text) {
+  return text.split(/[\s_-]+/).map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join(" ");
+}
+function matchSignal(behaviorText, signals) {
+  const lowerText = behaviorText.toLowerCase();
+  for (const signal of signals) {
+    const signalWords = signal.toLowerCase().split("_");
+    if (signalWords.some((w) => w.length > 3 && lowerText.includes(w))) {
+      return signal;
+    }
+  }
+  return "alignment_score";
+}
+function emitWorldMarkdown(model) {
+  const lines = [];
+  const worldId = model.frontmatter.model_id;
+  const worldName = model.frontmatter.name;
+  const version = model.frontmatter.version;
+  lines.push("---");
+  lines.push(`world_id: ${worldId}`);
+  lines.push(`name: ${worldName}`);
+  lines.push(`version: ${version}`);
+  lines.push("runtime_mode: COMPLIANCE");
+  lines.push("default_profile: aligned");
+  lines.push("alternative_profile: drifting");
+  lines.push("---");
+  lines.push("");
+  lines.push("# Thesis");
+  lines.push("");
+  lines.push(model.geometry.mission);
+  if (model.geometry.centerIdentity) {
+    lines.push(
+      `When all domains are aligned, the system operates as: ${model.geometry.centerIdentity}.`
+    );
+  }
+  lines.push("");
+  lines.push("# Invariants");
+  lines.push("");
+  let invariantIdx = 0;
+  for (const domain of model.geometry.domains) {
+    for (const value of domain.values) {
+      invariantIdx++;
+      const invId = `${toSnakeCase(domain.name)}_value_${String(invariantIdx).padStart(2, "0")}`;
+      lines.push(
+        `- \`${invId}\` \u2014 ${value} [${domain.name}] (structural, immutable)`
+      );
+    }
+  }
+  lines.push("");
+  lines.push("# State");
+  lines.push("");
+  lines.push("## alignment_score");
+  lines.push("- type: number");
+  lines.push("- min: 0");
+  lines.push("- max: 100");
+  lines.push("- step: 5");
+  lines.push("- default: 70");
+  lines.push("- label: Alignment Score");
+  lines.push(
+    "- description: Composite behavioral alignment metric derived from all signals"
+  );
+  lines.push("");
+  for (const signal of model.evolution.signals) {
+    const signalId = toSnakeCase(signal);
+    const signalLabel = titleCase(signal);
+    lines.push(`## ${signalId}`);
+    lines.push("- type: number");
+    lines.push("- min: 0");
+    lines.push("- max: 100");
+    lines.push("- step: 5");
+    lines.push("- default: 70");
+    lines.push(`- label: ${signalLabel}`);
+    lines.push(`- description: Behavioral signal measuring ${signal.replace(/_/g, " ")}`);
+    lines.push("");
+  }
+  lines.push("# Assumptions");
+  lines.push("");
+  lines.push("## aligned");
+  lines.push("- name: Aligned");
+  lines.push("- description: All behavioral signals at healthy levels");
+  lines.push("- pressure_level: low");
+  lines.push("");
+  lines.push("## drifting");
+  lines.push("- name: Drifting");
+  lines.push("- description: Behavioral signals under pressure with drift risk");
+  lines.push("- pressure_level: high");
+  lines.push("");
+  lines.push("# Rules");
+  lines.push("");
+  let ruleIdx = 0;
+  for (const drift of model.evolution.driftBehaviors) {
+    ruleIdx++;
+    const ruleId = `rule-${String(ruleIdx).padStart(3, "0")}`;
+    const matchedSignal = matchSignal(drift, model.evolution.signals);
+    const signalId = toSnakeCase(matchedSignal);
+    lines.push(`## ${ruleId}: ${drift} (degradation)`);
+    lines.push(`Drift behavior detected: ${drift}`);
+    lines.push("");
+    lines.push(`When ${signalId} < 50 [state]`);
+    lines.push("Then alignment_score *= 0.80");
+    lines.push("");
+    lines.push(`> trigger: ${signalId} drops below threshold`);
+    lines.push(`> rule: Drift behavior weakens alignment`);
+    lines.push(`> shift: Behavioral alignment decreases`);
+    lines.push(`> effect: Alignment score reduced by 20%`);
+    lines.push("");
+  }
+  for (const aligned of model.evolution.alignedBehaviors) {
+    ruleIdx++;
+    const ruleId = `rule-${String(ruleIdx).padStart(3, "0")}`;
+    const matchedSignal = matchSignal(aligned, model.evolution.signals);
+    const signalId = toSnakeCase(matchedSignal);
+    lines.push(`## ${ruleId}: ${aligned} (advantage)`);
+    lines.push(`Aligned behavior reinforced: ${aligned}`);
+    lines.push("");
+    lines.push(`When ${signalId} >= 70 [state]`);
+    lines.push("Then alignment_score *= 1.10");
+    lines.push("");
+    lines.push(`> trigger: ${signalId} above healthy threshold`);
+    lines.push(`> rule: Aligned behavior strengthens system`);
+    lines.push(`> shift: Behavioral alignment increases`);
+    lines.push(`> effect: Alignment score boosted by 10%`);
+    lines.push("");
+  }
+  for (let i = 0; i < model.evolution.decisionPriorities.length; i++) {
+    ruleIdx++;
+    const priority = model.evolution.decisionPriorities[i];
+    const ruleId = `rule-${String(ruleIdx).padStart(3, "0")}`;
+    lines.push(
+      `## ${ruleId}: ${priority.preferred} over ${priority.over} (structural)`
+    );
+    lines.push(
+      `Priority: ${priority.preferred} takes precedence over ${priority.over} in tradeoff situations.`
+    );
+    lines.push("");
+    lines.push("When alignment_score < 40 [state]");
+    lines.push("Then alignment_score *= 0.70");
+    lines.push("Collapse: alignment_score < 10");
+    lines.push("");
+    lines.push(`> trigger: Alignment score critically low`);
+    lines.push(
+      `> rule: Priority violation \u2014 ${priority.preferred} must outweigh ${priority.over}`
+    );
+    lines.push(`> shift: System enters structural enforcement`);
+    lines.push(`> effect: Alignment sharply reduced; collapse if critical`);
+    lines.push("");
+  }
+  lines.push("# Gates");
+  lines.push("");
+  lines.push("- STRONG: alignment_score >= 85");
+  lines.push("- STABLE: alignment_score >= 65");
+  lines.push("- WATCHING: alignment_score >= 45");
+  lines.push("- FRAGILE: alignment_score > 30");
+  lines.push("- MISALIGNED: alignment_score <= 30");
+  lines.push("");
+  lines.push("# Outcomes");
+  lines.push("");
+  lines.push("## alignment_score");
+  lines.push("- type: number");
+  lines.push("- range: 0-100");
+  lines.push("- display: percentage");
+  lines.push("- label: Alignment Score");
+  lines.push("- primary: true");
+  lines.push("");
+  for (const signal of model.evolution.signals) {
+    const signalId = toSnakeCase(signal);
+    const signalLabel = titleCase(signal);
+    lines.push(`## ${signalId}`);
+    lines.push("- type: number");
+    lines.push("- range: 0-100");
+    lines.push("- display: percentage");
+    lines.push(`- label: ${signalLabel}`);
+    lines.push("");
+  }
+  const lensSuggestions = buildLensSuggestions(model);
+  if (lensSuggestions.length > 0) {
+    lines.push("# Lenses");
+    lines.push("- policy: role_default");
+    lines.push("");
+    for (const lens of lensSuggestions) {
+      lines.push(`## ${lens.id}`);
+      lines.push(`- tagline: ${lens.tagline}`);
+      lines.push(
+        `- description: Lens derived from ${lens.derived_from.domainA} and ${lens.derived_from.domainB} interaction, producing ${lens.derived_from.effect}.`
+      );
+      lines.push(`- formality: ${lens.tone.formality}`);
+      lines.push(`- verbosity: ${lens.tone.verbosity}`);
+      lines.push(`- emotion: ${lens.tone.emotion}`);
+      lines.push(`- confidence: ${lens.tone.confidence}`);
+      lines.push("- tags: behavioral, worldmodel, overlap");
+      lines.push("- default_for_roles: all");
+      lines.push("- priority: 50");
+      lines.push("- stackable: true");
+      lines.push("");
+      for (const directive of lens.directives) {
+        lines.push(`> ${directive.scope}: ${directive.instruction}`);
+      }
+      lines.push("");
+    }
+  }
+  return lines.join("\n");
+}
+function emitSignalSchema(model) {
+  const signals = model.evolution.signals.map((signal) => ({
+    id: toSnakeCase(signal),
+    name: titleCase(signal),
+    type: "number",
+    default: 70
+  }));
+  return {
+    model_id: model.frontmatter.model_id,
+    signals
+  };
+}
+function emitOverlapMap(model) {
+  const pairings = model.geometry.overlapEffects.map((o) => ({
+    domainA: o.domainA,
+    domainB: o.domainB,
+    effect: o.effect
+  }));
+  const matrix = {};
+  for (const overlap of model.geometry.overlapEffects) {
+    const keyA = toKebabCase(overlap.domainA);
+    const keyB = toKebabCase(overlap.domainB);
+    if (!matrix[keyA]) matrix[keyA] = {};
+    matrix[keyA][keyB] = overlap.effect;
+  }
+  return {
+    model_id: model.frontmatter.model_id,
+    pairings,
+    matrix
+  };
+}
+function emitContextsConfig(model) {
+  return {
+    model_id: model.frontmatter.model_id,
+    authority_layers: model.modifiers.authorityLayers,
+    spatial_contexts: model.modifiers.spatialContexts,
+    interpretation_rules: model.modifiers.interpretationRules
+  };
+}
+function deriveTone(domainA, domainB) {
+  const combined = `${domainA} ${domainB}`.toLowerCase();
+  let formality = "neutral";
+  if (/strateg|technic|analytic|research|engineer/.test(combined)) {
+    formality = "professional";
+  } else if (/narrat|story|communi|creative/.test(combined)) {
+    formality = "casual";
+  }
+  let verbosity = "balanced";
+  if (/foresight|scenario|plan|design/.test(combined)) {
+    verbosity = "detailed";
+  } else if (/prosper|negotiat|stakeholder/.test(combined)) {
+    verbosity = "concise";
+  }
+  let emotion = "neutral";
+  if (/empath|emoti|care|safe|trust/.test(combined)) {
+    emotion = "warm";
+  } else if (/analytic|system|data/.test(combined)) {
+    emotion = "clinical";
+  }
+  let confidence = "balanced";
+  if (/lead|command|decis|strateg/.test(combined)) {
+    confidence = "authoritative";
+  } else if (/explor|experiment|creat/.test(combined)) {
+    confidence = "exploratory";
+  }
+  return { formality, verbosity, emotion, confidence };
+}
+function buildLensSuggestions(model) {
+  const lenses = [];
+  const domainMap = new Map(model.geometry.domains.map((d) => [d.name.toLowerCase(), d]));
+  for (const overlap of model.geometry.overlapEffects) {
+    const lensId = toKebabCase(overlap.effect);
+    const tone = deriveTone(overlap.domainA, overlap.domainB);
+    const domainAData = domainMap.get(overlap.domainA.toLowerCase());
+    const domainBData = domainMap.get(overlap.domainB.toLowerCase());
+    const directives = [];
+    if (domainAData && domainAData.skills.length > 0) {
+      directives.push({
+        scope: "response_framing",
+        instruction: `Approach through the lens of ${domainAData.skills.join(", ").toLowerCase()}.`
+      });
+    }
+    if (domainBData && domainBData.values.length > 0) {
+      directives.push({
+        scope: "behavior_shaping",
+        instruction: `Maintain ${domainBData.values.join(", ").toLowerCase()} in all responses.`
+      });
+    }
+    directives.push({
+      scope: "value_emphasis",
+      instruction: `Emphasize ${overlap.effect.toLowerCase()} as the emergent state of aligned behavior.`
+    });
+    lenses.push({
+      id: lensId,
+      name: titleCase(overlap.effect),
+      tagline: `${overlap.effect} through ${overlap.domainA} and ${overlap.domainB}.`,
+      derived_from: {
+        domainA: overlap.domainA,
+        domainB: overlap.domainB,
+        effect: overlap.effect
+      },
+      tone,
+      directives
+    });
+  }
+  return lenses;
+}
+function emitLensSuggestions(model) {
+  return buildLensSuggestions(model);
+}
+function compileWorldModel(model) {
+  return {
+    worldMarkdown: emitWorldMarkdown(model),
+    signalSchema: emitSignalSchema(model),
+    overlapMap: emitOverlapMap(model),
+    contextsConfig: emitContextsConfig(model),
+    lensSuggestions: emitLensSuggestions(model)
+  };
+}
+
+export {
+  emitWorldMarkdown,
+  emitSignalSchema,
+  emitOverlapMap,
+  emitContextsConfig,
+  emitLensSuggestions,
+  compileWorldModel
+};

package/dist/{chunk-LAKUB76X.js → chunk-FDPPZLSQ.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-AKW5YVCE.js";
 import {
   loadWorld
-} from "./chunk-EQUAWNXW.js";
+} from "./chunk-I4RTIMLX.js";
 import {
   evaluateGuard
 } from "./chunk-ZAF6JH23.js";

package/dist/{chunk-UZBW44KD.js → chunk-FKQCPRKI.js}

@@ -6,7 +6,7 @@ import {
 } from "./chunk-5U2MQO5P.js";
 import {
   loadWorld
-} from "./chunk-EQUAWNXW.js";
+} from "./chunk-I4RTIMLX.js";
 import {
   evaluateGuard
 } from "./chunk-ZAF6JH23.js";

package/dist/{chunk-XPMZB46F.js → chunk-FS2UUJJO.js}

@@ -35,7 +35,7 @@ async function addGuard(worldDir, input) {
   };
   config.guards.push(guard);
   await writeFile(guardsPath, JSON.stringify(config, null, 2) + "\n");
-  const { loadWorldFromDirectory } = await import("./world-loader-J47PCPDZ.js");
+  const { loadWorldFromDirectory } = await import("./world-loader-YTYFOP7D.js");
   const world = await loadWorldFromDirectory(worldDir);
   const report = validateWorld(world);
   return {
@@ -83,7 +83,7 @@ async function addRule(worldDir, input) {
   };
   const rulePath = join(rulesDir, `rule-${ruleNum}.json`);
   await writeFile(rulePath, JSON.stringify(rule, null, 2) + "\n");
-  const { loadWorldFromDirectory } = await import("./world-loader-J47PCPDZ.js");
+  const { loadWorldFromDirectory } = await import("./world-loader-YTYFOP7D.js");
   const world = await loadWorldFromDirectory(worldDir);
   const report = validateWorld(world);
   return {
@@ -118,7 +118,7 @@ async function addInvariant(worldDir, input) {
   };
   config.invariants.push(invariant);
   await writeFile(invariantsPath, JSON.stringify(config, null, 2) + "\n");
-  const { loadWorldFromDirectory } = await import("./world-loader-J47PCPDZ.js");
+  const { loadWorldFromDirectory } = await import("./world-loader-YTYFOP7D.js");
   const world = await loadWorldFromDirectory(worldDir);
   const report = validateWorld(world);
   return {