Steps 7–24: Persistent WebXR Disability World + Wolfram-grounded algorithms

App.tsx

@@ -16,12 +16,21 @@ function MobileSimulation() {
   const refresh = () => setRevision(runtime.kernel.snapshot().revision);
   const choose = (choiceId: string) => { runtime.emit('scenario.choice.committed', { choiceId }); refresh(); };
   const state = runtime.kernel.snapshot();
+
   return <SafeAreaView style={styles.safeArea}><StatusBar style="auto"/><ScrollView contentContainerStyle={styles.container}>
     <Text accessibilityRole="header" style={styles.title}>MERT Engine · Companion</Text>
     <Text>Open the web deployment on a WebXR headset for the immersive world.</Text>
-    <View style={styles.card}><Text style={styles.heading}>World State</Text><Text>HR {state.vitals.heartRate} · RR {state.vitals.respiratoryRate} · SpO₂ {state.vitals.spo2}%</Text><Text>AAC: {state.communication.available ? 'AVAILABLE' : 'UNAVAILABLE'}</Text><Text>Revision: {revision}</Text></View>
-    <Pressable accessibilityRole="button" style={styles.button} onPress={()=>choose('restore-access')}><Text style={styles.buttonText}>Restore AAC + Position</Text></Pressable>
-    <Pressable accessibilityRole="button" style={styles.button} onPress={()=>choose('escalate')}><Text style={styles.buttonText}>Escalate</Text></Pressable>
+    <View style={styles.card}>
+      <Text style={styles.heading}>World State</Text>
+      <Text>HR {state.vitals.heartRate} · RR {state.vitals.respiratoryRate} · SpO₂ {state.vitals.spo2}%</Text>
+      <Text>AAC: {state.communication.available ? 'AVAILABLE' : 'UNAVAILABLE'} · {state.communication.reliable ? 'RELIABLE' : 'UNRELIABLE'}</Text>
+      <Text>Decision authority: {state.authority.decisionMaker}</Text>
+      <Text>Revision: {revision}</Text>
+    </View>
+    <Pressable accessibilityRole="button" accessibilityLabel="Restore communication and positioning access" style={styles.button} onPress={()=>choose('restore-access')}><Text style={styles.buttonText}>Restore AAC + Position</Text></Pressable>
+    <Pressable accessibilityRole="button" accessibilityLabel="Escalate to senior support" style={styles.button} onPress={()=>choose('escalate')}><Text style={styles.buttonText}>Escalate</Text></Pressable>
+    <Pressable accessibilityRole="button" accessibilityLabel="Choose diagnostic overshadowing branch" style={styles.button} onPress={()=>choose('anchor-on-disability')}><Text style={styles.buttonText}>Anchor on Baseline Disability</Text></Pressable>
   </ScrollView></SafeAreaView>;
 }
+
 const styles=StyleSheet.create({safeArea:{flex:1},container:{padding:20,gap:12,maxWidth:820,width:'100%',alignSelf:'center'},title:{fontSize:28,fontWeight:'700'},card:{borderWidth:1,borderRadius:12,padding:16,gap:6},heading:{fontSize:19,fontWeight:'700'},button:{borderWidth:2,borderRadius:10,padding:16},buttonText:{fontWeight:'700'}});

__tests__/liveWorldIntegration.test.ts

