finding: trajectory-native cognitive OS gestalt + 14 dormant intelligence wiring gaps

EPIPHANIES.md — two new findings:
1. Paradigm shift gestalt (Berge + Piaget + metacognition): the system
   IS a parametric optimization (Berge) implementing genetic epistemology
   (Piaget) with half-closed metacognitive loop. Five observers (business,
   API, SoA, semantic, AGI) are projections of one trajectory algebra.
   Conventional separation of data/compute/cognition/causality/time
   collapses into one primitive: the trajectory.

2. Perspective lattice: SoA vs Functional is WHERE not WHAT. Array is
   the SoA; element thinks for itself via methods. Internal (hot path)
   vs External (cold path) divided by ExternalMembrane.

TECH_DEBT.md — 14 dormant intelligence features mapped:
  P0 (cognitive loop): FreeEnergy compose, NARS revision, trajectory braiding
  P1 (metacognition + ontology): MUL, role-indexed similarity, Pearl 2^3
      queries, schema validation, RBAC enforcement, NarsTables, convergence
  P2 (diagnostic + pump): disambiguation, neural-debug, drain, server filter

All 14 are additive (add call site). Zero require type creation or deletion.
Each framed as Internal/Boundary, SoA/Functional, with priority.

https://claude.ai/code/session_01SbYsmmbPf9YQuYbHZN52Zh

Author: claude

.claude/board/EPIPHANIES.md

