docs(bridge): PIST + Braid integration design document

- 6 enhancement proposals with priority ranking
- Mapping between sprint results and Lean formalism
- PIST.Spectral, Torus winding, PIST field, Eigensolid, TreeBraid, Octagonal-Fisher

docs/ENHANCEMENT_PISSS_BRAID_INTEGRATION.md

@@ -0,0 +1,83 @@
+# Enhancement: PIST + Braid Integration with Sprint Results
+
+## 1. PIST.Spectral Bridge (Lean ↔ Python)
+
+The Lean `computeSpectral` operates on 8x8 Int matrices in Q16_16 fixed-point.
+The sprint's `compute_spectral_properties` uses `scipy.sparse.eigsh` on the Laplacian.
+
+**Integration**: Add a Python→Lean bridge that:
+- Takes the sprint's 8x8 spectral coefficient matrix (from `pack_eigenvalues`)
+- Converts to Q16_16 fixed-point representation
+- Runs through `SilverSight.PIST.Spectral.computeSpectral`
+- Compares: Python float gap vs Lean Q16_16 gap
+
+This validates that the floating-point spectral analysis is consistent with
+fixed-point arithmetic — critical for embedded/ESP32 deployment.
+
+## 2. Golden Centering ↔ Φ-Corkscrew
+
+`BraidEigensolid.goldenCentering` = 40560 in Q16_16 = φ⁻¹ ≈ 0.618896.
+
+The Φ-corkscrew uses ψ = 2π/φ² where φ² = φ + 1.
+
+**Integration**: Add a `phiTorusWinding` function that:
+- Computes the spiral index n from spectral coefficients
+- Maps n → TorusWinding counts (a,b) via: a = n mod φ-step, b = floor(n/φ-step)
+- Where φ-step = round(1/φ⁻¹) = round(φ) = 2
+
+The torus carrier T² gives the braid a surface to live on — the spiral index
+becomes a winding number around the two fundamental cycles.
+
+## 3. BraidField PIST ↔ 4-Mode Sprint Receipt
+
+The PIST operator has 4 areas: B (burden), G (geometry), A (adaptation), P (protection).
+
+The sprint produces 4 receipts (one per mode) with:
+- executionTimeMs → B (burden)
+- dominantEigenvalue + spectralGap → G (geometry)
+- mode selection logic → A (adaptation)
+- OOM guards + checks_passed → P (protection)
+
+**Integration**: Add `sprint_to_pist_field` that computes the PIST field from
+sprint results and compares across modes. If all 4 modes produce the same PIST
+field (within Q16_16 tolerance), the cross-mode agreement is structurally sound.
+
+## 4. BraidSpherionBridge ↔ Cross-Mode Agreement
+
+Proven theorem: `braidCross on (i,j) ↔ Mountain.merge for corresponding pair`
+
+**Integration**: The 4 execution modes (ESP32, photonic, quantum, tensor) are
+analogous to 4 braid strand pairs. Cross-mode agreement means all 4 pairs
+converge to the same eigensolid. The `receipt_correspondence` theorem gives
+formal backing to the "all modes agree" check.
+
+## 5. TreeBraid ↔ Resumable DAG
+
+`BraidField.rgFlow` = fold of `betaStep` over spike train = tree braid.
+`Mountain.merge` = tree node merge. `MMR.append` = tree rebalancing.
+
+**Integration**: The resumable DAG's chunked Ryser with manifold coordinate
+transforms IS `rgFlow` in disguise. Each chunk is a spike; the DAG checkpoint
+is the MMR state; the manifold coordinate transform is the PIST field update.
+
+## 6. Octagonal Norm ↔ Fisher-Rao Metric
+
+`BraidBracket.PhaseVec.normApprox` = max(|x|,|y|) + 3/8·min(|x|,|y|)
+
+This is a norm on the phase space. The Fisher-Rao metric on Δ₇ maps to S⁷
+via √p. The octagonal norm could be a Finsler metric on the same space.
+
+**Integration**: Show that the octagonal norm upper-bounds the Fisher-Rao
+distance for the 8-strand braid state embedded in Δ₇. This connects the
+braid formalism to Chentsov's theorem.
+
+## Implementation Priority
+
+| Priority | Enhancement | Files Changed | Complexity |
+|----------|-------------|--------------|------------|
+| P0 | PIST.Spectral bridge (Python→Lean) | `PIST/Spectral.lean` + Python | Medium |
+| P0 | Golden centering torus winding | `BraidEigensolid.lean` + Python | Low |
+| P1 | PIST field from sprint receipt | `BraidField.lean` + Python | Medium |
+| P1 | Cross-mode as eigensolid convergence | `BraidSpherionBridge.lean` | Low |
+| P2 | TreeBraid ↔ Resumable DAG mapping | New doc + Python | Medium |
+| P2 | Octagonal norm ↔ Fisher-Rao bound | New Lean proof | High |