@neuroverseos/governance 0.4.0 → 0.4.1

package/dist/types.d.ts

@@ -0,0 +1,370 @@
+/**
+ * World Engine Types — Subset for Governance Engine
+ *
+ * These types map to the .nv-world.zip file format.
+ * This file contains only the types referenced by the governance
+ * engine (guard, validate, bootstrap). The full type system lives
+ * in the main NeuroVerse OS repo.
+ */
+interface ModelIdentity {
+    modelName: string;
+    acronymExpansion?: string;
+    nameType: 'acronym' | 'metaphor';
+    purpose: string;
+    domain?: string;
+}
+interface WorldIdentity {
+    world_id: string;
+    name: string;
+    thesis: string;
+    version: string;
+    runtime_mode: 'SIMULATION' | 'NARRATIVE' | 'COMPLIANCE' | 'CUSTOM';
+    default_assumption_profile: string;
+    default_alternative_profile: string;
+    modules: string[];
+    players: {
+        thinking_space: boolean;
+        experience_space: boolean;
+        action_space: boolean;
+    };
+    modelIdentity?: ModelIdentity;
+}
+interface Invariant {
+    id: string;
+    label: string;
+    enforcement: 'structural' | 'prompt';
+    mutable: false;
+}
+interface AssumptionProfile {
+    name: string;
+    description: string;
+    is_default_baseline?: boolean;
+    is_default_alternative?: boolean;
+    parameters: Record<string, string>;
+}
+interface ParameterDefinition {
+    type: 'enum' | 'number' | 'boolean';
+    options?: string[];
+    min?: number;
+    max?: number;
+    label: string;
+    description: string;
+}
+interface AssumptionConfig {
+    profiles: Record<string, AssumptionProfile>;
+    parameter_definitions: Record<string, ParameterDefinition>;
+}
+interface StateVariable {
+    type: 'enum' | 'number' | 'boolean';
+    options?: string[];
+    min?: number;
+    max?: number;
+    step?: number;
+    default: string | number | boolean;
+    mutable: boolean;
+    label: string;
+    description: string;
+    display_as?: 'percentage' | 'integer' | 'decimal';
+}
+interface StatePreset {
+    description: string;
+    values: Record<string, string | number | boolean>;
+}
+interface StateSchema {
+    variables: Record<string, StateVariable>;
+    presets: Record<string, StatePreset>;
+}
+type TriggerOperator = '==' | '!=' | '>' | '<' | '>=' | '<=' | 'in';
+type EffectOperation = 'multiply' | 'add' | 'subtract' | 'set' | 'set_boolean' | 'multiply_dynamic' | 'add_dynamic' | 'subtract_dynamic' | 'set_dynamic';
+type RuleSeverity = 'structural' | 'degradation' | 'advantage';
+interface Trigger {
+    field: string;
+    operator: TriggerOperator;
+    value: string | number | boolean | string[];
+    source: 'state' | 'assumption';
+}
+interface Effect {
+    target: string;
+    operation: EffectOperation;
+    value: number | boolean | string;
+    value_formula?: string;
+}
+interface CollapseCheck {
+    field: string;
+    operator: TriggerOperator;
+    value: number;
+    result: 'MODEL_COLLAPSES';
+}
+interface ConditionalEffect {
+    condition: Trigger;
+    and?: Trigger;
+    or?: Trigger;
+    condition_any?: Trigger[];
+    effects: Effect[];
+}
+interface CausalTranslation {
+    trigger_text: string;
+    rule_text: string;
+    shift_text: string;
+    effect_text: string;
+}
+interface RuleRedirect {
+    suggested_action: string;
+    reason: string;
+    fallback_state_changes?: Record<string, string | number | boolean>;
+}
+interface Rule {
+    id: string;
+    severity: RuleSeverity;
+    label: string;
+    description: string;
+    order: number;
+    triggers: Trigger[];
+    effects?: Effect[];
+    effects_conditional?: ConditionalEffect[];
+    collapse_check?: CollapseCheck;
+    secondary_check?: CollapseCheck;
+    exclusive_with?: string;
+    causal_translation: CausalTranslation;
+    redirect?: RuleRedirect;
+}
+type ViabilityStatus = 'THRIVING' | 'STABLE' | 'COMPRESSED' | 'CRITICAL' | 'MODEL_COLLAPSES';
+interface ViabilityGate {
+    status: ViabilityStatus;
+    field: string;
+    operator: TriggerOperator;
+    value: number;
+    color: string;
+    icon: string;
+}
+interface CollapseVisual {
+    background: string;
+    text: string;
+    border: string;
+    label: string;
+}
+interface GatesConfig {
+    viability_classification: ViabilityGate[];
+    structural_override: {
+        description: string;
+        enforcement: 'mandatory';
+    };
+    sustainability_threshold: number;
+    collapse_visual: CollapseVisual;
+}
+interface ComputedOutcome {
+    id: string;
+    type: 'number' | 'boolean' | 'enum';
+    range?: [number, number];
+    options?: string[];
+    default?: number | boolean | string;
+    display_as?: 'percentage' | 'integer' | 'decimal';
+    label: string;
+    primary?: boolean;
+    initial_value?: string;
+    derived_from?: string;
+    assignment?: 'rule' | 'external';
+    show_in_comparison: boolean;
+    structural_indicator?: boolean;
+}
+interface ComparisonLayout {
+    primary_card: string;
+    status_badge: string;
+    structural_indicators: string[];
+}
+interface OutcomesConfig {
+    computed_outcomes: ComputedOutcome[];
+    comparison_layout: ComparisonLayout;
+}
+interface WorldMetadata {
+    format_version: string;
+    created_at: string;
+    last_modified: string;
+    authoring_method: 'manual-authoring' | 'configurator-ai' | 'migration';
+    integrity_hash?: string;
+}
+interface KernelConfig {
+    artifact_type: string;
+    kernel_id: string;
+    version: string;
+    domain: string;
+    enforcement_level: 'standard' | 'strict' | 'permissive';
+    input_boundaries: {
+        forbidden_patterns: Array<{
+            id: string;
+            pattern: string;
+            reason: string;
+            action: 'BLOCK' | 'WARN';
+        }>;
+    };
+    output_boundaries: {
+        forbidden_patterns: Array<{
+            id: string;
+            pattern: string;
+            reason: string;
+            action: 'BLOCK' | 'WARN';
+        }>;
+    };
+    response_vocabulary: Record<string, string>;
+    metadata: {
+        compiled_by: string;
+        compiled_at: string;
+        source_hash: string;
+        compiler_version: string;
+    };
+}
+type RoleArchetype = 'observer' | 'operator' | 'strategist' | 'guardian' | 'steward' | 'executor';
+type RoleAuthority = 'none' | 'execute_within_limits' | 'reprioritize_within_bounds' | 'block_violations' | 'escalate_audit_freeze' | 'execute_declared_actions';
+type RolePosture = 'analyze' | 'task_oriented' | 'long_term_coherence' | 'constraint_aware' | 'system_integrity' | 'efficient';
+interface WorldRoleDefinition {
+    id: string;
+    archetype: RoleArchetype;
+    authority: RoleAuthority;
+    posture: RolePosture;
+    name: string;
+    description: string;
+    icon?: string;
+    roleMandate: string;
+    voiceStyle?: string;
+    canDo: string[];
+    cannotDo: string[];
+    requiresApproval?: boolean;
+    trackedOutcomes?: string[];
+    ownedRules?: string[];
+    /** Default lens for this role (references a lens id from the world's lenses config) */
+    defaultLens?: string;
+}
+type RoleAssignment = 'dynamic' | 'per_session' | 'permanent';
+interface RoleTransition {
+    from: string;
+    to: string;
+    initiator: 'self' | 'steward' | 'any';
+    condition?: string;
+}
+interface RolesConfig {
+    assignment: RoleAssignment;
+    roles: WorldRoleDefinition[];
+    transitions?: RoleTransition[];
+}
+interface Guard {
+    id: string;
+    label: string;
+    description: string;
+    category: 'structural' | 'operational' | 'advisory';
+    enforcement: 'block' | 'pause' | 'warn' | 'modify' | 'penalize' | 'reward' | 'neutral';
+    immutable: boolean;
+    invariant_ref?: string;
+    intent_patterns: string[];
+    required_roles?: string[];
+    redirect?: string;
+    default_enabled?: boolean;
+    /** Tool names this guard applies to (case-insensitive). Empty/absent = all tools. */
+    appliesTo?: string[];
+    player_modes?: {
+        thinking?: 'annotate' | 'block' | 'ignore';
+        experience?: 'simulate' | 'score' | 'ignore';
+        action?: 'block' | 'pause' | 'warn' | 'modify' | 'penalize' | 'reward' | 'neutral';
+    };
+    /** Consequence to apply when enforcement is 'penalize' */
+    consequence?: {
+        type: 'freeze' | 'reduce_influence' | 'increase_risk' | 'cooldown' | 'custom';
+        rounds?: number;
+        magnitude?: number;
+        description: string;
+    };
+    /** Reward to apply when enforcement is 'reward' */
+    reward?: {
+        type: 'boost_influence' | 'priority' | 'faster_execution' | 'weight_increase' | 'custom';
+        rounds?: number;
+        magnitude?: number;
+        description: string;
+    };
+    /** For 'modify' enforcement: what the action should be changed to */
+    modify_to?: string;
+}
+interface IntentPattern {
+    label: string;
+    pattern: string;
+}
+interface GuardsConfig {
+    guards: Guard[];
+    intent_vocabulary: Record<string, IntentPattern>;
+    /** All known action surfaces (e.g. "shell", "http", "db", "email", "deploy").
+     *  When declared, the validator checks that every surface has at least one
+     *  governing guard — surfaces without guards are reported as fail-open. */
+    tool_surfaces?: string[];
+}
+/**
+ * A governance event — the bridge between Guard and Simulate.
+ *
+ * Guard produces events (what happened).
+ * Simulate consumes events (what changes because of it).
+ *
+ * Events are NOT stored — they flow through the system.
+ * Guard evaluation log IS the event stream.
+ */
+interface GovernanceEvent {
+    /** Semantic event type: "complaint", "refund", "action_blocked", etc. */
+    type: string;
+    /** Who caused this event */
+    actor?: 'customer' | 'agent' | 'system';
+    /** Where the event originated */
+    source: 'guard' | 'manual' | 'system';
+    /** Unix timestamp (ms) */
+    timestamp: number;
+    /** Guard status that produced this event (when source=guard) */
+    guardStatus?: 'ALLOW' | 'BLOCK' | 'PAUSE' | 'MODIFY' | 'PENALIZE' | 'REWARD' | 'NEUTRAL';
+    /** Optional metadata */
+    metadata?: Record<string, unknown>;
+}
+interface LensDirectiveConfig {
+    id: string;
+    scope: 'response_framing' | 'language_style' | 'content_filtering' | 'value_emphasis' | 'behavior_shaping';
+    instruction: string;
+}
+interface LensConfig {
+    id: string;
+    name: string;
+    tagline: string;
+    description: string;
+    tags: string[];
+    tone: {
+        formality: 'casual' | 'neutral' | 'formal' | 'professional';
+        verbosity: 'terse' | 'concise' | 'balanced' | 'detailed';
+        emotion: 'warm' | 'neutral' | 'reserved' | 'clinical';
+        confidence: 'humble' | 'balanced' | 'authoritative' | 'assertive';
+    };
+    directives: LensDirectiveConfig[];
+    defaultForRoles: string[];
+    priority: number;
+    stackable: boolean;
+}
+interface LensesConfig {
+    lenses: LensConfig[];
+    /**
+     * Lens policy:
+     * - 'locked': lenses are assigned by role, user cannot change without pin
+     * - 'role_default': lenses start as role default, user can override
+     * - 'user_choice': no default, user picks freely
+     */
+    policy?: 'locked' | 'role_default' | 'user_choice';
+    /** Pin required to change lenses when policy is 'locked' */
+    lockPin?: string;
+}
+interface WorldDefinition {
+    world: WorldIdentity;
+    invariants: Invariant[];
+    assumptions: AssumptionConfig;
+    stateSchema: StateSchema;
+    rules: Rule[];
+    gates: GatesConfig;
+    outcomes: OutcomesConfig;
+    guards?: GuardsConfig;
+    roles?: RolesConfig;
+    kernel?: KernelConfig;
+    lenses?: LensesConfig;
+    enforcement?: string;
+    metadata: WorldMetadata;
+}
+
+export type { AssumptionConfig, AssumptionProfile, CausalTranslation, CollapseCheck, CollapseVisual, ComparisonLayout, ComputedOutcome, ConditionalEffect, Effect, EffectOperation, GatesConfig, GovernanceEvent, Guard, GuardsConfig, IntentPattern, Invariant, KernelConfig, LensConfig, LensDirectiveConfig, LensesConfig, ModelIdentity, OutcomesConfig, ParameterDefinition, RoleArchetype, RoleAssignment, RoleAuthority, RolePosture, RoleTransition, RolesConfig, Rule, RuleRedirect, RuleSeverity, StatePreset, StateSchema, StateVariable, Trigger, TriggerOperator, ViabilityGate, ViabilityStatus, WorldDefinition, WorldIdentity, WorldMetadata, WorldRoleDefinition };