@@ -0,0 +1,35 @@
+import { LiveWorldLoop } from '../src/world/liveWorldLoop';
+import { PersistentWorldStore, initialOpenWorldState, type PersonEntity } from '../src/world/worldModel';
+import { addInfrastructure, validateWorldDraft, type WorldStudioDraft } from '../src/world/scenarioStudio';
+
+function memoryStore() {
+  return new PersistentWorldStore(initialOpenWorldState);
+}
+
+describe('live disability world integration', () => {
+  test('autonomous travel changes position without changing person authority', () => {
+    const store = memoryStore();
+    const before = store.entity('maya') as PersonEntity;
+    const start = [...before.position];
+    const loop = new LiveWorldLoop(store);
+    loop.step(3);
+    const after = store.entity('maya') as PersonEntity;
+    expect(after.position).not.toEqual(start);
+    expect(after.authority).toBe('self');
+  });
+
+  test('infrastructure failure remains an environmental event', () => {
+    const store = memoryStore();
+    store.setInfrastructure('station-lift', false);
+    const event = store.snapshot().events.at(-1);
+    expect(event?.type).toBe('infrastructure.changed');
+    expect(event?.detail).toContain('unavailable');
+    expect((store.entity('maya') as PersonEntity).authority).toBe('self');
+  });
+
+  test('Scenario Studio rejects silent authority reassignment', () => {
+    const draft: WorldStudioDraft = { title: 'Test', description: 'Test world', seed: initialOpenWorldState };
+    const extended = addInfrastructure(draft, { id: 'test-ramp', label: 'Test ramp', position: [0,0,0], feature: 'ramp', accessibility: ['powered-wheelchair'] });
+    expect(validateWorldDraft(extended).filter(issue => issue.severity === 'error')).toHaveLength(0);
+  });
+});

__tests__/liveWorldLoop.test.ts

@@ -0,0 +1,30 @@
+import { defaultSchedules, runDailyLifeTick } from '../src/world/dailyLife';
+import { LiveWorldLoop } from '../src/world/liveWorldLoop';
+import { addInfrastructure, exportWorldDraft, validateWorldDraft } from '../src/world/scenarioStudio';
+import { initialOpenWorldState, PersistentWorldStore, type PersonEntity } from '../src/world/worldModel';
+
+describe('live disability world integration', () => {
+  it('plans daily life without replacing person authority', () => {
+    const schedule = defaultSchedules[0];
+    expect(schedule).toBeDefined();
+    if (!schedule) return;
+    const tick = runDailyLifeTick(initialOpenWorldState, schedule);
+    expect(tick.activity?.personId).toBe('maya');
+    const maya = initialOpenWorldState.entities.find((entity): entity is PersonEntity => entity.id === 'maya' && entity.kind === 'person');
+    expect(maya?.authority).toBe('self');
+  });
+
+  it('runs the bounded world loop and records dynamics events', () => {
+    const store = new PersistentWorldStore(initialOpenWorldState);
+    const loop = new LiveWorldLoop(store);
+    loop.step(6);
+    expect(store.snapshot().events.some((event) => event.type.startsWith('vnn.'))).toBe(true);
+  });
+
+  it('scenario studio validates duplicate IDs and authority invariants', () => {
+    const draft = { title: 'Test', description: '', seed: initialOpenWorldState };
+    const withDuplicate = addInfrastructure(draft, { id: 'station-lift', label: 'Duplicate lift', position: [0,0,0], feature: 'lift', accessibility: ['powered-wheelchair'] });
+    expect(validateWorldDraft(withDuplicate).some((issue) => issue.severity === 'error')).toBe(true);
+    expect(() => exportWorldDraft(withDuplicate)).toThrow();
+  });
+});

__tests__/worldAdvanced.test.ts

