<!-- HONEYCOMB-STAGING · part 9 -->
pth: 1, panel: true });

    videoPanel = { group, video, screen };
    return videoPanel;
  }

  function getVideoPanel() { return videoPanel; }

  // ── CONTROL ROOM: Open design — 4 posts + canopy, NO WALLS ──
  // The King's law: "A room with 4 walls is exactly like jail."
  // Video screen floats between posts, visible from all sides.
  function createControlRoom(bx, bz, videoUrl, label) {
    const group = new THREE.Group();
    const W = 20, H = 12, D = 16;

    const tex = createTacticalTexture(label || 'CONTROL');
    const postMat = new THREE.MeshStandardMaterial({
      map: tex, roughness: 0.5, metalness: 0.6,
      emissive: 0x330000, emissiveIntensity: 0.4, emissiveMap: tex,
      side: THREE.DoubleSide
    });

    // 4 corner posts (the only solid parts)
    const postGeo = new THREE.BoxGeometry(1.5, H, 1.5);
    const hx = W/2 - 0.75, hz = D/2 - 0.75;
    const corners = [
      [bx - hx, bz - hz], [bx + hx, bz - hz],
      [bx - hx, bz + hz], [bx + hx, bz + hz]
    ];
    for (const [px, pz] of corners) {
      const post = new THREE.Mesh(postGeo, postMat);
      post.position.set(px, H/2, pz);
      group.add(post);
    }

    // Sloped canopy (rocket-ship roof)
    const roofGeo = new THREE.ConeGeometry(Math.max(W, D) * 0.75, H * 0.35, 4);
    const roofMat = new THREE.MeshStandardMaterial({
      map: tex, roughness: 0.4, metalness: 0.7,
      emissive: 0x440000, emissiveIntensity: 0.5, emissiveMap: tex,
      side: THREE.DoubleSide
    });
    const roof = new THREE.Mesh(roofGeo, roofMat);
    roof.position.set(bx, H + H * 0.175, bz);
    roof.rotation.y = Math.PI / 4;
    group.add(roof);

    // VIDEO SCREEN floats between posts (visible from all sides, no walls)
    const video = document.createElement('video');
    video.src = videoUrl;
    video.crossOrigin = 'anonymous';
    video.loop = true; video.muted = true; video.playsInline = true;
    video.play().catch(() => {});
    const vtex = new THREE.VideoTexture(video);
    vtex.minFilter = THREE.LinearFilter;

    const screenGeo = new THREE.PlaneGeometry(W - 4, H - 3);
    const screenMat = new THREE.MeshBasicMaterial({ map: vtex, side: THREE.DoubleSide });
    const screen = new THREE.Mesh(screenGeo, screenMat);
    screen.position.set(bx, H/2 + 0.5, bz);
    group.add(screen);

    // Glass overlay (both sides)
    const glass = new THREE.Mesh(
      new THREE.PlaneGeometry(W - 4, H - 3),
      new THREE.MeshStandardMaterial({
        color: 0x88ccff, transparent: true, opacity: 0.07,
        roughness: 0.1, metalness: 0.9, side: THREE.DoubleSide
      })
    );
    glass.position.set(bx, H/2 + 0.5, bz + 0.1);
    group.add(glass);

    // Label above (floating, no walls to mount on)
    const lc = document.createElement('canvas');
    lc.width = 512; lc.height = 64;
    const lx = lc.getContext('2d');
    lx.font = 'bold 36px monospace'; lx.textAlign = 'center';
    lx.fillStyle = '#FF3333';
    const lbl = (label || 'CONTROL').toUpperCase();
    lx.fillText(lbl, 256, 44);
    const ltex = new THREE.CanvasTexture(lc);
    const lmat = new THREE.MeshBasicMaterial({ map: ltex, transparent: true, depthTest: false, side: THREE.DoubleSide });
    const lmesh = new THREE.Mesh(new THREE.PlaneGeometry(12, 1.5), lmat);
    lmesh.position.set(bx, H + H * 0.35 + 3, bz);
    lmesh.renderOrder = 999;
    group.add(lmesh);
    labelMeshes.push({mesh: lmesh, bx, bz});

    scene.add(group);
    observe('building.create', { label: label || 'CONTROL', position: { x: bx, z: bz }, dimensions: { w: W, h: H, d: D }, design: 'open-no-walls' });
  }

  // ── PUBLIC API ──
  return {
    init,
    setupInput,
    setupTactical,
    getPerformanceStats,
    addBuilding,
    checkCollision,
    getScene: () => scene,
    getPlayer: () => player,
    getCamera: () => camera,
    getBuildings: () => buildings,
    createVideoPanel,
    createControlRoom,
    getVideoPanel,
    getColliders: () => colliders
  };
})();

/* ═══════════════════════════════════════════════════════════════════
   EPISTEMOLOGY MODULE — Phase 1 Staging
   Read-only observation of 3D world. Never modifies 3D. Never breaks 3D.
   Persona of Articulation governs disposition. PostgreSQL is authoritative.
   ═══════════════════════════════════════════════════════════════════ */
const Epistemology = (function() {
  'use strict';

  const API_BASE = '/api/solidivism/epistemology';
  const CACHE_KEY = 'solidivism.epistemology.pending';
  const SESSION_ID = 'sess-' + Date.now() + '-' + Math.random().toString(36).slice(2, 9);

  // ── In-memory runtime index (NOT authoritative) ──
  const registry = new Map();
  const ledgerCache = [];

  // ── Health (separate from 3D, diagnosable) ──
  const Health = {
    observations: { attempted: 0, succeeded: 0, failed: 0 },
    lastError: null,
    lastSuccess: null,
    recordAttempt() { this.observations.attempted++; },
    recordSuccess() {
      this.observations.succeeded++;
      this.lastSuccess = new