package/dist/{validate-Q5O5TGLT.js → validate-M52DX22Y.js}

@@ -6,7 +6,7 @@ import {
 } from "./chunk-7P3S7MAY.js";
 import {
   loadWorld
-} from "./chunk-BXLTEUS4.js";
+} from "./chunk-I4RTIMLX.js";
 import "./chunk-QWGCMQQD.js";
 
 // src/cli/validate.ts

package/dist/{world-V52ZMH26.js → world-O4HTQPDP.js}

@@ -10,7 +10,7 @@ import {
 } from "./chunk-AKW5YVCE.js";
 import {
   loadWorld
-} from "./chunk-BXLTEUS4.js";
+} from "./chunk-I4RTIMLX.js";
 import "./chunk-QWGCMQQD.js";
 
 // src/cli/world.ts

package/dist/{world-loader-C4D3VPP3.js → world-loader-YTYFOP7D.js}

@@ -3,7 +3,7 @@ import {
   loadBundledWorld,
   loadWorld,
   loadWorldFromDirectory
-} from "./chunk-BXLTEUS4.js";
+} from "./chunk-I4RTIMLX.js";
 import "./chunk-QWGCMQQD.js";
 export {
   DEFAULT_BUNDLED_WORLD,

package/dist/worlds/mentraos-spatial.nv-world.md

@@ -0,0 +1,68 @@
+---
+world_id: mentraos-spatial
+name: "MentraOS Spatial Governance"
+version: "1.0.0"
+runtime_mode: COMPLIANCE
+description: >
+  Spatial governance layer for MentraOS smart glasses. Activates when
+  glasses detect zones (via Auki anchors, BLE, geofence) or nearby
+  participants (multi-user handshake). Rules are temporary — they apply
+  while you're in the space and dissolve when you leave.
+---
+
+# Thesis
+
+Smart glasses live in the real world. The rules that apply at home don't apply at a hospital. The rules that apply when you're alone don't apply when you're standing next to someone who doesn't want to be recorded. Spatial governance makes AI respect the physical context it operates in.
+
+This world governs the spatial layer — the bridge between physical location and AI behavior. It enforces three principles: (1) zones publish rules and users opt in explicitly, (2) when multiple AR users share a space their governance composes via handshake with "most restrictive wins," and (3) all spatial rules are temporary — they dissolve when you leave.
+
+This layer sits between user rules (which always win) and the platform world. A zone can tighten your rules, never relax them. A handshake participant can tighten the group, never relax it.
+
+# Invariants
+
+- `opt_in_required` — Users must explicitly accept a zone's rules before they apply. No zone can force governance on a user without consent. Discovery is passive; acceptance is active. (structural, immutable)
+- `most_restrictive_wins` — When zone rules, handshake rules, and user rules overlap, the most restrictive value for each field wins. A zone cannot relax your personal rules. A single handshake participant blocking recording means nobody records. (structural, immutable)
+- `rules_are_temporary` — Spatial rules apply only during the spatial session. When you leave a zone or a handshake dissolves, the rules dissolve with it. No spatial rule persists beyond the session. (structural, immutable)
+- `no_identity_leak` — Handshake negotiation shares governance constraints, not identity. "I require no recording" is a constraint, not a name. Participants are anonymous by default. (structural, immutable)
+- `zone_transparency` — When a zone's rules are active, the user must be able to see which zone they're in, what rules apply, and how to exit. No invisible governance. (structural, immutable)
+- `user_can_always_leave` — A user can exit any zone or leave any handshake at any time. Governance never traps the user. If you don't like the rules, you leave. Your personal rules remain. (structural, immutable)
+- `physics_over_policy` — Hardware constraints override spatial rules. If glasses don't have a camera, a zone rule allowing cameras is irrelevant. Physics always wins. (structural, immutable)
+- `bystander_default_protection` — In any space with non-consenting bystanders, the default is elevated bystander protection. Zones can tighten this to strict. No zone can lower it below standard. (structural, immutable)
+
+# State
+
+- `active_zone` — string, initial "none". The currently active zone ID.
+- `zone_opt_ins` — counter, initial 0. Number of zone opt-ins this session.
+- `zone_declines` — counter, initial 0. Number of zone opt-in declines.
+- `handshake_participants` — counter, initial 0. Current handshake participant count.
+- `handshake_negotiations` — counter, initial 0. Number of handshake re-negotiations.
+- `spatial_blocks` — counter, initial 0. Number of intents blocked by spatial rules.
+- `spatial_confirms` — counter, initial 0. Number of intents requiring spatial confirmation.
+- `spatial_trust` — score, initial 1.0, range [0.0, 1.0]. Spatial governance health score.
+
+# Assumptions
+
+- `standard` — Default spatial behavior. zone_opt_in_required=true, handshake_auto_join=false, bystander_protection=elevated, max_handshake_participants=10
+- `strict` — Privacy-first spatial. zone_opt_in_required=true, handshake_auto_join=false, bystander_protection=strict, max_handshake_participants=5
+- `open` — For controlled spaces (home, private office). zone_opt_in_required=false, handshake_auto_join=true, bystander_protection=standard, max_handshake_participants=20
+
+# Rules
+
+- `rule-001` — Zone rules applied without opt-in. trigger: zone_active AND NOT zone_opted_in → spatial_trust *= 0.10, BLOCK: "Zone rules cannot apply without your explicit opt-in."
+- `rule-002` — Handshake identity leaked. trigger: handshake_active AND identity_shared → spatial_trust *= 0.05, BLOCK: "Handshake negotiation must be anonymous."
+- `rule-003` — Bystander protection violated. trigger: bystander_protection == "strict" AND camera == "allowed" → spatial_trust *= 0.20, BLOCK: "Camera blocked in strict bystander protection zone."
+- `rule-004` — Zone exit blocked. trigger: user_exit_requested AND exit_denied → spatial_trust *= 0.01, BLOCK: "Users must always be able to exit a zone."
+- `rule-005` — Spatial rules persisted beyond session. trigger: session_ended AND spatial_rules_active → spatial_trust *= 0.10, BLOCK: "Spatial rules must dissolve when session ends."
+- `rule-006` — Clean spatial session (advantage). trigger: zone_opt_ins > 0 AND spatial_blocks == 0 → spatial_trust *= 1.08
+- `rule-007` — Zone relaxing user rules. trigger: zone_rule_less_restrictive_than_user_rule → spatial_trust *= 0.30, BLOCK: "Zones can only tighten rules, never relax them."
+
+# Gates
+
+- ACTIVE: spatial_trust >= 0.7
+- CAUTIOUS: spatial_trust >= 0.3
+- SUSPENDED: spatial_trust < 0.3
+
+# Outcomes
+
+- `clean_spatial` — Desired. User navigated zones and handshakes with no governance violations. Tracked by: zone_opt_ins > 0 AND spatial_blocks == 0.
+- `forced_governance` — Undesired. A zone or handshake tried to apply rules without consent. Tracked by: spatial_trust < 0.5.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neuroverseos/governance",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "Deterministic governance engine for AI agents — enforce worlds (permanent rules) and plans (mission constraints) with full audit trace",
   "license": "Apache-2.0",
   "type": "module",
@@ -48,10 +48,45 @@
       "import": "./dist/adapters/deep-agents.js",
       "require": "./dist/adapters/deep-agents.cjs"
     },