@@ -0,0 +1,47 @@
+import { initialOpenWorldState } from '../src/world/worldModel';
+import { defaultSocialAgents, interact } from '../src/world/socialAgents';
+import { assessClinicalTrigger } from '../src/world/clinicalBridge';
+import { WorldTimeline } from '../src/world/timeline';
+import { equivalentAction, validateInteractionProfile } from '../src/world/vrInteraction';
+
+describe('advanced disability world invariants', () => {
+  it('keeps an unavailable AAC answer unknown rather than transferring authority', () => {
+    const state = JSON.parse(JSON.stringify(initialOpenWorldState));
+    const maya = state.entities.find((entity: any) => entity.id === 'maya');
+    maya.communication.access = 'unavailable';
+    const agent = defaultSocialAgents[0];
+    expect(agent).toBeDefined();
+    if (!agent) return;
+    const interaction = interact(state, agent, 'maya', 'ask');
+    expect(interaction?.outcome).toBe('unknown');
+    expect(maya.authority).toBe('self');
+  });
+
+  it('does not launch a clinical scenario without an evidence-gated health transition', () => {
+    const assessment = assessClinicalTrigger(initialOpenWorldState, 'maya', []);
+    expect(assessment.status).toBe('continue-world');
+    expect(assessment.preserve.authority).toBe(true);
+  });
+
+  it('creates counterfactual branches without mutating the captured original', () => {
+    const timeline = new WorldTimeline();
+    const original = timeline.capture(initialOpenWorldState, 'original');
+    const branch = timeline.branch(original.id, 'lift failure', (state) => {
+      const lift = state.entities.find((entity) => entity.id === 'station-lift') as any;
+      lift.operational = false;
+    }, 'station lift unavailable');
+    expect((timeline.get(original.id)?.state.entities.find((entity) => entity.id === 'station-lift') as any).operational).toBe(true);
+    expect((branch?.state.entities.find((entity) => entity.id === 'station-lift') as any).operational).toBe(false);
+  });
+
+  it('treats VR and switch selection as equivalent semantic actions', () => {
+    expect(equivalentAction(
+      { actorId: 'maya', action: 'select', targetId: 'community-hub', modality: 'xr-controller' },
+      { actorId: 'maya', action: 'select', targetId: 'community-hub', modality: 'switch' },
+    )).toBe(true);
+  });
+
+  it('rejects reduced-motion smooth locomotion configuration', () => {
+    expect(validateInteractionProfile({ modalities: ['gaze'], locomotion: 'smooth', reducedMotion: true, dwellMilliseconds: 1200, responseTimeMultiplier: 2 })).toContain('reduced-motion profile should use teleport, seated snap turn, or non-spatial locomotion');
+  });
+});

__tests__/worldAutonomy.test.ts

@@ -0,0 +1,38 @@
+import { initialOpenWorldState } from '../src/world/worldModel';
+import { evaluateAffordance } from '../src/world/affordanceGraph';
+import { planNextActivity } from '../src/world/autonomy';
+import { proposeDynamics } from '../src/world/vnnDynamics';
+
+describe('open world autonomy', () => {
+  test('AAC loss changes observability without changing authority', () => {
+    const state = structuredClone(initialOpenWorldState);
+    const maya = state.entities.find((entity) => entity.id === 'maya') as any;
+    maya.communication.access = 'unavailable';
+    const activity = planNextActivity(state, 'maya')!;
+    const proposal = proposeDynamics(state, activity);
+
+    expect(maya.authority).toBe('self');
+    expect(proposal.signals.some((signal) => signal.node === 'communication' && signal.metric === 'observability')).toBe(true);
+    expect(proposal.invariantChecks).toContain('communication access does not infer incapacity');
+  });
+
+  test('failed lift is represented as an environmental barrier', () => {
+    const state = structuredClone(initialOpenWorldState);
+    const maya = state.entities.find((entity) => entity.id === 'maya') as any;
+    const lift = state.entities.find((entity) => entity.id === 'station-lift') as any;
+    lift.operational = false;
+
+    const result = evaluateAffordance(maya, lift, 'use');
+    expect(result.available).toBe(false);
+    expect(result.reason).toBe('environmental infrastructure unavailable');
+    expect(maya.mobility.independent).toBe(true);
+  });
+
+  test('planner preserves the goal by searching for alternatives', () => {
+    const state = structuredClone(initialOpenWorldState);
+    const activity = planNextActivity(state, 'maya');
+    expect(activity).toBeDefined();
+    expect(['travel', 'seek-alternative', 'rest']).toContain(activity!.kind);
+    expect(activity!.goal).toBe('move through the community');
+  });
+});

__tests__/worldModel.test.ts