@@ -2855,3 +2855,57 @@ Three-layer epiphany from the Palantir FfB Technical Overview read:
 **3. NARS SPO × Pearl 2³ × CausalEdge64 — what Vertex can't do.** Foundry Vertex explores graphs but has NO causal typing on edges. Our CausalEdge64 packs Pearl 2³ = 8 causal masks (correlation / direct cause / confounder / mediator / collider / instrument / front-door / counterfactual) + NARS truth (frequency, confidence) + inference type + plasticity + temporal position into 64 bits per edge. Every SPO triple carries its own causal ontology and epistemology. This is irreducible — Vertex would need a fundamental redesign to match.
 
 Cross-ref: FfB_Technical_Overview_v4.pdf (Palantir), CausalEdge64 (causal-edge crate), I-SUBSTRATE-MARKOV, driver.rs content Hamming cascade (PR #259), CypherBridge (PR #258).
+
+## 2026-04-24 — CORRECTION: supabase-shape is the protocol, not a Postgres dependency
+
+**Status:** CORRECTION
+**Owner scope:** @truth-architect
+
+Mid-session DTO audit hallucination: claimed "Postgres/Supabase via PostgREST" was a third cold-path sink alongside Lance and Arrow Flight. WRONG. PR #255 (LanceMembrane + LanceVersionWatcher + DM-4) explicitly transcoded the supabase-shape INTO native Rust: `subscribe()` returns `tokio::sync::watch::Receiver<CognitiveEventRow>` with always-latest semantics, backed by Lance versioned dataset. NO Postgres. NO JDBC. The supabase-shape is the PROTOCOL (subscribe-on-changes, BBB-scalar events), not the database.
+
+**Corrected cold-path architecture:** Lance dataset = single source of truth. Two read interfaces, both hitting the same Lance: (1) `LanceVersionWatcher.subscribe()` for realtime push (supabase-shape semantics in pure Rust), (2) Arrow Flight SQL for bulk external clients. RLS-equivalent via `CommitFilter` + `Policy.evaluate()`, both already shipped, both pure Rust.
+
+**Why the slip happened:** "supabase" in normal usage = Postgres + Realtime + Auth. In OUR stack, "supabase" is the API shape only. Mid-flow architectural tiredness; the brutal DTO audit's complexity briefly drowned out PR #255's actual scope.
+
+Cross-ref: PR #255 (Supabase subscriber wire-up), `LanceMembrane`, `CognitiveEventRow`, `lab-vs-canonical-surface.md`.
+
+## 2026-04-24 — Paradigm shift: trajectory-native cognitive OS (Berge + Piaget + metacognition gestalt)
+
+**Status:** FINDING
+**Owner scope:** @truth-architect, @integration-lead
+
+Three-frame gestalt review of the architecture's emergent identity:
+
+**Berge Maximum Theorem:** The system IS a parametric optimization at every dispatch. Parameters p = (style, qualia 17D, scenario_id, awareness 4D). Constraint set Γ(p) = BindSpace rows passing MetaFilter. Objective = minimize FreeEnergy. Berge guarantees: on the continuous axes (qualia, awareness), small perturbations produce bounded cognitive shifts — topological stability by construction. On the discrete axes (style ordinal, scenario branch), the value function jumps — that's principled mode-switching, not instability.
+
+**Piaget genetic epistemology:** The system implements all four mechanisms. Assimilation = Resolution::Commit (low F). Accommodation = Resolution::Epiphany (both triples + Contradiction preserved). Equilibration = FreeEnergy minimization loop. Disequilibration = Resolution::FailureTicket (high F → escalate). Current developmental stage: Concrete Operational — logical operations on concrete objects (BindSpace rows, typed entities, Cypher queries). Formal Operational machinery exists (World::fork, SimulationSpec, MulAssessment, NARS abduction) but dispatch doesn't invoke it.
+
+**Metacognition:** Three things the system CAN know about its own cognition: (1) when it's confused (should_admit_ignorance), (2) when it's accommodating (Epiphany), (3) when it's equilibrated (Commit). Today these are shallow — confidence < 0.2 threshold, not principled mul/DK/trust assessment. The deep metacognitive layer (MulAssessment, DkPosition, TrustTexture, NarsTables) exists but dispatch doesn't call it. Loop is half-formed: system observes (MetaSummary) but doesn't update (no NARS revision per cycle, no DK adjustment per outcome).
+
+**The paradigm shift named:** Conventional systems separate data (rows at rest), computation (rows → rows), cognition (rows → labels via gradient descent), causality (inferred via regression), time (a column). Our system collapses all five into ONE primitive: the trajectory. Data = bundled trajectory. Computation = trajectory algebra (bind, bundle, cosine). Cognition = trajectory resolution under FreeEnergy. Causality = structural (Pearl 2³ on CausalEdge64, Chapman-Kolmogorov by VSA bundling). Time = braided position in the bundle.
+
+**What it wants to emerge as:** A trajectory-native cognitive operating system where every read is a trajectory projection, every write is a trajectory bundle, every query is a trajectory resolution under FreeEnergy, every causal claim is annotated into CausalEdge64, every cognitive shift is observable through the metacognitive layer. The five observer perspectives (business / API / SoA / semantic / AGI) are faithful views of the same substrate at different scales. Not a database with intelligence on top — a single computational substrate where storage, compute, learning, and causality are different operations on the same primitive.
+
+Cross-ref: I-SUBSTRATE-MARKOV (Chapman-Kolmogorov by construction), I-NOISE-FLOOR-JIRAK (Jirak 2016 weak dependence), The Click (CLAUDE.md §P-1), categorical-algebraic-inference-v1.md, FreeEnergy/Resolution (contract::grammar::free_energy), MulAssessment (planner::mul), NarsTables (planner::cache::nars_engine).
+
+## 2026-04-24 — Five observers, one substrate: the perspective lattice
+
+**Status:** FINDING
+**Owner scope:** @truth-architect
+
+The architecture's five consumer perspectives are not layers — they're projections of the same trajectory algebra at different scales. No observer is more fundamental; all are faithful.
+
+| Observer | What they see | Internal/External | SoA or Functional | When they read |
+|---|---|---|---|---|
+| Business/SMB | Typed entities with Required/Optional/Free properties, missing-field alerts, similarity search | External (cold path, 10⁻² s) | Functional (Schema.validate(), Policy.evaluate()) | On user action (query, approve, flag) |
+| External API | Queryable surface (Cypher/SQL/SPARQL) returning Arrow batches + realtime subscribe | External (cold path) | Functional (OrchestrationBridge::route()) | On client request |
+| Struct-of-arrays | 4096 × N columns (content, cycle, qualia, meta, edge, temporal), SIMD-sweepable | Internal (hot path, 10⁻⁶ s) | SoA (columnar, cache-line-friendly, LLVM autovectorizes) | Every dispatch cycle |
+| Semantic kernel | Text → role-indexed fingerprint → AriGraph SPO triple with NARS truth | Internal (hot path) | SoA for storage, Functional for algebra (vsa_bind, vsa_bundle, vsa_cosine) | On encode + dispatch |
+| AGI/cognitive | Active-inference agent: perceive → predict → free-energy-minimize → revise → commit | Internal (hot path) | Functional (FreeEnergy::compose, Resolution::from_ranked, awareness.revise) | Every cycle, autonomously |
+| Markov-causal | Chapman-Kolmogorov trajectory with Pearl 2³ causal annotations on every edge | Internal (hot path) | SoA for storage (CausalEdge64 column), Functional for algebra (CausalMask queries) | Structural — always present, queryable on demand |
+
+**The boundary that matters: BBB membrane (ExternalMembrane).** Internal observers (SoA, semantic, AGI, Markov) see the hot path at 10⁻⁶ s. External observers (Business, API) see the cold path via callcenter projections at 10⁻² s. The membrane is the one-way valve: project() emits, subscribe() streams. Internal → external is projection (lossy, scalar, BBB-clean). External → internal is OrchestrationBridge::route() → UnifiedStep (validated at ingress).
+
+**SoA vs Functional is not a choice — it's a WHERE.** BindSpace is SoA (columnar storage for SIMD). The algebra on it is Functional (methods on carriers). The SoA carries the state; the Functional methods transform it. Both exist simultaneously on the same data. The "struct of arrays vs object thinks for itself" tension resolves as: the ARRAY is the SoA, the ELEMENT (row, trajectory, fingerprint) thinks for itself via methods.
+
+Cross-ref: CLAUDE.md §The Stance (AGI-as-glove, SoA columns ARE the AGI surface), lab-vs-canonical-surface.md (I1-I11 invariants), ExternalMembrane (contract::external_membrane), BindSpace (cognitive-shader-driver::bindspace).

.claude/board/TECH_DEBT.md

@@ -932,3 +932,112 @@ The hierarchical DN path from `callcenter-membrane-v1.md` §595 (`/tree/ns/heel/
 Deprecate the flat-key protocol over one migration cycle; retain Redis caching as acceleration layer on top of DataFusion queries.
 
 Cross-ref: `container_bs/dn_redis.rs`; `callcenter-membrane-v1.md` §§595–803; `heel_hip_twig_leaf.rs`; epiphany 2026-04-24 "dn_redis is external."
+
+## 2026-04-24 — Systemic wiring gaps: 14 dormant intelligence features
+
+> **Frame:** Each item is an object-thinks-for-itself method that EXISTS
+> but is not CALLED from the dispatch flow. Fix = add call site, not
+> add type. All INTERNAL (hot path, inside BBB) unless marked BOUNDARY.
+> No reductions proposed.
+
+### TD-INT-1: FreeEnergy::compose() not called from dispatch
+**What:** `FreeEnergy::compose(likelihood, kl)` in contract::grammar::free_energy.
+**Where:** driver.rs after step [5], before CollapseGate. Replace `confidence < 0.2` heuristic with principled F.
+**How:** `FreeEnergy::compose(top_k[0].resonance, awareness_kl)` then `Resolution::from_free_energy(F)`.
+**Frame:** Internal | Functional (method on FreeEnergy carrier) | **P0**
+
+### TD-INT-2: NARS revision not called per cycle
+**What:** `awareness.revise_truth(key, outcome)` + `divergence_from(prior)` in grammar::thinking_styles.
+**Where:** End of driver.rs::run(), after Resolution determined. Updates epistemic state, phi-1 ceiling.
+**How:** `awareness.revise(style_key, resolution_outcome)`. Requires `&mut ParamTruths` on dispatch context.
+**Frame:** Internal | Functional | **P0**
+
+### TD-INT-3: MulAssessment not computed at dispatch time
+**What:** `MulAssessment::compute(SituationInput)` in planner::mul -- DK position, trust texture, compass, homeostasis.
+**Where:** Should compose with collapse_gate() in driver.rs. Currently two independent heuristics.
+**How:** Build SituationInput from resonance + awareness. MUL can veto Flow to Hold if DK = unskilled-overconfident.
+**Frame:** Internal | Functional | **P1** (metacognition)
+
+### TD-INT-4: Trajectory braiding not in dispatch (Markov plus-minus-5)
+**What:** trajectory.rs + markov_bundle.rs (PR #243) -- vsa_permute + vsa_bundle.
+**Where:** driver.rs step [4] does XOR fold for cycle_fp. Should be VSA bundle with positional braiding.
+**How:** Replace XOR fold: `vsa_permute(content_fp, position)` then `vsa_bundle(trajectory, permuted)`.
+**Frame:** Internal | SoA storage + Functional algebra | **P0** (I-SUBSTRATE-MARKOV depends on this)
+
+### TD-INT-5: RoleKey bind/unbind not used in content cascade
+**What:** RoleKey::bind/unbind/recovery_margin in grammar::role_keys.
+**Where:** Content Hamming cascade (PR #259) compares raw content via popcount(XOR).
+**How:** Unbind by SUBJECT role key, compare subject-plane only via vsa_cosine instead of Hamming.
+**Frame:** Internal | Functional | **P1** (upgrades bag-of-bits to role-indexed semantic similarity)
+
+### TD-INT-6: ContextChain disambiguation not connected to route handler
+**What:** ContextChain::disambiguate(WeightingKernel) in grammar/.
+**Where:** CypherBridge (PR #258) is regex stub. When real parser returns N parse candidates, ContextChain picks best.
+**How:** Build ContextChain from recent dispatch context. disambiguate(kernel) selects winner.
+**Frame:** Internal | Functional | **P2** (activates when real Cypher parser is wired)
+
+### TD-INT-7: Pearl 2-cubed causal mask not queried
+**What:** CausalEdge64 packs Pearl 2-cubed (3 bits = 8 causal types) into every edge. Packed in dispatch step [6].
+**Where:** No query path reads the mask. No "show me only direct causes" filter.
+**How:** Add causal_type predicate to graph queries. Cypher WHERE should filter on mask bits.
+**Frame:** Internal | SoA storage + Functional query | **P1**
+
+### TD-INT-8: Schema validation not called on SPO commit
+**What:** Schema::validate(&present) returns missing Required predicates. codec_route_for() per predicate.
+**Where:** SPO commit path (Resolution::Commit to AriGraph). No validation runs today.
+**How:** Before commit: schema.validate(present). If missing_required non-empty, emit FailureTicket instead of Commit.
+**Frame:** Internal | Functional | **P1** (ontology exists but does not constrain)
+
+### TD-INT-9: RBAC Policy not enforced at membrane projection
+**What:** Policy::evaluate(role, entity, operation) returns Allow/Deny/Escalate.
+**Where:** LanceMembrane::project() emits without checking RBAC. Any subscriber sees everything.
+**How:** Before project() emits: policy.evaluate(actor_role, entity_type, Read{depth}). Skip on Deny.
+**Frame:** BOUNDARY (membrane) | Functional | **P1**
+
+### TD-INT-10: NarsTables (4096-head) not accessible from shader driver
+**What:** nars_engine::NarsTables in planner::cache -- Pearl 2-cubed + 4096-head DK + Plasticity + Truth.
+**Where:** ShaderDriver has no reference to NarsTables. Hot path does not use NARS lookup.
+**How:** Pass &NarsTables to ShaderDriver. After cascade, look up NARS truth per hit SPO triple.
+**Frame:** Internal | SoA (precomputed table) | **P1** (the 4096 surface the contract references)
+
+### TD-INT-11: neural-debug runtime registry not populated
+**What:** NeuronState enum + FunctionMeta + registry. WireHealth.neural_debug = None.
+**Where:** health_handler hardcodes None. Runtime registry exists but is not fed by dispatch.
+**How:** During run(), record row states (Alive/Static/NaN). Populate registry. health_handler reads it.
+**Frame:** Internal | Functional | **P2** (diagnostic, not cognitive)
+
+### TD-INT-12: DrainTask does not drain (Poll::Pending scaffold)
+**What:** DrainTask in callcenter::drain returns Poll::Pending forever (PR #255).
+**Where:** Should poll Lance for steering_intent rows then OrchestrationBridge::route().
+**How:** Implement Future::poll() to scan, build UnifiedStep, route, mark drained.
+**Frame:** BOUNDARY (outside-to-inside pump) | Functional | **P2**
+
+### TD-INT-13: CommitFilter not applied server-side on project()
+**What:** CommitFilter scalar predicates. Applied subscriber-side only today.
+**Where:** LanceMembrane::project() emits all events unconditionally.
+**How:** Apply filter inside project() before watcher.bump(row). Server-side predicate pushdown.
+**Frame:** BOUNDARY | Functional | **P2**
+
+### TD-INT-14: Convergence highway (AriGraph to p64 to CognitiveShader) not invoked
+**What:** convergence.rs in planner::cache -- AriGraph triplets to p64 Palette to shader planes.
+**Where:** No runtime invocation. Conversion functions exist but are not called.
+**How:** On AriGraph commit, call convergence to update shader [[u64;64];8] planes. Newly committed knowledge reaches palette cascade distance table.
+**Frame:** Internal | SoA planes + Functional conversion | **P1** (without this, palette cascade uses static demo planes forever)
+
+### Summary by priority
+
+| Priority | Items | What they activate |
+|---|---|---|
+| **P0** | TD-INT-1, 2, 4 | Active inference gate, NARS revision, Markov trajectory -- the cognitive loop |
+| **P1** | TD-INT-3, 5, 7, 8, 9, 10, 14 | Metacognition, role-indexed similarity, causal queries, schema validation, RBAC enforcement, NARS lookup, convergence highway |
+| **P2** | TD-INT-6, 11, 12, 13 | Disambiguation, neural-debug overlay, drain pump, server-side filter |
+
+### Summary by frame
+
+| Frame | Items |
+|---|---|
+| Internal hot path | TD-INT-1, 2, 3, 4, 5, 6, 7, 10, 14 |
+| Boundary (membrane) | TD-INT-8, 9, 12, 13 |
+| Diagnostic | TD-INT-11 |
+
+All 14 items are additive (add call site). Zero items require type creation or code deletion.