+    "./spatial": {
+      "types": "./dist/spatial/index.d.ts",
+      "import": "./dist/spatial/index.js",
+      "require": "./dist/spatial/index.cjs"
+    },
     "./plan": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
       "require": "./dist/index.cjs"
+    },
+    "./adapters/mentraos": {
+      "types": "./dist/adapters/mentraos.d.ts",
+      "import": "./dist/adapters/mentraos.js",
+      "require": "./dist/adapters/mentraos.cjs"
+    },
+    "./engine/guard-engine": {
+      "types": "./dist/engine/guard-engine.d.ts",
+      "import": "./dist/engine/guard-engine.js",
+      "require": "./dist/engine/guard-engine.cjs"
+    },
+    "./engine/simulate-engine": {
+      "types": "./dist/engine/simulate-engine.d.ts",
+      "import": "./dist/engine/simulate-engine.js",
+      "require": "./dist/engine/simulate-engine.cjs"
+    },
+    "./engine/bootstrap-parser": {
+      "types": "./dist/engine/bootstrap-parser.d.ts",
+      "import": "./dist/engine/bootstrap-parser.js",
+      "require": "./dist/engine/bootstrap-parser.cjs"
+    },
+    "./engine/bootstrap-emitter": {
+      "types": "./dist/engine/bootstrap-emitter.d.ts",
+      "import": "./dist/engine/bootstrap-emitter.js",
+      "require": "./dist/engine/bootstrap-emitter.cjs"
+    },
+    "./types": {
+      "types": "./dist/types.d.ts",
+      "import": "./dist/types.js",
+      "require": "./dist/types.cjs"
     }
   },
   "bin": {
@@ -73,7 +108,7 @@
     ".well-known"
   ],
   "scripts": {
-    "build": "tsup src/index.ts src/cli/neuroverse.ts src/cli/plan.ts src/cli/run.ts src/adapters/index.ts src/adapters/langchain.ts src/adapters/openai.ts src/adapters/openclaw.ts src/adapters/express.ts src/adapters/autoresearch.ts src/adapters/deep-agents.ts --format esm,cjs --dts --clean && npm run build:browser && cp src/worlds/*.nv-world.md dist/worlds/ && npm run build:viz",
+    "build": "tsup src/index.ts src/types.ts src/cli/neuroverse.ts src/cli/plan.ts src/cli/run.ts src/adapters/index.ts src/adapters/langchain.ts src/adapters/openai.ts src/adapters/openclaw.ts src/adapters/express.ts src/adapters/autoresearch.ts src/adapters/deep-agents.ts src/adapters/mentraos.ts src/engine/guard-engine.ts src/engine/simulate-engine.ts src/engine/bootstrap-parser.ts src/engine/bootstrap-emitter.ts src/spatial/index.ts --format esm,cjs --dts --clean && npm run build:browser && cp src/worlds/*.nv-world.md dist/worlds/ && cp src/spatial/zones/*.nv-world.md dist/worlds/ && npm run build:viz",
     "build:browser": "tsup src/browser.ts --format iife --global-name NeuroVerse --outDir dist --no-dts",
     "build:viz": "vite build",
     "dev:viz": "vite dev",
@@ -122,7 +157,15 @@
     "deep-agents",
     "coding-agents",
     "ai-firewall",
-    "agent-guardrails"
+    "agent-guardrails",
+    "smart-glasses",
+    "spatial-governance",
+    "mentra",
+    "mentraos",
+    "ar-governance",
+    "spatial-handshake",
+    "zone-governance",
+    "auki"
   ],
   "repository": {
     "type": "git",

package/dist/{behavioral-SPWPGYXL.js → behavioral-SLW7ALEK.js}

@@ -1,11 +1,11 @@
+import {
+  readAuditLog
+} from "./chunk-2VAWP6FI.js";
 import {
   adaptationFromVerdict,
   detectBehavioralPatterns,
   generateAdaptationNarrative
 } from "./chunk-CNSO6XW5.js";
-import {
-  readAuditLog
-} from "./chunk-2VAWP6FI.js";
 import "./chunk-ZAF6JH23.js";
 import "./chunk-QLPTHTVB.js";
 import "./chunk-QWGCMQQD.js";

package/dist/{bootstrap-IP5QMC3Q.js → bootstrap-2OW5ZLBL.js}

@@ -1,12 +1,12 @@
 import {
   BOOTSTRAP_EXIT_CODES
 } from "./chunk-4NGDRRQH.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/bootstrap.ts

package/dist/{chunk-QZ666FCV.js → chunk-FHXXD2TI.js}

@@ -1,18 +1,18 @@
-import {
-  loadConfig
-} from "./chunk-OT6PXH54.js";
 import {
   createProvider
 } from "./chunk-INWQHLPS.js";
+import {
+  loadConfig
+} from "./chunk-OT6PXH54.js";
 import {
   validateWorld
 } from "./chunk-7P3S7MAY.js";
-import {
-  parseWorldMarkdown
-} from "./chunk-3NZMMSOW.js";
 import {
   emitWorldDefinition
 } from "./chunk-YPCVY4GS.js";
+import {
+  parseWorldMarkdown
+} from "./chunk-3NZMMSOW.js";
 
 // src/engine/derive-normalizer.ts
 function findSections(lines) {

package/dist/{configure-ai-5MP5DWTT.js → configure-ai-LL3VAPQW.js}

@@ -1,15 +1,15 @@
 import {
   CONFIGURE_AI_EXIT_CODES
 } from "./chunk-FMSTRBBS.js";
+import {
+  createProvider
+} from "./chunk-INWQHLPS.js";
 import {
   getConfigPath,
   loadConfig,
   redactConfig,
   saveConfig
 } from "./chunk-OT6PXH54.js";
-import {
-  createProvider
-} from "./chunk-INWQHLPS.js";
 import "./chunk-QWGCMQQD.js";
 
 // src/cli/configure-ai.ts