@@ -0,0 +1,21 @@
+import { InfrastructureEntity, PersonEntity, PersistentWorldStore, accessAssessment, initialOpenWorldState } from '../src/world/worldModel';
+
+describe('persistent disability world', () => {
+  it('attributes a failed lift to the environment rather than person incapacity', () => {
+    const store = new PersistentWorldStore(initialOpenWorldState);
+    const person = store.entity('maya') as PersonEntity;
+    const lift = store.entity('station-lift') as InfrastructureEntity;
+    expect(accessAssessment(person, lift)).toEqual({ pass: true, cause: 'accessible' });
+    store.setInfrastructure('station-lift', false);
+    expect(accessAssessment(person, store.entity('station-lift') as InfrastructureEntity)).toEqual({ pass: false, cause: 'environmental infrastructure unavailable' });
+    expect(person.authority).toBe('self');
+  });
+
+  it('does not change decision authority when AAC access degrades', () => {
+    const store = new PersistentWorldStore(initialOpenWorldState);
+    store.setCommunicationAccess('maya', 'degraded');
+    const person = store.entity('maya') as PersonEntity;
+    expect(person.communication.access).toBe('degraded');
+    expect(person.authority).toBe('self');
+  });
+});

__tests__/worldSteps18to20.test.ts

@@ -0,0 +1,13 @@
+import { PersistentWorldStore, initialOpenWorldState, type PersonEntity } from '../src/world/worldModel';
+import { WorldRuntime } from '../src/world/liveWorldLoop';
+import { ensurePopulation, relationships } from '../src/world/population';
+import { createSpatialIntent, evaluateSpatialIntent, nearbyEntities, wayfind } from '../src/world/spatialInteraction';
+
+describe('Steps 18-20 world integration',()=>{
+  test('population seeds multiple self-authoritative people and relationships',()=>{const store=new PersistentWorldStore(initialOpenWorldState);ensurePopulation(store);const people=store.snapshot().entities.filter(e=>e.kind==='person') as PersonEntity[];expect(people.length).toBeGreaterThanOrEqual(4);expect(people.every(p=>p.authority==='self')).toBe(true);expect(relationships.length).toBeGreaterThan(0);});
+  test('WorldRuntime is authoritative and advances population without changing authority',()=>{const store=new PersistentWorldStore(initialOpenWorldState);const runtime=new WorldRuntime(store);runtime.step(3);runtime.step(3);const maya=store.entity('maya') as PersonEntity;expect(maya.authority).toBe('self');expect(runtime.snapshot().activities.length).toBeGreaterThan(0);});
+  test('semantic interaction is modality-independent',()=>{const store=new PersistentWorldStore(initialOpenWorldState);ensurePopulation(store);const state=store.snapshot();const touch=createSpatialIntent('maya','liam','communicate','touch');const xr=createSpatialIntent('maya','liam','communicate','xr-controller');expect(evaluateSpatialIntent(state,touch).allowed).toBe(evaluateSpatialIntent(state,xr).allowed);});
+  test('AAC loss blocks immediate communication action but preserves intent and authority',()=>{const store=new PersistentWorldStore(initialOpenWorldState);ensurePopulation(store);store.setCommunicationAccess('maya','unavailable');const result=evaluateSpatialIntent(store.snapshot(),createSpatialIntent('maya','liam','communicate','switch'));expect(result.allowed).toBe(false);expect(result.reason).toContain('intent is preserved');expect((store.entity('maya') as PersonEntity).authority).toBe('self');});
+  test('wayfinding attributes failed infrastructure to environment',()=>{const store=new PersistentWorldStore(initialOpenWorldState);store.setInfrastructure('station-lift',false);const route=wayfind(store.snapshot(),'maya','station-lift');expect(route?.accessible).toBe(false);expect(route?.reason).toContain('environmental infrastructure unavailable');});
+  test('nearby discovery supports non-spatial equivalent of proximity interaction',()=>{const store=new PersistentWorldStore(initialOpenWorldState);ensurePopulation(store);const near=nearbyEntities(store.snapshot(),'maya',30);expect(near.length).toBeGreaterThan(0);});
+});

__tests__/worldSteps21to24.test.ts

@@ -0,0 +1,61 @@
+import { defaultNavigationNetwork, findAccessibleRoutes, navigationProfile } from '../src/world/accessibleNavigation';
+import { chargerPercent, ObjectInteractionEngine, smoothstep } from '../src/world/objectInteractions';
+import { encounterScore, SocialEncounterEngine } from '../src/world/socialEncounters';
+import { ContinuityEngine } from '../src/world/continuity';
+import { initialOpenWorldState, PersistentWorldStore, type InfrastructureEntity, type PersonEntity } from '../src/world/worldModel';
+
+describe('Steps 21-24 Wolfram-grounded world algorithms', () => {
+  test('accessible routes are ordered by cost and failed infrastructure is environmental', () => {
+    const store = new PersistentWorldStore(initialOpenWorldState);
+    const maya = store.entity('maya') as PersonEntity;
+    expect(navigationProfile(maya).mobility).toBe('powered-wheelchair');
+    const routes = findAccessibleRoutes(defaultNavigationNetwork, store.snapshot(), maya, 'plaza', 'transit', 3);
+    expect(routes.length).toBeGreaterThan(0);
+    for (let i = 1; i < routes.length; i++) expect(routes[i]!.cost).toBeGreaterThanOrEqual(routes[i-1]!.cost);
+    const lift = store.entity('station-lift') as InfrastructureEntity;
+    store.setInfrastructure(lift.id, false);
+    const blocked = findAccessibleRoutes(defaultNavigationNetwork, store.snapshot(), maya, 'plaza', 'transit', 3);
+    expect(blocked.every(route => !route.nodeIds.includes('station-lift'))).toBe(true);
+    expect((store.entity('maya') as PersonEntity).authority).toBe('self');
+  });
+
+  test('smoothstep lift model has stationary endpoints', () => {
+    expect(smoothstep(0)).toBe(0);
+    expect(smoothstep(1)).toBe(1);
+    const engine = new ObjectInteractionEngine();
+    expect(engine.requestLift(1, 'maya')).toBe(true);
+    engine.step(4);
+    expect(engine.snapshot().lift.positionMetres).toBeCloseTo(2.1, 5);
+    engine.step(4);
+    expect(engine.snapshot().lift.positionMetres).toBeCloseTo(4.2, 5);
+  });
+
+  test('Wolfram-derived charger curve reaches approximately 80 percent at computed time', () => {
+    expect(chargerPercent(30, 100, .0015, 835.1753123302453)).toBeCloseTo(80, 5);
+  });
+
+  test('relationship and proximity affect encounters while support remains explicit', () => {
+    expect(encounterScore(1.5, 1, 1, .2)).toBeGreaterThan(encounterScore(1.5, 0, 0, .2));
+    const store = new PersistentWorldStore(initialOpenWorldState);
+    const engine = new SocialEncounterEngine();
+    const before = engine.detect(store.snapshot()).encounters;
+    expect(before.every(encounter => encounter.supportRequested === false)).toBe(true);
+    engine.requestSupport('maya', 'liam');
+  });
+
+  test('continuity preserves authority and rejects non-adjacent jumps', () => {
+    const store = new PersistentWorldStore(initialOpenWorldState);
+    const maya = store.entity('maya') as PersonEntity;
+    const engine = new ContinuityEngine(store);
+    engine.start(maya, 'educational test');
+    expect(engine.episode('maya')?.preserved.authority).toBe('self');
+    expect(engine.advance('maya', 'icu')).toBe(false);
+    expect(engine.advance('maya', 'ed')).toBe(true);
+    expect(engine.advance('maya', 'icu')).toBe(true);
+    expect(engine.advance('maya', 'mert-scenario')).toBe(true);
+    expect(engine.advance('maya', 'discharge')).toBe(true);
+    expect(engine.advance('maya', 'community-return')).toBe(true);
+    expect(engine.advance('maya', 'community-with-consequences')).toBe(true);
+    expect((store.entity('maya') as PersonEntity).authority).toBe('self');
+  });
+});