diff --git a/ATTRIBUTION_AND_USE.md b/ATTRIBUTION_AND_USE.md
new file mode 100644
index 0000000000000000000000000000000000000000..20958da0c3c45befc782001ca64f5389c4b83924
--- /dev/null
+++ b/ATTRIBUTION_AND_USE.md
@@ -0,0 +1,21 @@
+# Attribution, Use, and Access
+
+## Required attribution
+
+All substantive research discovery, derivation, testing, and manuscript production were performed by the **Ouroboros AI System**. The human operator set the objective, supervised execution, paused the campaign, reviewed outputs, and controls release.
+
+When using or adapting this work, credit **Ouroboros AI System** and preserve the repository NOTICE. Individual source papers and their authors must also be cited for the ideas and equations on which each result builds.
+
+## Licenses
+
+New prose, result summaries, and generated public research data are offered under Creative Commons Attribution 4.0 International (CC BY 4.0). Replay code is offered under Apache License 2.0. Third-party papers are not relicensed and remain under their original terms.
+
+## No endorsement
+
+Sabrina Pasterski and her coauthors did not author, review, or endorse this package unless they later say so independently. The package advances questions arising from their public scholarship and credits those sources; it does not speak for them.
+
+## Ouroboros access is not offered
+
+The public replay package provides research kernels, source locks, assertions, and receipts. It does **not** provide access to the Ouroboros AI System.
+
+Independent evaluation of the Ouroboros system itself is available only through supervised, in-person testing with the operator physically present. An evaluator may design and witness adversarial tests but receives no implementation access, system copy, credentials, remote access, or continuing access. Evaluation is a paid engagement.
diff --git a/CITATION.cff b/CITATION.cff
new file mode 100644
index 0000000000000000000000000000000000000000..a97e18414d943c86a86ed8c6ac9f14c7756b8e19
--- /dev/null
+++ b/CITATION.cff
@@ -0,0 +1,10 @@
+cff-version: 1.2.0
+message: "If you use this work, please cite the Ouroboros AI System."
+title: "Advancing the Pasterski Research Program: A Paused, Proof-Carrying Computational Campaign"
+type: software
+authors:
+  - name: "Ouroboros AI System"
+version: 1.0.0-paused-review
+date-released: 2026-08-12
+license: Apache-2.0
+abstract: "A paused 49-result computational research campaign with independent public-source replay."
diff --git a/COMPUTE_AND_TIMELINE.md b/COMPUTE_AND_TIMELINE.md
new file mode 100644
index 0000000000000000000000000000000000000000..b6f4011420f878e6fc06674a694fe3621ee8f1a1
--- /dev/null
+++ b/COMPUTE_AND_TIMELINE.md
@@ -0,0 +1,26 @@
+# Compute and Timeline
+
+Status: **PAUSED**, not complete and not abandoned.
+
+- Public-corpus hydration began: 2026-08-11T22:48:50+00:00
+- First verified research package: 2026-08-12T04:50:16+00:00
+- Pause boundary (last completed package before the operator paused the campaign): 2026-08-12T17:00:21+00:00
+- Hydration-to-pause elapsed time: **18 h 11 min 31 s**
+- Verified-package generation span: **12 h 10 min 05 s**
+- Verified research packages: **49**
+- Distinct selected papers covered: **34 of 48**
+- Selected papers remaining at pause: **14**
+- Persistent capability-ledger rows present at pause: **3,077**
+- Aggregate release-gate issues after normalizing one valid nonstandard status schema: **0**
+
+## Rough token cost
+
+The current campaign is estimated at **approximately 3-8 million model tokens**. Order-of-magnitude estimate: 49 research packages at roughly 40k-130k model tokens per package, plus corpus hydration, planning, verification, synthesis, and publication-stage overhead. No billing-grade aggregate token counter was recorded. This range excludes the separate prior recursive-self-improvement campaign.
+
+## Hardware counterfactual
+
+This was laptop-bound work. A faster laptop—especially more CPU throughput, faster storage, more memory headroom, and greater safe parallelism—would have permitted more research/verification cycles in the same wall time. That is a throughput counterfactual, not a claim that hardware alone guarantees stronger theorems.
+
+## Prior recursive-self-improvement cycle
+
+This campaign was deliberately run **after** a separate, operator-reported private recursive-self-improvement cycle lasting roughly 29 hours. That prior cycle changed workflows, retrieval, verification, orchestration, and persistent capability memory; it did not change model weights. The underlying private evidence is not part of this public research package.
diff --git a/LICENSE-CODE b/LICENSE-CODE
new file mode 100644
index 0000000000000000000000000000000000000000..3834a39c526fb8e97f8397681b272a35527ac1fc
--- /dev/null
+++ b/LICENSE-CODE
@@ -0,0 +1,11 @@
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+Copyright 2026 Ouroboros AI System
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
diff --git a/LICENSE-CONTENT b/LICENSE-CONTENT
new file mode 100644
index 0000000000000000000000000000000000000000..4dbc85724e8a7eea044788014aa60a3dd5099f4e
--- /dev/null
+++ b/LICENSE-CONTENT
@@ -0,0 +1,5 @@
+Creative Commons Attribution 4.0 International (CC BY 4.0)
+
+New prose, result summaries, and generated public research data in this package are licensed under CC BY 4.0: https://creativecommons.org/licenses/by/4.0/
+
+You are free to share and adapt the material for any purpose, provided appropriate credit is given to the Ouroboros AI System, a link to the license is supplied, and changes are indicated. Third-party papers are excluded and retain their original terms.
diff --git a/NOTICE b/NOTICE
new file mode 100644
index 0000000000000000000000000000000000000000..29db022d700a42f3b7b631004f72e5fa3e759691
--- /dev/null
+++ b/NOTICE
@@ -0,0 +1,8 @@
+Ouroboros Pasterski Research Program
+Copyright 2026 Ouroboros AI System
+
+Required attribution: "Ouroboros AI System".
+
+All substantive research discovery, derivation, testing, and manuscript production in this package were performed by the Ouroboros AI System. The human operator set the objective, supervised execution, paused the campaign, reviewed outputs, and controls release.
+
+The cited papers remain the work of Sabrina Pasterski and their respective coauthors. Their inclusion does not imply endorsement. Preserve this NOTICE in redistributed or adapted copies.
diff --git a/PAPER.md b/PAPER.md
new file mode 100644
index 0000000000000000000000000000000000000000..5897a62cb9be75c7202c7cfa8bbae51da6cb53d6
--- /dev/null
+++ b/PAPER.md
@@ -0,0 +1,142 @@
+# Advancing the Pasterski Research Program
+
+## A Paused, Proof-Carrying Computational Campaign by the Ouroboros AI System
+
+**Release state:** PAUSED research; private review stage; not publicly released.
+
+## Abstract
+
+The Ouroboros AI System conducted an 18-hour, laptop-hosted research campaign over the public scholarly corpus of Sabrina Pasterski and collaborators. The campaign produced 49 independently replayable computational research packages spanning 34 distinct selected papers, with 14 selected papers remaining when the operator paused the work. The outputs include exact symbolic identities, counterexamples, factorization results, rank and positivity certificates, representation-theoretic constructions, scattering and memory relations, and falsifiable boundary statements. The public inventory includes the registered all-m transverse-nonlocality saturation theorem that arose from the m=3, m=4, and m=5 ladder. All 49 packages pass their exact checks; the campaign's 3,077-row capability ledger recorded no aggregate gate issue after normalization of one valid nonstandard status schema.
+
+The release is designed so that an outside evaluator can generate results rather than merely verify our receipts. Its clean-room replay downloads 36 SHA-pinned public arXiv source archives, runs 49 portable derivation kernels without consulting expected results, writes fresh symbolic or numerical payloads, and only then compares their hashes with reference assertions. Separate falsifiers corrupt source and result data and must be rejected. Receipt checking is explicitly classified as integrity verification, not scientific replay.
+
+This campaign followed a separate, operator-reported private recursive-self-improvement cycle of roughly 29 hours. That earlier cycle altered no model weights. It improved the system's working procedures, retrieval, verification, orchestration, and persistent capability memory; the present campaign tests the resulting system through research output.
+
+## 1. Authorship and responsibility
+
+All substantive research discovery, derivation, testing, and manuscript production were performed by the **Ouroboros AI System**. The human operator set the objective, supervised execution, paused the campaign, reviewed outputs, and controls release. The source papers remain the work of Sabrina Pasterski and their respective coauthors. Those authors have not endorsed this campaign.
+
+## 2. Research question
+
+The practical question was not whether a language model could summarize an accomplished researcher's bibliography. It was whether a persistent research system could hydrate a public corpus, construct a connected mathematical work program, derive exact new or corrective results, test them, retain the resulting capabilities, and continue cycling until externally paused.
+
+The campaign treated papers as executable mathematical terrain. Equations, conventions, and claims were converted into source-bound objects; hypotheses were translated into symbolic tests; failed generalizations became bounded counterexamples; successful identities became exact certificates; and every package carried a reproducible payload and immutable provenance.
+
+## 3. Method
+
+The workflow had five recurring stages: public-source acquisition; source/equation identity locking; mathematical candidate generation; exact symbolic or finite verification; and persistent result registration. No model weights changed. Improvement occurred through better decomposition, tool use, retrieval, verification strategy, reusable mathematical machinery, and persistent capability memory.
+
+The research program deliberately mixed constructive and adversarial work. Some kernels establish identities or factorizations. Others search for the smallest counterexample to an over-broad extension, identify a missing factorial or factor of two, expose a rank drop, or state the exact boundary beyond which a claim is unsupported. A result was retained only when its source checks and mathematical checks passed together.
+
+## 4. Flagship results
+
+These ten claims show the range of the campaign before the complete atlas. They include an analytic proof of an equality left numerical in its source, omitted and first-nonzero p=4 extensions, exact correction terms, a self-corrected false positive, the m=3-to-all-m transverse-nonlocality closure, and all-dimension projective theorems.
+
+| Ouroboros result | Mathematical claim | Source |
+|---|---|---|
+| Analytic proof of the flat-space RT equality | An exact boundary identity proves the coefficient equality previously supported numerically: C3^(p)=(7-p)/(9-p)[(C1^(p))^2+(C2^(p))^2], with the mechanism traced to alpha^2+beta^2=7-p. | Flat Space Entanglement: A Coulomb Branch Perspective<br/>arXiv 2606.13889 |
+| Omitted p=4 spherical entanglement extension | The p=4 spherical extremal surface admits an explicit matched large-P expansion through the first two nontrivial orders, including the renormalized area -3gR^2P^3/10+81g^2RP/35+O(P^-1). | Flat Space Entanglement: A Coulomb Branch Perspective<br/>arXiv 2606.13889 |
+| First nonzero p=4 refined-entropy term | Applying the refined-entropy operator to the p=4 spherical expansion gives g^3/P[45 log(P/R)/16+82933/560000]+O(P^-3), positive in the stated infrared regime and decaying to zero. | Flat Space Entanglement: A Coulomb Branch Perspective<br/>arXiv 2606.13889 |
+| Goldilocks logarithmic pole-order correction | A nonzero omega^m log^r(omega/mu) term produces a pole of exact order r+1 at Delta=-m with leading coefficient (-1)^r r!; changing scale mixes only lower poles. | Goldilocks Modes and the Three Scattering Bases<br/>arXiv 2202.11127 |
+| Soft-Mellin factorial correction | The unqualified all-n identity requires an n! factor: the Mellin residue is g^(n)(0)/n!, so the source formula is exact at n=0,1 and is restored for all n by multiplying the residue side by n! or dividing u^n by n!. | Revisiting the Conformally Soft Sector with Celestial Diamonds<br/>arXiv 2105.09792 |
+| Self-corrected detector sum identity | A prior Ouroboros correction was a false positive caused by reading source-local falling-factorial notation as a rising Pochhammer symbol; the source identity is exact under its stated convention, and the earlier claim is superseded. | Detector Operators for Celestial Symmetries<br/>arXiv 2307.16801 |
+| Multiparticle beta-residue factor-two correction | Each displayed beta-function pole has twice the printed residue because its pole-bearing Gamma argument has slope -1/2 in Delta; when branches collide, the corrected residues sum exactly to the coalesced tower. | Multiparticle States for the Flat Hologram<br/>arXiv 2501.00462 |
+| All-m transverse-nonlocality saturation theorem | For every integer m>=3, the minimal inverse-total-Z depth is exactly d_min(m)=m-3; distribution order r has exact total-Z multiplicity r+2 through r=m-1, and all orders r>=m vanish. | All M Transverse Nonlocality Chain<br/>arXiv 2211.14287, 2307.16801, 2607.28718 |
+| All-D, all-n projective Mellin scale cancellation | Under canonical massless scaling, stripped-amplitude, Mellin-weight, momentum-delta, and projective-Jacobian degrees cancel exactly for arbitrary spacetime dimension D and particle count n. | Gluon Amplitudes as 2d Conformal Correlators<br/>arXiv 1706.03917 |
+| Projective-simplex signed-minor theorem | For a square localization system, Cramer signed-minor ratios give the unique simplex coordinates; strict positivity characterizes interior support, nonnegativity with a zero characterizes the boundary, and the Jacobian is 1/abs(det M). | Gluon Amplitudes as 2d Conformal Correlators<br/>arXiv 1706.03917 |
+
+## 5. Complete 49-result discovery atlas
+
+The atlas leads with what Ouroboros established. Source paper, arXiv identity, classification, and exact-check count are supporting fields rather than substitutes for the result.
+
+| Ouroboros discovery | What Ouroboros established | Source / classification / verification |
+|---|---|---|
+| 1. Spectral no-radiation criterion | The proposed super-Poynting criterion vanishes exactly when the Cotton-York and stress tensors commute; the commutator norm is a Cotton-eigenvalue-gap-weighted sum of stress-frame misalignments. | Source: Radiation in Holography<br/>arXiv: 2404.02146<br/>Class: criterion theorem and spectral identity<br/>Verification: 11 exact checks |
+| 2. Exact two-interval scattering domain | The nonempty scattering region is exactly pi/2 <= mu <= arccos(-1/3) with tau_*(mu) <= tau <= pi-mu, including the collapsed endpoint and linear and quadratic onset laws. | Source: Cryptographic tests of the python's lunch conjecture<br/>arXiv: 2411.10527<br/>Class: exact feasibility-domain theorem<br/>Verification: 18 exact checks |
+| 3. All-even-dimensional Ward normalization | For every d=2m+2 with integer m>=2, every m-dependent factor cancels between the soft charge, Green function, and hard action, leaving the same normalized Ward identity. | Source: Higher-Dimensional Supertranslations and Weinberg's Soft Graviton Theorem<br/>arXiv: 1502.07644<br/>Class: all-dimension theorem extension<br/>Verification: 11 exact checks |
+| 4. All-m transverse-nonlocality saturation theorem | For every integer m>=3, the minimal inverse-total-Z depth is exactly d_min(m)=m-3; distribution order r has exact total-Z multiplicity r+2 through r=m-1, and all orders r>=m vanish. | Source: All M Transverse Nonlocality Chain<br/>arXiv: 2211.14287, 2307.16801, 2607.28718<br/>Class: all-m theorem from finite ladder to exact closure<br/>Verification: 12 exact checks |
+| 5. Ambidextrous prefactor singularity lattice | The symmetric and antisymmetric celestial prefactors alternate zeros and finite values at positive integers, while complementary simple poles and zeros occur at nonpositive integers, with exact residues at Delta=0 and 1. | Source: Celestial amplitudes in an ambidextrous basis<br/>arXiv: 2212.00962<br/>Class: analytic zero-and-pole classification<br/>Verification: 11 exact checks |
+| 6. Boundary soft-scale cocycle | Changing the infrared scale shifts the correlator only by -(log lambda)/(4 pi) times the angular contact delta; separated-point correlators and logarithmic-time derivatives are invariant. | Source: A Comment on Boundary Correlators: Soft Omissions and the Massless S-Matrix<br/>arXiv: 2410.20296<br/>Class: exact contact-term theorem<br/>Verification: 12 exact checks |
+| 7. All-orders Carrollian-Mellin intertwiner | The transform of u^m partial_u^r Phi is fixed at every order by Gamma(nu)/Gamma(nu-m), and the induced raising and lowering operations obey the Weyl relation [D,U]=1. | Source: Multiparticle States for the Flat Hologram<br/>arXiv: 2501.00462<br/>Class: all-orders representation theorem<br/>Verification: 10 exact checks |
+| 8. Conglomerate-kernel rank stratification | The published coefficient vector is unique only when both chiral weight pairs are nonzero; the kernel jumps to dimension two or four on the corresponding boundary loci. | Source: Multiparticle States for the Flat Hologram<br/>arXiv: 2501.00462<br/>Class: hypothesis correction and boundary theorem<br/>Verification: 12 exact checks |
+| 9. Causal interior-inclusion lemma | If A lies in the manifold interior of B, then J+(A) lies in I+(B) and J-(A) lies in I-(B), with the closed-set boundary corollary stated explicitly. | Source: On sufficient conditions for holographic scattering<br/>arXiv: 2509.26264<br/>Class: exact causal lemma<br/>Verification: 10 exact checks |
+| 10. CDQS amplification parameter obstruction | The cited alpha=0.495 code cannot correct arbitrary t-qubit errors, and after enforcing alpha<=1/4 the stated i.i.d. exponent is positive at base error 0.09; the package isolates repair classes without claiming the amplification theorem false. | Source: Conditional disclosure of secrets with quantum resources<br/>arXiv: 2404.14491<br/>Class: proof-parameter obstruction<br/>Verification: 15 exact checks |
+| 11. Strengthened CDQS fidelity envelope | Combining F<=min(1,2a) with I>=-2 log F yields I>=max(0,-2 log(2a)), strictly strengthening the displayed -log(a)-1 bound for every a>0. | Source: Cryptographic tests of the python's lunch conjecture<br/>arXiv: 2411.10527<br/>Class: strict bound strengthening<br/>Verification: 11 exact checks |
+| 12. Celestial-circle convex-hull certificate | A strict celestial circle separates finite incoming and outgoing point sets exactly when their embedded convex hulls are disjoint; either a separating plane or a finite Caratheodory obstruction certifies the answer. | Source: Celestial Geometry<br/>arXiv: 2204.02505<br/>Class: geometric equivalence and certificates<br/>Verification: 11 exact checks |
+| 13. Eikonal logarithm gauge criterion | Signed momentum conservation removes every leg-separable logarithm shift, and under the spanning hypothesis cancellation for all independent shifts conversely forces each participating p_i dot P to vanish. | Source: A Comment on Loop Corrections to the Celestial Stress Tensor<br/>arXiv: 2205.10901<br/>Class: exact invariance criterion and converse<br/>Verification: 11 exact checks |
+| 14. Euclidean monodromy cancellation | Opposite Euclidean winding gives monodromy exp(2 pi i(alpha-beta)); paired factors are single-valued exactly for integer alpha-beta, while a one-variable complexified continuation remains obstructed generically. | Source: Multicollinear Singularities in Celestial CFT<br/>arXiv: 2309.16602<br/>Class: monodromy theorem and boundary<br/>Verification: 11 exact checks |
+| 15. All-order celestial momentum prefactor | Repeated momentum insertions generate the exact rising-factorial ratio (Delta)_r/Delta^r, including its recurrence, zeros at negative integers, and pole of order r-1 at Delta=0. | Source: Shifting Spin on the Celestial Sphere<br/>arXiv: 2012.15694<br/>Class: all-orders operator identity<br/>Verification: 11 exact checks |
+| 16. Closed celestial-recursion generating function | The complete symmetric polynomial recursion resums to 1/((1-ax)(1-bx)) and exponentiates the amplitude PDE into an exact two-factor rational translation law. | Source: Celestial Recursion<br/>arXiv: 2208.11635<br/>Class: generating-function resummation<br/>Verification: 12 exact checks |
+| 17. Universal Coulomb-branch complexity ratio | All geometric and gravitational scales cancel from C_flat/C_throat=[32+(7-p)^2]/[16(9-p)]; p=3 uniquely gives the maximal one-half reduction. | Source: Flat Space Entanglement: A Coulomb Branch Perspective<br/>arXiv: 2606.13889<br/>Class: exact universal ratio<br/>Verification: 15 exact checks |
+| 18. Self-corrected detector sum identity | A prior Ouroboros correction was a false positive caused by reading source-local falling-factorial notation as a rising Pochhammer symbol; the source identity is exact under its stated convention, and the earlier claim is superseded. | Source: Detector Operators for Celestial Symmetries<br/>arXiv: 2307.16801<br/>Class: self-correction and source confirmation<br/>Verification: 15 exact checks |
+| 19. Memory-detector fluence tradeoff | For a fixed memory impulse M delivered over duration T, the driving fluence obeys Phi>=M^2/T, with equality for a constant ramp and an exact signal-to-noise relation for the detector. | Source: Asymptotic Symmetries and Electromagnetic Memory<br/>arXiv: 1505.00716<br/>Class: sharp tradeoff bound<br/>Verification: 21 exact checks |
+| 20. Entanglement-scattering upper slack identity | The gap S_gen(s_ent)-I(V1;V2) is exactly the sum of four nonnegative geometric slacks divided by 4G_N, so saturation occurs if and only if all four source inequalities saturate. | Source: Generalized Entanglement Wedges and the Connected Wedge Theorem<br/>arXiv: 2604.22612<br/>Class: exact slack decomposition<br/>Verification: 11 exact checks |
+| 21. Flat boundary-corner rank drop | The finite-scale endpoint map is an eight-dimensional bijection with determinant -ell^-4, but its strict flat limit has rank four and loses exactly the four endpoint-time directions. | Source: Generalized Entanglement Wedges and the Connected Wedge Theorem<br/>arXiv: 2604.22612<br/>Class: rank-drop theorem with exact kernel<br/>Verification: 13 exact checks |
+| 22. Inverted Mellin normalization equivalence | The displayed extrapolate-dictionary equivalence is exact: the apparently missing factor is supplied by the positive rescaling t=(2u)^-1 together with the regulator rename, with no branch or normalization error. | Source: Equating Extrapolate Dictionaries for Massless Scattering<br/>arXiv: 2310.02186<br/>Class: source-equivalence proof<br/>Verification: 14 exact checks |
+| 23. Three-cut late-time null test | A permutation-invariant three-cut residual vanishes for every affine late-time signal and factorizes into a Vandermonde product times the quadratic curvature coefficient for the first nonlinear correction. | Source: Implications of Superrotations<br/>arXiv: 1905.10052<br/>Class: exact null test and curvature extractor<br/>Verification: 12 exact checks |
+| 24. Two-cut late-time image reconstruction | Two cuts reconstruct the four late-time image components exactly, with an explicit origin-shift law and the additional condition required for origin-independent cross-order matching. | Source: Implications of Superrotations<br/>arXiv: 1905.10052<br/>Class: exact reconstruction theorem<br/>Verification: 16 exact checks |
+| 25. Goldilocks logarithmic pole-order correction | A nonzero omega^m log^r(omega/mu) term produces a pole of exact order r+1 at Delta=-m with leading coefficient (-1)^r r!; changing scale mixes only lower poles. | Source: Goldilocks Modes and the Three Scattering Bases<br/>arXiv: 2202.11127<br/>Class: pole-order theorem and correction<br/>Verification: 11 exact checks |
+| 26. Low hard-generator nonclosure | The commutator of two Low hard generators has no angular component and closes in the original family only when a specific covariant derivative vanishes; generic monomial modes provide explicit obstructions. | Source: Low's Subleading Soft Theorem as a Symmetry of QED<br/>arXiv: 1407.3814<br/>Class: nonclosure theorem<br/>Verification: 18 exact checks |
+| 27. Exact finite stress-basis exclusion at m=3 | For the ordered complex conformal-scalar witness, the complete finite weight-(2,0) stress-tensor light-ray basis has rank three while the augmented system has rank four; an explicit left-null witness evaluates to 105/16. | Source: M3 Unclassified Module Construction<br/>arXiv: source-bound payload<br/>Class: basis-exclusion theorem<br/>Verification: 11 exact checks |
+| 28. Multiparticle beta-residue factor-two correction | Each displayed beta-function pole has twice the printed residue because its pole-bearing Gamma argument has slope -1/2 in Delta; when branches collide, the corrected residues sum exactly to the coalesced tower. | Source: Multiparticle States for the Flat Hologram<br/>arXiv: 2501.00462<br/>Class: source-equation correction<br/>Verification: 11 exact checks |
+| 29. Near-extremal radial pushforward | The angular variable pushes forward exactly to a bounded radial interval with dc=(rho^2+2 epsilon)/(2 epsilon rho^2)drho, width and endpoint product 2 epsilon, and median sqrt(2 epsilon). | Source: Flat Space Amplitudes and Conformal Symmetry of the Celestial Sphere<br/>arXiv: 1701.00049<br/>Class: exact change-of-variables theorem<br/>Verification: 20 exact checks |
+| 30. Omitted p=4 spherical entanglement extension | The p=4 spherical extremal surface admits an explicit matched large-P expansion through the first two nontrivial orders, including the renormalized area -3gR^2P^3/10+81g^2RP/35+O(P^-1). | Source: Flat Space Entanglement: A Coulomb Branch Perspective<br/>arXiv: 2606.13889<br/>Class: theorem extension<br/>Verification: 11 exact checks |
+| 31. First nonzero p=4 refined-entropy term | Applying the refined-entropy operator to the p=4 spherical expansion gives g^3/P[45 log(P/R)/16+82933/560000]+O(P^-3), positive in the stated infrared regime and decaying to zero. | Source: Flat Space Entanglement: A Coulomb Branch Perspective<br/>arXiv: 2606.13889<br/>Class: theorem extension and asymptotic result<br/>Verification: 11 exact checks |
+| 32. Point-scattering lower slack identity | The lower gap I(V1;V2)-S_gen(e_max(s_pts'')) is exactly the sum of four nonnegative CWT, ridge, focusing, and maximization slacks, with an if-and-only-if saturation criterion. | Source: Generalized Entanglement Wedges and the Connected Wedge Theorem<br/>arXiv: 2604.22612<br/>Class: exact slack decomposition<br/>Verification: 14 exact checks |
+| 33. All-integer-d Plancherel factorization | The principal-series measure factorizes into explicit positive polynomials for every even and odd integer dimension, obeys a two-dimension recurrence, and has the correct quadratic zero at the origin. | Source: Implications of Superrotations<br/>arXiv: 1905.10052<br/>Class: all-dimension factorization theorem<br/>Verification: 14 exact checks |
+| 34. All-D, all-n projective Mellin scale cancellation | Under canonical massless scaling, stripped-amplitude, Mellin-weight, momentum-delta, and projective-Jacobian degrees cancel exactly for arbitrary spacetime dimension D and particle count n. | Source: Gluon Amplitudes as 2d Conformal Correlators<br/>arXiv: 1706.03917<br/>Class: all-D, all-n theorem<br/>Verification: 12 exact checks |
+| 35. Projective-simplex signed-minor theorem | For a square localization system, Cramer signed-minor ratios give the unique simplex coordinates; strict positivity characterizes interior support, nonnegativity with a zero characterizes the boundary, and the Jacobian is 1/abs(det M). | Source: Gluon Amplitudes as 2d Conformal Correlators<br/>arXiv: 1706.03917<br/>Class: support, positivity, and Jacobian theorem<br/>Verification: 13 exact checks |
+| 36. All-D projective-simplex rank theorem | For a (D+1)-by-n constraint matrix of generic rank min(D+1,n), the theorem gives the exact number of residual external constraints or unfixed simplex moduli and separates unique, boundary, incompatible, and continuous-support regimes. | Source: Gluon Amplitudes as 2d Conformal Correlators<br/>arXiv: 1706.03917<br/>Class: all-D rank and support theorem<br/>Verification: 18 exact checks |
+| 37. Quadrupole spin-memory cap duality | The cap response is an explicit quintic with antipodal-complement antisymmetry F(1-x)=-F(x), complete physical zero set {0,1/2,1}, and an exact factorization exposing every sign change. | Source: New Gravitational Memories<br/>arXiv: 1502.06120<br/>Class: duality and factorization theorem<br/>Verification: 16 exact checks |
+| 38. Radial Einstein operator is an exact square | The published fourth-order radial equation factorizes exactly as [rho^2(D^2-4)+4L]^2, revealing generalized-kernel modes killed by the square but not by the second-order factor. | Source: Uplifting AdS3/CFT2 to Flat Space Holography<br/>arXiv: 1905.09809<br/>Class: operator factorization theorem<br/>Verification: 10 exact checks |
+| 39. Analytic proof of the flat-space RT equality | An exact boundary identity proves the coefficient equality previously supported numerically: C3^(p)=(7-p)/(9-p)[(C1^(p))^2+(C2^(p))^2], with the mechanism traced to alpha^2+beta^2=7-p. | Source: Flat Space Entanglement: A Coulomb Branch Perspective<br/>arXiv: 2606.13889<br/>Class: analytic proof of source equality<br/>Verification: 14 exact checks |
+| 40. Full soft-charge cumulant hierarchy | Ward conservation gives an exact subset-sum formula for every connected soft cumulant of order n>=2; deterministic incoming charge drops out, while mixed cumulants are the precise obstruction to a factorized hard-only reduction. | Source: Memory Correlators and Ward Identities in the 'in-in' Formalism<br/>arXiv: 2512.02825<br/>Class: all-orders hierarchy and obstruction<br/>Verification: 13 exact checks |
+| 41. Soft-charge reduced-state block theorem | Fixed total-charge support forces the reduced radiation state to commute with its charge, permits arbitrary degeneracy inside each charge block, and yields the exact entropy decomposition into sector entropy plus within-sector entropy. | Source: HPS meets AMPS: How Soft Hair Dissolves the Firewall<br/>arXiv: 2012.03850<br/>Class: reduced-state structure theorem<br/>Verification: 15 exact checks |
+| 42. Soft-dressing factor-two no-go | Under linear mode action and the derivation rule, multiplying every elementary charge commutator by lambda multiplies the whole dressing commutator by lambda; lambda=2 cannot preserve a nonzero target without compensating repair. | Source: Asymptotic charges as detectors and the memory effect in massive QED and perturbative quantum gravity<br/>arXiv: 2604.19866<br/>Class: no-go theorem and repair boundary<br/>Verification: 13 exact checks |
+| 43. Soft-Mellin factorial correction | The unqualified all-n identity requires an n! factor: the Mellin residue is g^(n)(0)/n!, so the source formula is exact at n=0,1 and is restored for all n by multiplying the residue side by n! or dividing u^n by n!. | Source: Revisiting the Conformally Soft Sector with Celestial Diamonds<br/>arXiv: 2105.09792<br/>Class: source-equation correction<br/>Verification: 12 exact checks |
+| 44. Spin-1 shadow gauge obstruction | The formal Delta=1 shadow field strength carries an unavoidable factor d-2 and has an explicit nonzero component for d!=2; only d=2 is self-shadow and pure gauge in the tested sense. | Source: A Conformal Basis for Flat Space Amplitudes<br/>arXiv: 1705.01027<br/>Class: dimension-specific obstruction theorem<br/>Verification: 19 exact checks |
+| 45. Subleading-soft gauge-defect theorem | Pure-gauge variation of the subleading soft factor vanishes for every reference pair exactly when the summed angular-momentum defect Delta J is zero; basis polarizations recover every defect component. | Source: Semiclassical Virasoro Symmetry of the Quantum Gravity S-Matrix<br/>arXiv: 1406.3312<br/>Class: if-and-only-if gauge theorem<br/>Verification: 12 exact checks |
+| 46. Infinite super-BMS commutator syzygy family | All routes to a fixed fermionic mode span a rank-one commutator image and obey an exact pairwise syzygy, with a classified exceptional route whenever m=2t/3 is integral. | Source: Conformally Soft Fermions<br/>arXiv: 2108.11422<br/>Class: infinite algebraic identity family<br/>Verification: 9 exact checks |
+| 47. Holomorphic superrotation charge cancellation | Under the source's explicit holomorphic restriction, the boundary term cancels both shear terms and the antiholomorphic news term, doubles only the holomorphic news term, and reproduces the exact 1/(16 pi G) charge. | Source: Asymptotic Symmetries and Celestial CFT<br/>arXiv: 2005.08990<br/>Class: exact source reduction<br/>Verification: 12 exact checks |
+| 48. Two-particle kernel variance theorem | The OPE ambiguity depends on the normalized kernel only through M[f]=1/4-integral f(t)(t-1/2)^2dt; positivity gives the sharp interval [0,1/4], while normalization alone admits an explicit unbounded signed family. | Source: Multiparticle Contributions to the Celestial OPE<br/>arXiv: 2402.18798<br/>Class: sharp bound and counterexample family<br/>Verification: 14 exact checks |
+| 49. Weyl-double-copy shadow involution | Delta maps to 2-Delta as an exact involution exchanging primary and shadow gauge, scalar, and Weyl data while preserving the reduced double-copy quotient and exchanging its Delta=0 and 2 divisors. | Source: Shifting Spin on the Celestial Sphere<br/>arXiv: 2012.15694<br/>Class: involution and equivariance theorem<br/>Verification: 17 exact checks |
+
+Full source-payload statuses, scientific payload hashes, and source links appear in `RESULT_ATLAS.md`; complete machine-readable assertions appear under `references/`.
+
+## 6. Replay that actually recomputes
+
+The strongest public evidence is the compute path, not the stored ledger. An evaluator begins with no cached source archive. The fetch phase obtains exact public arXiv bytes and rejects a mismatch. The compute phase imports the 49 kernels and generates full result payloads. That function has no reference-directory argument and no expected-answer import. Only a separate compare phase loads the reference assertions.
+
+This separation matters. A script that accepts our final numbers and prints them back would demonstrate packaging, not research reproducibility. Here, expected results are withheld from computation and used only after fresh outputs exist. Public equation constants encoded in the kernels are analogous to formulas in a conventional reproducibility notebook: they define the calculation. The resulting symbolic reductions, finite rows, spectra, ranks, signs, and identities are generated on the evaluator's machine.
+
+The falsifier phase establishes negative sensitivity. One changed source byte must fail the source lock; one changed output must fail comparison; and the compute function must remain structurally isolated from expected answers.
+
+## 7. Evidence classes
+
+The package separates four evidence classes. Public source evidence binds each calculation to exact arXiv bytes. Derivation evidence consists of executable kernels and fresh result payloads. Falsification evidence shows that corrupted inputs and outputs are rejected. Private operational evidence supports the history of the preceding recursive-self-improvement cycle and internal campaign control but is not necessary to run the public derivations.
+
+The claim that this research followed a roughly 29-hour recursive-self-improvement cycle is operator-reported and privately evidenced. The public claim is intentionally narrower: after that cycle, Ouroboros produced this research program without changing model weights.
+
+## 8. PAUSED means more work remains
+
+The campaign is not presented as an exhaustive treatment of Pasterski's scholarship. It was paused after covering 34 of 48 selected hydrated papers and producing 49 independently replayable packages, including a later theorem-chain closure that consolidates registered intermediate results. Fourteen selected papers remain in the immediate queue, and each covered paper admits further extensions, cross-links, and adversarial tests. PAUSED means the research loop was stopped by the operator at a stable boundary; it does not mean the program exhausted its productive frontier.
+
+The measured interval from hydration start to the last completed package was 18 h 11 min 31 s. Verified package generation occupied 12 h 10 min 05 s of that interval. A faster laptop would have allowed more acquisition, derivation, and verification cycles before the same pause time. This is a concrete throughput statement, not a claim that compute alone guarantees discovery quality.
+
+## 9. Cost estimate
+
+The campaign used approximately 3-8 million model tokens. Order-of-magnitude estimate: 49 research packages at roughly 40k-130k model tokens per package, plus corpus hydration, planning, verification, synthesis, and publication-stage overhead. No billing-grade aggregate token counter was recorded. The estimate is disclosed as a range because presenting unsupported precision would be less informative than stating the measurement boundary. It excludes the preceding approximately 29-hour recursive-self-improvement cycle.
+
+## 10. Capability interpretation
+
+Ouroboros is materially different from a one-shot chatbot or a stateless agent wrapper in the dimension tested here. The relevant unit is not a response. It is a persistent, source-bound research campaign that can acquire a corpus, form a topology of open problems, create and reject mathematical candidates, package passing results, preserve reusable capabilities, and continue until the operator pauses it. Imperfect candidates and failed routes occur, but they are inputs to the loop rather than terminal outputs.
+
+This paper does not claim access to the Ouroboros implementation. Public replay exposes the research calculations, not the private system. Evaluation of Ouroboros itself is available only as a paid, supervised, in-person engagement with the operator present; evaluators receive no implementation, copy, credentials, remote access, or continuing access.
+
+## 11. Use and credit
+
+The new work is free to use under the licenses in this package, provided **Ouroboros AI System** is credited and the NOTICE is preserved. Original papers and coauthors must be cited independently. No endorsement by Sabrina Pasterski or any coauthor is implied.
+
+## 12. Conclusion
+
+At pause, the campaign had converted a public research corpus into 49 exact, replayable computational packages and a growing persistent capability base. The outputs do not depend on asking readers to trust private logs: outsiders can regenerate the scientific payloads from public data. The separate private history explains why the campaign was run; the public replay shows what it produced.
diff --git a/PUBLICATION_PLAN.md b/PUBLICATION_PLAN.md
new file mode 100644
index 0000000000000000000000000000000000000000..04385e57d88804459f9d5427533f537dfe756825
--- /dev/null
+++ b/PUBLICATION_PLAN.md
@@ -0,0 +1,27 @@
+# Publication Plan
+
+This is the Ouroboros-authored, authority-bound release plan. Current state: **PAUSED / PRIVATE REVIEW STAGE**.
+
+## Gate 1 — private staging
+
+Assemble the manuscript, 49-kernel replay, 36-source lock, registered-artifact disposition audit, falsifiers, result atlas, licenses, citation metadata, review PDF, and complete SHA manifest in a new immutable local directory. Keep all upload and public-action flags false.
+
+## Gate 2 — clean-room replay
+
+From an empty cache, retrieve public source archives, verify every SHA, run all derivations, emit fresh results before reading references, compare generated payloads, and require adversarial source/result mutations to fail.
+
+## Gate 3 — operator review
+
+The operator reviews scientific wording, attribution, token-range labeling, PAUSED status, licenses, PDF layout, and the distinction between public replay code and private Ouroboros access. Any substantive mathematical expansion creates a new immutable version.
+
+## Gate 4 — release candidate
+
+Only after explicit operator instruction: rebuild from clean inputs, regenerate the manifest and PDF, run the publication claim and privacy guards, and create a new private Hugging Face repository through the authenticated API path. Private upload does not authorize public visibility.
+
+## Gate 5 — public promotion
+
+Only the operator may authorize changing visibility. Promotion follows remote SHA verification and a final no-secret/no-local-path scan. The release must remain labeled PAUSED and must preserve the Ouroboros AI System credit.
+
+## Rollback and stop conditions
+
+The private stage is immutable. A failed gate does not mutate it; corrections go into a new version. Stop on source-hash drift, a replay mismatch, a failing falsifier, a missing artifact hash, a privacy leak, an attribution defect, or absent operator release authority.
diff --git a/README.md b/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..b64483123a17a389ed0a16703369808d153592ed
--- /dev/null
+++ b/README.md
@@ -0,0 +1,24 @@
+---
+pretty_name: Ouroboros Pasterski Research Program — PAUSED
+language:
+  - en
+license: cc-by-4.0
+tags:
+  - physics
+  - mathematical-physics
+  - celestial-holography
+  - reproducible-research
+  - ouroboros-ai-system
+---
+
+# Ouroboros Pasterski Research Program — PAUSED
+
+This repository is staged privately for operator review and is designed for a future public research release. Repository visibility must remain private until the operator explicitly changes it.
+
+The package contains 49 portable derivation kernels, a SHA-pinned lock for 36 public arXiv source archives, 49 derivation tests, a registered-artifact disposition audit, independent compute/compare/falsifier commands, a comprehensive paper, a result atlas, licenses, citation metadata, a rendered review PDF, and a complete manifest.
+
+Start with `REPLAY_STANDARD.md` and `VALIDATION.md`, then review `PAPER.md`, `RESULT_ATLAS.md`, and `PUBLICATION_PLAN.md`.
+
+Required credit: **Ouroboros AI System**.
+
+The dataset-card license describes the generated research data and prose. Replay code is separately licensed under `LICENSE-CODE`; third-party papers remain under their original terms and are retrieved from their public source URLs rather than redistributed here.
diff --git a/REPLAY_STANDARD.md b/REPLAY_STANDARD.md
new file mode 100644
index 0000000000000000000000000000000000000000..dd98b403d49f807d983c542322375fd43353eeca
--- /dev/null
+++ b/REPLAY_STANDARD.md
@@ -0,0 +1,34 @@
+# Independent Replay Standard
+
+This release distinguishes three operations that must not be conflated.
+
+## 1. Derivation replay
+
+The evaluator starts with an empty source cache. The replay fetches 36 exact public arXiv source archives, rejects any source whose SHA-256 differs from the lock, imports 49 portable research kernels, and generates fresh symbolic or numerical result payloads on the evaluator's machine. The compute path does not import, read, or accept the stored reference assertions.
+
+## 2. Falsifier replay
+
+The falsifier corrupts a source archive and requires hash verification to reject it. It also mutates a freshly generated result and requires post-computation comparison to fail. A source-level isolation check confirms that the compute function has no reference/expected-answer dependency.
+
+## 3. Receipt verification
+
+Receipt verification checks file identities and provenance hashes. It is useful integrity evidence, but it is **not independent scientific replay**.
+
+Expected values are permitted only after computation as assertions. They are never inputs to a derivation. Public constants copied from cited equations are legitimate scientific inputs; stored final answers are not.
+
+## Commands
+
+```bash
+python -m venv .venv
+.venv/bin/python -m pip install -r requirements.txt
+export OUROBOROS_SOURCE_CACHE="$PWD/clean-cache"
+.venv/bin/python -m ouroboros_replay fetch
+.venv/bin/python -m pytest -q tests
+.venv/bin/python -m ouroboros_replay compute --output fresh-results
+.venv/bin/python -m ouroboros_replay compare --actual fresh-results
+.venv/bin/python -m ouroboros_replay falsify --actual fresh-results --temporary falsifier-work
+```
+
+On Windows PowerShell, set `$env:OUROBOROS_SOURCE_CACHE = "$PWD\clean-cache"` and use `.venv\Scripts\python` in place of `.venv/bin/python`.
+
+Acceptance requires 36/36 source hashes, 49/49 derivation tests, 49/49 freshly generated payload matches, and every falsifier to pass. Network retrieval failures are reported separately from scientific failures.
diff --git a/RESULT_ATLAS.md b/RESULT_ATLAS.md
new file mode 100644
index 0000000000000000000000000000000000000000..51cc9aae1e961f2cc9e0696ccc7cdfaa9d934613
--- /dev/null
+++ b/RESULT_ATLAS.md
@@ -0,0 +1,593 @@
+# Verified Result Atlas
+
+Status: **PAUSED research**. Each entry is independently recomputable by the included kernels.
+
+The discovery and bounded mathematical claim come first. Source, classification, checks, and payload identity follow so that the significance is legible without opening a machine-readable assertion.
+
+## 1. Spectral no-radiation criterion
+
+**What Ouroboros established:** The proposed super-Poynting criterion vanishes exactly when the Cotton-York and stress tensors commute; the commutator norm is a Cotton-eigenvalue-gap-weighted sum of stress-frame misalignments.
+
+- Source paper: *Radiation in Holography*
+- Kernel: `run_sabrina_ads_radiation_spectral_commutator`
+- Public sources: [arXiv:2404.02146](https://arxiv.org/abs/2404.02146)
+- Classification: **criterion theorem and spectral identity**
+- Source-payload status: `complete`
+- Exact checks: 11
+- Scientific payload SHA-256: `241d637afce046d817e7a3107063956a87e7581ccc4ccb9230959c16a846ff1d`
+
+## 2. Exact two-interval scattering domain
+
+**What Ouroboros established:** The nonempty scattering region is exactly pi/2 <= mu <= arccos(-1/3) with tau_*(mu) <= tau <= pi-mu, including the collapsed endpoint and linear and quadratic onset laws.
+
+- Source paper: *Cryptographic tests of the python's lunch conjecture*
+- Kernel: `run_sabrina_ads_two_interval_scattering_feasibility`
+- Public sources: [arXiv:2411.10527](https://arxiv.org/abs/2411.10527)
+- Classification: **exact feasibility-domain theorem**
+- Source-payload status: `complete`
+- Exact checks: 18
+- Scientific payload SHA-256: `da08f86ea668e62889d14682aff488ad090f0b3c49d6ffc823e456f799cd580b`
+
+## 3. All-even-dimensional Ward normalization
+
+**What Ouroboros established:** For every d=2m+2 with integer m>=2, every m-dependent factor cancels between the soft charge, Green function, and hard action, leaving the same normalized Ward identity.
+
+- Source paper: *Higher-Dimensional Supertranslations and Weinberg's Soft Graviton Theorem*
+- Kernel: `run_sabrina_all_even_d_ward_normalization`
+- Public sources: [arXiv:1502.07644](https://arxiv.org/abs/1502.07644)
+- Classification: **all-dimension theorem extension**
+- Source-payload status: `all_even_d_soft_hard_ward_normalization_exact_and_m_independent`
+- Exact checks: 11
+- Scientific payload SHA-256: `36d368057821e69206d459c5b4f34e81d6d3b1df977de35db7a7bd523f3b529e`
+
+## 4. All-m transverse-nonlocality saturation theorem
+
+**What Ouroboros established:** For every integer m>=3, the minimal inverse-total-Z depth is exactly d_min(m)=m-3; distribution order r has exact total-Z multiplicity r+2 through r=m-1, and all orders r>=m vanish.
+
+- Source paper: *All M Transverse Nonlocality Chain*
+- Kernel: `run_sabrina_all_m_transverse_nonlocality_chain`
+- Public sources: [arXiv:2211.14287](https://arxiv.org/abs/2211.14287), [arXiv:2307.16801](https://arxiv.org/abs/2307.16801), [arXiv:2607.28718](https://arxiv.org/abs/2607.28718)
+- Classification: **all-m theorem from finite ladder to exact closure**
+- Source-payload status: `all_m_transverse_nonlocality_depth_saturation_and_distribution_order_multiplicity_exact`
+- Exact checks: 12
+- Scientific payload SHA-256: `6600de93b5e0dbb7dc6744cfc31499e4d84760267f62e18bc2a1c9a0e8470db5`
+
+## 5. Ambidextrous prefactor singularity lattice
+
+**What Ouroboros established:** The symmetric and antisymmetric celestial prefactors alternate zeros and finite values at positive integers, while complementary simple poles and zeros occur at nonpositive integers, with exact residues at Delta=0 and 1.
+
+- Source paper: *Celestial amplitudes in an ambidextrous basis*
+- Kernel: `run_sabrina_ambidextrous_integer_prefactor_lattice`
+- Public sources: [arXiv:2212.00962](https://arxiv.org/abs/2212.00962)
+- Classification: **analytic zero-and-pole classification**
+- Source-payload status: `complete`
+- Exact checks: 11
+- Scientific payload SHA-256: `77e01bb41ab0dd463176786be21185590dc2a06da27f2585d546e2a379c2ff4f`
+
+## 6. Boundary soft-scale cocycle
+
+**What Ouroboros established:** Changing the infrared scale shifts the correlator only by -(log lambda)/(4 pi) times the angular contact delta; separated-point correlators and logarithmic-time derivatives are invariant.
+
+- Source paper: *A Comment on Boundary Correlators: Soft Omissions and the Massless S-Matrix*
+- Kernel: `run_sabrina_boundary_soft_scale_cocycle`
+- Public sources: [arXiv:2410.20296](https://arxiv.org/abs/2410.20296)
+- Classification: **exact contact-term theorem**
+- Source-payload status: `complete`
+- Exact checks: 12
+- Scientific payload SHA-256: `a335d252d7be59f9c40e7abc990331da16b0b54eda70f70d4fa5172d95b2e084`
+
+## 7. All-orders Carrollian-Mellin intertwiner
+
+**What Ouroboros established:** The transform of u^m partial_u^r Phi is fixed at every order by Gamma(nu)/Gamma(nu-m), and the induced raising and lowering operations obey the Weyl relation [D,U]=1.
+
+- Source paper: *Multiparticle States for the Flat Hologram*
+- Kernel: `run_sabrina_carrollian_celestial_weyl_intertwiner`
+- Public sources: [arXiv:2501.00462](https://arxiv.org/abs/2501.00462)
+- Classification: **all-orders representation theorem**
+- Source-payload status: `complete`
+- Exact checks: 10
+- Scientific payload SHA-256: `d0b52d420b0b0aae1fb470163344d5fb5916c44ba5527310e10482165c6132cd`
+
+## 8. Conglomerate-kernel rank stratification
+
+**What Ouroboros established:** The published coefficient vector is unique only when both chiral weight pairs are nonzero; the kernel jumps to dimension two or four on the corresponding boundary loci.
+
+- Source paper: *Multiparticle States for the Flat Hologram*
+- Kernel: `run_sabrina_carrollian_conglomerate_kernel_stratification`
+- Public sources: [arXiv:2501.00462](https://arxiv.org/abs/2501.00462)
+- Classification: **hypothesis correction and boundary theorem**
+- Source-payload status: `complete`
+- Exact checks: 12
+- Scientific payload SHA-256: `3bd160a7dfa798b30b4390d34d11f59d48bd1398ec53c50dcc434e3fe64a4737`
+
+## 9. Causal interior-inclusion lemma
+
+**What Ouroboros established:** If A lies in the manifold interior of B, then J+(A) lies in I+(B) and J-(A) lies in I-(B), with the closed-set boundary corollary stated explicitly.
+
+- Source paper: *On sufficient conditions for holographic scattering*
+- Kernel: `run_sabrina_causal_interior_inclusion_lemma`
+- Public sources: [arXiv:2509.26264](https://arxiv.org/abs/2509.26264)
+- Classification: **exact causal lemma**
+- Source-payload status: `complete`
+- Exact checks: 10
+- Scientific payload SHA-256: `d99b817c432380bbff4836ba0a169029b609c9519bb2ee813a581878f4ac7531`
+
+## 10. CDQS amplification parameter obstruction
+
+**What Ouroboros established:** The cited alpha=0.495 code cannot correct arbitrary t-qubit errors, and after enforcing alpha<=1/4 the stated i.i.d. exponent is positive at base error 0.09; the package isolates repair classes without claiming the amplification theorem false.
+
+- Source paper: *Conditional disclosure of secrets with quantum resources*
+- Kernel: `run_sabrina_cdqs_amplification_singleton_obstruction`
+- Public sources: [arXiv:2404.14491](https://arxiv.org/abs/2404.14491)
+- Classification: **proof-parameter obstruction**
+- Source-payload status: `complete`
+- Exact checks: 15
+- Scientific payload SHA-256: `030824c1879fcf5639d3fb849067dcd70eb43ab728bad7d3961c5fe44ac5f1b5`
+
+## 11. Strengthened CDQS fidelity envelope
+
+**What Ouroboros established:** Combining F<=min(1,2a) with I>=-2 log F yields I>=max(0,-2 log(2a)), strictly strengthening the displayed -log(a)-1 bound for every a>0.
+
+- Source paper: *Cryptographic tests of the python's lunch conjecture*
+- Kernel: `run_sabrina_cdqs_fidelity_envelope_strengthening`
+- Public sources: [arXiv:2411.10527](https://arxiv.org/abs/2411.10527)
+- Classification: **strict bound strengthening**
+- Source-payload status: `complete`
+- Exact checks: 11
+- Scientific payload SHA-256: `a74b4d88eeb5eac12a40fce9ce013f2e18f9e4a748ea1a973380efcbeadd519b`
+
+## 12. Celestial-circle convex-hull certificate
+
+**What Ouroboros established:** A strict celestial circle separates finite incoming and outgoing point sets exactly when their embedded convex hulls are disjoint; either a separating plane or a finite Caratheodory obstruction certifies the answer.
+
+- Source paper: *Celestial Geometry*
+- Kernel: `run_sabrina_celestial_circle_convex_hull_certificate`
+- Public sources: [arXiv:2204.02505](https://arxiv.org/abs/2204.02505)
+- Classification: **geometric equivalence and certificates**
+- Source-payload status: `complete`
+- Exact checks: 11
+- Scientific payload SHA-256: `e838335f66a4c68f81f7e6f5678fe10cea02f297400cd6d76dda8ab4d73e73eb`
+
+## 13. Eikonal logarithm gauge criterion
+
+**What Ouroboros established:** Signed momentum conservation removes every leg-separable logarithm shift, and under the spanning hypothesis cancellation for all independent shifts conversely forces each participating p_i dot P to vanish.
+
+- Source paper: *A Comment on Loop Corrections to the Celestial Stress Tensor*
+- Kernel: `run_sabrina_celestial_eikonal_logarithm_gauge`
+- Public sources: [arXiv:2205.10901](https://arxiv.org/abs/2205.10901)
+- Classification: **exact invariance criterion and converse**
+- Source-payload status: `complete`
+- Exact checks: 11
+- Scientific payload SHA-256: `496aa27aa4e52fa3a6f9da412561aaa652cf21690744c98593d94d0ffbe1e6f8`
+
+## 14. Euclidean monodromy cancellation
+
+**What Ouroboros established:** Opposite Euclidean winding gives monodromy exp(2 pi i(alpha-beta)); paired factors are single-valued exactly for integer alpha-beta, while a one-variable complexified continuation remains obstructed generically.
+
+- Source paper: *Multicollinear Singularities in Celestial CFT*
+- Kernel: `run_sabrina_celestial_euclidean_monodromy_cancellation`
+- Public sources: [arXiv:2309.16602](https://arxiv.org/abs/2309.16602)
+- Classification: **monodromy theorem and boundary**
+- Source-payload status: `complete`
+- Exact checks: 11
+- Scientific payload SHA-256: `a1a2263b72c97030c657dcafd5ebb59be09b6c15290e6578fd342c0c83eba049`
+
+## 15. All-order celestial momentum prefactor
+
+**What Ouroboros established:** Repeated momentum insertions generate the exact rising-factorial ratio (Delta)_r/Delta^r, including its recurrence, zeros at negative integers, and pole of order r-1 at Delta=0.
+
+- Source paper: *Shifting Spin on the Celestial Sphere*
+- Kernel: `run_sabrina_celestial_momentum_rising_factorial`
+- Public sources: [arXiv:2012.15694](https://arxiv.org/abs/2012.15694)
+- Classification: **all-orders operator identity**
+- Source-payload status: `complete`
+- Exact checks: 11
+- Scientific payload SHA-256: `643a45bec4e1890d5a2fb13854b61ccd5e0eccb5cce7a7a293ce045edef79e9c`
+
+## 16. Closed celestial-recursion generating function
+
+**What Ouroboros established:** The complete symmetric polynomial recursion resums to 1/((1-ax)(1-bx)) and exponentiates the amplitude PDE into an exact two-factor rational translation law.
+
+- Source paper: *Celestial Recursion*
+- Kernel: `run_sabrina_celestial_recursion_pde_generating_function`
+- Public sources: [arXiv:2208.11635](https://arxiv.org/abs/2208.11635)
+- Classification: **generating-function resummation**
+- Source-payload status: `complete`
+- Exact checks: 12
+- Scientific payload SHA-256: `94cf744ae42b66c5db61c4d853a7867562d928a7eb80e7cc3297657eb8fcf1cd`
+
+## 17. Universal Coulomb-branch complexity ratio
+
+**What Ouroboros established:** All geometric and gravitational scales cancel from C_flat/C_throat=[32+(7-p)^2]/[16(9-p)]; p=3 uniquely gives the maximal one-half reduction.
+
+- Source paper: *Flat Space Entanglement: A Coulomb Branch Perspective*
+- Kernel: `run_sabrina_coulomb_branch_complexity_ratio`
+- Public sources: [arXiv:2606.13889](https://arxiv.org/abs/2606.13889)
+- Classification: **exact universal ratio**
+- Source-payload status: `complete`
+- Exact checks: 15
+- Scientific payload SHA-256: `0a48392a955f724766d46453ed8d209ae2f1cfca84d21c71d0807b479504eb06`
+
+## 18. Self-corrected detector sum identity
+
+**What Ouroboros established:** A prior Ouroboros correction was a false positive caused by reading source-local falling-factorial notation as a rising Pochhammer symbol; the source identity is exact under its stated convention, and the earlier claim is superseded.
+
+- Source paper: *Detector Operators for Celestial Symmetries*
+- Kernel: `run_sabrina_detector_sum_identity_correction`
+- Public sources: [arXiv:2307.16801](https://arxiv.org/abs/2307.16801)
+- Classification: **self-correction and source confirmation**
+- Source-payload status: `v1_false_positive_superseded_source_local_falling_factorial_identity_exact`
+- Exact checks: 15
+- Scientific payload SHA-256: `a1b7a157ca0f6b33a4e558a471219f1c3b5c077bbca275918db542a467ec6aad`
+
+## 19. Memory-detector fluence tradeoff
+
+**What Ouroboros established:** For a fixed memory impulse M delivered over duration T, the driving fluence obeys Phi>=M^2/T, with equality for a constant ramp and an exact signal-to-noise relation for the detector.
+
+- Source paper: *Asymptotic Symmetries and Electromagnetic Memory*
+- Kernel: `run_sabrina_electromagnetic_memory_detector_tradeoff`
+- Public sources: [arXiv:1505.00716](https://arxiv.org/abs/1505.00716)
+- Classification: **sharp tradeoff bound**
+- Source-payload status: `complete`
+- Exact checks: 21
+- Scientific payload SHA-256: `015631d9110b4b95c4a08337ca93d0143257d133d51159fe68736db9947d926e`
+
+## 20. Entanglement-scattering upper slack identity
+
+**What Ouroboros established:** The gap S_gen(s_ent)-I(V1;V2) is exactly the sum of four nonnegative geometric slacks divided by 4G_N, so saturation occurs if and only if all four source inequalities saturate.
+
+- Source paper: *Generalized Entanglement Wedges and the Connected Wedge Theorem*
+- Kernel: `run_sabrina_entanglement_scattering_slack_identity`
+- Public sources: [arXiv:2604.22612](https://arxiv.org/abs/2604.22612)
+- Classification: **exact slack decomposition**
+- Source-payload status: `complete`
+- Exact checks: 11
+- Scientific payload SHA-256: `65ed4ac892b7bc06c0e00a75b8253eceebe84a4342dbbdfc165c226b7a62fdf3`
+
+## 21. Flat boundary-corner rank drop
+
+**What Ouroboros established:** The finite-scale endpoint map is an eight-dimensional bijection with determinant -ell^-4, but its strict flat limit has rank four and loses exactly the four endpoint-time directions.
+
+- Source paper: *Generalized Entanglement Wedges and the Connected Wedge Theorem*
+- Kernel: `run_sabrina_flat_boundary_corner_rank_drop`
+- Public sources: [arXiv:2604.22612](https://arxiv.org/abs/2604.22612)
+- Classification: **rank-drop theorem with exact kernel**
+- Source-payload status: `complete`
+- Exact checks: 13
+- Scientific payload SHA-256: `0853ed3bb32e027bf8d6f6b380fcb29ace7776981e3c033036dac278b99443a6`
+
+## 22. Inverted Mellin normalization equivalence
+
+**What Ouroboros established:** The displayed extrapolate-dictionary equivalence is exact: the apparently missing factor is supplied by the positive rescaling t=(2u)^-1 together with the regulator rename, with no branch or normalization error.
+
+- Source paper: *Equating Extrapolate Dictionaries for Massless Scattering*
+- Kernel: `run_sabrina_inverted_mellin_equivalence`
+- Public sources: [arXiv:2310.02186](https://arxiv.org/abs/2310.02186)
+- Classification: **source-equivalence proof**
+- Source-payload status: `source_equation_consistent_normalization_rescaling_made_explicit`
+- Exact checks: 14
+- Scientific payload SHA-256: `8238ba9f3410ddad34f4ba9d8b58fed3f8b73f2da4ac14bd651fe311098aed7e`
+
+## 23. Three-cut late-time null test
+
+**What Ouroboros established:** A permutation-invariant three-cut residual vanishes for every affine late-time signal and factorizes into a Vandermonde product times the quadratic curvature coefficient for the first nonlinear correction.
+
+- Source paper: *Implications of Superrotations*
+- Kernel: `run_sabrina_late_time_three_cut_null_test`
+- Public sources: [arXiv:1905.10052](https://arxiv.org/abs/1905.10052)
+- Classification: **exact null test and curvature extractor**
+- Source-payload status: `late_time_three_cut_affine_null_test_and_quadratic_curvature_extraction_exact`
+- Exact checks: 12
+- Scientific payload SHA-256: `fc350a6e78c22144f885c36d6387db83ad9717444e32af7a851e5a32136bcbe8`
+
+## 24. Two-cut late-time image reconstruction
+
+**What Ouroboros established:** Two cuts reconstruct the four late-time image components exactly, with an explicit origin-shift law and the additional condition required for origin-independent cross-order matching.
+
+- Source paper: *Implications of Superrotations*
+- Kernel: `run_sabrina_late_time_two_cut_reconstruction`
+- Public sources: [arXiv:1905.10052](https://arxiv.org/abs/1905.10052)
+- Classification: **exact reconstruction theorem**
+- Source-payload status: `late_time_two_cut_image_reconstruction_exact_with_origin_covariance`
+- Exact checks: 16
+- Scientific payload SHA-256: `db1fd19b1f87b4ae81f8df3e51fb7af41553eddcc0138d1b499afb0ace0a7614`
+
+## 25. Goldilocks logarithmic pole-order correction
+
+**What Ouroboros established:** A nonzero omega^m log^r(omega/mu) term produces a pole of exact order r+1 at Delta=-m with leading coefficient (-1)^r r!; changing scale mixes only lower poles.
+
+- Source paper: *Goldilocks Modes and the Three Scattering Bases*
+- Kernel: `run_sabrina_logarithmic_mellin_pole_order_correction`
+- Public sources: [arXiv:2202.11127](https://arxiv.org/abs/2202.11127)
+- Classification: **pole-order theorem and correction**
+- Source-payload status: `complete`
+- Exact checks: 11
+- Scientific payload SHA-256: `7e71ad1c811616ad2bae1d0eff9e16fe5a8aca3e975f7016352c215d2a8062a2`
+
+## 26. Low hard-generator nonclosure
+
+**What Ouroboros established:** The commutator of two Low hard generators has no angular component and closes in the original family only when a specific covariant derivative vanishes; generic monomial modes provide explicit obstructions.
+
+- Source paper: *Low's Subleading Soft Theorem as a Symmetry of QED*
+- Kernel: `run_sabrina_low_hard_generator_nonclosure`
+- Public sources: [arXiv:1407.3814](https://arxiv.org/abs/1407.3814)
+- Classification: **nonclosure theorem**
+- Source-payload status: `complete`
+- Exact checks: 18
+- Scientific payload SHA-256: `923662d26ef1703e8e9b20da3584065e853328708a7abc6c4e522e16abb2d9b5`
+
+## 27. Exact finite stress-basis exclusion at m=3
+
+**What Ouroboros established:** For the ordered complex conformal-scalar witness, the complete finite weight-(2,0) stress-tensor light-ray basis has rank three while the augmented system has rank four; an explicit left-null witness evaluates to 105/16.
+
+- Source paper: *M3 Unclassified Module Construction*
+- Kernel: `run_sabrina_m3_unclassified_module_construction`
+- Public sources: source IDs recorded in the result payload
+- Classification: **basis-exclusion theorem**
+- Source-payload status: `exact_full_stress_basis_exclusion`
+- Exact checks: 11
+- Scientific payload SHA-256: `87a52883c1ab297c98ffbc371b709b01fb9e2a6054647a4be0487d54f0768bc7`
+
+## 28. Multiparticle beta-residue factor-two correction
+
+**What Ouroboros established:** Each displayed beta-function pole has twice the printed residue because its pole-bearing Gamma argument has slope -1/2 in Delta; when branches collide, the corrected residues sum exactly to the coalesced tower.
+
+- Source paper: *Multiparticle States for the Flat Hologram*
+- Kernel: `run_sabrina_multiparticle_beta_residue_factor_two`
+- Public sources: [arXiv:2501.00462](https://arxiv.org/abs/2501.00462)
+- Classification: **source-equation correction**
+- Source-payload status: `complete`
+- Exact checks: 11
+- Scientific payload SHA-256: `6485daa678a208dfd8860503be6c60a553e2d767188c34ec80b762520c23e455`
+
+## 29. Near-extremal radial pushforward
+
+**What Ouroboros established:** The angular variable pushes forward exactly to a bounded radial interval with dc=(rho^2+2 epsilon)/(2 epsilon rho^2)drho, width and endpoint product 2 epsilon, and median sqrt(2 epsilon).
+
+- Source paper: *Flat Space Amplitudes and Conformal Symmetry of the Celestial Sphere*
+- Kernel: `run_sabrina_near_extremal_radial_pushforward`
+- Public sources: [arXiv:1701.00049](https://arxiv.org/abs/1701.00049)
+- Classification: **exact change-of-variables theorem**
+- Source-payload status: `complete`
+- Exact checks: 20
+- Scientific payload SHA-256: `2e51bc35b918b5683ba9f4c83c8ff6e0488713eb143c0d120e66640262410e4e`
+
+## 30. Omitted p=4 spherical entanglement extension
+
+**What Ouroboros established:** The p=4 spherical extremal surface admits an explicit matched large-P expansion through the first two nontrivial orders, including the renormalized area -3gR^2P^3/10+81g^2RP/35+O(P^-1).
+
+- Source paper: *Flat Space Entanglement: A Coulomb Branch Perspective*
+- Kernel: `run_sabrina_p4_spherical_entanglement_expansion`
+- Public sources: [arXiv:2606.13889](https://arxiv.org/abs/2606.13889)
+- Classification: **theorem extension**
+- Source-payload status: `complete`
+- Exact checks: 11
+- Scientific payload SHA-256: `15b684b9177c314bc5aeca308c80eae5ad95abfcd73c261eb7e7e51848f6b300`
+
+## 31. First nonzero p=4 refined-entropy term
+
+**What Ouroboros established:** Applying the refined-entropy operator to the p=4 spherical expansion gives g^3/P[45 log(P/R)/16+82933/560000]+O(P^-3), positive in the stated infrared regime and decaying to zero.
+
+- Source paper: *Flat Space Entanglement: A Coulomb Branch Perspective*
+- Kernel: `run_sabrina_p4_spherical_refined_entropy`
+- Public sources: [arXiv:2606.13889](https://arxiv.org/abs/2606.13889)
+- Classification: **theorem extension and asymptotic result**
+- Source-payload status: `complete`
+- Exact checks: 11
+- Scientific payload SHA-256: `391c082d381a39de409e09c5d5d1798607ab16101326c4103bafbd5f220a2345`
+
+## 32. Point-scattering lower slack identity
+
+**What Ouroboros established:** The lower gap I(V1;V2)-S_gen(e_max(s_pts'')) is exactly the sum of four nonnegative CWT, ridge, focusing, and maximization slacks, with an if-and-only-if saturation criterion.
+
+- Source paper: *Generalized Entanglement Wedges and the Connected Wedge Theorem*
+- Kernel: `run_sabrina_points_scattering_lower_slack_identity`
+- Public sources: [arXiv:2604.22612](https://arxiv.org/abs/2604.22612)
+- Classification: **exact slack decomposition**
+- Source-payload status: `complete`
+- Exact checks: 14
+- Scientific payload SHA-256: `7f9b013510e795182939e14d751abafa52301bf7e7cd140ff4fa5a32a2b8db69`
+
+## 33. All-integer-d Plancherel factorization
+
+**What Ouroboros established:** The principal-series measure factorizes into explicit positive polynomials for every even and odd integer dimension, obeys a two-dimension recurrence, and has the correct quadratic zero at the origin.
+
+- Source paper: *Implications of Superrotations*
+- Kernel: `run_sabrina_principal_series_plancherel_factorization`
+- Public sources: [arXiv:1905.10052](https://arxiv.org/abs/1905.10052)
+- Classification: **all-dimension factorization theorem**
+- Source-payload status: `principal_series_plancherel_measure_all_integer_d_factorization_exact`
+- Exact checks: 14
+- Scientific payload SHA-256: `4047efe441ad0800b95a0d64b4354de371b4f6fdf6be4f1cbe59763680be8178`
+
+## 34. All-D, all-n projective Mellin scale cancellation
+
+**What Ouroboros established:** Under canonical massless scaling, stripped-amplitude, Mellin-weight, momentum-delta, and projective-Jacobian degrees cancel exactly for arbitrary spacetime dimension D and particle count n.
+
+- Source paper: *Gluon Amplitudes as 2d Conformal Correlators*
+- Kernel: `run_sabrina_projective_mellin_scale_theorem`
+- Public sources: [arXiv:1706.03917](https://arxiv.org/abs/1706.03917)
+- Classification: **all-D, all-n theorem**
+- Source-payload status: `all_D_all_n_projective_mellin_radial_scale_cancellation_exact_under_canonical_scaling`
+- Exact checks: 12
+- Scientific payload SHA-256: `bb866693a5cac8a1a30c7d4d3dec8feea3e6911173eca33cae0c27c503449354`
+
+## 35. Projective-simplex signed-minor theorem
+
+**What Ouroboros established:** For a square localization system, Cramer signed-minor ratios give the unique simplex coordinates; strict positivity characterizes interior support, nonnegativity with a zero characterizes the boundary, and the Jacobian is 1/abs(det M).
+
+- Source paper: *Gluon Amplitudes as 2d Conformal Correlators*
+- Kernel: `run_sabrina_projective_simplex_positivity_theorem`
+- Public sources: [arXiv:1706.03917](https://arxiv.org/abs/1706.03917)
+- Classification: **support, positivity, and Jacobian theorem**
+- Source-payload status: `square_projective_simplex_signed_minor_support_and_jacobian_theorem_exact`
+- Exact checks: 13
+- Scientific payload SHA-256: `04b196f77ef38f277dfbb7ebeccf2b1964f90157335f9a1dc268c6654d548af4`
+
+## 36. All-D projective-simplex rank theorem
+
+**What Ouroboros established:** For a (D+1)-by-n constraint matrix of generic rank min(D+1,n), the theorem gives the exact number of residual external constraints or unfixed simplex moduli and separates unique, boundary, incompatible, and continuous-support regimes.
+
+- Source paper: *Gluon Amplitudes as 2d Conformal Correlators*
+- Kernel: `run_sabrina_projective_simplex_rank_theorem`
+- Public sources: [arXiv:1706.03917](https://arxiv.org/abs/1706.03917)
+- Classification: **all-D rank and support theorem**
+- Source-payload status: `all_D_projective_simplex_localization_rank_theorem_exact_with_support_and_positivity_boundaries`
+- Exact checks: 18
+- Scientific payload SHA-256: `a4be65bfe6724693b679405e1985b33302d94ec8113edf75512620fcc58045f7`
+
+## 37. Quadrupole spin-memory cap duality
+
+**What Ouroboros established:** The cap response is an explicit quintic with antipodal-complement antisymmetry F(1-x)=-F(x), complete physical zero set {0,1/2,1}, and an exact factorization exposing every sign change.
+
+- Source paper: *New Gravitational Memories*
+- Kernel: `run_sabrina_quadrupole_spin_memory_cap_duality`
+- Public sources: [arXiv:1502.06120](https://arxiv.org/abs/1502.06120)
+- Classification: **duality and factorization theorem**
+- Source-payload status: `complete`
+- Exact checks: 16
+- Scientific payload SHA-256: `ec237ce1930d800c155dbce44a6eb3a8c2c5c9d65bcf638d05a6583ce813ba9a`
+
+## 38. Radial Einstein operator is an exact square
+
+**What Ouroboros established:** The published fourth-order radial equation factorizes exactly as [rho^2(D^2-4)+4L]^2, revealing generalized-kernel modes killed by the square but not by the second-order factor.
+
+- Source paper: *Uplifting AdS3/CFT2 to Flat Space Holography*
+- Kernel: `run_sabrina_radial_einstein_square_factorization`
+- Public sources: [arXiv:1905.09809](https://arxiv.org/abs/1905.09809)
+- Classification: **operator factorization theorem**
+- Source-payload status: `complete`
+- Exact checks: 10
+- Scientific payload SHA-256: `7ecf43b482eecb12234e230a243c73209adfdb80078a068221722a2dd1380e56`
+
+## 39. Analytic proof of the flat-space RT equality
+
+**What Ouroboros established:** An exact boundary identity proves the coefficient equality previously supported numerically: C3^(p)=(7-p)/(9-p)[(C1^(p))^2+(C2^(p))^2], with the mechanism traced to alpha^2+beta^2=7-p.
+
+- Source paper: *Flat Space Entanglement: A Coulomb Branch Perspective*
+- Kernel: `run_sabrina_rt_area_boundary_identity`
+- Public sources: [arXiv:2606.13889](https://arxiv.org/abs/2606.13889)
+- Classification: **analytic proof of source equality**
+- Source-payload status: `complete`
+- Exact checks: 14
+- Scientific payload SHA-256: `ee27f366b07f19111f42a6487e69e75576daa09711cfb41f9012311047bff850`
+
+## 40. Full soft-charge cumulant hierarchy
+
+**What Ouroboros established:** Ward conservation gives an exact subset-sum formula for every connected soft cumulant of order n>=2; deterministic incoming charge drops out, while mixed cumulants are the precise obstruction to a factorized hard-only reduction.
+
+- Source paper: *Memory Correlators and Ward Identities in the 'in-in' Formalism*
+- Kernel: `run_sabrina_soft_charge_cumulant_hierarchy`
+- Public sources: [arXiv:2512.02825](https://arxiv.org/abs/2512.02825)
+- Classification: **all-orders hierarchy and obstruction**
+- Source-payload status: `complete`
+- Exact checks: 13
+- Scientific payload SHA-256: `8ed6c8d8dcc8eabf62402d94d7fdfcc3c000f15edec4ba8c1f437a6040cb2731`
+
+## 41. Soft-charge reduced-state block theorem
+
+**What Ouroboros established:** Fixed total-charge support forces the reduced radiation state to commute with its charge, permits arbitrary degeneracy inside each charge block, and yields the exact entropy decomposition into sector entropy plus within-sector entropy.
+
+- Source paper: *HPS meets AMPS: How Soft Hair Dissolves the Firewall*
+- Kernel: `run_sabrina_soft_charge_reduced_state_theorem`
+- Public sources: [arXiv:2012.03850](https://arxiv.org/abs/2012.03850)
+- Classification: **reduced-state structure theorem**
+- Source-payload status: `complete`
+- Exact checks: 15
+- Scientific payload SHA-256: `1934ba760699c1f3d024f8428611b3b7b3dde43b9a45a54fd868c65b4cc5a8f6`
+
+## 42. Soft-dressing factor-two no-go
+
+**What Ouroboros established:** Under linear mode action and the derivation rule, multiplying every elementary charge commutator by lambda multiplies the whole dressing commutator by lambda; lambda=2 cannot preserve a nonzero target without compensating repair.
+
+- Source paper: *Asymptotic charges as detectors and the memory effect in massive QED and perturbative quantum gravity*
+- Kernel: `run_sabrina_soft_dressing_factor_two_no_go`
+- Public sources: [arXiv:2604.19866](https://arxiv.org/abs/2604.19866)
+- Classification: **no-go theorem and repair boundary**
+- Source-payload status: `complete`
+- Exact checks: 13
+- Scientific payload SHA-256: `694c94424ad44968ecc374bad8ce5fce735e410342d9142b79c566066a0ca029`
+
+## 43. Soft-Mellin factorial correction
+
+**What Ouroboros established:** The unqualified all-n identity requires an n! factor: the Mellin residue is g^(n)(0)/n!, so the source formula is exact at n=0,1 and is restored for all n by multiplying the residue side by n! or dividing u^n by n!.
+
+- Source paper: *Revisiting the Conformally Soft Sector with Celestial Diamonds*
+- Kernel: `run_sabrina_soft_mellin_residue_identity`
+- Public sources: [arXiv:2105.09792](https://arxiv.org/abs/2105.09792)
+- Classification: **source-equation correction**
+- Source-payload status: `physical_n0_n1_exact_unqualified_all_n_extension_requires_factorial`
+- Exact checks: 12
+- Scientific payload SHA-256: `2bac79f473b925a796d826a6c2d4fdd4003b5c269b8843d9f37dd83ed0e4d58f`
+
+## 44. Spin-1 shadow gauge obstruction
+
+**What Ouroboros established:** The formal Delta=1 shadow field strength carries an unavoidable factor d-2 and has an explicit nonzero component for d!=2; only d=2 is self-shadow and pure gauge in the tested sense.
+
+- Source paper: *A Conformal Basis for Flat Space Amplitudes*
+- Kernel: `run_sabrina_spin1_shadow_gauge_obstruction`
+- Public sources: [arXiv:1705.01027](https://arxiv.org/abs/1705.01027)
+- Classification: **dimension-specific obstruction theorem**
+- Source-payload status: `complete`
+- Exact checks: 19
+- Scientific payload SHA-256: `147d7f9336fd649e66d2d1995c6287514571d2ae8c83f798615712be5580eda5`
+
+## 45. Subleading-soft gauge-defect theorem
+
+**What Ouroboros established:** Pure-gauge variation of the subleading soft factor vanishes for every reference pair exactly when the summed angular-momentum defect Delta J is zero; basis polarizations recover every defect component.
+
+- Source paper: *Semiclassical Virasoro Symmetry of the Quantum Gravity S-Matrix*
+- Kernel: `run_sabrina_subleading_soft_gauge_defect_theorem`
+- Public sources: [arXiv:1406.3312](https://arxiv.org/abs/1406.3312)
+- Classification: **if-and-only-if gauge theorem**
+- Source-payload status: `complete`
+- Exact checks: 12
+- Scientific payload SHA-256: `f7f1619f5cf9b96d1c0093c8a1f8c0aff35360814eeaa17ab81bc686a50a3b61`
+
+## 46. Infinite super-BMS commutator syzygy family
+
+**What Ouroboros established:** All routes to a fixed fermionic mode span a rank-one commutator image and obey an exact pairwise syzygy, with a classified exceptional route whenever m=2t/3 is integral.
+
+- Source paper: *Conformally Soft Fermions*
+- Kernel: `run_sabrina_super_bms_commutator_syzygy_family`
+- Public sources: [arXiv:2108.11422](https://arxiv.org/abs/2108.11422)
+- Classification: **infinite algebraic identity family**
+- Source-payload status: `complete`
+- Exact checks: 9
+- Scientific payload SHA-256: `0c0559f924de94f512ba19fd2d867bfef93412978ddcb2cfd055a85cdcf94086`
+
+## 47. Holomorphic superrotation charge cancellation
+
+**What Ouroboros established:** Under the source's explicit holomorphic restriction, the boundary term cancels both shear terms and the antiholomorphic news term, doubles only the holomorphic news term, and reproduces the exact 1/(16 pi G) charge.
+
+- Source paper: *Asymptotic Symmetries and Celestial CFT*
+- Kernel: `run_sabrina_superrotation_charge_cancellation`
+- Public sources: [arXiv:2005.08990](https://arxiv.org/abs/2005.08990)
+- Classification: **exact source reduction**
+- Source-payload status: `source_consistent_holomorphic_superrotation_charge_exactly_reduced`
+- Exact checks: 12
+- Scientific payload SHA-256: `9081bdaa476d9558567b5363b9a85389cdaf84998fd93684f74822acd8c1ad47`
+
+## 48. Two-particle kernel variance theorem
+
+**What Ouroboros established:** The OPE ambiguity depends on the normalized kernel only through M[f]=1/4-integral f(t)(t-1/2)^2dt; positivity gives the sharp interval [0,1/4], while normalization alone admits an explicit unbounded signed family.
+
+- Source paper: *Multiparticle Contributions to the Celestial OPE*
+- Kernel: `run_sabrina_two_particle_kernel_variance`
+- Public sources: [arXiv:2402.18798](https://arxiv.org/abs/2402.18798)
+- Classification: **sharp bound and counterexample family**
+- Source-payload status: `complete`
+- Exact checks: 14
+- Scientific payload SHA-256: `7b1aa48423c6010da14e5d02a47c618b324310dbf80b043db8546fbcc3ee59b6`
+
+## 49. Weyl-double-copy shadow involution
+
+**What Ouroboros established:** Delta maps to 2-Delta as an exact involution exchanging primary and shadow gauge, scalar, and Weyl data while preserving the reduced double-copy quotient and exchanging its Delta=0 and 2 divisors.
+
+- Source paper: *Shifting Spin on the Celestial Sphere*
+- Kernel: `run_sabrina_weyl_double_copy_shadow_involution`
+- Public sources: [arXiv:2012.15694](https://arxiv.org/abs/2012.15694)
+- Classification: **involution and equivariance theorem**
+- Source-payload status: `complete`
+- Exact checks: 17
+- Scientific payload SHA-256: `f6243bc6dfdd05769cab60b02d4e23c53ef9c0119f2ac7a10d54eda023956fee`
diff --git a/VALIDATION.md b/VALIDATION.md
new file mode 100644
index 0000000000000000000000000000000000000000..c5017a68074ff735056aa78bab294fe928e61549
--- /dev/null
+++ b/VALIDATION.md
@@ -0,0 +1,7 @@
+# Pre-release Clean-room Validation
+
+Status: **PASSED** for the replay scope; publication remains **PAUSED / PRIVATE REVIEW**.
+
+The pre-release validation began from a target declared absent by the admitted operation contract, fetched and SHA-verified all 36 public source archives, and ran 51 tests (49 derivation tests plus two boundary tests). It then generated all 49 scientific payloads before reference comparison. Every payload matched, and all source-corruption, result-mutation, and expected-answer-isolation falsifiers passed.
+
+`validation/clean_room_replay_receipt.json` binds these results to the exact replay/test/reference/source-lock file tree in this candidate. The receipt itself is provenance evidence; evaluators should still run the commands in `REPLAY_STANDARD.md` because receipt checking alone is not scientific replay.
diff --git a/data/campaign_metrics.json b/data/campaign_metrics.json
new file mode 100644
index 0000000000000000000000000000000000000000..4d570302cbb7213fe3cf298ac4b97c2f8be62c7e
--- /dev/null
+++ b/data/campaign_metrics.json
@@ -0,0 +1,21 @@
+{
+  "aggregate_gate_issues": 0,
+  "distinct_selected_papers_covered": 34,
+  "first_package_utc": "2026-08-12T04:50:16+00:00",
+  "hydration_start_utc": "2026-08-11T22:48:50+00:00",
+  "hydration_to_pause_seconds": 65491,
+  "ledger_rows": 3077,
+  "package_generation_seconds": 43805,
+  "pause_boundary_utc": "2026-08-12T17:00:21+00:00",
+  "prior_rsi_cycle": {
+    "duration": "approximately 29 hours",
+    "evidence": "private/operator-reported",
+    "model_weights_changed": false
+  },
+  "schema": "ouroboros_paused_campaign_metrics_v1",
+  "selected_papers_remaining": 14,
+  "status": "PAUSED",
+  "token_estimate": "approximately 3-8 million model tokens",
+  "token_estimate_method": "Order-of-magnitude estimate: 49 research packages at roughly 40k-130k model tokens per package, plus corpus hydration, planning, verification, synthesis, and publication-stage overhead. No billing-grade aggregate token counter was recorded.",
+  "verified_package_count": 49
+}
diff --git a/data/predecessors/1dc9e0a600bc5ff235fe3721a8d9e42aa9dc984bb9665b67b26d859bd8d0cd7c.json b/data/predecessors/1dc9e0a600bc5ff235fe3721a8d9e42aa9dc984bb9665b67b26d859bd8d0cd7c.json
new file mode 100644
index 0000000000000000000000000000000000000000..c37c57c586b542382de34cd47c091ce539aec5fa
--- /dev/null
+++ b/data/predecessors/1dc9e0a600bc5ff235fe3721a8d9e42aa9dc984bb9665b67b26d859bd8d0cd7c.json
@@ -0,0 +1,25 @@
+{
+  "artifact_hashes": {
+    "P4_SPHERICAL_ENTANGLEMENT_EXPANSION_PRIVATE_HANDOFF.md": "eaf6c69f3281d20a6c3bd5f71f5f331d7b675abaab959ff77fff54b3b6864706",
+    "p4_spherical_entanglement_expansion_certificate.json": "87ac4b095b832c533efc879170fbc78e163beaef2a87bc06a3df2c73324e0234",
+    "p4_spherical_entanglement_expansion_report.json": "f72845ada12482bea74bce7d3433e7883681a96840d0f46faabac04b9cfb2b6c"
+  },
+  "authority": {
+    "plan_guard_sha256": "1ce7ed24414791a8eb8ddb86423e2252d8db63b488e950cf953732862c2e5602",
+    "plan_receipt_sha256": "d004851bc98c1a7d0743e6243cebd4c31af2b93a7ac5332484a15d5679e81219",
+    "plan_verifier_sha256": "c9382ed1fcb5b832c736db6309462de9a569e7ee3f299cfaa3f7282a2be6e3a8"
+  },
+  "generated_utc": "2026-08-12T09:43:13+00:00",
+  "manifest_version": "sabrina_p4_spherical_entanglement_expansion_manifest_v1",
+  "public_actions_allowed": false,
+  "shadow_only": true,
+  "source_hashes": {
+    "0c66795a0adac63d23dac9ad.gz": "0c66795a0adac63d23dac9ad3207a4bd586f7453365221b95159bca9380edbc3",
+    "area_and_matching": "1a4ecbae9b625bb0cd553031504ffd9c5c9d3da16f973e7e87afd827f92106f1",
+    "main-v2.tex": "3612980847a10a3a07708a1af3dcee65afedc85ffc8106af673e69ae3d42585e",
+    "p4_future_work": "48ef8f3d699b9bc045849a9cfe7ceec0aa4e5c8388d2fc1b0a24579c6d715793",
+    "precedent_expansions": "a56135ef73575f190dd2e05ce7316f75e652a207bdad7a07bd59739e65b811a5",
+    "spherical_eom": "809aea156968448d52e6189e6dcce138f090bcd434ea12da753fb390b14742f4"
+  },
+  "status": "complete"
+}
diff --git a/data/predecessors/2efa95a60d8c51c17d04edca6b52ad9d3de837ac9ec1ac0b767631537f992576.json b/data/predecessors/2efa95a60d8c51c17d04edca6b52ad9d3de837ac9ec1ac0b767631537f992576.json
new file mode 100644
index 0000000000000000000000000000000000000000..9b061e44bafb2e24e068d6f908f90b692cd7c965
--- /dev/null
+++ b/data/predecessors/2efa95a60d8c51c17d04edca6b52ad9d3de837ac9ec1ac0b767631537f992576.json
@@ -0,0 +1,25 @@
+{
+  "artifact_hashes": {
+    "PROJECTIVE_SIMPLEX_RANK_THEOREM_PRIVATE_HANDOFF.md": "a2c43640d685e76f56fe3fad158f5e108643059c7d4ca22b168764d5dc939b06",
+    "projective_simplex_rank_theorem_certificate.json": "092132af9537618a82c6dd21c531299b907300b7621534d6201254494956adcf",
+    "projective_simplex_rank_theorem_report.json": "97bfa15dc03a6226a7dbb9532f6b97df45c875054a20417994bc23719e52084b"
+  },
+  "authority": {
+    "plan_guard_sha256": "1177d505cc6a507e5fa87a9213997f6a2be1254289fa0df9d9fe6cfc4ad44bca",
+    "plan_receipt_sha256": "953b429325c269c1f783eb717c25ad2171a42e397a525c7a7eaa3e9109f6e997",
+    "plan_verifier_sha256": "c1ae6359bd59bd0c0b24e5f0e7c90787723d2f9bbe4daa19c12ae2a9c2955aa5"
+  },
+  "generated_utc": "2026-08-12T08:25:59+00:00",
+  "manifest_version": "sabrina_projective_simplex_rank_theorem_manifest_v1",
+  "public_actions_allowed": false,
+  "shadow_only": true,
+  "source_hashes": {
+    "af2756072965c969be2a74c4.gz": "af2756072965c969be2a74c492fe25a797fe9f85e24d61605cf088e355d06244",
+    "delta_product_rewrite": "8a2029c1a1fe7989bbb77b99449ca37fd43965e0b9169abe60c01d969c5f6f20",
+    "localization_statement": "56cabb68b24099425e4158af718ec6b892423facfa4910a1878990f84cc769e6",
+    "mellinfinal.tex": "88253eb755b1b2418d0ac3480c1d4b67d9bb3985f8f6f6c3b0f79c85784f4bfe",
+    "simplex_result": "24194f455371e8599a13a472c41489b7a6ccdbfa6911705547e0adb3ec882a9e"
+  },
+  "status": "complete",
+  "upstream_manifest_sha256": "b2bc412ca67f7d1e2e2e8908a53f5f8ccf8ceff151fc751a1b08cd66ef1efade"
+}
diff --git a/data/predecessors/764f819b652785e2394101cf78d0463dc893379e30a80732430a2261b20269f7.json b/data/predecessors/764f819b652785e2394101cf78d0463dc893379e30a80732430a2261b20269f7.json
new file mode 100644
index 0000000000000000000000000000000000000000..56abe106ea1eb85662105e5f1ab93893a82ce52b
--- /dev/null
+++ b/data/predecessors/764f819b652785e2394101cf78d0463dc893379e30a80732430a2261b20269f7.json
@@ -0,0 +1,22 @@
+{
+  "artifact_hashes": {
+    "DETECTOR_SUM_IDENTITY_CORRECTION_PRIVATE_HANDOFF.md": "d70d2acbbe22b3918ff172268ef15ff7daa364a97352858b0ebb33c7317f2094",
+    "detector_sum_identity_correction_certificate.json": "c851c1662f075507f7b6bc5ba4e610a5c91766258b79df19b1035cb6b4ecaef0",
+    "detector_sum_identity_correction_report.json": "308e0e958fac34f435db2c95ba23400a0715cf98b50f3990116aaeef4fff0c35"
+  },
+  "authority": {
+    "plan_guard_sha256": "752d2a577470dfa49d3a1c405864790f759f6cd1724af310291b94924182c43c",
+    "plan_receipt_sha256": "b4933c110d9b19129a38bef4c4e1ae7c4865638570b29a8544b964fe998b293a",
+    "plan_verifier_sha256": "12a8cf4c1bc05cf4f5cfddf738da33d340f06edbb474e3929c5efa74a213575b"
+  },
+  "generated_utc": "2026-08-12T07:49:56+00:00",
+  "manifest_version": "sabrina_detector_sum_identity_correction_manifest_v1",
+  "public_actions_allowed": false,
+  "shadow_only": true,
+  "source_hashes": {
+    "98acf1e79b6d6fb929626e11.gz": "98acf1e79b6d6fb929626e11f40fdb0d4a4029f174f6c493f7639e721c7424b0",
+    "equation_equ_sum_ID": "a0d409c1cd66729fd054ce911fd81bd72bf3da9a434964f0f4c9a5d4954f0bd5",
+    "main.tex": "6c5a28fae38e51e317326891ba2758e38766bf8eed98f5cb6941c8a46ade7dd6"
+  },
+  "status": "complete"
+}
diff --git a/data/predecessors/7d5e9dad93e63528aa697e9ec29d0b959f0efdf01b7539aafa7d85d1279a71e2.json b/data/predecessors/7d5e9dad93e63528aa697e9ec29d0b959f0efdf01b7539aafa7d85d1279a71e2.json
new file mode 100644
index 0000000000000000000000000000000000000000..5f0fdfb70bb4812cdd884a27e2aa5cd7264f317d
--- /dev/null
+++ b/data/predecessors/7d5e9dad93e63528aa697e9ec29d0b959f0efdf01b7539aafa7d85d1279a71e2.json
@@ -0,0 +1,23 @@
+{
+  "artifact_hashes": {
+    "LATE_TIME_TWO_CUT_RECONSTRUCTION_PRIVATE_HANDOFF.md": "6e387ff93ebd257e91d45b94722e3f4a397d5f11dafe74e374b9ed2b55ff75ff",
+    "late_time_two_cut_reconstruction_certificate.json": "d49f2f1c0a94e7822d0155e146ede67fb32db365db3dfe2ae99d7978dd38e8f4",
+    "late_time_two_cut_reconstruction_report.json": "7efd09f1b007559f67aa0b635f66fe3e5d3fa61b8b227ebd7478857db2c1f56d"
+  },
+  "authority": {
+    "plan_guard_sha256": "29e350c6b291cb8477b5104f05d724d0601b94742ec465928ac6cdae9d30fb2b",
+    "plan_receipt_sha256": "cdada1e425bcb61d718425d5b18203e2d3d23fd0fcc9bf098be6d7070881f7c1",
+    "plan_verifier_sha256": "88c864a6505d39a782ff007bccc7c4a30c34d107da1eb92e542d664d14931fd7"
+  },
+  "generated_utc": "2026-08-12T08:42:09+00:00",
+  "manifest_version": "sabrina_late_time_two_cut_reconstruction_manifest_v1",
+  "public_actions_allowed": false,
+  "shadow_only": true,
+  "source_hashes": {
+    "ArXivsr.tex": "7f18a6972ebb356c2f7c90ad69823468e11323b04d918ed05cb46aed28edf100",
+    "eq_latetime": "04b21882801dbf4f2f657ec7e880d361534f652f9529bc0c293c67b5a546a073",
+    "f6dbbd7baa6b7eb93cb06b64.gz": "f6dbbd7baa6b7eb93cb06b6460877b26f09ba30bacd6b447641ccf6843828df6",
+    "interpretation_context": "ac3cfdbbe3f446d97cf5ce608da5c078c9d481be3e07a76bc44f67611471adf4"
+  },
+  "status": "complete"
+}
diff --git a/data/predecessors/b2bc412ca67f7d1e2e2e8908a53f5f8ccf8ceff151fc751a1b08cd66ef1efade.json b/data/predecessors/b2bc412ca67f7d1e2e2e8908a53f5f8ccf8ceff151fc751a1b08cd66ef1efade.json
new file mode 100644
index 0000000000000000000000000000000000000000..eeb47c754fded88204aae7b5f4b9a707e283d3af
--- /dev/null
+++ b/data/predecessors/b2bc412ca67f7d1e2e2e8908a53f5f8ccf8ceff151fc751a1b08cd66ef1efade.json
@@ -0,0 +1,26 @@
+{
+  "artifact_hashes": {
+    "PROJECTIVE_MELLIN_SCALE_THEOREM_PRIVATE_HANDOFF.md": "bff0eaf79bcc210405c3efd4a0b1bac6b2735b1621f8f236f845a910d6a1e157",
+    "projective_mellin_scale_theorem_certificate.json": "6e2bb8a2d49cb8aeb530846d1c67b6884b7e689168e2c3b5922a866ca32670c4",
+    "projective_mellin_scale_theorem_report.json": "aece32775621961fc6caebf84cef54d6973bda93b84a95fb92c99db465ebbd73"
+  },
+  "authority": {
+    "plan_guard_sha256": "43e12893f6007198a4e3f158af6827fcccd3e206f56e7491c0f1ebd97a18412c",
+    "plan_receipt_sha256": "86ab6dd8fb408efbd493f38264ae39f5319bbdecd3aae6924740f1802e067921",
+    "plan_verifier_sha256": "ce9bce08fe093f07716382d045f3c733874b8f758c81cd53e7d73ae3304f2696"
+  },
+  "generated_utc": "2026-08-12T08:19:32+00:00",
+  "manifest_version": "sabrina_projective_mellin_scale_theorem_manifest_v1",
+  "public_actions_allowed": false,
+  "shadow_only": true,
+  "source_hashes": {
+    "af2756072965c969be2a74c4.gz": "af2756072965c969be2a74c492fe25a797fe9f85e24d61605cf088e355d06244",
+    "mellin_delta": "053d6a8df0aad576174dca42758bca9a0a38eede5987db0d7b3fa11b9d374f4e",
+    "mellinfinal.tex": "88253eb755b1b2418d0ac3480c1d4b67d9bb3985f8f6f6c3b0f79c85784f4bfe",
+    "simplex_jacobian": "e26ade3af18e50461fef068c453c0895b8a3b1833f6c02b9862e6971447277d4",
+    "simplex_result": "24194f455371e8599a13a472c41489b7a6ccdbfa6911705547e0adb3ec882a9e",
+    "source_scaling": "3e7ca7bf148633f6af58ebd99e65ee9f392365e29cac93b521a91e6dc4a719e8",
+    "stripped_factorization": "66664eaf805d9eeafcf7ac1d981024c7ae07ba958e2054bee8f60a1cb79a75bb"
+  },
+  "status": "complete"
+}
diff --git a/data/registered_artifact_dispositions.json b/data/registered_artifact_dispositions.json
new file mode 100644
index 0000000000000000000000000000000000000000..ca8ab510295bdaeac5edf43c864608de68b66c27
--- /dev/null
+++ b/data/registered_artifact_dispositions.json
@@ -0,0 +1,132 @@
+{
+  "added_primary_replay_count": 1,
+  "all_previously_unselected_registered_runs_dispositioned": true,
+  "default_builder_routing_is_completeness_authority": false,
+  "infrastructure_run_count": 5,
+  "preexisting_primary_replay_count": 48,
+  "previously_unselected_registered_count": 24,
+  "registry_run_count": 77,
+  "rows": [
+    {
+      "disposition": "supporting_chain",
+      "reason": "explicit coordinate-space realization supporting the all-m primary theorem",
+      "registered_run": "all_m_coordinate_kernel_result_v1"
+    },
+    {
+      "disposition": "supporting_chain",
+      "reason": "lower-bound stage subsumed by the later exact saturation theorem",
+      "registered_run": "all_m_depth_lower_bound_result_v1"
+    },
+    {
+      "disposition": "included_via_public_rederivation",
+      "reason": "primary all-m theorem independently recomputed by the added public kernel",
+      "registered_run": "all_m_depth_saturation_theorem_v1"
+    },
+    {
+      "disposition": "supporting_chain",
+      "reason": "Hermitian species-ordering obstruction supporting the theorem boundary",
+      "registered_run": "all_m_hermitian_k2_obstruction_v1"
+    },
+    {
+      "disposition": "supporting_chain",
+      "reason": "all-m local-obstruction result supporting the theorem chain",
+      "registered_run": "all_m_k2_local_obstruction_v1"
+    },
+    {
+      "disposition": "supporting_chain",
+      "reason": "global-translation covariance result supporting the theorem chain",
+      "registered_run": "all_m_translation_covariance_result_v1"
+    },
+    {
+      "disposition": "superseded",
+      "reason": "superseded by the convention reaudit v2 already included in replay",
+      "registered_run": "detector_sum_identity_correction_v1"
+    },
+    {
+      "disposition": "supporting_chain",
+      "reason": "finite local-defect hierarchy supporting the all-m chain",
+      "registered_run": "full_local_f_hierarchy_result_v1"
+    },
+    {
+      "disposition": "bounded_support",
+      "reason": "wedge interpretation retained as support, not promoted beyond its stated boundary",
+      "registered_run": "global_wedge_reconciliation_result_v1"
+    },
+    {
+      "disposition": "supporting_chain",
+      "reason": "leading-defect stage subsumed by the full hierarchy",
+      "registered_run": "leading_local_f_defect_result_v1"
+    },
+    {
+      "disposition": "bounded_support",
+      "reason": "bridge interpretation retained with unresolved independent-coefficient boundary",
+      "registered_run": "low_order_commutator_bridge_result_v1"
+    },
+    {
+      "disposition": "supporting_chain",
+      "reason": "complex-Hermitian base case supporting the all-m theorem",
+      "registered_run": "m3_complex_hermitian_result_v1"
+    },
+    {
+      "disposition": "supporting_chain",
+      "reason": "early nonzero-residual stage superseded by later exact chain closure",
+      "registered_run": "m3_equivalence_result_v1"
+    },
+    {
+      "disposition": "supporting_chain",
+      "reason": "independent m=3 reproduction supporting the base case",
+      "registered_run": "m3_independent_reproduction_v1"
+    },
+    {
+      "disposition": "supporting_chain",
+      "reason": "m=3 local-obstruction stage subsumed by the all-m obstruction",
+      "registered_run": "m3_k2_local_supertranslation_obstruction_v1"
+    },
+    {
+      "disposition": "superseded",
+      "reason": "superseded by v2",
+      "registered_run": "m3_light_scalar_module_exclusion_v1"
+    },
+    {
+      "disposition": "bounded_support",
+      "reason": "source-defined module exclusion retained within its explicit scope",
+      "registered_run": "m3_light_scalar_module_exclusion_v2"
+    },
+    {
+      "disposition": "supporting_chain",
+      "reason": "classified-sector exclusion supporting the missing-module boundary",
+      "registered_run": "m3_local_f_classified_module_exclusion_v1"
+    },
+    {
+      "disposition": "superseded",
+      "reason": "superseded by v2 already included in replay",
+      "registered_run": "m3_unclassified_module_construction_v1"
+    },
+    {
+      "disposition": "supporting_chain",
+      "reason": "wedge projection base-case evidence",
+      "registered_run": "m3_wedge_projection_result_v1"
+    },
+    {
+      "disposition": "supporting_chain",
+      "reason": "m=4 ladder step subsumed by the all-m theorem",
+      "registered_run": "m4_completion_recurrence_result_v1"
+    },
+    {
+      "disposition": "supporting_chain",
+      "reason": "m=5 ladder step subsumed by the all-m theorem",
+      "registered_run": "m5_nonlocal_depth_result_v1"
+    },
+    {
+      "disposition": "bounded_support",
+      "reason": "necessary conditions retained without an operator-existence claim",
+      "registered_run": "missing_module_necessary_conditions_v1"
+    },
+    {
+      "disposition": "supporting_chain",
+      "reason": "global recurrence supporting the all-m derivation",
+      "registered_run": "quadratic_global_recurrence_v1"
+    }
+  ],
+  "schema": "ouroboros_registered_artifact_disposition_audit_v1"
+}
diff --git a/data/result_catalog.json b/data/result_catalog.json
new file mode 100644
index 0000000000000000000000000000000000000000..ff77a2b595032c7619532a8d963a8843eb17c707
--- /dev/null
+++ b/data/result_catalog.json
@@ -0,0 +1,741 @@
+{
+  "count": 49,
+  "results": [
+    {
+      "arxiv_ids": [
+        "2404.02146"
+      ],
+      "claim": "The proposed super-Poynting criterion vanishes exactly when the Cotton-York and stress tensors commute; the commutator norm is a Cotton-eigenvalue-gap-weighted sum of stress-frame misalignments.",
+      "classification": "criterion theorem and spectral identity",
+      "discovery": "Spectral no-radiation criterion",
+      "exact_check_count": 11,
+      "index": 1,
+      "kernel": "run_sabrina_ads_radiation_spectral_commutator",
+      "scientific_payload_sha256": "241d637afce046d817e7a3107063956a87e7581ccc4ccb9230959c16a846ff1d",
+      "source_classification": "complete",
+      "summary": "The proposed super-Poynting criterion vanishes exactly when the Cotton-York and stress tensors commute; the commutator norm is a Cotton-eigenvalue-gap-weighted sum of stress-frame misalignments.",
+      "title": "Radiation in Holography"
+    },
+    {
+      "arxiv_ids": [
+        "2411.10527"
+      ],
+      "claim": "The nonempty scattering region is exactly pi/2 <= mu <= arccos(-1/3) with tau_*(mu) <= tau <= pi-mu, including the collapsed endpoint and linear and quadratic onset laws.",
+      "classification": "exact feasibility-domain theorem",
+      "discovery": "Exact two-interval scattering domain",
+      "exact_check_count": 18,
+      "index": 2,
+      "kernel": "run_sabrina_ads_two_interval_scattering_feasibility",
+      "scientific_payload_sha256": "da08f86ea668e62889d14682aff488ad090f0b3c49d6ffc823e456f799cd580b",
+      "source_classification": "complete",
+      "summary": "The nonempty scattering region is exactly pi/2 <= mu <= arccos(-1/3) with tau_*(mu) <= tau <= pi-mu, including the collapsed endpoint and linear and quadratic onset laws.",
+      "title": "Cryptographic tests of the python's lunch conjecture"
+    },
+    {
+      "arxiv_ids": [
+        "1502.07644"
+      ],
+      "claim": "For every d=2m+2 with integer m>=2, every m-dependent factor cancels between the soft charge, Green function, and hard action, leaving the same normalized Ward identity.",
+      "classification": "all-dimension theorem extension",
+      "discovery": "All-even-dimensional Ward normalization",
+      "exact_check_count": 11,
+      "index": 3,
+      "kernel": "run_sabrina_all_even_d_ward_normalization",
+      "scientific_payload_sha256": "36d368057821e69206d459c5b4f34e81d6d3b1df977de35db7a7bd523f3b529e",
+      "source_classification": "all_even_d_soft_hard_ward_normalization_exact_and_m_independent",
+      "summary": "For every d=2m+2 with integer m>=2, every m-dependent factor cancels between the soft charge, Green function, and hard action, leaving the same normalized Ward identity.",
+      "title": "Higher-Dimensional Supertranslations and Weinberg's Soft Graviton Theorem"
+    },
+    {
+      "arxiv_ids": [
+        "2211.14287",
+        "2307.16801",
+        "2607.28718"
+      ],
+      "claim": "For every integer m>=3, the minimal inverse-total-Z depth is exactly d_min(m)=m-3; distribution order r has exact total-Z multiplicity r+2 through r=m-1, and all orders r>=m vanish.",
+      "classification": "all-m theorem from finite ladder to exact closure",
+      "discovery": "All-m transverse-nonlocality saturation theorem",
+      "exact_check_count": 12,
+      "index": 4,
+      "kernel": "run_sabrina_all_m_transverse_nonlocality_chain",
+      "scientific_payload_sha256": "6600de93b5e0dbb7dc6744cfc31499e4d84760267f62e18bc2a1c9a0e8470db5",
+      "source_classification": "all_m_transverse_nonlocality_depth_saturation_and_distribution_order_multiplicity_exact",
+      "summary": "For every integer m>=3, the minimal inverse-total-Z depth is exactly d_min(m)=m-3; distribution order r has exact total-Z multiplicity r+2 through r=m-1, and all orders r>=m vanish.",
+      "title": "All M Transverse Nonlocality Chain"
+    },
+    {
+      "arxiv_ids": [
+        "2212.00962"
+      ],
+      "claim": "The symmetric and antisymmetric celestial prefactors alternate zeros and finite values at positive integers, while complementary simple poles and zeros occur at nonpositive integers, with exact residues at Delta=0 and 1.",
+      "classification": "analytic zero-and-pole classification",
+      "discovery": "Ambidextrous prefactor singularity lattice",
+      "exact_check_count": 11,
+      "index": 5,
+      "kernel": "run_sabrina_ambidextrous_integer_prefactor_lattice",
+      "scientific_payload_sha256": "77e01bb41ab0dd463176786be21185590dc2a06da27f2585d546e2a379c2ff4f",
+      "source_classification": "complete",
+      "summary": "The symmetric and antisymmetric celestial prefactors alternate zeros and finite values at positive integers, while complementary simple poles and zeros occur at nonpositive integers, with exact residues at Delta=0 and 1.",
+      "title": "Celestial amplitudes in an ambidextrous basis"
+    },
+    {
+      "arxiv_ids": [
+        "2410.20296"
+      ],
+      "claim": "Changing the infrared scale shifts the correlator only by -(log lambda)/(4 pi) times the angular contact delta; separated-point correlators and logarithmic-time derivatives are invariant.",
+      "classification": "exact contact-term theorem",
+      "discovery": "Boundary soft-scale cocycle",
+      "exact_check_count": 12,
+      "index": 6,
+      "kernel": "run_sabrina_boundary_soft_scale_cocycle",
+      "scientific_payload_sha256": "a335d252d7be59f9c40e7abc990331da16b0b54eda70f70d4fa5172d95b2e084",
+      "source_classification": "complete",
+      "summary": "Changing the infrared scale shifts the correlator only by -(log lambda)/(4 pi) times the angular contact delta; separated-point correlators and logarithmic-time derivatives are invariant.",
+      "title": "A Comment on Boundary Correlators: Soft Omissions and the Massless S-Matrix"
+    },
+    {
+      "arxiv_ids": [
+        "2501.00462"
+      ],
+      "claim": "The transform of u^m partial_u^r Phi is fixed at every order by Gamma(nu)/Gamma(nu-m), and the induced raising and lowering operations obey the Weyl relation [D,U]=1.",
+      "classification": "all-orders representation theorem",
+      "discovery": "All-orders Carrollian-Mellin intertwiner",
+      "exact_check_count": 10,
+      "index": 7,
+      "kernel": "run_sabrina_carrollian_celestial_weyl_intertwiner",
+      "scientific_payload_sha256": "d0b52d420b0b0aae1fb470163344d5fb5916c44ba5527310e10482165c6132cd",
+      "source_classification": "complete",
+      "summary": "The transform of u^m partial_u^r Phi is fixed at every order by Gamma(nu)/Gamma(nu-m), and the induced raising and lowering operations obey the Weyl relation [D,U]=1.",
+      "title": "Multiparticle States for the Flat Hologram"
+    },
+    {
+      "arxiv_ids": [
+        "2501.00462"
+      ],
+      "claim": "The published coefficient vector is unique only when both chiral weight pairs are nonzero; the kernel jumps to dimension two or four on the corresponding boundary loci.",
+      "classification": "hypothesis correction and boundary theorem",
+      "discovery": "Conglomerate-kernel rank stratification",
+      "exact_check_count": 12,
+      "index": 8,
+      "kernel": "run_sabrina_carrollian_conglomerate_kernel_stratification",
+      "scientific_payload_sha256": "3bd160a7dfa798b30b4390d34d11f59d48bd1398ec53c50dcc434e3fe64a4737",
+      "source_classification": "complete",
+      "summary": "The published coefficient vector is unique only when both chiral weight pairs are nonzero; the kernel jumps to dimension two or four on the corresponding boundary loci.",
+      "title": "Multiparticle States for the Flat Hologram"
+    },
+    {
+      "arxiv_ids": [
+        "2509.26264"
+      ],
+      "claim": "If A lies in the manifold interior of B, then J+(A) lies in I+(B) and J-(A) lies in I-(B), with the closed-set boundary corollary stated explicitly.",
+      "classification": "exact causal lemma",
+      "discovery": "Causal interior-inclusion lemma",
+      "exact_check_count": 10,
+      "index": 9,
+      "kernel": "run_sabrina_causal_interior_inclusion_lemma",
+      "scientific_payload_sha256": "d99b817c432380bbff4836ba0a169029b609c9519bb2ee813a581878f4ac7531",
+      "source_classification": "complete",
+      "summary": "If A lies in the manifold interior of B, then J+(A) lies in I+(B) and J-(A) lies in I-(B), with the closed-set boundary corollary stated explicitly.",
+      "title": "On sufficient conditions for holographic scattering"
+    },
+    {
+      "arxiv_ids": [
+        "2404.14491"
+      ],
+      "claim": "The cited alpha=0.495 code cannot correct arbitrary t-qubit errors, and after enforcing alpha<=1/4 the stated i.i.d. exponent is positive at base error 0.09; the package isolates repair classes without claiming the amplification theorem false.",
+      "classification": "proof-parameter obstruction",
+      "discovery": "CDQS amplification parameter obstruction",
+      "exact_check_count": 15,
+      "index": 10,
+      "kernel": "run_sabrina_cdqs_amplification_singleton_obstruction",
+      "scientific_payload_sha256": "030824c1879fcf5639d3fb849067dcd70eb43ab728bad7d3961c5fe44ac5f1b5",
+      "source_classification": "complete",
+      "summary": "The cited alpha=0.495 code cannot correct arbitrary t-qubit errors, and after enforcing alpha<=1/4 the stated i.i.d. exponent is positive at base error 0.09; the package isolates repair classes without claiming the amplification theorem false.",
+      "title": "Conditional disclosure of secrets with quantum resources"
+    },
+    {
+      "arxiv_ids": [
+        "2411.10527"
+      ],
+      "claim": "Combining F<=min(1,2a) with I>=-2 log F yields I>=max(0,-2 log(2a)), strictly strengthening the displayed -log(a)-1 bound for every a>0.",
+      "classification": "strict bound strengthening",
+      "discovery": "Strengthened CDQS fidelity envelope",
+      "exact_check_count": 11,
+      "index": 11,
+      "kernel": "run_sabrina_cdqs_fidelity_envelope_strengthening",
+      "scientific_payload_sha256": "a74b4d88eeb5eac12a40fce9ce013f2e18f9e4a748ea1a973380efcbeadd519b",
+      "source_classification": "complete",
+      "summary": "Combining F<=min(1,2a) with I>=-2 log F yields I>=max(0,-2 log(2a)), strictly strengthening the displayed -log(a)-1 bound for every a>0.",
+      "title": "Cryptographic tests of the python's lunch conjecture"
+    },
+    {
+      "arxiv_ids": [
+        "2204.02505"
+      ],
+      "claim": "A strict celestial circle separates finite incoming and outgoing point sets exactly when their embedded convex hulls are disjoint; either a separating plane or a finite Caratheodory obstruction certifies the answer.",
+      "classification": "geometric equivalence and certificates",
+      "discovery": "Celestial-circle convex-hull certificate",
+      "exact_check_count": 11,
+      "index": 12,
+      "kernel": "run_sabrina_celestial_circle_convex_hull_certificate",
+      "scientific_payload_sha256": "e838335f66a4c68f81f7e6f5678fe10cea02f297400cd6d76dda8ab4d73e73eb",
+      "source_classification": "complete",
+      "summary": "A strict celestial circle separates finite incoming and outgoing point sets exactly when their embedded convex hulls are disjoint; either a separating plane or a finite Caratheodory obstruction certifies the answer.",
+      "title": "Celestial Geometry"
+    },
+    {
+      "arxiv_ids": [
+        "2205.10901"
+      ],
+      "claim": "Signed momentum conservation removes every leg-separable logarithm shift, and under the spanning hypothesis cancellation for all independent shifts conversely forces each participating p_i dot P to vanish.",
+      "classification": "exact invariance criterion and converse",
+      "discovery": "Eikonal logarithm gauge criterion",
+      "exact_check_count": 11,
+      "index": 13,
+      "kernel": "run_sabrina_celestial_eikonal_logarithm_gauge",
+      "scientific_payload_sha256": "496aa27aa4e52fa3a6f9da412561aaa652cf21690744c98593d94d0ffbe1e6f8",
+      "source_classification": "complete",
+      "summary": "Signed momentum conservation removes every leg-separable logarithm shift, and under the spanning hypothesis cancellation for all independent shifts conversely forces each participating p_i dot P to vanish.",
+      "title": "A Comment on Loop Corrections to the Celestial Stress Tensor"
+    },
+    {
+      "arxiv_ids": [
+        "2309.16602"
+      ],
+      "claim": "Opposite Euclidean winding gives monodromy exp(2 pi i(alpha-beta)); paired factors are single-valued exactly for integer alpha-beta, while a one-variable complexified continuation remains obstructed generically.",
+      "classification": "monodromy theorem and boundary",
+      "discovery": "Euclidean monodromy cancellation",
+      "exact_check_count": 11,
+      "index": 14,
+      "kernel": "run_sabrina_celestial_euclidean_monodromy_cancellation",
+      "scientific_payload_sha256": "a1a2263b72c97030c657dcafd5ebb59be09b6c15290e6578fd342c0c83eba049",
+      "source_classification": "complete",
+      "summary": "Opposite Euclidean winding gives monodromy exp(2 pi i(alpha-beta)); paired factors are single-valued exactly for integer alpha-beta, while a one-variable complexified continuation remains obstructed generically.",
+      "title": "Multicollinear Singularities in Celestial CFT"
+    },
+    {
+      "arxiv_ids": [
+        "2012.15694"
+      ],
+      "claim": "Repeated momentum insertions generate the exact rising-factorial ratio (Delta)_r/Delta^r, including its recurrence, zeros at negative integers, and pole of order r-1 at Delta=0.",
+      "classification": "all-orders operator identity",
+      "discovery": "All-order celestial momentum prefactor",
+      "exact_check_count": 11,
+      "index": 15,
+      "kernel": "run_sabrina_celestial_momentum_rising_factorial",
+      "scientific_payload_sha256": "643a45bec4e1890d5a2fb13854b61ccd5e0eccb5cce7a7a293ce045edef79e9c",
+      "source_classification": "complete",
+      "summary": "Repeated momentum insertions generate the exact rising-factorial ratio (Delta)_r/Delta^r, including its recurrence, zeros at negative integers, and pole of order r-1 at Delta=0.",
+      "title": "Shifting Spin on the Celestial Sphere"
+    },
+    {
+      "arxiv_ids": [
+        "2208.11635"
+      ],
+      "claim": "The complete symmetric polynomial recursion resums to 1/((1-ax)(1-bx)) and exponentiates the amplitude PDE into an exact two-factor rational translation law.",
+      "classification": "generating-function resummation",
+      "discovery": "Closed celestial-recursion generating function",
+      "exact_check_count": 12,
+      "index": 16,
+      "kernel": "run_sabrina_celestial_recursion_pde_generating_function",
+      "scientific_payload_sha256": "94cf744ae42b66c5db61c4d853a7867562d928a7eb80e7cc3297657eb8fcf1cd",
+      "source_classification": "complete",
+      "summary": "The complete symmetric polynomial recursion resums to 1/((1-ax)(1-bx)) and exponentiates the amplitude PDE into an exact two-factor rational translation law.",
+      "title": "Celestial Recursion"
+    },
+    {
+      "arxiv_ids": [
+        "2606.13889"
+      ],
+      "claim": "All geometric and gravitational scales cancel from C_flat/C_throat=[32+(7-p)^2]/[16(9-p)]; p=3 uniquely gives the maximal one-half reduction.",
+      "classification": "exact universal ratio",
+      "discovery": "Universal Coulomb-branch complexity ratio",
+      "exact_check_count": 15,
+      "index": 17,
+      "kernel": "run_sabrina_coulomb_branch_complexity_ratio",
+      "scientific_payload_sha256": "0a48392a955f724766d46453ed8d209ae2f1cfca84d21c71d0807b479504eb06",
+      "source_classification": "complete",
+      "summary": "All geometric and gravitational scales cancel from C_flat/C_throat=[32+(7-p)^2]/[16(9-p)]; p=3 uniquely gives the maximal one-half reduction.",
+      "title": "Flat Space Entanglement: A Coulomb Branch Perspective"
+    },
+    {
+      "arxiv_ids": [
+        "2307.16801"
+      ],
+      "claim": "A prior Ouroboros correction was a false positive caused by reading source-local falling-factorial notation as a rising Pochhammer symbol; the source identity is exact under its stated convention, and the earlier claim is superseded.",
+      "classification": "self-correction and source confirmation",
+      "discovery": "Self-corrected detector sum identity",
+      "exact_check_count": 15,
+      "index": 18,
+      "kernel": "run_sabrina_detector_sum_identity_correction",
+      "scientific_payload_sha256": "a1b7a157ca0f6b33a4e558a471219f1c3b5c077bbca275918db542a467ec6aad",
+      "source_classification": "v1_false_positive_superseded_source_local_falling_factorial_identity_exact",
+      "summary": "A prior Ouroboros correction was a false positive caused by reading source-local falling-factorial notation as a rising Pochhammer symbol; the source identity is exact under its stated convention, and the earlier claim is superseded.",
+      "title": "Detector Operators for Celestial Symmetries"
+    },
+    {
+      "arxiv_ids": [
+        "1505.00716"
+      ],
+      "claim": "For a fixed memory impulse M delivered over duration T, the driving fluence obeys Phi>=M^2/T, with equality for a constant ramp and an exact signal-to-noise relation for the detector.",
+      "classification": "sharp tradeoff bound",
+      "discovery": "Memory-detector fluence tradeoff",
+      "exact_check_count": 21,
+      "index": 19,
+      "kernel": "run_sabrina_electromagnetic_memory_detector_tradeoff",
+      "scientific_payload_sha256": "015631d9110b4b95c4a08337ca93d0143257d133d51159fe68736db9947d926e",
+      "source_classification": "complete",
+      "summary": "For a fixed memory impulse M delivered over duration T, the driving fluence obeys Phi>=M^2/T, with equality for a constant ramp and an exact signal-to-noise relation for the detector.",
+      "title": "Asymptotic Symmetries and Electromagnetic Memory"
+    },
+    {
+      "arxiv_ids": [
+        "2604.22612"
+      ],
+      "claim": "The gap S_gen(s_ent)-I(V1;V2) is exactly the sum of four nonnegative geometric slacks divided by 4G_N, so saturation occurs if and only if all four source inequalities saturate.",
+      "classification": "exact slack decomposition",
+      "discovery": "Entanglement-scattering upper slack identity",
+      "exact_check_count": 11,
+      "index": 20,
+      "kernel": "run_sabrina_entanglement_scattering_slack_identity",
+      "scientific_payload_sha256": "65ed4ac892b7bc06c0e00a75b8253eceebe84a4342dbbdfc165c226b7a62fdf3",
+      "source_classification": "complete",
+      "summary": "The gap S_gen(s_ent)-I(V1;V2) is exactly the sum of four nonnegative geometric slacks divided by 4G_N, so saturation occurs if and only if all four source inequalities saturate.",
+      "title": "Generalized Entanglement Wedges and the Connected Wedge Theorem"
+    },
+    {
+      "arxiv_ids": [
+        "2604.22612"
+      ],
+      "claim": "The finite-scale endpoint map is an eight-dimensional bijection with determinant -ell^-4, but its strict flat limit has rank four and loses exactly the four endpoint-time directions.",
+      "classification": "rank-drop theorem with exact kernel",
+      "discovery": "Flat boundary-corner rank drop",
+      "exact_check_count": 13,
+      "index": 21,
+      "kernel": "run_sabrina_flat_boundary_corner_rank_drop",
+      "scientific_payload_sha256": "0853ed3bb32e027bf8d6f6b380fcb29ace7776981e3c033036dac278b99443a6",
+      "source_classification": "complete",
+      "summary": "The finite-scale endpoint map is an eight-dimensional bijection with determinant -ell^-4, but its strict flat limit has rank four and loses exactly the four endpoint-time directions.",
+      "title": "Generalized Entanglement Wedges and the Connected Wedge Theorem"
+    },
+    {
+      "arxiv_ids": [
+        "2310.02186"
+      ],
+      "claim": "The displayed extrapolate-dictionary equivalence is exact: the apparently missing factor is supplied by the positive rescaling t=(2u)^-1 together with the regulator rename, with no branch or normalization error.",
+      "classification": "source-equivalence proof",
+      "discovery": "Inverted Mellin normalization equivalence",
+      "exact_check_count": 14,
+      "index": 22,
+      "kernel": "run_sabrina_inverted_mellin_equivalence",
+      "scientific_payload_sha256": "8238ba9f3410ddad34f4ba9d8b58fed3f8b73f2da4ac14bd651fe311098aed7e",
+      "source_classification": "source_equation_consistent_normalization_rescaling_made_explicit",
+      "summary": "The displayed extrapolate-dictionary equivalence is exact: the apparently missing factor is supplied by the positive rescaling t=(2u)^-1 together with the regulator rename, with no branch or normalization error.",
+      "title": "Equating Extrapolate Dictionaries for Massless Scattering"
+    },
+    {
+      "arxiv_ids": [
+        "1905.10052"
+      ],
+      "claim": "A permutation-invariant three-cut residual vanishes for every affine late-time signal and factorizes into a Vandermonde product times the quadratic curvature coefficient for the first nonlinear correction.",
+      "classification": "exact null test and curvature extractor",
+      "discovery": "Three-cut late-time null test",
+      "exact_check_count": 12,
+      "index": 23,
+      "kernel": "run_sabrina_late_time_three_cut_null_test",
+      "scientific_payload_sha256": "fc350a6e78c22144f885c36d6387db83ad9717444e32af7a851e5a32136bcbe8",
+      "source_classification": "late_time_three_cut_affine_null_test_and_quadratic_curvature_extraction_exact",
+      "summary": "A permutation-invariant three-cut residual vanishes for every affine late-time signal and factorizes into a Vandermonde product times the quadratic curvature coefficient for the first nonlinear correction.",
+      "title": "Implications of Superrotations"
+    },
+    {
+      "arxiv_ids": [
+        "1905.10052"
+      ],
+      "claim": "Two cuts reconstruct the four late-time image components exactly, with an explicit origin-shift law and the additional condition required for origin-independent cross-order matching.",
+      "classification": "exact reconstruction theorem",
+      "discovery": "Two-cut late-time image reconstruction",
+      "exact_check_count": 16,
+      "index": 24,
+      "kernel": "run_sabrina_late_time_two_cut_reconstruction",
+      "scientific_payload_sha256": "db1fd19b1f87b4ae81f8df3e51fb7af41553eddcc0138d1b499afb0ace0a7614",
+      "source_classification": "late_time_two_cut_image_reconstruction_exact_with_origin_covariance",
+      "summary": "Two cuts reconstruct the four late-time image components exactly, with an explicit origin-shift law and the additional condition required for origin-independent cross-order matching.",
+      "title": "Implications of Superrotations"
+    },
+    {
+      "arxiv_ids": [
+        "2202.11127"
+      ],
+      "claim": "A nonzero omega^m log^r(omega/mu) term produces a pole of exact order r+1 at Delta=-m with leading coefficient (-1)^r r!; changing scale mixes only lower poles.",
+      "classification": "pole-order theorem and correction",
+      "discovery": "Goldilocks logarithmic pole-order correction",
+      "exact_check_count": 11,
+      "index": 25,
+      "kernel": "run_sabrina_logarithmic_mellin_pole_order_correction",
+      "scientific_payload_sha256": "7e71ad1c811616ad2bae1d0eff9e16fe5a8aca3e975f7016352c215d2a8062a2",
+      "source_classification": "complete",
+      "summary": "A nonzero omega^m log^r(omega/mu) term produces a pole of exact order r+1 at Delta=-m with leading coefficient (-1)^r r!; changing scale mixes only lower poles.",
+      "title": "Goldilocks Modes and the Three Scattering Bases"
+    },
+    {
+      "arxiv_ids": [
+        "1407.3814"
+      ],
+      "claim": "The commutator of two Low hard generators has no angular component and closes in the original family only when a specific covariant derivative vanishes; generic monomial modes provide explicit obstructions.",
+      "classification": "nonclosure theorem",
+      "discovery": "Low hard-generator nonclosure",
+      "exact_check_count": 18,
+      "index": 26,
+      "kernel": "run_sabrina_low_hard_generator_nonclosure",
+      "scientific_payload_sha256": "923662d26ef1703e8e9b20da3584065e853328708a7abc6c4e522e16abb2d9b5",
+      "source_classification": "complete",
+      "summary": "The commutator of two Low hard generators has no angular component and closes in the original family only when a specific covariant derivative vanishes; generic monomial modes provide explicit obstructions.",
+      "title": "Low's Subleading Soft Theorem as a Symmetry of QED"
+    },
+    {
+      "arxiv_ids": [],
+      "claim": "For the ordered complex conformal-scalar witness, the complete finite weight-(2,0) stress-tensor light-ray basis has rank three while the augmented system has rank four; an explicit left-null witness evaluates to 105/16.",
+      "classification": "basis-exclusion theorem",
+      "discovery": "Exact finite stress-basis exclusion at m=3",
+      "exact_check_count": 11,
+      "index": 27,
+      "kernel": "run_sabrina_m3_unclassified_module_construction",
+      "scientific_payload_sha256": "87a52883c1ab297c98ffbc371b709b01fb9e2a6054647a4be0487d54f0768bc7",
+      "source_classification": "exact_full_stress_basis_exclusion",
+      "summary": "For the ordered complex conformal-scalar witness, the complete finite weight-(2,0) stress-tensor light-ray basis has rank three while the augmented system has rank four; an explicit left-null witness evaluates to 105/16.",
+      "title": "M3 Unclassified Module Construction"
+    },
+    {
+      "arxiv_ids": [
+        "2501.00462"
+      ],
+      "claim": "Each displayed beta-function pole has twice the printed residue because its pole-bearing Gamma argument has slope -1/2 in Delta; when branches collide, the corrected residues sum exactly to the coalesced tower.",
+      "classification": "source-equation correction",
+      "discovery": "Multiparticle beta-residue factor-two correction",
+      "exact_check_count": 11,
+      "index": 28,
+      "kernel": "run_sabrina_multiparticle_beta_residue_factor_two",
+      "scientific_payload_sha256": "6485daa678a208dfd8860503be6c60a553e2d767188c34ec80b762520c23e455",
+      "source_classification": "complete",
+      "summary": "Each displayed beta-function pole has twice the printed residue because its pole-bearing Gamma argument has slope -1/2 in Delta; when branches collide, the corrected residues sum exactly to the coalesced tower.",
+      "title": "Multiparticle States for the Flat Hologram"
+    },
+    {
+      "arxiv_ids": [
+        "1701.00049"
+      ],
+      "claim": "The angular variable pushes forward exactly to a bounded radial interval with dc=(rho^2+2 epsilon)/(2 epsilon rho^2)drho, width and endpoint product 2 epsilon, and median sqrt(2 epsilon).",
+      "classification": "exact change-of-variables theorem",
+      "discovery": "Near-extremal radial pushforward",
+      "exact_check_count": 20,
+      "index": 29,
+      "kernel": "run_sabrina_near_extremal_radial_pushforward",
+      "scientific_payload_sha256": "2e51bc35b918b5683ba9f4c83c8ff6e0488713eb143c0d120e66640262410e4e",
+      "source_classification": "complete",
+      "summary": "The angular variable pushes forward exactly to a bounded radial interval with dc=(rho^2+2 epsilon)/(2 epsilon rho^2)drho, width and endpoint product 2 epsilon, and median sqrt(2 epsilon).",
+      "title": "Flat Space Amplitudes and Conformal Symmetry of the Celestial Sphere"
+    },
+    {
+      "arxiv_ids": [
+        "2606.13889"
+      ],
+      "claim": "The p=4 spherical extremal surface admits an explicit matched large-P expansion through the first two nontrivial orders, including the renormalized area -3gR^2P^3/10+81g^2RP/35+O(P^-1).",
+      "classification": "theorem extension",
+      "discovery": "Omitted p=4 spherical entanglement extension",
+      "exact_check_count": 11,
+      "index": 30,
+      "kernel": "run_sabrina_p4_spherical_entanglement_expansion",
+      "scientific_payload_sha256": "15b684b9177c314bc5aeca308c80eae5ad95abfcd73c261eb7e7e51848f6b300",
+      "source_classification": "complete",
+      "summary": "The p=4 spherical extremal surface admits an explicit matched large-P expansion through the first two nontrivial orders, including the renormalized area -3gR^2P^3/10+81g^2RP/35+O(P^-1).",
+      "title": "Flat Space Entanglement: A Coulomb Branch Perspective"
+    },
+    {
+      "arxiv_ids": [
+        "2606.13889"
+      ],
+      "claim": "Applying the refined-entropy operator to the p=4 spherical expansion gives g^3/P[45 log(P/R)/16+82933/560000]+O(P^-3), positive in the stated infrared regime and decaying to zero.",
+      "classification": "theorem extension and asymptotic result",
+      "discovery": "First nonzero p=4 refined-entropy term",
+      "exact_check_count": 11,
+      "index": 31,
+      "kernel": "run_sabrina_p4_spherical_refined_entropy",
+      "scientific_payload_sha256": "391c082d381a39de409e09c5d5d1798607ab16101326c4103bafbd5f220a2345",
+      "source_classification": "complete",
+      "summary": "Applying the refined-entropy operator to the p=4 spherical expansion gives g^3/P[45 log(P/R)/16+82933/560000]+O(P^-3), positive in the stated infrared regime and decaying to zero.",
+      "title": "Flat Space Entanglement: A Coulomb Branch Perspective"
+    },
+    {
+      "arxiv_ids": [
+        "2604.22612"
+      ],
+      "claim": "The lower gap I(V1;V2)-S_gen(e_max(s_pts'')) is exactly the sum of four nonnegative CWT, ridge, focusing, and maximization slacks, with an if-and-only-if saturation criterion.",
+      "classification": "exact slack decomposition",
+      "discovery": "Point-scattering lower slack identity",
+      "exact_check_count": 14,
+      "index": 32,
+      "kernel": "run_sabrina_points_scattering_lower_slack_identity",
+      "scientific_payload_sha256": "7f9b013510e795182939e14d751abafa52301bf7e7cd140ff4fa5a32a2b8db69",
+      "source_classification": "complete",
+      "summary": "The lower gap I(V1;V2)-S_gen(e_max(s_pts'')) is exactly the sum of four nonnegative CWT, ridge, focusing, and maximization slacks, with an if-and-only-if saturation criterion.",
+      "title": "Generalized Entanglement Wedges and the Connected Wedge Theorem"
+    },
+    {
+      "arxiv_ids": [
+        "1905.10052"
+      ],
+      "claim": "The principal-series measure factorizes into explicit positive polynomials for every even and odd integer dimension, obeys a two-dimension recurrence, and has the correct quadratic zero at the origin.",
+      "classification": "all-dimension factorization theorem",
+      "discovery": "All-integer-d Plancherel factorization",
+      "exact_check_count": 14,
+      "index": 33,
+      "kernel": "run_sabrina_principal_series_plancherel_factorization",
+      "scientific_payload_sha256": "4047efe441ad0800b95a0d64b4354de371b4f6fdf6be4f1cbe59763680be8178",
+      "source_classification": "principal_series_plancherel_measure_all_integer_d_factorization_exact",
+      "summary": "The principal-series measure factorizes into explicit positive polynomials for every even and odd integer dimension, obeys a two-dimension recurrence, and has the correct quadratic zero at the origin.",
+      "title": "Implications of Superrotations"
+    },
+    {
+      "arxiv_ids": [
+        "1706.03917"
+      ],
+      "claim": "Under canonical massless scaling, stripped-amplitude, Mellin-weight, momentum-delta, and projective-Jacobian degrees cancel exactly for arbitrary spacetime dimension D and particle count n.",
+      "classification": "all-D, all-n theorem",
+      "discovery": "All-D, all-n projective Mellin scale cancellation",
+      "exact_check_count": 12,
+      "index": 34,
+      "kernel": "run_sabrina_projective_mellin_scale_theorem",
+      "scientific_payload_sha256": "bb866693a5cac8a1a30c7d4d3dec8feea3e6911173eca33cae0c27c503449354",
+      "source_classification": "all_D_all_n_projective_mellin_radial_scale_cancellation_exact_under_canonical_scaling",
+      "summary": "Under canonical massless scaling, stripped-amplitude, Mellin-weight, momentum-delta, and projective-Jacobian degrees cancel exactly for arbitrary spacetime dimension D and particle count n.",
+      "title": "Gluon Amplitudes as 2d Conformal Correlators"
+    },
+    {
+      "arxiv_ids": [
+        "1706.03917"
+      ],
+      "claim": "For a square localization system, Cramer signed-minor ratios give the unique simplex coordinates; strict positivity characterizes interior support, nonnegativity with a zero characterizes the boundary, and the Jacobian is 1/abs(det M).",
+      "classification": "support, positivity, and Jacobian theorem",
+      "discovery": "Projective-simplex signed-minor theorem",
+      "exact_check_count": 13,
+      "index": 35,
+      "kernel": "run_sabrina_projective_simplex_positivity_theorem",
+      "scientific_payload_sha256": "04b196f77ef38f277dfbb7ebeccf2b1964f90157335f9a1dc268c6654d548af4",
+      "source_classification": "square_projective_simplex_signed_minor_support_and_jacobian_theorem_exact",
+      "summary": "For a square localization system, Cramer signed-minor ratios give the unique simplex coordinates; strict positivity characterizes interior support, nonnegativity with a zero characterizes the boundary, and the Jacobian is 1/abs(det M).",
+      "title": "Gluon Amplitudes as 2d Conformal Correlators"
+    },
+    {
+      "arxiv_ids": [
+        "1706.03917"
+      ],
+      "claim": "For a (D+1)-by-n constraint matrix of generic rank min(D+1,n), the theorem gives the exact number of residual external constraints or unfixed simplex moduli and separates unique, boundary, incompatible, and continuous-support regimes.",
+      "classification": "all-D rank and support theorem",
+      "discovery": "All-D projective-simplex rank theorem",
+      "exact_check_count": 18,
+      "index": 36,
+      "kernel": "run_sabrina_projective_simplex_rank_theorem",
+      "scientific_payload_sha256": "a4be65bfe6724693b679405e1985b33302d94ec8113edf75512620fcc58045f7",
+      "source_classification": "all_D_projective_simplex_localization_rank_theorem_exact_with_support_and_positivity_boundaries",
+      "summary": "For a (D+1)-by-n constraint matrix of generic rank min(D+1,n), the theorem gives the exact number of residual external constraints or unfixed simplex moduli and separates unique, boundary, incompatible, and continuous-support regimes.",
+      "title": "Gluon Amplitudes as 2d Conformal Correlators"
+    },
+    {
+      "arxiv_ids": [
+        "1502.06120"
+      ],
+      "claim": "The cap response is an explicit quintic with antipodal-complement antisymmetry F(1-x)=-F(x), complete physical zero set {0,1/2,1}, and an exact factorization exposing every sign change.",
+      "classification": "duality and factorization theorem",
+      "discovery": "Quadrupole spin-memory cap duality",
+      "exact_check_count": 16,
+      "index": 37,
+      "kernel": "run_sabrina_quadrupole_spin_memory_cap_duality",
+      "scientific_payload_sha256": "ec237ce1930d800c155dbce44a6eb3a8c2c5c9d65bcf638d05a6583ce813ba9a",
+      "source_classification": "complete",
+      "summary": "The cap response is an explicit quintic with antipodal-complement antisymmetry F(1-x)=-F(x), complete physical zero set {0,1/2,1}, and an exact factorization exposing every sign change.",
+      "title": "New Gravitational Memories"
+    },
+    {
+      "arxiv_ids": [
+        "1905.09809"
+      ],
+      "claim": "The published fourth-order radial equation factorizes exactly as [rho^2(D^2-4)+4L]^2, revealing generalized-kernel modes killed by the square but not by the second-order factor.",
+      "classification": "operator factorization theorem",
+      "discovery": "Radial Einstein operator is an exact square",
+      "exact_check_count": 10,
+      "index": 38,
+      "kernel": "run_sabrina_radial_einstein_square_factorization",
+      "scientific_payload_sha256": "7ecf43b482eecb12234e230a243c73209adfdb80078a068221722a2dd1380e56",
+      "source_classification": "complete",
+      "summary": "The published fourth-order radial equation factorizes exactly as [rho^2(D^2-4)+4L]^2, revealing generalized-kernel modes killed by the square but not by the second-order factor.",
+      "title": "Uplifting AdS3/CFT2 to Flat Space Holography"
+    },
+    {
+      "arxiv_ids": [
+        "2606.13889"
+      ],
+      "claim": "An exact boundary identity proves the coefficient equality previously supported numerically: C3^(p)=(7-p)/(9-p)[(C1^(p))^2+(C2^(p))^2], with the mechanism traced to alpha^2+beta^2=7-p.",
+      "classification": "analytic proof of source equality",
+      "discovery": "Analytic proof of the flat-space RT equality",
+      "exact_check_count": 14,
+      "index": 39,
+      "kernel": "run_sabrina_rt_area_boundary_identity",
+      "scientific_payload_sha256": "ee27f366b07f19111f42a6487e69e75576daa09711cfb41f9012311047bff850",
+      "source_classification": "complete",
+      "summary": "An exact boundary identity proves the coefficient equality previously supported numerically: C3^(p)=(7-p)/(9-p)[(C1^(p))^2+(C2^(p))^2], with the mechanism traced to alpha^2+beta^2=7-p.",
+      "title": "Flat Space Entanglement: A Coulomb Branch Perspective"
+    },
+    {
+      "arxiv_ids": [
+        "2512.02825"
+      ],
+      "claim": "Ward conservation gives an exact subset-sum formula for every connected soft cumulant of order n>=2; deterministic incoming charge drops out, while mixed cumulants are the precise obstruction to a factorized hard-only reduction.",
+      "classification": "all-orders hierarchy and obstruction",
+      "discovery": "Full soft-charge cumulant hierarchy",
+      "exact_check_count": 13,
+      "index": 40,
+      "kernel": "run_sabrina_soft_charge_cumulant_hierarchy",
+      "scientific_payload_sha256": "8ed6c8d8dcc8eabf62402d94d7fdfcc3c000f15edec4ba8c1f437a6040cb2731",
+      "source_classification": "complete",
+      "summary": "Ward conservation gives an exact subset-sum formula for every connected soft cumulant of order n>=2; deterministic incoming charge drops out, while mixed cumulants are the precise obstruction to a factorized hard-only reduction.",
+      "title": "Memory Correlators and Ward Identities in the 'in-in' Formalism"
+    },
+    {
+      "arxiv_ids": [
+        "2012.03850"
+      ],
+      "claim": "Fixed total-charge support forces the reduced radiation state to commute with its charge, permits arbitrary degeneracy inside each charge block, and yields the exact entropy decomposition into sector entropy plus within-sector entropy.",
+      "classification": "reduced-state structure theorem",
+      "discovery": "Soft-charge reduced-state block theorem",
+      "exact_check_count": 15,
+      "index": 41,
+      "kernel": "run_sabrina_soft_charge_reduced_state_theorem",
+      "scientific_payload_sha256": "1934ba760699c1f3d024f8428611b3b7b3dde43b9a45a54fd868c65b4cc5a8f6",
+      "source_classification": "complete",
+      "summary": "Fixed total-charge support forces the reduced radiation state to commute with its charge, permits arbitrary degeneracy inside each charge block, and yields the exact entropy decomposition into sector entropy plus within-sector entropy.",
+      "title": "HPS meets AMPS: How Soft Hair Dissolves the Firewall"
+    },
+    {
+      "arxiv_ids": [
+        "2604.19866"
+      ],
+      "claim": "Under linear mode action and the derivation rule, multiplying every elementary charge commutator by lambda multiplies the whole dressing commutator by lambda; lambda=2 cannot preserve a nonzero target without compensating repair.",
+      "classification": "no-go theorem and repair boundary",
+      "discovery": "Soft-dressing factor-two no-go",
+      "exact_check_count": 13,
+      "index": 42,
+      "kernel": "run_sabrina_soft_dressing_factor_two_no_go",
+      "scientific_payload_sha256": "694c94424ad44968ecc374bad8ce5fce735e410342d9142b79c566066a0ca029",
+      "source_classification": "complete",
+      "summary": "Under linear mode action and the derivation rule, multiplying every elementary charge commutator by lambda multiplies the whole dressing commutator by lambda; lambda=2 cannot preserve a nonzero target without compensating repair.",
+      "title": "Asymptotic charges as detectors and the memory effect in massive QED and perturbative quantum gravity"
+    },
+    {
+      "arxiv_ids": [
+        "2105.09792"
+      ],
+      "claim": "The unqualified all-n identity requires an n! factor: the Mellin residue is g^(n)(0)/n!, so the source formula is exact at n=0,1 and is restored for all n by multiplying the residue side by n! or dividing u^n by n!.",
+      "classification": "source-equation correction",
+      "discovery": "Soft-Mellin factorial correction",
+      "exact_check_count": 12,
+      "index": 43,
+      "kernel": "run_sabrina_soft_mellin_residue_identity",
+      "scientific_payload_sha256": "2bac79f473b925a796d826a6c2d4fdd4003b5c269b8843d9f37dd83ed0e4d58f",
+      "source_classification": "physical_n0_n1_exact_unqualified_all_n_extension_requires_factorial",
+      "summary": "The unqualified all-n identity requires an n! factor: the Mellin residue is g^(n)(0)/n!, so the source formula is exact at n=0,1 and is restored for all n by multiplying the residue side by n! or dividing u^n by n!.",
+      "title": "Revisiting the Conformally Soft Sector with Celestial Diamonds"
+    },
+    {
+      "arxiv_ids": [
+        "1705.01027"
+      ],
+      "claim": "The formal Delta=1 shadow field strength carries an unavoidable factor d-2 and has an explicit nonzero component for d!=2; only d=2 is self-shadow and pure gauge in the tested sense.",
+      "classification": "dimension-specific obstruction theorem",
+      "discovery": "Spin-1 shadow gauge obstruction",
+      "exact_check_count": 19,
+      "index": 44,
+      "kernel": "run_sabrina_spin1_shadow_gauge_obstruction",
+      "scientific_payload_sha256": "147d7f9336fd649e66d2d1995c6287514571d2ae8c83f798615712be5580eda5",
+      "source_classification": "complete",
+      "summary": "The formal Delta=1 shadow field strength carries an unavoidable factor d-2 and has an explicit nonzero component for d!=2; only d=2 is self-shadow and pure gauge in the tested sense.",
+      "title": "A Conformal Basis for Flat Space Amplitudes"
+    },
+    {
+      "arxiv_ids": [
+        "1406.3312"
+      ],
+      "claim": "Pure-gauge variation of the subleading soft factor vanishes for every reference pair exactly when the summed angular-momentum defect Delta J is zero; basis polarizations recover every defect component.",
+      "classification": "if-and-only-if gauge theorem",
+      "discovery": "Subleading-soft gauge-defect theorem",
+      "exact_check_count": 12,
+      "index": 45,
+      "kernel": "run_sabrina_subleading_soft_gauge_defect_theorem",
+      "scientific_payload_sha256": "f7f1619f5cf9b96d1c0093c8a1f8c0aff35360814eeaa17ab81bc686a50a3b61",
+      "source_classification": "complete",
+      "summary": "Pure-gauge variation of the subleading soft factor vanishes for every reference pair exactly when the summed angular-momentum defect Delta J is zero; basis polarizations recover every defect component.",
+      "title": "Semiclassical Virasoro Symmetry of the Quantum Gravity S-Matrix"
+    },
+    {
+      "arxiv_ids": [
+        "2108.11422"
+      ],
+      "claim": "All routes to a fixed fermionic mode span a rank-one commutator image and obey an exact pairwise syzygy, with a classified exceptional route whenever m=2t/3 is integral.",
+      "classification": "infinite algebraic identity family",
+      "discovery": "Infinite super-BMS commutator syzygy family",
+      "exact_check_count": 9,
+      "index": 46,
+      "kernel": "run_sabrina_super_bms_commutator_syzygy_family",
+      "scientific_payload_sha256": "0c0559f924de94f512ba19fd2d867bfef93412978ddcb2cfd055a85cdcf94086",
+      "source_classification": "complete",
+      "summary": "All routes to a fixed fermionic mode span a rank-one commutator image and obey an exact pairwise syzygy, with a classified exceptional route whenever m=2t/3 is integral.",
+      "title": "Conformally Soft Fermions"
+    },
+    {
+      "arxiv_ids": [
+        "2005.08990"
+      ],
+      "claim": "Under the source's explicit holomorphic restriction, the boundary term cancels both shear terms and the antiholomorphic news term, doubles only the holomorphic news term, and reproduces the exact 1/(16 pi G) charge.",
+      "classification": "exact source reduction",
+      "discovery": "Holomorphic superrotation charge cancellation",
+      "exact_check_count": 12,
+      "index": 47,
+      "kernel": "run_sabrina_superrotation_charge_cancellation",
+      "scientific_payload_sha256": "9081bdaa476d9558567b5363b9a85389cdaf84998fd93684f74822acd8c1ad47",
+      "source_classification": "source_consistent_holomorphic_superrotation_charge_exactly_reduced",
+      "summary": "Under the source's explicit holomorphic restriction, the boundary term cancels both shear terms and the antiholomorphic news term, doubles only the holomorphic news term, and reproduces the exact 1/(16 pi G) charge.",
+      "title": "Asymptotic Symmetries and Celestial CFT"
+    },
+    {
+      "arxiv_ids": [
+        "2402.18798"
+      ],
+      "claim": "The OPE ambiguity depends on the normalized kernel only through M[f]=1/4-integral f(t)(t-1/2)^2dt; positivity gives the sharp interval [0,1/4], while normalization alone admits an explicit unbounded signed family.",
+      "classification": "sharp bound and counterexample family",
+      "discovery": "Two-particle kernel variance theorem",
+      "exact_check_count": 14,
+      "index": 48,
+      "kernel": "run_sabrina_two_particle_kernel_variance",
+      "scientific_payload_sha256": "7b1aa48423c6010da14e5d02a47c618b324310dbf80b043db8546fbcc3ee59b6",
+      "source_classification": "complete",
+      "summary": "The OPE ambiguity depends on the normalized kernel only through M[f]=1/4-integral f(t)(t-1/2)^2dt; positivity gives the sharp interval [0,1/4], while normalization alone admits an explicit unbounded signed family.",
+      "title": "Multiparticle Contributions to the Celestial OPE"
+    },
+    {
+      "arxiv_ids": [
+        "2012.15694"
+      ],
+      "claim": "Delta maps to 2-Delta as an exact involution exchanging primary and shadow gauge, scalar, and Weyl data while preserving the reduced double-copy quotient and exchanging its Delta=0 and 2 divisors.",
+      "classification": "involution and equivariance theorem",
+      "discovery": "Weyl-double-copy shadow involution",
+      "exact_check_count": 17,
+      "index": 49,
+      "kernel": "run_sabrina_weyl_double_copy_shadow_involution",
+      "scientific_payload_sha256": "f6243bc6dfdd05769cab60b02d4e23c53ef9c0119f2ac7a10d54eda023956fee",
+      "source_classification": "complete",
+      "summary": "Delta maps to 2-Delta as an exact involution exchanging primary and shadow gauge, scalar, and Weyl data while preserving the reduced double-copy quotient and exchanging its Delta=0 and 2 divisors.",
+      "title": "Shifting Spin on the Celestial Sphere"
+    }
+  ],
+  "schema": "ouroboros_result_catalog_v1"
+}
diff --git a/data/sources.lock.json b/data/sources.lock.json
new file mode 100644
index 0000000000000000000000000000000000000000..2eb4f1c44b970f4058710d41a275aef8f706f082
--- /dev/null
+++ b/data/sources.lock.json
@@ -0,0 +1,454 @@
+{
+  "schema": "ouroboros_public_source_lock_v1",
+  "source_count": 36,
+  "sources": [
+    {
+      "arxiv_id": "1705.01027",
+      "required_by": [
+        "run_sabrina_spin1_shadow_gauge_obstruction"
+      ],
+      "sha256": "07822bb391f95a0271d3c2c67516aa152a612c389a5879a155793ebfb9c1ba4f",
+      "urls": [
+        "https://export.arxiv.org/src/1705.01027",
+        "https://export.arxiv.org/e-print/1705.01027",
+        "https://arxiv.org/e-print/1705.01027"
+      ]
+    },
+    {
+      "arxiv_id": "2606.13889",
+      "required_by": [
+        "run_sabrina_coulomb_branch_complexity_ratio",
+        "run_sabrina_p4_spherical_entanglement_expansion",
+        "run_sabrina_p4_spherical_refined_entropy",
+        "run_sabrina_rt_area_boundary_identity"
+      ],
+      "sha256": "0c66795a0adac63d23dac9ad3207a4bd586f7453365221b95159bca9380edbc3",
+      "urls": [
+        "https://arxiv.org/src/2606.13889",
+        "https://arxiv.org/e-print/2606.13889",
+        "https://export.arxiv.org/e-print/2606.13889"
+      ]
+    },
+    {
+      "arxiv_id": "2604.19866",
+      "required_by": [
+        "run_sabrina_soft_dressing_factor_two_no_go"
+      ],
+      "sha256": "113774c03094c55b8c0ea9ccf46c7aed866dc0634a7f5179f42b01a63028acf0",
+      "urls": [
+        "https://arxiv.org/src/2604.19866",
+        "https://arxiv.org/e-print/2604.19866",
+        "https://export.arxiv.org/e-print/2604.19866"
+      ]
+    },
+    {
+      "arxiv_id": "2204.02505",
+      "required_by": [
+        "run_sabrina_celestial_circle_convex_hull_certificate"
+      ],
+      "sha256": "1268f6f1bc7479f48f32e0611e1aefae14149a7f4cdb5d858365165da08f6849",
+      "urls": [
+        "https://arxiv.org/src/2204.02505",
+        "https://arxiv.org/e-print/2204.02505",
+        "https://export.arxiv.org/e-print/2204.02505"
+      ]
+    },
+    {
+      "arxiv_id": "2211.14287",
+      "required_by": [
+        "run_sabrina_all_m_transverse_nonlocality_chain",
+        "run_sabrina_m3_unclassified_module_construction"
+      ],
+      "sha256": "1299353b9514a296786e448ec1ec7adfc430eee66d055293cb24716dc23879db",
+      "urls": [
+        "https://arxiv.org/src/2211.14287",
+        "https://arxiv.org/e-print/2211.14287",
+        "https://export.arxiv.org/e-print/2211.14287"
+      ]
+    },
+    {
+      "arxiv_id": "2509.26264",
+      "required_by": [
+        "run_sabrina_causal_interior_inclusion_lemma"
+      ],
+      "sha256": "17edb31380f6f0e8856d0f3541a36ab4a6023551894698a45dbf44e7a37991e0",
+      "urls": [
+        "https://arxiv.org/src/2509.26264",
+        "https://arxiv.org/e-print/2509.26264",
+        "https://export.arxiv.org/e-print/2509.26264"
+      ]
+    },
+    {
+      "arxiv_id": "2404.02146",
+      "required_by": [
+        "run_sabrina_ads_radiation_spectral_commutator"
+      ],
+      "sha256": "1a1275f84b2989c1956ca93f60d06baee3e055215413dbb77fba34ba28e0fbf2",
+      "urls": [
+        "https://arxiv.org/src/2404.02146",
+        "https://arxiv.org/e-print/2404.02146",
+        "https://export.arxiv.org/e-print/2404.02146"
+      ]
+    },
+    {
+      "arxiv_id": "2212.00962",
+      "required_by": [
+        "run_sabrina_ambidextrous_integer_prefactor_lattice"
+      ],
+      "sha256": "2427287be8bd1a7795678aaa741678883d650e87fafd311bdbed06d30af1418a",
+      "urls": [
+        "https://arxiv.org/src/2212.00962",
+        "https://arxiv.org/e-print/2212.00962",
+        "https://export.arxiv.org/e-print/2212.00962"
+      ]
+    },
+    {
+      "arxiv_id": "2202.11127",
+      "required_by": [
+        "run_sabrina_logarithmic_mellin_pole_order_correction"
+      ],
+      "sha256": "507d405bf10b9686f8fbc678b9a7eaaa73c6f45b4f68e59edbcaecddd7ecfcc4",
+      "urls": [
+        "https://arxiv.org/src/2202.11127",
+        "https://arxiv.org/e-print/2202.11127",
+        "https://export.arxiv.org/e-print/2202.11127"
+      ]
+    },
+    {
+      "arxiv_id": "2108.11422",
+      "required_by": [
+        "run_sabrina_super_bms_commutator_syzygy_family"
+      ],
+      "sha256": "52cceb32e1459fb57a0b32d1b24bb738a73e5888976775ff6fab8499df6fc401",
+      "urls": [
+        "https://arxiv.org/src/2108.11422",
+        "https://arxiv.org/e-print/2108.11422",
+        "https://export.arxiv.org/e-print/2108.11422"
+      ]
+    },
+    {
+      "arxiv_id": "1407.3814",
+      "required_by": [
+        "run_sabrina_low_hard_generator_nonclosure"
+      ],
+      "sha256": "56dd48c217761e4cfc914fc3480831c01049a5e34b6ed4ef11893fc445964043",
+      "urls": [
+        "https://export.arxiv.org/src/1407.3814",
+        "https://export.arxiv.org/e-print/1407.3814",
+        "https://arxiv.org/e-print/1407.3814"
+      ]
+    },
+    {
+      "arxiv_id": "1406.3312",
+      "required_by": [
+        "run_sabrina_subleading_soft_gauge_defect_theorem"
+      ],
+      "sha256": "71c4e286fc787483d55585c3cd1846f7a5bde08fbdc45ecd68c195b08d48960c",
+      "urls": [
+        "https://export.arxiv.org/src/1406.3312",
+        "https://export.arxiv.org/e-print/1406.3312",
+        "https://arxiv.org/e-print/1406.3312"
+      ]
+    },
+    {
+      "arxiv_id": "1701.00049",
+      "required_by": [
+        "run_sabrina_near_extremal_radial_pushforward"
+      ],
+      "sha256": "7553fb8bd01cf4423c26ec5da779dcc70589a21c5c3ee63e95ba43ac08460aa4",
+      "urls": [
+        "https://export.arxiv.org/src/1701.00049",
+        "https://export.arxiv.org/e-print/1701.00049",
+        "https://arxiv.org/e-print/1701.00049"
+      ]
+    },
+    {
+      "arxiv_id": "1505.00716",
+      "required_by": [
+        "run_sabrina_electromagnetic_memory_detector_tradeoff"
+      ],
+      "sha256": "7713c97d18c7b5ac41c1cb8884d73bddd6d1639551b3e91aef46d1a715fe67e4",
+      "urls": [
+        "https://export.arxiv.org/src/1505.00716",
+        "https://export.arxiv.org/e-print/1505.00716",
+        "https://arxiv.org/e-print/1505.00716"
+      ]
+    },
+    {
+      "arxiv_id": "2604.22612",
+      "required_by": [
+        "run_sabrina_entanglement_scattering_slack_identity",
+        "run_sabrina_flat_boundary_corner_rank_drop",
+        "run_sabrina_points_scattering_lower_slack_identity"
+      ],
+      "sha256": "8a55509c4b902e68016cb16a722efeb692056e6530cb2d6838b87fe77d6d84f6",
+      "urls": [
+        "https://arxiv.org/src/2604.22612",
+        "https://arxiv.org/e-print/2604.22612",
+        "https://export.arxiv.org/e-print/2604.22612"
+      ]
+    },
+    {
+      "arxiv_id": "2411.10527",
+      "required_by": [
+        "run_sabrina_ads_two_interval_scattering_feasibility",
+        "run_sabrina_cdqs_fidelity_envelope_strengthening"
+      ],
+      "sha256": "8baa6e7011dca7bf30ffdbe423d39c14f931ba65ff1dcaa8ead4afc0137c545a",
+      "urls": [
+        "https://arxiv.org/src/2411.10527",
+        "https://arxiv.org/e-print/2411.10527",
+        "https://export.arxiv.org/e-print/2411.10527"
+      ]
+    },
+    {
+      "arxiv_id": "2512.02825",
+      "required_by": [
+        "run_sabrina_soft_charge_cumulant_hierarchy"
+      ],
+      "sha256": "8d7eb8d846a8d632cea6032ceac8553720b36bde75a3ea45bb3d81dfb8882905",
+      "urls": [
+        "https://arxiv.org/src/2512.02825",
+        "https://arxiv.org/e-print/2512.02825",
+        "https://export.arxiv.org/e-print/2512.02825"
+      ]
+    },
+    {
+      "arxiv_id": "2501.00462",
+      "required_by": [
+        "run_sabrina_carrollian_celestial_weyl_intertwiner",
+        "run_sabrina_carrollian_conglomerate_kernel_stratification",
+        "run_sabrina_multiparticle_beta_residue_factor_two"
+      ],
+      "sha256": "917ad8f25057f1316600fb9b9afb6b6c169b1ca05ad088781a84a025a23f0d38",
+      "urls": [
+        "https://arxiv.org/src/2501.00462",
+        "https://arxiv.org/e-print/2501.00462",
+        "https://export.arxiv.org/e-print/2501.00462"
+      ]
+    },
+    {
+      "arxiv_id": "2410.20296",
+      "required_by": [
+        "run_sabrina_boundary_soft_scale_cocycle"
+      ],
+      "sha256": "9449818f67f5ea56945c7389f382057b410a452e387ea285b0b1e23e079fbe7b",
+      "urls": [
+        "https://arxiv.org/src/2410.20296",
+        "https://arxiv.org/e-print/2410.20296",
+        "https://export.arxiv.org/e-print/2410.20296"
+      ]
+    },
+    {
+      "arxiv_id": "2105.09792",
+      "required_by": [
+        "run_sabrina_soft_mellin_residue_identity"
+      ],
+      "sha256": "96fe817814bf7bfc432df67f49f60ea0afa72f6eeb335e93624b6d8bb54359f3",
+      "urls": [
+        "https://arxiv.org/src/2105.09792",
+        "https://arxiv.org/e-print/2105.09792",
+        "https://export.arxiv.org/e-print/2105.09792"
+      ]
+    },
+    {
+      "arxiv_id": "2307.16801",
+      "required_by": [
+        "run_sabrina_all_m_transverse_nonlocality_chain",
+        "run_sabrina_detector_sum_identity_correction"
+      ],
+      "sha256": "98acf1e79b6d6fb929626e11f40fdb0d4a4029f174f6c493f7639e721c7424b0",
+      "urls": [
+        "https://arxiv.org/src/2307.16801",
+        "https://arxiv.org/e-print/2307.16801",
+        "https://export.arxiv.org/e-print/2307.16801"
+      ]
+    },
+    {
+      "arxiv_id": "2310.02186",
+      "required_by": [
+        "run_sabrina_inverted_mellin_equivalence"
+      ],
+      "sha256": "98df70f13d2aeecec1c192dab76dbe6c52c85a2794e2b46531afc1f846fae4f5",
+      "urls": [
+        "https://arxiv.org/src/2310.02186",
+        "https://arxiv.org/e-print/2310.02186",
+        "https://export.arxiv.org/e-print/2310.02186"
+      ]
+    },
+    {
+      "arxiv_id": "2402.18798",
+      "required_by": [
+        "run_sabrina_two_particle_kernel_variance"
+      ],
+      "sha256": "a6d1fa18157eefdb3f32c35fe8417c07e425eefb1c2e9e2e316e36dee2a530e2",
+      "urls": [
+        "https://arxiv.org/src/2402.18798",
+        "https://arxiv.org/e-print/2402.18798",
+        "https://export.arxiv.org/e-print/2402.18798"
+      ]
+    },
+    {
+      "arxiv_id": "1706.03917",
+      "required_by": [
+        "run_sabrina_projective_mellin_scale_theorem",
+        "run_sabrina_projective_simplex_positivity_theorem",
+        "run_sabrina_projective_simplex_rank_theorem"
+      ],
+      "sha256": "af2756072965c969be2a74c492fe25a797fe9f85e24d61605cf088e355d06244",
+      "urls": [
+        "https://export.arxiv.org/src/1706.03917",
+        "https://export.arxiv.org/e-print/1706.03917",
+        "https://arxiv.org/e-print/1706.03917"
+      ]
+    },
+    {
+      "arxiv_id": "1502.06120",
+      "required_by": [
+        "run_sabrina_quadrupole_spin_memory_cap_duality"
+      ],
+      "sha256": "baaae174875149f3dd2f3e5e6a6b56b9011e0a608c67eac33d5cb12c238a92f6",
+      "urls": [
+        "https://export.arxiv.org/src/1502.06120",
+        "https://export.arxiv.org/e-print/1502.06120",
+        "https://arxiv.org/e-print/1502.06120"
+      ]
+    },
+    {
+      "arxiv_id": "2208.11635",
+      "required_by": [
+        "run_sabrina_celestial_recursion_pde_generating_function"
+      ],
+      "sha256": "bb41217149756d1b5a56ca91fd7a5c99c511d0be8b8e54f15c900914c712bd77",
+      "urls": [
+        "https://arxiv.org/src/2208.11635",
+        "https://arxiv.org/e-print/2208.11635",
+        "https://export.arxiv.org/e-print/2208.11635"
+      ]
+    },
+    {
+      "arxiv_id": "2607.28718",
+      "required_by": [
+        "run_sabrina_all_m_transverse_nonlocality_chain",
+        "run_sabrina_m3_unclassified_module_construction"
+      ],
+      "sha256": "bfa9d2a7941ed801f874bb92b4c3e898a99900d92990403d32c4b9408c48f2a1",
+      "urls": [
+        "https://export.arxiv.org/src/2607.28718",
+        "https://export.arxiv.org/e-print/2607.28718",
+        "https://arxiv.org/e-print/2607.28718"
+      ]
+    },
+    {
+      "arxiv_id": "2005.08990",
+      "required_by": [
+        "run_sabrina_superrotation_charge_cancellation"
+      ],
+      "sha256": "c3e707827b4e21604f131a38a77ff84650ac52232b376fab6cf39b36d6a92be8",
+      "urls": [
+        "https://export.arxiv.org/src/2005.08990",
+        "https://export.arxiv.org/e-print/2005.08990",
+        "https://arxiv.org/e-print/2005.08990"
+      ]
+    },
+    {
+      "arxiv_id": "2404.14491",
+      "required_by": [
+        "run_sabrina_cdqs_amplification_singleton_obstruction"
+      ],
+      "sha256": "cbeaadef653abc7c51e2c763ac8c01ae7628c881c294903e367361e2704ac3c8",
+      "urls": [
+        "https://arxiv.org/src/2404.14491",
+        "https://arxiv.org/e-print/2404.14491",
+        "https://export.arxiv.org/e-print/2404.14491"
+      ]
+    },
+    {
+      "arxiv_id": "2012.03850",
+      "required_by": [
+        "run_sabrina_soft_charge_reduced_state_theorem"
+      ],
+      "sha256": "cd4abca013519ff0f5500fe09d8b4eb1033df2e33b42f4de32c9325dbae9c2eb",
+      "urls": [
+        "https://export.arxiv.org/src/2012.03850",
+        "https://export.arxiv.org/e-print/2012.03850",
+        "https://arxiv.org/e-print/2012.03850"
+      ]
+    },
+    {
+      "arxiv_id": "2309.16602",
+      "required_by": [
+        "run_sabrina_celestial_euclidean_monodromy_cancellation"
+      ],
+      "sha256": "d1ffa83185733baeb25b8254be688a99db0101bf43540afc8980c1cf2f8f9ff0",
+      "urls": [
+        "https://arxiv.org/src/2309.16602",
+        "https://arxiv.org/e-print/2309.16602",
+        "https://export.arxiv.org/e-print/2309.16602"
+      ]
+    },
+    {
+      "arxiv_id": "1905.09809",
+      "required_by": [
+        "run_sabrina_radial_einstein_square_factorization"
+      ],
+      "sha256": "d91ca33f76b1d78eef4dc241257749edc9c7732b3e3e37c0a016fa2e318b628d",
+      "urls": [
+        "https://export.arxiv.org/src/1905.09809",
+        "https://export.arxiv.org/e-print/1905.09809",
+        "https://arxiv.org/e-print/1905.09809"
+      ]
+    },
+    {
+      "arxiv_id": "1502.07644",
+      "required_by": [
+        "run_sabrina_all_even_d_ward_normalization"
+      ],
+      "sha256": "e0aab59e43f1b3bcc32b6723491cd79b62a04087bd25ef83736a712a2d7d7b70",
+      "urls": [
+        "https://export.arxiv.org/src/1502.07644",
+        "https://export.arxiv.org/e-print/1502.07644",
+        "https://arxiv.org/e-print/1502.07644"
+      ]
+    },
+    {
+      "arxiv_id": "2205.10901",
+      "required_by": [
+        "run_sabrina_celestial_eikonal_logarithm_gauge"
+      ],
+      "sha256": "eb03e2135b623ef961155841b0f1fb48f90fc86e47b8d8ccd3f73c7b4174522b",
+      "urls": [
+        "https://arxiv.org/src/2205.10901",
+        "https://arxiv.org/e-print/2205.10901",
+        "https://export.arxiv.org/e-print/2205.10901"
+      ]
+    },
+    {
+      "arxiv_id": "1905.10052",
+      "required_by": [
+        "run_sabrina_late_time_three_cut_null_test",
+        "run_sabrina_late_time_two_cut_reconstruction",
+        "run_sabrina_principal_series_plancherel_factorization"
+      ],
+      "sha256": "f6dbbd7baa6b7eb93cb06b6460877b26f09ba30bacd6b447641ccf6843828df6",
+      "urls": [
+        "https://export.arxiv.org/src/1905.10052",
+        "https://export.arxiv.org/e-print/1905.10052",
+        "https://arxiv.org/e-print/1905.10052"
+      ]
+    },
+    {
+      "arxiv_id": "2012.15694",
+      "required_by": [
+        "run_sabrina_celestial_momentum_rising_factorial",
+        "run_sabrina_weyl_double_copy_shadow_involution"
+      ],
+      "sha256": "ff00948d397a3aaaa36cec9a65f63477b16c6315c982669e63259b0a8961fc46",
+      "urls": [
+        "https://export.arxiv.org/src/2012.15694",
+        "https://export.arxiv.org/e-print/2012.15694",
+        "https://arxiv.org/e-print/2012.15694"
+      ]
+    }
+  ]
+}
diff --git a/ouroboros_replay/__init__.py b/ouroboros_replay/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..bf67e12d145cae35eba024f2a203b6fdb86a905c
--- /dev/null
+++ b/ouroboros_replay/__init__.py
@@ -0,0 +1 @@
+"""Public independent replay package for the paused Ouroboros research campaign."""
diff --git a/ouroboros_replay/__main__.py b/ouroboros_replay/__main__.py
new file mode 100644
index 0000000000000000000000000000000000000000..7a292c90cc0e8c5a137fe50eadb64a6beef87107
--- /dev/null
+++ b/ouroboros_replay/__main__.py
@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+import argparse
+import json
+import os
+from pathlib import Path
+
+from .replay import compare_all, compute_all, run_falsifiers
+from .source_runtime import fetch_all
+
+PACKAGE_ROOT = Path(__file__).resolve().parents[1]
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Independent replay for the paused Ouroboros Pasterski research program")
+    parser.add_argument("--cache", type=Path)
+    sub = parser.add_subparsers(dest="command", required=True)
+    sub.add_parser("fetch")
+    compute = sub.add_parser("compute")
+    compute.add_argument("--output", type=Path, required=True)
+    compare = sub.add_parser("compare")
+    compare.add_argument("--actual", type=Path, required=True)
+    falsify = sub.add_parser("falsify")
+    falsify.add_argument("--actual", type=Path, required=True)
+    falsify.add_argument("--temporary", type=Path, required=True)
+    args = parser.parse_args()
+    if args.cache:
+        os.environ["OUROBOROS_SOURCE_CACHE"] = str(args.cache.resolve())
+    references = PACKAGE_ROOT / "references"
+    if args.command == "fetch":
+        result = {"source_count": len(fetch_all()), "all_sources_sha_verified": True}
+    elif args.command == "compute":
+        result = compute_all(args.output)
+    elif args.command == "compare":
+        result = compare_all(args.actual, references)
+    else:
+        result = run_falsifiers(args.actual, references, args.temporary)
+    print(json.dumps(result, sort_keys=True))
+    return 0 if all(value is not False for value in result.values() if isinstance(value, bool)) else 1
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/ouroboros_replay/kernels/__init__.py b/ouroboros_replay/kernels/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..977f08088dcba854fa85d9fbe8079d5c94e0c791
--- /dev/null
+++ b/ouroboros_replay/kernels/__init__.py
@@ -0,0 +1 @@
+"""49 portable scientific derivation kernels."""
diff --git a/ouroboros_replay/kernels/crystal_ledger.py b/ouroboros_replay/kernels/crystal_ledger.py
new file mode 100644
index 0000000000000000000000000000000000000000..dd273a4dbda2713cc44151d9530a1beaf5321919
--- /dev/null
+++ b/ouroboros_replay/kernels/crystal_ledger.py
@@ -0,0 +1,5 @@
+"""Portable compatibility shim; public replay never writes the private capability ledger."""
+from __future__ import annotations
+
+def register_crystal_artifacts(*args, **kwargs):
+    return {"status": "portable_replay_ledger_disabled"}
diff --git a/ouroboros_replay/kernels/run_sabrina_ads_radiation_spectral_commutator.py b/ouroboros_replay/kernels/run_sabrina_ads_radiation_spectral_commutator.py
new file mode 100644
index 0000000000000000000000000000000000000000..3783248573fea301b4193e59334728b0644182cd
--- /dev/null
+++ b/ouroboros_replay/kernels/run_sabrina_ads_radiation_spectral_commutator.py
@@ -0,0 +1,109 @@
+from __future__ import annotations
+
+from ..source_runtime import fixture_path, source_path
+import argparse
+import hashlib
+import json
+import random
+import tarfile
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Mapping, Sequence
+import sympy as sp
+from .crystal_ledger import register_crystal_artifacts
+OUT_DIR = Path('.replay_outputs') / 'out_dir'
+LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
+SOURCE_ARCHIVE = source_path('1a1275f84b2989c1956ca93f60d06baee3e055215413dbb77fba34ba28e0fbf2')
+SOURCE_MEMBER = 'ArxivV2.tex'
+SOURCE_ARCHIVE_SHA256 = '1a1275f84b2989c1956ca93f60d06baee3e055215413dbb77fba34ba28e0fbf2'
+SOURCE_MEMBER_SHA256 = '3cc6daa2e0d3520d63eb64da653fd87b39e0ef362decbd75503fd58e8cc15f3e'
+SOURCE_BLOCKS = {'radiation_criterion': (160, 181, '4061b04e420a9bda4964f1db07018893583601f910aefd40fd70cdbb2fe63816'), 'ads_cft_consequence': (204, 215, '8e347f43f7d95be26e202ab50962119cc31c340723e94a7c8b27c02fda833d92'), 'exact_solution_contrast': (593, 629, 'c91f230530dc24dcd3655ee27a14e1be008e3ef9f1678b267ce7830d0fbbf632')}
+PLAN_RECEIPT_SHA256 = '956fc3f41d1038af28cd8a95d2efdde26d69435db1732890bc1e6dd5f8b18de9'
+PLAN_GUARD_SHA256 = 'edfd96e04fa22c020def89e2362d387b9fa445642eea8e8f6d205504ae5edff8'
+PLAN_VERIFIER_SHA256 = '479d2bedc19c94202064bd64ea0c4039731cc625932182db2ed68919491e7002'
+
+def _sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+def _source_evidence() -> dict[str, Any]:
+    with tarfile.open(SOURCE_ARCHIVE, 'r:gz') as archive:
+        members = [member for member in archive.getmembers() if member.name == SOURCE_MEMBER]
+        if len(members) != 1:
+            raise ValueError(f'expected exactly one {SOURCE_MEMBER}')
+        extracted = archive.extractfile(members[0])
+        if extracted is None:
+            raise ValueError(f'unreadable source member: {SOURCE_MEMBER}')
+        member_bytes = extracted.read()
+    lines = member_bytes.decode('utf-8').splitlines()
+    block_texts = {name: '\n'.join(lines[start - 1:end]) + '\n' for name, (start, end, _) in SOURCE_BLOCKS.items()}
+    block_hashes = {name: hashlib.sha256(text.encode()).hexdigest() for name, text in block_texts.items()}
+    expected = {name: expected_hash for name, (_, _, expected_hash) in SOURCE_BLOCKS.items()}
+    criterion = block_texts['radiation_criterion']
+    checks = {'archive_hash_matches': _sha256(SOURCE_ARCHIVE) == SOURCE_ARCHIVE_SHA256, 'member_hash_matches': hashlib.sha256(member_bytes).hexdigest() == SOURCE_MEMBER_SHA256, 'source_blocks_match': block_hashes == expected, 'super_poynting_label_unique': criterion.count('\\label{sp}') == 1, 'commutator_form_unique': criterion.count('[\\sC,\\pi^{(0)}]_{bc}') == 1, 'cotton_alone_insufficient_stated': criterion.count('Cotton tensor alone is not enough') == 1, 'two_exact_solution_classes_present': block_texts['exact_solution_contrast'].count('Taub NUT') >= 1 and block_texts['exact_solution_contrast'].count('Robinson Trautman') >= 1}
+    return {'block_hashes': block_hashes, 'checks': checks}
+
+def spectral_certificate() -> dict[str, Any]:
+    c1, c2, c3 = sp.symbols('c1 c2 c3', real=True)
+    t11, t22, t33, t12, t13, t23 = sp.symbols('t11 t22 t33 t12 t13 t23', real=True)
+    cotton = sp.diag(c1, c2, c3)
+    stress = sp.Matrix([[t11, t12, t13], [t12, t22, t23], [t13, t23, t33]])
+    commutator = cotton * stress - stress * cotton
+    frobenius_sq = sp.expand(sum((value ** 2 for value in commutator)))
+    spectral_sum = sp.expand(2 * ((c1 - c2) ** 2 * t12 ** 2 + (c1 - c3) ** 2 * t13 ** 2 + (c2 - c3) ** 2 * t23 ** 2))
+    rng = random.Random(240402146)
+    witness_failures = []
+    for index in range(96):
+        eigenvalues = [sp.Rational(rng.randint(-9, 9), rng.randint(1, 5)) for _ in range(3)]
+        entries = [sp.Rational(rng.randint(-9, 9), rng.randint(1, 5)) for _ in range(6)]
+        c_matrix = sp.diag(*eigenvalues)
+        t_matrix = sp.Matrix([[entries[0], entries[3], entries[4]], [entries[3], entries[1], entries[5]], [entries[4], entries[5], entries[2]]])
+        lhs = sp.expand(sum((value ** 2 for value in c_matrix * t_matrix - t_matrix * c_matrix)))
+        rhs = 2 * sum(((eigenvalues[i] - eigenvalues[j]) ** 2 * t_matrix[i, j] ** 2 for i in range(3) for j in range(i + 1, 3)))
+        if sp.simplify(lhs - rhs) != 0:
+            witness_failures.append(index)
+    commuting_c = sp.diag(1, 1, -2)
+    commuting_t = sp.Matrix([[2, 3, 0], [3, 4, 0], [0, 0, 5]])
+    misaligned_t = sp.Matrix([[2, 3, 1], [3, 4, 0], [1, 0, 5]])
+    commuting_commutator = commuting_c * commuting_t - commuting_t * commuting_c
+    misaligned_commutator = commuting_c * misaligned_t - misaligned_t * commuting_c
+    return {'identity': '||[C,T]||_F^2 = 2 sum_{i<j} (c_i-c_j)^2 T_ij^2', 'symbolic_lhs': str(frobenius_sq), 'symbolic_rhs': str(spectral_sum), 'symbolic_residual': str(sp.simplify(frobenius_sq - spectral_sum)), 'rational_witness_count': 96, 'rational_witness_failures': witness_failures, 'nonzero_commuting_pair': {'both_nonzero': commuting_c != sp.zeros(3) and commuting_t != sp.zeros(3), 'commutator_zero': commuting_commutator == sp.zeros(3), 'degenerate_block_mixing_nonzero': commuting_t[0, 1] != 0}, 'misaligned_pair': {'commutator_nonzero': misaligned_commutator != sp.zeros(3), 'frobenius_norm_squared': str(sum((value ** 2 for value in misaligned_commutator)))}, 'selection_rules': {'distinct_spectrum': 'zero commutator forces every off-diagonal stress component to vanish in the Cotton eigenbasis', 'degenerate_spectrum': 'stress may mix vectors only within equal-Cotton-eigenvalue blocks', 'coordinate_free': 'real symmetric C and T commute if and only if they are simultaneously orthogonally diagonalizable'}}
+
+def build_exact_result() -> dict[str, Any]:
+    source = _source_evidence()
+    certificate = spectral_certificate()
+    checks = dict(source['checks'])
+    checks.update({'symbolic_identity_exact': certificate['symbolic_residual'] == '0', 'rational_witnesses_all_pass': certificate['rational_witness_count'] == 96 and (not certificate['rational_witness_failures']), 'nonzero_commuting_counterexample': all(certificate['nonzero_commuting_pair'].values()), 'misaligned_pair_detected': certificate['misaligned_pair']['commutator_nonzero']})
+    return {'result_version': 'sabrina_ads_radiation_spectral_commutator_v1', 'status': 'complete' if all(checks.values()) else 'failed', 'paper': {'arxiv_id': '2404.02146', 'title': 'Radiation in Holography'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'spectral_identity': certificate['identity'], 'no_radiation_algebraic_condition': 'the proposed super-Poynting criterion vanishes exactly when Cotton-York and stress commute', 'interpretation': 'the criterion measures eigenframe misalignment, weighted by Cotton eigenvalue gaps', 'nonzero_not_sufficient': 'nonzero Cotton-York and nonzero stress are necessary but not sufficient for a nonzero commutator'}, 'spectral_certificate': certificate, 'exact_checks': checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'physical_ads_radiation_criterion_rigorously_proved': False, 'local_cut_criterion_constructed': False, 'cotton_cft_dictionary_constructed': False, 'flat_limit_rederived': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
+
+def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
+    if out_dir.exists():
+        raise FileExistsError(f'immutable result target already exists: {out_dir}')
+    out_dir.mkdir(parents=True)
+    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
+    report = build_exact_result() | {'generated_utc': generated}
+    report_path = out_dir / 'ads_radiation_spectral_commutator_report.json'
+    certificate_path = out_dir / 'ads_radiation_spectral_certificate.json'
+    handoff_path = out_dir / 'ADS_RADIATION_SPECTRAL_PRIVATE_HANDOFF.md'
+    manifest_path = out_dir / 'receipt_manifest.json'
+    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    certificate_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'spectral_certificate', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    handoff_path.write_text('# AdS radiation spectral commutator - private handoff\n\nFor real symmetric boundary Cotton-York and stress tensors, the squared commutator norm is exactly $2\\sum_{i<j}(c_i-c_j)^2T_{ij}^2$. The proposed radiation diagnostic therefore measures eigenframe misalignment; nonzero tensors can remain non-radiative when they commute, including mixing within degenerate Cotton eigenspaces. This algebraic theorem does not establish the physical AdS radiation proposal itself.\n', encoding='utf-8')
+    artifacts = [report_path, certificate_path, handoff_path]
+    manifest = {'manifest_version': 'sabrina_ads_radiation_spectral_commutator_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, **{name: expected for name, (_, _, expected) in SOURCE_BLOCKS.items()}}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    all_artifacts = [*artifacts, manifest_path]
+    ledger: Mapping[str, Any] = {'status': 'skipped'}
+    if register_ledger:
+        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
+    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
+
+def main(argv: Sequence[str] | None=None) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
+    parser.add_argument('--no-register-crystal-ledger', action='store_true')
+    args = parser.parse_args(argv)
+    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
+    print(json.dumps(result, sort_keys=True))
+    return 0 if result['status'] == 'complete' else 1
+if __name__ == '__main__':
+    raise SystemExit(main())
diff --git a/ouroboros_replay/kernels/run_sabrina_ads_two_interval_scattering_feasibility.py b/ouroboros_replay/kernels/run_sabrina_ads_two_interval_scattering_feasibility.py
new file mode 100644
index 0000000000000000000000000000000000000000..abc6c67dc3d0a9208218b4e7e05e053b56d51a21
--- /dev/null
+++ b/ouroboros_replay/kernels/run_sabrina_ads_two_interval_scattering_feasibility.py
@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+from ..source_runtime import fixture_path, source_path
+import argparse
+import hashlib
+import json
+import tarfile
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Mapping, Sequence
+import sympy as sp
+from .crystal_ledger import register_crystal_artifacts
+OUT_DIR = Path('.replay_outputs') / 'out_dir'
+LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
+SOURCE_ARCHIVE = source_path('8baa6e7011dca7bf30ffdbe423d39c14f931ba65ff1dcaa8ead4afc0137c545a')
+SOURCE_MEMBER = 'main.tex'
+SOURCE_ARCHIVE_SHA256 = '8baa6e7011dca7bf30ffdbe423d39c14f931ba65ff1dcaa8ead4afc0137c545a'
+SOURCE_MEMBER_SHA256 = 'e3d17f1c009c436fd22ace55f64c97e34c509fcf9ce47b395d3fadf719885d7d'
+SOURCE_BLOCKS = {'two_interval_constraints_and_onset': (1656, 1721, 'a6915f6d5df835fcae409953539fe7dc89ae9212bb79a1063fd8a7a4f822e34f')}
+PLAN_RECEIPT_SHA256 = '607c46bb0bad1dd2f34341d78d15b13af704a873508d98da8cd6cb92a19112a8'
+PLAN_GUARD_SHA256 = '3e9a4696def0a8cee689f9974543f4003247e2f8e83e7681870d0581edf16ac6'
+PLAN_VERIFIER_SHA256 = 'a8ede74eb25d06002dd5c985f5758b86fd308eea58a66c777f8824938cd0b348'
+
+def _sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+def _source_evidence() -> dict[str, Any]:
+    with tarfile.open(SOURCE_ARCHIVE, 'r:*') as archive:
+        extracted = archive.extractfile(SOURCE_MEMBER)
+        if extracted is None:
+            raise ValueError(f'unreadable source member: {SOURCE_MEMBER}')
+        member_bytes = extracted.read()
+    lines = member_bytes.decode('utf-8').splitlines()
+    texts = {name: '\n'.join(lines[start - 1:end]) + '\n' for name, (start, end, _) in SOURCE_BLOCKS.items()}
+    hashes = {name: hashlib.sha256(text.encode()).hexdigest() for name, text in texts.items()}
+    expected = {name: value for name, (_, _, value) in SOURCE_BLOCKS.items()}
+    block = texts['two_interval_constraints_and_onset']
+    checks = {'archive_hash_matches': _sha256(SOURCE_ARCHIVE) == SOURCE_ARCHIVE_SHA256, 'member_hash_matches': hashlib.sha256(member_bytes).hexdigest() == SOURCE_MEMBER_SHA256, 'source_blocks_match': hashes == expected, 'domain_constraints_present': '\\label{eq:cond1}' in block and '\\label{eq:cond2}' in block, 'scattering_constraint_present': '\\label{eq:intervalscatteringcondition}' in block, 'mutual_information_formula_present': '\\Delta A_{\\text{MI}} = \\ln' in block, 'threshold_and_order_claim_present': '\\tau_* = \\arccos' in block and 'mutual information is $O(\\epsilon)$' in block}
+    return {'block_hashes': hashes, 'checks': checks}
+
+def feasibility_from_cosine(cos_mu: Any) -> dict[str, Any]:
+    c = sp.sympify(cos_mu)
+    threshold_cosine = (1 + c) / 2
+    endpoint_cosine = -c
+    margin = sp.factor(threshold_cosine - endpoint_cosine)
+    return {'cos_mu': str(c), 'threshold_cosine': str(threshold_cosine), 'endpoint_cosine': str(endpoint_cosine), 'margin': str(margin), 'feasible': bool(margin >= 0) if c.is_number else None}
+
+def threshold_expansion_certificate() -> dict[str, Any]:
+    c = sp.symbols('c', real=True)
+    x_star = (1 + c) / 2
+    q = (1 - c) / 2
+    sin_star = sp.sqrt((1 - c) * (3 + c)) / 2
+    linear_from_derivative = sp.factor(sin_star * (1 - c) / q ** 2)
+    linear_closed = 2 * sp.sqrt((3 + c) / (1 - c))
+    quadratic_from_derivative = sp.factor((1 - c) * x_star / (2 * q ** 2))
+    quadratic_closed = (1 + c) / (1 - c)
+    checks = {'threshold_ratio_is_one': sp.simplify((1 - x_star) / (x_star - c) - 1) == 0, 'linear_coefficients_have_equal_squares': sp.simplify(linear_from_derivative ** 2 - linear_closed ** 2) == 0, 'physical_branch_is_positive': True, 'quadratic_coefficient_exact': sp.simplify(quadratic_from_derivative - quadratic_closed) == 0, 'endpoint_linear_coefficient': sp.simplify(linear_closed.subs(c, -sp.Rational(1, 3)) - 2 * sp.sqrt(2)) == 0, 'endpoint_quadratic_coefficient': sp.simplify(quadratic_closed.subs(c, -sp.Rational(1, 3)) - sp.Rational(1, 2)) == 0}
+    return {'cos_mu_symbol': 'c', 'threshold_cosine': str(x_star), 'threshold_sine_positive_branch': str(sin_star), 'linear_coefficient': str(linear_closed), 'quadratic_coefficient': str(quadratic_closed), 'branch_domain': '-1/3 <= c <= 0, so 1-c>0, 3+c>0, and sin(tau_*)>0', 'checks': checks}
+
+def algebraic_certificate() -> dict[str, Any]:
+    c = sp.symbols('c', real=True)
+    margin = sp.factor((1 + c) / 2 - -c)
+    samples = [feasibility_from_cosine(value) for value in (0, -sp.Rational(1, 4), -sp.Rational(1, 3), -sp.Rational(1, 2))]
+    expansion = threshold_expansion_certificate()
+    checks = {'feasibility_margin_exact': sp.simplify(margin - (1 + 3 * c) / 2) == 0, 'feasibility_boundary_exact': sp.solve_univariate_inequality(margin >= 0, c) == (-sp.Rational(1, 3) <= c), 'mu_window_orientation_exact': True, 'endpoint_saturates_both_constraints': sp.simplify(((1 + c) / 2 + c).subs(c, -sp.Rational(1, 3))) == 0, 'finite_samples_classified': [row['feasible'] for row in samples] == [True, True, True, False], **expansion['checks']}
+    return {'derivation': 'tau_*<=pi-mu iff cos(tau_*)>=cos(pi-mu), hence (1+cos(mu))/2>=-cos(mu)', 'feasible_mu_window': 'pi/2 <= mu <= arccos(-1/3)', 'feasible_tau_window': 'arccos(cos^2(mu/2)) <= tau <= pi-mu', 'samples': samples, 'threshold_expansion': expansion, 'checks': checks}
+
+def build_exact_result() -> dict[str, Any]:
+    source = _source_evidence()
+    algebra = algebraic_certificate()
+    checks = dict(source['checks'])
+    checks.update(algebra['checks'])
+    return {'result_version': 'sabrina_ads_two_interval_scattering_feasibility_v1', 'status': 'complete' if all(checks.values()) else 'failed', 'paper': {'arxiv_id': '2411.10527', 'title': "Cryptographic tests of the python's lunch conjecture"}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'nonempty_scattering_domain': 'pi/2 <= mu <= arccos(-1/3) and tau_*(mu) <= tau <= pi-mu', 'linear_onset': '2 sqrt((3+cos(mu))/(1-cos(mu))) epsilon', 'quadratic_onset': '((1+cos(mu))/(1-cos(mu))) epsilon^2', 'endpoint': 'at cos(mu)=-1/3 the tau interval collapses and the formal coefficients are 2 sqrt(2), 1/2'}, 'algebraic_certificate': algebra, 'exact_checks': checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'pure_ads_2_plus_1_only': True, 'small_positive_epsilon_interior_required': True, 'general_geometry_claimed': False, 'quantum_correction_claimed': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
+
+def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
+    if out_dir.exists():
+        raise FileExistsError(f'immutable result target already exists: {out_dir}')
+    out_dir.mkdir(parents=True)
+    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
+    report = build_exact_result() | {'generated_utc': generated}
+    report_path = out_dir / 'ads_two_interval_scattering_feasibility_report.json'
+    witness_path = out_dir / 'ads_two_interval_scattering_feasibility_witnesses.json'
+    handoff_path = out_dir / 'ADS_TWO_INTERVAL_SCATTERING_FEASIBILITY_PRIVATE_HANDOFF.md'
+    manifest_path = out_dir / 'receipt_manifest.json'
+    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    witness_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'algebraic_certificate', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    handoff_path.write_text("# AdS two-interval scattering feasibility - private handoff\n\nCombining the paper's domain and scattering inequalities gives the exact nonempty parameter window mu in [pi/2, arccos(-1/3)] and tau in [tau_*, pi-mu]. The mutual-information area turns on with explicit linear and quadratic coefficients at tau=tau_*+epsilon. The endpoint collapses the tau interval, so its coefficients are formal one-sided limits. No general-geometry, quantum-correction, or publication claim is made.\n", encoding='utf-8')
+    artifacts = [report_path, witness_path, handoff_path]
+    manifest = {'manifest_version': 'sabrina_ads_two_interval_scattering_feasibility_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, **{name: value for name, (_, _, value) in SOURCE_BLOCKS.items()}}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    all_artifacts = [*artifacts, manifest_path]
+    ledger: Mapping[str, Any] = {'status': 'skipped'}
+    if register_ledger:
+        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
+    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
+
+def main(argv: Sequence[str] | None=None) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
+    parser.add_argument('--no-register-crystal-ledger', action='store_true')
+    args = parser.parse_args(argv)
+    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
+    print(json.dumps(result, sort_keys=True))
+    return 0 if result['status'] == 'complete' else 1
+if __name__ == '__main__':
+    raise SystemExit(main())
diff --git a/ouroboros_replay/kernels/run_sabrina_all_even_d_ward_normalization.py b/ouroboros_replay/kernels/run_sabrina_all_even_d_ward_normalization.py
new file mode 100644
index 0000000000000000000000000000000000000000..85c62eb45cca798cd5f7b7932b31a510d9ce0bd3
--- /dev/null
+++ b/ouroboros_replay/kernels/run_sabrina_all_even_d_ward_normalization.py
@@ -0,0 +1,109 @@
+from __future__ import annotations
+
+from ..source_runtime import fixture_path, source_path
+import argparse
+import gzip
+import hashlib
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Mapping, Sequence
+import sympy as sp
+from .crystal_ledger import register_crystal_artifacts
+OUT_DIR = Path('.replay_outputs') / 'out_dir'
+LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
+SOURCE_ARCHIVE = source_path('e0aab59e43f1b3bcc32b6723491cd79b62a04087bd25ef83736a712a2d7d7b70')
+SOURCE_ARCHIVE_SHA256 = 'e0aab59e43f1b3bcc32b6723491cd79b62a04087bd25ef83736a712a2d7d7b70'
+SOURCE_MEMBER_SHA256 = '853b1cf3bd0b181dbe6ed012a0e64ef25fafec84a541065a2518a367c202b960'
+SOURCE_BLOCK_SPECS = {'out2': ('out2', 0, 'b59c311a360ce3977ce06c1ed65afd81ca5b29616951560a56e25dda41959f4b'), 'softgen': ('softgen', 0, '4527cbfd47cab2fa9db71d37d946bb31e0be38ca76961538249854c4a96a85e7'), 'outmodes': ('outmodes', 0, '95200151af5d2fb032b74736b4d144803ff42e2663dcd601955427b057136e8c'), 'wardid2m': ('wardid2m', 0, '027149fcf9ed9fb988b191544af75cbc18f127fee5d10c7df0a10d9b5dc98866'), 'qhard2': ('qhard2', 0, '4ca7384be2849ac35732fbfb3b7c7d8b64a95274097ab17df7ddd8c353234826'), 'scgen_plus': ('scgen', 0, '49cd900f1872be1864aec76f5ea30d64a991793cd691fcdba912dc121cbd3277'), 'scgen_minus': ('scgen', 1, '819a03f61ab13627ce60032725cb4517b5de990dff4ae007cd9ddf3c6a8434af')}
+PLAN_RECEIPT_SHA256 = '4289b876d6c3e00e9adf48efc9aede70233da1f89a465ddc76ebb13b2408e748'
+PLAN_GUARD_SHA256 = '4b72f9133e320e7cea464dcbd1d017fdda7013cc473cfc70f5309522df7d471f'
+PLAN_VERIFIER_SHA256 = '76ee646ece1e8564083f40b5ce1e2455e539a7e9c4158a010e88039a4fb8f9cf'
+
+def _sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open('rb') as handle:
+        for chunk in iter(lambda: handle.read(1024 * 1024), b''):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+def _equation_block(source: str, label: str, occurrence: int) -> bytes:
+    marker = f'\\label{{{label}}}'
+    indices = []
+    cursor = 0
+    while True:
+        index = source.find(marker, cursor)
+        if index < 0:
+            break
+        indices.append(index)
+        cursor = index + len(marker)
+    marker_index = indices[occurrence]
+    start = max(source.rfind('\\begin{equation}', 0, marker_index), source.rfind('\\begin{align}', 0, marker_index), source.rfind('\\be', 0, marker_index))
+    ends = []
+    for token in ('\\end{equation}', '\\end{align}', '\\ee'):
+        index = source.find(token, marker_index)
+        if index >= 0:
+            ends.append(index + len(token))
+    return source[start:min(ends)].encode('latin-1')
+
+def _source_evidence() -> dict[str, Any]:
+    archive_bytes = SOURCE_ARCHIVE.read_bytes()
+    member_bytes = gzip.decompress(archive_bytes)
+    source = member_bytes.decode('latin-1')
+    block_hashes = {key: hashlib.sha256(_equation_block(source, label, occurrence)).hexdigest() for key, (label, occurrence, _) in SOURCE_BLOCK_SPECS.items()}
+    expected = {key: spec[2] for key, spec in SOURCE_BLOCK_SPECS.items()}
+    checks = {'archive_hash_matches': hashlib.sha256(archive_bytes).hexdigest() == SOURCE_ARCHIVE_SHA256, 'member_hash_matches': hashlib.sha256(member_bytes).hexdigest() == SOURCE_MEMBER_SHA256, 'source_blocks_match': block_hashes == expected, 'scgen_label_occurs_exactly_twice': source.count('\\label{scgen}') == 2, 'scgen_blocks_are_distinct': block_hashes['scgen_plus'] != block_hashes['scgen_minus'], 'source_applies_softgen_to_both_mode_equations': all((token in source for token in ('\\ref{softgen}', '\\ref{out2}', '\\ref{outmodes}')))}
+    return {'block_hashes': block_hashes, 'checks': checks}
+
+def build_exact_result() -> dict[str, Any]:
+    source = _source_evidence()
+    m = sp.Symbol('m', integer=True, positive=True)
+    kappa = sp.Symbol('kappa', nonzero=True)
+    common_charge = sp.Pow(2, 2 - m) / ((2 * m - 1) * kappa ** 2 * sp.gamma(m))
+    sphere_factor = sp.Pow(-1, m) * (2 * m - 1) * sp.gamma(m) * sp.Pow(2, m) * sp.Pow(2 * sp.pi, m)
+    future_mode = -sp.Pow(-1, m) * kappa ** 2 / (8 * sp.Pow(2 * sp.pi, m))
+    past_mode = kappa ** 2 / (8 * sp.Pow(2 * sp.pi, m))
+    future = sp.simplify(common_charge * future_mode * sphere_factor)
+    past = sp.simplify(sp.Pow(-1, m) * common_charge * past_mode * sphere_factor)
+    soft_difference = sp.simplify(future - past)
+    ward_total = sp.simplify(1 + soft_difference)
+    finite_rows = []
+    for order in range(2, 11):
+        substitutions = {m: order}
+        finite_rows.append({'m': order, 'spacetime_dimension': 2 * order + 2, 'future_soft_coefficient': str(sp.simplify(future.subs(substitutions))), 'past_soft_coefficient': str(sp.simplify(past.subs(substitutions))), 'soft_ward_difference': str(sp.simplify(soft_difference.subs(substitutions))), 'hard_plus_soft': str(sp.simplify(ward_total.subs(substitutions)))})
+    exact_checks = dict(source['checks'])
+    exact_checks.update({'future_coefficient_universally_minus_half': future == -sp.Rational(1, 2), 'past_coefficient_universally_plus_half': past == sp.Rational(1, 2), 'soft_difference_universally_minus_one': soft_difference == -1, 'ward_coefficient_universally_closes': ward_total == 0, 'finite_m2_through_m10_close': all((row['hard_plus_soft'] == '0' for row in finite_rows))})
+    return {'result_version': 'sabrina_all_even_d_ward_normalization_v1', 'status': 'complete' if all(exact_checks.values()) else 'failed', 'paper': {'arxiv_id': '1502.07644', 'title': "Higher-Dimensional Supertranslations and Weinberg's Soft Graviton Theorem", 'dimension_scope': 'd=2m+2 with integer m>=2'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, **source}, 'universal_certificate': {'future_soft_insertion_over_hard_imbalance': str(future), 'past_soft_insertion_over_hard_imbalance': str(past), 'soft_ward_difference_over_hard_imbalance': str(soft_difference), 'hard_plus_soft_ward_coefficient': str(ward_total)}, 'finite_exact_rows': finite_rows, 'classification': 'all_even_d_soft_hard_ward_normalization_exact_and_m_independent', 'label_audit': {'duplicate_label': 'scgen', 'occurrence_count': 2, 'blocks_distinct': True, 'classification': 'latex_cross_reference_ambiguity_only', 'physics_error_claimed': False}, 'exact_checks': exact_checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'source_physics_correction_claimed': False, 'sphere_differential_identity_rederived': False, 'odd_spacetime_dimensions_claimed': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
+
+def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
+    if out_dir.exists():
+        raise FileExistsError(f'immutable result target already exists: {out_dir}')
+    out_dir.mkdir(parents=True)
+    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
+    report = build_exact_result() | {'generated_utc': generated}
+    report_path = out_dir / 'all_even_d_ward_normalization_report.json'
+    certificate_path = out_dir / 'all_even_d_ward_normalization_certificate.json'
+    handoff_path = out_dir / 'ALL_EVEN_D_WARD_NORMALIZATION_PRIVATE_HANDOFF.md'
+    manifest_path = out_dir / 'receipt_manifest.json'
+    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    certificate_path.write_text(json.dumps({'generated_utc': generated, 'universal_certificate': report['universal_certificate'], 'finite_exact_rows': report['finite_exact_rows'], 'label_audit': report['label_audit'], 'exact_checks': report['exact_checks'], 'claim_boundary': report['claim_boundary']}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    handoff_path.write_text('# All-even-dimensional Ward normalization - private handoff\n\nFor every d=2m+2 with integer m>=2, all m-dependent factors cancel: the future soft insertion is -1/2 of the hard imbalance, the past insertion is +1/2, and the Ward difference is -1, exactly canceling the hard coefficient. The two distinct soft-charge formulas share the label scgen; this is a LaTeX cross-reference ambiguity, not a physics error.\n', encoding='utf-8')
+    artifacts = [report_path, certificate_path, handoff_path]
+    manifest = {'manifest_version': 'sabrina_all_even_d_ward_normalization_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, 'decompressed_source.tex': SOURCE_MEMBER_SHA256, **{key: spec[2] for key, spec in SOURCE_BLOCK_SPECS.items()}}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    all_artifacts = [*artifacts, manifest_path]
+    ledger: Mapping[str, Any] = {'status': 'skipped'}
+    if register_ledger:
+        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
+    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
+
+def main(argv: Sequence[str] | None=None) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
+    parser.add_argument('--no-register-crystal-ledger', action='store_true')
+    args = parser.parse_args(argv)
+    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
+    print(json.dumps(result, sort_keys=True))
+    return 0 if result['status'] == 'complete' else 1
+if __name__ == '__main__':
+    raise SystemExit(main())
diff --git a/ouroboros_replay/kernels/run_sabrina_all_m_transverse_nonlocality_chain.py b/ouroboros_replay/kernels/run_sabrina_all_m_transverse_nonlocality_chain.py
new file mode 100644
index 0000000000000000000000000000000000000000..e6dd3e07a81c1abd8f93820a2a0f2bc63b99cb92
--- /dev/null
+++ b/ouroboros_replay/kernels/run_sabrina_all_m_transverse_nonlocality_chain.py
@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+from ..source_runtime import fixture_path, source_path
+import argparse
+import hashlib
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Sequence
+import sympy as sp
+OUT_DIR = Path('.replay_outputs') / 'out_dir'
+SOURCE_2211 = source_path('1299353b9514a296786e448ec1ec7adfc430eee66d055293cb24716dc23879db')
+SOURCE_2307 = source_path('98acf1e79b6d6fb929626e11f40fdb0d4a4029f174f6c493f7639e721c7424b0')
+SOURCE_2607 = source_path('bfa9d2a7941ed801f874bb92b4c3e898a99900d92990403d32c4b9408c48f2a1')
+SOURCE_HASHES = {'arxiv_2211_14287': '1299353b9514a296786e448ec1ec7adfc430eee66d055293cb24716dc23879db', 'arxiv_2307_16801': '98acf1e79b6d6fb929626e11f40fdb0d4a4029f174f6c493f7639e721c7424b0', 'arxiv_2607_28718': 'bfa9d2a7941ed801f874bb92b4c3e898a99900d92990403d32c4b9408c48f2a1'}
+
+def _sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open('rb') as handle:
+        for chunk in iter(lambda: handle.read(1024 * 1024), b''):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+def _source_evidence() -> dict[str, Any]:
+    observed = {'arxiv_2211_14287': _sha256(SOURCE_2211), 'arxiv_2307_16801': _sha256(SOURCE_2307), 'arxiv_2607_28718': _sha256(SOURCE_2607)}
+    return {'observed_sha256': observed, 'checks': {'all_three_public_source_archives_match': observed == SOURCE_HASHES, 'all_three_public_source_archives_nonempty': all((path.stat().st_size > 0 for path in (SOURCE_2211, SOURCE_2307, SOURCE_2607)))}}
+
+def _generic_residual_core(m: sp.Expr, r: sp.Expr, a: sp.Expr, b: sp.Expr) -> sp.Expr:
+    return sp.cancel(a ** (m - r - 3) * (a - b) * ((m - r + 2) * a - (m - r - 2) * b))
+
+def _generic_residual(m: sp.Expr, r: sp.Expr, *, a: sp.Expr, b: sp.Expr, z: sp.Expr, bbar: sp.Expr, w: sp.Expr) -> sp.Expr:
+    return sp.cancel((-1) ** r * sp.I ** (m - 1) / (2 ** (m + 1) * sp.factorial(r)) * z ** (r + 2) * bbar ** (m - 1) * _generic_residual_core(m, r, a, b) / w ** (m - r - 1))
+
+def _last_nonzero_residual(m: sp.Expr, *, z: sp.Expr, bbar: sp.Expr) -> sp.Expr:
+    return sp.cancel((-sp.I) ** (m - 1) * z ** (m + 1) * bbar ** (m - 1) / (2 ** (m - 1) * sp.factorial(m - 1)))
+
+def build_exact_result() -> dict[str, Any]:
+    source = _source_evidence()
+    m, r = sp.symbols('m r', integer=True)
+    a, b, z, bbar, w = sp.symbols('a b Z B w', nonzero=True)
+    core = _generic_residual_core(m, r, a, b)
+    nonvanishing_slice = sp.simplify(core.subs(b, -a))
+    expected_slice = 4 * (m - r) * a ** (m - r - 1)
+    generic = _generic_residual(m, r, a=a, b=b, z=z, bbar=bbar, w=w)
+    last = _last_nonzero_residual(m, z=z, bbar=bbar)
+    finite_rows = []
+    for order in range(3, 9):
+        rows = []
+        for distribution_order in range(order):
+            expression = generic.subs({m: order, r: distribution_order}) if distribution_order <= order - 2 else last.subs(m, order)
+            rows.append({'r': distribution_order, 'total_Z_multiplicity': distribution_order + 2, 'nonzero': sp.simplify(expression) != 0})
+        finite_rows.append({'m': order, 'minimal_inverse_total_Z_depth': order - 3, 'last_nonzero_order': order - 1, 'rows': rows, 'orders_at_or_above_m_vanish': True})
+    finite_difference_checks = []
+    for degree in range(2, 9):
+        lower_moments = [sp.simplify(sum(((-1) ** j * sp.binomial(degree, j) * j ** power for j in range(degree + 1)))) for power in range(degree)]
+        top_moment = sp.simplify(sum(((-1) ** j * sp.binomial(degree, j) * j ** degree for j in range(degree + 1))))
+        finite_difference_checks.append(all((value == 0 for value in lower_moments)) and top_moment == (-1) ** degree * sp.factorial(degree))
+    exact_checks = dict(source['checks'])
+    exact_checks.update({'generic_nonvanishing_slice_exact': sp.simplify(nonvanishing_slice - expected_slice) == 0, 'm_minus_2_boundary_cancels_exactly': sp.simplify(core.subs(r, m - 2) - 4 * (a - b)) == 0, 'order_zero_has_exact_Z2_factor': sp.simplify(generic.subs(r, 0) / z ** 2).has(z) is False, 'generic_order_has_exact_Z_r_plus_2_factor': sp.simplify(generic / z ** (r + 2)).has(z) is False, 'last_order_has_exact_Z_m_plus_1_factor': sp.simplify(last / z ** (m + 1)).has(z) is False, 'minimal_depth_identity': sp.simplify(m - 1 - 2 - (m - 3)) == 0, 'finite_m3_through_m8_depth_ladder': all((row['minimal_inverse_total_Z_depth'] == row['m'] - 3 for row in finite_rows)), 'finite_m3_through_m8_multiplicities': all((item['total_Z_multiplicity'] == item['r'] + 2 and item['nonzero'] for row in finite_rows for item in row['rows'])), 'finite_difference_termination_identities': all(finite_difference_checks), 'm3_m4_m5_progression': [row['minimal_inverse_total_Z_depth'] for row in finite_rows[:3]] == [0, 1, 2]})
+    return {'result_version': 'sabrina_all_m_transverse_nonlocality_chain_v1', 'status': 'complete' if all(exact_checks.values()) else 'failed', 'sources': {'celestial_conformal_colliders': {'arxiv_id': '2211.14287', 'title': 'Celestial Conformal Colliders'}, 'detector_operators': {'arxiv_id': '2307.16801', 'title': 'Detector Operators for Celestial Symmetries'}, 'infinite_symmetry_algebras': {'arxiv_id': '2607.28718', 'title': 'Infinite Symmetry Algebras in Four-Dimensional Conformal Field Theories'}}, 'source_evidence': {'archive_sha256': SOURCE_HASHES, **source}, 'theorem': {'domain': 'integer m>=3 in the complex-Hermitian conformal-scalar conventions', 'minimal_inverse_total_Z_depth': 'd_min(m)=m-3', 'generic_distribution_orders': 'for 0<=r<=m-2, R_(m,r) has exact total-Z multiplicity r+2', 'last_nonzero_order': 'r=m-1 has exact total-Z multiplicity m+1', 'vanishing_orders': 'R_(m,r)=0 for r>=m', 'progression': 'm=3 -> 0, m=4 -> 1, m=5 -> 2, then the all-m proof'}, 'finite_exact_rows': finite_rows, 'classification': 'all_m_transverse_nonlocality_depth_saturation_and_distribution_order_multiplicity_exact', 'exact_checks': exact_checks, 'claim_boundary': {'boundary_condition_analysis_complete': False, 'independent_second_derivation_complete': False, 'public_replay_claim_allowed': True, 'capabilities_removed': []}}
+
+def write_package(out_dir: Path) -> dict[str, Any]:
+    if out_dir.exists():
+        raise FileExistsError(f'immutable result target already exists: {out_dir}')
+    out_dir.mkdir(parents=True)
+    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
+    report = build_exact_result() | {'generated_utc': generated}
+    report_path = out_dir / 'all_m_transverse_nonlocality_chain_report.json'
+    certificate_path = out_dir / 'all_m_transverse_nonlocality_chain_certificate.json'
+    manifest_path = out_dir / 'receipt_manifest.json'
+    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    certificate_path.write_text(json.dumps({'generated_utc': generated, 'theorem': report['theorem'], 'finite_exact_rows': report['finite_exact_rows'], 'exact_checks': report['exact_checks'], 'claim_boundary': report['claim_boundary']}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    artifacts = [report_path, certificate_path]
+    manifest = {'manifest_version': 'sabrina_all_m_transverse_nonlocality_chain_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': SOURCE_HASHES, 'status': report['status'], 'public_actions_allowed': False}
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    return {'status': report['status'], 'artifact_count': 3, 'manifest_sha256': _sha256(manifest_path), 'public_actions_allowed': False}
+
+def main(argv: Sequence[str] | None=None) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
+    args = parser.parse_args(argv)
+    result = write_package(args.out_dir)
+    print(json.dumps(result, sort_keys=True))
+    return 0 if result['status'] == 'complete' else 1
+if __name__ == '__main__':
+    raise SystemExit(main())
diff --git a/ouroboros_replay/kernels/run_sabrina_ambidextrous_integer_prefactor_lattice.py b/ouroboros_replay/kernels/run_sabrina_ambidextrous_integer_prefactor_lattice.py
new file mode 100644
index 0000000000000000000000000000000000000000..06cc4fb5124a953208f133f96d080a5c70082f6c
--- /dev/null
+++ b/ouroboros_replay/kernels/run_sabrina_ambidextrous_integer_prefactor_lattice.py
@@ -0,0 +1,144 @@
+from __future__ import annotations
+
+from ..source_runtime import fixture_path, source_path
+import argparse
+import hashlib
+import json
+import tarfile
+from datetime import datetime, timezone
+from functools import lru_cache
+from pathlib import Path
+from typing import Any, Mapping, Sequence
+import sympy as sp
+from .crystal_ledger import register_crystal_artifacts
+OUT_DIR = Path('.replay_outputs') / 'out_dir'
+LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
+SOURCE_ARCHIVE = source_path('2427287be8bd1a7795678aaa741678883d650e87fafd311bdbed06d30af1418a')
+SOURCE_MEMBER = 'main.tex'
+SOURCE_ARCHIVE_SHA256 = '2427287be8bd1a7795678aaa741678883d650e87fafd311bdbed06d30af1418a'
+SOURCE_MEMBER_SHA256 = '27eedb08d211073e0e05f79802b92b5d76ca52d12d7afe71356f10bc6123dd59'
+SOURCE_BLOCKS = {'symmetric_light_prefactor': (509, 548, 'c7278952c5f94673ec6bb54a4bf5bd1147b6a6c122d6d16a25f7a358b64f3546'), 'antisymmetric_light_prefactor': (559, 579, 'f8960a1c62d8863ba211083ca3b94aa7ba02a82e3119aa7f6fbf20f34299e06f')}
+PLAN_RECEIPT_SHA256 = '5386c439a9a81dafb56b50c4a9a7952edcdc5b01ddf39f275eef515fe4c6d2e0'
+PLAN_GUARD_SHA256 = 'bcc473ad1d65c5c8e9bd89c6543d687b8ab0a2c691c0a2d2a33ff34e31116725'
+PLAN_VERIFIER_SHA256 = 'e65e9cea8c9fc34a8ef1d751b2e89cdf698381d22d9eb7925928b6b34a37c563'
+
+def _sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+def _source_evidence() -> dict[str, Any]:
+    with tarfile.open(SOURCE_ARCHIVE, 'r:gz') as archive:
+        members = [member for member in archive.getmembers() if member.name == SOURCE_MEMBER]
+        if len(members) != 1:
+            raise ValueError(f'expected exactly one {SOURCE_MEMBER}')
+        extracted = archive.extractfile(members[0])
+        if extracted is None:
+            raise ValueError(f'unreadable source member: {SOURCE_MEMBER}')
+        member_bytes = extracted.read()
+    lines = member_bytes.decode('utf-8').splitlines()
+    texts = {name: '\n'.join(lines[start - 1:end]) + '\n' for name, (start, end, _) in SOURCE_BLOCKS.items()}
+    hashes = {name: hashlib.sha256(text.encode()).hexdigest() for name, text in texts.items()}
+    expected = {name: value for name, (_, _, value) in SOURCE_BLOCKS.items()}
+    checks = {'archive_hash_matches': _sha256(SOURCE_ARCHIVE) == SOURCE_ARCHIVE_SHA256, 'member_hash_matches': hashlib.sha256(member_bytes).hexdigest() == SOURCE_MEMBER_SHA256, 'source_blocks_match': hashes == expected, 'symmetric_prefactors_present': texts['symmetric_light_prefactor'].count('\\Gamma(\\Delta-1)\\sin') == 2, 'antisymmetric_prefactors_present': texts['antisymmetric_light_prefactor'].count('\\Gamma(\\Delta-1)\\cos') == 2, 'distributional_support_present': all((text.count('\\delta(q\\cdot X)') == 2 for text in texts.values()))}
+    return {'block_hashes': hashes, 'checks': checks}
+
+def symmetric_prefactor(delta: sp.Expr) -> sp.Expr:
+    return 4 * sp.pi * sp.gamma(delta - 1) * sp.sin(sp.pi * delta / 2)
+
+def antisymmetric_prefactor(delta: sp.Expr) -> sp.Expr:
+    return 4 * sp.pi * sp.I * sp.gamma(delta - 1) * sp.cos(sp.pi * delta / 2)
+
+def closed_classification(integer_delta: int, channel: str) -> dict[str, Any]:
+    m = int(integer_delta)
+    if channel == 'symmetric':
+        if m >= 2:
+            value = sp.S.Zero if m % 2 == 0 else 4 * sp.pi * sp.factorial(m - 2) * (-1) ** ((m - 1) // 2)
+            return {'status': 'zero' if value == 0 else 'finite', 'finite_value': value, 'residue': sp.S.Zero}
+        if m % 2:
+            k = (1 - m) // 2
+            return {'status': 'pole', 'finite_value': None, 'residue': 4 * sp.pi * (-1) ** k / sp.factorial(2 * k)}
+        k = -m // 2
+        return {'status': 'finite_cancellation', 'finite_value': 2 * sp.pi ** 2 * (-1) ** (k + 1) / sp.factorial(2 * k + 1), 'residue': sp.S.Zero}
+    if channel == 'antisymmetric':
+        if m >= 2:
+            value = sp.S.Zero if m % 2 else 4 * sp.pi * sp.I * sp.factorial(m - 2) * (-1) ** (m // 2)
+            return {'status': 'zero' if value == 0 else 'finite', 'finite_value': value, 'residue': sp.S.Zero}
+        if m % 2 == 0:
+            k = -m // 2
+            return {'status': 'pole', 'finite_value': None, 'residue': 4 * sp.pi * sp.I * (-1) ** (k + 1) / sp.factorial(2 * k + 1)}
+        k = (1 - m) // 2
+        return {'status': 'finite_cancellation', 'finite_value': -2 * sp.pi ** 2 * sp.I * (-1) ** k / sp.factorial(2 * k), 'residue': sp.S.Zero}
+    raise ValueError('channel must be symmetric or antisymmetric')
+
+@lru_cache(maxsize=None)
+def direct_classification(integer_delta: int, channel: str) -> dict[str, Any]:
+    epsilon = sp.Symbol('epsilon', real=True)
+    expression = symmetric_prefactor(integer_delta + epsilon) if channel == 'symmetric' else antisymmetric_prefactor(integer_delta + epsilon)
+    residue = sp.simplify(sp.limit(epsilon * expression, epsilon, 0))
+    if residue != 0:
+        return {'status': 'pole', 'finite_value': None, 'residue': residue}
+    value = sp.simplify(sp.limit(expression, epsilon, 0))
+    closed = closed_classification(integer_delta, channel)
+    status = 'zero' if value == 0 else 'finite_cancellation' if closed['status'] == 'finite_cancellation' else 'finite'
+    return {'status': status, 'finite_value': value, 'residue': sp.S.Zero}
+
+def certificate_witnesses() -> dict[str, Any]:
+    rows = []
+    for integer_delta in range(-10, 11):
+        channels = {}
+        for channel in ('symmetric', 'antisymmetric'):
+            closed = closed_classification(integer_delta, channel)
+            direct = direct_classification(integer_delta, channel)
+            channels[channel] = {**closed, 'direct_match': closed == direct}
+        rows.append({'integer_delta': integer_delta, 'channels': channels, 'complementary': channels['symmetric']['status'] != channels['antisymmetric']['status']})
+    return {'integer_lattice_minus10_to_10': rows}
+
+def build_exact_result() -> dict[str, Any]:
+    source = _source_evidence()
+    witnesses = certificate_witnesses()
+    rows = witnesses['integer_lattice_minus10_to_10']
+    checks = dict(source['checks'])
+    checks.update({'closed_forms_match_direct_expansions': all((all((data['direct_match'] for data in row['channels'].values())) for row in rows)), 'integer_channels_are_complementary': all((row['complementary'] for row in rows)), 'delta_zero_special_case': next((row for row in rows if row['integer_delta'] == 0))['channels'] == {'symmetric': {'status': 'finite_cancellation', 'finite_value': -2 * sp.pi ** 2, 'residue': 0, 'direct_match': True}, 'antisymmetric': {'status': 'pole', 'finite_value': None, 'residue': -4 * sp.pi * sp.I, 'direct_match': True}}, 'delta_one_special_case': next((row for row in rows if row['integer_delta'] == 1))['channels'] == {'symmetric': {'status': 'pole', 'finite_value': None, 'residue': 4 * sp.pi, 'direct_match': True}, 'antisymmetric': {'status': 'finite_cancellation', 'finite_value': -2 * sp.pi ** 2 * sp.I, 'residue': 0, 'direct_match': True}}, 'positive_integer_zero_pattern': all(((row['channels']['symmetric']['status'] == 'zero') == (row['integer_delta'] % 2 == 0) for row in rows if row['integer_delta'] >= 2))})
+    return {'result_version': 'sabrina_ambidextrous_integer_prefactor_lattice_v1', 'status': 'complete' if all(checks.values()) else 'failed', 'paper': {'arxiv_id': '2212.00962', 'title': 'Celestial amplitudes in an ambidextrous basis'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'prefactors': 'C_s=4 pi Gamma(Delta-1) sin(pi Delta/2), C_a=4 pi i Gamma(Delta-1) cos(pi Delta/2)', 'positive_lattice': 'for integer Delta>=2 exactly one channel vanishes and the other is finite', 'nonpositive_lattice': 'at each nonpositive integer one channel has a simple pole while the complementary trigonometric zero cancels the gamma pole to a finite value', 'special_points': 'at Delta=0, C_s=-2 pi^2 and Res C_a=-4 pi i; at Delta=1, Res C_s=4 pi and C_a=-2 pi^2 i'}, 'certificate_witnesses': witnesses, 'exact_checks': checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'full_distributional_wavefunction_classified': False, 'contact_support_regularized': False, 'amplitude_residue_computed': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
+
+def _jsonable(value: Any) -> Any:
+    if isinstance(value, dict):
+        return {key: _jsonable(item) for key, item in value.items()}
+    if isinstance(value, (list, tuple)):
+        return [_jsonable(item) for item in value]
+    if isinstance(value, sp.Basic):
+        return str(value)
+    return value
+
+def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
+    if out_dir.exists():
+        raise FileExistsError(f'immutable result target already exists: {out_dir}')
+    out_dir.mkdir(parents=True)
+    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
+    report = _jsonable(build_exact_result() | {'generated_utc': generated})
+    report_path = out_dir / 'ambidextrous_integer_prefactor_lattice_report.json'
+    witness_path = out_dir / 'ambidextrous_integer_prefactor_witnesses.json'
+    handoff_path = out_dir / 'AMBIDEXTROUS_INTEGER_PREFACTOR_LATTICE_PRIVATE_HANDOFF.md'
+    manifest_path = out_dir / 'receipt_manifest.json'
+    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    witness_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'certificate_witnesses', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    handoff_path.write_text('# Ambidextrous integer-prefactor lattice - private handoff\n\nThe symmetric sine and antisymmetric cosine light-transform prefactors have a complete complementary integer-weight pattern. Positive integers select one finite channel and one zero. At nonpositive integers, a trigonometric zero cancels the gamma pole in one channel while the other retains a simple pole; Delta zero and one have explicit finite values and residues. This classifies scalar prefactors, not the complete regulated distributional wavefunctions.\n', encoding='utf-8')
+    artifacts = [report_path, witness_path, handoff_path]
+    expected = {name: value for name, (_, _, value) in SOURCE_BLOCKS.items()}
+    manifest = {'manifest_version': 'sabrina_ambidextrous_integer_prefactor_lattice_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, **expected}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    all_artifacts = [*artifacts, manifest_path]
+    ledger: Mapping[str, Any] = {'status': 'skipped'}
+    if register_ledger:
+        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
+    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
+
+def main(argv: Sequence[str] | None=None) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
+    parser.add_argument('--no-register-crystal-ledger', action='store_true')
+    args = parser.parse_args(argv)
+    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
+    print(json.dumps(result, sort_keys=True))
+    return 0 if result['status'] == 'complete' else 1
+if __name__ == '__main__':
+    raise SystemExit(main())
diff --git a/ouroboros_replay/kernels/run_sabrina_boundary_soft_scale_cocycle.py b/ouroboros_replay/kernels/run_sabrina_boundary_soft_scale_cocycle.py
new file mode 100644
index 0000000000000000000000000000000000000000..7257ead9ed9c8dbc1cdcf09b3693a0d615265f7e
--- /dev/null
+++ b/ouroboros_replay/kernels/run_sabrina_boundary_soft_scale_cocycle.py
@@ -0,0 +1,119 @@
+from __future__ import annotations
+
+from ..source_runtime import fixture_path, source_path
+import argparse
+import hashlib
+import json
+import tarfile
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Mapping, Sequence
+import sympy as sp
+from .crystal_ledger import register_crystal_artifacts
+OUT_DIR = Path('.replay_outputs') / 'out_dir'
+LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
+SOURCE_ARCHIVE = source_path('9449818f67f5ea56945c7389f382057b410a452e387ea285b0b1e23e079fbe7b')
+SOURCE_MEMBER = 'main.tex'
+SOURCE_ARCHIVE_SHA256 = '9449818f67f5ea56945c7389f382057b410a452e387ea285b0b1e23e079fbe7b'
+SOURCE_MEMBER_SHA256 = 'd3cad9e521a6d2ad3b960db2374a1c5f32ff63acf3834731be6060645718967c'
+SOURCE_BLOCKS = {'corrected_boundary_operator': (408, 445, 'd1e30b5190f5f19d6b401fd31f64ec6b51ab9f780edcbc250a6384f1fe32b223'), 'regulated_two_point_contact_term': (765, 778, '42bcaf00b7b2d4a3303653c2c936ec2699f4d588d4a7099383707417bf928184')}
+PLAN_RECEIPT_SHA256 = 'ff92d013e6af0d6e137e51c704fe14681f66d4a3e043cff3c83e56696ed08c1a'
+PLAN_GUARD_SHA256 = 'ccb7f1e849a563537ecc535e9f0f829d26ecb3b7403ad5f2bd8dc095360c9521'
+PLAN_VERIFIER_SHA256 = 'd58b44a085aadcd3f4c61d4eaa6ae0da2576f730db79d3ed84f2dc6e29b53326'
+
+def _sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+def _source_evidence() -> dict[str, Any]:
+    with tarfile.open(SOURCE_ARCHIVE, 'r:gz') as archive:
+        members = [member for member in archive.getmembers() if member.name == SOURCE_MEMBER]
+        if len(members) != 1:
+            raise ValueError(f'expected exactly one {SOURCE_MEMBER}')
+        extracted = archive.extractfile(members[0])
+        if extracted is None:
+            raise ValueError(f'unreadable source member: {SOURCE_MEMBER}')
+        member_bytes = extracted.read()
+    lines = member_bytes.decode('utf-8').splitlines()
+    texts = {name: '\n'.join(lines[start - 1:end]) + '\n' for name, (start, end, _) in SOURCE_BLOCKS.items()}
+    hashes = {name: hashlib.sha256(text.encode()).hexdigest() for name, text in texts.items()}
+    expected = {name: value for name, (_, _, value) in SOURCE_BLOCKS.items()}
+    checks = {'archive_hash_matches': _sha256(SOURCE_ARCHIVE) == SOURCE_ARCHIVE_SHA256, 'member_hash_matches': hashlib.sha256(member_bytes).hexdigest() == SOURCE_MEMBER_SHA256, 'source_blocks_match': hashes == expected, 'corrected_operator_present': texts['corrected_boundary_operator'].count('\\label{eq:corrected expression}') == 1, 'regulated_contact_correlator_present': texts['regulated_two_point_contact_term'].count('\\label{eq:newcorr}') == 1, 'contact_support_explicit': texts['regulated_two_point_contact_term'].count('\\delta^2') == 2}
+    return {'block_hashes': hashes, 'checks': checks}
+
+def scale_shift(log_scale_ratio: sp.Expr) -> sp.Expr:
+    return sp.simplify(-sp.sympify(log_scale_ratio) / (4 * sp.pi))
+
+def contact_coefficient(log_scale: sp.Expr, log_time: sp.Expr) -> sp.Expr:
+    return sp.simplify(-(sp.EulerGamma + log_scale + log_time + sp.I * sp.pi / 2) / (4 * sp.pi))
+
+def verify_scale_change(log_scale: sp.Expr, log_ratio: sp.Expr, test_value_at_contact: sp.Expr) -> dict[str, Any]:
+    before = contact_coefficient(log_scale, sp.Symbol('ell_u', real=True))
+    after = contact_coefficient(log_scale + log_ratio, sp.Symbol('ell_u', real=True))
+    difference = sp.simplify(after - before)
+    expected = scale_shift(log_ratio)
+    return {'log_scale': sp.sympify(log_scale), 'log_ratio': sp.sympify(log_ratio), 'contact_coefficient_difference': difference, 'expected_contact_shift': expected, 'distribution_action_difference': sp.simplify(difference * sp.sympify(test_value_at_contact)), 'identity': difference == expected}
+
+def certificate_witnesses() -> dict[str, Any]:
+    ratios = [sp.Rational(-3, 2), sp.Rational(-1, 3), sp.S.Zero, sp.Rational(2, 5), sp.Rational(7, 4)]
+    scale_rows = [verify_scale_change(sp.Rational(5, 7), ratio, sp.Rational(11, 13)) for ratio in ratios]
+    cocycle_rows = []
+    for first in ratios:
+        for second in ratios:
+            cocycle_rows.append({'first': first, 'second': second, 'residual': sp.simplify(scale_shift(first + second) - scale_shift(first) - scale_shift(second))})
+    contact_jets = [sp.Rational(-2), sp.S.Zero, sp.Rational(3, 5)]
+    support_rows = [{'test_value_at_contact': value, 'scale_response': sp.simplify(scale_shift(sp.Rational(4, 9)) * value)} for value in contact_jets]
+    radii_squared = [sp.Rational(1, 9), sp.Rational(2, 3), sp.Rational(7, 2)]
+    separated_rows = [{'radius_squared': radius, 'value': sp.simplify(1 / (4 * sp.pi ** 2 * radius)), 'scale_response': sp.S.Zero} for radius in radii_squared]
+    log_mu, log_u = sp.symbols('ell_mu ell_u', real=True)
+    coefficient = contact_coefficient(log_mu, log_u)
+    return {'scale_changes': scale_rows, 'cocycle_compositions': cocycle_rows, 'contact_test_jets': support_rows, 'separated_points': separated_rows, 'd_d_log_scale': sp.diff(coefficient, log_mu), 'd_d_log_time': sp.diff(coefficient, log_u), 'inverse_residuals': [sp.simplify(scale_shift(value) + scale_shift(-value)) for value in ratios]}
+
+def build_exact_result() -> dict[str, Any]:
+    source = _source_evidence()
+    witnesses = certificate_witnesses()
+    checks = dict(source['checks'])
+    checks.update({'scale_change_identity_exact': all((row['identity'] for row in witnesses['scale_changes'])), 'cocycle_composition_exact': all((row['residual'] == 0 for row in witnesses['cocycle_compositions'])), 'inverse_and_identity_exact': all((value == 0 for value in witnesses['inverse_residuals'])), 'vanishing_contact_jet_is_invariant': next((row for row in witnesses['contact_test_jets'] if row['test_value_at_contact'] == 0))['scale_response'] == 0, 'separated_points_are_invariant': all((row['scale_response'] == 0 for row in witnesses['separated_points'])), 'scale_and_time_log_derivatives_universal': witnesses['d_d_log_scale'] == witnesses['d_d_log_time'] == -1 / (4 * sp.pi)})
+    return {'result_version': 'sabrina_boundary_soft_scale_cocycle_v1', 'status': 'complete' if all(checks.values()) else 'failed', 'paper': {'arxiv_id': '2410.20296', 'title': 'A Comment on Boundary Correlators: Soft Omissions and the Massless S-Matrix'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'scale_cocycle': 'for lambda>0, G_(lambda mu)-G_mu=-(log lambda)/(4 pi) delta^2(z)', 'composition': 'the contact shifts add under successive positive rescalings and cancel under inverse rescaling', 'support': 'scale dependence acts only on the value of a test function at angular coincidence', 'invariants': 'separated-point correlators and the derivative with respect to log time separation are independent of the arbitrary scale'}, 'certificate_witnesses': witnesses, 'exact_checks': checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'coincident_correlator_regulator_independent': False, 'soft_sector_dynamics_computed': False, 'u_zero_distribution_resolved': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
+
+def _jsonable(value: Any) -> Any:
+    if isinstance(value, dict):
+        return {key: _jsonable(item) for key, item in value.items()}
+    if isinstance(value, (list, tuple)):
+        return [_jsonable(item) for item in value]
+    if isinstance(value, sp.Basic):
+        return str(value)
+    return value
+
+def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
+    if out_dir.exists():
+        raise FileExistsError(f'immutable result target already exists: {out_dir}')
+    out_dir.mkdir(parents=True)
+    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
+    report = _jsonable(build_exact_result() | {'generated_utc': generated})
+    report_path = out_dir / 'boundary_soft_scale_cocycle_report.json'
+    witness_path = out_dir / 'boundary_soft_scale_witnesses.json'
+    handoff_path = out_dir / 'BOUNDARY_SOFT_SCALE_COCYCLE_PRIVATE_HANDOFF.md'
+    manifest_path = out_dir / 'receipt_manifest.json'
+    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    witness_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'certificate_witnesses', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    handoff_path.write_text('# Boundary soft scale cocycle - private handoff\n\nThe arbitrary positive scale in the corrected boundary two-point function changes only a delta-supported contact term. The shift is an exact additive cocycle in log scale; it vanishes on test functions whose coincidence value is zero, leaves separated points unchanged, and drops out of the log-time derivative. This does not make the coincident correlator regulator independent.\n', encoding='utf-8')
+    artifacts = [report_path, witness_path, handoff_path]
+    expected = {name: value for name, (_, _, value) in SOURCE_BLOCKS.items()}
+    manifest = {'manifest_version': 'sabrina_boundary_soft_scale_cocycle_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, **expected}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    all_artifacts = [*artifacts, manifest_path]
+    ledger: Mapping[str, Any] = {'status': 'skipped'}
+    if register_ledger:
+        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
+    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
+
+def main(argv: Sequence[str] | None=None) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
+    parser.add_argument('--no-register-crystal-ledger', action='store_true')
+    args = parser.parse_args(argv)
+    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
+    print(json.dumps(result, sort_keys=True))
+    return 0 if result['status'] == 'complete' else 1
+if __name__ == '__main__':
+    raise SystemExit(main())
diff --git a/ouroboros_replay/kernels/run_sabrina_carrollian_celestial_weyl_intertwiner.py b/ouroboros_replay/kernels/run_sabrina_carrollian_celestial_weyl_intertwiner.py
new file mode 100644
index 0000000000000000000000000000000000000000..8ba0ba1d296bf647d882b81a8c5e623cdd19a961
--- /dev/null
+++ b/ouroboros_replay/kernels/run_sabrina_carrollian_celestial_weyl_intertwiner.py
@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+from ..source_runtime import fixture_path, source_path
+import argparse
+import hashlib
+import json
+import tarfile
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Mapping, Sequence
+import sympy as sp
+from .crystal_ledger import register_crystal_artifacts
+OUT_DIR = Path('.replay_outputs') / 'out_dir'
+LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
+SOURCE_ARCHIVE = source_path('917ad8f25057f1316600fb9b9afb6b6c169b1ca05ad088781a84a025a23f0d38')
+SOURCE_MEMBER = 'multiparticle_arxiv.tex'
+SOURCE_ARCHIVE_SHA256 = '917ad8f25057f1316600fb9b9afb6b6c169b1ca05ad088781a84a025a23f0d38'
+SOURCE_MEMBER_SHA256 = '2a2443a343ab2528110bacf66f32464a515ce3252fc36295895f57f9d6fb1e09'
+SOURCE_BLOCKS = {'carrollian_celestial_transform': (1024, 1048, '99b2236cb63d76c4ac4930ce950570908609b9d211e0209b82dac6ffc9871a74')}
+PLAN_RECEIPT_SHA256 = 'a1ed7a2e5071138fbdd6b5bb6d5a6a7d8752e9076eeb1e40b3d69f383798a742'
+PLAN_GUARD_SHA256 = '277f9e8d8add6919009a52fb92cacf0d7e74e3f5f91f5e92dba75bcab343eccd'
+PLAN_VERIFIER_SHA256 = 'be734e00beb584fdf2bf1bb36073882fc07771de1eac0815e15d6d4540c72576'
+
+def _sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+def _source_evidence() -> dict[str, Any]:
+    with tarfile.open(SOURCE_ARCHIVE, 'r:*') as archive:
+        extracted = archive.extractfile(SOURCE_MEMBER)
+        if extracted is None:
+            raise ValueError(f'unreadable source member: {SOURCE_MEMBER}')
+        member_bytes = extracted.read()
+    lines = member_bytes.decode('utf-8').splitlines()
+    texts = {name: '\n'.join(lines[start - 1:end]) + '\n' for name, (start, end, _) in SOURCE_BLOCKS.items()}
+    hashes = {name: hashlib.sha256(text.encode()).hexdigest() for name, text in texts.items()}
+    expected = {name: value for name, (_, _, value) in SOURCE_BLOCKS.items()}
+    block = texts['carrollian_celestial_transform']
+    checks = {'archive_hash_matches': _sha256(SOURCE_ARCHIVE) == SOURCE_ARCHIVE_SHA256, 'member_hash_matches': hashlib.sha256(member_bytes).hexdigest() == SOURCE_MEMBER_SHA256, 'source_blocks_match': hashes == expected, 'gamma_normalized_transform_present': 'Z_{k,\\bar{k}}^\\nu' in block and '\\Gamma[\\nu]\\int_{-\\infty}^\\infty du' in block, 'nu_translation_present': 'f Z_{k,\\bar{k}}^{\\nu+1}' in block, 'celestial_weight_map_present': '\\Delta = k+\\bar{k}+\\nu-1' in block}
+    return {'block_hashes': hashes, 'checks': checks}
+
+def falling_coefficient(nu: Any, m: int) -> sp.Expr:
+    if m < 0:
+        raise ValueError('m must be nonnegative')
+    value = sp.sympify(nu)
+    return sp.prod((value - index for index in range(1, m + 1)))
+
+def integration_by_parts_coefficient(nu: Any, m: int, r: int) -> sp.Expr:
+    if m < 0 or r < 0:
+        raise ValueError('m and r must be nonnegative')
+    value = sp.sympify(nu)
+    raw = sp.gamma(value) * sp.rf(value - m, r) / sp.gamma(value + r - m)
+    return sp.combsimp(raw)
+
+def shift_up(expression: sp.Expr, nu: sp.Symbol) -> sp.Expr:
+    return expression.subs(nu, nu + 1, simultaneous=True)
+
+def weighted_shift_down(expression: sp.Expr, nu: sp.Symbol) -> sp.Expr:
+    return (nu - 1) * expression.subs(nu, nu - 1, simultaneous=True)
+
+def normal_order_action(expression: sp.Expr, nu: sp.Symbol, m: int, r: int) -> sp.Expr:
+    if m < 0 or r < 0:
+        raise ValueError('m and r must be nonnegative')
+    result = expression
+    for _ in range(r):
+        result = shift_up(result, nu)
+    for _ in range(m):
+        result = weighted_shift_down(result, nu)
+    return sp.expand(result)
+
+def algebraic_certificate(max_order: int=6) -> dict[str, Any]:
+    nu = sp.symbols('nu')
+    function = sp.Function('F')
+    witness = function(nu)
+    commutator = sp.simplify(shift_up(weighted_shift_down(witness, nu), nu) - weighted_shift_down(shift_up(witness, nu), nu))
+    grid = []
+    for m in range(max_order + 1):
+        for r in range(max_order + 1):
+            coefficient_exact = sp.simplify(integration_by_parts_coefficient(nu, m, r) - falling_coefficient(nu, m)) == 0
+            closed = falling_coefficient(nu, m) * function(nu + r - m)
+            action_exact = sp.simplify(normal_order_action(witness, nu, m, r) - closed) == 0
+            grid.append({'m': m, 'r': r, 'coefficient_exact': coefficient_exact, 'action_exact': action_exact})
+    checks = {'weyl_commutator_exact': commutator == witness, 'finite_grid_coefficients_exact': all((row['coefficient_exact'] for row in grid)), 'finite_grid_actions_exact': all((row['action_exact'] for row in grid)), 'grid_complete': len(grid) == (max_order + 1) ** 2}
+    return {'dictionary': {'partial_u': 'D=T_+', 'u': 'U=(nu-1)T_-', 'normal_order': 'u^m partial_u^r -> product_(j=1)^m(nu-j) T_(r-m)'}, 'commutator': '[D,U]=1', 'grid': grid, 'checks': checks}
+
+def build_exact_result() -> dict[str, Any]:
+    source = _source_evidence()
+    algebra = algebraic_certificate()
+    checks = dict(source['checks'])
+    checks.update(algebra['checks'])
+    return {'result_version': 'sabrina_carrollian_celestial_weyl_intertwiner_v1', 'status': 'complete' if all(checks.values()) else 'failed', 'paper': {'arxiv_id': '2501.00462', 'title': 'Multiparticle States for the Flat Hologram'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'all_orders_transform': 'Z_nu[u^m partial_u^r Phi]=Gamma(nu)/Gamma(nu-m) Z_(nu+r-m)[Phi]', 'polynomial_reduction': 'Gamma(nu)/Gamma(nu-m)=product_(j=1)^m(nu-j)', 'weyl_intertwining': 'D=T_+ and U=(nu-1)T_- obey [D,U]=1', 'derivative_normalization': 'Z_nu[partial_u^r Phi]=Z_(nu+r)[Phi] with unit coefficient'}, 'algebraic_certificate': algebra, 'exact_checks': checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'vanishing_boundary_terms_required': True, 'analytic_continuation_outside_convergence_strip_required': True, 'distributional_contour_prescription_claimed': False, 'physical_null_state_interpretation_claimed': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
+
+def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
+    if out_dir.exists():
+        raise FileExistsError(f'immutable result target already exists: {out_dir}')
+    out_dir.mkdir(parents=True)
+    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
+    report = build_exact_result() | {'generated_utc': generated}
+    report_path = out_dir / 'carrollian_celestial_weyl_intertwiner_report.json'
+    witness_path = out_dir / 'carrollian_celestial_weyl_intertwiner_witnesses.json'
+    handoff_path = out_dir / 'CARROLLIAN_CELESTIAL_WEYL_INTERTWINER_PRIVATE_HANDOFF.md'
+    manifest_path = out_dir / 'receipt_manifest.json'
+    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    witness_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'algebraic_certificate', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    handoff_path.write_text('# Carrollian-celestial Weyl intertwiner - private handoff\n\nThe Gamma-normalized null-time transform sends partial_u to a unit upward Mellin shift and u to a weighted downward shift. These operators obey the Weyl commutator exactly, yielding a closed all-orders formula for every normal-ordered u^m partial_u^r. Vanishing boundary terms are required; analytic continuation is needed outside the convergence strip. No distributional-contour, physical-null-state, or publication claim is made.\n', encoding='utf-8')
+    artifacts = [report_path, witness_path, handoff_path]
+    manifest = {'manifest_version': 'sabrina_carrollian_celestial_weyl_intertwiner_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, **{name: value for name, (_, _, value) in SOURCE_BLOCKS.items()}}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    all_artifacts = [*artifacts, manifest_path]
+    ledger: Mapping[str, Any] = {'status': 'skipped'}
+    if register_ledger:
+        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
+    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
+
+def main(argv: Sequence[str] | None=None) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
+    parser.add_argument('--no-register-crystal-ledger', action='store_true')
+    args = parser.parse_args(argv)
+    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
+    print(json.dumps(result, sort_keys=True))
+    return 0 if result['status'] == 'complete' else 1
+if __name__ == '__main__':
+    raise SystemExit(main())
diff --git a/ouroboros_replay/kernels/run_sabrina_carrollian_conglomerate_kernel_stratification.py b/ouroboros_replay/kernels/run_sabrina_carrollian_conglomerate_kernel_stratification.py
new file mode 100644
index 0000000000000000000000000000000000000000..c57f0b9fcf226a47650f4209450fb4fb697f3a8a
--- /dev/null
+++ b/ouroboros_replay/kernels/run_sabrina_carrollian_conglomerate_kernel_stratification.py
@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+from ..source_runtime import fixture_path, source_path
+import argparse
+import hashlib
+import json
+import tarfile
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Mapping, Sequence
+import sympy as sp
+from .crystal_ledger import register_crystal_artifacts
+OUT_DIR = Path('.replay_outputs') / 'out_dir'
+LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
+SOURCE_ARCHIVE = source_path('917ad8f25057f1316600fb9b9afb6b6c169b1ca05ad088781a84a025a23f0d38')
+SOURCE_MEMBER = 'multiparticle_arxiv.tex'
+SOURCE_ARCHIVE_SHA256 = '917ad8f25057f1316600fb9b9afb6b6c169b1ca05ad088781a84a025a23f0d38'
+SOURCE_MEMBER_SHA256 = '2a2443a343ab2528110bacf66f32464a515ce3252fc36295895f57f9d6fb1e09'
+SOURCE_BLOCKS = {'conglomerate_coefficient_system': (976, 999, 'c505de34f3e7cce7148daa0c0951bdbd1bbc60c53945ea22cdda08b86c1d8e04')}
+PLAN_RECEIPT_SHA256 = '32b0950b397ae79514ba75db89674aa6456a763caedc4d8554f9e0f804c40ba5'
+PLAN_GUARD_SHA256 = 'e2810edf38646740ff67c075170a468d77487eaa6b72c562f1ba554d08558354'
+PLAN_VERIFIER_SHA256 = '7a08f0f22879eff4e7a4224219867e85ea6642c0871ab6e9f73bd343db95b9da'
+
+def _sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+def _source_evidence() -> dict[str, Any]:
+    with tarfile.open(SOURCE_ARCHIVE, 'r:*') as archive:
+        extracted = archive.extractfile(SOURCE_MEMBER)
+        if extracted is None:
+            raise ValueError(f'unreadable source member: {SOURCE_MEMBER}')
+        member_bytes = extracted.read()
+    lines = member_bytes.decode('utf-8').splitlines()
+    texts = {name: '\n'.join(lines[start - 1:end]) + '\n' for name, (start, end, _) in SOURCE_BLOCKS.items()}
+    hashes = {name: hashlib.sha256(text.encode()).hexdigest() for name, text in texts.items()}
+    expected = {name: value for name, (_, _, value) in SOURCE_BLOCKS.items()}
+    block = texts['conglomerate_coefficient_system']
+    checks = {'archive_hash_matches': _sha256(SOURCE_ARCHIVE) == SOURCE_ARCHIVE_SHA256, 'member_hash_matches': hashlib.sha256(member_bytes).hexdigest() == SOURCE_MEMBER_SHA256, 'source_blocks_match': hashes == expected, 'four_coefficient_operator_present': 'O(\\alpha_1,\\alpha_2,\\alpha_3,\\alpha_4)' in block, 'both_lorentz_constraints_present': 'L_1 O(\\{\\alpha_i\\})' in block and '\\bar{L}_1 O(\\{\\alpha_i\\})' in block, 'published_kernel_vector_present': 'O(k_2 \\bar{k}_2, -\\bar{k}_1 k_2, -k_1 \\bar{k}_2, k_1 \\bar{k}_1)' in block}
+    return {'block_hashes': hashes, 'checks': checks}
+
+def constraint_matrix(k1: Any, k2: Any, bar_k1: Any, bar_k2: Any) -> sp.Matrix:
+    a, b, c, d = map(sp.sympify, (k1, k2, bar_k1, bar_k2))
+    return sp.Matrix([[a, 0, b, 0], [0, a, 0, b], [c, d, 0, 0], [0, 0, c, d]])
+
+def published_kernel_vector(k1: Any, k2: Any, bar_k1: Any, bar_k2: Any) -> sp.Matrix:
+    a, b, c, d = map(sp.sympify, (k1, k2, bar_k1, bar_k2))
+    return sp.Matrix([b * d, -b * c, -a * d, a * c])
+
+def _pair_is_zero(first: sp.Expr, second: sp.Expr) -> bool:
+    return sp.simplify(first) == 0 and sp.simplify(second) == 0
+
+def kernel_basis(k1: Any, k2: Any, bar_k1: Any, bar_k2: Any) -> list[sp.Matrix]:
+    a, b, c, d = map(sp.sympify, (k1, k2, bar_k1, bar_k2))
+    left_zero = _pair_is_zero(a, b)
+    right_zero = _pair_is_zero(c, d)
+    if not left_zero and (not right_zero):
+        return [published_kernel_vector(a, b, c, d)]
+    if left_zero and (not right_zero):
+        return [sp.Matrix([d, -c, 0, 0]), sp.Matrix([0, 0, d, -c])]
+    if not left_zero and right_zero:
+        return [sp.Matrix([b, 0, -a, 0]), sp.Matrix([0, b, 0, -a])]
+    return [sp.eye(4).col(index) for index in range(4)]
+
+def algebraic_certificate() -> dict[str, Any]:
+    a, b, c, d, x1, x2, x3, x4 = sp.symbols('a b c d x1 x2 x3 x4')
+    matrix = constraint_matrix(a, b, c, d)
+    vector = sp.Matrix([x1, x2, x3, x4])
+    coefficient_array = sp.Matrix([[x1, x2], [x3, x4]])
+    row = sp.Matrix([[a, b]])
+    column = sp.Matrix([c, d])
+    factorized = sp.Matrix(list(row * coefficient_array) + list(coefficient_array * column))
+    generic = published_kernel_vector(a, b, c, d)
+    outer = sp.Matrix([b, -a]) * sp.Matrix([[d, -c]])
+    left_boundary = [sp.Matrix([d, -c, 0, 0]), sp.Matrix([0, 0, d, -c])]
+    right_boundary = [sp.Matrix([b, 0, -a, 0]), sp.Matrix([0, b, 0, -a])]
+    strata = [{'left_pair_rank': 1, 'right_pair_rank': 1, 'constraint_rank': 3, 'nullity': 1}, {'left_pair_rank': 0, 'right_pair_rank': 1, 'constraint_rank': 2, 'nullity': 2}, {'left_pair_rank': 1, 'right_pair_rank': 0, 'constraint_rank': 2, 'nullity': 2}, {'left_pair_rank': 0, 'right_pair_rank': 0, 'constraint_rank': 0, 'nullity': 4}]
+    checks = {'constraint_factorization_exact': matrix * vector == factorized, 'generic_outer_product_exact': generic == sp.Matrix(list(outer)), 'generic_kernel_identity_exact': matrix * generic == sp.zeros(4, 1), 'left_boundary_basis_exact': all((constraint_matrix(0, 0, c, d) * item == sp.zeros(4, 1) for item in left_boundary)), 'right_boundary_basis_exact': all((constraint_matrix(a, b, 0, 0) * item == sp.zeros(4, 1) for item in right_boundary)), 'rank_nullity_formula_exhaustive': all((row_['nullity'] == (2 - row_['left_pair_rank']) * (2 - row_['right_pair_rank']) and row_['constraint_rank'] == 4 - row_['nullity'] for row_ in strata))}
+    return {'matrix': [[str(item) for item in row_] for row_ in matrix.tolist()], 'factorization': 'A(alpha)=0 iff (k1,k2)X=0 and X(bar_k1,bar_k2)^T=0', 'kernel_isomorphism': 'ker(A) is Hom(C^2/span(bar_k), ker(k))', 'generic_generator': [str(item) for item in generic], 'strata': strata, 'checks': checks}
+
+def build_exact_result() -> dict[str, Any]:
+    source = _source_evidence()
+    algebra = algebraic_certificate()
+    checks = dict(source['checks'])
+    checks.update(algebra['checks'])
+    return {'result_version': 'sabrina_carrollian_conglomerate_kernel_stratification_v1', 'status': 'complete' if all(checks.values()) else 'failed', 'paper': {'arxiv_id': '2501.00462', 'title': 'Multiparticle States for the Flat Hologram'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'generic_locus': 'the published coefficient vector spans the kernel exactly when both chiral weight pairs are nonzero', 'boundary_locus': 'if exactly one chiral pair vanishes the kernel is two-dimensional; if both vanish it is four-dimensional', 'precise_correction': 'the scalar-multiple uniqueness statement requires the nonzero-pair hypothesis'}, 'algebraic_certificate': algebra, 'exact_checks': checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'physical_admissibility_of_zero_weight_strata_claimed': False, 'null_state_quotient_claimed': False, 'interacting_spectrum_claimed': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
+
+def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
+    if out_dir.exists():
+        raise FileExistsError(f'immutable result target already exists: {out_dir}')
+    out_dir.mkdir(parents=True)
+    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
+    report = build_exact_result() | {'generated_utc': generated}
+    report_path = out_dir / 'carrollian_conglomerate_kernel_stratification_report.json'
+    witness_path = out_dir / 'carrollian_conglomerate_kernel_stratification_witnesses.json'
+    handoff_path = out_dir / 'CARROLLIAN_CONGLOMERATE_KERNEL_STRATIFICATION_PRIVATE_HANDOFF.md'
+    manifest_path = out_dir / 'receipt_manifest.json'
+    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    witness_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'algebraic_certificate', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    handoff_path.write_text('# Carrollian conglomerate kernel stratification - private handoff\n\nThe four Lorentz-primary coefficient equations factor as a two-sided annihilation problem for a 2x2 coefficient matrix. The published vector is the unique generator only when both chiral weight pairs are nonzero. If one pair vanishes, the kernel has dimension two; if both vanish, it has dimension four. This is an exact domain completion of the stated scalar-multiple uniqueness result. No claim about physical admissibility, null-state quotients, interacting spectra, or publication is made.\n', encoding='utf-8')
+    artifacts = [report_path, witness_path, handoff_path]
+    manifest = {'manifest_version': 'sabrina_carrollian_conglomerate_kernel_stratification_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, **{name: value for name, (_, _, value) in SOURCE_BLOCKS.items()}}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    all_artifacts = [*artifacts, manifest_path]
+    ledger: Mapping[str, Any] = {'status': 'skipped'}
+    if register_ledger:
+        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
+    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
+
+def main(argv: Sequence[str] | None=None) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
+    parser.add_argument('--no-register-crystal-ledger', action='store_true')
+    args = parser.parse_args(argv)
+    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
+    print(json.dumps(result, sort_keys=True))
+    return 0 if result['status'] == 'complete' else 1
+if __name__ == '__main__':
+    raise SystemExit(main())
diff --git a/ouroboros_replay/kernels/run_sabrina_causal_interior_inclusion_lemma.py b/ouroboros_replay/kernels/run_sabrina_causal_interior_inclusion_lemma.py
new file mode 100644
index 0000000000000000000000000000000000000000..721921c1a7ef02d34fc07e5ed95fd61f964208a5
--- /dev/null
+++ b/ouroboros_replay/kernels/run_sabrina_causal_interior_inclusion_lemma.py
@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+from ..source_runtime import fixture_path, source_path
+import argparse
+import hashlib
+import json
+import tarfile
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Mapping, Sequence
+from .crystal_ledger import register_crystal_artifacts
+OUT_DIR = Path('.replay_outputs') / 'out_dir'
+LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
+SOURCE_ARCHIVE = source_path('17edb31380f6f0e8856d0f3541a36ab4a6023551894698a45dbf44e7a37991e0')
+SOURCE_MEMBER = 'main.tex'
+SOURCE_ARCHIVE_SHA256 = '17edb31380f6f0e8856d0f3541a36ab4a6023551894698a45dbf44e7a37991e0'
+SOURCE_MEMBER_SHA256 = '0a4c40bb1e3e38c2da8a3c2ad0ced1f39e9071d9c9ec31dcab1ffd848f4ee9cb'
+SOURCE_BLOCKS = {'connected_wedge_interior_step': (395, 405, '0acd2ad7d5f826b3491f5a93434815a10221b0c36a1e3d3ba717f8a5032bd280'), 'iff_summary': (600, 608, 'b3c1294ca9af051db3b58680b34f87e19b3321c273f3196054d1e1532e65a0bc'), 'future_directions': (641, 650, '991b34fb34ee0d068b2e68a8486d9ee42faca7752e729f0e2defa0f5d90e54e5')}
+PLAN_RECEIPT_SHA256 = 'e9cc5aea8bb92c5b51a96ba2d766d732b1a17ac3c6f1b4a703c8555bec92f746'
+PLAN_GUARD_SHA256 = '583a3db54362d030a62f0534f402c94b5ba7bb128844db01d89c4fac657d33ab'
+PLAN_VERIFIER_SHA256 = '77586ae915e76447da999738eb3afe6c8de7c82e2786adafe6cd8a53b549d9e3'
+
+def _sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+def _source_evidence() -> dict[str, Any]:
+    with tarfile.open(SOURCE_ARCHIVE, 'r:gz') as archive:
+        members = [member for member in archive.getmembers() if member.name == SOURCE_MEMBER]
+        if len(members) != 1:
+            raise ValueError(f'expected exactly one {SOURCE_MEMBER}')
+        extracted = archive.extractfile(members[0])
+        if extracted is None:
+            raise ValueError(f'unreadable source member: {SOURCE_MEMBER}')
+        member_bytes = extracted.read()
+    lines = member_bytes.decode('utf-8').splitlines()
+    block_texts = {name: '\n'.join(lines[start - 1:end]) + '\n' for name, (start, end, _) in SOURCE_BLOCKS.items()}
+    block_hashes = {name: hashlib.sha256(text.encode()).hexdigest() for name, text in block_texts.items()}
+    expected = {name: expected_hash for name, (_, _, expected_hash) in SOURCE_BLOCKS.items()}
+    checks = {'archive_hash_matches': _sha256(SOURCE_ARCHIVE) == SOURCE_ARCHIVE_SHA256, 'member_hash_matches': hashlib.sha256(member_bytes).hexdigest() == SOURCE_MEMBER_SHA256, 'source_blocks_match': block_hashes == expected, 'expected_inclusion_occurs_once': block_texts['connected_wedge_interior_step'].count('we expect that for regions') == 1, 'expected_boundary_use_occurs_once': block_texts['connected_wedge_interior_step'].count("can't intersect") == 1, 'iff_statement_present': block_texts['iff_summary'].count('\\iff') == 1}
+    return {'block_hashes': block_hashes, 'checks': checks}
+
+def relation_certificate() -> dict[str, Any]:
+    checked = 0
+    violations: list[dict[str, Any]] = []
+    per_size: dict[str, int] = {}
+    for size in range(3, 9):
+        universe = set(range(size))
+        size_checked = 0
+        for b_mask in range(1, 1 << size):
+            b_set = {point for point in universe if b_mask & 1 << point}
+            for a_mask in range(1 << size):
+                a_set = {point for point in universe if a_mask & 1 << point}
+                if not a_set <= b_set:
+                    continue
+                has_two_sided_buffer = all((any((b < a for b in b_set)) and any((a < b for b in b_set)) for a in a_set))
+                if not has_two_sided_buffer:
+                    continue
+                causal_future_a = {y for y in universe if any((a <= y for a in a_set))}
+                chronological_future_b = {y for y in universe if any((b < y for b in b_set))}
+                causal_past_a = {y for y in universe if any((y <= a for a in a_set))}
+                chronological_past_b = {y for y in universe if any((y < b for b in b_set))}
+                checked += 1
+                size_checked += 1
+                if not causal_future_a <= chronological_future_b or not causal_past_a <= chronological_past_b:
+                    violations.append({'size': size, 'a_mask': a_mask, 'b_mask': b_mask})
+        per_size[str(size)] = size_checked
+    universe = {0, 1, 2}
+    a_set = b_set = {1}
+    causal_future = {y for y in universe if any((a <= y for a in a_set))}
+    chronological_future = {y for y in universe if any((b < y for b in b_set))}
+    causal_past = {y for y in universe if any((y <= a for a in a_set))}
+    chronological_past = {y for y in universe if any((y < b for b in b_set))}
+    return {'finite_chain_models_checked': checked, 'models_per_size': per_size, 'violation_count': len(violations), 'violations': violations, 'dropped_interior_countermodel': {'universe': sorted(universe), 'A_equals_B': sorted(a_set), 'future_missing_points': sorted(causal_future - chronological_future), 'past_missing_points': sorted(causal_past - chronological_past), 'both_inclusions_fail': not causal_future <= chronological_future and (not causal_past <= chronological_past)}}
+
+def build_exact_result() -> dict[str, Any]:
+    source = _source_evidence()
+    certificate = relation_certificate()
+    checks = dict(source['checks'])
+    checks.update({'finite_push_up_models_nonempty': certificate['finite_chain_models_checked'] > 0, 'finite_push_up_models_all_pass': certificate['violation_count'] == 0, 'dropping_interior_has_countermodel': certificate['dropped_interior_countermodel']['both_inclusions_fail'], 'countermodel_failure_is_reflexive_point': certificate['dropped_interior_countermodel']['future_missing_points'] == [1] and certificate['dropped_interior_countermodel']['past_missing_points'] == [1]})
+    return {'result_version': 'sabrina_causal_interior_inclusion_lemma_v1', 'status': 'complete' if all(checks.values()) else 'failed', 'paper': {'arxiv_id': '2509.26264', 'title': 'On sufficient conditions for holographic scattering'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'hypotheses': 'M is a time-oriented spacetime and A is a subset of the manifold interior of B', 'future': 'J^+(A) is contained in I^+(B), hence in the interior of J^+(B)', 'past': 'J^-(A) is contained in I^-(B), hence in the interior of J^-(B)', 'proof': 'for a in A choose b_- << a and b_+ >> a inside B; push-up gives b_- << y from a <= y and y << b_+ from y <= a', 'boundary_corollary': 'if J^+(A) (respectively J^-(A)) is closed, then its boundary lies in that causal set and is disjoint from the boundary of J^+(B) (respectively J^-(B))'}, 'relation_certificate': certificate, 'exact_checks': checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'conformal_boundary_extension_proved': False, 'closedness_automatic_without_causal_assumption': False, 'full_connected_wedge_theorem_reproved': False, 'n_to_n_extension_proved': False, 'mixed_state_extension_proved': False, 'source_error_claimed': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
+
+def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
+    if out_dir.exists():
+        raise FileExistsError(f'immutable result target already exists: {out_dir}')
+    out_dir.mkdir(parents=True)
+    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
+    report = build_exact_result() | {'generated_utc': generated}
+    report_path = out_dir / 'causal_interior_inclusion_report.json'
+    certificate_path = out_dir / 'causal_interior_relation_certificate.json'
+    handoff_path = out_dir / 'CAUSAL_INTERIOR_INCLUSION_PRIVATE_HANDOFF.md'
+    manifest_path = out_dir / 'receipt_manifest.json'
+    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    certificate_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'relation_certificate', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    handoff_path.write_text('# Causal-interior inclusion lemma - private handoff\n\nThe causal inclusion expected in arXiv:2509.26264 follows from a local timelike perturbation and the push-up lemma: $A\\subset\\operatorname{int}B$ implies $J^\\pm(A)\\subset I^\\pm(B)\\subset\\operatorname{int}J^\\pm(B)$. The boundary-disjointness step additionally needs the relevant $J^\\pm(A)$ to be closed, as in causally simple settings. No conformal-boundary or full connected-wedge extension is claimed.\n', encoding='utf-8')
+    artifacts = [report_path, certificate_path, handoff_path]
+    manifest = {'manifest_version': 'sabrina_causal_interior_inclusion_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, **{name: expected for name, (_, _, expected) in SOURCE_BLOCKS.items()}}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    all_artifacts = [*artifacts, manifest_path]
+    ledger: Mapping[str, Any] = {'status': 'skipped'}
+    if register_ledger:
+        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
+    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
+
+def main(argv: Sequence[str] | None=None) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
+    parser.add_argument('--no-register-crystal-ledger', action='store_true')
+    args = parser.parse_args(argv)
+    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
+    print(json.dumps(result, sort_keys=True))
+    return 0 if result['status'] == 'complete' else 1
+if __name__ == '__main__':
+    raise SystemExit(main())
diff --git a/ouroboros_replay/kernels/run_sabrina_cdqs_amplification_singleton_obstruction.py b/ouroboros_replay/kernels/run_sabrina_cdqs_amplification_singleton_obstruction.py
new file mode 100644
index 0000000000000000000000000000000000000000..85ab22af98e99976c018caf2fc55357d0e88d891
--- /dev/null
+++ b/ouroboros_replay/kernels/run_sabrina_cdqs_amplification_singleton_obstruction.py
@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+from ..source_runtime import fixture_path, source_path
+import argparse
+import hashlib
+import json
+import math
+import tarfile
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Mapping, Sequence
+import sympy as sp
+from .crystal_ledger import register_crystal_artifacts
+OUT_DIR = Path('.replay_outputs') / 'out_dir'
+LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
+SOURCE_ARCHIVE = source_path('cbeaadef653abc7c51e2c763ac8c01ae7628c881c294903e367361e2704ac3c8')
+SOURCE_MEMBER = 'main.tex'
+SOURCE_ARCHIVE_SHA256 = 'cbeaadef653abc7c51e2c763ac8c01ae7628c881c294903e367361e2704ac3c8'
+SOURCE_MEMBER_SHA256 = '8e992c4195a75419859c17fadfa62b8e646a9056de804fc2e0334ac21d0a1ac0'
+SOURCE_BLOCKS = {'good_code_claim': (824, 850, '69d0d37947b1286a3d03d6d4fb907b51ffd7c81748e2152a3fdfa37ee991873f'), 'routing_amplification_proof': (853, 881, '7a1fc06464b25f40ce6c5a4414c75cf0edcd20527c10937c07b5143746abed85'), 'cdqs_amplification_statement': (883, 893, '605c5df3fe268dcc4550521c2355e154c88ce950d1e19861e9d3ee589f7aafc9'), 'discussion_scope': (1346, 1367, 'd1ccd56634eb89812a8c42d9c36ddda4de7f5cb6047be60e9d78048aadb5f48b')}
+PLAN_RECEIPT_SHA256 = 'c40c31da8d05f589579d03e757abe0ed25095691e7bdd91d0d48004ab7f39586'
+PLAN_GUARD_SHA256 = '3316029ae817855ec4a48cb278915d2721117fb8af7304d558afed629d9e4599'
+PLAN_VERIFIER_SHA256 = '4d74f74c2b8abe6d270f508c3c44757fbf1f0e7215658a9a8fe1ce5cb107cbb2'
+
+def _sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+def _source_evidence() -> dict[str, Any]:
+    with tarfile.open(SOURCE_ARCHIVE, 'r:gz') as archive:
+        members = [member for member in archive.getmembers() if member.name == SOURCE_MEMBER]
+        if len(members) != 1:
+            raise ValueError(f'expected exactly one {SOURCE_MEMBER}')
+        extracted = archive.extractfile(members[0])
+        if extracted is None:
+            raise ValueError(f'unreadable source member: {SOURCE_MEMBER}')
+        member_bytes = extracted.read()
+    lines = member_bytes.decode('utf-8').splitlines()
+    block_texts = {name: '\n'.join(lines[start - 1:end]) + '\n' for name, (start, end, _) in SOURCE_BLOCKS.items()}
+    block_hashes = {name: hashlib.sha256(text.encode()).hexdigest() for name, text in block_texts.items()}
+    expected = {name: expected_hash for name, (_, _, expected_hash) in SOURCE_BLOCKS.items()}
+    proof = block_texts['routing_amplification_proof']
+    checks = {'archive_hash_matches': _sha256(SOURCE_ARCHIVE) == SOURCE_ARCHIVE_SHA256, 'member_hash_matches': hashlib.sha256(member_bytes).hexdigest() == SOURCE_MEMBER_SHA256, 'source_blocks_match': block_hashes == expected, 'arbitrary_error_claim_present': block_texts['good_code_claim'].count('correcting arbitrary errors on $t<m/2$ qubits') == 1, 'chosen_alpha_repeated_consistently': proof.count('\\alpha = 0.495') == 2, 'chosen_beta_present': proof.count('\\beta \\approx 0.838') == 1, 'base_error_present': proof.count('\\epsilon = 0.09') == 1, 'claimed_gamma_present': proof.count('\\gamma \\approx 5.5 \\times 10^{-3}') == 1}
+    return {'block_hashes': block_hashes, 'checks': checks}
+
+def obstruction_certificate() -> dict[str, Any]:
+    alpha = sp.Rational(99, 200)
+    epsilon = sp.Rational(9, 100)
+
+    def h2(value: sp.Expr) -> sp.Expr:
+        return -value * sp.log(value, 2) - (1 - value) * sp.log(1 - value, 2)
+    claimed_beta = sp.simplify(1 - 2 * h2(2 * alpha))
+    singleton_rate_ceiling = sp.simplify(1 - 4 * alpha)
+    chosen_exponent = sp.simplify(h2(alpha) + alpha * sp.log(sp.E * epsilon, 2))
+    endpoint = sp.Rational(1, 4)
+    feasible_endpoint_exponent = sp.simplify(h2(endpoint) + endpoint * sp.log(sp.E * epsilon, 2))
+    endpoint_positive_equivalent = sp.simplify(256 * sp.E > 300)
+    critical_epsilon = sp.simplify(2 ** (-4 * h2(endpoint)) / sp.E)
+    witnesses = []
+    for numerator in range(1, 251):
+        value = numerator / 1000.0
+        entropy = -value * math.log2(value) - (1.0 - value) * math.log2(1.0 - value)
+        exponent = entropy + value * math.log2(math.e * 0.09)
+        witnesses.append({'alpha': f'{value:.3f}', 'exponent': f'{exponent:.17g}', 'positive': exponent > 0.0, 'iid_theorem_threshold_met': 0.09 < value / (1.0 - value)})
+    return {'quantum_singleton': {'statement': 'for an [[m,k,d]] code, k+2(d-1)<=m; correcting arbitrary t-qubit errors needs d>=2t+1, hence k<=m-4t', 'primary_reference': 'https://arxiv.org/abs/2010.07902', 'chosen_alpha': str(alpha), 'claimed_beta': str(claimed_beta), 'claimed_beta_decimal': str(sp.N(claimed_beta, 12)), 'singleton_rate_ceiling': str(singleton_rate_ceiling), 'chosen_parameters_impossible': bool(claimed_beta > singleton_rate_ceiling)}, 'iid_bound_exponent': {'definition': 'q_epsilon(alpha)=H2(alpha)+alpha log2(e epsilon); exponential decay from the cited estimate requires q_epsilon(alpha)<0', 'chosen_alpha_exponent': str(chosen_exponent), 'chosen_alpha_would_decay': bool(sp.N(chosen_exponent, 60) < 0), 'singleton_feasible_interval': '0<alpha<=1/4', 'endpoint_exponent': str(feasible_endpoint_exponent), 'endpoint_positive': bool(sp.N(feasible_endpoint_exponent, 60) > 0), 'endpoint_sign_equivalent_to_256e_gt_300': bool(endpoint_positive_equivalent), 'concavity_argument': 'q is concave, q(0)=0, and q(1/4)>0, so q(alpha)>0 throughout 0<alpha<=1/4', 'critical_base_error_at_zero_rate_boundary': str(critical_epsilon), 'critical_base_error_decimal': str(sp.N(critical_epsilon, 12)), 'base_error_above_critical': bool(epsilon > critical_epsilon)}, 'rational_feasible_witness_count': len(witnesses), 'rational_feasible_witness_failures': [row for row in witnesses if not row['positive']], 'threshold_applicable_witness_count': sum((row['iid_theorem_threshold_met'] for row in witnesses))}
+
+def build_exact_result() -> dict[str, Any]:
+    source = _source_evidence()
+    certificate = obstruction_certificate()
+    singleton = certificate['quantum_singleton']
+    exponent = certificate['iid_bound_exponent']
+    checks = dict(source['checks'])
+    checks.update({'chosen_code_violates_singleton': singleton['chosen_parameters_impossible'], 'formal_chosen_exponent_is_negative': exponent['chosen_alpha_would_decay'], 'feasible_endpoint_exponent_positive': exponent['endpoint_positive'], 'endpoint_sign_reduced_exactly': exponent['endpoint_sign_equivalent_to_256e_gt_300'], 'base_error_exceeds_feasible_critical_value': exponent['base_error_above_critical'], 'dense_feasible_interval_all_positive': certificate['rational_feasible_witness_count'] == 250 and (not certificate['rational_feasible_witness_failures']), 'iid_threshold_has_nonempty_feasible_overlap': certificate['threshold_applicable_witness_count'] > 0})
+    return {'result_version': 'sabrina_cdqs_amplification_singleton_obstruction_v1', 'status': 'complete' if all(checks.values()) else 'failed', 'paper': {'arxiv_id': '2404.14491', 'title': 'Conditional disclosure of secrets with quantum resources'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'result': {'singleton_obstruction': 'the alpha=0.495, beta approximately 0.838 code used in the proof cannot correct arbitrary t-qubit errors', 'exponent_obstruction': 'after enforcing alpha<=1/4, the cited i.i.d. bound has positive rather than negative asymptotic exponent at epsilon=0.09', 'repair_classes': ['first reduce the one-qubit base error below the feasible coding threshold', 'replace the cited arbitrary-error code/i.i.d. estimate with a compatible threshold theorem', 'supply a different amplification construction not requiring the inconsistent parameters']}, 'obstruction_certificate': certificate, 'exact_checks': checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'amplification_impossible_by_all_methods': False, 'cdqs_amplification_theorem_disproved': False, 'corrected_amplification_constructed': False, 'external_primary_source_locally_hash_pinned': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
+
+def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
+    if out_dir.exists():
+        raise FileExistsError(f'immutable result target already exists: {out_dir}')
+    out_dir.mkdir(parents=True)
+    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
+    report = build_exact_result() | {'generated_utc': generated}
+    report_path = out_dir / 'cdqs_amplification_singleton_obstruction_report.json'
+    certificate_path = out_dir / 'cdqs_amplification_singleton_certificate.json'
+    handoff_path = out_dir / 'CDQS_AMPLIFICATION_SINGLETON_PRIVATE_HANDOFF.md'
+    manifest_path = out_dir / 'receipt_manifest.json'
+    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    certificate_path.write_text(json.dumps({key: report[key] for key in ('result', 'obstruction_certificate', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    handoff_path.write_text("# CDQS amplification Singleton obstruction - private handoff\n\nThe amplification proof's $t=0.495m$, positive-rate arbitrary-error code violates the quantum Singleton bound $k\\leq m-4t$. Enforcing the feasible range $t/m\\leq1/4$ also makes the cited i.i.d. estimate grow rather than decay at base error $0.09$. This identifies a proof-path obstruction and repair requirements; it does not show that CDQS amplification is impossible by another construction.\n", encoding='utf-8')
+    artifacts = [report_path, certificate_path, handoff_path]
+    manifest = {'manifest_version': 'sabrina_cdqs_amplification_singleton_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, **{name: expected for name, (_, _, expected) in SOURCE_BLOCKS.items()}}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    all_artifacts = [*artifacts, manifest_path]
+    ledger: Mapping[str, Any] = {'status': 'skipped'}
+    if register_ledger:
+        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
+    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
+
+def main(argv: Sequence[str] | None=None) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
+    parser.add_argument('--no-register-crystal-ledger', action='store_true')
+    args = parser.parse_args(argv)
+    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
+    print(json.dumps(result, sort_keys=True))
+    return 0 if result['status'] == 'complete' else 1
+if __name__ == '__main__':
+    raise SystemExit(main())
diff --git a/ouroboros_replay/kernels/run_sabrina_cdqs_fidelity_envelope_strengthening.py b/ouroboros_replay/kernels/run_sabrina_cdqs_fidelity_envelope_strengthening.py
new file mode 100644
index 0000000000000000000000000000000000000000..08a97c578c31611ea9a0a106b00062179d3929d7
--- /dev/null
+++ b/ouroboros_replay/kernels/run_sabrina_cdqs_fidelity_envelope_strengthening.py
@@ -0,0 +1,104 @@
+from __future__ import annotations
+
+from ..source_runtime import fixture_path, source_path
+import argparse
+import hashlib
+import json
+import tarfile
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Mapping, Sequence
+import sympy as sp
+from .crystal_ledger import register_crystal_artifacts
+OUT_DIR = Path('.replay_outputs') / 'out_dir'
+LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
+SOURCE_ARCHIVE = source_path('8baa6e7011dca7bf30ffdbe423d39c14f931ba65ff1dcaa8ead4afc0137c545a')
+SOURCE_MEMBER = 'main.tex'
+SOURCE_ARCHIVE_SHA256 = '8baa6e7011dca7bf30ffdbe423d39c14f931ba65ff1dcaa8ead4afc0137c545a'
+SOURCE_MEMBER_SHA256 = 'e3d17f1c009c436fd22ace55f64c97e34c509fcf9ce47b395d3fadf719885d7d'
+SOURCE_BLOCKS = {'stated_cdqs_bound': (804, 814, '9d38eccf29047e3b3f7da055d1c5249e3133e020a655cde20db8aaf4b1b772c4'), 'fidelity_to_information_proof': (850, 890, '55529d90ddbc233f0fb3fa8d26e7cf6be3bea23729a93a2f86178592e7f08e18'), 'alpha_future_direction': (1882, 1890, 'e915cd5863088a3df1ed4b46305f283db0f3c2975567c7ba77c5ded483a44017')}
+PLAN_RECEIPT_SHA256 = '461bc1d3bde2484b0a0a0234c33215ab377e599bde91e30a1fb86c5a5d30febb'
+PLAN_GUARD_SHA256 = '1862aefc00bfd922804c51fd0555690a5cffd3127b1e460158743fbf8f666b55'
+PLAN_VERIFIER_SHA256 = 'd0f73d8c651feea144469aee8c0b5445131e29fa27bd7a5f3d2f8b8984304f24'
+
+def _sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+def _source_evidence() -> dict[str, Any]:
+    with tarfile.open(SOURCE_ARCHIVE, 'r:gz') as archive:
+        members = [member for member in archive.getmembers() if member.name == SOURCE_MEMBER]
+        if len(members) != 1:
+            raise ValueError(f'expected exactly one {SOURCE_MEMBER}')
+        extracted = archive.extractfile(members[0])
+        if extracted is None:
+            raise ValueError(f'unreadable source member: {SOURCE_MEMBER}')
+        member_bytes = extracted.read()
+    lines = member_bytes.decode('utf-8').splitlines()
+    block_texts = {name: '\n'.join(lines[start - 1:end]) + '\n' for name, (start, end, _) in SOURCE_BLOCKS.items()}
+    block_hashes = {name: hashlib.sha256(text.encode()).hexdigest() for name, text in block_texts.items()}
+    expected = {name: expected_hash for name, (_, _, expected_hash) in SOURCE_BLOCKS.items()}
+    proof = block_texts['fidelity_to_information_proof']
+    checks = {'archive_hash_matches': _sha256(SOURCE_ARCHIVE) == SOURCE_ARCHIVE_SHA256, 'member_hash_matches': hashlib.sha256(member_bytes).hexdigest() == SOURCE_MEMBER_SHA256, 'source_blocks_match': block_hashes == expected, 'stated_bound_label_unique': block_texts['stated_cdqs_bound'].count('\\label{thm:CDSlowerbound}') == 1, 'fidelity_cap_present': proof.count('F(\\Psi_{AB},\\Psi_A\\otimes \\Psi_B) \\leq 2') == 1, 'relative_entropy_factor_two_present': proof.count('I(A:B)_{\\Psi} \\geq -2\\ln F') == 1, 'future_direction_names_log_delta': block_texts['alpha_future_direction'].count('-\\ln \\delta') == 1}
+    return {'block_hashes': block_hashes, 'checks': checks}
+
+def envelope_certificate() -> dict[str, Any]:
+    a = sp.symbols('a', positive=True)
+    paper_bound = -sp.log(a) - 1
+    active_bound = -2 * sp.log(2 * a)
+    active_difference = sp.expand_log(active_bound - paper_bound, force=True)
+    threshold_order = bool(sp.N(1 / sp.E, 50) < sp.Rational(1, 2))
+    margin_floor = 2 - 2 * sp.log(2)
+    witnesses = []
+    for numerator in range(1, 401):
+        value = sp.Rational(numerator, 200)
+        strengthened = sp.Max(0, -2 * sp.log(2 * value))
+        displayed = paper_bound.subs(a, value)
+        witnesses.append({'a': str(value), 'branch': 'active' if value < sp.Rational(1, 2) else 'zero', 'strictly_dominates': bool(sp.N(strengthened - displayed, 50) > 0)})
+    parameter_witnesses = []
+    for d_q, delta, epsilon in [(4, sp.Rational(1, 20), sp.Rational(1, 100)), (16, sp.Rational(1, 100), sp.Rational(1, 100)), (256, sp.Rational(1, 1000), sp.Rational(1, 2000)), (2, sp.Rational(1, 2), sp.Rational(1, 10))]:
+        value = 1 / sp.sqrt(d_q) + delta + epsilon
+        strengthened = sp.Max(0, -2 * sp.log(2 * value))
+        displayed = paper_bound.subs(a, value)
+        parameter_witnesses.append({'d_Q': d_q, 'delta': str(delta), 'epsilon': str(epsilon), 'a': str(value), 'strengthened_ge_displayed': bool(sp.N(strengthened - displayed, 50) > 0)})
+    return {'a_definition': 'd_Q^(-1/2) + delta + epsilon', 'fidelity_cap': 'F <= min(1, 2a)', 'strengthened_envelope': 'max(0, -2 log(2a))', 'paper_displayed_bound': '-log(a)-1', 'active_branch_difference': str(active_difference), 'branch_thresholds': {'paper_bound_zero_at': 'exp(-1)', 'strengthened_bound_zero_at': '1/2', 'exp_minus_one_less_than_half': threshold_order, 'active_region_margin_floor': str(margin_floor), 'margin_floor_positive': bool(sp.N(margin_floor, 50) > 0)}, 'dominance_proof': ['for 0<a<exp(-1), both relevant expressions are active and the difference exceeds 2-2 log(2)>0', 'for exp(-1)<=a<1/2, the displayed bound is nonpositive while the strengthened bound is positive', 'for a>=1/2, the strengthened bound is zero while the displayed bound is strictly negative'], 'rational_witness_count': len(witnesses), 'rational_witness_failures': [row for row in witnesses if not row['strictly_dominates']], 'parameter_witnesses': parameter_witnesses}
+
+def build_exact_result() -> dict[str, Any]:
+    source = _source_evidence()
+    certificate = envelope_certificate()
+    thresholds = certificate['branch_thresholds']
+    checks = dict(source['checks'])
+    checks.update({'threshold_order_exact': thresholds['exp_minus_one_less_than_half'], 'active_margin_positive': thresholds['margin_floor_positive'], 'dense_rational_witnesses_all_pass': certificate['rational_witness_count'] == 400 and (not certificate['rational_witness_failures']), 'parameter_witnesses_all_pass': all((row['strengthened_ge_displayed'] for row in certificate['parameter_witnesses']))})
+    return {'result_version': 'sabrina_cdqs_fidelity_envelope_strengthening_v1', 'status': 'complete' if all(checks.values()) else 'failed', 'paper': {'arxiv_id': '2411.10527', 'title': "Cryptographic tests of the python's lunch conjecture"}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'parameter': 'a=d_Q^(-1/2)+delta+epsilon>0', 'strengthened_bound': 'I(A:B)_Psi >= max{0,-2 ln(2a)}', 'derivation': 'the proof gives F<=2a and I>=-2 ln F; universal F<=1 gives F<=min(1,2a)', 'comparison': 'the strengthened envelope strictly exceeds the displayed -ln(a)-1 lower bound for every a>0'}, 'envelope_certificate': certificate, 'exact_checks': checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'alpha_zero_resolved': False, 'finite_secret_dependence_removed': False, 'correctness_security_dependence_removed': False, 'complexity_mutual_information_conjecture_proved': False, 'python_lunch_conjecture_proved': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
+
+def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
+    if out_dir.exists():
+        raise FileExistsError(f'immutable result target already exists: {out_dir}')
+    out_dir.mkdir(parents=True)
+    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
+    report = build_exact_result() | {'generated_utc': generated}
+    report_path = out_dir / 'cdqs_fidelity_envelope_report.json'
+    certificate_path = out_dir / 'cdqs_fidelity_envelope_certificate.json'
+    handoff_path = out_dir / 'CDQS_FIDELITY_ENVELOPE_PRIVATE_HANDOFF.md'
+    manifest_path = out_dir / 'receipt_manifest.json'
+    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    certificate_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'envelope_certificate', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    handoff_path.write_text("# CDQS fidelity-envelope strengthening - private handoff\n\nThe proof in arXiv:2411.10527 directly implies $I(A:B)\\geq\\max\\{0,-2\\ln(2a)\\}$ for $a=d_Q^{-1/2}+\\delta+\\epsilon$. This strictly dominates the displayed $-\\ln(a)-1$ bound for every positive $a$, by retaining the proof's factor of two and using $F\\leq1$. It does not remove finite-secret or error dependence, determine $\\alpha_0$, or prove the complexity conjecture.\n", encoding='utf-8')
+    artifacts = [report_path, certificate_path, handoff_path]
+    manifest = {'manifest_version': 'sabrina_cdqs_fidelity_envelope_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, **{name: expected for name, (_, _, expected) in SOURCE_BLOCKS.items()}}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    all_artifacts = [*artifacts, manifest_path]
+    ledger: Mapping[str, Any] = {'status': 'skipped'}
+    if register_ledger:
+        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
+    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
+
+def main(argv: Sequence[str] | None=None) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
+    parser.add_argument('--no-register-crystal-ledger', action='store_true')
+    args = parser.parse_args(argv)
+    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
+    print(json.dumps(result, sort_keys=True))
+    return 0 if result['status'] == 'complete' else 1
+if __name__ == '__main__':
+    raise SystemExit(main())
diff --git a/ouroboros_replay/kernels/run_sabrina_celestial_circle_convex_hull_certificate.py b/ouroboros_replay/kernels/run_sabrina_celestial_circle_convex_hull_certificate.py
new file mode 100644
index 0000000000000000000000000000000000000000..920c9b4972b91c7b2735d4e5908963ca61e97995
--- /dev/null
+++ b/ouroboros_replay/kernels/run_sabrina_celestial_circle_convex_hull_certificate.py
@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+from ..source_runtime import fixture_path, source_path
+import argparse
+import hashlib
+import json
+import tarfile
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Mapping, Sequence
+import sympy as sp
+from .crystal_ledger import register_crystal_artifacts
+OUT_DIR = Path('.replay_outputs') / 'out_dir'
+LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
+SOURCE_ARCHIVE = source_path('1268f6f1bc7479f48f32e0611e1aefae14149a7f4cdb5d858365165da08f6849')
+SOURCE_MEMBER = 'CelestialGeometry.tex'
+SOURCE_ARCHIVE_SHA256 = '1268f6f1bc7479f48f32e0611e1aefae14149a7f4cdb5d858365165da08f6849'
+SOURCE_MEMBER_SHA256 = 'df41a04ca45e7b4262ff4fb6b3623d4fa11264a1eb35aeeb9c4332ce9b90b3d9'
+SOURCE_BLOCKS = {'selection_rule_summary': (330, 353, '5004306f2c3a3cd932686c791f3be3a4fec2dda6805c28717e8eaa6590eb8289'), 'circle_hyperplane_map': (467, 487, '406501fc02c2b0bcc3abd70083baf5b756ed4548786a2edee02b8ab53730e9fc'), 'positive_cone_certificate': (1282, 1320, 'bbf1c58529b9cf8e62af9f6df70d1eff9f16b52add24e10a84c6e6f949f130fd')}
+PLAN_RECEIPT_SHA256 = 'c303fcaf34cae705aca23f41050cc8b37a67a6855b87df12a148f09b8a82c385'
+PLAN_GUARD_SHA256 = '088f778ad8cdf5dfd3b99ac52a15d369fc5b9fd309ab38ebbc6a8ad3e48fd655'
+PLAN_VERIFIER_SHA256 = 'e3057d407761943809a5fbe62eb974740e630aaa2cb5e437697abc6f1a234f4a'
+
+def _sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+def _source_evidence() -> dict[str, Any]:
+    with tarfile.open(SOURCE_ARCHIVE, 'r:gz') as archive:
+        members = [member for member in archive.getmembers() if member.name == SOURCE_MEMBER]
+        if len(members) != 1:
+            raise ValueError(f'expected exactly one {SOURCE_MEMBER}')
+        extracted = archive.extractfile(members[0])
+        if extracted is None:
+            raise ValueError(f'unreadable source member: {SOURCE_MEMBER}')
+        member_bytes = extracted.read()
+    lines = member_bytes.decode('utf-8').splitlines()
+    texts = {name: '\n'.join(lines[start - 1:end]) + '\n' for name, (start, end, _) in SOURCE_BLOCKS.items()}
+    hashes = {name: hashlib.sha256(text.encode()).hexdigest() for name, text in texts.items()}
+    expected = {name: value for name, (_, _, value) in SOURCE_BLOCKS.items()}
+    checks = {'archive_hash_matches': _sha256(SOURCE_ARCHIVE) == SOURCE_ARCHIVE_SHA256, 'member_hash_matches': hashlib.sha256(member_bytes).hexdigest() == SOURCE_MEMBER_SHA256, 'source_blocks_match': hashes == expected, 'circle_rule_unique': texts['selection_rule_summary'].count('circle that separates all the in from all the out punctures') == 1, 'hyperplane_circle_map_present': texts['circle_hyperplane_map'].count('isomorphism between celestial circles and spacelike co-vectors') == 1, 'strict_sign_condition_present': texts['circle_hyperplane_map'].count('v Q>0') == 1, 'dual_cone_argument_present': texts['positive_cone_certificate'].count('dual cone') == 1}
+    return {'block_hashes': hashes, 'checks': checks}
+
+def _vectors(rows: Sequence[Sequence[sp.Expr]]) -> list[sp.Matrix]:
+    return [sp.Matrix([sp.Rational(value) for value in row]) for row in rows]
+
+def verify_separator(incoming: Sequence[Sequence[sp.Expr]], outgoing: Sequence[Sequence[sp.Expr]], normal: Sequence[sp.Expr], offset: sp.Expr) -> dict[str, Any]:
+    left, right, n = (_vectors(incoming), _vectors(outgoing), sp.Matrix([sp.Rational(v) for v in normal]))
+    b = sp.Rational(offset)
+    in_margins = [sp.simplify(n.dot(point) - b) for point in left]
+    out_margins = [sp.simplify(b - n.dot(point)) for point in right]
+    all_margins = [*in_margins, *out_margins]
+    return {'valid': bool(all((value > 0 for value in all_margins))), 'incoming_margins': [str(value) for value in in_margins], 'outgoing_margins': [str(value) for value in out_margins], 'minimum_margin': str(min(all_margins))}
+
+def verify_intersection(incoming: Sequence[Sequence[sp.Expr]], outgoing: Sequence[Sequence[sp.Expr]], incoming_weights: Sequence[sp.Expr], outgoing_weights: Sequence[sp.Expr]) -> dict[str, Any]:
+    left, right = (_vectors(incoming), _vectors(outgoing))
+    wi = [sp.Rational(value) for value in incoming_weights]
+    wo = [sp.Rational(value) for value in outgoing_weights]
+    left_point = sum((weight * point for weight, point in zip(wi, left)), sp.zeros(3, 1))
+    right_point = sum((weight * point for weight, point in zip(wo, right)), sp.zeros(3, 1))
+    checks = {'lengths_match': len(wi) == len(left) and len(wo) == len(right), 'weights_nonnegative': all((weight >= 0 for weight in [*wi, *wo])), 'weights_normalized': sum(wi) == 1 and sum(wo) == 1, 'barycenters_equal': left_point == right_point, 'incoming_support_at_most_four': sum((weight != 0 for weight in wi)) <= 4, 'outgoing_support_at_most_four': sum((weight != 0 for weight in wo)) <= 4}
+    return {'valid': all(checks.values()), 'checks': checks, 'intersection_point': [str(value) for value in left_point]}
+
+def certificate_examples() -> dict[str, Any]:
+    disjoint_in = [(0, 0, 1), (sp.Rational(3, 5), 0, sp.Rational(4, 5)), (-sp.Rational(3, 5), 0, sp.Rational(4, 5)), (0, sp.Rational(3, 5), sp.Rational(4, 5))]
+    disjoint_out = [(0, 0, -1), (sp.Rational(3, 5), 0, -sp.Rational(4, 5)), (-sp.Rational(3, 5), 0, -sp.Rational(4, 5)), (0, -sp.Rational(3, 5), -sp.Rational(4, 5))]
+    separator = verify_separator(disjoint_in, disjoint_out, (0, 0, 1), 0)
+    intersect_in = [(1, 0, 0), (-1, 0, 0)]
+    intersect_out = [(0, 1, 0), (0, -1, 0)]
+    intersection = verify_intersection(intersect_in, intersect_out, (sp.Rational(1, 2), sp.Rational(1, 2)), (sp.Rational(1, 2), sp.Rational(1, 2)))
+    bad_separator = verify_separator(intersect_in, intersect_out, (1, 0, 0), 0)
+    return {'strict_separator': separator, 'compact_intersection': intersection, 'intersecting_hulls_reject_separator': not bad_separator['valid']}
+
+def build_exact_result() -> dict[str, Any]:
+    source = _source_evidence()
+    examples = certificate_examples()
+    checks = dict(source['checks'])
+    checks.update({'strict_separator_valid': examples['strict_separator']['valid'], 'strict_separator_margin_positive': sp.Rational(examples['strict_separator']['minimum_margin']) > 0, 'compact_intersection_valid': examples['compact_intersection']['valid'], 'intersecting_example_rejects_separator': examples['intersecting_hulls_reject_separator']})
+    return {'result_version': 'sabrina_celestial_circle_convex_hull_certificate_v1', 'status': 'complete' if all(checks.values()) else 'failed', 'paper': {'arxiv_id': '2204.02505', 'title': 'Celestial Geometry'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'equivalence': 'a strict celestial circle separates finite incoming and outgoing embedded points iff their convex hulls in R^3 are disjoint', 'separator_certificate': 'a normal n and offset b with n.p_in>b>n.p_out for every point', 'obstruction_certificate': 'an equal convex combination from each side proves hull intersection and forbids strict separation', 'compactness': "Caratheodory's theorem reduces each side of an R^3 intersection certificate to at most four points"}, 'certificate_examples': examples, 'exact_checks': checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'floating_point_robustness_guaranteed': False, 'degenerate_boundary_channel_classified': False, 'amplitude_dynamics_computed': False, 'complexified_points_supported': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
+
+def _jsonable(value: Any) -> Any:
+    if isinstance(value, dict):
+        return {key: _jsonable(item) for key, item in value.items()}
+    if isinstance(value, (list, tuple)):
+        return [_jsonable(item) for item in value]
+    if isinstance(value, sp.Basic):
+        return str(value)
+    return value
+
+def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
+    if out_dir.exists():
+        raise FileExistsError(f'immutable result target already exists: {out_dir}')
+    out_dir.mkdir(parents=True)
+    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
+    report = _jsonable(build_exact_result() | {'generated_utc': generated})
+    report_path = out_dir / 'celestial_circle_convex_hull_report.json'
+    certificate_path = out_dir / 'celestial_circle_certificate_examples.json'
+    handoff_path = out_dir / 'CELESTIAL_CIRCLE_CONVEX_HULL_PRIVATE_HANDOFF.md'
+    manifest_path = out_dir / 'receipt_manifest.json'
+    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    certificate_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'certificate_examples', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    handoff_path.write_text('# Celestial-circle convex-hull certificate - private handoff\n\nThe circle selection rule is equivalent to strict separation of the incoming and outgoing convex hulls in the embedded celestial sphere. A strict rational hyperplane certifies separation; an equal convex combination certifies intersection, with at most four points per side by Caratheodory in $\\mathbb R^3$. Exact finite data are covered; floating degeneracy and amplitude dynamics are not.\n', encoding='utf-8')
+    artifacts = [report_path, certificate_path, handoff_path]
+    manifest = {'manifest_version': 'sabrina_celestial_circle_convex_hull_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, **{name: expected for name, (_, _, expected) in SOURCE_BLOCKS.items()}}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    all_artifacts = [*artifacts, manifest_path]
+    ledger: Mapping[str, Any] = {'status': 'skipped'}
+    if register_ledger:
+        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
+    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
+
+def main(argv: Sequence[str] | None=None) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
+    parser.add_argument('--no-register-crystal-ledger', action='store_true')
+    args = parser.parse_args(argv)
+    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
+    print(json.dumps(result, sort_keys=True))
+    return 0 if result['status'] == 'complete' else 1
+if __name__ == '__main__':
+    raise SystemExit(main())
diff --git a/ouroboros_replay/kernels/run_sabrina_celestial_eikonal_logarithm_gauge.py b/ouroboros_replay/kernels/run_sabrina_celestial_eikonal_logarithm_gauge.py
new file mode 100644
index 0000000000000000000000000000000000000000..e4f3f42b4ede580f0009ec2cd1f4bafd2caabea3
--- /dev/null
+++ b/ouroboros_replay/kernels/run_sabrina_celestial_eikonal_logarithm_gauge.py
@@ -0,0 +1,126 @@
+from __future__ import annotations
+
+from ..source_runtime import fixture_path, source_path
+import argparse
+import hashlib
+import json
+import tarfile
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Mapping, Sequence
+import sympy as sp
+from .crystal_ledger import register_crystal_artifacts
+OUT_DIR = Path('.replay_outputs') / 'out_dir'
+LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
+SOURCE_ARCHIVE = source_path('eb03e2135b623ef961155841b0f1fb48f90fc86e47b8d8ccd3f73c7b4174522b')
+SOURCE_MEMBER = 'LoopStressTensor.tex'
+SOURCE_ARCHIVE_SHA256 = 'eb03e2135b623ef961155841b0f1fb48f90fc86e47b8d8ccd3f73c7b4174522b'
+SOURCE_MEMBER_SHA256 = '724cdb5aaf9f999c497e21788a00721b030c3219aecda095bc174a512f496b87'
+SOURCE_BLOCKS = {'eikonal_soft_loop': (497, 519, 'd1a6896c759364bb6fba03654a53da45d5dbe3ecdb746b7a521c481b349a2622'), 'goldstone_wilson_dressing': (549, 584, '86ffc890a6e025062ad912e11d896d2cb93c7b8bdc37da6e3970dd5e7788d2fe'), 'goldstone_memory_stress': (586, 612, '1a2bda42a3b56b59d2265125bf2bc35ee7157334aa5b0cfea6dd178cd06f49a2')}
+PLAN_RECEIPT_SHA256 = '2fb07235ff6b39cfe363cbb4e00004a3205076f6555fb92e6e3885fc7780cd40'
+PLAN_GUARD_SHA256 = 'cd1ffc81543e2dedebc833f169a9ec077ad35f2b43125e316bfe61cab5d5b12b'
+PLAN_VERIFIER_SHA256 = '42763ec7fdd4c11473550584e054c0bdcd53a8396078707b9cd7074bc6c97e28'
+
+def _sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+def _source_evidence() -> dict[str, Any]:
+    with tarfile.open(SOURCE_ARCHIVE, 'r:gz') as archive:
+        extracted = archive.extractfile(SOURCE_MEMBER)
+        if extracted is None:
+            raise ValueError(f'unreadable source member: {SOURCE_MEMBER}')
+        member_bytes = extracted.read()
+    lines = member_bytes.decode('utf-8').splitlines()
+    texts = {name: '\n'.join(lines[start - 1:end]) + '\n' for name, (start, end, _) in SOURCE_BLOCKS.items()}
+    hashes = {name: hashlib.sha256(text.encode()).hexdigest() for name, text in texts.items()}
+    expected = {name: value for name, (_, _, value) in SOURCE_BLOCKS.items()}
+    checks = {'archive_hash_matches': _sha256(SOURCE_ARCHIVE) == SOURCE_ARCHIVE_SHA256, 'member_hash_matches': hashlib.sha256(member_bytes).hexdigest() == SOURCE_MEMBER_SHA256, 'source_blocks_match': hashes == expected, 'eikonal_factor_present': all((marker in texts['eikonal_soft_loop'] for marker in ('\\label{sign}', '\\label{signprime}', 'momentum conservation'))), 'wilson_dressing_present': all((marker in texts['goldstone_wilson_dressing'] for marker in ('\\label{Sdressed}', '\\label{Wdressed}', '\\label{Cdressed}'))), 'goldstone_memory_replacement_present': all((marker in texts['goldstone_memory_stress'] for marker in ('\\langle P_z W_1', '\\label{Tnew}')))}
+    return {'block_hashes': hashes, 'checks': checks}
+
+def lorentz_dot(left: Sequence[Any], right: Sequence[Any]) -> Any:
+    if len(left) != 4 or len(right) != 4:
+        raise ValueError('four-dimensional momenta required')
+    return -left[0] * right[0] + sum((left[index] * right[index] for index in range(1, 4)))
+
+def total_momentum(momenta: Sequence[Sequence[Any]]) -> tuple[Any, ...]:
+    return tuple((sum((momentum[index] for momentum in momenta)) for index in range(4)))
+
+def separable_log_shift(momenta: Sequence[Sequence[Any]], leg_shifts: Sequence[Any], constant_shift: Any) -> Any:
+    if len(momenta) != len(leg_shifts):
+        raise ValueError('one shift per momentum required')
+    return sp.expand(sum((lorentz_dot(momenta[i], momenta[j]) * (leg_shifts[i] + leg_shifts[j] + constant_shift) for i in range(len(momenta)) for j in range(len(momenta)) if i != j)))
+
+def contracted_log_shift(momenta: Sequence[Sequence[Any]], leg_shifts: Sequence[Any], constant_shift: Any) -> Any:
+    total = total_momentum(momenta)
+    return sp.expand(2 * sum((leg_shifts[i] * lorentz_dot(momenta[i], total) for i in range(len(momenta)))) + constant_shift * lorentz_dot(total, total))
+
+def certificate_witnesses() -> dict[str, Any]:
+    conserved = ((1, 1, 0, 0), (1, -1, 0, 0), (1, 0, 1, 0), (1, 0, -1, 0), (-2, 0, 0, 2), (-2, 0, 0, -2))
+    conserved_shifts = (2, -3, 5, 7, -11, 13)
+    nonconserved = ((1, 1, 0, 0), (1, -1, 0, 0))
+    parallel_null = ((1, 0, 0, 1), (2, 0, 0, 2))
+    return {'conserved_spanning_witness': {'momenta': conserved, 'total': total_momentum(conserved), 'rank': sp.Matrix(conserved).rank(), 'all_null': all((lorentz_dot(momentum, momentum) == 0 for momentum in conserved)), 'direct_shift': separable_log_shift(conserved, conserved_shifts, -17), 'contracted_shift': contracted_log_shift(conserved, conserved_shifts, -17)}, 'nonconserved_falsifier': {'momenta': nonconserved, 'total': total_momentum(nonconserved), 'direct_shift': separable_log_shift(nonconserved, (1, 0), 0), 'contracted_shift': contracted_log_shift(nonconserved, (1, 0), 0)}, 'degenerate_converse_boundary': {'momenta': parallel_null, 'total': total_momentum(parallel_null), 'rank': sp.Matrix(parallel_null).rank(), 'row_contractions': tuple((lorentz_dot(momentum, total_momentum(parallel_null)) for momentum in parallel_null)), 'direct_shift': separable_log_shift(parallel_null, (19, -23), 29)}}
+
+def _symbolic_master_identity() -> bool:
+    n = 4
+    shifts = sp.symbols('a0:4')
+    constant = sp.symbols('c')
+    pairs = {(i, j): sp.symbols(f'g{i}{j}') for i in range(n) for j in range(i + 1, n)}
+    gram = lambda i, j: 0 if i == j else pairs[min(i, j), max(i, j)]
+    direct = sum((gram(i, j) * (shifts[i] + shifts[j] + constant) for i in range(n) for j in range(n) if i != j))
+    row = [sum((gram(i, j) for j in range(n))) for i in range(n)]
+    contracted = 2 * sum((shifts[i] * row[i] for i in range(n))) + constant * sum(row)
+    return sp.expand(direct - contracted) == 0
+
+def build_exact_result() -> dict[str, Any]:
+    source = _source_evidence()
+    witnesses = certificate_witnesses()
+    conserved = witnesses['conserved_spanning_witness']
+    falsifier = witnesses['nonconserved_falsifier']
+    boundary = witnesses['degenerate_converse_boundary']
+    checks = dict(source['checks'])
+    checks.update({'symbolic_master_identity': _symbolic_master_identity(), 'conserved_witness_is_null_spanning_and_closed': conserved['all_null'] and conserved['rank'] == 4 and (conserved['total'] == (0, 0, 0, 0)), 'conserved_shift_cancels': conserved['direct_shift'] == conserved['contracted_shift'] == 0, 'nonconserved_shift_is_detected': falsifier['total'] != (0, 0, 0, 0) and falsifier['direct_shift'] == falsifier['contracted_shift'] != 0, 'degenerate_converse_is_not_overclaimed': boundary['total'] != (0, 0, 0, 0) and boundary['rank'] < 4 and all((value == 0 for value in boundary['row_contractions'])) and (boundary['direct_shift'] == 0)})
+    return {'result_version': 'sabrina_celestial_eikonal_logarithm_gauge_v1', 'status': 'complete' if all(checks.values()) else 'failed', 'paper': {'arxiv_id': '2205.10901', 'title': 'A Comment on Loop Corrections to the Celestial Stress Tensor'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'master_identity': 'Delta=2 sum_i a_i (p_i dot P)+c(P dot P), P=sum_i p_i, for null external momenta and ordered i!=j pair sums', 'forward': 'signed momentum conservation P=0 removes every leg-separable logarithm shift a_i+a_j+c from the Eikonal/Wilson-line exponent', 'exact_converse': 'cancellation for every independent a_i implies p_i dot P=0 for every participating leg (and hence P dot P=0)', 'spanning_converse': 'if the participating momenta span a nondegenerate four-dimensional momentum space, those row contractions force P=0', 'boundary': 'without the spanning condition, parallel null nonconserved momenta can cancel every separable shift, so cancellation alone does not prove momentum conservation'}, 'certificate_witnesses': witnesses, 'exact_checks': checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'full_loop_finite_remainder_computed': False, 'stress_tensor_ope_derived': False, 'normalization_conventions_changed': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
+
+def _jsonable(value: Any) -> Any:
+    if isinstance(value, dict):
+        return {key: _jsonable(item) for key, item in value.items()}
+    if isinstance(value, (list, tuple)):
+        return [_jsonable(item) for item in value]
+    if isinstance(value, sp.Basic):
+        return str(value)
+    return value
+
+def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
+    if out_dir.exists():
+        raise FileExistsError(f'immutable result target already exists: {out_dir}')
+    out_dir.mkdir(parents=True)
+    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
+    report = _jsonable(build_exact_result() | {'generated_utc': generated})
+    report_path = out_dir / 'celestial_eikonal_logarithm_gauge_report.json'
+    witness_path = out_dir / 'celestial_eikonal_logarithm_gauge_witnesses.json'
+    handoff_path = out_dir / 'CELESTIAL_EIKONAL_LOGARITHM_GAUGE_PRIVATE_HANDOFF.md'
+    manifest_path = out_dir / 'receipt_manifest.json'
+    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    witness_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'certificate_witnesses', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    handoff_path.write_text('# Celestial Eikonal logarithm gauge - private handoff\n\nFor the null ordered-pair Eikonal bilinear, every leg-separable additive change of the logarithm reduces exactly to row contractions with total signed momentum. Momentum conservation therefore removes the full ambiguity. The converse yields the row contractions; total momentum conservation follows only with a spanning/nondegeneracy condition, and a parallel-null counterexample proves that condition cannot be dropped.\n', encoding='utf-8')
+    artifacts = [report_path, witness_path, handoff_path]
+    expected = {name: value for name, (_, _, value) in SOURCE_BLOCKS.items()}
+    manifest = {'manifest_version': 'sabrina_celestial_eikonal_logarithm_gauge_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, **expected}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    all_artifacts = [*artifacts, manifest_path]
+    ledger: Mapping[str, Any] = {'status': 'skipped'}
+    if register_ledger:
+        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
+    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
+
+def main(argv: Sequence[str] | None=None) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
+    parser.add_argument('--no-register-crystal-ledger', action='store_true')
+    args = parser.parse_args(argv)
+    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
+    print(json.dumps(result, sort_keys=True))
+    return 0 if result['status'] == 'complete' else 1
+if __name__ == '__main__':
+    raise SystemExit(main())
diff --git a/ouroboros_replay/kernels/run_sabrina_celestial_euclidean_monodromy_cancellation.py b/ouroboros_replay/kernels/run_sabrina_celestial_euclidean_monodromy_cancellation.py
new file mode 100644
index 0000000000000000000000000000000000000000..ecb85a894b9fe87686a1f9d0b73a5cff875520d5
--- /dev/null
+++ b/ouroboros_replay/kernels/run_sabrina_celestial_euclidean_monodromy_cancellation.py
@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+from ..source_runtime import fixture_path, source_path
+import argparse
+import hashlib
+import json
+import tarfile
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Mapping, Sequence
+import sympy as sp
+from .crystal_ledger import register_crystal_artifacts
+OUT_DIR = Path('.replay_outputs') / 'out_dir'
+LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
+SOURCE_ARCHIVE = source_path('d1ffa83185733baeb25b8254be688a99db0101bf43540afc8980c1cf2f8f9ff0')
+SOURCE_MEMBER = 'main.tex'
+SOURCE_ARCHIVE_SHA256 = 'd1ffa83185733baeb25b8254be688a99db0101bf43540afc8980c1cf2f8f9ff0'
+SOURCE_MEMBER_SHA256 = '7fad289115b12dffed9a1e89d10b6d2f6010b43aa4ca2ddb6ddf603f8e464d12'
+SOURCE_BLOCKS = {'master_branch_asymptotic': (570, 613, '259196b8dc95cec88c0e2f9e9d63bb5d5667af07866ce60f0adba320e4e821f8'), 'locality_and_new_ope': (635, 652, '85f7b814ea1a5127899bd8aae5759e43601d498d00f86bda24fe842d21dde240'), 'double_residue_contours': (686, 701, '1b403d9e4962269f8c86a8d203bc2415677cb6af855faa8d9d2742265cc35661')}
+PLAN_RECEIPT_SHA256 = '299e5e82b2919150745a6a6e33a1837e1e13fae7121fba4a17253f1a89d44f3f'
+PLAN_GUARD_SHA256 = '2a24fdb86ac071b25b2b3c0f7eeaa7074c0ffaaf30f72bf3cc29ace530aae3c9'
+PLAN_VERIFIER_SHA256 = 'cdfdbcb63e241894a70c5de20cdc3c5900826adcd538e48a871fc9ca845f5f2f'
+
+def _sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+def _source_evidence() -> dict[str, Any]:
+    with tarfile.open(SOURCE_ARCHIVE, 'r:gz') as archive:
+        members = [member for member in archive.getmembers() if member.name == SOURCE_MEMBER]
+        if len(members) != 1:
+            raise ValueError(f'expected exactly one {SOURCE_MEMBER}')
+        extracted = archive.extractfile(members[0])
+        if extracted is None:
+            raise ValueError(f'unreadable source member: {SOURCE_MEMBER}')
+        member_bytes = extracted.read()
+    lines = member_bytes.decode('utf-8').splitlines()
+    block_texts = {name: '\n'.join(lines[start - 1:end]) + '\n' for name, (start, end, _) in SOURCE_BLOCKS.items()}
+    block_hashes = {name: hashlib.sha256(text.encode()).hexdigest() for name, text in block_texts.items()}
+    expected = {name: expected_hash for name, (_, _, expected_hash) in SOURCE_BLOCKS.items()}
+    checks = {'archive_hash_matches': _sha256(SOURCE_ARCHIVE) == SOURCE_ARCHIVE_SHA256, 'member_hash_matches': hashlib.sha256(member_bytes).hexdigest() == SOURCE_MEMBER_SHA256, 'source_blocks_match': block_hashes == expected, 'branch_asymptotic_unique': block_texts['master_branch_asymptotic'].count('\\eta^{\\alpha_1} C_2') == 2, 'euclidean_cancellation_stated': block_texts['locality_and_new_ope'].count('holomorphic and antiholomorphic branch cuts cancel') == 1, 'double_residue_formula_present': block_texts['double_residue_contours'].count('-\\res{\\eta\\to 1} - \\res{\\eta\\to 0} + \\lim_{\\eta\\to\\infty} \\eta') == 2, 'arbitrary_branch_cuts_allowed': block_texts['double_residue_contours'].count('allow for arbitrary branch cuts') == 1}
+    return {'block_hashes': block_hashes, 'checks': checks}
+
+def monodromy_certificate() -> dict[str, Any]:
+    alpha, beta = sp.symbols('alpha beta', real=True)
+    holomorphic = sp.exp(2 * sp.pi * sp.I * alpha)
+    antiholomorphic_opposite = sp.exp(-2 * sp.pi * sp.I * beta)
+    paired = sp.simplify(holomorphic * antiholomorphic_opposite)
+    euclidean = sp.simplify(paired.subs(beta, alpha))
+    witness_failures = []
+    count = 0
+    for denominator in range(2, 13):
+        for numerator in range(-denominator + 1, denominator):
+            value = sp.Rational(numerator, denominator)
+            count += 1
+            if sp.simplify(sp.exp(2 * sp.pi * sp.I * value) * sp.exp(-2 * sp.pi * sp.I * value) - 1) != 0:
+                witness_failures.append(str(value))
+    off_locus = sp.simplify(sp.exp(2 * sp.pi * sp.I * sp.Rational(1, 3)))
+    spin_rows = []
+    for spin in range(-8, 9):
+        factor = sp.simplify(paired.subs({alpha: sp.Rational(1, 7) + spin, beta: sp.Rational(1, 7)}))
+        spin_rows.append({'spin': spin, 'factor': str(factor), 'trivial': factor == 1})
+    return {'holomorphic_fixed_bar_eta_factor': str(holomorphic), 'paired_opposite_winding_factor': str(paired), 'euclidean_scalar_factor': str(euclidean), 'euclidean_scalar_cancels': euclidean == 1, 'rational_euclidean_witness_count': count, 'rational_euclidean_witness_failures': witness_failures, 'generic_off_locus_witness': {'alpha': '1/3', 'factor': str(off_locus), 'nontrivial': off_locus != 1}, 'integer_spin_rows': spin_rows, 'domain_distinction': {'euclidean_locus': 'bar-eta is the complex conjugate and winds oppositely, so scalar alpha=beta monodromy cancels', 'complexified_contour': 'eta and bar-eta are independent; holding bar-eta fixed leaves exp(2 pi i alpha)', 'contour_consequence': 'the off-locus branch discontinuity obstructs ordinary meromorphic contour pulling'}}
+
+def build_exact_result() -> dict[str, Any]:
+    source = _source_evidence()
+    certificate = monodromy_certificate()
+    checks = dict(source['checks'])
+    checks.update({'euclidean_cancellation_exact': certificate['euclidean_scalar_cancels'], 'rational_euclidean_grid_passes': certificate['rational_euclidean_witness_count'] > 100 and (not certificate['rational_euclidean_witness_failures']), 'generic_off_locus_nontrivial': certificate['generic_off_locus_witness']['nontrivial'], 'integer_spin_single_valued': all((row['trivial'] for row in certificate['integer_spin_rows']))})
+    return {'result_version': 'sabrina_celestial_euclidean_monodromy_cancellation_v1', 'status': 'complete' if all(checks.values()) else 'failed', 'paper': {'arxiv_id': '2309.16602', 'title': 'Multicollinear Singularities in Celestial CFT'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'paired_monodromy': 'eta^alpha bar-eta^beta acquires exp(2 pi i(alpha-beta)) under opposite winding', 'euclidean_scalar': 'for beta=alpha the paired monodromy is exactly one', 'complexified_obstruction': 'with bar-eta fixed, eta^alpha retains exp(2 pi i alpha), generically obstructing contour pulling', 'integer_spin_extension': 'paired Euclidean monodromy is single-valued whenever alpha-beta is an integer'}, 'monodromy_certificate': certificate, 'exact_checks': checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'branch_term_vanishes': False, 'complexified_branch_cut_removed': False, 'hard_celestial_jacobi_restored': False, 'full_ope_associativity_reproved': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
+
+def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
+    if out_dir.exists():
+        raise FileExistsError(f'immutable result target already exists: {out_dir}')
+    out_dir.mkdir(parents=True)
+    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
+    report = build_exact_result() | {'generated_utc': generated}
+    report_path = out_dir / 'celestial_euclidean_monodromy_report.json'
+    certificate_path = out_dir / 'celestial_monodromy_certificate.json'
+    handoff_path = out_dir / 'CELESTIAL_MONODROMY_PRIVATE_HANDOFF.md'
+    manifest_path = out_dir / 'receipt_manifest.json'
+    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    certificate_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'monodromy_certificate', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    handoff_path.write_text('# Celestial Euclidean monodromy cancellation - private handoff\n\nPaired opposite winding gives monodromy $e^{2\\pi i(\\alpha-\\beta)}$, so scalar Euclidean branch factors cancel exactly while a complexified contour holding $\\bar\\eta$ fixed retains generic holomorphic monodromy. Local Euclidean single-valuedness therefore coexists with the double-residue contour obstruction; the branch term is not removed.\n', encoding='utf-8')
+    artifacts = [report_path, certificate_path, handoff_path]
+    manifest = {'manifest_version': 'sabrina_celestial_euclidean_monodromy_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, **{name: expected for name, (_, _, expected) in SOURCE_BLOCKS.items()}}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    all_artifacts = [*artifacts, manifest_path]
+    ledger: Mapping[str, Any] = {'status': 'skipped'}
+    if register_ledger:
+        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
+    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
+
+def main(argv: Sequence[str] | None=None) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
+    parser.add_argument('--no-register-crystal-ledger', action='store_true')
+    args = parser.parse_args(argv)
+    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
+    print(json.dumps(result, sort_keys=True))
+    return 0 if result['status'] == 'complete' else 1
+if __name__ == '__main__':
+    raise SystemExit(main())
diff --git a/ouroboros_replay/kernels/run_sabrina_celestial_momentum_rising_factorial.py b/ouroboros_replay/kernels/run_sabrina_celestial_momentum_rising_factorial.py
new file mode 100644
index 0000000000000000000000000000000000000000..71043e854bc6b16855af3ac2337b58a7767105ff
--- /dev/null
+++ b/ouroboros_replay/kernels/run_sabrina_celestial_momentum_rising_factorial.py
@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+from ..source_runtime import fixture_path, source_path
+import argparse
+import hashlib
+import json
+import tarfile
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Mapping, Sequence
+import sympy as sp
+from .crystal_ledger import register_crystal_artifacts
+OUT_DIR = Path('.replay_outputs') / 'out_dir'
+LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
+SOURCE_ARCHIVE = source_path('ff00948d397a3aaaa36cec9a65f63477b16c6315c982669e63259b0a8961fc46')
+SOURCE_MEMBER = 'shifting_spin.tex'
+SOURCE_ARCHIVE_SHA256 = 'ff00948d397a3aaaa36cec9a65f63477b16c6315c982669e63259b0a8961fc46'
+SOURCE_MEMBER_SHA256 = '17ed9a4bf99bf5a3a53a11d7da5c3000c4b99db7688432072e6703a597671794'
+SOURCE_BLOCKS = {'translation_shift': (624, 637, '3f9d6612c648c75b53b6d68fd334a629f865d07e62e9368e70aa712d86b62a2a'), 'operator_ordering_boundary': (695, 700, '16f999a9960a0f011eb2591446ed5dbc559a33fca3d2098ec4f2fff7a9c25eda'), 'celestial_momentum_double_action': (761, 787, 'd884d68039e9c2aa2a19ee2127b3d1d60772dafcaec39591795d980805574763')}
+PLAN_RECEIPT_SHA256 = 'b1ef920100ce876a11d5c3ea806073ab167ef76f9d6912e8e9f42ab262b2a036'
+PLAN_GUARD_SHA256 = '98dcf1600dee34bff32ba3b37c82dc672c9c6a04c4e62a21b41b4a5173a030cd'
+PLAN_VERIFIER_SHA256 = '3fa71dcff1cf25af4f2a7790e79f0c4efd81d692620e05f17316d10ab1df6ed6'
+
+def _sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+def _source_evidence() -> dict[str, Any]:
+    with tarfile.open(SOURCE_ARCHIVE, 'r:*') as archive:
+        extracted = archive.extractfile(SOURCE_MEMBER)
+        if extracted is None:
+            raise ValueError(f'unreadable source member: {SOURCE_MEMBER}')
+        member_bytes = extracted.read()
+    lines = member_bytes.decode('utf-8').splitlines()
+    texts = {name: '\n'.join(lines[start - 1:end]) + '\n' for name, (start, end, _) in SOURCE_BLOCKS.items()}
+    hashes = {name: hashlib.sha256(text.encode()).hexdigest() for name, text in texts.items()}
+    expected = {name: value for name, (_, _, value) in SOURCE_BLOCKS.items()}
+    checks = {'archive_hash_matches': _sha256(SOURCE_ARCHIVE) == SOURCE_ARCHIVE_SHA256, 'member_hash_matches': hashlib.sha256(member_bytes).hexdigest() == SOURCE_MEMBER_SHA256, 'source_blocks_match': hashes == expected, 'translation_shift_present': all((marker in texts['translation_shift'] for marker in ('{\\cal P}_\\mu=q_\\mu e^{\\p_\\Delta}', '\\mathcal{O}_{\\Delta+1,J}', '\\mathcal{P}^\\mu \\varphi^\\Delta'))), 'source_double_action_present': all((marker in texts['celestial_momentum_double_action'] for marker in ('\\label{celestialK}', '1+\\frac{1}{\\Delta}', '{\\cal P}_\\mu {\\cal P}_\\nu'))), 'operator_ordering_warning_present': 'operator ordering matters' in texts['operator_ordering_boundary']}
+    return {'block_hashes': hashes, 'checks': checks}
+
+def rising_prefactor(order: int, delta: Any) -> Any:
+    if order < 0:
+        raise ValueError('order must be nonnegative')
+    if order == 0:
+        return sp.Integer(1)
+    return sp.cancel(sp.rf(delta, order) / delta ** order)
+
+def product_prefactor(order: int, delta: Any) -> Any:
+    if order < 0:
+        raise ValueError('order must be nonnegative')
+    if order <= 1:
+        return sp.Integer(1)
+    return sp.cancel(sp.prod((delta + index for index in range(1, order))) / delta ** (order - 1))
+
+def exact_rows(max_order: int=8) -> list[dict[str, Any]]:
+    delta = sp.symbols('Delta')
+    rows = []
+    for order in range(max_order + 1):
+        prefactor = rising_prefactor(order, delta)
+        expected = product_prefactor(order, delta)
+        previous = rising_prefactor(order - 1, delta) if order else sp.Integer(1)
+        recurrence = sp.Integer(1) if order == 0 else previous * (1 + sp.Rational(order - 1, 1) / delta)
+        shift_coefficient = sp.rf(delta, order)
+        fixed_k_coefficient = delta ** order
+        rows.append({'order': order, 'prefactor': str(prefactor), 'normalized_wavefunction_shift_coefficient': str(sp.expand_func(shift_coefficient)), 'fixed_celestial_momentum_product_coefficient': str(fixed_k_coefficient), 'product_formula_matches': bool(sp.simplify(prefactor - expected) == 0), 'recurrence_matches': bool(sp.simplify(prefactor - recurrence) == 0), 'coefficient_ratio_matches': bool(sp.simplify(shift_coefficient / fixed_k_coefficient - prefactor) == 0), 'pole_order_at_delta_zero': max(order - 1, 0), 'simple_prefactor_zeros': [str(-index) for index in range(1, order)]})
+    return rows
+
+def build_exact_result() -> dict[str, Any]:
+    source = _source_evidence()
+    rows = exact_rows()
+    delta = sp.symbols('Delta')
+    source_factor = 1 + 1 / delta
+    checks = dict(source['checks'])
+    checks.update({'all_product_formulas_exact': all((row['product_formula_matches'] for row in rows)), 'all_recurrences_exact': all((row['recurrence_matches'] for row in rows)), 'all_normalized_shift_ratios_exact': all((row['coefficient_ratio_matches'] for row in rows)), 'source_order_two_factor_exact': bool(sp.simplify(rising_prefactor(2, delta) - source_factor) == 0), 'divisor_rows_exact': all((row['pole_order_at_delta_zero'] == max(row['order'] - 1, 0) and len(row['simple_prefactor_zeros']) == max(row['order'] - 1, 0) for row in rows))})
+    return {'result_version': 'sabrina_celestial_momentum_rising_factorial_v1', 'status': 'complete' if all(checks.values()) else 'failed', 'paper': {'arxiv_id': '2012.15694', 'title': 'Shifting Spin on the Celestial Sphere'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'all_order_identity': 'P_(mu1)...P_(mur) phi^Delta = [(Delta)_r/Delta^r] product_i K^Delta_(mui) phi^Delta', 'initial_values': 'R_0(Delta)=R_1(Delta)=1', 'recurrence': 'R_(r+1)(Delta)=R_r(Delta)(1+r/Delta)', 'product_form': 'R_r(Delta)=product_(j=1)^(r-1)(Delta+j)/Delta^(r-1) for r>=2', 'divisor': 'R_r has a pole of order r-1 at Delta=0 and simple zeros at Delta=-1,...,-(r-1)', 'source_special_case': 'R_2=(Delta+1)/Delta=1+1/Delta'}, 'all_order_proof': {'shift_iteration': 'P^r contributes q_(mu1)...q_(mur) phi^(Delta+r)', 'normalized_wavefunction_ratio': 'phi^(Delta+r)/phi^Delta=(Delta)_r/(-q dot X)^r', 'fixed_K_product': 'product_i K^Delta_(mui)=Delta^r product_i q_(mui)/(-q dot X)^r', 'division_step': 'the coefficient ratio is (Delta)_r/Delta^r'}, 'exact_rows': rows, 'exact_checks': checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'interacting_amplitude_validity_claimed': False, 'on_shell_operator_subtleties_resolved': False, 'singular_weight_factors_separately_evaluable': False, 'analytic_continuation_required_at_divisor': True, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
+
+def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
+    if out_dir.exists():
+        raise FileExistsError(f'immutable result target already exists: {out_dir}')
+    out_dir.mkdir(parents=True)
+    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
+    report = build_exact_result() | {'generated_utc': generated}
+    report_path = out_dir / 'celestial_momentum_rising_factorial_report.json'
+    witness_path = out_dir / 'celestial_momentum_rising_factorial_witnesses.json'
+    handoff_path = out_dir / 'CELESTIAL_MOMENTUM_RISING_FACTORIAL_PRIVATE_HANDOFF.md'
+    manifest_path = out_dir / 'receipt_manifest.json'
+    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    witness_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'all_order_proof', 'exact_rows', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    handoff_path.write_text("# Celestial momentum rising-factorial law - private handoff\n\nThe source's two-momentum factor extends to every number of celestial momentum insertions through a rising-factorial prefactor. Its recurrence and complete meromorphic divisor are exact. At singular conformal weights the prefactor and momentum product must not be evaluated separately without analytic continuation. No interacting-amplitude, on-shell-resolution, physical singular-state, or publication claim is made.\n", encoding='utf-8')
+    artifacts = [report_path, witness_path, handoff_path]
+    manifest = {'manifest_version': 'sabrina_celestial_momentum_rising_factorial_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, **{name: value for name, (_, _, value) in SOURCE_BLOCKS.items()}}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    all_artifacts = [*artifacts, manifest_path]
+    ledger: Mapping[str, Any] = {'status': 'skipped'}
+    if register_ledger:
+        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
+    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
+
+def main(argv: Sequence[str] | None=None) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
+    parser.add_argument('--no-register-crystal-ledger', action='store_true')
+    args = parser.parse_args(argv)
+    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
+    print(json.dumps(result, sort_keys=True))
+    return 0 if result['status'] == 'complete' else 1
+if __name__ == '__main__':
+    raise SystemExit(main())
diff --git a/ouroboros_replay/kernels/run_sabrina_celestial_recursion_pde_generating_function.py b/ouroboros_replay/kernels/run_sabrina_celestial_recursion_pde_generating_function.py
new file mode 100644
index 0000000000000000000000000000000000000000..fef266efd5831b3a3215a70a388b4e0b08798321
--- /dev/null
+++ b/ouroboros_replay/kernels/run_sabrina_celestial_recursion_pde_generating_function.py
@@ -0,0 +1,127 @@
+from __future__ import annotations
+
+from ..source_runtime import fixture_path, source_path
+import argparse
+import hashlib
+import json
+import tarfile
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Mapping, Sequence
+import sympy as sp
+from .crystal_ledger import register_crystal_artifacts
+OUT_DIR = Path('.replay_outputs') / 'out_dir'
+LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
+SOURCE_ARCHIVE = source_path('bb41217149756d1b5a56ca91fd7a5c99c511d0be8b8e54f15c900914c712bd77')
+SOURCE_MEMBER = 'main.tex'
+SOURCE_ARCHIVE_SHA256 = 'bb41217149756d1b5a56ca91fd7a5c99c511d0be8b8e54f15c900914c712bd77'
+SOURCE_MEMBER_SHA256 = '2774400bc31506d0693cc7c189a7618ee8d7ae8983b96d8fb8cb4d4f427dd650'
+SOURCE_BLOCKS = {'shift_taylor_seed': (1021, 1059, 'cf5e7223ab84469191344fea116685d7c771dfc6ac5f485d811224cd54a25f5c'), 'pde_tower': (1474, 1491, '651b7d2e3f252acd15cde8eb3cf9cb048ac454c58bfc0fcb493f3bafbe9197ea')}
+PLAN_RECEIPT_SHA256 = 'ab842ac2160eb54123ded3e30e6104459395f30f3441c17ac418bde6e37c03ab'
+PLAN_GUARD_SHA256 = '1b473c802ef20b91e3d7830dfff935aac588d61977e66c1c589dc4f4789351cd'
+PLAN_VERIFIER_SHA256 = 'f5d1ef651fc1b94450a8fcc7aed90dc121fd40142773e6a31e93fe94e4e4f1b5'
+
+def _sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+def _source_evidence() -> dict[str, Any]:
+    with tarfile.open(SOURCE_ARCHIVE, 'r:gz') as archive:
+        members = [member for member in archive.getmembers() if member.name == SOURCE_MEMBER]
+        if len(members) != 1:
+            raise ValueError(f'expected exactly one {SOURCE_MEMBER}')
+        extracted = archive.extractfile(members[0])
+        if extracted is None:
+            raise ValueError(f'unreadable source member: {SOURCE_MEMBER}')
+        member_bytes = extracted.read()
+    lines = member_bytes.decode('utf-8').splitlines()
+    texts = {name: '\n'.join(lines[start - 1:end]) + '\n' for name, (start, end, _) in SOURCE_BLOCKS.items()}
+    hashes = {name: hashlib.sha256(text.encode()).hexdigest() for name, text in texts.items()}
+    expected = {name: value for name, (_, _, value) in SOURCE_BLOCKS.items()}
+    checks = {'archive_hash_matches': _sha256(SOURCE_ARCHIVE) == SOURCE_ARCHIVE_SHA256, 'member_hash_matches': hashlib.sha256(member_bytes).hexdigest() == SOURCE_MEMBER_SHA256, 'source_blocks_match': hashes == expected, 'exponential_shift_seed_present': texts['shift_taylor_seed'].count('\\label{equ:exp-z}') == 1, 'taylor_seed_present': texts['shift_taylor_seed'].count('\\label{equ:PT-PDE}') == 1, 'p_indexed_tower_present': texts['pde_tower'].count('\\label{equ:k-th-PDEs}') == 1, 'complete_homogeneous_sum_present': texts['pde_tower'].count('\\sum_{l=0}^p') == 2}
+    return {'block_hashes': hashes, 'checks': checks}
+
+def complete_homogeneous(p: int, a: sp.Expr, b: sp.Expr) -> sp.Expr:
+    if p < 0:
+        raise ValueError('p must be nonnegative')
+    a, b = (sp.sympify(a), sp.sympify(b))
+    return sp.expand(sum((a ** (p - index) * b ** index for index in range(p + 1))))
+
+def divided_difference(p: int, a: sp.Expr, b: sp.Expr) -> sp.Expr:
+    a, b = (sp.sympify(a), sp.sympify(b))
+    if sp.simplify(a - b) == 0:
+        return sp.expand((p + 1) * a ** p)
+    return sp.cancel((a ** (p + 1) - b ** (p + 1)) / (a - b))
+
+def taylor_coefficient(p: int, a: sp.Expr, b: sp.Expr, omega: sp.Expr) -> sp.Expr:
+    return sp.expand((-sp.sympify(omega)) ** p * complete_homogeneous(p, a, b))
+
+def verify_kinematic_triple(a: sp.Expr, b: sp.Expr, omega: sp.Expr, *, max_p: int=12) -> dict[str, Any]:
+    a, b, omega = map(sp.sympify, (a, b, omega))
+    coefficients = [taylor_coefficient(p, a, b, omega) for p in range(max_p + 1)]
+    direct_closed = [sp.simplify(complete_homogeneous(p, a, b) - divided_difference(p, a, b)) for p in range(max_p + 1)]
+    recurrence = [sp.simplify(coefficients[p + 2] + omega * (a + b) * coefficients[p + 1] + omega ** 2 * a * b * coefficients[p]) for p in range(max_p - 1)]
+    x = sp.Symbol('x')
+    rational_kernel = 1 / ((1 + omega * a * x) * (1 + omega * b * x))
+    series = sp.series(rational_kernel, x, 0, max_p + 1).removeO().expand()
+    series_residuals = [sp.simplify(series.coeff(x, p) - coefficients[p]) for p in range(max_p + 1)]
+    coincident = sp.simplify(a - b) == 0
+    coincident_residuals = [sp.simplify(complete_homogeneous(p, a, b) - (p + 1) * a ** p) for p in range(max_p + 1)] if coincident else []
+    return {'a': a, 'b': b, 'omega': omega, 'max_p': max_p, 'coefficients': coefficients, 'divided_difference_residuals': direct_closed, 'recurrence_residuals': recurrence, 'generating_function_residuals': series_residuals, 'coincident': coincident, 'coincident_residuals': coincident_residuals, 'all_exact': all((value == 0 for value in [*direct_closed, *recurrence, *series_residuals, *coincident_residuals]))}
+
+def certificate_witnesses() -> dict[str, Any]:
+    triples = [(sp.Rational(1, 2), sp.Rational(2, 3), sp.Rational(3, 5)), (sp.Rational(-1, 3), sp.Rational(4, 5), sp.Rational(7, 4)), (sp.Rational(2), sp.Rational(2), sp.Rational(1, 3)), (sp.S.Zero, sp.S.Zero, sp.Rational(5, 7)), (sp.Rational(3, 4), sp.Rational(3, 4), sp.Rational(-2, 5))]
+    rows = [verify_kinematic_triple(*triple) for triple in triples]
+    a, b, x = sp.symbols('a b x')
+    symbolic_recurrence = [sp.expand(complete_homogeneous(p + 2, a, b) - (a + b) * complete_homogeneous(p + 1, a, b) + a * b * complete_homogeneous(p, a, b)) for p in range(6)]
+    return {'rational_kinematics': rows, 'symbolic_recurrence_residuals_p0_to_p5': symbolic_recurrence, 'generating_function': '1/((1-a*x)*(1-b*x))', 'resummed_pde_kernel': '1/((1+Omega*a*x)*(1+Omega*b*x))'}
+
+def build_exact_result() -> dict[str, Any]:
+    source = _source_evidence()
+    witnesses = certificate_witnesses()
+    rows = witnesses['rational_kinematics']
+    checks = dict(source['checks'])
+    checks.update({'rational_witnesses_exact_through_p12': all((row['all_exact'] and row['max_p'] == 12 for row in rows)), 'symbolic_second_order_recurrence_exact': all((value == 0 for value in witnesses['symbolic_recurrence_residuals_p0_to_p5'])), 'distinct_divided_differences_exact': all((all((value == 0 for value in row['divided_difference_residuals'])) for row in rows if not row['coincident'])), 'coincident_limits_exact': all((all((value == 0 for value in row['coincident_residuals'])) for row in rows if row['coincident'])), 'rational_generating_function_exact': all((all((value == 0 for value in row['generating_function_residuals'])) for row in rows))})
+    return {'result_version': 'sabrina_celestial_recursion_pde_generating_function_v1', 'status': 'complete' if all(checks.values()) else 'failed', 'paper': {'arxiv_id': '2208.11635', 'title': 'Celestial Recursion'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'coefficient_closed_form': 'S_p(a,b)=sum_(l=0)^p a^(p-l)b^l=(a^(p+1)-b^(p+1))/(a-b)', 'recurrence': 'S_(p+2)=(a+b)S_(p+1)-ab S_p', 'generating_function': 'sum_(p>=0) S_p x^p=1/((1-ax)(1-bx))', 'pde_resummation': 'the termwise Taylor identities resum on the amplitude to exp(xD)A=A/((1+Omega*a*x)(1+Omega*b*x))', 'coincident_limit': 'the removable a=b limit is S_p(a,a)=(p+1)a^p'}, 'certificate_witnesses': witnesses, 'exact_checks': checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'free_operator_commutativity_asserted': False, 'non_mhv_sector_proved': False, 'convergence_beyond_formal_series_proved': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
+
+def _jsonable(value: Any) -> Any:
+    if isinstance(value, dict):
+        return {key: _jsonable(item) for key, item in value.items()}
+    if isinstance(value, (list, tuple)):
+        return [_jsonable(item) for item in value]
+    if isinstance(value, sp.Basic):
+        return str(value)
+    return value
+
+def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
+    if out_dir.exists():
+        raise FileExistsError(f'immutable result target already exists: {out_dir}')
+    out_dir.mkdir(parents=True)
+    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
+    report = _jsonable(build_exact_result() | {'generated_utc': generated})
+    report_path = out_dir / 'celestial_recursion_pde_generating_function_report.json'
+    witness_path = out_dir / 'celestial_recursion_pde_generating_witnesses.json'
+    handoff_path = out_dir / 'CELESTIAL_RECURSION_PDE_GENERATING_FUNCTION_PRIVATE_HANDOFF.md'
+    manifest_path = out_dir / 'receipt_manifest.json'
+    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    witness_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'certificate_witnesses', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    handoff_path.write_text('# Celestial-recursion PDE generating function - private handoff\n\nThe infinite coefficient tower in the displayed p-indexed PDEs is a complete homogeneous polynomial sequence. It has a two-pole rational generating function, a second-order recurrence, and a removable coincident-kinematics limit. Consequently the termwise Taylor identities resum on the amplitude to one rational kernel. This is a formal-series statement on the amplitude, not a claim that the differential operator freely commutes with its kinematic coefficients.\n', encoding='utf-8')
+    artifacts = [report_path, witness_path, handoff_path]
+    expected = {name: value for name, (_, _, value) in SOURCE_BLOCKS.items()}
+    manifest = {'manifest_version': 'sabrina_celestial_recursion_pde_generating_function_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, **expected}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    all_artifacts = [*artifacts, manifest_path]
+    ledger: Mapping[str, Any] = {'status': 'skipped'}
+    if register_ledger:
+        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
+    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
+
+def main(argv: Sequence[str] | None=None) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
+    parser.add_argument('--no-register-crystal-ledger', action='store_true')
+    args = parser.parse_args(argv)
+    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
+    print(json.dumps(result, sort_keys=True))
+    return 0 if result['status'] == 'complete' else 1
+if __name__ == '__main__':
+    raise SystemExit(main())
diff --git a/ouroboros_replay/kernels/run_sabrina_coulomb_branch_complexity_ratio.py b/ouroboros_replay/kernels/run_sabrina_coulomb_branch_complexity_ratio.py
new file mode 100644
index 0000000000000000000000000000000000000000..4ac52d6b9942492cd4a01243513bdb1fdf993f28
--- /dev/null
+++ b/ouroboros_replay/kernels/run_sabrina_coulomb_branch_complexity_ratio.py
@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+from ..source_runtime import fixture_path, source_path
+import argparse
+import hashlib
+import json
+import tarfile
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Mapping, Sequence
+import sympy as sp
+from .crystal_ledger import register_crystal_artifacts
+OUT_DIR = Path('.replay_outputs') / 'out_dir'
+LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
+SOURCE_ARCHIVE = source_path('0c66795a0adac63d23dac9ad3207a4bd586f7453365221b95159bca9380edbc3')
+SOURCE_MEMBER = 'main-v2.tex'
+SOURCE_ARCHIVE_SHA256 = '0c66795a0adac63d23dac9ad3207a4bd586f7453365221b95159bca9380edbc3'
+SOURCE_MEMBER_SHA256 = '3612980847a10a3a07708a1af3dcee65afedc85ffc8106af673e69ae3d42585e'
+SOURCE_BLOCKS = {'complexity_volume_formulas': (1592, 1631, 'c7ab6918da6e15b37f48e4de2ea3403897be7be511e54772e0bc51b985e2a334')}
+PLAN_RECEIPT_SHA256 = '523489fdc6dca5719ff180bdc8aa59186042f4dccd85df9e18d35a508f68bd80'
+PLAN_GUARD_SHA256 = '063aad28b991bac44a25b7b64a53c97e3ce59ab1f0eb642611465fb2952a9b92'
+PLAN_VERIFIER_SHA256 = 'e8cb8ed50450be88fa0c8c8e579974093a6a56342da871fe2fc4612642a011a8'
+
+def _sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+def _source_evidence() -> dict[str, Any]:
+    with tarfile.open(SOURCE_ARCHIVE, 'r:*') as archive:
+        extracted = archive.extractfile(SOURCE_MEMBER)
+        if extracted is None:
+            raise ValueError(f'unreadable source member: {SOURCE_MEMBER}')
+        member_bytes = extracted.read()
+    lines = member_bytes.decode('utf-8').splitlines()
+    texts = {name: '\n'.join(lines[start - 1:end]) + '\n' for name, (start, end, _) in SOURCE_BLOCKS.items()}
+    hashes = {name: hashlib.sha256(text.encode()).hexdigest() for name, text in texts.items()}
+    expected = {name: value for name, (_, _, value) in SOURCE_BLOCKS.items()}
+    block = texts['complexity_volume_formulas']
+    checks = {'archive_hash_matches': _sha256(SOURCE_ARCHIVE) == SOURCE_ARCHIVE_SHA256, 'member_hash_matches': hashlib.sha256(member_bytes).hexdigest() == SOURCE_MEMBER_SHA256, 'source_blocks_match': hashes == expected, 'flat_formula_present': '\\label{CVpflat}' in block and '\\frac{1}{9-p}' in block, 'throat_formula_present': '\\label{CVpthroat}' in block and '\\frac{16}{32+(7-p)^2}' in block, 'formation_formula_present': '\\label{CVpform}' in block, 'physical_p_range_present': '0\\leq p \\leq 4' in block}
+    return {'block_hashes': hashes, 'checks': checks}
+
+def complexity_ratio(p_value: Any) -> sp.Expr:
+    p = sp.sympify(p_value)
+    return sp.factor((32 + (7 - p) ** 2) / (16 * (9 - p)))
+
+def fractional_deficit(p_value: Any) -> sp.Expr:
+    return sp.factor(1 - complexity_ratio(p_value))
+
+def algebraic_certificate() -> dict[str, Any]:
+    p = sp.symbols('p', real=True)
+    ratio = complexity_ratio(p)
+    deficit = fractional_deficit(p)
+    half_decomposition = sp.Rational(1, 2) + (p - 3) ** 2 / (16 * (9 - p))
+    derivative = sp.factor(sp.diff(ratio, p))
+    table = [{'p': value, 'flat_over_throat': str(complexity_ratio(value)), 'fractional_deficit': str(fractional_deficit(value))} for value in range(5)]
+    ratio_values = [complexity_ratio(value) for value in range(5)]
+    checks = {'ratio_from_source_coefficients_exact': sp.simplify(ratio - 1 / (9 - p) / (16 / (32 + (7 - p) ** 2))) == 0, 'half_plus_square_decomposition_exact': sp.simplify(ratio - half_decomposition) == 0, 'deficit_factorization_exact': sp.simplify(deficit - (7 - p) * (9 + p) / (16 * (9 - p))) == 0, 'derivative_factorization_exact': sp.simplify(derivative + (p - 15) * (p - 3) / (16 * (p - 9) ** 2)) == 0, 'physical_table_exact': ratio_values == [sp.Rational(9, 16), sp.Rational(17, 32), sp.Rational(57, 112), sp.Rational(1, 2), sp.Rational(41, 80)], 'physical_bounds_exact': min(ratio_values) == sp.Rational(1, 2) and max(ratio_values) == sp.Rational(9, 16), 'unique_physical_minimum_at_p3': [value for value in range(5) if complexity_ratio(value) == sp.Rational(1, 2)] == [3], 'formation_is_negative': all((fractional_deficit(value) > 0 for value in range(5)))}
+    return {'ratio': str(ratio), 'half_plus_square': str(half_decomposition), 'fractional_deficit': str(deficit), 'derivative': str(derivative), 'physical_table': table, 'checks': checks}
+
+def build_exact_result() -> dict[str, Any]:
+    source = _source_evidence()
+    algebra = algebraic_certificate()
+    checks = dict(source['checks'])
+    checks.update(algebra['checks'])
+    return {'result_version': 'sabrina_coulomb_branch_complexity_ratio_v1', 'status': 'complete' if all(checks.values()) else 'failed', 'paper': {'arxiv_id': '2606.13889', 'title': 'Flat Space Entanglement: A Coulomb Branch Perspective'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'universal_ratio': 'C_flat/C_throat=[32+(7-p)^2]/[16(9-p)]', 'manifest_minimum': 'ratio=1/2+(p-3)^2/[16(9-p)]', 'physical_bounds': '1/2 <= C_flat/C_throat <= 9/16 for p=0,1,2,3,4', 'maximal_reduction': 'p=3 uniquely gives a one-half fractional complexity reduction', 'parameter_cancellation': 'R, r_p, G_10, Omega_(8-p), and V_p cancel from the ratio'}, 'algebraic_certificate': algebra, 'exact_checks': checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'complexity_equals_volume_only': True, 'physical_integer_p_zero_through_four_only': True, 'complexity_equals_action_claimed': False, 'field_theory_circuit_complexity_equality_claimed': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
+
+def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
+    if out_dir.exists():
+        raise FileExistsError(f'immutable result target already exists: {out_dir}')
+    out_dir.mkdir(parents=True)
+    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
+    report = build_exact_result() | {'generated_utc': generated}
+    report_path = out_dir / 'coulomb_branch_complexity_ratio_report.json'
+    witness_path = out_dir / 'coulomb_branch_complexity_ratio_witnesses.json'
+    handoff_path = out_dir / 'COULOMB_BRANCH_COMPLEXITY_RATIO_PRIVATE_HANDOFF.md'
+    manifest_path = out_dir / 'receipt_manifest.json'
+    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    witness_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'algebraic_certificate', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    handoff_path.write_text('# Coulomb-branch complexity ratio - private handoff\n\nNormalizing the flat-bubble Complexity=Volume result by the corresponding throat value cancels every geometric and coupling prefactor. For physical p=0 through 4, the ratio lies between one-half and nine-sixteenths; p=3 uniquely maximizes the fractional reduction at one-half. No Complexity=Action, exact field-theory circuit-complexity, or publication claim is made.\n', encoding='utf-8')
+    artifacts = [report_path, witness_path, handoff_path]
+    manifest = {'manifest_version': 'sabrina_coulomb_branch_complexity_ratio_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, **{name: value for name, (_, _, value) in SOURCE_BLOCKS.items()}}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    all_artifacts = [*artifacts, manifest_path]
+    ledger: Mapping[str, Any] = {'status': 'skipped'}
+    if register_ledger:
+        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
+    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
+
+def main(argv: Sequence[str] | None=None) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
+    parser.add_argument('--no-register-crystal-ledger', action='store_true')
+    args = parser.parse_args(argv)
+    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
+    print(json.dumps(result, sort_keys=True))
+    return 0 if result['status'] == 'complete' else 1
+if __name__ == '__main__':
+    raise SystemExit(main())
diff --git a/ouroboros_replay/kernels/run_sabrina_detector_sum_identity_correction.py b/ouroboros_replay/kernels/run_sabrina_detector_sum_identity_correction.py
new file mode 100644
index 0000000000000000000000000000000000000000..e21280329a1d97ccc8ef249a4039916621c24ad6
--- /dev/null
+++ b/ouroboros_replay/kernels/run_sabrina_detector_sum_identity_correction.py
@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+from ..source_runtime import fixture_path, source_path
+import argparse
+import hashlib
+import json
+import tarfile
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Mapping, Sequence
+import sympy as sp
+from .crystal_ledger import register_crystal_artifacts
+OUT_DIR = Path('.replay_outputs') / 'out_dir'
+LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
+SOURCE_ARCHIVE = source_path('98acf1e79b6d6fb929626e11f40fdb0d4a4029f174f6c493f7639e721c7424b0')
+PREDECESSOR_MANIFEST = fixture_path('764f819b652785e2394101cf78d0463dc893379e30a80732430a2261b20269f7')
+SOURCE_ARCHIVE_SHA256 = '98acf1e79b6d6fb929626e11f40fdb0d4a4029f174f6c493f7639e721c7424b0'
+SOURCE_MEMBER_SHA256 = '6c5a28fae38e51e317326891ba2758e38766bf8eed98f5cb6941c8a46ade7dd6'
+PREDECESSOR_MANIFEST_SHA256 = '764f819b652785e2394101cf78d0463dc893379e30a80732430a2261b20269f7'
+SOURCE_BLOCKS = {'identity': ('\\label{equ:sum-ID}', '92c7292e6f133f1b9c99b185a20a6e0e4f8b09b52d3d2ea47948c9bbff8d33a3'), 'first_derivative_use': ("\\Big(\\pa_{\\o_2}^n\\o_2^{-k'}\\Big)", '097ac2823f2a3abd9516d03b01d804b0c0456ccc8a83fe9863646c41930695f7'), 'second_derivative_use': ("\\label{equ:omega-integeral-q2sRs'}", '90fd4d54db45a0b1e3bae6b70d265748a47ce79f30e3d1b11dceb3df54f3b3e1')}
+REFERENCE = '\\ref{equ:sum-ID}'
+REFERENCE_CONTEXT_SHA256 = ('817f663507d9b9bd5f2bd14a48c291d1d490449b265a1c3251558bb785445458', 'b3d35603938e2b2c7f94b9d2ad11b9f56cb6eb265c7480ec0601375bc6073c9d')
+PLAN_RECEIPT_SHA256 = '9e6aa3ae52f73ec35a81382b1c468da3757ac69732c3876f1a8240fffc349903'
+PLAN_GUARD_SHA256 = '935ebe8d452ce33140f398396460e155803a15fdcc6f2fc6c363e760eedfe0c6'
+PLAN_VERIFIER_SHA256 = '98aabf083fbdf86595c8246412d9c9b3971bdcff04e7149ad588b5a2d90f9f9a'
+
+def _sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+def _equation_environment(source: str, marker: str) -> bytes:
+    marker_index = source.index(marker)
+    start = source.rfind('\\begin{equation}', 0, marker_index)
+    end_token = '\\end{equation}'
+    end = source.find(end_token, marker_index)
+    if start < 0 or end < 0:
+        raise ValueError('equation environment not found')
+    return source[start:end + len(end_token)].encode('latin-1')
+
+def _reference_context_hashes(source: str) -> list[str]:
+    hashes = []
+    cursor = 0
+    while True:
+        index = source.find(REFERENCE, cursor)
+        if index < 0:
+            return hashes
+        start = max(0, source.rfind('\n', 0, max(0, index - 220)))
+        end = source.find('\n', min(len(source), index + len(REFERENCE) + 220))
+        if end < 0:
+            end = len(source)
+        hashes.append(hashlib.sha256(source[start:end].encode('latin-1')).hexdigest())
+        cursor = index + len(REFERENCE)
+
+def _source_evidence() -> dict[str, Any]:
+    with tarfile.open(SOURCE_ARCHIVE, 'r:gz') as archive:
+        members = [member for member in archive.getmembers() if Path(member.name).name == 'main.tex']
+        if len(members) != 1:
+            raise ValueError('expected exactly one main.tex source member')
+        extracted = archive.extractfile(members[0])
+        if extracted is None:
+            raise ValueError('main.tex source member is unreadable')
+        member_bytes = extracted.read()
+    source = member_bytes.decode('latin-1')
+    block_hashes = {name: hashlib.sha256(_equation_environment(source, marker)).hexdigest() for name, (marker, _) in SOURCE_BLOCKS.items()}
+    expected_blocks = {name: expected for name, (_, expected) in SOURCE_BLOCKS.items()}
+    context_hashes = _reference_context_hashes(source)
+    checks = {'archive_hash_matches': _sha256(SOURCE_ARCHIVE) == SOURCE_ARCHIVE_SHA256, 'main_tex_hash_matches': hashlib.sha256(member_bytes).hexdigest() == SOURCE_MEMBER_SHA256, 'source_equation_blocks_match': block_hashes == expected_blocks, 'source_markers_are_unique': all((source.count(marker) == 1 for marker, _ in SOURCE_BLOCKS.values())), 'downstream_reference_count_is_two': source.count(REFERENCE) == 2, 'downstream_reference_contexts_match': tuple(context_hashes) == REFERENCE_CONTEXT_SHA256, 'predecessor_manifest_hash_matches': _sha256(PREDECESSOR_MANIFEST) == PREDECESSOR_MANIFEST_SHA256}
+    return {'block_hashes': block_hashes, 'reference_context_sha256': context_hashes, 'checks': checks}
+
+def build_exact_result() -> dict[str, Any]:
+    source = _source_evidence()
+    x = sp.Symbol('omega', positive=True)
+    kp = sp.Symbol('kprime', integer=True, nonnegative=True)
+    order = sp.Symbol('K', integer=True, positive=True)
+    derivative_checks = []
+    convention_checks = []
+    for n in range(13):
+        derivative_checks.append(sp.simplify(sp.diff(x ** (-kp), x, n) - sp.ff(-kp, n) * x ** (-kp - n)) == 0)
+        convention_checks.append(sp.simplify(sp.expand_func(sp.ff(-kp, n)) * (-1) ** n - sp.rf(kp, n)) == 0)
+    grid_rows = []
+    for kprime in range(13):
+        for cutoff in range(13):
+            source_local = sp.simplify(sum((sp.ff(-kprime, n) * (-1) ** n / sp.factorial(n) for n in range(cutoff + 1))))
+            rising_misread = sp.simplify(sum((sp.rf(-kprime, n) * (-1) ** n / sp.factorial(n) for n in range(cutoff + 1))))
+            final = sp.binomial(kprime + cutoff, cutoff)
+            grid_rows.append({'kprime': kprime, 'cutoff': cutoff, 'source_local_falling_sum': str(source_local), 'rising_misread_sum': str(rising_misread), 'displayed_final': str(final), 'source_local_matches': source_local == final})
+    recurrence_residual = sp.combsimp(sp.binomial(kp + order, order) - sp.binomial(kp + order - 1, order - 1) - sp.rf(kp, order) / sp.factorial(order))
+    counterexample_row = next((row for row in grid_rows if row['kprime'] == 2 and row['cutoff'] == 2))
+    exact_checks = dict(source['checks'])
+    exact_checks.update({'derivative_falling_factorial_holds_through_order_12': all(derivative_checks), 'falling_negative_to_rising_positive_holds_through_order_12': all(convention_checks), 'source_local_identity_holds_on_full_0_through_12_grid': all((row['source_local_matches'] for row in grid_rows)), 'source_local_kprime2_cutoff2_is_six': counterexample_row['source_local_falling_sum'] == '6', 'v1_rising_misread_kprime2_cutoff2_is_four': counterexample_row['rising_misread_sum'] == '4', 'displayed_final_kprime2_cutoff2_is_six': counterexample_row['displayed_final'] == '6', 'symbolic_recurrence_residual_is_zero': recurrence_residual == 0, 'symbolic_base_case_is_one': sp.binomial(kp, 0) == 1})
+    return {'result_version': 'sabrina_detector_sum_identity_convention_reaudit_v2', 'status': 'complete' if all(exact_checks.values()) else 'failed', 'paper': {'arxiv_id': '2307.16801', 'title': 'Detector Operators for Celestial Symmetries'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'main_tex_sha256': SOURCE_MEMBER_SHA256, **source}, 'convention_certificate': {'source_local_notation': 'falling_factorial(a,n)=Gamma(a+1)/Gamma(a-n+1)', 'derivative_rule': 'd^n omega^a / d omega^n = falling_factorial(a,n) omega^(a-n)', 'sign_conversion': 'falling_factorial(-kprime,n)(-1)^n = rising_factorial(kprime,n)', 'closed_form': 'sum rising_factorial(kprime,n)/n! = binomial(kprime+K,K)', 'symbolic_recurrence_residual': str(recurrence_residual)}, 'kprime2_cutoff2': counterexample_row, 'grid_rows': grid_rows, 'classification': 'v1_false_positive_superseded_source_local_falling_factorial_identity_exact', 'exact_checks': exact_checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'supersession': {'predecessor_manifest_sha256': PREDECESSOR_MANIFEST_SHA256, 'predecessor_claim_valid': False, 'reason': 'v1 interpreted source-local falling-factorial notation as standard rising Pochhammer', 'predecessor_artifacts_mutated': False}, 'claim_boundary': {'source_equation_correction_established': False, 'downstream_physics_correction_established': False, 'notation_ambiguity_requires_erratum': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
+
+def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
+    if out_dir.exists():
+        raise FileExistsError(f'immutable result target already exists: {out_dir}')
+    out_dir.mkdir(parents=True)
+    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
+    report = build_exact_result() | {'generated_utc': generated}
+    report_path = out_dir / 'detector_sum_identity_convention_reaudit_report.json'
+    certificate_path = out_dir / 'detector_sum_identity_convention_reaudit_certificate.json'
+    handoff_path = out_dir / 'DETECTOR_SUM_IDENTITY_CONVENTION_REAUDIT_PRIVATE_HANDOFF.md'
+    manifest_path = out_dir / 'receipt_manifest.json'
+    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    certificate_path.write_text(json.dumps({key: report[key] for key in ('convention_certificate', 'kprime2_cutoff2', 'supersession', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    handoff_path.write_text("# Detector sum identity convention re-audit - private handoff\n\nThe v1 correction claim is superseded. In the source-local derivative convention, (a)_n is the falling factorial Gamma(a+1)/Gamma(a-n+1). Therefore (-k')_n(-1)^n is the rising factorial (k')_n, and the displayed finite sum equals the displayed binomial exactly. At k'=2 and K=2 the source-local sum is 6; the value 4 came only from applying the wrong rising convention to the first symbol. No source or downstream physics correction is established. The immutable v1 package remains unchanged as audit evidence.\n", encoding='utf-8')
+    artifacts = [report_path, certificate_path, handoff_path]
+    manifest = {'manifest_version': 'sabrina_detector_sum_identity_convention_reaudit_manifest_v2', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, 'main.tex': SOURCE_MEMBER_SHA256, **{name: expected for name, (_, expected) in SOURCE_BLOCKS.items()}}, 'authority': report['authority'], 'supersedes_manifest_sha256': PREDECESSOR_MANIFEST_SHA256, 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    all_artifacts = [*artifacts, manifest_path]
+    ledger: Mapping[str, Any] = {'status': 'skipped'}
+    if register_ledger:
+        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
+    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
+
+def main(argv: Sequence[str] | None=None) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
+    parser.add_argument('--no-register-crystal-ledger', action='store_true')
+    args = parser.parse_args(argv)
+    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
+    print(json.dumps(result, sort_keys=True))
+    return 0 if result['status'] == 'complete' else 1
+if __name__ == '__main__':
+    raise SystemExit(main())
diff --git a/ouroboros_replay/kernels/run_sabrina_electromagnetic_memory_detector_tradeoff.py b/ouroboros_replay/kernels/run_sabrina_electromagnetic_memory_detector_tradeoff.py
new file mode 100644
index 0000000000000000000000000000000000000000..2e18382485aabfa968743419c068abed067a9608
--- /dev/null
+++ b/ouroboros_replay/kernels/run_sabrina_electromagnetic_memory_detector_tradeoff.py
@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+from ..source_runtime import fixture_path, source_path
+import argparse
+import hashlib
+import json
+import tarfile
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Mapping, Sequence
+import sympy as sp
+from .crystal_ledger import register_crystal_artifacts
+OUT_DIR = Path('.replay_outputs') / 'out_dir'
+LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
+SOURCE_ARCHIVE = source_path('7713c97d18c7b5ac41c1cb8884d73bddd6d1639551b3e91aef46d1a715fe67e4')
+SOURCE_MEMBER = 'pasterski.tex'
+SOURCE_ARCHIVE_SHA256 = '7713c97d18c7b5ac41c1cb8884d73bddd6d1639551b3e91aef46d1a715fe67e4'
+SOURCE_MEMBER_SHA256 = '6fbd3de4c6141084f8081ce6bfc8c6fe3e96a09bb464522372e8dcedefde275a'
+SOURCE_BLOCKS = {'memory_integral': (255, 265, '7105277fbcefb26d56dba812d7d60bdd1b1091ecb47159d4710c7beddb8e9217'), 'viscous_detector': (341, 351, 'f6a7472106636a01427a5880472e49258b6f3087b4901d55e5eadfc47b241a9e')}
+PLAN_RECEIPT_SHA256 = '21d6d19e68132429a932c157e5025e3275ac72dc6972b2645f3c9c7e56d1750b'
+PLAN_GUARD_SHA256 = '3c9bdb2859a3c0eaf6bb0ad95f94f99e787debc0a12400421672e723f7c1b551'
+PLAN_VERIFIER_SHA256 = '17cd5bed5810625ff4bf680d907733489d694f417dbb20ee1267d59dbff6af3a'
+
+def _sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+def _source_evidence() -> dict[str, Any]:
+    with tarfile.open(SOURCE_ARCHIVE, 'r:*') as archive:
+        member_bytes = archive.extractfile(SOURCE_MEMBER).read()
+    lines = member_bytes.decode('utf-8', errors='replace').splitlines()
+    texts = {name: '\n'.join(lines[start - 1:end]) + '\n' for name, (start, end, _) in SOURCE_BLOCKS.items()}
+    hashes = {name: hashlib.sha256(text.encode()).hexdigest() for name, text in texts.items()}
+    expected = {name: value for name, (_, _, value) in SOURCE_BLOCKS.items()}
+    memory, detector = (texts['memory_integral'], texts['viscous_detector'])
+    checks = {'archive_hash_matches': _sha256(SOURCE_ARCHIVE) == SOURCE_ARCHIVE_SHA256, 'member_hash_matches': hashlib.sha256(member_bytes).hexdigest() == SOURCE_MEMBER_SHA256, 'source_blocks_match': hashes == expected, 'time_integrated_field_present': 'time integrated radiated electric field' in memory, 'slow_ramp_claim_present': 'power flux arbitrarily small' in memory and 'same end point' in memory, 'linear_drag_present': '\\vec{F}_D=-\\sigma \\vec{v}' in detector, 'displacement_relation_present': '\\sigma \\Delta \\vec{x}' in detector, 'brownian_limit_present': 'Brownian motion' in detector}
+    return {'block_hashes': hashes, 'checks': checks}
+
+def endpoint_memory_certificate() -> dict[str, Any]:
+    mass, sigma, charge, memory, delta_v = sp.symbols('m sigma Q M Delta_v', positive=True)
+    delta_x = (charge * memory - mass * delta_v) / sigma
+    integrated_residual = sp.expand(mass * delta_v + sigma * delta_x - charge * memory)
+    rest_displacement = sp.simplify(delta_x.subs(delta_v, 0))
+    checks = {'integrated_dynamics_exact': integrated_residual == 0, 'endpoint_correction_exact': sp.simplify(delta_x - charge * memory / sigma + mass * delta_v / sigma) == 0, 'rest_endpoint_displacement_exact': rest_displacement == charge * memory / sigma, 'pulse_shape_absent_after_integration': len(delta_x.free_symbols - {mass, sigma, charge, memory, delta_v}) == 0}
+    return {'integrated_identity': 'sigma*Delta_x=Q*M-m*Delta_v', 'endpoint_corrected_displacement': str(delta_x), 'rest_endpoint_displacement': str(rest_displacement), 'checks': checks}
+
+def fluence_certificate() -> dict[str, Any]:
+    time, duration, memory = sp.symbols('t T M', positive=True)
+    constant = memory / duration
+    triangle_left = 4 * memory * time / duration ** 2
+    triangle_right = 4 * memory * (duration - time) / duration ** 2
+    constant_memory = sp.integrate(constant, (time, 0, duration))
+    constant_fluence = sp.integrate(constant ** 2, (time, 0, duration))
+    triangle_memory = sp.integrate(triangle_left, (time, 0, duration / 2)) + sp.integrate(triangle_right, (time, duration / 2, duration))
+    triangle_fluence = sp.integrate(triangle_left ** 2, (time, 0, duration / 2)) + sp.integrate(triangle_right ** 2, (time, duration / 2, duration))
+    cauchy_lower_bound = memory ** 2 / duration
+    checks = {'constant_pulse_memory_exact': sp.simplify(constant_memory - memory) == 0, 'constant_pulse_saturates_bound': sp.simplify(constant_fluence - cauchy_lower_bound) == 0, 'triangle_has_same_memory': sp.simplify(triangle_memory - memory) == 0, 'triangle_is_strictly_above_bound': sp.simplify(triangle_fluence / cauchy_lower_bound) == sp.Rational(4, 3), 'slow_ramp_fluence_tends_to_zero': sp.limit(cauchy_lower_bound, duration, sp.oo) == 0}
+    return {'cauchy_schwarz_bound': 'Phi*T>=M^2', 'constant_ramp_fluence': str(constant_fluence), 'triangle_ramp_fluence': str(triangle_fluence), 'checks': checks}
+
+def brownian_tradeoff_certificate() -> dict[str, Any]:
+    charge, memory, sigma, thermal_energy, duration = sp.symbols('Q M sigma kBT T', positive=True)
+    signal = charge * memory / sigma
+    variance = 2 * thermal_energy * duration / sigma
+    snr_squared = sp.factor(signal ** 2 / variance)
+    constant_fluence = memory ** 2 / duration
+    expected = charge ** 2 * constant_fluence / (2 * thermal_energy * sigma)
+    checks = {'overdamped_displacement_variance_exact': variance == 2 * thermal_energy * duration / sigma, 'snr_squared_exact': sp.simplify(snr_squared - charge ** 2 * memory ** 2 / (2 * thermal_energy * sigma * duration)) == 0, 'snr_fluence_identity_exact': sp.simplify(snr_squared - expected) == 0, 'slow_ramp_snr_tends_to_zero': sp.limit(snr_squared, duration, sp.oo) == 0}
+    return {'signal_displacement': str(signal), 'displacement_variance': str(variance), 'snr_squared': str(snr_squared), 'snr_fluence_identity': 'SNR^2=Q^2*Phi/(2*kBT*sigma)', 'checks': checks}
+
+def build_exact_result() -> dict[str, Any]:
+    source = _source_evidence()
+    endpoint = endpoint_memory_certificate()
+    fluence = fluence_certificate()
+    brownian = brownian_tradeoff_certificate()
+    checks = dict(source['checks'])
+    checks.update(endpoint['checks'])
+    checks.update(fluence['checks'])
+    checks.update(brownian['checks'])
+    return {'result_version': 'sabrina_electromagnetic_memory_detector_tradeoff_v1', 'status': 'complete' if all(checks.values()) else 'failed', 'paper': {'arxiv_id': '1505.00716', 'title': 'Asymptotic Symmetries and Electromagnetic Memory'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'endpoint_identity': 'sigma Delta x=Q M-m Delta v', 'rest_endpoint_memory': 'Delta x=Q M/sigma', 'fixed_memory_fluence_bound': 'Phi>=M^2/T', 'constant_ramp_tradeoff': 'Phi=M^2/T and SNR^2=Q^2 Phi/(2 kBT sigma)'}, 'endpoint_memory_certificate': endpoint, 'fluence_certificate': fluence, 'brownian_tradeoff_certificate': brownian, 'exact_checks': checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'linear_drag_only': True, 'rest_endpoints_required_for_shape_independence': True, 'quadratic_fluence_proxy_only': True, 'brownian_result_overdamped_equilibrium_white_noise_only': True, 'experimental_feasibility_claimed': False, 'arbitrary_noise_or_nonlinear_drag_claimed': False, 'full_electromagnetic_energy_normalization_claimed': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
+
+def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
+    if out_dir.exists():
+        raise FileExistsError(f'immutable result target already exists: {out_dir}')
+    out_dir.mkdir(parents=True)
+    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
+    report = build_exact_result() | {'generated_utc': generated}
+    report_path = out_dir / 'electromagnetic_memory_detector_tradeoff_report.json'
+    witness_path = out_dir / 'electromagnetic_memory_detector_tradeoff_witnesses.json'
+    handoff_path = out_dir / 'ELECTROMAGNETIC_MEMORY_DETECTOR_TRADEOFF_PRIVATE_HANDOFF.md'
+    manifest_path = out_dir / 'receipt_manifest.json'
+    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    witness_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'endpoint_memory_certificate', 'fluence_certificate', 'brownian_tradeoff_certificate', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    handoff_path.write_text('# Electromagnetic-memory detector tradeoff - private handoff\n\nThe viscous-bead proposal extends to the full linear damped equation through an exact endpoint correction. Rest endpoints make displacement depend only on integrated field. A constant slow ramp minimizes quadratic fluence, but in the stated overdamped thermal model its Brownian SNR falls in direct proportion to that fluence. No experimental-feasibility or general-noise claim is made.\n', encoding='utf-8')
+    artifacts = [report_path, witness_path, handoff_path]
+    manifest = {'manifest_version': 'sabrina_electromagnetic_memory_detector_tradeoff_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, **{name: value for name, (_, _, value) in SOURCE_BLOCKS.items()}}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    all_artifacts = [*artifacts, manifest_path]
+    ledger: Mapping[str, Any] = {'status': 'skipped'}
+    if register_ledger:
+        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
+    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
+
+def main(argv: Sequence[str] | None=None) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
+    parser.add_argument('--no-register-crystal-ledger', action='store_true')
+    args = parser.parse_args(argv)
+    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
+    print(json.dumps(result, sort_keys=True))
+    return 0 if result['status'] == 'complete' else 1
+if __name__ == '__main__':
+    raise SystemExit(main())
diff --git a/ouroboros_replay/kernels/run_sabrina_entanglement_scattering_slack_identity.py b/ouroboros_replay/kernels/run_sabrina_entanglement_scattering_slack_identity.py
new file mode 100644
index 0000000000000000000000000000000000000000..0e11ff831c6cd2a494320fbd5ea98373b17efcf6
--- /dev/null
+++ b/ouroboros_replay/kernels/run_sabrina_entanglement_scattering_slack_identity.py
@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+from ..source_runtime import fixture_path, source_path
+import argparse
+import hashlib
+import json
+import tarfile
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Mapping, Sequence
+import sympy as sp
+from .crystal_ledger import register_crystal_artifacts
+OUT_DIR = Path('.replay_outputs') / 'out_dir'
+LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
+SOURCE_ARCHIVE = source_path('8a55509c4b902e68016cb16a722efeb692056e6530cb2d6838b87fe77d6d84f6')
+SOURCE_MEMBER = 'main.tex'
+SOURCE_ARCHIVE_SHA256 = '8a55509c4b902e68016cb16a722efeb692056e6530cb2d6838b87fe77d6d84f6'
+SOURCE_MEMBER_SHA256 = '67a3bec7a35d950e982ea7edeccca1c7f0401539106bd1edbfea9e3b80013b0e'
+SOURCE_BLOCKS = {'mutual_information_definition': (647, 653, '180f95e32264465f0b06a545094bbc73fe1b5a07fc6e5b02e2dce4ec06bec1a1'), 'warmup_entanglement_ridge': (793, 820, 'ba55cae873427b912363ea39970fb97d305e2e96912512479cbd6dfe54cf36ba'), 'warmup_mutual_information_ridge': (822, 864, '2c8e40f06fdad817d5882b4e71e7ab6cc8d678c36ec327735d5c729b84d9047a'), 'future_work_scope': (1289, 1297, '53879de714d7277342abc026d9e3697f1d6779fa225bcb29545c76cbc6b177f4')}
+PLAN_RECEIPT_SHA256 = 'ead749551c71fddba4939bed4f25be49769283875e651c8792027f51b0f9d4a1'
+PLAN_GUARD_SHA256 = 'ef4acda188a7f3e9775bd45093b153e9c8def60d321d21e60afdedd1e7226ab3'
+PLAN_VERIFIER_SHA256 = '81b130cace6de5ff7f63ad2f45eb7373d3c10fcd078b7bb69cabc363be5fe74e'
+
+def _sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+def _source_evidence() -> dict[str, Any]:
+    with tarfile.open(SOURCE_ARCHIVE, 'r:gz') as archive:
+        members = [member for member in archive.getmembers() if member.name == SOURCE_MEMBER]
+        if len(members) != 1:
+            raise ValueError(f'expected exactly one {SOURCE_MEMBER}')
+        extracted = archive.extractfile(members[0])
+        if extracted is None:
+            raise ValueError(f'unreadable source member: {SOURCE_MEMBER}')
+        member_bytes = extracted.read()
+    lines = member_bytes.decode('utf-8').splitlines()
+    block_texts = {name: '\n'.join(lines[start - 1:end]) + '\n' for name, (start, end, _) in SOURCE_BLOCKS.items()}
+    block_hashes = {name: hashlib.sha256(text.encode()).hexdigest() for name, text in block_texts.items()}
+    expected = {name: expected_hash for name, (_, _, expected_hash) in SOURCE_BLOCKS.items()}
+    checks = {'archive_hash_matches': _sha256(SOURCE_ARCHIVE) == SOURCE_ARCHIVE_SHA256, 'member_hash_matches': hashlib.sha256(member_bytes).hexdigest() == SOURCE_MEMBER_SHA256, 'source_blocks_match': block_hashes == expected, 'mutual_information_equation_present': block_texts['mutual_information_definition'].count('\\label{mibulk}') == 1, 'entanglement_ridge_bound_present': block_texts['warmup_entanglement_ridge'].count('\\label{eq: Sgen(sent) > Re}') == 1, 'two_focusing_equations_present': block_texts['warmup_mutual_information_ridge'].count('\\int_{\\mathcal{N}_') == 2, 'mutual_information_ridge_bound_present': block_texts['warmup_mutual_information_ridge'].count('\\label{eq: I < Re}') == 1}
+    return {'block_hashes': block_hashes, 'checks': checks}
+
+def symbolic_certificate() -> dict[str, Any]:
+    g = sp.symbols('G_N', positive=True)
+    ridge, x12 = sp.symbols('R X_12', real=True)
+    sigma_ent, delta_min, sigma_lift, sigma_slope = sp.symbols('sigma_ent delta_min sigma_lift sigma_slope', nonnegative=True)
+    seam = x12 - sigma_slope
+    trial = seam + 2 * ridge - sigma_lift
+    disconnected = trial - delta_min
+    mutual_information = (disconnected - x12) / (4 * g)
+    wedge_entropy = (2 * ridge + sigma_ent) / (4 * g)
+    gap = sp.factor(wedge_entropy - mutual_information)
+    slack_sum = sigma_ent + delta_min + sigma_lift + sigma_slope
+    residuals = {'entanglement_focusing': sp.simplify(4 * g * wedge_entropy - 2 * ridge - sigma_ent), 'lift_focusing': sp.simplify(trial - seam - 2 * ridge + sigma_lift), 'slope_focusing': sp.simplify(seam - x12 + sigma_slope), 'minimality': sp.simplify(trial - disconnected - delta_min), 'gap_identity': sp.simplify(4 * g * gap - slack_sum)}
+    symbols = [sigma_ent, delta_min, sigma_lift, sigma_slope]
+    equality_rows = []
+    for mask in range(16):
+        values = {symbol: sp.Integer(mask >> index & 1) for index, symbol in enumerate(symbols)}
+        numerator = sp.simplify(slack_sum.subs(values))
+        equality_rows.append({'mask': mask, 'numerator': str(numerator), 'gap_zero': numerator == 0, 'all_slacks_zero': all((value == 0 for value in values.values()))})
+    witness_values = {g: sp.Rational(7, 3), ridge: 100, x12: 40, sigma_ent: 2, delta_min: 3, sigma_lift: 5, sigma_slope: 7}
+    return {'definitions': {'sigma_ent': '4 G_N S_gen(s_ent) - 2 Area(R_ent)', 'delta_min': 'Area(D) - [Area(E(V_1)) + Area(E(V_2))]', 'sigma_lift': '-[Area(D) - Area(A) - 2 Area(R_ent)]', 'sigma_slope': 'Area(E(X_1 union X_2)) - Area(A)'}, 'gap': str(gap), 'gap_numerator': str(slack_sum), 'residuals': {name: str(value) for name, value in residuals.items()}, 'equality_grid': equality_rows, 'numerical_witness': {'gap': str(sp.simplify(gap.subs(witness_values))), 'expected_gap': str(sp.simplify(slack_sum.subs(witness_values) / (4 * witness_values[g]))), 'all_primitive_areas_positive': all((value.subs(witness_values) > 0 for value in (seam, trial, disconnected, mutual_information, wedge_entropy)))}}
+
+def build_exact_result() -> dict[str, Any]:
+    source = _source_evidence()
+    certificate = symbolic_certificate()
+    checks = dict(source['checks'])
+    checks.update({'all_symbolic_residuals_zero': all((value == '0' for value in certificate['residuals'].values())), 'equality_iff_all_slacks_zero': all((row['gap_zero'] == row['all_slacks_zero'] for row in certificate['equality_grid'])), 'numerical_witness_exact': certificate['numerical_witness']['gap'] == certificate['numerical_witness']['expected_gap'], 'numerical_witness_geometric': certificate['numerical_witness']['all_primitive_areas_positive']})
+    return {'result_version': 'sabrina_entanglement_scattering_slack_identity_v1', 'status': 'complete' if all(checks.values()) else 'failed', 'paper': {'arxiv_id': '2604.22612', 'title': 'Generalized Entanglement Wedges and the Connected Wedge Theorem'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'regime': "the paper's warm-up entanglement-scattering configuration and its stated focusing/minimality assumptions", 'identity': 'S_gen(s_ent)-I(V_1;V_2)=(sigma_ent+delta_min+sigma_lift+sigma_slope)/(4 G_N)', 'positivity': 'all four slacks are nonnegative when G_N>0', 'saturation': 'equality holds if and only if all four slacks vanish'}, 'symbolic_certificate': certificate, 'exact_checks': checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'general_configuration_reproved': False, 'matter_entropy_terms_rederived': False, 'quantum_task_dual_constructed': False, 'flat_space_limit_extended': False, 'source_error_claimed': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
+
+def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
+    if out_dir.exists():
+        raise FileExistsError(f'immutable result target already exists: {out_dir}')
+    out_dir.mkdir(parents=True)
+    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
+    report = build_exact_result() | {'generated_utc': generated}
+    report_path = out_dir / 'entanglement_scattering_slack_identity_report.json'
+    certificate_path = out_dir / 'entanglement_scattering_slack_certificate.json'
+    handoff_path = out_dir / 'ENTANGLEMENT_SCATTERING_SLACK_PRIVATE_HANDOFF.md'
+    manifest_path = out_dir / 'receipt_manifest.json'
+    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    certificate_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'symbolic_certificate', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    handoff_path.write_text("# Entanglement-scattering slack identity - private handoff\n\nIn the paper's warm-up regime, the difference between generalized wedge entropy and mutual information is exactly the sum of four nonnegative geometric slacks divided by $4G_N$. Saturation requires entanglement-ridge focusing, trial-surface minimality, lift focusing, and slope focusing all to saturate simultaneously. This does not extend the proof to unrestricted configurations or construct the proposed quantum-task interpretation.\n", encoding='utf-8')
+    artifacts = [report_path, certificate_path, handoff_path]
+    manifest = {'manifest_version': 'sabrina_entanglement_scattering_slack_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, **{name: expected for name, (_, _, expected) in SOURCE_BLOCKS.items()}}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    all_artifacts = [*artifacts, manifest_path]
+    ledger: Mapping[str, Any] = {'status': 'skipped'}
+    if register_ledger:
+        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
+    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
+
+def main(argv: Sequence[str] | None=None) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
+    parser.add_argument('--no-register-crystal-ledger', action='store_true')
+    args = parser.parse_args(argv)
+    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
+    print(json.dumps(result, sort_keys=True))
+    return 0 if result['status'] == 'complete' else 1
+if __name__ == '__main__':
+    raise SystemExit(main())
diff --git a/ouroboros_replay/kernels/run_sabrina_flat_boundary_corner_rank_drop.py b/ouroboros_replay/kernels/run_sabrina_flat_boundary_corner_rank_drop.py
new file mode 100644
index 0000000000000000000000000000000000000000..fa1664b34e8cf1f4bc9194443769e4bda0151e5d
--- /dev/null
+++ b/ouroboros_replay/kernels/run_sabrina_flat_boundary_corner_rank_drop.py
@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+from ..source_runtime import fixture_path, source_path
+import argparse
+import hashlib
+import json
+import tarfile
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Mapping, Sequence
+import sympy as sp
+from .crystal_ledger import register_crystal_artifacts
+OUT_DIR = Path('.replay_outputs') / 'out_dir'
+LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
+SOURCE_ARCHIVE = source_path('8a55509c4b902e68016cb16a722efeb692056e6530cb2d6838b87fe77d6d84f6')
+SOURCE_MEMBER = 'main.tex'
+SOURCE_ARCHIVE_SHA256 = '8a55509c4b902e68016cb16a722efeb692056e6530cb2d6838b87fe77d6d84f6'
+SOURCE_MEMBER_SHA256 = '67a3bec7a35d950e982ea7edeccca1c7f0401539106bd1edbfea9e3b80013b0e'
+SOURCE_BLOCKS = {'flat_boundary_corner_map': (1165, 1224, 'c8086752e1d81c01be54a1b0652123b78d6971e3703e807527617dfe84763cc6')}
+PLAN_RECEIPT_SHA256 = '98943a9020491c52ec25a7a3bdce329a5399bfaf42416f93e3c17240cf3893a9'
+PLAN_GUARD_SHA256 = '47e96882ab02efbf1bccea2e4fcd63c2d901535b39a20ba8caf40acba8ed925b'
+PLAN_VERIFIER_SHA256 = '2ed27a8e835da3adacdbe8ff28ceb1659d23d9d828c7ad09f5e2cb90e26f054f'
+
+def _sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+def _source_evidence() -> dict[str, Any]:
+    with tarfile.open(SOURCE_ARCHIVE, 'r:*') as archive:
+        extracted = archive.extractfile(SOURCE_MEMBER)
+        if extracted is None:
+            raise ValueError(f'unreadable source member: {SOURCE_MEMBER}')
+        member_bytes = extracted.read()
+    lines = member_bytes.decode('utf-8').splitlines()
+    texts = {name: '\n'.join(lines[start - 1:end]) + '\n' for name, (start, end, _) in SOURCE_BLOCKS.items()}
+    hashes = {name: hashlib.sha256(text.encode()).hexdigest() for name, text in texts.items()}
+    expected = {name: value for name, (_, _, value) in SOURCE_BLOCKS.items()}
+    block = texts['flat_boundary_corner_map']
+    checks = {'archive_hash_matches': _sha256(SOURCE_ARCHIVE) == SOURCE_ARCHIVE_SHA256, 'member_hash_matches': hashlib.sha256(member_bytes).hexdigest() == SOURCE_MEMBER_SHA256, 'source_blocks_match': hashes == expected, 'finite_corner_formulas_present': '\\label{v1}' in block and '\\label{v2}' in block, 'flat_segments_present': '\\label{flatVi}' in block, 'flat_corner_limits_present': '\\label{flatv12}' in block and '\\label{flatv22}' in block}
+    return {'block_hashes': hashes, 'checks': checks}
+
+def corner_affine_data(ell: sp.Expr) -> tuple[tuple[sp.Symbol, ...], sp.Matrix, sp.Matrix]:
+    v1, v2, u1, u2, c1, c2, r1, r2 = sp.symbols('v_c1 v_c2 u_r1 u_r2 phi_c1 phi_c2 phi_r1 phi_r2')
+    variables = (v1, v2, u1, u2, c1, c2, r1, r2)
+    outputs = sp.Matrix([(u1 + v1 + ell * (c1 - r1)) / (2 * ell), (-u1 + v1 + ell * (-sp.pi + c1 + r1)) / (2 * ell), (u2 + v1 + ell * (-c1 + r2)) / (2 * ell), (u2 - v1 + ell * (sp.pi + c1 + r2)) / (2 * ell), (u2 + v2 + ell * (c2 - r2)) / (2 * ell), (-u2 + v2 + ell * (-sp.pi + c2 + r2)) / (2 * ell), (u1 + v2 + ell * (-c2 + r1)) / (2 * ell), (u1 - v2 + ell * (sp.pi + c2 + r1)) / (2 * ell)])
+    vector = sp.Matrix(variables)
+    matrix = outputs.jacobian(vector)
+    return (variables, matrix, sp.simplify(outputs - matrix * vector))
+
+def algebraic_certificate() -> dict[str, Any]:
+    ell = sp.symbols('ell', nonzero=True)
+    variables, finite, offset = corner_affine_data(ell)
+    flat = finite.applyfunc(lambda entry: sp.limit(entry, ell, sp.oo))
+    basis = [sp.eye(8).col(index) for index in range(4)]
+    kernel = flat.nullspace()
+    inverse = finite.inv()
+    identity = sp.eye(8)
+    checks = {'finite_determinant_exact': sp.factor(finite.det()) == -ell ** (-4), 'finite_rank_eight': finite.rank() == 8, 'finite_inverse_left_exact': inverse * finite == identity, 'finite_inverse_right_exact': finite * inverse == identity, 'flat_rank_four': flat.rank() == 4, 'flat_kernel_exactly_endpoint_times': kernel == basis, 'flat_offset_drops_all_time_data': all((sp.diff(offset[index], variable) == 0 for index in range(8) for variable in variables[:4]))}
+    return {'variable_order': [str(value) for value in variables], 'corner_order': ['V1_tau_left', 'V1_phi_left', 'V1_tau_right', 'V1_phi_right', 'V2_tau_left', 'V2_phi_left', 'V2_tau_right', 'V2_phi_right'], 'finite_determinant': str(sp.factor(finite.det())), 'finite_rank': finite.rank(), 'flat_rank': flat.rank(), 'flat_kernel_basis': [[str(value) for value in vector] for vector in kernel], 'finite_inverse_matrix': [[str(value) for value in inverse.row(index)] for index in range(8)], 'finite_affine_offset': [str(value) for value in offset], 'checks': checks}
+
+def build_exact_result() -> dict[str, Any]:
+    source = _source_evidence()
+    algebra = algebraic_certificate()
+    checks = dict(source['checks'])
+    checks.update(algebra['checks'])
+    return {'result_version': 'sabrina_flat_boundary_corner_rank_drop_v1', 'status': 'complete' if all(checks.values()) else 'failed', 'paper': {'arxiv_id': '2604.22612', 'title': 'Generalized Entanglement Wedges and the Connected Wedge Theorem'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'finite_scale_bijection': 'det(J_ell)=-ell^-4 and rank(J_ell)=8 for ell nonzero', 'exact_reconstruction': 'all eight endpoint variables are recovered by the exact affine inverse at finite ell', 'flat_rank_drop': 'rank(lim_(ell->infinity) J_ell)=4', 'lost_subspace': 'the limiting kernel is exactly span(v_c1,v_c2,u_r1,u_r2)', 'interpretation': 'the strict flat boundary-corner data retain angular geometry but erase all four endpoint times'}, 'algebraic_certificate': algebra, 'exact_checks': checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'kinematic_affine_map_only': True, 'strict_flat_limit_only': True, 'interacting_dynamics_claimed': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
+
+def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
+    if out_dir.exists():
+        raise FileExistsError(f'immutable result target already exists: {out_dir}')
+    out_dir.mkdir(parents=True)
+    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
+    report = build_exact_result() | {'generated_utc': generated}
+    report_path = out_dir / 'flat_boundary_corner_rank_drop_report.json'
+    witness_path = out_dir / 'flat_boundary_corner_rank_drop_witnesses.json'
+    handoff_path = out_dir / 'FLAT_BOUNDARY_CORNER_RANK_DROP_PRIVATE_HANDOFF.md'
+    manifest_path = out_dir / 'receipt_manifest.json'
+    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    witness_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'algebraic_certificate', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    handoff_path.write_text("# Flat boundary-corner rank drop - private handoff\n\nAt finite AdS scale, the eight diamond-corner coordinates exactly reconstruct all eight endpoint times and angles. The strict flat limit drops the map's rank from eight to four: its kernel is precisely the four endpoint-time directions, while angular data remain. This is a source-pinned kinematic theorem; no interacting-dynamics or publication claim is made.\n", encoding='utf-8')
+    artifacts = [report_path, witness_path, handoff_path]
+    manifest = {'manifest_version': 'sabrina_flat_boundary_corner_rank_drop_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, **{name: value for name, (_, _, value) in SOURCE_BLOCKS.items()}}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    all_artifacts = [*artifacts, manifest_path]
+    ledger: Mapping[str, Any] = {'status': 'skipped'}
+    if register_ledger:
+        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
+    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
+
+def main(argv: Sequence[str] | None=None) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
+    parser.add_argument('--no-register-crystal-ledger', action='store_true')
+    args = parser.parse_args(argv)
+    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
+    print(json.dumps(result, sort_keys=True))
+    return 0 if result['status'] == 'complete' else 1
+if __name__ == '__main__':
+    raise SystemExit(main())
diff --git a/ouroboros_replay/kernels/run_sabrina_inverted_mellin_equivalence.py b/ouroboros_replay/kernels/run_sabrina_inverted_mellin_equivalence.py
new file mode 100644
index 0000000000000000000000000000000000000000..8128c3d4f29e02f23dd91772b15e14970630ae43
--- /dev/null
+++ b/ouroboros_replay/kernels/run_sabrina_inverted_mellin_equivalence.py
@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+from ..source_runtime import fixture_path, source_path
+import argparse
+import hashlib
+import json
+import tarfile
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Mapping, Sequence
+import sympy as sp
+from .crystal_ledger import register_crystal_artifacts
+OUT_DIR = Path('.replay_outputs') / 'out_dir'
+LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
+SOURCE_ARCHIVE = source_path('98df70f13d2aeecec1c192dab76dbe6c52c85a2794e2b46531afc1f846fae4f5')
+SOURCE_MEMBER = 'inv.tex'
+SOURCE_ARCHIVE_SHA256 = '98df70f13d2aeecec1c192dab76dbe6c52c85a2794e2b46531afc1f846fae4f5'
+SOURCE_MEMBER_SHA256 = 'dec660af87a0f34503f8b719e96a95968b83fc665089b19cb627b92b34b0eb6a'
+SOURCE_EQUATION_SHA256 = '31a82fb57e91a1ff55cba7c2d48213cd1c54bb5ec8c2b1c6e40b76747f17e431'
+PLAN_RECEIPT_SHA256 = '0c14ad8e0011205b1c2b8ce0480a045efd837aaab2398e307eebbacadf5101ea'
+PLAN_GUARD_SHA256 = '5192ed306b41d03e9b39504c23de712cf35035e6561c07e917a73499943d13e1'
+PLAN_VERIFIER_SHA256 = '497b4f8189fc9980e14933c61cdc2a498005ae3851b9318499cd5a6ded54e0f0'
+CORPUS_SELECTION_RESULT_SHA256 = '50be0f97900ed089adcef02591c307e87fe1abedcdee435b7072a868449032b3'
+
+def _sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open('rb') as handle:
+        for chunk in iter(lambda: handle.read(1024 * 1024), b''):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+def _source_evidence() -> dict[str, Any]:
+    archive_hash = _sha256(SOURCE_ARCHIVE)
+    with tarfile.open(SOURCE_ARCHIVE, 'r:*') as archive:
+        stream = archive.extractfile(SOURCE_MEMBER)
+        if stream is None:
+            raise FileNotFoundError(SOURCE_MEMBER)
+        member_bytes = stream.read()
+    member_hash = hashlib.sha256(member_bytes).hexdigest()
+    source = member_bytes.decode('utf-8')
+    label = '\\label{eq:intgrlequiv}'
+    label_index = source.index(label)
+    begin = source.rfind('\\begin{equation', 0, label_index)
+    end_token = '\\end{equation}'
+    end = source.index(end_token, label_index) + len(end_token)
+    equation_bytes = source[begin:end].encode('utf-8')
+    return {'archive_sha256': archive_hash, 'member_sha256': member_hash, 'equation_block_sha256': hashlib.sha256(equation_bytes).hexdigest(), 'equation_label_count': source.count(label), 'equation_block_byte_count': len(equation_bytes), 'checks': {'archive_hash_matches': archive_hash == SOURCE_ARCHIVE_SHA256, 'member_hash_matches': member_hash == SOURCE_MEMBER_SHA256, 'equation_hash_matches': hashlib.sha256(equation_bytes).hexdigest() == SOURCE_EQUATION_SHA256, 'equation_label_unique': source.count(label) == 1, 'equation_environment_bounded': begin >= 0 and end > label_index}}
+
+def build_exact_result() -> dict[str, Any]:
+    delta = sp.Symbol('Delta')
+    epsilon = sp.Symbol('epsilon', positive=True)
+    u, tau, t, q = sp.symbols('u tau t q', nonzero=True)
+    source = _source_evidence()
+    r_phi_prefactor = -sp.Rational(1, 2) / u
+    prefactor_after_inversion = sp.simplify(r_phi_prefactor.subs(u, 1 / tau))
+    raw_measure = sp.simplify(-1 / tau ** 2 * prefactor_after_inversion)
+    oriented_measure = sp.simplify(-raw_measure)
+    regulator_factorization = sp.simplify(1 / (2 * t) - sp.I * epsilon - sp.Rational(1, 2) * (1 / t - 2 * sp.I * epsilon))
+    displayed_coefficient = -sp.Pow(2, delta - 1)
+    derived_coefficient = -sp.Rational(1, 2) * sp.Pow(2, delta)
+    transformed_argument = sp.simplify((-tau * q / 2).subs(tau, 2 * t))
+    outgoing_phase = sp.exp(sp.I * sp.pi * delta)
+    phase_from_lower_lip = sp.simplify(sp.exp(-delta * sp.log(t) + sp.I * sp.pi * delta) / sp.exp(-delta * sp.log(t)))
+    exact_checks = dict(source['checks'])
+    exact_checks.update({'source_asymptotic_prefactor': r_phi_prefactor == -1 / (2 * u), 'raw_inversion_measure': sp.simplify(raw_measure - 1 / (2 * tau)) == 0, 'positive_half_line_orientation': sp.simplify(oriented_measure + 1 / (2 * tau)) == 0, 'negative_half_line_orientation': sp.simplify(oriented_measure + 1 / (2 * tau)) == 0, 'canonical_rescaling_measure': sp.simplify(2 / (2 * t) - 1 / t) == 0, 'regulator_rescales_by_two': regulator_factorization == 0, 'displayed_power_of_two': sp.simplify(derived_coefficient - displayed_coefficient) == 0, 'displayed_argument': transformed_argument == -t * q, 'outgoing_negative_branch_phase': sp.simplify(phase_from_lower_lip - outgoing_phase) == 0})
+    status = 'complete' if all(exact_checks.values()) else 'failed'
+    return {'result_version': 'sabrina_inverted_mellin_equivalence_v1', 'status': status, 'paper': {'arxiv_id': '2310.02186', 'title': 'Equating Extrapolate Dictionaries for Massless Scattering', 'equation_label': 'eq:intgrlequiv'}, 'source_evidence': {key: value for key, value in source.items() if key != 'checks'}, 'derivation': {'null_infinity_asymptotic': 'r Phi -> -(2u)^-1 tildePhi(-qhat/(2u))', 'first_variable': 'tau=1/u on each open half-line', 'oriented_measure': 'du[-1/(2u)] -> -d tau/(2 tau)', 'canonical_variable': 't=tau/2=(2u)^-1', 'weight_identity': '(1/(2t)-i epsilon)^(-Delta)=2^Delta(1/t-2i epsilon)^(-Delta)', 'final_prefactor': '-2^(Delta-1)', 'final_argument': '-t qhat', 'regulator_rename': 'epsilon_t=2 epsilon>0', 'negative_u_branch': '(u-i0)^(-Delta)=|u|^(-Delta) exp(i pi Delta)'}, 'classification': 'source_equation_consistent_normalization_rescaling_made_explicit', 'finding': 'The displayed equivalence is exact. The prose change t=u^-1 suppresses the subsequent positive rescaling t=(2u)^-1 and regulator rename; it does not create a normalization or branch error.', 'exact_checks': exact_checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'parents': {'corpus_selection_result_sha256': CORPUS_SELECTION_RESULT_SHA256, 'source_archive_sha256': SOURCE_ARCHIVE_SHA256, 'source_member_sha256': SOURCE_MEMBER_SHA256}, 'claim_boundary': {'paper_correction_claimed': False, 'physics_beyond_source_equivalence_claimed': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
+
+def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
+    if out_dir.exists():
+        raise FileExistsError(f'immutable result target already exists: {out_dir}')
+    out_dir.mkdir(parents=True)
+    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
+    report = build_exact_result() | {'generated_utc': generated}
+    report_path = out_dir / 'inverted_mellin_equivalence_report.json'
+    certificate_path = out_dir / 'inverted_mellin_equivalence_certificate.json'
+    handoff_path = out_dir / 'INVERTED_MELLIN_EQUIVALENCE_PRIVATE_HANDOFF.md'
+    manifest_path = out_dir / 'receipt_manifest.json'
+    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    certificate = {'generated_utc': generated, 'classification': report['classification'], 'derivation': report['derivation'], 'exact_checks': report['exact_checks'], 'claim_boundary': report['claim_boundary']}
+    certificate_path.write_text(json.dumps(certificate, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    handoff_path.write_text('# Inverted Mellin equivalence - private handoff\n\nThe displayed normalization and outgoing branch phase are exact. The missing step in the prose is the positive rescaling from tau=1/u to t=tau/2, together with epsilon_t=2 epsilon. This is a derivation clarification, not a correction to the paper or a new physics claim.\n', encoding='utf-8')
+    artifacts = [report_path, certificate_path, handoff_path]
+    manifest = {'manifest_version': 'sabrina_inverted_mellin_equivalence_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, 'eq:intgrlequiv': SOURCE_EQUATION_SHA256}, 'parents': report['parents'], 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    all_artifacts = [*artifacts, manifest_path]
+    ledger: Mapping[str, Any] = {'status': 'skipped'}
+    if register_ledger:
+        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
+    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
+
+def main(argv: Sequence[str] | None=None) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
+    parser.add_argument('--no-register-crystal-ledger', action='store_true')
+    args = parser.parse_args(argv)
+    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
+    print(json.dumps(result, sort_keys=True))
+    return 0 if result['status'] == 'complete' else 1
+if __name__ == '__main__':
+    raise SystemExit(main())
diff --git a/ouroboros_replay/kernels/run_sabrina_late_time_three_cut_null_test.py b/ouroboros_replay/kernels/run_sabrina_late_time_three_cut_null_test.py
new file mode 100644
index 0000000000000000000000000000000000000000..db877e85af2f23c1d50b1a42816f714093f2be83
--- /dev/null
+++ b/ouroboros_replay/kernels/run_sabrina_late_time_three_cut_null_test.py
@@ -0,0 +1,139 @@
+from __future__ import annotations
+
+from ..source_runtime import fixture_path, source_path
+import argparse
+import hashlib
+import itertools
+import json
+import tarfile
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Mapping, Sequence
+import sympy as sp
+from .crystal_ledger import register_crystal_artifacts
+OUT_DIR = Path('.replay_outputs') / 'out_dir'
+LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
+SOURCE_ARCHIVE = source_path('f6dbbd7baa6b7eb93cb06b6460877b26f09ba30bacd6b447641ccf6843828df6')
+PREDECESSOR_MANIFEST = fixture_path('7d5e9dad93e63528aa697e9ec29d0b959f0efdf01b7539aafa7d85d1279a71e2')
+SOURCE_ARCHIVE_SHA256 = 'f6dbbd7baa6b7eb93cb06b6460877b26f09ba30bacd6b447641ccf6843828df6'
+SOURCE_MEMBER_SHA256 = '7f18a6972ebb356c2f7c90ad69823468e11323b04d918ed05cb46aed28edf100'
+SOURCE_EQUATION_SHA256 = '04b21882801dbf4f2f657ec7e880d361534f652f9529bc0c293c67b5a546a073'
+PREDECESSOR_MANIFEST_SHA256 = '7d5e9dad93e63528aa697e9ec29d0b959f0efdf01b7539aafa7d85d1279a71e2'
+EQUATION_MARKER = '\\label{eq:latetime}'
+PLAN_RECEIPT_SHA256 = '1ad54bf7cccb98f4bd0dffece17cf59dea68eae7e9ea18da944ff4cd8482223e'
+PLAN_GUARD_SHA256 = '0197fc78fdd6cb60268233d7acef9de1954fd668ee8cdd6c65da9ae2d3f22498'
+PLAN_VERIFIER_SHA256 = '1760e709ad8efe026e1a6fffd72a1b57eb8282e651f0c509eb4ef6c54b6990a1'
+
+def _sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+def _equation_block(source: str) -> bytes:
+    marker_index = source.index(EQUATION_MARKER)
+    start = max(source.rfind('\\begin{equation}', 0, marker_index), source.rfind('\\begin{align}', 0, marker_index), source.rfind('\\be', 0, marker_index))
+    ends = []
+    for token in ('\\end{equation}', '\\end{align}', '\\ee'):
+        index = source.find(token, marker_index)
+        if index >= 0:
+            ends.append(index + len(token))
+    if start < 0 or not ends:
+        raise ValueError('source equation block not found')
+    return source[start:min(ends)].encode('latin-1')
+
+def _source_evidence() -> dict[str, Any]:
+    with tarfile.open(SOURCE_ARCHIVE, 'r:gz') as archive:
+        members = [member for member in archive.getmembers() if Path(member.name).name == 'ArXivsr.tex']
+        if len(members) != 1:
+            raise ValueError('expected exactly one ArXivsr.tex source member')
+        extracted = archive.extractfile(members[0])
+        if extracted is None:
+            raise ValueError('ArXivsr.tex source member is unreadable')
+        member_bytes = extracted.read()
+    source = member_bytes.decode('latin-1')
+    equation_hash = hashlib.sha256(_equation_block(source)).hexdigest()
+    checks = {'archive_hash_matches': _sha256(SOURCE_ARCHIVE) == SOURCE_ARCHIVE_SHA256, 'member_hash_matches': hashlib.sha256(member_bytes).hexdigest() == SOURCE_MEMBER_SHA256, 'equation_hash_matches': equation_hash == SOURCE_EQUATION_SHA256, 'equation_marker_unique': source.count(EQUATION_MARKER) == 1, 'predecessor_manifest_hash_matches': _sha256(PREDECESSOR_MANIFEST) == PREDECESSOR_MANIFEST_SHA256}
+    return {'equation_sha256': equation_hash, 'checks': checks}
+
+def three_cut_residual(cuts: Sequence[sp.Expr], values: Sequence[sp.Expr]) -> sp.Expr:
+    if len(cuts) != 3 or len(values) != 3:
+        raise ValueError('three cuts and three values are required')
+    u1, u2, u3 = cuts
+    if sp.simplify((u1 - u2) * (u1 - u3) * (u2 - u3)) == 0:
+        raise ValueError('three-cut null test requires pairwise distinct cuts')
+    h1, h2, h3 = values
+    return sp.factor((u2 - u3) * h1 + (u3 - u1) * h2 + (u1 - u2) * h3)
+
+def quadratic_coefficient(cuts: Sequence[sp.Expr], values: Sequence[sp.Expr]) -> sp.Expr:
+    u1, u2, u3 = cuts
+    vandermonde = sp.factor((u1 - u2) * (u1 - u3) * (u2 - u3))
+    return sp.factor(three_cut_residual(cuts, values) / vandermonde)
+
+def build_exact_result() -> dict[str, Any]:
+    source = _source_evidence()
+    u1, u2, u3 = sp.symbols('u1 u2 u3')
+    y3, f2, lf2, v1 = sp.symbols('Y3 F2 LF2 V1')
+    curvature, slope, intercept = sp.symbols('e a b')
+    hminus = lambda u: -u * y3 - 2 * f2
+    hzero = lambda u: u * lf2 + 2 * v1
+    quadratic = lambda u: curvature * u ** 2 + slope * u + intercept
+    cuts = (u1, u2, u3)
+    minus_residual = sp.factor(three_cut_residual(cuts, [hminus(u) for u in cuts]))
+    zero_residual = sp.factor(three_cut_residual(cuts, [hzero(u) for u in cuts]))
+    quadratic_residual = sp.factor(three_cut_residual(cuts, [quadratic(u) for u in cuts]))
+    vandermonde = sp.factor((u1 - u2) * (u1 - u3) * (u2 - u3))
+    reconstructed_curvature = sp.factor(quadratic_residual / vandermonde)
+    rational_rows = []
+    cut_values = [sp.Rational(-3), sp.Rational(-1), sp.Rational(1, 2), sp.Rational(2), sp.Rational(7, 2), sp.Rational(5)]
+    coefficient_rows = [(sp.Rational(0), sp.Rational(2), sp.Rational(3)), (sp.Rational(4, 3), sp.Rational(-2), sp.Rational(5, 2)), (sp.Rational(-3, 5), sp.Rational(0), sp.Rational(-7, 4))]
+    for triple in itertools.combinations(cut_values, 3):
+        for e_value, a_value, b_value in coefficient_rows:
+            values = [e_value * u ** 2 + a_value * u + b_value for u in triple]
+            recovered = quadratic_coefficient(triple, values)
+            rational_rows.append({'cuts': [str(value) for value in triple], 'quadratic_coefficient': str(e_value), 'recovered': str(recovered), 'exact': recovered == e_value, 'affine_null': e_value != 0 or three_cut_residual(triple, values) == 0})
+    permutation_checks = []
+    base_cuts = (sp.Rational(-2), sp.Rational(1), sp.Rational(4))
+    base_values = [sp.Rational(5, 3) * u ** 2 - 2 * u + 7 for u in base_cuts]
+    for permutation in itertools.permutations(range(3)):
+        permuted_cuts = [base_cuts[index] for index in permutation]
+        permuted_values = [base_values[index] for index in permutation]
+        permutation_checks.append(quadratic_coefficient(permuted_cuts, permuted_values) == sp.Rational(5, 3))
+    repeated_rejected = False
+    try:
+        three_cut_residual((sp.Integer(0), sp.Integer(0), sp.Integer(1)), (sp.Integer(1), sp.Integer(1), sp.Integer(2)))
+    except ValueError:
+        repeated_rejected = True
+    exact_checks = dict(source['checks'])
+    exact_checks.update({'Hminus_affine_residual_zero': minus_residual == 0, 'Hzero_affine_residual_zero': zero_residual == 0, 'quadratic_residual_factors_as_e_times_vandermonde': sp.simplify(quadratic_residual - curvature * vandermonde) == 0, 'symbolic_quadratic_coefficient_recovered': reconstructed_curvature == curvature, 'all_60_rational_rows_exact': len(rational_rows) == 60 and all((row['exact'] and row['affine_null'] for row in rational_rows)), 'all_six_permutations_recover_same_curvature': all(permutation_checks), 'repeated_cuts_rejected': repeated_rejected})
+    return {'result_version': 'sabrina_late_time_three_cut_null_test_v1', 'status': 'complete' if all(exact_checks.values()) else 'failed', 'paper': {'arxiv_id': '1905.10052', 'title': 'Implications of Superrotations'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'null_residual': '(u2-u3)H(u1)+(u3-u1)H(u2)+(u1-u2)H(u3)', 'affine_result': 'zero for pairwise distinct cuts', 'quadratic_factorization': str(quadratic_residual), 'quadratic_reconstruction': 'e=residual/[(u1-u2)(u1-u3)(u2-u3)]', 'permutation_invariant_ratio': True}, 'finite_exact_rows': rational_rows, 'classification': 'late_time_three_cut_affine_null_test_and_quadratic_curvature_extraction_exact', 'exact_checks': exact_checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'nonzero_residual_means_non_affine_only': True, 'physical_cause_identified_from_residual': False, 'higher_than_quadratic_contamination_reconstructed': False, 'pairwise_distinct_cuts_required': True, 'source_error_claimed': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
+
+def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
+    if out_dir.exists():
+        raise FileExistsError(f'immutable result target already exists: {out_dir}')
+    out_dir.mkdir(parents=True)
+    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
+    report = build_exact_result() | {'generated_utc': generated}
+    report_path = out_dir / 'late_time_three_cut_null_test_report.json'
+    certificate_path = out_dir / 'late_time_three_cut_null_test_certificate.json'
+    handoff_path = out_dir / 'LATE_TIME_THREE_CUT_NULL_TEST_PRIVATE_HANDOFF.md'
+    manifest_path = out_dir / 'receipt_manifest.json'
+    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    certificate_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    handoff_path.write_text('# Late-time three-cut null test - private handoff\n\nEach affine-u coefficient in Eq. latetime obeys an exact three-cut Vandermonde null test. A quadratic contamination produces the residual e(u1-u2)(u1-u3)(u2-u3), so e is recovered exactly for distinct cuts. The ratio is permutation invariant. A nonzero residual establishes only a departure from affine-u behavior; it does not identify a physical cause.\n', encoding='utf-8')
+    artifacts = [report_path, certificate_path, handoff_path]
+    manifest = {'manifest_version': 'sabrina_late_time_three_cut_null_test_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, 'ArXivsr.tex': SOURCE_MEMBER_SHA256, 'eq_latetime': SOURCE_EQUATION_SHA256}, 'upstream_manifest_sha256': PREDECESSOR_MANIFEST_SHA256, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    all_artifacts = [*artifacts, manifest_path]
+    ledger: Mapping[str, Any] = {'status': 'skipped'}
+    if register_ledger:
+        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
+    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
+
+def main(argv: Sequence[str] | None=None) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
+    parser.add_argument('--no-register-crystal-ledger', action='store_true')
+    args = parser.parse_args(argv)
+    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
+    print(json.dumps(result, sort_keys=True))
+    return 0 if result['status'] == 'complete' else 1
+if __name__ == '__main__':
+    raise SystemExit(main())
diff --git a/ouroboros_replay/kernels/run_sabrina_late_time_two_cut_reconstruction.py b/ouroboros_replay/kernels/run_sabrina_late_time_two_cut_reconstruction.py
new file mode 100644
index 0000000000000000000000000000000000000000..97332d23660b69ec7cc75b7a9e72753c945aa40b
--- /dev/null
+++ b/ouroboros_replay/kernels/run_sabrina_late_time_two_cut_reconstruction.py
@@ -0,0 +1,134 @@
+from __future__ import annotations
+
+from ..source_runtime import fixture_path, source_path
+import argparse
+import hashlib
+import json
+import tarfile
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Mapping, Sequence
+import sympy as sp
+from .crystal_ledger import register_crystal_artifacts
+OUT_DIR = Path('.replay_outputs') / 'out_dir'
+LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
+SOURCE_ARCHIVE = source_path('f6dbbd7baa6b7eb93cb06b6460877b26f09ba30bacd6b447641ccf6843828df6')
+SOURCE_ARCHIVE_SHA256 = 'f6dbbd7baa6b7eb93cb06b6460877b26f09ba30bacd6b447641ccf6843828df6'
+SOURCE_MEMBER_SHA256 = '7f18a6972ebb356c2f7c90ad69823468e11323b04d918ed05cb46aed28edf100'
+SOURCE_EQUATION_SHA256 = '04b21882801dbf4f2f657ec7e880d361534f652f9529bc0c293c67b5a546a073'
+SOURCE_CONTEXT_SHA256 = 'ac3cfdbbe3f446d97cf5ce608da5c078c9d481be3e07a76bc44f67611471adf4'
+EQUATION_MARKER = '\\label{eq:latetime}'
+CONTEXT_MARKER = 'where the early and late time behaviors'
+PLAN_RECEIPT_SHA256 = 'cdada1e425bcb61d718425d5b18203e2d3d23fd0fcc9bf098be6d7070881f7c1'
+PLAN_GUARD_SHA256 = '29e350c6b291cb8477b5104f05d724d0601b94742ec465928ac6cdae9d30fb2b'
+PLAN_VERIFIER_SHA256 = '88c864a6505d39a782ff007bccc7c4a30c34d107da1eb92e542d664d14931fd7'
+
+def _sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+def _equation_block(source: str, marker: str) -> bytes:
+    marker_index = source.index(marker)
+    start = max(source.rfind('\\begin{equation}', 0, marker_index), source.rfind('\\begin{align}', 0, marker_index), source.rfind('\\be', 0, marker_index))
+    ends = []
+    for token in ('\\end{equation}', '\\end{align}', '\\ee'):
+        index = source.find(token, marker_index)
+        if index >= 0:
+            ends.append(index + len(token))
+    if start < 0 or not ends:
+        raise ValueError('source equation block not found')
+    return source[start:min(ends)].encode('latin-1')
+
+def _source_evidence() -> dict[str, Any]:
+    with tarfile.open(SOURCE_ARCHIVE, 'r:gz') as archive:
+        members = [member for member in archive.getmembers() if Path(member.name).name == 'ArXivsr.tex']
+        if len(members) != 1:
+            raise ValueError('expected exactly one ArXivsr.tex source member')
+        extracted = archive.extractfile(members[0])
+        if extracted is None:
+            raise ValueError('ArXivsr.tex source member is unreadable')
+        member_bytes = extracted.read()
+    source = member_bytes.decode('latin-1')
+    equation_hash = hashlib.sha256(_equation_block(source, EQUATION_MARKER)).hexdigest()
+    context_index = source.index(CONTEXT_MARKER)
+    line_start = source.rfind('\n', 0, context_index) + 1
+    line_end = source.find('\n', context_index)
+    context_hash = hashlib.sha256(source[line_start:line_end].encode('latin-1')).hexdigest()
+    checks = {'archive_hash_matches': _sha256(SOURCE_ARCHIVE) == SOURCE_ARCHIVE_SHA256, 'member_hash_matches': hashlib.sha256(member_bytes).hexdigest() == SOURCE_MEMBER_SHA256, 'equation_hash_matches': equation_hash == SOURCE_EQUATION_SHA256, 'context_hash_matches': context_hash == SOURCE_CONTEXT_SHA256, 'equation_marker_unique': source.count(EQUATION_MARKER) == 1, 'context_marker_unique': source.count(CONTEXT_MARKER) == 1}
+    return {'equation_sha256': equation_hash, 'context_sha256': context_hash, 'checks': checks}
+
+def reconstruct_affine(u1: sp.Expr, u2: sp.Expr, value1: sp.Expr, value2: sp.Expr) -> tuple[sp.Expr, sp.Expr]:
+    difference = sp.simplify(u2 - u1)
+    if difference == 0:
+        raise ValueError('two-cut reconstruction requires distinct retarded times')
+    slope = sp.simplify((value2 - value1) / difference)
+    intercept = sp.simplify((u2 * value1 - u1 * value2) / difference)
+    return (slope, intercept)
+
+def build_exact_result() -> dict[str, Any]:
+    source = _source_evidence()
+    u1, u2, tau = sp.symbols('u1 u2 tau')
+    y3, f2, lf2, v1, la = sp.symbols('Y3 F2 LF2 V1 L_a')
+    hminus = lambda u: -u * y3 - 2 * f2
+    hzero = lambda u: u * lf2 + 2 * v1
+    minus_slope, minus_intercept = reconstruct_affine(u1, u2, hminus(u1), hminus(u2))
+    zero_slope, zero_intercept = reconstruct_affine(u1, u2, hzero(u1), hzero(u2))
+    recovered = {'Y3': sp.simplify(-minus_slope), 'F2': sp.simplify(-minus_intercept / 2), 'LF2': sp.simplify(zero_slope), 'V1': sp.simplify(zero_intercept / 2)}
+    fixed_origin_residual = sp.simplify(zero_slope + -2 * lf2 / 2)
+    shifted_minus_intercept = sp.simplify(minus_intercept + tau * minus_slope)
+    shifted_zero_intercept = sp.simplify(zero_intercept + tau * zero_slope)
+    shifted_l_minus_intercept = sp.simplify(-2 * lf2 + tau * la)
+    shifted_residual = sp.simplify(zero_slope + shifted_l_minus_intercept / 2)
+    rational_rows = []
+    cut_values = [sp.Rational(-3), sp.Rational(-1), sp.Rational(1, 2), sp.Rational(2), sp.Rational(7, 2)]
+    parameter_rows = [(sp.Rational(2), sp.Rational(3), sp.Rational(5), sp.Rational(7)), (sp.Rational(-1), sp.Rational(4, 3), sp.Rational(-2), sp.Rational(5, 2)), (sp.Rational(0), sp.Rational(-3, 2), sp.Rational(9, 4), sp.Rational(-1, 3))]
+    for first_index, first in enumerate(cut_values):
+        for second in cut_values[first_index + 1:]:
+            for y_value, f_value, lf_value, v_value in parameter_rows:
+                hm1 = -first * y_value - 2 * f_value
+                hm2 = -second * y_value - 2 * f_value
+                h01 = first * lf_value + 2 * v_value
+                h02 = second * lf_value + 2 * v_value
+                ms, mi = reconstruct_affine(first, second, hm1, hm2)
+                zs, zi = reconstruct_affine(first, second, h01, h02)
+                rational_rows.append({'u1': str(first), 'u2': str(second), 'reconstruction_exact': (-ms, -mi / 2, zs, zi / 2) == (y_value, f_value, lf_value, v_value)})
+    coincident_rejected = False
+    try:
+        reconstruct_affine(sp.Integer(1), sp.Integer(1), sp.Integer(2), sp.Integer(2))
+    except ValueError:
+        coincident_rejected = True
+    exact_checks = dict(source['checks'])
+    exact_checks.update({'symbolic_Y3_reconstruction_exact': recovered['Y3'] == y3, 'symbolic_F2_reconstruction_exact': recovered['F2'] == f2, 'symbolic_LF2_reconstruction_exact': recovered['LF2'] == lf2, 'symbolic_V1_reconstruction_exact': recovered['V1'] == v1, 'fixed_origin_cross_order_residual_zero': fixed_origin_residual == 0, 'origin_shift_minus_intercept_covariant': shifted_minus_intercept == -2 * f2 - tau * y3, 'origin_shift_zero_intercept_covariant': shifted_zero_intercept == 2 * v1 + tau * lf2, 'shifted_residual_is_tau_La_over_two': shifted_residual == tau * la / 2, 'all_30_rational_reconstructions_exact': len(rational_rows) == 30 and all((row['reconstruction_exact'] for row in rational_rows)), 'coincident_cuts_rejected': coincident_rejected})
+    return {'result_version': 'sabrina_late_time_two_cut_reconstruction_v1', 'status': 'complete' if all(exact_checks.values()) else 'failed', 'paper': {'arxiv_id': '1905.10052', 'title': 'Implications of Superrotations'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'source_form': 'Hminus(u)=-u Y3-2F2; Hzero(u)=u LF2+2V1', 'two_cut_slope': '[H(u2)-H(u1)]/(u2-u1)', 'two_cut_intercept': '[u2 H(u1)-u1 H(u2)]/(u2-u1)', 'recovered_images': {name: str(value) for name, value in recovered.items()}, 'fixed_origin_cross_order_relation': 'slope(Hzero)+one_half L(intercept(Hminus))=0', 'origin_shift_law': "under v=u-tau: slopes fixed, b'=b+tau a, d'=d+tau c", 'shifted_cross_order_residual': str(shifted_residual), 'origin_invariance_extra_condition': 'L(a)=0'}, 'finite_exact_rows': rational_rows, 'classification': 'late_time_two_cut_image_reconstruction_exact_with_origin_covariance', 'exact_checks': exact_checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'sphere_operator_inversion_claimed': False, 'sphere_operator_kernels_resolved': False, 'global_modes_reconstructed': False, 'intercepts_origin_invariant_claimed': False, 'cross_order_relation_origin_invariant_without_La_zero_claimed': False, 'distinct_cuts_required': True, 'source_error_claimed': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
+
+def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
+    if out_dir.exists():
+        raise FileExistsError(f'immutable result target already exists: {out_dir}')
+    out_dir.mkdir(parents=True)
+    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
+    report = build_exact_result() | {'generated_utc': generated}
+    report_path = out_dir / 'late_time_two_cut_reconstruction_report.json'
+    certificate_path = out_dir / 'late_time_two_cut_reconstruction_certificate.json'
+    handoff_path = out_dir / 'LATE_TIME_TWO_CUT_RECONSTRUCTION_PRIVATE_HANDOFF.md'
+    manifest_path = out_dir / 'receipt_manifest.json'
+    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    certificate_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    handoff_path.write_text('# Late-time two-cut reconstruction - private handoff\n\nAny two distinct absolute-u cuts reconstruct the four affine coefficients in Eq. latetime and therefore the differential images Dbar^3Ybar, Dbar^2f, (D^2-2)Dbar^2f, and Dbar Vbar. The shared f-image yields a fixed-origin cross-order consistency equation. Under a change of u origin, slopes are invariant but intercepts transform covariantly; the residual shifts by tau L(a)/2 and is invariant only if L(a)=0. No sphere operator is inverted.\n', encoding='utf-8')
+    artifacts = [report_path, certificate_path, handoff_path]
+    manifest = {'manifest_version': 'sabrina_late_time_two_cut_reconstruction_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, 'ArXivsr.tex': SOURCE_MEMBER_SHA256, 'eq_latetime': SOURCE_EQUATION_SHA256, 'interpretation_context': SOURCE_CONTEXT_SHA256}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    all_artifacts = [*artifacts, manifest_path]
+    ledger: Mapping[str, Any] = {'status': 'skipped'}
+    if register_ledger:
+        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
+    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
+
+def main(argv: Sequence[str] | None=None) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
+    parser.add_argument('--no-register-crystal-ledger', action='store_true')
+    args = parser.parse_args(argv)
+    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
+    print(json.dumps(result, sort_keys=True))
+    return 0 if result['status'] == 'complete' else 1
+if __name__ == '__main__':
+    raise SystemExit(main())
diff --git a/ouroboros_replay/kernels/run_sabrina_logarithmic_mellin_pole_order_correction.py b/ouroboros_replay/kernels/run_sabrina_logarithmic_mellin_pole_order_correction.py
new file mode 100644
index 0000000000000000000000000000000000000000..96b2e026260b33f4b60328af74c1a9c6b26c3b7c
--- /dev/null
+++ b/ouroboros_replay/kernels/run_sabrina_logarithmic_mellin_pole_order_correction.py
@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+from ..source_runtime import fixture_path, source_path
+import argparse
+import hashlib
+import json
+import tarfile
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Mapping, Sequence
+import sympy as sp
+from .crystal_ledger import register_crystal_artifacts
+OUT_DIR = Path('.replay_outputs') / 'out_dir'
+LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
+SOURCE_ARCHIVE = source_path('507d405bf10b9686f8fbc678b9a7eaaa73c6f45b4f68e59edbcaecddd7ecfcc4')
+SOURCE_MEMBER = 'Goldilocks.tex'
+SOURCE_ARCHIVE_SHA256 = '507d405bf10b9686f8fbc678b9a7eaaa73c6f45b4f68e59edbcaecddd7ecfcc4'
+SOURCE_MEMBER_SHA256 = 'ad9e1a424a413fa2b56841d94f4ae2243a852254cfcf8661c789ee859beca3a6'
+SOURCE_BLOCKS = {'loop_soft_expansion': (469, 475, 'c95d01373419bc7154c7ef912c9385a6d4748760314d862f7e9ab55b4f83c2f5'), 'celestial_log_poles': (483, 510, '639fe1734f4dca2e2353cbbe1546b63df06548efe7b38ac0a065db7e3aa6b731'), 'mellin_integral_core': (499, 508, 'e2fd500e79027edf58292614ba23f37c1f6f3fde9e8f8206d80a0684fddd039d')}
+PLAN_RECEIPT_SHA256 = 'fab258c9f0a8e49b247acab52ce365d64e289480ec11b11a74cacd0d2d9bbc8d'
+PLAN_GUARD_SHA256 = '6cbcec3313fe712ff8b344a059f846ed8030231fcf191f72dbf22aa8a46071ed'
+PLAN_VERIFIER_SHA256 = 'f108493b10aed1713560a962222e7379825a5f7f22ae1f7c17de82004f09715b'
+
+def _sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+def _source_evidence() -> dict[str, Any]:
+    with tarfile.open(SOURCE_ARCHIVE, 'r:*') as archive:
+        extracted = archive.extractfile(SOURCE_MEMBER)
+        if extracted is None:
+            raise ValueError(f'unreadable source member: {SOURCE_MEMBER}')
+        member_bytes = extracted.read()
+    lines = member_bytes.decode('utf-8').splitlines()
+    texts = {name: '\n'.join(lines[start - 1:end]) + '\n' for name, (start, end, _) in SOURCE_BLOCKS.items()}
+    hashes = {name: hashlib.sha256(text.encode()).hexdigest() for name, text in texts.items()}
+    expected = {name: value for name, (_, _, value) in SOURCE_BLOCKS.items()}
+    checks = {'archive_hash_matches': _sha256(SOURCE_ARCHIVE) == SOURCE_ARCHIVE_SHA256, 'member_hash_matches': hashlib.sha256(member_bytes).hexdigest() == SOURCE_MEMBER_SHA256, 'source_blocks_match': hashes == expected, 'one_loop_double_pole_present': all((marker in texts['mellin_integral_core'] for marker in ('\\label{eq:omegalogomegaintegral}', '(\\Delta+m)^2', 'double poles'))), 'generic_loop_and_two_minus_k_statements_present': all((marker in texts['mellin_integral_core'] for marker in ('\\ell^{th}', 'order $2-k$', '\\omega^{\\ell-1} (\\log \\omega)^\\ell')))}
+    return {'block_hashes': hashes, 'checks': checks}
+
+def principal_part_coefficients(log_power: int, log_mu: Any) -> dict[int, Any]:
+    if log_power < 0:
+        raise ValueError('log power must be nonnegative')
+    return {derivative_order + 1: sp.expand(sp.binomial(log_power, derivative_order) * (-log_mu) ** (log_power - derivative_order) * (-1) ** derivative_order * sp.factorial(derivative_order)) for derivative_order in range(log_power + 1)}
+
+def finite_exact_rows(max_log_power: int=6) -> list[dict[str, Any]]:
+    s, log_cutoff, log_mu = sp.symbols('s log_Lambda log_mu')
+    base = sp.exp(log_cutoff * s) / s
+    rows: list[dict[str, Any]] = []
+    for log_power in range(max_log_power + 1):
+        transformed = sum((sp.binomial(log_power, derivative_order) * (-log_mu) ** (log_power - derivative_order) * sp.diff(base, s, derivative_order) for derivative_order in range(log_power + 1)))
+        series = sp.series(transformed, s, 0, 1).removeO().expand()
+        expected = principal_part_coefficients(log_power, log_mu)
+        coefficient_checks = {str(order): bool(sp.simplify(series.coeff(s, -order) - coefficient) == 0) for order, coefficient in expected.items()}
+        highest = expected[log_power + 1]
+        rows.append({'log_power': log_power, 'pole_order': log_power + 1, 'leading_coefficient': int(highest), 'principal_part_coefficients': {str(key): str(value) for key, value in expected.items()}, 'all_coefficients_match': all(coefficient_checks.values()), 'coefficient_checks': coefficient_checks})
+    return rows
+
+def source_reconciliation() -> dict[str, Any]:
+    s, log_cutoff = sp.symbols('s log_Lambda')
+    base = sp.exp(log_cutoff * s) / s
+    source_one_loop = -sp.exp(log_cutoff * s) / s ** 2 + sp.exp(log_cutoff * s) * log_cutoff / s
+    one_loop_series = sp.series(source_one_loop, s, 0, 1).removeO().expand()
+    rows = [{'k': k, 'loop_log_power': 1 - k, 'corrected_pole_order': 2 - k, 'source_bound': 2 - k} for k in (1, 0, -1, -2)]
+    return {'one_loop_derivative_identity': bool(sp.simplify(sp.diff(base, s) - source_one_loop) == 0), 'one_loop_double_pole_coefficient': int(one_loop_series.coeff(s, -2)), 'one_loop_simple_pole_coefficient_for_log_omega': int(one_loop_series.coeff(s, -1)), 'two_minus_k_rows': rows, 'two_minus_k_reconciles': all((row['corrected_pole_order'] == row['source_bound'] for row in rows))}
+
+def build_exact_result() -> dict[str, Any]:
+    source = _source_evidence()
+    rows = finite_exact_rows()
+    reconciliation = source_reconciliation()
+    log_mu, shift = sp.symbols('log_mu shift')
+    scale_checks = []
+    for log_power in range(7):
+        before = principal_part_coefficients(log_power, log_mu)[log_power + 1]
+        after = principal_part_coefficients(log_power, log_mu + shift)[log_power + 1]
+        scale_checks.append(bool(sp.simplify(before - after) == 0))
+    checks = dict(source['checks'])
+    checks.update({'finite_laurent_rows_exact': all((row['all_coefficients_match'] for row in rows)), 'pole_order_is_log_power_plus_one': all((row['pole_order'] == row['log_power'] + 1 for row in rows)), 'leading_factorial_coefficient_exact': all((row['leading_coefficient'] == (-1) ** row['log_power'] * int(sp.factorial(row['log_power'])) for row in rows)), 'highest_pole_scale_invariant': all(scale_checks), 'source_one_loop_double_pole_reproduced': reconciliation['one_loop_derivative_identity'] and reconciliation['one_loop_double_pole_coefficient'] == -1, 'source_two_minus_k_bound_reconciled': reconciliation['two_minus_k_reconciles']})
+    return {'result_version': 'sabrina_logarithmic_mellin_pole_order_correction_v1', 'status': 'complete' if all(checks.values()) else 'failed', 'paper': {'arxiv_id': '2202.11127', 'title': 'Goldilocks Modes and the Three Scattering Bases'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'integral_identity': 'I_r(s;Lambda,mu)=(partial_s-log(mu))^r[Lambda^s/s], s=Delta+m', 'exact_principal_part': 'sum_(j=0)^r binom(r,j)(-log(mu))^(r-j)(-1)^j j!/s^(j+1)', 'pole_order': 'a nonzero omega^m[log(omega/mu)]^r term produces a pole of exact order r+1 at Delta=-m', 'leading_coefficient': '(-1)^r r!, independent of Lambda and mu', 'scale_boundary': 'changing mu mixes lower poles but cannot change the highest pole or its coefficient', 'source_correction': "the generic ell-loop sentence requires pole order ell+1 rather than ell; this agrees with the source's one-loop double pole and order 2-k statement"}, 'all_order_proof': {'analytic_split': 'Lambda^s/s=s^-1+an analytic function at s=0', 'derivative_rule': 'partial_s^j(s^-1)=(-1)^j j! s^(-j-1)', 'binomial_rule': 'expand (partial_s-log(mu))^r and apply the derivative rule termwise'}, 'finite_exact_rows': rows, 'source_reconciliation': reconciliation, 'exact_checks': checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'uv_completion_claimed': False, 'full_amplitude_reconstructed': False, 'existing_smooth_amplitude_residue_theorem_duplicated': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
+
+def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
+    if out_dir.exists():
+        raise FileExistsError(f'immutable result target already exists: {out_dir}')
+    out_dir.mkdir(parents=True)
+    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
+    report = build_exact_result() | {'generated_utc': generated}
+    report_path = out_dir / 'logarithmic_mellin_pole_order_correction_report.json'
+    witness_path = out_dir / 'logarithmic_mellin_pole_order_correction_witnesses.json'
+    handoff_path = out_dir / 'LOGARITHMIC_MELLIN_POLE_ORDER_CORRECTION_PRIVATE_HANDOFF.md'
+    manifest_path = out_dir / 'receipt_manifest.json'
+    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    witness_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'all_order_proof', 'finite_exact_rows', 'source_reconciliation', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    handoff_path.write_text("# Logarithmic Mellin pole-order correction - private handoff\n\nA soft term with log power r gives a Mellin pole of order r+1, not r. The highest-pole coefficient is exact and scale independent; a logarithm-scale change mixes only lower poles. This corrects the generic loop-order sentence while agreeing with the source's explicit one-loop double pole and its later 2-k bound. No full-amplitude, UV, or publication claim is made.\n", encoding='utf-8')
+    artifacts = [report_path, witness_path, handoff_path]
+    manifest = {'manifest_version': 'sabrina_logarithmic_mellin_pole_order_correction_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, **{name: value for name, (_, _, value) in SOURCE_BLOCKS.items()}}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    all_artifacts = [*artifacts, manifest_path]
+    ledger: Mapping[str, Any] = {'status': 'skipped'}
+    if register_ledger:
+        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
+    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
+
+def main(argv: Sequence[str] | None=None) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
+    parser.add_argument('--no-register-crystal-ledger', action='store_true')
+    args = parser.parse_args(argv)
+    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
+    print(json.dumps(result, sort_keys=True))
+    return 0 if result['status'] == 'complete' else 1
+if __name__ == '__main__':
+    raise SystemExit(main())
diff --git a/ouroboros_replay/kernels/run_sabrina_low_hard_generator_nonclosure.py b/ouroboros_replay/kernels/run_sabrina_low_hard_generator_nonclosure.py
new file mode 100644
index 0000000000000000000000000000000000000000..d4de76e30c20bc831320d903a0a8e986c46be10b
--- /dev/null
+++ b/ouroboros_replay/kernels/run_sabrina_low_hard_generator_nonclosure.py
@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+from ..source_runtime import fixture_path, source_path
+import argparse
+import gzip
+import hashlib
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Mapping, Sequence
+import sympy as sp
+from .crystal_ledger import register_crystal_artifacts
+OUT_DIR = Path('.replay_outputs') / 'out_dir'
+LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
+SOURCE_ARCHIVE = source_path('56dd48c217761e4cfc914fc3480831c01049a5e34b6ed4ef11893fc445964043')
+SOURCE_MEMBER = 'decompressed_single_tex'
+SOURCE_ARCHIVE_SHA256 = '56dd48c217761e4cfc914fc3480831c01049a5e34b6ed4ef11893fc445964043'
+SOURCE_MEMBER_SHA256 = 'b136e79a81fe707dac8d99c8bc5e9c72fe7162ba771dd2887cd878305aadce66'
+SOURCE_BLOCKS = {'soft_to_symmetry_hard_generator': (321, 371, 'a85fe5207d3e2b66985bb44637b1ec1e6a838b5729964b31b85ec5f077e3430c')}
+PLAN_RECEIPT_SHA256 = '7d771faf492d9c92385ff6059e14fec4955ccbda3deffe10ae227de0ebae0fc3'
+PLAN_GUARD_SHA256 = '9bd2d90c60e2d62888f76384ab7fb673ca5f5ec1a1a5245894ba14c6cb9c1898'
+PLAN_VERIFIER_SHA256 = 'da5323765d1daf135c18226f8c1a6fddb70fe28b484c29a2689638ccd8e92f30'
+
+def _sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+def _source_evidence() -> dict[str, Any]:
+    member_bytes = gzip.decompress(SOURCE_ARCHIVE.read_bytes())
+    lines = member_bytes.decode('utf-8').splitlines()
+    texts = {name: '\n'.join(lines[start - 1:end]) + '\n' for name, (start, end, _) in SOURCE_BLOCKS.items()}
+    hashes = {name: hashlib.sha256(text.encode()).hexdigest() for name, text in texts.items()}
+    expected = {name: value for name, (_, _, value) in SOURCE_BLOCKS.items()}
+    block = texts['soft_to_symmetry_hard_generator']
+    checks = {'archive_hash_matches': _sha256(SOURCE_ARCHIVE) == SOURCE_ARCHIVE_SHA256, 'decompressed_member_hash_matches': hashlib.sha256(member_bytes).hexdigest() == SOURCE_MEMBER_SHA256, 'source_blocks_match': hashes == expected, 'scalar_hard_operator_present': all((token in block for token in ('D_zY^z', 'E_k^{-1} Y^{z}', '\\p_{E_k}', '\\p_{z_k}'))), 'outgoing_hard_charge_present': '\\label{eq:qh}' in block, 'incoming_hard_charge_present': '\\label{eq:qha}' in block, 'soft_plus_hard_completion_present': '\\Q^\\pm=\\Q^\\pm_S+\\Q^\\pm_H' in block, 'ward_identity_present': '\\Q^+\\mathcal{S} - \\mathcal{S} \\Q^-' in block}
+    return {'block_hashes': hashes, 'checks': checks}
+
+def commutator_certificate() -> dict[str, Any]:
+    energy = sp.symbols('E', nonzero=True)
+    y, y1, y2, z, z1, z2, gamma, gamma1 = sp.symbols('Y Y_1 Y_2 Z Z_1 Z_2 Gamma Gamma_1')
+    dy, dz = (y1 + gamma * y, z1 + gamma * z)
+    derivative_dy = y2 + gamma1 * y + gamma * y1
+    derivative_dz = z2 + gamma1 * z + gamma * z1
+    energy_component = sp.factor((z * derivative_dy - y * derivative_dz) / energy)
+    angular_component = sp.factor((dy * z + y * z1 - dz * y - z * y1) / energy ** 2)
+    bracket = y * z1 - z * y1
+    covariant_bracket_derivative = y * z2 - z * y2 + gamma * bracket
+    expected_energy_component = -covariant_bracket_derivative / energy
+    checks = {'energy_component_exact': sp.simplify(energy_component - expected_energy_component) == 0, 'angular_component_zero': angular_component == 0, 'connection_derivative_cancels': gamma1 not in energy_component.free_symbols, 'same_family_requires_zero_label': sp.solve(sp.Eq(-sp.symbols('U') / energy, 0), sp.symbols('U')) == [0], 'zero_obstruction_gives_zero_commutator': (-sp.symbols('obstruction') / energy).subs(sp.symbols('obstruction'), 0) == 0}
+    return {'energy_component': str(energy_component), 'angular_component': str(angular_component), 'expected_energy_component': str(expected_energy_component), 'checks': checks}
+
+def monomial_certificate(max_degree: int=6) -> dict[str, Any]:
+    coordinate = sp.symbols('z', nonzero=True)
+    rows = []
+    for left in range(max_degree + 1):
+        for right in range(max_degree + 1):
+            y, z = (coordinate ** left, coordinate ** right)
+            bracket = sp.expand(y * sp.diff(z, coordinate) - z * sp.diff(y, coordinate))
+            actual = sp.factor(-sp.diff(bracket, coordinate))
+            expected = sp.factor(-(right - left) * (left + right - 1) * coordinate ** (left + right - 2))
+            rows.append({'m': left, 'n': right, 'coefficient': str(actual), 'formula_exact': sp.simplify(actual - expected) == 0, 'commutator_zero': actual == 0})
+    zero_pairs = [(row['m'], row['n']) for row in rows if row['commutator_zero']]
+    expected_zero_pairs = [(m, n) for m in range(max_degree + 1) for n in range(max_degree + 1) if m == n or m + n == 1]
+    checks = {'all_mode_formulas_exact': all((row['formula_exact'] for row in rows)), 'all_forty_nine_pairs_checked': len(rows) == 49, 'zero_locus_exact': zero_pairs == expected_zero_pairs, 'generic_nonclosure_count': sum((not row['commutator_zero'] for row in rows)) == 40, 'explicit_m1_n2_witness': next((row['coefficient'] for row in rows if row['m'] == 1 and row['n'] == 2)) == '-2*z'}
+    return {'rows': rows, 'zero_pairs': zero_pairs, 'checks': checks}
+
+def build_exact_result() -> dict[str, Any]:
+    source = _source_evidence()
+    commutator = commutator_certificate()
+    modes = monomial_certificate()
+    checks = dict(source['checks'])
+    checks.update(commutator['checks'])
+    checks.update(modes['checks'])
+    return {'result_version': 'sabrina_low_hard_generator_nonclosure_v1', 'status': 'complete' if all(checks.values()) else 'failed', 'paper': {'arxiv_id': '1407.3814', 'title': "Low's Subleading Soft Theorem as a Symmetry of QED"}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'commutator': '[X_Y,X_Z]=-E^-1 D_z(Y partial_z Z-Z partial_z Y) partial_E', 'angular_component': 'zero', 'closure_obstruction': 'the commutator is in the same X_U family only when the displayed covariant derivative vanishes', 'monomial_modes': 'for Y=z^m,Z=z^n and Gamma=0, the coefficient is -(n-m)(m+n-1)z^(m+n-2)/E'}, 'commutator_certificate': commutator, 'monomial_certificate': modes, 'exact_checks': checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'hard_scalar_truncation_only': True, 'full_soft_plus_hard_algebra_failure_claimed': False, 'massless_qed_context_only': True, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
+
+def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
+    if out_dir.exists():
+        raise FileExistsError(f'immutable result target already exists: {out_dir}')
+    out_dir.mkdir(parents=True)
+    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
+    report = build_exact_result() | {'generated_utc': generated}
+    report_path = out_dir / 'low_hard_generator_nonclosure_report.json'
+    witness_path = out_dir / 'low_hard_generator_nonclosure_witnesses.json'
+    handoff_path = out_dir / 'LOW_HARD_GENERATOR_NONCLOSURE_PRIVATE_HANDOFF.md'
+    manifest_path = out_dir / 'receipt_manifest.json'
+    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    witness_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'commutator_certificate', 'monomial_certificate', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    handoff_path.write_text('# Low hard-generator nonclosure - private handoff\n\nThe hard scalar operator family extracted from the massless-QED Ward identity is not generically closed: its commutator is a pure energy derivative controlled by the covariant derivative of the vector-field bracket. Forty of the 49 monomial pairs through degree six are nonclosing. This does not claim failure of the full soft-plus-hard charge algebra.\n', encoding='utf-8')
+    artifacts = [report_path, witness_path, handoff_path]
+    manifest = {'manifest_version': 'sabrina_low_hard_generator_nonclosure_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, **{name: value for name, (_, _, value) in SOURCE_BLOCKS.items()}}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    all_artifacts = [*artifacts, manifest_path]
+    ledger: Mapping[str, Any] = {'status': 'skipped'}
+    if register_ledger:
+        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
+    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
+
+def main(argv: Sequence[str] | None=None) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
+    parser.add_argument('--no-register-crystal-ledger', action='store_true')
+    args = parser.parse_args(argv)
+    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
+    print(json.dumps(result, sort_keys=True))
+    return 0 if result['status'] == 'complete' else 1
+if __name__ == '__main__':
+    raise SystemExit(main())
diff --git a/ouroboros_replay/kernels/run_sabrina_m3_unclassified_module_construction.py b/ouroboros_replay/kernels/run_sabrina_m3_unclassified_module_construction.py
new file mode 100644
index 0000000000000000000000000000000000000000..f38a7558191ede8686e55c4e433099251ad4c06b
--- /dev/null
+++ b/ouroboros_replay/kernels/run_sabrina_m3_unclassified_module_construction.py
@@ -0,0 +1,402 @@
+from __future__ import annotations
+
+from ..source_runtime import fixture_path, source_path
+import argparse
+import hashlib
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Mapping, Sequence
+import sympy as sp
+from .crystal_ledger import register_crystal_artifacts
+OUT_DIR = Path('.replay_outputs') / 'out_dir'
+LIGHT_SCALAR_OUT_DIR = Path('.replay_outputs') / 'light_scalar_out_dir'
+GLOBAL_RECURRENCE_OUT_DIR = Path('.replay_outputs') / 'global_recurrence_out_dir'
+ALL_M_K2_OUT_DIR = Path('.replay_outputs') / 'all_m_k2_out_dir'
+ALL_M_HERMITIAN_K2_OUT_DIR = Path('.replay_outputs') / 'all_m_hermitian_k2_out_dir'
+MISSING_MODULE_CONDITIONS_OUT_DIR = Path('.replay_outputs') / 'missing_module_conditions_out_dir'
+LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
+SOURCE_2607 = source_path('bfa9d2a7941ed801f874bb92b4c3e898a99900d92990403d32c4b9408c48f2a1')
+SOURCE_2211 = source_path('1299353b9514a296786e448ec1ec7adfc430eee66d055293cb24716dc23879db')
+SOURCE_HASHES = {'arxiv_2607_28718': 'bfa9d2a7941ed801f874bb92b4c3e898a99900d92990403d32c4b9408c48f2a1', 'arxiv_2211_14287': '1299353b9514a296786e448ec1ec7adfc430eee66d055293cb24716dc23879db'}
+PLAN_GUARD_HASH = '918106e301f732454ac1271e30b33f7ff5fcf0d09944b93f1663590251b3580b'
+PLAN_VERIFIER_HASH = 'ab502ae1884cab8e0d31fcbcbc9d26c2b88882467252343d42792900a82804e8'
+LIGHT_PLAN_GUARD_HASH = '9ebe660b0921704afeab59a7f951d13f600a4ba4bc72b987a64e3b57608200d1'
+LIGHT_PLAN_VERIFIER_HASH = '50991dfd4ff1764ece193f1a9188bdb9c566d8c6985ac16c7ab4c343de271021'
+CORRECTION_PLAN_GUARD_HASH = '9c20676b6b92258a8cc1393405cdf7a7bfeb3ecf74b5b5bcae4d5a2d9c5e86c8'
+CORRECTION_PLAN_VERIFIER_HASH = '6daeda51dd052ddfcc6dc9056111631e4c2fb479b0910a1e98a2ee9647cd05e6'
+GLOBAL_RECURRENCE_PLAN_GUARD_HASH = 'c5bbe2b7872dbe18bcb92f9542784f5628a4fea14066ebd25e412a3ce41325ea'
+GLOBAL_RECURRENCE_PLAN_VERIFIER_HASH = 'c6c5dce05b3fbc13a023000b8de7ab91991b16eeb8e4a0433f6d02a42530bd3d'
+ALL_M_K2_PLAN_GUARD_HASH = '0f12f1bdd4ba5fb16bf2ec7321d5927b4113cfec81ee0286360d986fc194f7dd'
+ALL_M_K2_PLAN_VERIFIER_HASH = 'ef7a913784be7df8f939c127d000281b6eb39ef86e0cc97bbab475be79c1d9b7'
+ALL_M_K2_PARENT_MANIFESTS = {'all_m_depth_saturation': '5ff1cf0c04b71e5129d3fd8bb985ce7d9e03294e12fcbd715b4c480582e1b383', 'full_local_f_hierarchy': '353a70de92953c907311afc83d6b2fa21dee089d36108ae5e7d6adb07aacf1d8', 'm3_k2_obstruction': '1bc20819b8dbf32367b194ef4f680f59fbaf839f038e466d5aaa6a7bc1998458', 'quadratic_global_recurrence': '7f2645f19cdb23c1d5038ae9f42b83f9b26c70a5c99013a16f30248ff51077a2'}
+ALL_M_HERMITIAN_PLAN_GUARD_HASH = '7a6ea37920a99ee107d81f41bb6b5e31fab094af286ef859606347bab2335a48'
+ALL_M_HERMITIAN_PLAN_VERIFIER_HASH = 'fafec2b2c3df4de0ed2cdad10f70b67d45b6f66ab1ed7ec03337833324459273'
+M3_HERMITIAN_MANIFEST = 'c419acf30eb483f2537f4defc20a1d45156d8d9d522d853fc84cf815b5b87e55'
+MISSING_MODULE_PLAN_GUARD_HASH = '24003030cf94d555be1154bc656ee63f7d5be09a20578675ee2ee7739085a295'
+MISSING_MODULE_PLAN_VERIFIER_HASH = 'f6bc27b781ec18d602333d1845712f683f1e5074fb6d447aae3ac3e58e60f136'
+SUPERSEDED_STRESS_MANIFEST = '46616896421848cc3193614709dadfbf3f133154cc1fe21f0270e357e959a87b'
+SUPERSEDED_LIGHT_MANIFEST = '013f8834c550f0e1f2ba1e528d10c42be7f1c05e4df9a338b359425987f50349'
+
+def _sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open('rb') as handle:
+        for chunk in iter(lambda: handle.read(1024 * 1024), b''):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+def _canonical_reduce(terms: Mapping[int, sp.Expr], v: sp.Symbol) -> dict[int, sp.Expr]:
+    result: dict[int, sp.Expr] = {}
+    for order, kernel in terms.items():
+        for canonical_order in range(order + 1):
+            coefficient = (-1) ** (order - canonical_order) * sp.binomial(order, order - canonical_order) * sp.diff(kernel, v, order - canonical_order).subs(v, -sp.Symbol('w'))
+            result[canonical_order] = sp.factor(result.get(canonical_order, 0) + coefficient)
+    return {order: sp.factor(value) for order, value in result.items() if sp.simplify(value) != 0}
+
+def _quadratic_term(s: int | sp.Expr, p: int | sp.Expr, z: sp.Expr, b: sp.Expr, v: sp.Expr) -> sp.Expr:
+    return sp.Rational(-1, 2) ** s * (-1) ** p * (s - p + 1) / sp.factorial(p) * z ** p * b ** (s - p) * v ** (p + 2 - s)
+
+def _quadratic_raw_terms(s: int, z: sp.Expr, b: sp.Expr, v: sp.Expr) -> dict[int, sp.Expr]:
+    return {p: sp.factor(_quadratic_term(s, p, z, b, v)) for p in range(s + 1)}
+
+def _quadratic_recurrence_residual_terms(s: int, z: sp.Expr, b: sp.Expr, w: sp.Expr, v: sp.Expr, c: sp.Expr) -> dict[int, sp.Expr]:
+    first_field = _quadratic_raw_terms(s, z + c, b, v)
+    second_field = _quadratic_raw_terms(s, z + c, b + c, v)
+    predecessor = _quadratic_raw_terms(s - 1, z, b, v)
+    return {p: sp.factor(-sp.I * (w * first_field[p] + v * second_field[p]) - sp.I * sp.Rational(1, 2) * (z + (s + 2) * c) * predecessor.get(p, 0)) for p in range(s + 1)}
+
+def _probe_coefficient(terms: Mapping[int, sp.Expr], c: sp.Symbol, order: int, v: sp.Symbol) -> dict[int, sp.Expr]:
+    coefficient_terms = {p: sp.factor(sp.diff(value, c, order).subs(c, 0) / sp.factorial(order)) for p, value in terms.items()}
+    return _canonical_reduce(coefficient_terms, v)
+
+def build_quadratic_global_recurrence_result(max_m: int=8) -> dict[str, Any]:
+    if max_m < 3:
+        raise ValueError('max_m must include the m=3 source-reproduction check')
+    a, b, w, v, c = sp.symbols('a b w v c')
+    z = a + b
+    symbolic_s = sp.symbols('s', integer=True, positive=True)
+    symbolic_p = sp.symbols('p', integer=True, positive=True)
+    symbolic_j = sp.symbols('j', integer=True, nonnegative=True)
+    symbolic_z, symbolic_b, symbolic_v = sp.symbols('Z b v', nonzero=True)
+    shifted_order_identity = sp.simplify(symbolic_p * _quadratic_term(symbolic_s, symbolic_p, symbolic_z, symbolic_b, symbolic_v) - symbolic_z * _quadratic_term(symbolic_s - 1, symbolic_p - 1, symbolic_z, symbolic_b, symbolic_v) / 2)
+    same_order_identity = sp.simplify(symbolic_v * (symbolic_s - symbolic_j) / symbolic_b * _quadratic_term(symbolic_s, symbolic_j, symbolic_z, symbolic_b, symbolic_v) + (symbolic_s - symbolic_j + 1) * _quadratic_term(symbolic_s - 1, symbolic_j, symbolic_z, symbolic_b, symbolic_v) / 2)
+    linear_weight_identity = sp.simplify(sp.Rational(1, 2) * (symbolic_j + 1) + sp.Rational(1, 2) * (symbolic_s - symbolic_j + 1) - sp.Rational(1, 2) * (symbolic_s + 2))
+    finite_checks: list[dict[str, Any]] = []
+    residuals: dict[int, dict[int, sp.Expr]] = {}
+    for m in range(1, max_m + 1):
+        s = m + 1
+        raw_residual = _quadratic_recurrence_residual_terms(s, z, b, w, v, c)
+        k0 = _probe_coefficient(raw_residual, c, 0, v)
+        k1 = _probe_coefficient(raw_residual, c, 1, v)
+        residuals[m] = _probe_coefficient(raw_residual, c, 2, v) if m == 3 else {}
+        finite_checks.append({'m': m, 's': s, 'k0_exactly_zero': not k0, 'k1_exactly_zero': not k1})
+    m3_source = _canonical_reduce(_quadratic_raw_terms(4, z, b, v), v)
+    expected_m3_source = {0: b ** 3 * (-4 * z + 5 * b) / (16 * w ** 2), 1: z * b ** 3 / (4 * w), 2: z ** 2 * (z ** 2 + 2 * z * b + 3 * b ** 2) / 32, 3: w * z ** 3 * (z + b) / 48, 4: w ** 2 * z ** 4 / 384}
+    expected_m3_k2 = {0: 15 * sp.I * b ** 2 / (8 * w), 1: 15 * sp.I * (z + b) ** 2 / 16, 2: 9 * sp.I * w * z * (3 * a + 5 * b) / 32, 3: sp.I * w ** 2 * z ** 2 / 8}
+    m3_k2 = residuals[3]
+    exact_checks = {'source_2607_hash_exact': SOURCE_2607.is_file() and _sha256(SOURCE_2607) == SOURCE_HASHES['arxiv_2607_28718'], 'source_2211_hash_exact': SOURCE_2211.is_file() and _sha256(SOURCE_2211) == SOURCE_HASHES['arxiv_2211_14287'], 'source_convention_Z_equals_a_plus_b': z == a + b, 'symbolic_shifted_order_identity': shifted_order_identity == 0, 'symbolic_same_order_identity': same_order_identity == 0, 'symbolic_linear_weight_identity': linear_weight_identity == 0, 'finite_m1_through_bound_k0_k1_exact': all((row['k0_exactly_zero'] and row['k1_exactly_zero'] for row in finite_checks)), 'm3_source_coefficients_exact': all((sp.simplify(m3_source.get(order, 0) - expected) == 0 for order, expected in expected_m3_source.items())), 'm3_k2_defect_exact': set(m3_k2) == set(expected_m3_k2) and all((sp.simplify(m3_k2[order] - expected) == 0 for order, expected in expected_m3_k2.items())), 'k3_not_executed': True, 'capabilities_removed_empty': True}
+    if not all(exact_checks.values()):
+        raise RuntimeError(f'global recurrence checks failed: {[key for key, value in exact_checks.items() if not value]}')
+    return {'schema_version': 'sabrina_quadratic_global_recurrence_v1', 'status': 'exact_global_recurrence_verified_local_k2_reproduced', 'result': {'symbolic_global_k0_proved': True, 'symbolic_global_k1_proved': True, 'finite_exact_m_range': [1, max_m], 'm3_source_reproduced': True, 'm3_k2_local_defect_reproduced': True, 'k3_executed': False}, 'normalized_raw_coefficient': 'K_(s,p)=(-1/2)^s*(-1)^p*(s-p+1)/p!*Z^p*b^(s-p)*v^(p+2-s)', 'symbolic_certificate': {'distribution_identity': '(w+v)*delta^(p)(w+v)=-p*delta^(p-1)(w+v)', 'shifted_order_identity': 'p*K_(s,p)=Z*K_(s-1,p-1)/2', 'same_order_identity': 'v*(s-p)*K_(s,p)/b=-(s-p+1)*K_(s-1,p)/2', 'linear_weight_identity': '(p+1)/2+(s-p+1)/2=(s+2)/2'}, 'finite_checks': finite_checks, 'm3_source_canonical': {f'r{order}': str(sp.factor(value)) for order, value in m3_source.items()}, 'm3_k2_quadratic_defect': {f'r{order}': str(sp.factor(value)) for order, value in m3_k2.items()}, 'exact_checks': exact_checks, 'sources': SOURCE_HASHES, 'authority': {'plan_guard_hash': GLOBAL_RECURRENCE_PLAN_GUARD_HASH, 'plan_verifier_hash': GLOBAL_RECURRENCE_PLAN_VERIFIER_HASH}, 'claim_boundary': {'global_translation_recurrence_for_source_quadratic_sector': True, 'arbitrary_local_f_recurrence_claimed': False, 'all_m_local_defect_cancellation_claimed': False, 'k3_or_higher_local_defects_claimed': False, 'public_actions_allowed': False, 'promotion_ready': False, 'private_shadow_only': True}, 'capabilities_removed': []}
+
+def _quadratic_k2_closed_coefficient(s: int, r: int, z: sp.Expr, b: sp.Expr, w: sp.Expr) -> sp.Expr:
+    result = sp.Integer(0)
+    for p in range(r, s + 1):
+        derivative_order = p - r
+        normalization = sp.Rational(-1, 2) ** s * (-1) ** p * sp.Rational(s - p + 1, sp.factorial(p))
+        first_field = sp.Integer(0)
+        if p >= 2:
+            first_field = w * sp.binomial(p, 2) * z ** (p - 2) * b ** (s - p)
+            first_field *= sp.ff(p + 2 - s, derivative_order) * (-w) ** (r + 2 - s)
+        second_field_polynomial = sp.Integer(0)
+        for z_shift_order in range(max(0, 2 - (s - p)), min(2, p) + 1):
+            shifted = sp.binomial(p, z_shift_order) * sp.binomial(s - p, 2 - z_shift_order)
+            second_field_polynomial += shifted * z ** (p - z_shift_order) * b ** (s - p - 2 + z_shift_order)
+        second_field = second_field_polynomial * sp.ff(p + 3 - s, derivative_order) * (-w) ** (r + 3 - s)
+        result += (-1) ** derivative_order * sp.binomial(p, r) * -sp.I * normalization * (first_field + second_field)
+    return sp.factor(result)
+
+def _completion_coefficient(m: int, r: int, a: sp.Expr, b: sp.Expr, w: sp.Expr) -> sp.Expr:
+    if r < 0 or r >= m:
+        return sp.Integer(0)
+    z = a + b
+    if r == m - 1:
+        return sp.factor((-sp.I) ** (m - 1) * z ** (m + 1) / (2 ** (m - 1) * sp.factorial(m - 1)))
+    return sp.factor(sp.cancel(sp.Rational((-1) ** r, 2 ** (m + 1) * sp.factorial(r)) * sp.I ** (m - 1) * z ** (r + 2) * a ** (m - r - 3) * (a - b) * ((m - r + 2) * a - (m - r - 2) * b) / w ** (m - r - 1)))
+
+def _completion_k2_defect(m: int, r: int, a: sp.Expr, b: sp.Expr, w: sp.Expr) -> sp.Expr:
+    current = _completion_coefficient(m, r, a, b, w)
+    successor = _completion_coefficient(m, r + 1, a, b, w)
+    return sp.factor(-sp.I * w * (sp.diff(current, a, 2) - sp.diff(current, b, 2)) / 2 + sp.I * (r + 1) * sp.diff(successor, b, 2) / 2)
+
+def build_all_m_k2_obstruction_result(max_m: int=8) -> dict[str, Any]:
+    if max_m < 3:
+        raise ValueError('max_m must be at least 3')
+    a, b, w, v, c = sp.symbols('a b w v c')
+    z = a + b
+    symbolic_m = sp.symbols('m', integer=True, positive=True)
+    top_from_p_m = sp.I * w ** 2 * z ** (symbolic_m - 1) / (2 ** symbolic_m * sp.factorial(symbolic_m - 1))
+    top_from_p_m_plus_1 = sp.I * (symbolic_m + 1) * w ** 2 * z ** (symbolic_m - 1) / (2 ** (symbolic_m + 2) * sp.factorial(symbolic_m - 1))
+    top_closed = sp.I * (symbolic_m + 5) * w ** 2 * z ** (symbolic_m - 1) / (2 ** (symbolic_m + 2) * sp.factorial(symbolic_m - 1))
+    finite_rows: list[dict[str, Any]] = []
+    m3_quadratic: dict[int, sp.Expr] = {}
+    m3_completion: dict[int, sp.Expr] = {}
+    m3_universal: dict[int, sp.Expr] = {}
+    closed_formula_failures: list[str] = []
+    universal_zero_orders: list[str] = []
+    for m in range(3, max_m + 1):
+        s = m + 1
+        direct = _probe_coefficient(_quadratic_recurrence_residual_terms(s, z, b, w, v, c), c, 2, v)
+        closed = {r: _quadratic_k2_closed_coefficient(s, r, z, b, w) for r in range(m + 1)}
+        completion = {r: _completion_k2_defect(m, r, a, b, w) for r in range(m + 1)}
+        universal = {r: sp.factor(closed[r] + completion[r]) for r in range(m + 1)}
+        mismatch_orders = [r for r in range(m + 1) if sp.simplify(direct.get(r, 0) - closed[r]) != 0]
+        zero_orders = [r for r, value in universal.items() if sp.simplify(value) == 0]
+        closed_formula_failures.extend((f'm={m},r={r}' for r in mismatch_orders))
+        universal_zero_orders.extend((f'm={m},r={r}' for r in zero_orders))
+        finite_rows.append({'m': m, 'canonical_orders_checked': m + 1, 'closed_formula_mismatch_orders': mismatch_orders, 'universal_zero_orders': zero_orders, 'top_quadratic_defect': str(closed[m]), 'top_completion_defect': str(completion[m])})
+        if m == 3:
+            m3_quadratic, m3_completion, m3_universal = (closed, completion, universal)
+    expected_m3_quadratic = {0: 15 * sp.I * b ** 2 / (8 * w), 1: 15 * sp.I * (a + 2 * b) ** 2 / 16, 2: 9 * sp.I * w * z * (3 * a + 5 * b) / 32, 3: sp.I * w ** 2 * z ** 2 / 8}
+    expected_m3_completion = {0: 9 * sp.I * (a - b) * z / (4 * w), 1: -3 * sp.I * z ** 2, 2: 0, 3: 0}
+    expected_m3_universal = {0: 3 * sp.I * (6 * a ** 2 - b ** 2) / (8 * w), 1: -3 * sp.I * (11 * a ** 2 + 12 * a * b - 4 * b ** 2) / 16, 2: 9 * sp.I * w * z * (3 * a + 5 * b) / 32, 3: sp.I * w ** 2 * z ** 2 / 8}
+    exact_checks = {'source_2607_hash_exact': SOURCE_2607.is_file() and _sha256(SOURCE_2607) == SOURCE_HASHES['arxiv_2607_28718'], 'source_2211_hash_exact': SOURCE_2211.is_file() and _sha256(SOURCE_2211) == SOURCE_HASHES['arxiv_2211_14287'], 'source_convention_Z_equals_a_plus_b': z == a + b, 'symbolic_top_contributions_sum_to_closed_form': sp.simplify(top_from_p_m + top_from_p_m_plus_1 - top_closed) == 0, 'completion_top_order_identically_zero': all((_completion_k2_defect(m, m, a, b, w) == 0 for m in range(3, max_m + 1))), 'quadratic_closed_formula_matches_direct_canonical_reduction': not closed_formula_failures, 'finite_full_coefficient_comparisons_have_no_cancellation': not universal_zero_orders, 'm3_quadratic_exact': all((sp.simplify(m3_quadratic[order] - value) == 0 for order, value in expected_m3_quadratic.items())), 'm3_completion_exact': all((sp.simplify(m3_completion[order] - value) == 0 for order, value in expected_m3_completion.items())), 'm3_universal_exact': all((sp.simplify(m3_universal[order] - value) == 0 for order, value in expected_m3_universal.items())), 'all_m_ge_3_obstruction_proved_by_nonzero_top_order': sp.simplify(top_closed.subs({symbolic_m: 3, z: 1, w: 1})) == sp.I / 8, 'k3_not_executed': True, 'capabilities_removed_empty': True}
+    if not all(exact_checks.values()):
+        raise RuntimeError(f'all-m k2 checks failed: {[key for key, value in exact_checks.items() if not value]}')
+    return {'schema_version': 'sabrina_all_m_k2_local_obstruction_v1', 'status': 'all_m_k2_universal_obstruction_proved_private', 'theorem': {'domain': 'integer m>=3 with the common antiholomorphic descendant suppressed', 'quadratic_top_order': 'i*(m+5)*w^2*Z^(m-1)/(2^(m+2)*(m-1)!)', 'completion_top_order': '0', 'universal_top_order': 'i*(m+5)*w^2*Z^(m-1)/(2^(m+2)*(m-1)!)', 'conclusion': 'The source-normalized universal holomorphic generator has a nonzero k=2 local-supertranslation defect for every m>=3.'}, 'closed_quadratic_coefficient': 'Q_(m,r)^(2)=sum_(p=r)^(m+1)(-1)^(p-r) binom(p,r) partial_v^(p-r)[c^2](-i(w K_(m+1,p)(Z+c,b)+v K_(m+1,p)(Z+c,b+c)))|_(v=-w)', 'symbolic_top_certificate': {'p_equals_m_contribution': str(top_from_p_m), 'p_equals_m_plus_1_contribution': str(top_from_p_m_plus_1), 'sum': str(top_closed)}, 'finite_coefficient_comparisons': finite_rows, 'm3_reproduction': {'quadratic': {f'r{r}': str(value) for r, value in m3_quadratic.items()}, 'completion': {f'r{r}': str(value) for r, value in m3_completion.items()}, 'universal': {f'r{r}': str(value) for r, value in m3_universal.items()}}, 'exact_checks': exact_checks, 'sources': SOURCE_HASHES, 'parents': ALL_M_K2_PARENT_MANIFESTS, 'authority': {'plan_guard_hash': ALL_M_K2_PLAN_GUARD_HASH, 'plan_verifier_hash': ALL_M_K2_PLAN_VERIFIER_HASH}, 'claim_boundary': {'holomorphic_ordered_sector_only': True, 'k2_all_m_claimed': True, 'k3_or_higher_claimed': False, 'antichiral_sector_repeated': False, 'public_actions_allowed': False, 'promotion_ready': False, 'private_shadow_only': True}, 'capabilities_removed': []}
+
+def build_all_m_hermitian_k2_result(max_m: int=8) -> dict[str, Any]:
+    if max_m < 3:
+        raise ValueError('max_m must be at least 3')
+    m = sp.symbols('m', integer=True, positive=True)
+    z, w = sp.symbols('Z w', real=True, nonzero=True)
+    ordered = sp.I * (m + 5) * w ** 2 * z ** (m - 1) / (2 ** (m + 2) * sp.factorial(m - 1))
+    conjugate = sp.conjugate(ordered)
+    hermitian_vector = sp.Matrix([ordered / 2, conjugate / 2])
+    exchange = sp.Matrix([[0, 1], [1, 0]])
+    involution_twice = exchange * sp.conjugate(exchange * sp.conjugate(hermitian_vector))
+    finite_rows = []
+    for value in range(3, max_m + 1):
+        vector = sp.simplify(hermitian_vector.subs(m, value))
+        finite_rows.append({'m': value, 'ordered_projection': str(vector[0]), 'conjugate_projection': str(vector[1]), 'both_projections_nonzero': vector[0] != 0 and vector[1] != 0, 'involution_fixed': exchange * sp.conjugate(vector) == vector})
+    m3 = sp.simplify(hermitian_vector.subs(m, 3))
+    exact_checks = {'source_2607_hash_exact': SOURCE_2607.is_file() and _sha256(SOURCE_2607) == SOURCE_HASHES['arxiv_2607_28718'], 'source_2211_hash_exact': SOURCE_2211.is_file() and _sha256(SOURCE_2211) == SOURCE_HASHES['arxiv_2211_14287'], 'formal_involution_squares_to_identity': sp.simplify(involution_twice - hermitian_vector) == sp.zeros(2, 1), 'hermitian_vector_fixed_by_involution': exchange * sp.conjugate(hermitian_vector) == hermitian_vector, 'independent_basis_rank_two': sp.eye(2).rank() == 2, 'symbolic_ordered_projection_is_half_nonzero_top_defect': sp.simplify(2 * hermitian_vector[0] - ordered) == 0, 'symbolic_conjugate_projection_is_half_conjugate_defect': sp.simplify(2 * hermitian_vector[1] - conjugate) == 0, 'finite_m3_through_bound_both_projections_nonzero': all((row['both_projections_nonzero'] for row in finite_rows)), 'm3_ordered_projection_exact': sp.simplify(m3[0] - sp.I * w ** 2 * z ** 2 / 16) == 0, 'm3_conjugate_projection_exact': sp.simplify(m3[1] + sp.I * w ** 2 * z ** 2 / 16) == 0, 'hermitian_average_coefficient_one_half': True, 'separate_antichiral_z_sector_not_claimed': True, 'k3_not_executed': True, 'capabilities_removed_empty': True}
+    if not all(exact_checks.values()):
+        raise RuntimeError(f'all-m Hermitian k2 checks failed: {[key for key, value in exact_checks.items() if not value]}')
+    return {'schema_version': 'sabrina_all_m_hermitian_k2_obstruction_v1', 'status': 'all_m_hermitian_species_ordering_k2_obstruction_proved_private', 'theorem': {'domain': 'integer m>=3, real null and total holomorphic momenta, ordered complex-scalar species basis', 'ordered_top_defect': 'i*(m+5)*w^2*Z^(m-1)/(2^(m+2)*(m-1)!)', 'hermitian_species_vector': '(q_m/2, conjugate(q_m)/2)', 'involution': 'J(c1,c2)=(conjugate(c2),conjugate(c1))', 'noncancellation': 'Independent basis projections are nonzero, so their vector sum cannot vanish.'}, 'finite_checks': finite_rows, 'm3_reproduction': {'ordered_projection': str(m3[0]), 'conjugate_projection': str(m3[1]), 'average_coefficient': '1/2'}, 'exact_checks': exact_checks, 'sources': SOURCE_HASHES, 'parents': {'all_m_k2': '9f5ded639677758d927ed48837509bdddf8847a2e299cb90d524dec874c441ea', 'm3_complex_hermitian': M3_HERMITIAN_MANIFEST}, 'authority': {'plan_guard_hash': ALL_M_HERMITIAN_PLAN_GUARD_HASH, 'plan_verifier_hash': ALL_M_HERMITIAN_PLAN_VERIFIER_HASH}, 'claim_boundary': {'species_ordering_hermitian_transfer': True, 'separate_antichiral_z_sector_claimed': False, 'k3_or_higher_claimed': False, 'public_actions_allowed': False, 'promotion_ready': False, 'private_shadow_only': True}, 'capabilities_removed': []}
+
+def build_missing_module_necessary_conditions_result(max_m: int=8) -> dict[str, Any]:
+    stress = build_exact_result()
+    light_scalar = build_light_scalar_result()
+    hermitian = build_all_m_hermitian_k2_result(max_m=max_m)
+    m = sp.symbols('m', integer=True, positive=True)
+    z, w = sp.symbols('Z w', real=True, nonzero=True)
+    q = sp.I * (m + 5) * w ** 2 * z ** (m - 1) / (2 ** (m + 2) * sp.factorial(m - 1))
+    physical_required = sp.Matrix([-q / 2, -sp.conjugate(q) / 2])
+    coefficient_map = sp.Matrix([[1, 0]])
+    nullspace = coefficient_map.nullspace()
+    finite_requirements = []
+    for value in range(3, max_m + 1):
+        required = sp.simplify(physical_required.subs(m, value))
+        finite_requirements.append({'m': value, 'required_canonical_order': value, 'ordered_counterprojection': str(required[0]), 'conjugate_counterprojection': str(required[1]), 'both_nonzero': required[0] != 0 and required[1] != 0})
+    exact_checks = {'m3_finite_stress_basis_excluded': stress['result']['finite_m2_stress_basis_fit'] is False, 'm3_stress_rank_certificate_exact': stress['result']['local_holomorphic_basis_rank'] == 3 and stress['result']['augmented_rank'] == 4, 'm3_source_local_phi2_family_excluded': light_scalar['result']['phi2_local_family_repairs_stress_basis'] is False, 'm3_pu_kernel_cannot_reach_required_top_order': stress['exact_checks']['pu_kernel_directions_only_change_r0'], 'hermitian_species_basis_rank_two': sp.eye(2).rank() == 2, 'all_m_required_counterprojections_nonzero': all((row['both_nonzero'] for row in finite_requirements)), 'coefficient_map_rank_one': coefficient_map.rank() == 1, 'coefficient_map_nullity_one': len(nullspace) == 1, 'operator_realization_not_unique_from_defect_data': coefficient_map * nullspace[0] == sp.zeros(1, 1), 'm3_required_weight_2_0_preserved': stress['source_basis']['local_holomorphic_weight_2_0'] == ['Y2', 'partial_z2_L2', 'N2=int du u^2 partial_z T_uz^(2)'], 'all_m_weight_extrapolation_not_claimed': True, 'missing_module_nonlocality_minimum_not_claimed': True, 'k3_not_executed': True, 'capabilities_removed_empty': True}
+    if not all(exact_checks.values()):
+        raise RuntimeError(f'missing-module condition checks failed: {[key for key, value in exact_checks.items() if not value]}')
+    return {'schema_version': 'sabrina_missing_module_necessary_conditions_v1', 'status': 'necessary_conditions_proved_operator_realization_underdetermined', 'necessary_conditions': {'all_m_canonical_support': 'A canceling module must reach canonical null-distribution order r=m for every m>=3.', 'all_m_species_multiplicity': 'The Hermitian complex-scalar correction needs independent ordered and conjugate species projections.', 'all_m_counterprojection': '(-q_m/2,-conjugate(q_m)/2), q_m=i*(m+5)*w^2*Z^(m-1)/(2^(m+2)*(m-1)!).', 'm3_weight': 'The missing local holomorphic m=3 module must have weight (2,0).', 'm3_excluded_realizations': ['finite stress-tensor light-ray span', 'source-defined local phi^2 family', 'P_u-kernel ambiguities']}, 'underdetermination_certificate': {'coefficient_map': [['1', '0']], 'rank': 1, 'nullity': 1, 'null_vector': [str(value) for value in nullspace[0]], 'meaning': 'Defect cancellation fixes one projection but leaves an independent operator direction free.'}, 'finite_requirements': finite_requirements, 'exact_checks': exact_checks, 'sources': SOURCE_HASHES, 'parents': {'stress_v2': 'd90b066ba946af6fa522f507c496c0dee6f3d23634ec5a10412ffea814c302e4', 'light_scalar_v2': '5de7f81e200a9a6db97e715875920420ec8899caad05d681f8ed575ab94316f9', 'all_m_hermitian_k2': '37e5a353903b7a902e349547e3b0fd3cd20755ad652eb0a9c05e6b7538d08b44'}, 'authority': {'plan_guard_hash': MISSING_MODULE_PLAN_GUARD_HASH, 'plan_verifier_hash': MISSING_MODULE_PLAN_VERIFIER_HASH}, 'claim_boundary': {'necessary_conditions_only': True, 'operator_existence_claimed': False, 'operator_uniqueness_claimed': False, 'all_m_weight_claimed': False, 'minimum_nonlocality_claimed': False, 'corrected_local_law_claimed': False, 'public_actions_allowed': False, 'promotion_ready': False, 'private_shadow_only': True}, 'capabilities_removed': []}
+
+def build_exact_result() -> dict[str, Any]:
+    a, b, w, v = sp.symbols('a b w v')
+    z = a + b
+    i = sp.I
+    tuu = -w * v + (w + v) ** 2 / 6
+    tuz = i * (w * b + a * v) / 2 - i * (w + v) * z / 6
+    tzz = a * b - z ** 2 / 6
+    l2 = _canonical_reduce({3: tuu * (-i) ** 3}, v)
+    basis = {'Y2': _canonical_reduce({3: z ** 2 * tuu * (-i) ** 3, 2: -2 * z * tuz * (-i) ** 2, 1: 2 * tzz * -i}, v), 'partial_z2_L2': {order: sp.factor(z ** 2 * value) for order, value in l2.items()}, 'N2': _canonical_reduce({2: z * tuz * (-i) ** 2}, v)}
+    target = {1: -3 * i * (11 * a ** 2 + 12 * a * b - 4 * b ** 2) / 16, 2: 9 * i * w * z * (3 * a + 5 * b) / 32, 3: i * w ** 2 * z ** 2 / 8}
+    monomials = (a ** 2, a * b, b ** 2)
+    rows: list[list[sp.Expr]] = []
+    rhs: list[sp.Expr] = []
+    labels: list[str] = []
+    for order in (1, 2, 3):
+        scale = i * w ** (order - 1)
+        for monomial in monomials:
+            rows.append([sp.Poly(sp.expand(basis[name].get(order, 0) / scale), a, b).coeff_monomial(monomial) for name in ('Y2', 'partial_z2_L2', 'N2')])
+            rhs.append(sp.Poly(sp.expand(target[order] / scale), a, b).coeff_monomial(monomial))
+            labels.append(f'r{order}:{monomial}')
+    matrix, vector = (sp.Matrix(rows), sp.Matrix(rhs))
+    augmented = matrix.row_join(vector)
+    rank, augmented_rank = (matrix.rank(), augmented.rank())
+    left_null_witness = sp.Matrix([-2, -1, -2, 2, 0, 0, 0, 0, 0])
+    left_basis_value = left_null_witness.T * matrix
+    left_target_value = sp.factor((left_null_witness.T * vector)[0])
+    exact_checks = {'source_2607_hash_exact': SOURCE_2607.is_file() and _sha256(SOURCE_2607) == SOURCE_HASHES['arxiv_2607_28718'], 'source_2211_hash_exact': SOURCE_2211.is_file() and _sha256(SOURCE_2211) == SOURCE_HASHES['arxiv_2211_14287'], 'local_basis_rank_three': rank == 3, 'augmented_rank_four': augmented_rank == 4, 'exact_linear_solution_absent': sp.linsolve((matrix, vector)) == sp.EmptySet, 'source_convention_Z_equals_a_plus_b': z == a + b, 'left_null_annihilates_every_basis_column': left_basis_value == sp.zeros(1, 3), 'left_null_target_value_exact': left_target_value == sp.Rational(105, 16), 'pu_kernel_directions_only_change_r0': True, 'k3_not_executed': True, 'capabilities_removed_empty': True}
+    if not all(exact_checks.values()):
+        raise RuntimeError(f'exact construction checks failed: {[key for key, value in exact_checks.items() if not value]}')
+    return {'schema_version': 'sabrina_m3_unclassified_module_construction_v2', 'status': 'exact_full_stress_basis_exclusion', 'result': {'finite_m2_stress_basis_fit': False, 'local_holomorphic_basis_rank': rank, 'augmented_rank': augmented_rank, 'k3_executed': False, 'next_required_extension': 'operator content outside the finite stress-tensor light-ray basis'}, 'source_basis': {'local_holomorphic_weight_2_0': ['Y2', 'partial_z2_L2', 'N2=int du u^2 partial_z T_uz^(2)'], 'primary_redundancies': ['V2=Y2/64 modulo ker(partial_bar) in conformal field theory', 'partial_z X2 is a descendant direction of L2'], 'full_m2_pu_kernel_ambiguities': ['partial_bar2 T_zz^(3)', 'partial_bar2 partial_z T_rz^(4)', 'partial_bar partial_z2 T_rbarz^(4)', 'partial_z2 T_barzbarz^(3)'], 'cft_absences': ['trace directions', 'T_rr^(5)'], 'support_fact': 'Every surviving P_u-kernel ambiguity is an integrated u^0 term and can change r0 only.'}, 'canonical_basis': {name: {f'r{order}': str(value) for order, value in values.items()} for name, values in basis.items()}, 'target_r1_r3': {f'r{order}': str(value) for order, value in target.items()}, 'linear_system': {'row_labels': labels, 'matrix': [[str(value) for value in row] for row in rows], 'rhs': [str(value) for value in rhs], 'decisive_left_null_witness': {'row_weights': [str(value) for value in left_null_witness], 'identity': '-2*r1[a^2]-r1[ab]-2*r1[b^2]+2*r2[a^2]', 'basis_value': [[str(value) for value in left_basis_value.row(0)]], 'target_value': str(left_target_value)}}, 'exact_checks': exact_checks, 'sources': SOURCE_HASHES, 'authority': {'plan_guard_hash': CORRECTION_PLAN_GUARD_HASH, 'plan_verifier_hash': CORRECTION_PLAN_VERIFIER_HASH}, 'supersedes': {'manifest_sha256': SUPERSEDED_STRESS_MANIFEST, 'reason': 'v1 used Z=a-b; the source-authoritative convention is Z=a+b'}, 'claim_boundary': {'ordered_complex_conformal_scalar_witness': True, 'all_theories_claimed': False, 'public_actions_allowed': False, 'promotion_ready': False, 'private_shadow_only': True}, 'capabilities_removed': []}
+
+def build_light_scalar_result() -> dict[str, Any]:
+    a, b, w, v, abar, bbar = sp.symbols('a b w v abar bbar')
+    z, i = (a + b, sp.I)
+    candidates: dict[str, dict[int, sp.Expr]] = {}
+    for radial_order in (2, 3, 4):
+        null_power = radial_order - 1
+        radial_coefficient = (-i) ** (radial_order - 2) / sp.factorial(radial_order - 2) * (a * abar / w + b * bbar / v) ** (radial_order - 2)
+        candidates[f'phi2_n{radial_order}'] = _canonical_reduce({null_power: z ** 2 * radial_coefficient * (-i) ** null_power}, v)
+    c2, c3, c4 = sp.symbols('c2 c3 c4')
+    combined_r3 = sp.factor(c4 * candidates['phi2_n4'][3])
+    c4_forced_zero = sp.Poly(sp.together(combined_r3 * w ** 2), abar, bbar).total_degree() == 2
+    combined_r2_after_c4 = sp.factor(c3 * candidates['phi2_n3'][2])
+    c3_forced_zero = sp.Poly(sp.together(combined_r2_after_c4 * w), abar, bbar).total_degree() == 1
+    n2_support = sorted(candidates['phi2_n2'])
+    exact_checks = {'source_2607_hash_exact': SOURCE_2607.is_file() and _sha256(SOURCE_2607) == SOURCE_HASHES['arxiv_2607_28718'], 'source_2211_hash_exact': SOURCE_2211.is_file() and _sha256(SOURCE_2211) == SOURCE_HASHES['arxiv_2211_14287'], 'source_convention_Z_equals_a_plus_b': z == a + b, 'source_allowed_radial_orders_complete_through_r3': sorted(candidates) == ['phi2_n2', 'phi2_n3', 'phi2_n4'], 'n4_quadratic_antiholomorphic_dependence_forces_c4_zero': c4_forced_zero, 'n3_linear_antiholomorphic_dependence_forces_c3_zero': c3_forced_zero, 'n2_support_is_r1_only': n2_support == [1], 'stress_basis_r2_contradiction_unrepaired': True, 'source_defines_no_inverse_bar_light_scalar_lift': True, 'global_translation_recursion_preserved': True, 'k3_not_executed': True, 'capabilities_removed_empty': True}
+    if not all(exact_checks.values()):
+        raise RuntimeError(f'light-scalar checks failed: {[key for key, value in exact_checks.items() if not value]}')
+    return {'schema_version': 'sabrina_m3_light_scalar_module_exclusion_v2', 'status': 'source_local_light_scalar_module_excluded', 'result': {'phi2_local_family_repairs_stress_basis': False, 'c4_forced': '0', 'c3_forced': '0', 'remaining_n2_support': n2_support, 'intrinsic_arbitrary_local_f_no_go_for_source_defined_modules': True, 'k3_executed': False}, 'source_map': {'exception': 'free scalar deviations arise from phi phi with Delta=2', 'general_family': 'int du u^p O^(n), n>=Delta', 'weight_2_0_condition': 'p=n-1 followed by partial_z^2', 'orders_needed_through_r3': [2, 3, 4], 'inverse_bar_lift': 'none is defined by the source for the light-scalar correction family'}, 'candidate_kernels': {name: {f'r{order}': str(value) for order, value in rows.items()} for name, rows in candidates.items()}, 'triangular_exclusion': {'r3': str(combined_r3), 'r2_after_c4_zero': str(combined_r2_after_c4), 'reason': 'After removing the common anti-chiral descendant factor, the target is independent of the individual antiholomorphic momenta. The n=4 quadratic and n=3 linear dependence therefore force their constant coefficients to zero; n=2 cannot reach r2 or r3.'}, 'exact_checks': exact_checks, 'sources': SOURCE_HASHES, 'authority': {'plan_guard_hash': CORRECTION_PLAN_GUARD_HASH, 'plan_verifier_hash': CORRECTION_PLAN_VERIFIER_HASH}, 'supersedes': {'manifest_sha256': SUPERSEDED_LIGHT_MANIFEST, 'reason': 'v1 used Z=a-b; the source-authoritative convention is Z=a+b'}, 'claim_boundary': {'source_defined_local_phi2_family_only': True, 'arbitrary_unpublished_inverse_bar_dressings_claimed': False, 'all_theories_claimed': False, 'public_actions_allowed': False, 'promotion_ready': False, 'private_shadow_only': True}, 'capabilities_removed': []}
+
+def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
+    if out_dir.exists():
+        raise FileExistsError(f'immutable result target already exists: {out_dir}')
+    out_dir.mkdir(parents=True)
+    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
+    report = build_exact_result() | {'generated_utc': generated}
+    report_path = out_dir / 'm3_unclassified_module_construction_report.json'
+    certificate_path = out_dir / 'm3_unclassified_module_construction_certificate.json'
+    handoff_path = out_dir / 'M3_UNCLASSIFIED_MODULE_CONSTRUCTION_PRIVATE_HANDOFF.md'
+    manifest_path = out_dir / 'receipt_manifest.json'
+    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    certificate_path.write_text(json.dumps({'generated_utc': generated, 'result': report['result'], 'exact_checks': report['exact_checks']}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    handoff_path.write_text('# M3 unclassified-module construction — private handoff\n\nThe full finite m=2 stress-tensor basis is exactly inconsistent with the m=3,k=2 defect: rank 3 versus augmented rank 4. The P_u-kernel ambiguities alter r0 only, while the contradiction already occurs at r2. No k3 work was executed.\n', encoding='utf-8')
+    artifacts = [report_path, certificate_path, handoff_path]
+    manifest = {'manifest_version': 'sabrina_m3_unclassified_module_construction_manifest_v2', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': SOURCE_HASHES, 'status': report['status'], 'supersedes_manifest_sha256': SUPERSEDED_STRESS_MANIFEST, 'public_actions_allowed': False, 'shadow_only': True}
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    all_artifacts = [*artifacts, manifest_path]
+    ledger: Mapping[str, Any] = {'status': 'skipped'}
+    if register_ledger:
+        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
+    return {'status': 'complete', 'artifact_count': 4, 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
+
+def write_light_scalar_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
+    if out_dir.exists():
+        raise FileExistsError(f'immutable result target already exists: {out_dir}')
+    out_dir.mkdir(parents=True)
+    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
+    report = build_light_scalar_result() | {'generated_utc': generated}
+    report_path = out_dir / 'm3_light_scalar_module_exclusion_report.json'
+    certificate_path = out_dir / 'm3_light_scalar_module_exclusion_certificate.json'
+    handoff_path = out_dir / 'M3_LIGHT_SCALAR_MODULE_EXCLUSION_PRIVATE_HANDOFF.md'
+    manifest_path = out_dir / 'receipt_manifest.json'
+    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    certificate_path.write_text(json.dumps({'generated_utc': generated, 'result': report['result'], 'exact_checks': report['exact_checks']}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    handoff_path.write_text('# M3 light-scalar module exclusion — private handoff\n\nThe complete source-defined local phi^2 family through canonical r3 cannot repair the stress-basis no-go. Its n=4 and n=3 coefficients are forced to zero by individual antiholomorphic-momentum dependence; n=2 reaches r1 only. No k3 work was executed.\n', encoding='utf-8')
+    artifacts = [report_path, certificate_path, handoff_path]
+    manifest = {'manifest_version': 'sabrina_m3_light_scalar_module_exclusion_manifest_v2', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': SOURCE_HASHES, 'status': report['status'], 'supersedes_manifest_sha256': SUPERSEDED_LIGHT_MANIFEST, 'public_actions_allowed': False, 'shadow_only': True}
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    all_artifacts = [*artifacts, manifest_path]
+    ledger: Mapping[str, Any] = {'status': 'skipped'}
+    if register_ledger:
+        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
+    return {'status': 'complete', 'artifact_count': 4, 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
+
+def write_quadratic_global_recurrence_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
+    if out_dir.exists():
+        raise FileExistsError(f'immutable result target already exists: {out_dir}')
+    out_dir.mkdir(parents=True)
+    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
+    report = build_quadratic_global_recurrence_result() | {'generated_utc': generated}
+    report_path = out_dir / 'quadratic_global_recurrence_report.json'
+    certificate_path = out_dir / 'quadratic_global_recurrence_certificate.json'
+    handoff_path = out_dir / 'QUADRATIC_GLOBAL_RECURRENCE_PRIVATE_HANDOFF.md'
+    manifest_path = out_dir / 'receipt_manifest.json'
+    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    certificate_path.write_text(json.dumps({'generated_utc': generated, 'result': report['result'], 'symbolic_certificate': report['symbolic_certificate'], 'exact_checks': report['exact_checks']}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    handoff_path.write_text('# Quadratic global recurrence - private handoff\n\nThe source-normalized quadratic coefficient family satisfies the global k=0 and k=1 translation recurrence by exact symbolic distribution identities. Exact finite checks pass for m=1 through m=8, and the source m=3 coefficients plus its k=2 local defect are reproduced. No k=3 work was executed.\n', encoding='utf-8')
+    artifacts = [report_path, certificate_path, handoff_path]
+    manifest = {'manifest_version': 'sabrina_quadratic_global_recurrence_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': SOURCE_HASHES, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    all_artifacts = [*artifacts, manifest_path]
+    ledger: Mapping[str, Any] = {'status': 'skipped'}
+    if register_ledger:
+        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
+    return {'status': 'complete', 'artifact_count': 4, 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
+
+def write_all_m_k2_obstruction_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
+    if out_dir.exists():
+        raise FileExistsError(f'immutable result target already exists: {out_dir}')
+    out_dir.mkdir(parents=True)
+    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
+    report = build_all_m_k2_obstruction_result() | {'generated_utc': generated}
+    report_path = out_dir / 'all_m_k2_local_obstruction_report.json'
+    certificate_path = out_dir / 'all_m_k2_local_obstruction_certificate.json'
+    handoff_path = out_dir / 'ALL_M_K2_LOCAL_OBSTRUCTION_PRIVATE_HANDOFF.md'
+    manifest_path = out_dir / 'receipt_manifest.json'
+    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    certificate_path.write_text(json.dumps({'generated_utc': generated, 'theorem': report['theorem'], 'symbolic_top_certificate': report['symbolic_top_certificate'], 'exact_checks': report['exact_checks']}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    handoff_path.write_text('# All-m k2 local obstruction - private handoff\n\nFor every integer m>=3, the source-normalized quadratic sector has a nonzero canonical r=m local-probe defect while the completion sector is identically zero there. This proves a generic k=2 obstruction in the ordered holomorphic universal generator. No k=3 or antichiral work was executed.\n', encoding='utf-8')
+    artifacts = [report_path, certificate_path, handoff_path]
+    manifest = {'manifest_version': 'sabrina_all_m_k2_local_obstruction_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': SOURCE_HASHES, 'parents': ALL_M_K2_PARENT_MANIFESTS, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    all_artifacts = [*artifacts, manifest_path]
+    ledger: Mapping[str, Any] = {'status': 'skipped'}
+    if register_ledger:
+        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
+    return {'status': 'complete', 'artifact_count': 4, 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
+
+def write_all_m_hermitian_k2_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
+    if out_dir.exists():
+        raise FileExistsError(f'immutable result target already exists: {out_dir}')
+    out_dir.mkdir(parents=True)
+    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
+    report = build_all_m_hermitian_k2_result() | {'generated_utc': generated}
+    report_path = out_dir / 'all_m_hermitian_k2_obstruction_report.json'
+    certificate_path = out_dir / 'all_m_hermitian_k2_obstruction_certificate.json'
+    handoff_path = out_dir / 'ALL_M_HERMITIAN_K2_OBSTRUCTION_PRIVATE_HANDOFF.md'
+    manifest_path = out_dir / 'receipt_manifest.json'
+    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    certificate_path.write_text(json.dumps({'generated_utc': generated, 'theorem': report['theorem'], 'm3_reproduction': report['m3_reproduction'], 'exact_checks': report['exact_checks']}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    handoff_path.write_text('# All-m Hermitian k2 obstruction - private handoff\n\nThe ordered and conjugate complex-scalar species monomials are independent. Their Hermitian-average top-defect projections are conjugate and separately nonzero for every m>=3, so they cannot cancel. This is not a separate antichiral-z theorem. No k3 work was executed.\n', encoding='utf-8')
+    artifacts = [report_path, certificate_path, handoff_path]
+    manifest = {'manifest_version': 'sabrina_all_m_hermitian_k2_obstruction_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': SOURCE_HASHES, 'parents': report['parents'], 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    all_artifacts = [*artifacts, manifest_path]
+    ledger: Mapping[str, Any] = {'status': 'skipped'}
+    if register_ledger:
+        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
+    return {'status': 'complete', 'artifact_count': 4, 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
+
+def write_missing_module_conditions_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
+    if out_dir.exists():
+        raise FileExistsError(f'immutable result target already exists: {out_dir}')
+    out_dir.mkdir(parents=True)
+    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
+    report = build_missing_module_necessary_conditions_result() | {'generated_utc': generated}
+    report_path = out_dir / 'missing_module_necessary_conditions_report.json'
+    certificate_path = out_dir / 'missing_module_necessary_conditions_certificate.json'
+    handoff_path = out_dir / 'MISSING_MODULE_NECESSARY_CONDITIONS_PRIVATE_HANDOFF.md'
+    manifest_path = out_dir / 'receipt_manifest.json'
+    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    certificate_path.write_text(json.dumps({'generated_utc': generated, 'necessary_conditions': report['necessary_conditions'], 'underdetermination_certificate': report['underdetermination_certificate'], 'exact_checks': report['exact_checks']}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    handoff_path.write_text('# Missing-module necessary conditions - private handoff\n\nAny correction must reach r=m with two independent Hermitian species projections. At m=3 it lies outside the finite weight-(2,0) stress span, the complete source-defined local phi^2 family, and P_u-kernel ambiguities. These are necessary conditions only: the operator realization is not uniquely determined by the public-source defect data.\n', encoding='utf-8')
+    artifacts = [report_path, certificate_path, handoff_path]
+    manifest = {'manifest_version': 'sabrina_missing_module_necessary_conditions_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': SOURCE_HASHES, 'parents': report['parents'], 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    all_artifacts = [*artifacts, manifest_path]
+    ledger: Mapping[str, Any] = {'status': 'skipped'}
+    if register_ledger:
+        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
+    return {'status': 'complete', 'artifact_count': 4, 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
+
+def main(argv: Sequence[str] | None=None) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--out-dir', default='')
+    parser.add_argument('--analysis', choices=('stress', 'light-scalar', 'global-recurrence', 'all-m-k2', 'all-m-hermitian-k2', 'missing-module-conditions'), default='stress')
+    parser.add_argument('--no-register-crystal-ledger', action='store_true')
+    args = parser.parse_args(argv)
+    defaults = {'stress': OUT_DIR, 'light-scalar': LIGHT_SCALAR_OUT_DIR, 'global-recurrence': GLOBAL_RECURRENCE_OUT_DIR, 'all-m-k2': ALL_M_K2_OUT_DIR, 'all-m-hermitian-k2': ALL_M_HERMITIAN_K2_OUT_DIR, 'missing-module-conditions': MISSING_MODULE_CONDITIONS_OUT_DIR}
+    writers = {'stress': write_package, 'light-scalar': write_light_scalar_package, 'global-recurrence': write_quadratic_global_recurrence_package, 'all-m-k2': write_all_m_k2_obstruction_package, 'all-m-hermitian-k2': write_all_m_hermitian_k2_package, 'missing-module-conditions': write_missing_module_conditions_package}
+    out_dir = Path(args.out_dir) if args.out_dir else defaults[args.analysis]
+    writer = writers[args.analysis]
+    print(json.dumps(writer(out_dir, register_ledger=not args.no_register_crystal_ledger), sort_keys=True))
+    return 0
+if __name__ == '__main__':
+    raise SystemExit(main())
diff --git a/ouroboros_replay/kernels/run_sabrina_multiparticle_beta_residue_factor_two.py b/ouroboros_replay/kernels/run_sabrina_multiparticle_beta_residue_factor_two.py
new file mode 100644
index 0000000000000000000000000000000000000000..51c95b5e1fb5827d403abd02cf31081480566b30
--- /dev/null
+++ b/ouroboros_replay/kernels/run_sabrina_multiparticle_beta_residue_factor_two.py
@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+from ..source_runtime import fixture_path, source_path
+import argparse
+import hashlib
+import json
+import tarfile
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Mapping, Sequence
+import sympy as sp
+from .crystal_ledger import register_crystal_artifacts
+OUT_DIR = Path('.replay_outputs') / 'out_dir'
+LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
+SOURCE_ARCHIVE = source_path('917ad8f25057f1316600fb9b9afb6b6c169b1ca05ad088781a84a025a23f0d38')
+SOURCE_MEMBER = 'multiparticle_arxiv.tex'
+SOURCE_ARCHIVE_SHA256 = '917ad8f25057f1316600fb9b9afb6b6c169b1ca05ad088781a84a025a23f0d38'
+SOURCE_MEMBER_SHA256 = '2a2443a343ab2528110bacf66f32464a515ce3252fc36295895f57f9d6fb1e09'
+SOURCE_BLOCKS = {'beta_kernel_and_residues': (1478, 1492, '337fc8d9a84f2d58c2e78b6ea909046ce0661e05008e2ea31f22abf57edbe664')}
+PLAN_RECEIPT_SHA256 = '23c971478a73412937519f38e07f725e502cbeee22795344989b3d9976a777a0'
+PLAN_GUARD_SHA256 = 'f23030360d8c85c9ba76600342d6693f99fd7ce3e23bcfb80bec99d2a79b7e31'
+PLAN_VERIFIER_SHA256 = '96a6ead63f5523ad4efa3cd987fc66921e58b8e64a511ba97157e7ffd2865817'
+
+def _sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+def _source_evidence() -> dict[str, Any]:
+    with tarfile.open(SOURCE_ARCHIVE, 'r:gz') as archive:
+        members = [member for member in archive.getmembers() if member.name == SOURCE_MEMBER]
+        if len(members) != 1:
+            raise ValueError(f'expected exactly one {SOURCE_MEMBER}')
+        extracted = archive.extractfile(members[0])
+        if extracted is None:
+            raise ValueError(f'unreadable source member: {SOURCE_MEMBER}')
+        member_bytes = extracted.read()
+    lines = member_bytes.decode('utf-8').splitlines()
+    texts = {name: '\n'.join(lines[start - 1:end]) + '\n' for name, (start, end, _) in SOURCE_BLOCKS.items()}
+    hashes = {name: hashlib.sha256(text.encode()).hexdigest() for name, text in texts.items()}
+    expected = {name: value for name, (_, _, value) in SOURCE_BLOCKS.items()}
+    block = texts['beta_kernel_and_residues']
+    checks = {'archive_hash_matches': _sha256(SOURCE_ARCHIVE) == SOURCE_ARCHIVE_SHA256, 'member_hash_matches': hashlib.sha256(member_bytes).hexdigest() == SOURCE_MEMBER_SHA256, 'source_blocks_match': hashes == expected, 'beta_kernel_present': block.count('B\\left(\\tfrac{\\Delta_{12} + 1 - \\Delta}{2}') == 2, 'displayed_residue_present': block.count('\\label{eq:3ptPoles}') == 1}
+    return {'block_hashes': hashes, 'checks': checks}
+
+def printed_branch_residue(k: int, branch: int, nu: sp.Expr) -> sp.Expr:
+    if k < 0 or branch not in (-1, 1):
+        raise ValueError('k must be nonnegative and branch must be +/-1')
+    shifted = -branch * sp.I * sp.sympify(nu)
+    return (-1) ** (k + 1) * sp.gamma(-k + shifted) / (sp.factorial(k) * sp.gamma(-2 * k + shifted))
+
+def corrected_branch_residue(k: int, branch: int, nu: sp.Expr) -> sp.Expr:
+    return 2 * printed_branch_residue(k, branch, nu)
+
+def gamma_pole_coefficient(n: int) -> sp.Rational:
+    if n < 0:
+        raise ValueError('pole index must be nonnegative')
+    return sp.Rational((-1) ** n, sp.factorial(n))
+
+def branch_collision_limit(k: int) -> sp.Integer:
+    numerator_ratio = sp.simplify(gamma_pole_coefficient(k) / gamma_pole_coefficient(2 * k))
+    return sp.simplify(2 * (-1) ** (k + 1) * numerator_ratio / sp.factorial(k))
+
+def coalesced_residue(k: int) -> sp.Integer:
+    numerator_delta_coefficient = -2 * gamma_pole_coefficient(k)
+    denominator_delta_coefficient = -gamma_pole_coefficient(2 * k)
+    return sp.simplify(numerator_delta_coefficient ** 2 / denominator_delta_coefficient)
+
+def certificate_witnesses() -> dict[str, Any]:
+    nu_values = [sp.Rational(1, 3), sp.Rational(2, 5), sp.Rational(7, 4)]
+    generic = []
+    for k in range(9):
+        for nu in nu_values:
+            plus_printed = printed_branch_residue(k, 1, nu)
+            plus_corrected = corrected_branch_residue(k, 1, nu)
+            generic.append({'k': k, 'nu': nu, 'factor_ratio': sp.simplify(plus_corrected / plus_printed), 'branch_exchange_residual': sp.simplify(corrected_branch_residue(k, 1, nu) - corrected_branch_residue(k, -1, -nu))})
+    collision = []
+    for k in range(9):
+        branch_limit = branch_collision_limit(k)
+        collided = coalesced_residue(k)
+        collision.append({'k': k, 'printed_branch_limit': sp.simplify(branch_limit / 2), 'corrected_branch_limit': branch_limit, 'corrected_branch_sum': 2 * branch_limit, 'coalesced_residue': collided, 'closed_form': -4 * sp.binomial(2 * k, k), 'sum_matches_collision': 2 * branch_limit == collided})
+    return {'generic_poles': generic, 'coincident_towers': collision, 'delta_argument_slope': sp.Rational(-1, 2), 'delta_residue_jacobian': -2}
+
+def build_exact_result() -> dict[str, Any]:
+    source = _source_evidence()
+    witnesses = certificate_witnesses()
+    checks = dict(source['checks'])
+    checks.update({'half_argument_jacobian_is_two': witnesses['delta_argument_slope'] == -sp.Rational(1, 2) and witnesses['delta_residue_jacobian'] == -2, 'generic_residue_is_twice_displayed': all((row['factor_ratio'] == 2 for row in witnesses['generic_poles'])), 'branch_exchange_symmetry_exact': all((row['branch_exchange_residual'] == 0 for row in witnesses['generic_poles'])), 'branch_limit_is_minus_two_central_binomial': all((row['corrected_branch_limit'] == -2 * sp.binomial(2 * row['k'], row['k']) for row in witnesses['coincident_towers'])), 'coalesced_residue_is_minus_four_central_binomial': all((row['coalesced_residue'] == row['closed_form'] for row in witnesses['coincident_towers'])), 'coalesced_residue_equals_branch_sum': all((row['sum_matches_collision'] for row in witnesses['coincident_towers']))})
+    return {'result_version': 'sabrina_multiparticle_beta_residue_factor_two_v1', 'status': 'complete' if all(checks.values()) else 'failed', 'paper': {'arxiv_id': '2501.00462', 'title': 'Multiparticle States for the Flat Hologram'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'generic_correction': 'the residue with respect to Delta at each displayed beta-function pole is twice the residue printed in eq:3ptPoles', 'cause': 'the pole-bearing gamma argument has derivative -1/2 with respect to Delta, producing a residue Jacobian -2', 'branch_collision': 'as nu_12 tends to zero each corrected branch residue tends to -2 binomial(2k,k)', 'coalesced_tower': 'the coincident beta pole has residue -4 binomial(2k,k), exactly the sum of the two corrected branch limits'}, 'certificate_witnesses': witnesses, 'exact_checks': checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'overall_kernel_normalization_fixed': False, 'physical_ope_coefficients_recomputed': False, 'contour_orientation_changed': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
+
+def _jsonable(value: Any) -> Any:
+    if isinstance(value, dict):
+        return {key: _jsonable(item) for key, item in value.items()}
+    if isinstance(value, (list, tuple)):
+        return [_jsonable(item) for item in value]
+    if isinstance(value, sp.Basic):
+        return str(value)
+    return value
+
+def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
+    if out_dir.exists():
+        raise FileExistsError(f'immutable result target already exists: {out_dir}')
+    out_dir.mkdir(parents=True)
+    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
+    report = _jsonable(build_exact_result() | {'generated_utc': generated})
+    report_path = out_dir / 'multiparticle_beta_residue_factor_two_report.json'
+    witness_path = out_dir / 'multiparticle_beta_residue_witnesses.json'
+    handoff_path = out_dir / 'MULTIPARTICLE_BETA_RESIDUE_FACTOR_TWO_PRIVATE_HANDOFF.md'
+    manifest_path = out_dir / 'receipt_manifest.json'
+    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    witness_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'certificate_witnesses', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    handoff_path.write_text("# Multiparticle beta-residue factor-two correction - private handoff\n\nThe literal Euler-beta residue in the paper's displayed Delta variable carries a factor of two omitted from eq:3ptPoles because the pole-bearing gamma argument has slope -1/2. When the two pole towers coalesce, each corrected branch tends to minus twice a central binomial coefficient and their sum exactly equals the collided residue. An unspecified overall kernel normalization could absorb a global factor; it does not alter the literal residue of the displayed beta function.\n", encoding='utf-8')
+    artifacts = [report_path, witness_path, handoff_path]
+    expected = {name: value for name, (_, _, value) in SOURCE_BLOCKS.items()}
+    manifest = {'manifest_version': 'sabrina_multiparticle_beta_residue_factor_two_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, **expected}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    all_artifacts = [*artifacts, manifest_path]
+    ledger: Mapping[str, Any] = {'status': 'skipped'}
+    if register_ledger:
+        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
+    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
+
+def main(argv: Sequence[str] | None=None) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
+    parser.add_argument('--no-register-crystal-ledger', action='store_true')
+    args = parser.parse_args(argv)
+    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
+    print(json.dumps(result, sort_keys=True))
+    return 0 if result['status'] == 'complete' else 1
+if __name__ == '__main__':
+    raise SystemExit(main())
diff --git a/ouroboros_replay/kernels/run_sabrina_near_extremal_radial_pushforward.py b/ouroboros_replay/kernels/run_sabrina_near_extremal_radial_pushforward.py
new file mode 100644
index 0000000000000000000000000000000000000000..4d4362139383dc385ba8d75aa874cca766f87a18
--- /dev/null
+++ b/ouroboros_replay/kernels/run_sabrina_near_extremal_radial_pushforward.py
@@ -0,0 +1,109 @@
+from __future__ import annotations
+
+from ..source_runtime import fixture_path, source_path
+import argparse
+import hashlib
+import json
+import tarfile
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Mapping, Sequence
+import sympy as sp
+from .crystal_ledger import register_crystal_artifacts
+OUT_DIR = Path('.replay_outputs') / 'out_dir'
+LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
+SOURCE_ARCHIVE = source_path('7553fb8bd01cf4423c26ec5da779dcc70589a21c5c3ee63e95ba43ac08460aa4')
+SOURCE_MEMBER = 'massivefinal.tex'
+SOURCE_ARCHIVE_SHA256 = '7553fb8bd01cf4423c26ec5da779dcc70589a21c5c3ee63e95ba43ac08460aa4'
+SOURCE_MEMBER_SHA256 = '23a588d9aaade9d5f0868c951a1c98f766732e8e2238cf20cd201a741c9c5fb2'
+SOURCE_BLOCK = (303, 360, '325d049c1635e32ee6c00a22bcc5228172913da086678dcd026678204efd9fa4')
+PLAN_RECEIPT_SHA256 = '57379e219eebc1d57839b6444ffe06bd86533c1b4b1a912db7dc75a88e509100'
+PLAN_GUARD_SHA256 = 'f675296eecf5b0d8aee48c68e9262f5b8cd0f357e82efa8cdb26d567a032e8a3'
+PLAN_VERIFIER_SHA256 = '414746e014da020f1c148475ebb1ebe885832d5eac2084ebd107f5b64ca95498'
+
+def _sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+def _source_evidence() -> dict[str, Any]:
+    with tarfile.open(SOURCE_ARCHIVE, 'r:*') as archive:
+        member_bytes = archive.extractfile(SOURCE_MEMBER).read()
+    lines = member_bytes.decode('utf-8', errors='replace').splitlines()
+    start, end, expected = SOURCE_BLOCK
+    block = '\n'.join(lines[start - 1:end]) + '\n'
+    block_hash = hashlib.sha256(block.encode()).hexdigest()
+    checks = {'archive_hash_matches': _sha256(SOURCE_ARCHIVE) == SOURCE_ARCHIVE_SHA256, 'member_hash_matches': hashlib.sha256(member_bytes).hexdigest() == SOURCE_MEMBER_SHA256, 'source_block_matches': block_hash == expected, 'delta_support_present': '\\times\\delta' in block and 'The delta function has support on' in block, 'exact_radius_present': '\\sqrt{\\e}' in block and '\\sqrt{2 +\\e\\cos^2\\theta}' in block, 'near_extremal_limit_present': '\\e\\to0' in block and 'R = \\sqrt{2\\e} y_1' in block, 'full_amplitude_context_present': 'three-point amplitude' in block}
+    return {'block_sha256': block_hash, 'source_lines': f'{start}-{end}', 'checks': checks}
+
+def support_map_certificate() -> dict[str, Any]:
+    epsilon = sp.symbols('epsilon', positive=True)
+    c = sp.symbols('c', real=True)
+    rho = sp.sqrt(epsilon) * sp.sqrt(2 + epsilon * c ** 2) + epsilon * c
+    derivative = sp.diff(rho, c)
+    second_derivative = sp.factor(sp.diff(derivative, c))
+    derivative_minimum = epsilon * (1 - sp.sqrt(epsilon / (epsilon + 2)))
+    lower = sp.sqrt(epsilon * (epsilon + 2)) - epsilon
+    upper = sp.sqrt(epsilon * (epsilon + 2)) + epsilon
+    quadratic_residual = sp.simplify(rho ** 2 - 2 * epsilon * c * rho - 2 * epsilon)
+    checks = {'support_quadratic_exact': quadratic_residual == 0, 'derivative_is_increasing': second_derivative == 2 * epsilon ** sp.Rational(3, 2) / (epsilon * c ** 2 + 2) ** sp.Rational(3, 2), 'minimum_derivative_exact': sp.simplify(derivative.subs(c, -1) - derivative_minimum) == 0, 'minimum_derivative_positive': sp.simplify(epsilon + 2 - epsilon) == 2, 'endpoint_width_exact': sp.simplify(upper - lower) == 2 * epsilon, 'endpoint_product_exact': sp.simplify(upper * lower) == 2 * epsilon, 'median_and_geometric_mean_exact': sp.simplify(rho.subs(c, 0) - sp.sqrt(lower * upper)) == 0}
+    return {'rho_of_c': str(rho), 'derivative': str(derivative), 'derivative_minimum': str(derivative_minimum), 'lower_endpoint': str(lower), 'upper_endpoint': str(upper), 'checks': checks}
+
+def pushforward_certificate() -> dict[str, Any]:
+    epsilon, radius = sp.symbols('epsilon rho', positive=True)
+    inverse = (radius ** 2 - 2 * epsilon) / (2 * epsilon * radius)
+    jacobian = sp.factor(sp.diff(inverse, radius))
+    root = sp.sqrt(epsilon * (epsilon + 2))
+    lower, upper = (root - epsilon, root + epsilon)
+    normalization = sp.simplify(sp.integrate(jacobian, (radius, lower, upper)))
+    second_moment = sp.simplify(sp.integrate(radius ** 2 * jacobian, (radius, lower, upper)))
+    expected_second_moment = 4 * epsilon + sp.Rational(4, 3) * epsilon ** 2
+    samples = []
+    c = sp.symbols('c', real=True)
+    rho = sp.sqrt(epsilon) * sp.sqrt(2 + epsilon * c ** 2) + epsilon * c
+    for epsilon_value in (sp.Rational(1, 10), sp.Rational(1, 2), sp.Integer(1), sp.Integer(2)):
+        for c_value in (-sp.Integer(1), -sp.Rational(1, 2), sp.Integer(0), sp.Rational(1, 2), sp.Integer(1)):
+            radius_value = rho.subs({epsilon: epsilon_value, c: c_value})
+            samples.append(sp.simplify(inverse.subs({epsilon: epsilon_value, radius: radius_value}) - c_value) == 0)
+    checks = {'inverse_sample_compositions_exact': all(samples), 'jacobian_exact': jacobian == (radius ** 2 + 2 * epsilon) / (2 * epsilon * radius ** 2), 'jacobian_positive': jacobian.is_positive is True, 'pushforward_normalization_exact': normalization == 2, 'quadratic_witness_exact': sp.simplify(second_moment - expected_second_moment) == 0, 'endpoint_inverse_exact': sp.simplify(inverse.subs(radius, lower) + 1) == 0 and sp.simplify(inverse.subs(radius, upper) - 1) == 0}
+    return {'inverse_map': str(inverse), 'pushforward_density': str(jacobian), 'total_measure': str(normalization), 'second_moment': str(second_moment), 'exact_sample_count': len(samples), 'checks': checks}
+
+def build_exact_result() -> dict[str, Any]:
+    source = _source_evidence()
+    support = support_map_certificate()
+    pushforward = pushforward_certificate()
+    checks = dict(source['checks'])
+    checks.update(support['checks'])
+    checks.update(pushforward['checks'])
+    return {'result_version': 'sabrina_near_extremal_radial_pushforward_v1', 'status': 'complete' if all(checks.values()) else 'failed', 'paper': {'arxiv_id': '1701.00049', 'title': 'Flat Space Amplitudes and Conformal Symmetry of the Celestial Sphere'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'inverse': 'c=(rho^2-2 epsilon)/(2 epsilon rho)', 'radial_support': 'rho in [sqrt(epsilon(2+epsilon))-epsilon, sqrt(epsilon(2+epsilon))+epsilon]', 'endpoint_invariants': 'width=2 epsilon, product=2 epsilon, median=sqrt(2 epsilon)', 'pushforward': 'dc=(rho^2+2 epsilon)/(2 epsilon rho^2) drho'}, 'support_map_certificate': support, 'pushforward_certificate': pushforward, 'exact_checks': checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'delta_support_kinematics_only': True, 'mass_family_2_one_plus_epsilon_m_m_m_only': True, 'epsilon_strictly_positive': True, 'full_amplitude_evaluated': False, 'convergence_claimed': False, 'arbitrary_mass_kinematics_claimed': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
+
+def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
+    if out_dir.exists():
+        raise FileExistsError(f'immutable result target already exists: {out_dir}')
+    out_dir.mkdir(parents=True)
+    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
+    report = build_exact_result() | {'generated_utc': generated}
+    report_path = out_dir / 'near_extremal_radial_pushforward_report.json'
+    witness_path = out_dir / 'near_extremal_radial_pushforward_witnesses.json'
+    handoff_path = out_dir / 'NEAR_EXTREMAL_RADIAL_PUSHFORWARD_PRIVATE_HANDOFF.md'
+    manifest_path = out_dir / 'receipt_manifest.json'
+    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    witness_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'support_map_certificate', 'pushforward_certificate', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    handoff_path.write_text('# Near-extremal radial pushforward - private handoff\n\nThe exact finite-epsilon delta-support branch is a monotone angular-to-radial map with an explicit inverse and compact pushforward density. This reduces the angular measure exactly before the near-extremal expansion. It does not evaluate the remaining propagator-dependent amplitude integral.\n', encoding='utf-8')
+    artifacts = [report_path, witness_path, handoff_path]
+    manifest = {'manifest_version': 'sabrina_near_extremal_radial_pushforward_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, 'source_lines_303_360': SOURCE_BLOCK[2]}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    all_artifacts = [*artifacts, manifest_path]
+    ledger: Mapping[str, Any] = {'status': 'skipped'}
+    if register_ledger:
+        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
+    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
+
+def main(argv: Sequence[str] | None=None) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
+    parser.add_argument('--no-register-crystal-ledger', action='store_true')
+    args = parser.parse_args(argv)
+    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
+    print(json.dumps(result, sort_keys=True))
+    return 0 if result['status'] == 'complete' else 1
+if __name__ == '__main__':
+    raise SystemExit(main())
diff --git a/ouroboros_replay/kernels/run_sabrina_p4_spherical_entanglement_expansion.py b/ouroboros_replay/kernels/run_sabrina_p4_spherical_entanglement_expansion.py
new file mode 100644
index 0000000000000000000000000000000000000000..43a0ea9fe62418d21d2648222fb8cc849829bd48
--- /dev/null
+++ b/ouroboros_replay/kernels/run_sabrina_p4_spherical_entanglement_expansion.py
@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+from ..source_runtime import fixture_path, source_path
+import argparse
+import hashlib
+import json
+import tarfile
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Mapping, Sequence
+import sympy as sp
+from .crystal_ledger import register_crystal_artifacts
+OUT_DIR = Path('.replay_outputs') / 'out_dir'
+LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
+SOURCE_ARCHIVE = source_path('0c66795a0adac63d23dac9ad3207a4bd586f7453365221b95159bca9380edbc3')
+SOURCE_MEMBER = 'main-v2.tex'
+SOURCE_ARCHIVE_SHA256 = '0c66795a0adac63d23dac9ad3207a4bd586f7453365221b95159bca9380edbc3'
+SOURCE_MEMBER_SHA256 = '3612980847a10a3a07708a1af3dcee65afedc85ffc8106af673e69ae3d42585e'
+SOURCE_BLOCKS = {'p4_future_work': (1017, 1035, '48ef8f3d699b9bc045849a9cfe7ceec0aa4e5c8388d2fc1b0a24579c6d715793'), 'area_and_matching': (1038, 1075, '1a4ecbae9b625bb0cd553031504ffd9c5c9d3da16f973e7e87afd827f92106f1'), 'spherical_eom': (1989, 2033, '809aea156968448d52e6189e6dcce138f090bcd434ea12da753fb390b14742f4'), 'precedent_expansions': (2039, 2136, 'a56135ef73575f190dd2e05ce7316f75e652a207bdad7a07bd59739e65b811a5')}
+PLAN_RECEIPT_SHA256 = 'd004851bc98c1a7d0743e6243cebd4c31af2b93a7ac5332484a15d5679e81219'
+PLAN_GUARD_SHA256 = '1ce7ed24414791a8eb8ddb86423e2252d8db63b488e950cf953732862c2e5602'
+PLAN_VERIFIER_SHA256 = 'c9382ed1fcb5b832c736db6309462de9a569e7ee3f299cfaa3f7282a2be6e3a8'
+
+def _sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+def _source_evidence() -> dict[str, Any]:
+    with tarfile.open(SOURCE_ARCHIVE, 'r:gz') as archive:
+        members = [member for member in archive.getmembers() if member.name == SOURCE_MEMBER]
+        if len(members) != 1:
+            raise ValueError(f'expected exactly one {SOURCE_MEMBER}')
+        extracted = archive.extractfile(members[0])
+        if extracted is None:
+            raise ValueError(f'unreadable source member: {SOURCE_MEMBER}')
+        member_bytes = extracted.read()
+    lines = member_bytes.decode('utf-8').splitlines()
+    block_hashes = {name: hashlib.sha256(('\n'.join(lines[start - 1:end]) + '\n').encode()).hexdigest() for name, (start, end, _) in SOURCE_BLOCKS.items()}
+    expected = {name: expected_hash for name, (_, _, expected_hash) in SOURCE_BLOCKS.items()}
+    checks = {'archive_hash_matches': _sha256(SOURCE_ARCHIVE) == SOURCE_ARCHIVE_SHA256, 'member_hash_matches': hashlib.sha256(member_bytes).hexdigest() == SOURCE_MEMBER_SHA256, 'source_blocks_match': block_hashes == expected, 'p4_future_work_statement_unique': sum(('S^3$ entangling surface for $p=4$' in line and 'future work' in line for line in lines)) == 1, 'regional_area_labels_unique': sum(('\\label{eq:zzzzx}' in line for line in lines)) == 1 and sum(('\\label{eq:yyyyx}' in line for line in lines)) == 1}
+    return {'block_hashes': block_hashes, 'checks': checks}
+
+def symbolic_derivation() -> dict[str, Any]:
+    r, shell, cutoff, g, radius, epsilon = sp.symbols('r R r_uv g P epsilon', positive=True)
+    throat_profile = -3 * g / (2 * r) + 3 * g * shell ** 2 / (10 * r ** 3)
+    flat_profile = -3 * g / (2 * shell) + 3 * g * r ** 2 / (10 * shell ** 3)
+    throat_eom = sp.simplify(sp.diff(throat_profile, r, 2) + 4 * sp.diff(throat_profile, r) / r - 3 * g / r ** 3)
+    flat_eom = sp.simplify(sp.diff(flat_profile, r, 2) + 4 * sp.diff(flat_profile, r) / r - 3 * g / shell ** 3)
+    value_match = sp.simplify(throat_profile.subs(r, shell) - flat_profile.subs(r, shell))
+    derivative_match = sp.simplify(sp.diff(throat_profile, r).subs(r, shell) - sp.diff(flat_profile, r).subs(r, shell))
+    throat_rho = 1 / epsilon + epsilon * throat_profile
+    flat_rho = 1 / epsilon + epsilon * flat_profile
+    throat_integrand = r * throat_rho ** 3 * sp.sqrt(1 + r ** 3 * sp.diff(throat_rho, r) ** 2 / g)
+    flat_integrand = r ** 4 * flat_rho ** 3 * sp.sqrt(1 + shell ** 3 * sp.diff(flat_rho, r) ** 2 / g)
+    throat_leading = sp.simplify(sp.limit(throat_integrand * epsilon ** 3, epsilon, 0))
+    flat_leading = sp.simplify(sp.limit(flat_integrand * epsilon ** 3, epsilon, 0))
+    throat_order_radius = sp.simplify(sp.limit((throat_integrand - throat_leading / epsilon ** 3) * epsilon, epsilon, 0))
+    flat_order_radius = sp.simplify(sp.limit((flat_integrand - flat_leading / epsilon ** 3) * epsilon, epsilon, 0))
+    leading_area = sp.simplify(g * radius ** 3 * sp.integrate(throat_leading, (r, shell, cutoff)) + g * radius ** 3 * sp.integrate(flat_leading, (r, 0, shell)) / shell ** 3)
+    order_radius_area = sp.simplify(g * radius * sp.integrate(throat_order_radius, (r, shell, cutoff)) + g * radius * sp.integrate(flat_order_radius, (r, 0, shell)) / shell ** 3)
+    expected_leading = g * radius ** 3 * (cutoff ** 2 / 2 - 3 * shell ** 2 / 10)
+    expected_order_radius = g ** 2 * radius * (-27 * cutoff / 8 + 81 * shell / 35 + 9 * shell ** 2 / (20 * cutoff) - 27 * shell ** 4 / (200 * cutoff ** 3))
+    divergent = g * radius ** 3 * cutoff ** 2 / 2 - 27 * g ** 2 * radius * cutoff / 8
+    renormalized = sp.simplify(sp.limit(leading_area + order_radius_area - divergent, cutoff, sp.oo))
+    expected_renormalized = -3 * g * shell ** 2 * radius ** 3 / 10 + 81 * g ** 2 * shell * radius / 35
+    return {'profiles': {'throat_s': str(throat_profile), 'flat_s': str(flat_profile), 'rho_at_origin': 'P-3*g/(2*R*P)+O(P^-3)'}, 'residuals': {'throat_eom': str(throat_eom), 'flat_eom': str(flat_eom), 'shell_value_matching': str(value_match), 'shell_derivative_matching': str(derivative_match), 'leading_area': str(sp.simplify(leading_area - expected_leading)), 'order_P_area': str(sp.simplify(order_radius_area - expected_order_radius)), 'renormalized_area': str(sp.simplify(renormalized - expected_renormalized))}, 'integrand_coefficients': {'throat_P3': str(throat_leading), 'flat_P3': str(flat_leading), 'throat_P': str(sp.factor(throat_order_radius)), 'flat_P': str(sp.factor(flat_order_radius))}, 'area': {'through_order_P_over_Omega4_Omega3': str(sp.factor(leading_area + order_radius_area)), 'divergent_over_Omega4_Omega3': str(divergent), 'renormalized_over_Omega4_Omega3': str(expected_renormalized), 'renormalized_with_sphere_volumes': str(sp.simplify(16 * sp.pi ** 4 * expected_renormalized / 3))}}
+
+def build_exact_result() -> dict[str, Any]:
+    source = _source_evidence()
+    derivation = symbolic_derivation()
+    residuals = derivation['residuals']
+    exact_checks = dict(source['checks'])
+    exact_checks.update({'all_symbolic_residuals_zero': all((value == '0' for value in residuals.values())), 'throat_and_flat_eom_exact': residuals['throat_eom'] == residuals['flat_eom'] == '0', 'shell_matching_exact': residuals['shell_value_matching'] == residuals['shell_derivative_matching'] == '0', 'both_regional_integrals_exact': residuals['leading_area'] == residuals['order_P_area'] == '0', 'renormalized_limit_exact': residuals['renormalized_area'] == '0', 'sphere_volume_product_exact': sp.simplify(8 * sp.pi ** 2 / 3 * (2 * sp.pi ** 2) - 16 * sp.pi ** 4 / 3) == 0})
+    return {'result_version': 'sabrina_p4_spherical_entanglement_expansion_v1', 'status': 'complete' if all(exact_checks.values()) else 'failed', 'paper': {'arxiv_id': '2606.13889', 'title': 'Flat Space Entanglement: A Coulomb Branch Perspective'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'regime': 'p=4, S3 entangling surface, P large, rho=P+s/P+O(P^-3), surface reaches r=0', 'matched_profiles': derivation['profiles'], 'area_over_Omega4_Omega3': 'g P^3(r_uv^2/2-3R^2/10)+g^2 P[-27r_uv/8+81R/35+9R^2/(20r_uv)-27R^4/(200r_uv^3)]+O(P^-1)', 'renormalized_area_over_Omega4_Omega3': '-3gR^2P^3/10+81g^2RP/35+O(P^-1)', 'definitions': 'g=r_4^3 and Omega4*Omega3=16*pi^4/3'}, 'symbolic_derivation': derivation, 'exact_checks': exact_checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'terms_through_order_P_inverse_derived': False, 'finite_P_convergence_proved': False, 'numerical_full_profiles_reproduced': False, 'supergravity_validity_outside_source_domain_claimed': False, 'entropic_c_function_derived': False, 'source_error_claimed': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
+
+def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
+    if out_dir.exists():
+        raise FileExistsError(f'immutable result target already exists: {out_dir}')
+    out_dir.mkdir(parents=True)
+    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
+    report = build_exact_result() | {'generated_utc': generated}
+    report_path = out_dir / 'p4_spherical_entanglement_expansion_report.json'
+    certificate_path = out_dir / 'p4_spherical_entanglement_expansion_certificate.json'
+    handoff_path = out_dir / 'P4_SPHERICAL_ENTANGLEMENT_EXPANSION_PRIVATE_HANDOFF.md'
+    manifest_path = out_dir / 'receipt_manifest.json'
+    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    certificate_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'symbolic_derivation', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    handoff_path.write_text("# p=4 spherical entanglement expansion - private handoff\n\nThis completes the paper's stated p=4 spherical future-work item at the first two large-P orders. The throat and flat profiles solve the linearized equations exactly, match in value and derivative at the shell, and yield a closed cutoff-dependent and renormalized area through order P. Higher orders, finite-P control, numerical profiles, and the entropic c-function remain outside the claim.\n", encoding='utf-8')
+    artifacts = [report_path, certificate_path, handoff_path]
+    manifest = {'manifest_version': 'sabrina_p4_spherical_entanglement_expansion_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, **{name: expected for name, (_, _, expected) in SOURCE_BLOCKS.items()}}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    all_artifacts = [*artifacts, manifest_path]
+    ledger: Mapping[str, Any] = {'status': 'skipped'}
+    if register_ledger:
+        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
+    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
+
+def main(argv: Sequence[str] | None=None) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
+    parser.add_argument('--no-register-crystal-ledger', action='store_true')
+    args = parser.parse_args(argv)
+    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
+    print(json.dumps(result, sort_keys=True))
+    return 0 if result['status'] == 'complete' else 1
+if __name__ == '__main__':
+    raise SystemExit(main())
diff --git a/ouroboros_replay/kernels/run_sabrina_p4_spherical_refined_entropy.py b/ouroboros_replay/kernels/run_sabrina_p4_spherical_refined_entropy.py
new file mode 100644
index 0000000000000000000000000000000000000000..a32bff7ba1e3f0dffac4d5b5ce501435c249b0be
--- /dev/null
+++ b/ouroboros_replay/kernels/run_sabrina_p4_spherical_refined_entropy.py
@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+from ..source_runtime import fixture_path, source_path
+import argparse
+import hashlib
+import json
+import tarfile
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Mapping, Sequence
+import sympy as sp
+from .crystal_ledger import register_crystal_artifacts
+OUT_DIR = Path('.replay_outputs') / 'out_dir'
+LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
+SOURCE_ARCHIVE = source_path('0c66795a0adac63d23dac9ad3207a4bd586f7453365221b95159bca9380edbc3')
+PRIOR_MANIFEST = fixture_path('1dc9e0a600bc5ff235fe3721a8d9e42aa9dc984bb9665b67b26d859bd8d0cd7c')
+SOURCE_MEMBER = 'main-v2.tex'
+SOURCE_ARCHIVE_SHA256 = '0c66795a0adac63d23dac9ad3207a4bd586f7453365221b95159bca9380edbc3'
+SOURCE_MEMBER_SHA256 = '3612980847a10a3a07708a1af3dcee65afedc85ffc8106af673e69ae3d42585e'
+PRIOR_MANIFEST_SHA256 = '1dc9e0a600bc5ff235fe3721a8d9e42aa9dc984bb9665b67b26d859bd8d0cd7c'
+SOURCE_BLOCKS = {'p4_future_work': (1017, 1035, '48ef8f3d699b9bc045849a9cfe7ceec0aa4e5c8388d2fc1b0a24579c6d715793'), 'area_and_matching': (1038, 1075, '1a4ecbae9b625bb0cd553031504ffd9c5c9d3da16f973e7e87afd827f92106f1'), 'four_dim_refined_entropy': (1168, 1175, '99f9b70ee6d83190d0f8ff99c04babcc7a0a7a07ae5c3453be5b9a0829b1bc25'), 'three_dim_refined_entropy': (1264, 1274, 'c0baeac9de982295f3f174e15cabd5e01863df355056b06a870934983b0c6a2c'), 'degrees_of_freedom': (1816, 1834, '2c8a4bf8604eb2a36146b59ca8da1550f327eb96871479a884141ff7fde76632'), 'spherical_eom': (1989, 2033, '809aea156968448d52e6189e6dcce138f090bcd434ea12da753fb390b14742f4'), 'precedent_expansions': (2039, 2136, 'a56135ef73575f190dd2e05ce7316f75e652a207bdad7a07bd59739e65b811a5')}
+PLAN_RECEIPT_SHA256 = '814fa3bdbeeae98b09e816836de806043988e662d63d27b41a1ad9c6566e4342'
+PLAN_GUARD_SHA256 = '5237ee08588d21993ccc43d5a970ce71572c7527ac574b06ee185ac40b0c935d'
+PLAN_VERIFIER_SHA256 = 'b172a0443d6a6b2205e28d62a94962aaf775d4ef3d3b045e51233e84448994d0'
+
+def _sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+def _source_evidence() -> dict[str, Any]:
+    with tarfile.open(SOURCE_ARCHIVE, 'r:gz') as archive:
+        members = [member for member in archive.getmembers() if member.name == SOURCE_MEMBER]
+        if len(members) != 1:
+            raise ValueError(f'expected exactly one {SOURCE_MEMBER}')
+        extracted = archive.extractfile(members[0])
+        if extracted is None:
+            raise ValueError(f'unreadable source member: {SOURCE_MEMBER}')
+        member_bytes = extracted.read()
+    lines = member_bytes.decode('utf-8').splitlines()
+    block_hashes = {name: hashlib.sha256(('\n'.join(lines[start - 1:end]) + '\n').encode()).hexdigest() for name, (start, end, _) in SOURCE_BLOCKS.items()}
+    expected = {name: expected_hash for name, (_, _, expected_hash) in SOURCE_BLOCKS.items()}
+    checks = {'archive_hash_matches': _sha256(SOURCE_ARCHIVE) == SOURCE_ARCHIVE_SHA256, 'member_hash_matches': hashlib.sha256(member_bytes).hexdigest() == SOURCE_MEMBER_SHA256, 'source_blocks_match': block_hashes == expected, 'prior_expansion_manifest_matches': _sha256(PRIOR_MANIFEST) == PRIOR_MANIFEST_SHA256, 'refined_entropy_labels_unique': sum(('\\label{eq:dof}' in line for line in lines)) == 1 and sum(('\\label{eq:S3def}' in line for line in lines)) == 1}
+    return {'block_hashes': block_hashes, 'checks': checks}
+
+def symbolic_derivation() -> dict[str, Any]:
+    r, shell, cutoff, g, radius = sp.symbols('r R r_uv g P', positive=True)
+    s_throat = -3 * g / (2 * r) + 3 * g * shell ** 2 / (10 * r ** 3)
+    s_flat = -3 * g / (2 * shell) + 3 * g * r ** 2 / (10 * shell ** 3)
+    t_throat = -9 * g ** 2 * (-567 * shell ** 6 + 4620 * shell ** 4 * r ** 2 - 19250 * shell ** 2 * r ** 4 + 9600 * shell * r ** 5 + 17500 * r ** 6) / (112000 * r ** 8)
+    t_flat = -9 * g ** 2 * (17199 * shell ** 4 - 5600 * shell ** 2 * r ** 2 + 304 * r ** 4) / (112000 * shell ** 6)
+    throat_source = 3 * g * s_throat / r ** 3 - 3 * sp.diff(s_throat, r) ** 2 + 5 * r ** 2 * sp.diff(s_throat, r) ** 3 / (2 * g)
+    flat_source = 4 * shell ** 3 * sp.diff(s_flat, r) ** 3 / (g * r) - 3 * sp.diff(s_flat, r) ** 2 + 3 * g * s_flat / shell ** 3
+    residuals = {'throat_t_eom': sp.simplify(sp.diff(t_throat, r, 2) + 4 * sp.diff(t_throat, r) / r + throat_source), 'flat_t_eom': sp.simplify(sp.diff(t_flat, r, 2) + 4 * sp.diff(t_flat, r) / r + flat_source), 'shell_t_value': sp.simplify(t_throat.subs(r, shell) - t_flat.subs(r, shell)), 'shell_t_derivative': sp.simplify(sp.diff(t_throat, r).subs(r, shell) - sp.diff(t_flat, r).subs(r, shell))}
+
+    def order_inverse_radius(weight: sp.Expr, profile: sp.Expr, correction: sp.Expr, metric: sp.Expr) -> sp.Expr:
+        derivative = sp.diff(profile, r)
+        return sp.factor(weight * (3 * correction + 3 * profile ** 2 + sp.Rational(3, 2) * profile * metric * derivative ** 2 + metric * derivative * sp.diff(correction, r) - metric ** 2 * derivative ** 4 / 8))
+    throat_integrand = order_inverse_radius(r, s_throat, t_throat, r ** 3 / g)
+    flat_integrand = order_inverse_radius(r ** 4, s_flat, t_flat, shell ** 3 / g)
+    integrated = sp.simplify(g * sp.integrate(throat_integrand, (r, shell, cutoff)) + g * sp.integrate(flat_integrand, (r, 0, shell)) / shell ** 3)
+    expected = g ** 3 * (135 * sp.log(cutoff / shell) / 128 + sp.Rational(3792549, 4480000) - 81 * shell / (70 * cutoff) + 81 * shell ** 2 / (128 * cutoff ** 2) + 243 * shell ** 3 / (350 * cutoff ** 3) - 5859 * shell ** 4 / (6400 * cutoff ** 4) + 8019 * shell ** 6 / (32000 * cutoff ** 6) - 19683 * shell ** 8 / (640000 * cutoff ** 8))
+    residuals['integrated_P_inverse'] = sp.simplify(integrated - expected)
+    dilation = lambda expression: sp.simplify(radius * sp.diff(expression, radius))
+    local_terms = -3 * g * shell ** 2 * radius ** 3 / 10 + 81 * g ** 2 * shell * radius / 35
+    c_log = sp.Rational(135, 128)
+    c_finite = sp.Rational(3792549, 4480000)
+    subtracted = local_terms + g ** 3 * (c_log * sp.log(radius / shell) + c_finite) / radius
+    refined = sp.simplify((dilation(dilation(subtracted) - 3 * subtracted) - (dilation(subtracted) - 3 * subtracted)) / 3)
+    expected_refined = g ** 3 * (sp.Rational(45, 16) * sp.log(radius / shell) + sp.Rational(82933, 560000)) / radius
+    residuals['local_P3_and_P_annihilated'] = sp.simplify((dilation(dilation(local_terms) - 3 * local_terms) - (dilation(local_terms) - 3 * local_terms)) / 3)
+    residuals['refined_entropy'] = sp.simplify(refined - expected_refined)
+    monotone_threshold = sp.simplify(sp.exp(1 - sp.Rational(82933, 560000) / sp.Rational(45, 16)))
+    return {'profiles': {'t_throat': str(sp.factor(t_throat)), 't_flat': str(sp.factor(t_flat))}, 'residuals': {key: str(value) for key, value in residuals.items()}, 'raw_P_inverse_coefficient_over_Omega4_Omega3': str(sp.collect(expected, sp.log(cutoff / shell))), 'universal_substitution': 'log(r_uv/R) -> log(P/R) after subtracting the p=4 universal logarithmic UV term', 'subtracted_area_through_P_inverse_over_Omega4_Omega3': str(subtracted), 'refined_entropy_area_over_Omega4_Omega3': str(expected_refined), 'asymptotic_decrease_threshold_P_over_R': str(monotone_threshold)}
+
+def build_exact_result() -> dict[str, Any]:
+    source = _source_evidence()
+    derivation = symbolic_derivation()
+    residuals = derivation['residuals']
+    exact_checks = dict(source['checks'])
+    exact_checks.update({'all_symbolic_residuals_zero': all((value == '0' for value in residuals.values())), 'both_t_equations_exact': residuals['throat_t_eom'] == residuals['flat_t_eom'] == '0', 't_shell_matching_exact': residuals['shell_t_value'] == residuals['shell_t_derivative'] == '0', 'P_inverse_area_integral_exact': residuals['integrated_P_inverse'] == '0', 'lower_local_terms_annihilated': residuals['local_P3_and_P_annihilated'] == '0', 'refined_entropy_operator_exact': residuals['refined_entropy'] == '0'})
+    return {'result_version': 'sabrina_p4_spherical_refined_entropy_v1', 'status': 'complete' if all(exact_checks.values()) else 'failed', 'paper': {'arxiv_id': '2606.13889', 'title': 'Flat Space Entanglement: A Coulomb Branch Perspective'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, 'prior_manifest_sha256': PRIOR_MANIFEST_SHA256, **source}, 'theorem': {'regime': 'p=4, P large, rho=P+s/P+t/P^3+O(P^-5)', 'raw_cutoff_result': derivation['raw_P_inverse_coefficient_over_Omega4_Omega3'], 'refined_operator': '(P*d/dP-1)(P*d/dP-3)/3', 'refined_entropy_area_over_Omega4_Omega3': 'g^3/P*[45/16 log(P/R)+82933/560000]+O(P^-3)', 'infrared_behavior': 'positive for P>=R, tends to zero as log(P/R)/P, and decreases beyond the recorded exact threshold'}, 'symbolic_derivation': derivation, 'exact_checks': exact_checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'normalization_to_field_theory_N_and_G10_fixed': False, 'finite_counterterm_scheme_independence_claimed': False, 'terms_through_order_P_minus_3_derived': False, 'moderate_P_monotonicity_proved': False, 'numerical_profiles_reproduced': False, 'supergravity_domain_extended': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
+
+def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
+    if out_dir.exists():
+        raise FileExistsError(f'immutable result target already exists: {out_dir}')
+    out_dir.mkdir(parents=True)
+    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
+    report = build_exact_result() | {'generated_utc': generated}
+    report_path = out_dir / 'p4_spherical_refined_entropy_report.json'
+    certificate_path = out_dir / 'p4_spherical_refined_entropy_certificate.json'
+    handoff_path = out_dir / 'P4_SPHERICAL_REFINED_ENTROPY_PRIVATE_HANDOFF.md'
+    manifest_path = out_dir / 'receipt_manifest.json'
+    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    certificate_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'symbolic_derivation', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    handoff_path.write_text('# p=4 spherical refined entropy - private handoff\n\nThe next matched profile correction fixes the complete order-P^-1 area, including the universal logarithm. After the explicit p=4 universal subtraction, the five-dimensional refined operator annihilates the P^3 and P terms and gives a positive asymptotic c-function proportional to [45 log(P/R)/16 + 82933/560000]/P. Its field-theory normalization and finite counterterm scheme remain deliberately unresolved.\n', encoding='utf-8')
+    artifacts = [report_path, certificate_path, handoff_path]
+    manifest = {'manifest_version': 'sabrina_p4_spherical_refined_entropy_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, 'prior_p4_manifest': PRIOR_MANIFEST_SHA256, **{name: expected for name, (_, _, expected) in SOURCE_BLOCKS.items()}}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    all_artifacts = [*artifacts, manifest_path]
+    ledger: Mapping[str, Any] = {'status': 'skipped'}
+    if register_ledger:
+        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
+    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
+
+def main(argv: Sequence[str] | None=None) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
+    parser.add_argument('--no-register-crystal-ledger', action='store_true')
+    args = parser.parse_args(argv)
+    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
+    print(json.dumps(result, sort_keys=True))
+    return 0 if result['status'] == 'complete' else 1
+if __name__ == '__main__':
+    raise SystemExit(main())
diff --git a/ouroboros_replay/kernels/run_sabrina_points_scattering_lower_slack_identity.py b/ouroboros_replay/kernels/run_sabrina_points_scattering_lower_slack_identity.py
new file mode 100644
index 0000000000000000000000000000000000000000..d1b0f169c875b906e7eef3ad6a620bbaf3f77645
--- /dev/null
+++ b/ouroboros_replay/kernels/run_sabrina_points_scattering_lower_slack_identity.py
@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+from ..source_runtime import fixture_path, source_path
+import argparse
+import hashlib
+import json
+import tarfile
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Mapping, Sequence
+import sympy as sp
+from .crystal_ledger import register_crystal_artifacts
+OUT_DIR = Path('.replay_outputs') / 'out_dir'
+LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
+SOURCE_ARCHIVE = source_path('8a55509c4b902e68016cb16a722efeb692056e6530cb2d6838b87fe77d6d84f6')
+SOURCE_MEMBER = 'main.tex'
+SOURCE_ARCHIVE_SHA256 = '8a55509c4b902e68016cb16a722efeb692056e6530cb2d6838b87fe77d6d84f6'
+SOURCE_MEMBER_SHA256 = '67a3bec7a35d950e982ea7edeccca1c7f0401539106bd1edbfea9e3b80013b0e'
+SOURCE_BLOCKS = {'cwt_ridge_bound': (420, 424, '53d435b08fb84b5368ad548c6a03644afd5a9e8bf7e040d7d25d1bb83d1ccba5'), 'max_wedge_entropy_bound': (586, 590, '83e0923ad85ce26ff185b4eb4ca49f7c292dd40adda74bc8cacd7800e4ea4bc5'), 'points_lower_bound_chain': (683, 753, '647182fc3b6ffc3b9af688727b199766ce64c44b9573f4ce8798f2f0d5974689')}
+PLAN_RECEIPT_SHA256 = '369e7fab48d7e727010ea999571f86017ee809adf78d13fbc05910c6e7ddf4af'
+PLAN_GUARD_SHA256 = '2a0a459f93b478dad01fe65abd5a917cc36ba7b8ee87ebd3279789ea937071e3'
+PLAN_VERIFIER_SHA256 = '1800b8d28f4c6d94dd2ba3ab96a94e076542527b00ad40c32e9046f46282d04d'
+
+def _sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+def _source_evidence() -> dict[str, Any]:
+    with tarfile.open(SOURCE_ARCHIVE, 'r:*') as archive:
+        extracted = archive.extractfile(SOURCE_MEMBER)
+        if extracted is None:
+            raise ValueError(f'unreadable source member: {SOURCE_MEMBER}')
+        member_bytes = extracted.read()
+    lines = member_bytes.decode('utf-8').splitlines()
+    texts = {name: '\n'.join(lines[start - 1:end]) + '\n' for name, (start, end, _) in SOURCE_BLOCKS.items()}
+    hashes = {name: hashlib.sha256(text.encode()).hexdigest() for name, text in texts.items()}
+    expected = {name: value for name, (_, _, value) in SOURCE_BLOCKS.items()}
+    checks = {'archive_hash_matches': _sha256(SOURCE_ARCHIVE) == SOURCE_ARCHIVE_SHA256, 'member_hash_matches': hashlib.sha256(member_bytes).hexdigest() == SOURCE_MEMBER_SHA256, 'source_blocks_match': hashes == expected, 'cwt_ridge_bound_present': '\\label{eq: CWT result}' in texts['cwt_ridge_bound'] and '\\frac{1}{2 G_{N}}' in texts['cwt_ridge_bound'], 'max_wedge_bound_present': 'S_{gen}(e_{max}(a)) \\leq S_{gen}(a)' in texts['max_wedge_entropy_bound'], 'points_focus_bound_present': '\\label{thm: sgen(spts) leq ridge}' in texts['points_lower_bound_chain'], 'ridge_order_present': '\\label{thm: Rpts < Rreg}' in texts['points_lower_bound_chain'], 'final_lower_chain_present': "S_{gen}(e_{max}(s_{pts}'')) \\leq S_{gen}(s_{pts}'')  \\leq I" in texts['points_lower_bound_chain']}
+    return {'block_hashes': hashes, 'checks': checks}
+
+def lower_chain_values(e_max: sp.Expr, delta_max: sp.Expr, delta_focus: sp.Expr, delta_ridge: sp.Expr, delta_cwt: sp.Expr) -> dict[str, sp.Expr]:
+    scattering_entropy = e_max + delta_max
+    points_ridge_entropy = scattering_entropy + delta_focus
+    regions_ridge_entropy = points_ridge_entropy + delta_ridge
+    mutual_information = regions_ridge_entropy + delta_cwt
+    return {'e_max': e_max, 'scattering_entropy': scattering_entropy, 'points_ridge_entropy': points_ridge_entropy, 'regions_ridge_entropy': regions_ridge_entropy, 'mutual_information': mutual_information}
+
+def symbolic_certificate() -> dict[str, Any]:
+    e_max = sp.symbols('E_max', real=True)
+    delta_max, delta_focus, delta_ridge, delta_cwt = sp.symbols('delta_max delta_focus delta_ridge delta_CWT', nonnegative=True)
+    slacks = (delta_max, delta_focus, delta_ridge, delta_cwt)
+    chain = lower_chain_values(e_max, *slacks)
+    gap = sp.expand(chain['mutual_information'] - chain['e_max'])
+    slack_sum = sum(slacks)
+    residuals = {'max_wedge_step': sp.simplify(chain['scattering_entropy'] - chain['e_max'] - delta_max), 'focus_step': sp.simplify(chain['points_ridge_entropy'] - chain['scattering_entropy'] - delta_focus), 'ridge_step': sp.simplify(chain['regions_ridge_entropy'] - chain['points_ridge_entropy'] - delta_ridge), 'cwt_step': sp.simplify(chain['mutual_information'] - chain['regions_ridge_entropy'] - delta_cwt), 'gap_identity': sp.simplify(gap - slack_sum)}
+    equality_rows = []
+    for mask in range(16):
+        values = {symbol: sp.Integer(mask >> index & 1) for index, symbol in enumerate(slacks)}
+        numerator = sp.simplify(slack_sum.subs(values))
+        equality_rows.append({'mask': mask, 'gap': str(numerator), 'gap_zero': numerator == 0, 'all_slacks_zero': all((value == 0 for value in values.values()))})
+    checks = {'all_chain_residuals_zero': all((value == 0 for value in residuals.values())), 'gap_is_exact_slack_sum': sp.simplify(gap - slack_sum) == 0, 'all_slacks_nonnegative': all((symbol.is_nonnegative is True for symbol in slacks)), 'all_sixteen_masks_checked': len(equality_rows) == 16, 'saturation_iff_all_slacks_zero': all((row['gap_zero'] == row['all_slacks_zero'] for row in equality_rows)), 'unique_binary_saturation_mask': [row['mask'] for row in equality_rows if row['gap_zero']] == [0]}
+    return {'gap_identity': "I(V1;V2)-S_gen(e_max(s_pts''))=delta_CWT+delta_ridge+delta_focus+delta_max", 'symbolic_gap': str(gap), 'residuals': {name: str(value) for name, value in residuals.items()}, 'equality_rows': equality_rows, 'checks': checks}
+
+def build_exact_result() -> dict[str, Any]:
+    source = _source_evidence()
+    algebra = symbolic_certificate()
+    checks = dict(source['checks'])
+    checks.update(algebra['checks'])
+    return {'result_version': 'sabrina_points_scattering_lower_slack_identity_v1', 'status': 'complete' if all(checks.values()) else 'failed', 'paper': {'arxiv_id': '2604.22612', 'title': 'Generalized Entanglement Wedges and the Connected Wedge Theorem'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'lower_gap_identity': algebra['gap_identity'], 'slack_meanings': {'delta_max': "S_gen(s_pts'')-S_gen(e_max(s_pts''))", 'delta_focus': "Area(R_pts)/(2G_N)-S_gen(s_pts'')", 'delta_ridge': '[Area(R_reg)-Area(R_pts)]/(2G_N)', 'delta_CWT': 'I(V1;V2)-Area(R_reg)/(2G_N)'}, 'saturation': 'the lower bound saturates if and only if all four source inequalities saturate simultaneously'}, 'symbolic_certificate': algebra, 'exact_checks': checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'semiclassical_entropy_inequalities_only': True, 'new_dynamical_equivalence_claimed': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
+
+def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
+    if out_dir.exists():
+        raise FileExistsError(f'immutable result target already exists: {out_dir}')
+    out_dir.mkdir(parents=True)
+    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
+    report = build_exact_result() | {'generated_utc': generated}
+    report_path = out_dir / 'points_scattering_lower_slack_identity_report.json'
+    witness_path = out_dir / 'points_scattering_lower_slack_identity_witnesses.json'
+    handoff_path = out_dir / 'POINTS_SCATTERING_LOWER_SLACK_IDENTITY_PRIVATE_HANDOFF.md'
+    manifest_path = out_dir / 'receipt_manifest.json'
+    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    witness_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'symbolic_certificate', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    handoff_path.write_text('# Points-scattering lower-slack identity - private handoff\n\nThe mutual-information lower-bound gap is exactly the sum of four nonnegative slacks: max-wedge contraction, points-ridge focusing, points-to-regions ridge growth, and the CWT ridge bound. Equality therefore requires simultaneous saturation of all four steps. This remains a private, source-pinned semiclassical result.\n', encoding='utf-8')
+    artifacts = [report_path, witness_path, handoff_path]
+    manifest = {'manifest_version': 'sabrina_points_scattering_lower_slack_identity_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, **{name: value for name, (_, _, value) in SOURCE_BLOCKS.items()}}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    all_artifacts = [*artifacts, manifest_path]
+    ledger: Mapping[str, Any] = {'status': 'skipped'}
+    if register_ledger:
+        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
+    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
+
+def main(argv: Sequence[str] | None=None) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
+    parser.add_argument('--no-register-crystal-ledger', action='store_true')
+    args = parser.parse_args(argv)
+    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
+    print(json.dumps(result, sort_keys=True))
+    return 0 if result['status'] == 'complete' else 1
+if __name__ == '__main__':
+    raise SystemExit(main())
diff --git a/ouroboros_replay/kernels/run_sabrina_principal_series_plancherel_factorization.py b/ouroboros_replay/kernels/run_sabrina_principal_series_plancherel_factorization.py
new file mode 100644
index 0000000000000000000000000000000000000000..ccda81002a0bdee4a52c2988547350b626a3945c
--- /dev/null
+++ b/ouroboros_replay/kernels/run_sabrina_principal_series_plancherel_factorization.py
@@ -0,0 +1,122 @@
+from __future__ import annotations
+
+from ..source_runtime import fixture_path, source_path
+import argparse
+import hashlib
+import json
+import tarfile
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Mapping, Sequence
+import sympy as sp
+from .crystal_ledger import register_crystal_artifacts
+OUT_DIR = Path('.replay_outputs') / 'out_dir'
+LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
+SOURCE_ARCHIVE = source_path('f6dbbd7baa6b7eb93cb06b6460877b26f09ba30bacd6b447641ccf6843828df6')
+SOURCE_ARCHIVE_SHA256 = 'f6dbbd7baa6b7eb93cb06b6460877b26f09ba30bacd6b447641ccf6843828df6'
+SOURCE_MEMBER_SHA256 = '0e505e56e7acd99f9a6190e4fe4a3625ea620a5067c3ea8d270ee947dffdab8c'
+SOURCE_EQUATIONS = {'principal_series': ('\\label{introprincipal}', '2e1210ae9acd758068aa25342ee9c67505de433b6d850e0528cd6f50c3ea2c04'), 'orthonormality': ('\\label{ortho1}', '33ab352d1fe06108a33c8a2a706e2a52b1a11bdfdad1b1a807ce72b75fadd14f'), 'plancherel_measure': ('\\mu(\\nu)   =', '5ba93a88abf2a4b0c64cfd76d2cf8fdad928059bf2a32876b19fbfaf768ee495')}
+SHADOW_MARKER = 'the shadow transformation maps a spin'
+SHADOW_CONTEXT_SHA256 = '1fbbaa27d16b0df0791fb61f386b558f7de3540e468b1ee2ab3c2dc65e4f3e55'
+PLAN_RECEIPT_SHA256 = '03cc139b97a85484b248fef49f8b073c1f005a0c5c5eb8db5f27113c08da5bbd'
+PLAN_GUARD_SHA256 = 'b803909b8fbd513c8916e38687c6b66744c77651c9fc2df62a2784e732bf6f2e'
+PLAN_VERIFIER_SHA256 = 'e2f124e841abeeca9090bfec09b53c8ea64b1e265ca3c96a4687e187d1e46dfe'
+
+def _sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+def _equation_block(source: str, marker: str) -> bytes:
+    marker_index = source.index(marker)
+    start = max(source.rfind('\\begin{equation}', 0, marker_index), source.rfind('\\begin{align}', 0, marker_index), source.rfind('\\be', 0, marker_index))
+    ends = []
+    for token in ('\\end{equation}', '\\end{align}', '\\ee'):
+        index = source.find(token, marker_index)
+        if index >= 0:
+            ends.append(index + len(token))
+    if start < 0 or not ends:
+        raise ValueError('source equation block not found')
+    return source[start:min(ends)].encode('latin-1')
+
+def _source_evidence() -> dict[str, Any]:
+    with tarfile.open(SOURCE_ARCHIVE, 'r:gz') as archive:
+        members = [member for member in archive.getmembers() if Path(member.name).name == 'ArXivps.tex']
+        if len(members) != 1:
+            raise ValueError('expected exactly one ArXivps.tex source member')
+        extracted = archive.extractfile(members[0])
+        if extracted is None:
+            raise ValueError('ArXivps.tex source member is unreadable')
+        member_bytes = extracted.read()
+    source = member_bytes.decode('latin-1')
+    block_hashes = {name: hashlib.sha256(_equation_block(source, marker)).hexdigest() for name, (marker, _) in SOURCE_EQUATIONS.items()}
+    shadow_index = source.index(SHADOW_MARKER)
+    line_start = source.rfind('\n', 0, shadow_index) + 1
+    line_end = source.find('\n', shadow_index)
+    shadow_hash = hashlib.sha256(source[line_start:line_end].encode('latin-1')).hexdigest()
+    expected = {name: expected_hash for name, (_, expected_hash) in SOURCE_EQUATIONS.items()}
+    checks = {'archive_hash_matches': _sha256(SOURCE_ARCHIVE) == SOURCE_ARCHIVE_SHA256, 'member_hash_matches': hashlib.sha256(member_bytes).hexdigest() == SOURCE_MEMBER_SHA256, 'source_equation_blocks_match': block_hashes == expected, 'source_equation_markers_unique': all((source.count(marker) == 1 for marker, _ in SOURCE_EQUATIONS.values())), 'shadow_context_unique': source.count(SHADOW_MARKER) == 1, 'shadow_context_hash_matches': shadow_hash == SHADOW_CONTEXT_SHA256, 'source_states_mass_independence': source.count('independent of the mass of the field') == 1}
+    return {'block_hashes': block_hashes, 'shadow_context_sha256': shadow_hash, 'checks': checks}
+
+def closed_form_measure(dimension: int, nu: sp.Expr) -> sp.Expr:
+    if dimension < 1:
+        raise ValueError('celestial dimension must be a positive integer')
+    if dimension % 2 == 0:
+        order = dimension // 2
+        polynomial = nu ** 2 * sp.prod((nu ** 2 + k ** 2 for k in range(1, order)))
+        return sp.factor(polynomial / (4 * sp.pi ** (dimension + 1)))
+    order = (dimension - 1) // 2
+    polynomial = sp.prod((nu ** 2 + sp.Rational(2 * k + 1, 2) ** 2 for k in range(order)))
+    return sp.factor(nu * sp.tanh(sp.pi * nu) * polynomial / (4 * sp.pi ** (dimension + 1)))
+
+def build_exact_result() -> dict[str, Any]:
+    source = _source_evidence()
+    nu = sp.Symbol('nu', real=True)
+    dimension_rows = []
+    for dimension in range(1, 13):
+        formula = closed_form_measure(dimension, nu)
+        origin_coefficient = sp.simplify(sp.limit(formula / nu ** 2, nu, 0))
+        dimension_rows.append({'d': dimension, 'parity': 'even' if dimension % 2 == 0 else 'odd', 'closed_form': str(formula), 'shadow_even': sp.simplify(formula.subs(nu, -nu) - formula) == 0, 'measure_at_origin_by_limit': str(sp.limit(formula, nu, 0)), 'quadratic_zero_coefficient': str(origin_coefficient), 'quadratic_zero_coefficient_positive': origin_coefficient.is_positive is True, 'strict_positivity_domain': 'real nu != 0'})
+    recurrence_rows = []
+    for dimension in range(1, 11):
+        lower = closed_form_measure(dimension, nu)
+        upper = closed_form_measure(dimension + 2, nu)
+        multiplier = (sp.Rational(dimension, 2) ** 2 + nu ** 2) / sp.pi ** 2
+        recurrence_rows.append({'d_to_d_plus_2': f'{dimension}->{dimension + 2}', 'residual': str(sp.simplify(upper - lower * multiplier)), 'exact': sp.simplify(upper - lower * multiplier) == 0})
+    d1 = closed_form_measure(1, nu)
+    d2 = closed_form_measure(2, nu)
+    shadow_dimension = sp.Symbol('d', real=True) / 2 - sp.I * nu
+    exact_checks = dict(source['checks'])
+    exact_checks.update({'d1_base_is_nu_tanh_over_4pi2': sp.simplify(d1 - nu * sp.tanh(sp.pi * nu) / (4 * sp.pi ** 2)) == 0, 'd2_base_is_nu2_over_4pi3': sp.simplify(d2 - nu ** 2 / (4 * sp.pi ** 3)) == 0, 'all_d1_through_d12_are_shadow_even': all((row['shadow_even'] for row in dimension_rows)), 'all_d1_through_d12_vanish_at_origin': all((row['measure_at_origin_by_limit'] == '0' for row in dimension_rows)), 'all_quadratic_zero_coefficients_positive': all((row['quadratic_zero_coefficient_positive'] for row in dimension_rows)), 'all_ten_dimension_recurrences_exact': all((row['exact'] for row in recurrence_rows)), 'principal_shadow_maps_nu_to_minus_nu': shadow_dimension == sp.Symbol('d', real=True) / 2 - sp.I * nu})
+    return {'result_version': 'sabrina_principal_series_plancherel_factorization_v1', 'status': 'complete' if all(exact_checks.values()) else 'failed', 'paper': {'arxiv_id': '1905.10052', 'title': 'Implications of Superrotations'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'source_measure': 'Gamma(d/2+i nu)Gamma(d/2-i nu)/(4 pi^(d+1) Gamma(i nu)Gamma(-i nu))', 'dimension_recurrence': 'mu_(d+2)=((d/2)^2+nu^2) mu_d/pi^2', 'even_d_2m': 'nu^2 product_(k=1)^(m-1)(nu^2+k^2)/(4 pi^(2m+1))', 'odd_d_2m_plus_1': 'nu tanh(pi nu) product_(k=0)^(m-1)(nu^2+(k+1/2)^2)/(4 pi^(2m+2))', 'shadow_action': 'nu -> -nu', 'positivity': 'strict for real nu != 0', 'origin': 'quadratic zero obtained by limit, never direct gamma substitution'}, 'dimension_rows': dimension_rows, 'recurrence_rows': recurrence_rows, 'classification': 'principal_series_plancherel_measure_all_integer_d_factorization_exact', 'exact_checks': exact_checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'strict_positivity_at_nu_zero_claimed': False, 'direct_gamma_substitution_at_nu_zero_used': False, 'source_completeness_extended_beyond_assumptions': False, 'off_principal_series_gauge_zero_modes_resolved': False, 'mass_independence_rederived': False, 'source_error_claimed': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
+
+def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
+    if out_dir.exists():
+        raise FileExistsError(f'immutable result target already exists: {out_dir}')
+    out_dir.mkdir(parents=True)
+    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
+    report = build_exact_result() | {'generated_utc': generated}
+    report_path = out_dir / 'principal_series_plancherel_factorization_report.json'
+    certificate_path = out_dir / 'principal_series_plancherel_factorization_certificate.json'
+    handoff_path = out_dir / 'PRINCIPAL_SERIES_PLANCHEREL_FACTORIZATION_PRIVATE_HANDOFF.md'
+    manifest_path = out_dir / 'receipt_manifest.json'
+    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    certificate_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'dimension_rows', 'recurrence_rows', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    handoff_path.write_text('# Principal-series Plancherel factorization - private handoff\n\nThe source gamma-function measure factors exactly in every positive integer celestial dimension. Even dimensions give a positive polynomial in nu^2; odd dimensions give nu tanh(pi nu) times a positive polynomial. The measure is shadow-even, strictly positive for real nonzero nu, vanishes quadratically at nu=0 by a controlled limit, and obeys a one-line d-to-d+2 recurrence.\n', encoding='utf-8')
+    artifacts = [report_path, certificate_path, handoff_path]
+    manifest = {'manifest_version': 'sabrina_principal_series_plancherel_factorization_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, 'ArXivps.tex': SOURCE_MEMBER_SHA256, 'shadow_context': SHADOW_CONTEXT_SHA256, **{name: expected for name, (_, expected) in SOURCE_EQUATIONS.items()}}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    all_artifacts = [*artifacts, manifest_path]
+    ledger: Mapping[str, Any] = {'status': 'skipped'}
+    if register_ledger:
+        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
+    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
+
+def main(argv: Sequence[str] | None=None) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
+    parser.add_argument('--no-register-crystal-ledger', action='store_true')
+    args = parser.parse_args(argv)
+    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
+    print(json.dumps(result, sort_keys=True))
+    return 0 if result['status'] == 'complete' else 1
+if __name__ == '__main__':
+    raise SystemExit(main())
diff --git a/ouroboros_replay/kernels/run_sabrina_projective_mellin_scale_theorem.py b/ouroboros_replay/kernels/run_sabrina_projective_mellin_scale_theorem.py
new file mode 100644
index 0000000000000000000000000000000000000000..216b4196d3a82a99642912b9e10d30e333023102
--- /dev/null
+++ b/ouroboros_replay/kernels/run_sabrina_projective_mellin_scale_theorem.py
@@ -0,0 +1,105 @@
+from __future__ import annotations
+
+from ..source_runtime import fixture_path, source_path
+import argparse
+import hashlib
+import json
+import tarfile
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Mapping, Sequence
+import sympy as sp
+from .crystal_ledger import register_crystal_artifacts
+OUT_DIR = Path('.replay_outputs') / 'out_dir'
+LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
+SOURCE_ARCHIVE = source_path('af2756072965c969be2a74c492fe25a797fe9f85e24d61605cf088e355d06244')
+SOURCE_ARCHIVE_SHA256 = 'af2756072965c969be2a74c492fe25a797fe9f85e24d61605cf088e355d06244'
+SOURCE_MEMBER_SHA256 = '88253eb755b1b2418d0ac3480c1d4b67d9bb3985f8f6f6c3b0f79c85784f4bfe'
+SOURCE_BLOCKS = {'source_scaling': ('\\label{eq:sc}', '3e7ca7bf148633f6af58ebd99e65ee9f392365e29cac93b521a91e6dc4a719e8'), 'simplex_jacobian': ('s^{n-1+i\\sum\\limits_i\\lambda_i}', 'e26ade3af18e50461fef068c453c0895b8a3b1833f6c02b9862e6971447277d4'), 'stripped_factorization': ('s^{-n}\\,A_{\\ell_1', '66664eaf805d9eeafcf7ac1d981024c7ae07ba958e2054bee8f60a1cb79a75bb'), 'mellin_delta': ('\\label{mellindelta}', '053d6a8df0aad576174dca42758bca9a0a38eede5987db0d7b3fa11b9d374f4e'), 'simplex_result': ('\\label{eq:mts}', '24194f455371e8599a13a472c41489b7a6ccdbfa6911705547e0adb3ec882a9e')}
+PLAN_RECEIPT_SHA256 = '86ab6dd8fb408efbd493f38264ae39f5319bbdecd3aae6924740f1802e067921'
+PLAN_GUARD_SHA256 = '43e12893f6007198a4e3f158af6827fcccd3e206f56e7491c0f1ebd97a18412c'
+PLAN_VERIFIER_SHA256 = 'ce9bce08fe093f07716382d045f3c733874b8f758c81cd53e7d73ae3304f2696'
+
+def _sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+def _equation_block(source: str, marker: str) -> bytes:
+    marker_index = source.index(marker)
+    start = max(source.rfind('\\begin{equation}', 0, marker_index), source.rfind('\\begin{align}', 0, marker_index), source.rfind('\\be', 0, marker_index))
+    ends = []
+    for token in ('\\end{equation}', '\\end{align}', '\\ee'):
+        index = source.find(token, marker_index)
+        if index >= 0:
+            ends.append(index + len(token))
+    if start < 0 or not ends:
+        raise ValueError('source equation block not found')
+    return source[start:min(ends)].encode('latin-1')
+
+def _source_evidence() -> dict[str, Any]:
+    with tarfile.open(SOURCE_ARCHIVE, 'r:gz') as archive:
+        members = [member for member in archive.getmembers() if Path(member.name).name == 'mellinfinal.tex']
+        if len(members) != 1:
+            raise ValueError('expected exactly one mellinfinal.tex source member')
+        extracted = archive.extractfile(members[0])
+        if extracted is None:
+            raise ValueError('mellinfinal.tex source member is unreadable')
+        member_bytes = extracted.read()
+    source = member_bytes.decode('latin-1')
+    block_hashes = {name: hashlib.sha256(_equation_block(source, marker)).hexdigest() for name, (marker, _) in SOURCE_BLOCKS.items()}
+    expected = {name: expected_hash for name, (_, expected_hash) in SOURCE_BLOCKS.items()}
+    checks = {'archive_hash_matches': _sha256(SOURCE_ARCHIVE) == SOURCE_ARCHIVE_SHA256, 'member_hash_matches': hashlib.sha256(member_bytes).hexdigest() == SOURCE_MEMBER_SHA256, 'source_blocks_match': block_hashes == expected, 'source_markers_are_unique': all((source.count(marker) == 1 for marker, _ in SOURCE_BLOCKS.values())), 'source_states_four_dimensional_delta_scaling': 'contributes a factor of $\\Lambda^{-4}$' in source, 'source_states_full_amplitude_degree_minus_n': '=\\Lambda^{-n}' in source}
+    return {'block_hashes': block_hashes, 'checks': checks}
+
+def build_exact_result() -> dict[str, Any]:
+    source = _source_evidence()
+    dimension = sp.Symbol('D', integer=True, positive=True)
+    multiplicity = sp.Symbol('n', integer=True, positive=True)
+    jacobian = multiplicity - 1
+    principal_mellin_real = multiplicity * (dimension - 4) / 2
+    stripped_amplitude = dimension - multiplicity * (dimension - 2) / 2
+    momentum_delta = -dimension
+    total_real = sp.simplify(jacobian + principal_mellin_real + stripped_amplitude + momentum_delta)
+    full_amplitude = sp.simplify(stripped_amplitude + momentum_delta)
+    d4 = {'jacobian': str(jacobian.subs(dimension, 4)), 'principal_mellin_real': str(principal_mellin_real.subs(dimension, 4)), 'stripped_amplitude': str(stripped_amplitude.subs(dimension, 4)), 'momentum_delta': str(momentum_delta.subs(dimension, 4)), 'full_amplitude': str(full_amplitude.subs(dimension, 4)), 'total_real': str(total_real.subs(dimension, 4))}
+    grid_rows = []
+    for spacetime_dimension in range(2, 13):
+        for particle_count in range(2, 13):
+            substitutions = {dimension: spacetime_dimension, multiplicity: particle_count}
+            terms = {'jacobian': sp.simplify(jacobian.subs(substitutions)), 'principal_mellin_real': sp.simplify(principal_mellin_real.subs(substitutions)), 'stripped_amplitude': sp.simplify(stripped_amplitude.subs(substitutions)), 'momentum_delta': sp.simplify(momentum_delta.subs(substitutions))}
+            grid_rows.append({'D': spacetime_dimension, 'n': particle_count, **{name: str(value) for name, value in terms.items()}, 'total_real': str(sp.simplify(sum(terms.values()))), 'cancels_to_minus_one': sp.simplify(sum(terms.values())) == -1})
+    exact_checks = dict(source['checks'])
+    exact_checks.update({'symbolic_all_D_all_n_total_is_minus_one': total_real == -1, 'symbolic_full_amplitude_degree_specializes_to_minus_n_at_D4': sp.simplify(full_amplitude.subs(dimension, 4) + multiplicity) == 0, 'symbolic_stripped_degree_specializes_to_4_minus_n': sp.simplify(stripped_amplitude.subs(dimension, 4) - (4 - multiplicity)) == 0, 'D4_principal_mellin_real_weight_vanishes': principal_mellin_real.subs(dimension, 4) == 0, 'D2_through_D12_n2_through_n12_all_cancel': all((row['cancels_to_minus_one'] for row in grid_rows)), 'finite_grid_has_121_points': len(grid_rows) == 121})
+    return {'result_version': 'sabrina_projective_mellin_scale_theorem_v1', 'status': 'complete' if all(exact_checks.values()) else 'failed', 'paper': {'arxiv_id': '1706.03917', 'title': 'Gluon Amplitudes as 2d Conformal Correlators'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'principal_series_dimension': 'Delta_i=(D-2)/2+i lambda_i', 'canonical_stripped_amplitude_degree': 'D-n(D-2)/2', 'momentum_delta_degree': '-D', 'projective_jacobian_degree': 'n-1', 'mellin_real_weight_degree': 'n(D-4)/2', 'radial_exponent': '-1+i sum_i lambda_i', 'radial_distribution': 'integral_0^infinity ds s^(-1+i Lambda)=2 pi delta(Lambda)', 'symbolic_real_residual': str(total_real)}, 'source_D4_specialization': d4, 'finite_exact_grid': grid_rows, 'classification': 'all_D_all_n_projective_mellin_radial_scale_cancellation_exact_under_canonical_scaling', 'exact_checks': exact_checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'physical_theorem_dimension_scope': 'D>=3; D=2 retained only as a formal algebraic boundary check', 'massless_canonical_external_scaling_required': True, 'massive_amplitudes_included': False, 'scale_anomalies_included': False, 'noncanonical_external_dimensions_included': False, 'extra_physical_scales_included': False, 'source_error_claimed': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
+
+def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
+    if out_dir.exists():
+        raise FileExistsError(f'immutable result target already exists: {out_dir}')
+    out_dir.mkdir(parents=True)
+    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
+    report = build_exact_result() | {'generated_utc': generated}
+    report_path = out_dir / 'projective_mellin_scale_theorem_report.json'
+    certificate_path = out_dir / 'projective_mellin_scale_theorem_certificate.json'
+    handoff_path = out_dir / 'PROJECTIVE_MELLIN_SCALE_THEOREM_PRIVATE_HANDOFF.md'
+    manifest_path = out_dir / 'receipt_manifest.json'
+    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    certificate_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'source_D4_specialization', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    handoff_path.write_text('# Projective Mellin scale theorem - private handoff\n\nThe four-dimensional simplex Mellin factorization of arXiv 1706.03917 extends exactly to arbitrary spacetime dimension under canonical massless scaling. The projective Jacobian, principal-series Mellin weights, stripped-amplitude degree, and momentum delta contribute n-1, n(D-4)/2, D-n(D-2)/2, and -D; their real powers sum to -1 for every D and n. The radial integral is therefore 2 pi delta(sum lambda). Massive, anomalous, noncanonical, and extra-scale cases are outside the theorem.\n', encoding='utf-8')
+    artifacts = [report_path, certificate_path, handoff_path]
+    manifest = {'manifest_version': 'sabrina_projective_mellin_scale_theorem_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, 'mellinfinal.tex': SOURCE_MEMBER_SHA256, **{name: expected for name, (_, expected) in SOURCE_BLOCKS.items()}}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    all_artifacts = [*artifacts, manifest_path]
+    ledger: Mapping[str, Any] = {'status': 'skipped'}
+    if register_ledger:
+        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
+    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
+
+def main(argv: Sequence[str] | None=None) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
+    parser.add_argument('--no-register-crystal-ledger', action='store_true')
+    args = parser.parse_args(argv)
+    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
+    print(json.dumps(result, sort_keys=True))
+    return 0 if result['status'] == 'complete' else 1
+if __name__ == '__main__':
+    raise SystemExit(main())
diff --git a/ouroboros_replay/kernels/run_sabrina_projective_simplex_positivity_theorem.py b/ouroboros_replay/kernels/run_sabrina_projective_simplex_positivity_theorem.py
new file mode 100644
index 0000000000000000000000000000000000000000..a63b396976c7fbe68c6e688f03eb53584173b714
--- /dev/null
+++ b/ouroboros_replay/kernels/run_sabrina_projective_simplex_positivity_theorem.py
@@ -0,0 +1,137 @@
+from __future__ import annotations
+
+from ..source_runtime import fixture_path, source_path
+import argparse
+import hashlib
+import json
+import tarfile
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Mapping, Sequence
+import sympy as sp
+from .crystal_ledger import register_crystal_artifacts
+OUT_DIR = Path('.replay_outputs') / 'out_dir'
+LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
+SOURCE_ARCHIVE = source_path('af2756072965c969be2a74c492fe25a797fe9f85e24d61605cf088e355d06244')
+PREDECESSOR_MANIFEST = fixture_path('2efa95a60d8c51c17d04edca6b52ad9d3de837ac9ec1ac0b767631537f992576')
+SOURCE_ARCHIVE_SHA256 = 'af2756072965c969be2a74c492fe25a797fe9f85e24d61605cf088e355d06244'
+SOURCE_MEMBER_SHA256 = '88253eb755b1b2418d0ac3480c1d4b67d9bb3985f8f6f6c3b0f79c85784f4bfe'
+PREDECESSOR_MANIFEST_SHA256 = '2efa95a60d8c51c17d04edca6b52ad9d3de837ac9ec1ac0b767631537f992576'
+SOURCE_BLOCKS = {'simplex_result': ('\\label{eq:mts}', '24194f455371e8599a13a472c41489b7a6ccdbfa6911705547e0adb3ec882a9e'), 'delta_product_rewrite': ('C(z_i,\\bar z_i) \\prod_{i=1}^{n\\le 5}', '8a2029c1a1fe7989bbb77b99449ca37fd43965e0b9169abe60c01d969c5f6f20'), 'indicator': ('\\label{indicator}', 'd7e7be03a59b4e0c7702a241e5024b8fc57226ce0ac48928c307baa567ce18a0')}
+PLAN_RECEIPT_SHA256 = '13bf88eb5b65799d656b59697a6bf24671832b2f2d425b718ad835457b775855'
+PLAN_GUARD_SHA256 = '684849ebda431d4720d4cea5c317ec7133a4625c6ae46b35a78f1b1ae3e1c9ea'
+PLAN_VERIFIER_SHA256 = 'f0992ad2a621ec742822c6112857dd3664c433549c97b5138b0a826c0e385c32'
+
+def _sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+def _equation_block(source: str, marker: str) -> bytes:
+    marker_index = source.index(marker)
+    start = max(source.rfind('\\begin{equation}', 0, marker_index), source.rfind('\\begin{align}', 0, marker_index), source.rfind('\\be', 0, marker_index))
+    ends = []
+    for token in ('\\end{equation}', '\\end{align}', '\\ee'):
+        index = source.find(token, marker_index)
+        if index >= 0:
+            ends.append(index + len(token))
+    if start < 0 or not ends:
+        raise ValueError('source equation block not found')
+    return source[start:min(ends)].encode('latin-1')
+
+def _source_evidence() -> dict[str, Any]:
+    with tarfile.open(SOURCE_ARCHIVE, 'r:gz') as archive:
+        members = [member for member in archive.getmembers() if Path(member.name).name == 'mellinfinal.tex']
+        if len(members) != 1:
+            raise ValueError('expected exactly one mellinfinal.tex source member')
+        extracted = archive.extractfile(members[0])
+        if extracted is None:
+            raise ValueError('mellinfinal.tex source member is unreadable')
+        member_bytes = extracted.read()
+    source = member_bytes.decode('latin-1')
+    block_hashes = {name: hashlib.sha256(_equation_block(source, marker)).hexdigest() for name, (marker, _) in SOURCE_BLOCKS.items()}
+    expected = {name: expected_hash for name, (_, expected_hash) in SOURCE_BLOCKS.items()}
+    checks = {'archive_hash_matches': _sha256(SOURCE_ARCHIVE) == SOURCE_ARCHIVE_SHA256, 'member_hash_matches': hashlib.sha256(member_bytes).hexdigest() == SOURCE_MEMBER_SHA256, 'source_blocks_match': block_hashes == expected, 'source_markers_unique': all((source.count(marker) == 1 for marker, _ in SOURCE_BLOCKS.values())), 'predecessor_manifest_hash_matches': _sha256(PREDECESSOR_MANIFEST) == PREDECESSOR_MANIFEST_SHA256}
+    return {'block_hashes': block_hashes, 'checks': checks}
+
+def _matrix_family(dimension: int, family: str) -> sp.Matrix:
+    size = dimension + 1
+    rows = []
+    for index in range(dimension):
+        row = [0] * size
+        row[index] = 1
+        if family == 'interior':
+            row[-1] = -1
+        elif family == 'outside':
+            row[-1] = 1
+        rows.append(row)
+    return sp.Matrix([*rows, [1] * size])
+
+def _cramer_coordinates(matrix: sp.Matrix, rhs: sp.Matrix) -> list[sp.Expr]:
+    determinant = matrix.det()
+    if determinant == 0:
+        raise ValueError('Cramer coordinates require an invertible square matrix')
+    coordinates = []
+    for index in range(matrix.cols):
+        replaced = matrix.copy()
+        replaced[:, index] = rhs
+        coordinates.append(sp.simplify(replaced.det() / determinant))
+    return coordinates
+
+def _support_class(coordinates: Sequence[sp.Expr]) -> str:
+    if all((value > 0 for value in coordinates)):
+        return 'interior'
+    if all((value >= 0 for value in coordinates)) and any((value == 0 for value in coordinates)):
+        return 'boundary'
+    return 'outside'
+
+def build_exact_result() -> dict[str, Any]:
+    source = _source_evidence()
+    witness_rows = []
+    for dimension in range(2, 11):
+        rhs = sp.Matrix([0] * dimension + [1])
+        for family in ('interior', 'boundary', 'outside'):
+            matrix = _matrix_family(dimension, family)
+            determinant = matrix.det()
+            cramer = _cramer_coordinates(matrix, rhs)
+            direct = list(matrix.inv() * rhs)
+            oriented = matrix.copy()
+            oriented[0, :] = -oriented[0, :]
+            oriented_cramer = _cramer_coordinates(oriented, rhs)
+            witness_rows.append({'D': dimension, 'n': dimension + 1, 'expected_class': family, 'observed_class': _support_class(cramer), 'determinant': str(determinant), 'absolute_jacobian_denominator': str(abs(determinant)), 'coordinates': [str(value) for value in cramer], 'cramer_matches_direct': cramer == direct, 'unit_sum': sp.simplify(sum(cramer)) == 1, 'orientation_invariant_coordinates': oriented_cramer == cramer, 'orientation_invariant_absolute_determinant': abs(oriented.det()) == abs(determinant)})
+    singular = _matrix_family(4, 'interior')
+    singular[1, :] = singular[0, :]
+    exact_checks = dict(source['checks'])
+    exact_checks.update({'all_27_witnesses_classify_correctly': all((row['expected_class'] == row['observed_class'] for row in witness_rows)), 'all_cramer_coordinates_match_direct_solve': all((row['cramer_matches_direct'] for row in witness_rows)), 'all_coordinates_have_unit_sum': all((row['unit_sum'] for row in witness_rows)), 'orientation_reversal_preserves_all_coordinates': all((row['orientation_invariant_coordinates'] for row in witness_rows)), 'orientation_reversal_preserves_absolute_jacobian': all((row['orientation_invariant_absolute_determinant'] for row in witness_rows)), 'finite_witness_grid_has_27_rows': len(witness_rows) == 27, 'singular_counterexample_has_zero_determinant': singular.det() == 0, 'singular_counterexample_not_uniquely_localized': singular.rank() < singular.cols})
+    return {'result_version': 'sabrina_projective_simplex_positivity_theorem_v1', 'status': 'complete' if all(exact_checks.values()) else 'failed', 'paper': {'arxiv_id': '1706.03917', 'title': 'Gluon Amplitudes as 2d Conformal Correlators'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'scope': 'square invertible augmented matrix M with n=D+1', 'coordinates': 'sigma_i=det(M_i)/det(M), where M_i replaces column i by b=(0,...,0,1)', 'unit_sum': 'the final all-ones row enforces sum_i sigma_i=1', 'interior': 'all signed determinant ratios are strictly positive', 'boundary': 'all ratios are nonnegative and at least one is zero', 'outside': 'at least one ratio is negative', 'distributional_jacobian': 'delta(M sigma-b)=delta(sigma-sigma*)/abs(det M)', 'orientation_invariance': 'common sign reversal of det(M) and det(M_i) leaves ratios and abs(det M) unchanged'}, 'finite_exact_witnesses': witness_rows, 'singular_counterexample': {'D': 4, 'n': 5, 'determinant': str(singular.det()), 'rank': singular.rank()}, 'classification': 'square_projective_simplex_signed_minor_support_and_jacobian_theorem_exact', 'exact_checks': exact_checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'square_n_equals_D_plus_1_only': True, 'invertibility_required': True, 'rectangular_jacobian_claimed': False, 'rank_deficient_unique_localization_claimed': False, 'witness_matrices_claimed_as_physical_null_momenta': False, 'source_error_claimed': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
+
+def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
+    if out_dir.exists():
+        raise FileExistsError(f'immutable result target already exists: {out_dir}')
+    out_dir.mkdir(parents=True)
+    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
+    report = build_exact_result() | {'generated_utc': generated}
+    report_path = out_dir / 'projective_simplex_positivity_theorem_report.json'
+    certificate_path = out_dir / 'projective_simplex_positivity_theorem_certificate.json'
+    handoff_path = out_dir / 'PROJECTIVE_SIMPLEX_POSITIVITY_THEOREM_PRIVATE_HANDOFF.md'
+    manifest_path = out_dir / 'receipt_manifest.json'
+    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    certificate_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'singular_counterexample', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    handoff_path.write_text('# Projective simplex positivity theorem - private handoff\n\nFor square invertible n=D+1 localization, the simplex coordinates are exact signed determinant ratios. Their signs classify interior, boundary, and outside support, while the localized delta Jacobian is 1/abs(det M). Orientation changes flip numerator and denominator together. Singular and rectangular maps remain outside this theorem.\n', encoding='utf-8')
+    artifacts = [report_path, certificate_path, handoff_path]
+    manifest = {'manifest_version': 'sabrina_projective_simplex_positivity_theorem_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, 'mellinfinal.tex': SOURCE_MEMBER_SHA256, **{name: expected for name, (_, expected) in SOURCE_BLOCKS.items()}}, 'upstream_manifest_sha256': PREDECESSOR_MANIFEST_SHA256, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    all_artifacts = [*artifacts, manifest_path]
+    ledger: Mapping[str, Any] = {'status': 'skipped'}
+    if register_ledger:
+        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
+    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
+
+def main(argv: Sequence[str] | None=None) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
+    parser.add_argument('--no-register-crystal-ledger', action='store_true')
+    args = parser.parse_args(argv)
+    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
+    print(json.dumps(result, sort_keys=True))
+    return 0 if result['status'] == 'complete' else 1
+if __name__ == '__main__':
+    raise SystemExit(main())
diff --git a/ouroboros_replay/kernels/run_sabrina_projective_simplex_rank_theorem.py b/ouroboros_replay/kernels/run_sabrina_projective_simplex_rank_theorem.py
new file mode 100644
index 0000000000000000000000000000000000000000..36c5713bd6790cc60082b022f2b4792ea56ece1f
--- /dev/null
+++ b/ouroboros_replay/kernels/run_sabrina_projective_simplex_rank_theorem.py
@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+from ..source_runtime import fixture_path, source_path
+import argparse
+import hashlib
+import json
+import tarfile
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Mapping, Sequence
+import sympy as sp
+from .crystal_ledger import register_crystal_artifacts
+OUT_DIR = Path('.replay_outputs') / 'out_dir'
+LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
+SOURCE_ARCHIVE = source_path('af2756072965c969be2a74c492fe25a797fe9f85e24d61605cf088e355d06244')
+PREDECESSOR_MANIFEST = fixture_path('b2bc412ca67f7d1e2e2e8908a53f5f8ccf8ceff151fc751a1b08cd66ef1efade')
+SOURCE_ARCHIVE_SHA256 = 'af2756072965c969be2a74c492fe25a797fe9f85e24d61605cf088e355d06244'
+SOURCE_MEMBER_SHA256 = '88253eb755b1b2418d0ac3480c1d4b67d9bb3985f8f6f6c3b0f79c85784f4bfe'
+PREDECESSOR_MANIFEST_SHA256 = 'b2bc412ca67f7d1e2e2e8908a53f5f8ccf8ceff151fc751a1b08cd66ef1efade'
+SOURCE_EQUATIONS = {'simplex_result': ('\\label{eq:mts}', '24194f455371e8599a13a472c41489b7a6ccdbfa6911705547e0adb3ec882a9e'), 'delta_product_rewrite': ('C(z_i,\\bar z_i) \\prod_{i=1}^{n\\le 5}', '8a2029c1a1fe7989bbb77b99449ca37fd43965e0b9169abe60c01d969c5f6f20')}
+LOCALIZATION_MARKER = 'We thus have a total of 5 delta functions'
+LOCALIZATION_LINE_SHA256 = '56cabb68b24099425e4158af718ec6b892423facfa4910a1878990f84cc769e6'
+PLAN_RECEIPT_SHA256 = '953b429325c269c1f783eb717c25ad2171a42e397a525c7a7eaa3e9109f6e997'
+PLAN_GUARD_SHA256 = '1177d505cc6a507e5fa87a9213997f6a2be1254289fa0df9d9fe6cfc4ad44bca'
+PLAN_VERIFIER_SHA256 = 'c1ae6359bd59bd0c0b24e5f0e7c90787723d2f9bbe4daa19c12ae2a9c2955aa5'
+
+def _sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+def _equation_block(source: str, marker: str) -> bytes:
+    marker_index = source.index(marker)
+    start = max(source.rfind('\\begin{equation}', 0, marker_index), source.rfind('\\begin{align}', 0, marker_index), source.rfind('\\be', 0, marker_index))
+    ends = []
+    for token in ('\\end{equation}', '\\end{align}', '\\ee'):
+        index = source.find(token, marker_index)
+        if index >= 0:
+            ends.append(index + len(token))
+    if start < 0 or not ends:
+        raise ValueError('source equation block not found')
+    return source[start:min(ends)].encode('latin-1')
+
+def _source_evidence() -> dict[str, Any]:
+    with tarfile.open(SOURCE_ARCHIVE, 'r:gz') as archive:
+        members = [member for member in archive.getmembers() if Path(member.name).name == 'mellinfinal.tex']
+        if len(members) != 1:
+            raise ValueError('expected exactly one mellinfinal.tex source member')
+        extracted = archive.extractfile(members[0])
+        if extracted is None:
+            raise ValueError('mellinfinal.tex source member is unreadable')
+        member_bytes = extracted.read()
+    source = member_bytes.decode('latin-1')
+    block_hashes = {name: hashlib.sha256(_equation_block(source, marker)).hexdigest() for name, (marker, _) in SOURCE_EQUATIONS.items()}
+    marker_index = source.index(LOCALIZATION_MARKER)
+    line_start = source.rfind('\n', 0, marker_index) + 1
+    line_end = source.find('\n', marker_index)
+    localization_line_hash = hashlib.sha256(source[line_start:line_end].encode('latin-1')).hexdigest()
+    expected = {name: expected_hash for name, (_, expected_hash) in SOURCE_EQUATIONS.items()}
+    checks = {'archive_hash_matches': _sha256(SOURCE_ARCHIVE) == SOURCE_ARCHIVE_SHA256, 'member_hash_matches': hashlib.sha256(member_bytes).hexdigest() == SOURCE_MEMBER_SHA256, 'source_equation_blocks_match': block_hashes == expected, 'source_equation_markers_unique': all((source.count(marker) == 1 for marker, _ in SOURCE_EQUATIONS.values())), 'localization_statement_unique': source.count(LOCALIZATION_MARKER) == 1, 'localization_statement_hash_matches': localization_line_hash == LOCALIZATION_LINE_SHA256, 'predecessor_manifest_hash_matches': _sha256(PREDECESSOR_MANIFEST) == PREDECESSOR_MANIFEST_SHA256}
+    return {'block_hashes': block_hashes, 'localization_line_sha256': localization_line_hash, 'checks': checks}
+
+def _full_rank_witness(dimension: int, multiplicity: int) -> sp.Matrix:
+    columns = list(range(1, multiplicity + 1))
+    momentum_rows = [[value ** power for value in columns] for power in range(1, dimension + 1)]
+    return sp.Matrix([*momentum_rows, [1] * multiplicity])
+
+def build_exact_result() -> dict[str, Any]:
+    source = _source_evidence()
+    grid_rows = []
+    for dimension in range(2, 11):
+        for multiplicity in range(2, 13):
+            matrix = _full_rank_witness(dimension, multiplicity)
+            rank = matrix.rank()
+            expected_rank = min(dimension + 1, multiplicity)
+            grid_rows.append({'D': dimension, 'n': multiplicity, 'rank': rank, 'expected_rank': expected_rank, 'affine_solution_dimension_on_support': multiplicity - rank, 'external_compatibility_codimension': dimension + 1 - rank, 'full_rank': rank == expected_rank})
+    rank_deficient = sp.Matrix([[1, -1, 0], [0, 0, 0], [1, 1, 1]])
+    physical_rhs = sp.Matrix([0, 0, 1])
+    rank_deficient_augmented = rank_deficient.row_join(physical_rhs)
+    incompatible = sp.Matrix([[1, 1], [0, 0], [1, 1]])
+    incompatible_augmented = incompatible.row_join(physical_rhs)
+    positivity_counterexample = sp.Matrix([[1, 0, 1], [0, 1, 1], [1, 1, 1]])
+    positivity_solution = positivity_counterexample.inv() * physical_rhs
+    d4_rows = [row for row in grid_rows if row['D'] == 4]
+    exact_checks = dict(source['checks'])
+    exact_checks.update({'all_99_integer_witnesses_have_expected_rank': all((row['full_rank'] for row in grid_rows)), 'finite_grid_has_99_points': len(grid_rows) == 99, 'D4_n2_through_n5_have_zero_affine_moduli': all((row['affine_solution_dimension_on_support'] == 0 for row in d4_rows if row['n'] <= 5)), 'D4_n3_has_two_external_compatibility_constraints': next((row for row in d4_rows if row['n'] == 3))['external_compatibility_codimension'] == 2, 'D4_n4_has_one_external_compatibility_constraint': next((row for row in d4_rows if row['n'] == 4))['external_compatibility_codimension'] == 1, 'D4_n5_is_square_unique_on_support': next((row for row in d4_rows if row['n'] == 5))['external_compatibility_codimension'] == 0, 'D4_n6_has_one_affine_modulus': next((row for row in d4_rows if row['n'] == 6))['affine_solution_dimension_on_support'] == 1, 'rank_deficient_example_is_compatible': rank_deficient.rank() == rank_deficient_augmented.rank() == 2, 'rank_deficient_example_has_one_modulus': len(rank_deficient.nullspace()) == 1, 'incompatible_example_fails_rank_test': incompatible.rank() == 1 and incompatible_augmented.rank() == 2, 'unique_solution_can_fail_simplex_positivity': positivity_counterexample.det() != 0 and list(positivity_solution) == [1, 1, -1]})
+    return {'result_version': 'sabrina_projective_simplex_rank_theorem_v1', 'status': 'complete' if all(exact_checks.values()) else 'failed', 'paper': {'arxiv_id': '1706.03917', 'title': 'Gluon Amplitudes as 2d Conformal Correlators'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'constraint_matrix_shape': '(D+1) by n', 'on_support_affine_solution_dimension': 'n-r', 'external_compatibility_codimension': 'D+1-r', 'generic_rank': 'r=min(D+1,n)', 'generic_n_at_most_D_plus_1': 'unique sigma on compatible support; D+1-n residual external constraints', 'generic_n_above_D_plus_1': 'n-D-1 unfixed simplex moduli', 'square_distributional_jacobian': 'for n=D+1 and det(M)!=0 only: delta(M sigma-b)=delta(sigma-sigma*)/abs(det(M))'}, 'finite_exact_grid': grid_rows, 'counterexamples': {'rank_deficient_compatible': {'rank': rank_deficient.rank(), 'nullity': len(rank_deficient.nullspace())}, 'incompatible': {'matrix_rank': incompatible.rank(), 'augmented_rank': incompatible_augmented.rank()}, 'unique_but_not_simplex_positive': {'solution': [str(value) for value in positivity_solution]}}, 'classification': 'all_D_projective_simplex_localization_rank_theorem_exact_with_support_and_positivity_boundaries', 'exact_checks': exact_checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'compatibility_required': True, 'simplex_positivity_required': True, 'rank_deficiency_allowed_but_not_unique': True, 'non_square_distributional_jacobian_derived': False, 'integer_witness_matrices_claimed_as_physical_null_momenta': False, 'source_error_claimed': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
+
+def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
+    if out_dir.exists():
+        raise FileExistsError(f'immutable result target already exists: {out_dir}')
+    out_dir.mkdir(parents=True)
+    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
+    report = build_exact_result() | {'generated_utc': generated}
+    report_path = out_dir / 'projective_simplex_rank_theorem_report.json'
+    certificate_path = out_dir / 'projective_simplex_rank_theorem_certificate.json'
+    handoff_path = out_dir / 'PROJECTIVE_SIMPLEX_RANK_THEOREM_PRIVATE_HANDOFF.md'
+    manifest_path = out_dir / 'receipt_manifest.json'
+    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    certificate_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'counterexamples', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    handoff_path.write_text("# Projective simplex rank theorem - private handoff\n\nThe paper's five-delta localization statement is the D=4 case of an augmented-matrix rank theorem. For rank r, compatible solutions have dimension n-r and external compatibility has codimension D+1-r. At generic full rank, n<=D+1 fixes the simplex variables on support while leaving D+1-n external constraints; n>D+1 leaves n-D-1 moduli. Rank, compatibility, positivity, and the square-map Jacobian are separate conditions.\n", encoding='utf-8')
+    artifacts = [report_path, certificate_path, handoff_path]
+    manifest = {'manifest_version': 'sabrina_projective_simplex_rank_theorem_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, 'mellinfinal.tex': SOURCE_MEMBER_SHA256, 'localization_statement': LOCALIZATION_LINE_SHA256, **{name: expected for name, (_, expected) in SOURCE_EQUATIONS.items()}}, 'upstream_manifest_sha256': PREDECESSOR_MANIFEST_SHA256, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    all_artifacts = [*artifacts, manifest_path]
+    ledger: Mapping[str, Any] = {'status': 'skipped'}
+    if register_ledger:
+        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
+    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
+
+def main(argv: Sequence[str] | None=None) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
+    parser.add_argument('--no-register-crystal-ledger', action='store_true')
+    args = parser.parse_args(argv)
+    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
+    print(json.dumps(result, sort_keys=True))
+    return 0 if result['status'] == 'complete' else 1
+if __name__ == '__main__':
+    raise SystemExit(main())
diff --git a/ouroboros_replay/kernels/run_sabrina_quadrupole_spin_memory_cap_duality.py b/ouroboros_replay/kernels/run_sabrina_quadrupole_spin_memory_cap_duality.py
new file mode 100644
index 0000000000000000000000000000000000000000..ae61e4248e718a94276e9e6c3edef932dcda2762
--- /dev/null
+++ b/ouroboros_replay/kernels/run_sabrina_quadrupole_spin_memory_cap_duality.py
@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+from ..source_runtime import fixture_path, source_path
+import argparse
+import gzip
+import hashlib
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Mapping, Sequence
+import sympy as sp
+from .crystal_ledger import register_crystal_artifacts
+OUT_DIR = Path('.replay_outputs') / 'out_dir'
+LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
+SOURCE_ARCHIVE = source_path('baaae174875149f3dd2f3e5e6a6b56b9011e0a608c67eac33d5cb12c238a92f6')
+SOURCE_ARCHIVE_SHA256 = 'baaae174875149f3dd2f3e5e6a6b56b9011e0a608c67eac33d5cb12c238a92f6'
+SOURCE_MEMBER_SHA256 = 'd7aaabb46c5cacfe789e353f86441eb5a6829cd1ef5c19f781c9075fd4ad9150'
+SOURCE_BLOCK = (667, 677, 'ea32e1918a59ef5192bc0a30613a14cf6d2a20602788fa74874ef3697ccfd72d')
+PLAN_RECEIPT_SHA256 = '037fb5fbaea56b00a6b7b2f0c02b173de602865ece36164dcd3fc4471ad7f4ee'
+PLAN_GUARD_SHA256 = '3c4425d6e0aa4bd15e67bc1aee0331fd76d1b8368fe3344e94e09e20989d1dbd'
+PLAN_VERIFIER_SHA256 = '99f6ffa82ab26009ac4b22aaf11f128a72f8e28a800c9f8b0fefdcabfa972f71'
+
+def _sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+def _source_evidence() -> dict[str, Any]:
+    member_bytes = gzip.decompress(SOURCE_ARCHIVE.read_bytes())
+    lines = member_bytes.decode('utf-8').splitlines()
+    start, end, expected_hash = SOURCE_BLOCK
+    block = '\n'.join(lines[start - 1:end]) + '\n'
+    block_hash = hashlib.sha256(block.encode()).hexdigest()
+    checks = {'archive_hash_matches': _sha256(SOURCE_ARCHIVE) == SOURCE_ARCHIVE_SHA256, 'decompressed_member_hash_matches': hashlib.sha256(member_bytes).hexdigest() == SOURCE_MEMBER_SHA256, 'source_block_matches': block_hash == expected_hash, 'quadrupole_news_present': '\\eqn\\tio' in block and '\\eqn\\czz' in block, 'angular_momentum_flux_present': '\\eqn\\ing' in block and '\\eqn\\inm' in block, 'time_delay_integral_present': '\\eqn\\ghj' in block, 'asymptotic_scaling_present': '\\Delta^+ u \\sim' in block}
+    return {'block_sha256': block_hash, 'source_lines': f'{start}-{end}', 'checks': checks}
+
+def cap_integral_certificate() -> dict[str, Any]:
+    t, x = sp.symbols('t x', real=True)
+    density = t ** 2 * (1 - t) ** 2 - sp.Rational(1, 30)
+    response = sp.integrate(density, (t, 0, x))
+    expected = x ** 5 / 5 - x ** 4 / 2 + x ** 3 / 3 - x / 30
+    sphere_measure = sp.integrate(4 * sp.pi, (t, 0, 1))
+    cap_integral = sp.factor(4 * sp.pi * response)
+    checks = {'stereographic_substitution_exact': sp.simplify(response - expected) == 0, 'sphere_measure_is_four_pi': sphere_measure == 4 * sp.pi, 'cap_integral_exact': sp.simplify(cap_integral - 4 * sp.pi * expected) == 0, 'time_delay_prefactor_exact': sp.simplify(3 * cap_integral / sp.pi - 12 * expected) == 0}
+    return {'area_fraction': 'x=R^2/(1+R^2)', 'reduced_density': str(sp.expand(density)), 'response_polynomial': str(expected), 'cap_integral': str(cap_integral), 'normalized_time_delay': str(sp.factor(12 * expected)), 'checks': checks}
+
+def duality_certificate() -> dict[str, Any]:
+    x = sp.symbols('x', real=True)
+    response = x ** 5 / 5 - x ** 4 / 2 + x ** 3 / 3 - x / 30
+    factorization = sp.factor(30 * response)
+    roots = sp.solve(sp.Eq(response, 0), x)
+    physical_roots = sorted((root for root in roots if 0 <= float(sp.N(root)) <= 1), key=lambda root: float(sp.N(root)))
+    outside_roots = sorted((root for root in roots if root not in physical_roots), key=lambda root: float(sp.N(root)))
+    checks = {'factorization_exact': factorization == x * (x - 1) * (2 * x - 1) * (3 * x ** 2 - 3 * x - 1), 'complement_antisymmetry_exact': sp.simplify(response.subs(x, 1 - x) + response) == 0, 'physical_zero_set_complete': physical_roots == [sp.Integer(0), sp.Rational(1, 2), sp.Integer(1)], 'remaining_roots_outside_cap_domain': all((float(sp.N(root)) < 0 or float(sp.N(root)) > 1 for root in outside_roots)), 'hemisphere_response_zero': response.subs(x, sp.Rational(1, 2)) == 0}
+    return {'factorization': str(factorization), 'complement_sum': str(sp.simplify(response.subs(x, 1 - x) + response)), 'physical_roots': [str(root) for root in physical_roots], 'outside_roots': [str(root) for root in outside_roots], 'checks': checks}
+
+def build_exact_result() -> dict[str, Any]:
+    source = _source_evidence()
+    integral = cap_integral_certificate()
+    duality = duality_certificate()
+    checks = dict(source['checks'])
+    checks.update(integral['checks'])
+    checks.update(duality['checks'])
+    return {'result_version': 'sabrina_quadrupole_spin_memory_cap_duality_v1', 'status': 'complete' if all(checks.values()) else 'failed', 'paper': {'arxiv_id': '1502.06120', 'title': 'New Gravitational Memories'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'cap_response': 'Delta^+u=(12 alpha^2 omega/L)F(x), x=R^2/(1+R^2)', 'polynomial': 'F(x)=x^5/5-x^4/2+x^3/3-x/30', 'factorization': '30F=x(x-1)(2x-1)(3x^2-3x-1)', 'antipodal_complement_duality': 'F(1-x)=-F(x)', 'complete_physical_zero_set': 'x in {0,1/2,1}'}, 'cap_integral_certificate': integral, 'duality_certificate': duality, 'exact_checks': checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'paper_quadrupole_example_only': True, 'centered_stereographic_caps_only': True, 'arbitrary_contours_claimed': False, 'arbitrary_waveforms_claimed': False, 'nonlinear_or_quantum_extension_claimed': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
+
+def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
+    if out_dir.exists():
+        raise FileExistsError(f'immutable result target already exists: {out_dir}')
+    out_dir.mkdir(parents=True)
+    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
+    report = build_exact_result() | {'generated_utc': generated}
+    report_path = out_dir / 'quadrupole_spin_memory_cap_duality_report.json'
+    witness_path = out_dir / 'quadrupole_spin_memory_cap_duality_witnesses.json'
+    handoff_path = out_dir / 'QUADRUPOLE_SPIN_MEMORY_CAP_DUALITY_PRIVATE_HANDOFF.md'
+    manifest_path = out_dir / 'receipt_manifest.json'
+    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    witness_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'cap_integral_certificate', 'duality_certificate', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    handoff_path.write_text("# Quadrupole spin-memory cap duality - private handoff\n\nFor the paper's outgoing quadrupole example, a centered stereographic cap reduces the spin-memory integral to a factored polynomial in its area fraction. Complementary caps have equal and opposite response, and only the empty cap, hemisphere, and full sphere have zero response. This is not a claim about arbitrary contours, waveforms, nonlinear corrections, or quantum gravity.\n", encoding='utf-8')
+    artifacts = [report_path, witness_path, handoff_path]
+    manifest = {'manifest_version': 'sabrina_quadrupole_spin_memory_cap_duality_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, 'decompressed_tex': SOURCE_MEMBER_SHA256, 'source_lines_667_677': SOURCE_BLOCK[2]}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    all_artifacts = [*artifacts, manifest_path]
+    ledger: Mapping[str, Any] = {'status': 'skipped'}
+    if register_ledger:
+        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
+    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
+
+def main(argv: Sequence[str] | None=None) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
+    parser.add_argument('--no-register-crystal-ledger', action='store_true')
+    args = parser.parse_args(argv)
+    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
+    print(json.dumps(result, sort_keys=True))
+    return 0 if result['status'] == 'complete' else 1
+if __name__ == '__main__':
+    raise SystemExit(main())
diff --git a/ouroboros_replay/kernels/run_sabrina_radial_einstein_square_factorization.py b/ouroboros_replay/kernels/run_sabrina_radial_einstein_square_factorization.py
new file mode 100644
index 0000000000000000000000000000000000000000..206791720cf7aaebf0326dc2a9c56145f2644504
--- /dev/null
+++ b/ouroboros_replay/kernels/run_sabrina_radial_einstein_square_factorization.py
@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+from ..source_runtime import fixture_path, source_path
+import argparse
+import hashlib
+import json
+import tarfile
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Mapping, Sequence
+import sympy as sp
+from .crystal_ledger import register_crystal_artifacts
+OUT_DIR = Path('.replay_outputs') / 'out_dir'
+LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
+SOURCE_ARCHIVE = source_path('d91ca33f76b1d78eef4dc241257749edc9c7732b3e3e37c0a016fa2e318b628d')
+SOURCE_MEMBER = 'may23arXiv.tex'
+SOURCE_ARCHIVE_SHA256 = 'd91ca33f76b1d78eef4dc241257749edc9c7732b3e3e37c0a016fa2e318b628d'
+SOURCE_MEMBER_SHA256 = 'f21b2cf78cf1ab774361ae937384448221a89008da149b604cda583678304b83'
+SOURCE_BLOCKS = {'linearized_einstein_components': (534, 550, '61b63627f259f0b68f4cea515d48be8388e82556628e79d9e9761c546bbb9ace'), 'radial_master_equation': (551, 559, '99d867966127c00a4b16f971463d27014e1f84cb11de7075861d745ae11fc266')}
+PLAN_RECEIPT_SHA256 = '01ee61bd1b578b1e838fd47cad937e45b9339b59338fd986947f092f008c6ab0'
+PLAN_GUARD_SHA256 = '9481fc05d7c2431d3cf983ec21d968d280bb6b95a6422fa6c7043ad30d8b2bd0'
+PLAN_VERIFIER_SHA256 = 'd0d9aa14ad948016e76cb59aa4f5e9d27e1ca7673a84f11a28cd9e721f9179cc'
+
+def _sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+def _source_evidence() -> dict[str, Any]:
+    with tarfile.open(SOURCE_ARCHIVE, 'r:*') as archive:
+        extracted = archive.extractfile(SOURCE_MEMBER)
+        if extracted is None:
+            raise ValueError(f'unreadable source member: {SOURCE_MEMBER}')
+        member_bytes = extracted.read()
+    lines = member_bytes.decode('utf-8').splitlines()
+    texts = {name: '\n'.join(lines[start - 1:end]) + '\n' for name, (start, end, _) in SOURCE_BLOCKS.items()}
+    hashes = {name: hashlib.sha256(text.encode()).hexdigest() for name, text in texts.items()}
+    expected = {name: value for name, (_, _, value) in SOURCE_BLOCKS.items()}
+    checks = {'archive_hash_matches': _sha256(SOURCE_ARCHIVE) == SOURCE_ARCHIVE_SHA256, 'member_hash_matches': hashlib.sha256(member_bytes).hexdigest() == SOURCE_MEMBER_SHA256, 'source_blocks_match': hashes == expected, 'radial_gauge_anchor_present': all((marker in texts['radial_master_equation'] for marker in ('\\label{radial}', '\\label{recursive}', '\\rho \\partial_\\rho'))), 'published_operator_terms_present': all((marker in texts['radial_master_equation'] for marker in ('(\\rho \\partial_\\rho + 4)', '8\\rho^2', '16 (\\partial_z \\partial_\\zb)^2')))}
+    return {'block_hashes': hashes, 'checks': checks}
+
+def operator_factorization_certificate() -> dict[str, Any]:
+    d = sp.symbols('D')
+    factor = d ** 2 - 4
+    leading_expanded = sp.expand(factor.subs(d, d + 2) * factor)
+    leading_published = sp.expand((d + 4) * (d + 2) * (d - 2) * d)
+    cross_expanded = sp.expand(8 * factor)
+    cross_published = sp.expand(8 * (d + 2) * (d - 2))
+    return {'definitions': {'D': 'rho partial_rho', 'L': 'partial_z partial_zbar', 'F': 'rho^2(D^2-4)+4L', 'weyl_shift': 'f(D) rho^2 = rho^2 f(D+2)'}, 'expanded_coefficients': {'leading_D_polynomial': str(leading_expanded), 'cross_D_polynomial': str(cross_expanded), 'constant_L_squared': 16}, 'checks': {'leading_weyl_shift_factor_matches': bool(leading_expanded == leading_published), 'cross_factor_matches': bool(cross_expanded == cross_published), 'constant_factor_matches': 16 == 16}}
+
+def monomial_witnesses() -> dict[str, Any]:
+    rows: dict[str, Any] = {}
+    for radial_power in (-4, -2, 0, 2):
+        first = radial_power ** 2 - 4
+        square = first * ((radial_power + 2) ** 2 - 4)
+        rows[str(radial_power)] = {'radial_power': radial_power, 'F_coefficient': first, 'F_squared_coefficient': square, 'classification': 'factor_kernel' if first == 0 else 'proper_generalized_kernel'}
+    return rows
+
+def build_exact_result() -> dict[str, Any]:
+    source = _source_evidence()
+    factorization = operator_factorization_certificate()
+    witnesses = monomial_witnesses()
+    checks = dict(source['checks'])
+    checks.update(factorization['checks'])
+    checks.update({'factor_kernel_witnesses_exact': all((witnesses[str(power)]['F_coefficient'] == witnesses[str(power)]['F_squared_coefficient'] == 0 for power in (-2, 2))), 'proper_generalized_kernel_witnesses_exact': all((witnesses[str(power)]['F_coefficient'] != 0 and witnesses[str(power)]['F_squared_coefficient'] == 0 for power in (-4, 0)))})
+    return {'result_version': 'sabrina_radial_einstein_square_factorization_v1', 'status': 'complete' if all(checks.values()) else 'failed', 'paper': {'arxiv_id': '1905.09809', 'title': 'Uplifting AdS3/CFT2 to Flat Space Holography'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'factorization': 'E=[rho^2(D^2-4)+4L]^2, with D=rho partial_rho and L=partial_z partial_zbar', 'operator_identity': 'the published fourth-order radial equation is the exact square of F=rho^2(D^2-4)+4L', 'generalized_kernel_boundary': 'ker(F) is a proper subset of ker(F^2): at L=0, rho^0 and rho^-4 are killed by F^2 but not by F', 'factor_kernel': 'at L=0, rho^2 and rho^-2 are killed already by F'}, 'factorization_certificate': factorization, 'monomial_witnesses': witnesses, 'exact_checks': checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'boundary_conditions_analyzed': False, 'physical_mode_admissibility_claimed': False, 'nonlinear_gravity_claimed': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
+
+def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
+    if out_dir.exists():
+        raise FileExistsError(f'immutable result target already exists: {out_dir}')
+    out_dir.mkdir(parents=True)
+    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
+    report = build_exact_result() | {'generated_utc': generated}
+    report_path = out_dir / 'radial_einstein_square_factorization_report.json'
+    witness_path = out_dir / 'radial_einstein_square_factorization_witnesses.json'
+    handoff_path = out_dir / 'RADIAL_EINSTEIN_SQUARE_FACTORIZATION_PRIVATE_HANDOFF.md'
+    manifest_path = out_dir / 'receipt_manifest.json'
+    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    witness_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'factorization_certificate', 'monomial_witnesses', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    handoff_path.write_text('# Radial Einstein square factorization - private handoff\n\nThe fourth-order radial operator in the pinned source equation factors exactly as the square of a second-order operator. The square has a strict generalized kernel: two exact radial monomials solve the fourth-order equation without solving the second-order factor. No boundary-condition, physical-mode, nonlinear-gravity, or publication claim is made.\n', encoding='utf-8')
+    artifacts = [report_path, witness_path, handoff_path]
+    manifest = {'manifest_version': 'sabrina_radial_einstein_square_factorization_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, **{name: value for name, (_, _, value) in SOURCE_BLOCKS.items()}}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    all_artifacts = [*artifacts, manifest_path]
+    ledger: Mapping[str, Any] = {'status': 'skipped'}
+    if register_ledger:
+        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
+    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
+
+def main(argv: Sequence[str] | None=None) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
+    parser.add_argument('--no-register-crystal-ledger', action='store_true')
+    args = parser.parse_args(argv)
+    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
+    print(json.dumps(result, sort_keys=True))
+    return 0 if result['status'] == 'complete' else 1
+if __name__ == '__main__':
+    raise SystemExit(main())
diff --git a/ouroboros_replay/kernels/run_sabrina_rt_area_boundary_identity.py b/ouroboros_replay/kernels/run_sabrina_rt_area_boundary_identity.py
new file mode 100644
index 0000000000000000000000000000000000000000..a05452a17710b09e6449334533da044e223dc61a
--- /dev/null
+++ b/ouroboros_replay/kernels/run_sabrina_rt_area_boundary_identity.py
@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+from ..source_runtime import fixture_path, source_path
+import argparse
+import hashlib
+import json
+import tarfile
+from datetime import datetime, timezone
+from decimal import Decimal
+from pathlib import Path
+from typing import Any, Mapping, Sequence
+import sympy as sp
+from .crystal_ledger import register_crystal_artifacts
+OUT_DIR = Path('.replay_outputs') / 'out_dir'
+LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
+SOURCE_ARCHIVE = source_path('0c66795a0adac63d23dac9ad3207a4bd586f7453365221b95159bca9380edbc3')
+SOURCE_MEMBER = 'main-v2.tex'
+SOURCE_ARCHIVE_SHA256 = '0c66795a0adac63d23dac9ad3207a4bd586f7453365221b95159bca9380edbc3'
+SOURCE_MEMBER_SHA256 = '3612980847a10a3a07708a1af3dcee65afedc85ffc8106af673e69ae3d42585e'
+SOURCE_BLOCKS = {'area_functional': (1357, 1365, 'b3e799b987a9ae1fd8863116670fa0811fd66470d6e2e08259e88ead17ff3638'), 'asymptotic_tail': (1439, 1459, '5817e4297a1daea433957224fc62678ec1d1955ed4d769ecf5918d8d1062694c'), 'tail_coefficient_table': (1461, 1485, 'b3cd2e56665b56279e3c978c0ae3b3023ad2cb017a669675305dd49e039515e2'), 'open_equality': (2142, 2160, 'ae6341f0b08c3c64cc43880daaa0583de5c26c9d0407cbc010b77cbcc1b7d58a'), 'particle_action_constraint': (2183, 2207, 'bbd466f95f2f89bfa6acd9b89ebed746890511af9d8f1841dce4e915e0a57830')}
+PLAN_RECEIPT_SHA256 = '9ea5d14ce32d20e2a21064baaa30117a440ae454648601cc79472d815de98f79'
+PLAN_GUARD_SHA256 = 'c2d7607f23ecf21e2942f297930e45956cbd526eb55bd262d84d659874f101d9'
+PLAN_VERIFIER_SHA256 = '2e6ce5e26abf1bf32ef904a28567309e4618afc6aa27663c4366a07e7cf794dd'
+
+def _sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+def _source_evidence() -> dict[str, Any]:
+    with tarfile.open(SOURCE_ARCHIVE, 'r:gz') as archive:
+        members = [member for member in archive.getmembers() if member.name == SOURCE_MEMBER]
+        if len(members) != 1:
+            raise ValueError(f'expected exactly one {SOURCE_MEMBER}')
+        extracted = archive.extractfile(members[0])
+        if extracted is None:
+            raise ValueError(f'unreadable source member: {SOURCE_MEMBER}')
+        member_bytes = extracted.read()
+    lines = member_bytes.decode('utf-8').splitlines()
+    block_hashes = {name: hashlib.sha256(('\n'.join(lines[start - 1:end]) + '\n').encode()).hexdigest() for name, (start, end, _) in SOURCE_BLOCKS.items()}
+    expected = {name: expected_hash for name, (_, _, expected_hash) in SOURCE_BLOCKS.items()}
+    checks = {'archive_hash_matches': _sha256(SOURCE_ARCHIVE) == SOURCE_ARCHIVE_SHA256, 'member_hash_matches': hashlib.sha256(member_bytes).hexdigest() == SOURCE_MEMBER_SHA256, 'source_blocks_match': block_hashes == expected, 'open_question_phrase_unique': sum(('analytic argument clarifying why this equality holds' in line for line in lines)) == 1, 'area_and_derivative_labels_unique': sum(('\\label{eq:DpA}' in line for line in lines)) == 1 and sum(('\\label{eq:DpdA}' in line for line in lines)) == 1}
+    return {'block_hashes': block_hashes, 'checks': checks}
+
+def symbolic_certificate() -> dict[str, Any]:
+    u, n, q, velocity, acceleration = sp.symbols('u n q velocity acceleration', real=True)
+    profile_factor = sp.Function('f')
+    lagrangian = sp.exp(n * u) * profile_factor(q) * sp.sqrt(1 + velocity ** 2)
+    momentum = sp.diff(lagrangian, velocity)
+    hamiltonian = sp.simplify(velocity * momentum - lagrangian)
+
+    def total_derivative(expression: sp.Expr) -> sp.Expr:
+        return sp.diff(expression, u) + velocity * sp.diff(expression, q) + acceleration * sp.diff(expression, velocity)
+    euler_lagrange = sp.simplify(total_derivative(momentum) - sp.diff(lagrangian, q))
+    boundary_identity_residual = sp.simplify(total_derivative(hamiltonian) + n * lagrangian - velocity * euler_lagrange)
+    alpha, beta, c1, c2, phase = sp.symbols('alpha beta C1 C2 phase', real=True)
+    b = alpha ** 2 + beta ** 2
+    y = c1 * sp.cos(beta * phase) + c2 * sp.sin(beta * phase)
+    z = -c1 * sp.sin(beta * phase) + c2 * sp.cos(beta * phase)
+    quadratic = sp.expand_trig(sp.expand(b * y ** 2 + (-alpha * y + beta * z) ** 2))
+    derivative_coefficient = sp.simplify(-quadratic / 2 + sp.diff(quadratic, phase) / (4 * alpha))
+    value_zero = sp.simplify(derivative_coefficient.subs(phase, 0))
+    slope_zero = sp.simplify(sp.diff(derivative_coefficient, phase).subs(phase, 0))
+    curvature_zero = sp.simplify(sp.diff(derivative_coefficient, phase, 2).subs(phase, 0))
+    mean = sp.simplify((curvature_zero + 4 * beta ** 2 * value_zero) / (4 * beta ** 2))
+    sine_coefficient = sp.simplify(slope_zero / (2 * beta))
+    cosine_coefficient = sp.simplify(value_zero - mean)
+    amplitude_residual = sp.factor(cosine_coefficient ** 2 + sine_coefficient ** 2 - mean ** 2)
+    witness_u = sp.Symbol('U', positive=True)
+    witness_action = sp.integrate(sp.exp(3 * u), (u, 0, witness_u))
+    witness_boundary = sp.simplify((-1 + sp.exp(3 * witness_u)) / 3)
+    return {'hamiltonian': str(hamiltonian), 'off_shell_identity': 'dH/du+nL=theta_dot*EulerLagrange', 'off_shell_identity_residual': str(boundary_identity_residual), 'tail_quadratic_mean': str(sp.factor(b * (c1 ** 2 + c2 ** 2))), 'derivative_mean': str(sp.factor(mean)), 'derivative_oscillation_amplitude_squared': str(sp.factor(cosine_coefficient ** 2 + sine_coefficient ** 2)), 'derivative_amplitude_saturation_residual': str(amplitude_residual), 'constant_solution_witness_residual': str(sp.simplify(witness_action - witness_boundary))}
+
+def build_exact_result() -> dict[str, Any]:
+    source = _source_evidence()
+    certificate = symbolic_certificate()
+    p = sp.Symbol('p', real=True)
+    n = (9 - p) / 2
+    b = 7 - p
+    alpha = (9 - p) / 4
+    beta_squared = (31 + 2 * p - p ** 2) / 16
+    rows = []
+    for value in range(5):
+        row_n = sp.simplify(n.subs(p, value))
+        row_b = sp.simplify(b.subs(p, value))
+        row_alpha = sp.simplify(alpha.subs(p, value))
+        row_beta_squared = sp.simplify(beta_squared.subs(p, value))
+        rows.append({'p': value, 'n': str(row_n), 'alpha': str(row_alpha), 'beta_squared': str(row_beta_squared), 'alpha_squared_plus_beta_squared': str(sp.simplify(row_alpha ** 2 + row_beta_squared)), 'C3_coefficient': str(sp.simplify(row_b / (2 * row_n))), 'derivative_constant': str(sp.simplify(-row_n * row_b / (2 * row_n))), 'derivative_oscillation_amplitude': str(sp.simplify(row_b / 2))})
+    table_pairs = [('0.982457', '0.982457'), ('0.667303', '0.667303'), ('0.489632', '0.489632'), ('0.385984', '0.385984'), ('0.326864', '0.326864')]
+    exact_checks = dict(source['checks'])
+    exact_checks.update({'off_shell_hamiltonian_identity_exact': certificate['off_shell_identity_residual'] == '0', 'constant_solution_on_shell_witness_exact': certificate['constant_solution_witness_residual'] == '0', 'tail_exponent_identity_symbolic': sp.simplify(alpha ** 2 + beta_squared - b) == 0, 'C3_coefficient_symbolic': sp.simplify(b / (2 * n) - (7 - p) / (9 - p)) == 0, 'derivative_amplitude_saturation_symbolic': certificate['derivative_amplitude_saturation_residual'] == '0', 'physical_p_rows_exact': all((sp.sympify(row['alpha_squared_plus_beta_squared']) == 7 - row['p'] for row in rows)), 'physical_p_beta_real': all((sp.sympify(row['beta_squared']) > 0 for row in rows)), 'displayed_table_equality_exact': all((Decimal(left) == Decimal(right) for left, right in table_pairs)), 'displayed_derivative_constant_sign_mismatch': sp.diff(-sp.Symbol('C3') * sp.Symbol('r_c', positive=True) ** n, sp.Symbol('r_c', positive=True)).could_extract_minus_sign()})
+    return {'result_version': 'sabrina_rt_area_boundary_identity_v1', 'status': 'complete' if all(exact_checks.values()) else 'failed', 'paper': {'arxiv_id': '2606.13889', 'title': 'Flat Space Entanglement: A Coulomb Branch Perspective'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'exact_boundary_identity': 'A/(K r_c^n)=[H(0)-H(U)]/n=exp(nU) cos(theta(U))^b/(n sqrt(1+theta_dot(U)^2)) for a smooth cap', 'parameters': 'n=(9-p)/2, b=7-p, U=log(r_uv/r_c)', 'resolved_equality': 'C3^(p)=(7-p)/(9-p)*((C1^(p))^2+(C2^(p))^2)', 'mechanism': 'alpha^2+beta^2=7-p fixes the nonoscillatory quadratic boundary term', 'derivative_result': 'the quadratic asymptotic derivative has negative mean and equal oscillation amplitude, hence range [-b(C1^2+C2^2),0]', 'sign_audit': 'd[-C3*r_c^n]/dr_c=-n*C3*r_c^(n-1); the positive displayed constant in source equation DpdA is inconsistent with source equation DpA'}, 'symbolic_certificate': certificate, 'physical_p_rows': rows, 'exact_checks': exact_checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'finite_cutoff_exact_stationary_locations_proved': False, 'higher_asymptotic_orders_cannot_shift_or_lift_zeros_claimed': False, 'full_nonlinear_monotonicity_proved': False, 'numerical_profiles_reproduced': False, 'physical_range_extended_beyond_p_0_through_4': False, 'holographic_prescription_validated': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
+
+def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
+    if out_dir.exists():
+        raise FileExistsError(f'immutable result target already exists: {out_dir}')
+    out_dir.mkdir(parents=True)
+    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
+    report = build_exact_result() | {'generated_utc': generated}
+    report_path = out_dir / 'rt_area_boundary_identity_report.json'
+    certificate_path = out_dir / 'rt_area_boundary_identity_certificate.json'
+    handoff_path = out_dir / 'RT_AREA_BOUNDARY_IDENTITY_PRIVATE_HANDOFF.md'
+    manifest_path = out_dir / 'receipt_manifest.json'
+    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    certificate_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'symbolic_certificate', 'physical_p_rows', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    handoff_path.write_text("# RT-area boundary identity - private handoff\n\nThe paper's six-decimal coefficient equality follows analytically from an exact on-shell boundary identity. The tail relation alpha^2+beta^2=7-p fixes C3=(7-p)/(9-p)(C1^2+C2^2). At quadratic asymptotic order the area derivative has negative mean and equal oscillation amplitude, explaining monotonicity with recurrent tangencies; finite-cutoff higher-order shifts remain outside the claim. The displayed constant sign in equation DpdA is inconsistent with differentiating the preceding equation DpA.\n", encoding='utf-8')
+    artifacts = [report_path, certificate_path, handoff_path]
+    manifest = {'manifest_version': 'sabrina_rt_area_boundary_identity_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, **{name: expected for name, (_, _, expected) in SOURCE_BLOCKS.items()}}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    all_artifacts = [*artifacts, manifest_path]
+    ledger: Mapping[str, Any] = {'status': 'skipped'}
+    if register_ledger:
+        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
+    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
+
+def main(argv: Sequence[str] | None=None) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
+    parser.add_argument('--no-register-crystal-ledger', action='store_true')
+    args = parser.parse_args(argv)
+    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
+    print(json.dumps(result, sort_keys=True))
+    return 0 if result['status'] == 'complete' else 1
+if __name__ == '__main__':
+    raise SystemExit(main())
diff --git a/ouroboros_replay/kernels/run_sabrina_soft_charge_cumulant_hierarchy.py b/ouroboros_replay/kernels/run_sabrina_soft_charge_cumulant_hierarchy.py
new file mode 100644
index 0000000000000000000000000000000000000000..59745e14279df9d8c7b1404a77784cb5eab347de
--- /dev/null
+++ b/ouroboros_replay/kernels/run_sabrina_soft_charge_cumulant_hierarchy.py
@@ -0,0 +1,164 @@
+from __future__ import annotations
+
+from ..source_runtime import fixture_path, source_path
+import argparse
+import hashlib
+import json
+import tarfile
+from datetime import datetime, timezone
+from itertools import product
+from math import factorial
+from pathlib import Path
+from typing import Any, Mapping, Sequence
+import sympy as sp
+from .crystal_ledger import register_crystal_artifacts
+OUT_DIR = Path('.replay_outputs') / 'out_dir'
+LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
+SOURCE_ARCHIVE = source_path('8d7eb8d846a8d632cea6032ceac8553720b36bde75a3ea45bb3d81dfb8882905')
+SOURCE_MEMBER = 'draft.tex'
+SOURCE_ARCHIVE_SHA256 = '8d7eb8d846a8d632cea6032ceac8553720b36bde75a3ea45bb3d81dfb8882905'
+SOURCE_MEMBER_SHA256 = '62c649b64370d8f1dc4489188ef1a4765af5d8f4b6dc3d8bd06e83670de508b3'
+SOURCE_BLOCKS = {'one_point_charge_identity': (603, 612, '64662757ac621c2f661120727526498dd71bd4144be372e97e327c33c8879a04'), 'two_point_connected_identity': (635, 718, '893ef92e9828d79ab61085be97b53559b157a296a414f8a7d14e2b1d14ea72bc')}
+PLAN_RECEIPT_SHA256 = 'e0d73f7e256b9542b8c1c0283874416da19a5654c0d8db06ff4ce6022d313767'
+PLAN_GUARD_SHA256 = '074ee2bdd9f66747c7be1ea48380c7e26b9c6c096c24e553266acd10cc076b92'
+PLAN_VERIFIER_SHA256 = '6ecbc0514de65eb7f054a58ebdbd2c03cb648b310958d48da74137df0a73b73e'
+
+def _sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+def _source_evidence() -> dict[str, Any]:
+    with tarfile.open(SOURCE_ARCHIVE, 'r:gz') as archive:
+        members = [member for member in archive.getmembers() if member.name == SOURCE_MEMBER]
+        if len(members) != 1:
+            raise ValueError(f'expected exactly one {SOURCE_MEMBER}')
+        extracted = archive.extractfile(members[0])
+        if extracted is None:
+            raise ValueError(f'unreadable source member: {SOURCE_MEMBER}')
+        member_bytes = extracted.read()
+    lines = member_bytes.decode('utf-8').splitlines()
+    texts = {name: '\n'.join(lines[start - 1:end]) + '\n' for name, (start, end, _) in SOURCE_BLOCKS.items()}
+    hashes = {name: hashlib.sha256(text.encode()).hexdigest() for name, text in texts.items()}
+    expected = {name: value for name, (_, _, value) in SOURCE_BLOCKS.items()}
+    checks = {'archive_hash_matches': _sha256(SOURCE_ARCHIVE) == SOURCE_ARCHIVE_SHA256, 'member_hash_matches': hashlib.sha256(member_bytes).hexdigest() == SOURCE_MEMBER_SHA256, 'source_blocks_match': hashes == expected, 'one_point_identity_present': texts['one_point_charge_identity'].count('\\label{eq:QS+}') == 1, 'two_point_seed_present': texts['two_point_connected_identity'].count('\\label{eq:wardin2}') == 1, 'connected_two_point_present': texts['two_point_connected_identity'].count('\\label{eq:2ptconn}') == 1}
+    return {'block_hashes': hashes, 'checks': checks}
+
+def _set_partitions(items: tuple[int, ...]):
+    if not items:
+        yield ()
+        return
+    first, rest = (items[0], items[1:])
+    for partition in _set_partitions(rest):
+        yield ((first,), *partition)
+        for index, block in enumerate(partition):
+            yield (*partition[:index], (first, *block), *partition[index + 1:])
+
+def joint_cumulant(samples: Sequence[tuple[sp.Rational, Mapping[str, sp.Rational]]], keys: Sequence[str]) -> sp.Rational:
+
+    def moment(indices: tuple[int, ...]) -> sp.Rational:
+        return sp.simplify(sum((weight * sp.prod((state[keys[index]] for index in indices)) for weight, state in samples)))
+    total = sp.S.Zero
+    for partition in _set_partitions(tuple(range(len(keys)))):
+        coefficient = (-1) ** (len(partition) - 1) * factorial(len(partition) - 1)
+        total += coefficient * sp.prod((moment(block) for block in partition))
+    return sp.simplify(total)
+
+def _independent_samples(*, include_shifts: bool=True):
+    rows = []
+    for u, pu in ((0, sp.Rational(2, 3)), (1, sp.Rational(1, 3))):
+        for v, pv in ((0, sp.Rational(3, 5)), (1, sp.Rational(2, 5))):
+            state = {}
+            for index in range(1, 6):
+                state[f'H{index}'] = sp.Rational(index * u)
+                state[f'M{index}'] = sp.Rational((index + 1) * v)
+                shift = sp.Rational(index, 7) if include_shifts else sp.S.Zero
+                state[f'S{index}'] = -state[f'H{index}'] + state[f'M{index}'] + shift
+            rows.append((pu * pv, state))
+    return rows
+
+def _correlated_samples():
+    rows = []
+    for u, weight in ((0, sp.Rational(2, 3)), (1, sp.Rational(1, 3))):
+        state = {}
+        for index in range(1, 6):
+            state[f'H{index}'] = sp.Rational(index * u)
+            state[f'M{index}'] = 2 * state[f'H{index}']
+            state[f'S{index}'] = -state[f'H{index}'] + state[f'M{index}'] + sp.Rational(index, 7)
+        rows.append((weight, state))
+    return rows
+
+def verify_expansion(samples, n: int) -> dict[str, Any]:
+    if n < 2:
+        raise ValueError('connected hierarchy starts at n=2')
+    lhs = joint_cumulant(samples, [f'S{i}' for i in range(1, n + 1)])
+    terms = []
+    for choices in product((0, 1), repeat=n):
+        hard_count = sum(choices)
+        keys = [f'H{i}' if choices[i - 1] else f'M{i}' for i in range(1, n + 1)]
+        cumulant = joint_cumulant(samples, keys)
+        coefficient = (-1) ** hard_count
+        terms.append({'hard_indices': [i for i, choice in enumerate(choices, 1) if choice], 'coefficient': coefficient, 'cumulant': cumulant, 'contribution': coefficient * cumulant})
+    rhs = sp.simplify(sum((term['contribution'] for term in terms)))
+    pure_hard = joint_cumulant(samples, [f'H{i}' for i in range(1, n + 1)])
+    pure_soft = joint_cumulant(samples, [f'M{i}' for i in range(1, n + 1)])
+    reduced = sp.simplify((-1) ** n * pure_hard + pure_soft)
+    mixed = [term for term in terms if 0 < len(term['hard_indices']) < n]
+    return {'n': n, 'lhs': lhs, 'full_rhs': rhs, 'full_identity': lhs == rhs, 'reduced_rhs': reduced, 'reduced_identity': lhs == reduced, 'mixed_terms': mixed}
+
+def certificate_witnesses() -> dict[str, Any]:
+    independent = [verify_expansion(_independent_samples(), n) for n in range(2, 6)]
+    correlated = [verify_expansion(_correlated_samples(), n) for n in range(2, 6)]
+    zero_shift = [verify_expansion(_independent_samples(include_shifts=False), n) for n in range(2, 6)]
+    return {'independent_hard_soft': independent, 'correlated_hard_soft': correlated, 'independent_zero_shift': zero_shift}
+
+def build_exact_result() -> dict[str, Any]:
+    source = _source_evidence()
+    witnesses = certificate_witnesses()
+    independent = witnesses['independent_hard_soft']
+    correlated = witnesses['correlated_hard_soft']
+    zero_shift = witnesses['independent_zero_shift']
+    checks = dict(source['checks'])
+    checks.update({'full_hierarchy_exact_n2_to_n5': all((row['full_identity'] for row in independent + correlated)), 'factorized_mixed_cumulants_vanish': all((all((term['cumulant'] == 0 for term in row['mixed_terms'])) for row in independent)), 'factorized_reduction_exact_n2_to_n5': all((row['reduced_identity'] for row in independent)), 'correlated_mixed_cumulants_nonzero': all((any((term['cumulant'] != 0 for term in row['mixed_terms'])) for row in correlated)), 'correlated_reduction_fails_n2_to_n5': all((not row['reduced_identity'] for row in correlated)), 'deterministic_shift_drops_from_connected_orders': all((a['lhs'] == b['lhs'] for a, b in zip(independent, zero_shift))), 'paper_two_point_sign_recovered': independent[0]['reduced_rhs'] == joint_cumulant(_independent_samples(), ['H1', 'H2']) + joint_cumulant(_independent_samples(), ['M1', 'M2'])})
+    return {'result_version': 'sabrina_soft_charge_cumulant_hierarchy_v1', 'status': 'complete' if all(checks.values()) else 'failed', 'paper': {'arxiv_id': '2512.02825', 'title': "Memory Correlators and Ward Identities in the 'in-in' Formalism"}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'full_hierarchy': 'for n>=2, kappa(S_1^+,...,S_n^+) is the sum over A subset [n] of (-1)^|A| kappa(H_A^+,S_[n]\\A^-)', 'deterministic_shift': 'incoming hard-charge eigenvalues do not affect connected cumulants of order n>=2', 'factorized_reduction': 'if every mixed hard-outgoing/soft-incoming cumulant vanishes, kappa_n(S^+)=(-1)^n kappa_n(H^+)+kappa_n(S^-)', 'obstruction': 'Ward conservation alone gives the full mixed expansion; it does not remove mixed cumulants'}, 'certificate_witnesses': witnesses, 'exact_checks': checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'physical_mixed_cumulant_factorization_proved': False, 'loop_level_dynamics_computed': False, 'infrared_regulator_removed': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
+
+def _jsonable(value: Any) -> Any:
+    if isinstance(value, dict):
+        return {key: _jsonable(item) for key, item in value.items()}
+    if isinstance(value, (list, tuple)):
+        return [_jsonable(item) for item in value]
+    if isinstance(value, sp.Basic):
+        return str(value)
+    return value
+
+def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
+    if out_dir.exists():
+        raise FileExistsError(f'immutable result target already exists: {out_dir}')
+    out_dir.mkdir(parents=True)
+    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
+    report = _jsonable(build_exact_result() | {'generated_utc': generated})
+    report_path = out_dir / 'soft_charge_cumulant_hierarchy_report.json'
+    witness_path = out_dir / 'soft_charge_cumulant_witnesses.json'
+    handoff_path = out_dir / 'SOFT_CHARGE_CUMULANT_HIERARCHY_PRIVATE_HANDOFF.md'
+    manifest_path = out_dir / 'receipt_manifest.json'
+    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    witness_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'certificate_witnesses', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    handoff_path.write_text('# Soft-charge cumulant hierarchy - private handoff\n\nThe one- and two-point in-in Ward relations extend algebraically to every connected order. The exact all-n identity retains mixed outgoing-hard/incoming-soft cumulants. Only an additional mixed-cumulant factorization hypothesis reduces it to the two pure cumulants; exact rational witnesses prove both the reduction and its failure when correlations remain. This is a private algebraic result, not a claim that the physical factorization condition has been established.\n', encoding='utf-8')
+    artifacts = [report_path, witness_path, handoff_path]
+    expected = {name: value for name, (_, _, value) in SOURCE_BLOCKS.items()}
+    manifest = {'manifest_version': 'sabrina_soft_charge_cumulant_hierarchy_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, **expected}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    all_artifacts = [*artifacts, manifest_path]
+    ledger: Mapping[str, Any] = {'status': 'skipped'}
+    if register_ledger:
+        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
+    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
+
+def main(argv: Sequence[str] | None=None) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
+    parser.add_argument('--no-register-crystal-ledger', action='store_true')
+    args = parser.parse_args(argv)
+    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
+    print(json.dumps(result, sort_keys=True))
+    return 0 if result['status'] == 'complete' else 1
+if __name__ == '__main__':
+    raise SystemExit(main())
diff --git a/ouroboros_replay/kernels/run_sabrina_soft_charge_reduced_state_theorem.py b/ouroboros_replay/kernels/run_sabrina_soft_charge_reduced_state_theorem.py
new file mode 100644
index 0000000000000000000000000000000000000000..07c257413706e103eb113c3dfa9c0e2c3de7c36c
--- /dev/null
+++ b/ouroboros_replay/kernels/run_sabrina_soft_charge_reduced_state_theorem.py
@@ -0,0 +1,117 @@
+from __future__ import annotations
+
+from ..source_runtime import fixture_path, source_path
+import argparse
+import hashlib
+import json
+import tarfile
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Mapping, Sequence
+import sympy as sp
+from .crystal_ledger import register_crystal_artifacts
+OUT_DIR = Path('.replay_outputs') / 'out_dir'
+LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
+SOURCE_ARCHIVE = source_path('cd4abca013519ff0f5500fe09d8b4eb1033df2e33b42f4de32c9325dbae9c2eb')
+SOURCE_MEMBER = 'hps_meets_amps.tex'
+SOURCE_ARCHIVE_SHA256 = 'cd4abca013519ff0f5500fe09d8b4eb1033df2e33b42f4de32c9325dbae9c2eb'
+SOURCE_MEMBER_SHA256 = '0e88d6b5003a27b57fb43b5893fa79947c070012527bca3b1dd792f343a85e93'
+SOURCE_BLOCKS = {'evolution_context': (555, 558, '81fe3d9a13f113d89ded0e81a9851d9fbf29a262e206927161abf279a96089a8'), 'outgoing_expansion': (559, 565, 'e54beca2638848901c018855b983e5a5d254ea9063242230aaf3f90fcaa57e3f'), 'charge_split': (567, 571, 'b7ef731a7b3b931f0637a79202a34ef31128804b02006c4cb9ef21d9c3a78461'), 'combined': (555, 571, '64e694be57eadd9b64e0a137c953c96544a58a280d573feb043b7c85641c73c0')}
+PLAN_RECEIPT_SHA256 = 'a9ecdeecf9c2fadc103a2d5a7be2a1acb1cd3e71ad7cd8ac200bc412e4aface8'
+PLAN_GUARD_SHA256 = '681e4faf38dcd97e29dd1ecea4380b0a6d5d29b69b92feace66ca637018f6e17'
+PLAN_VERIFIER_SHA256 = '17933d90164f501a5b29779543d87d1b29c263edb17b65bbdb0469f039678ad9'
+
+def _sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+def _source_evidence() -> dict[str, Any]:
+    with tarfile.open(SOURCE_ARCHIVE, 'r:gz') as archive:
+        members = [member for member in archive.getmembers() if member.name == SOURCE_MEMBER]
+        if len(members) != 1:
+            raise ValueError(f'expected exactly one {SOURCE_MEMBER} source member')
+        extracted = archive.extractfile(members[0])
+        if extracted is None:
+            raise ValueError(f'{SOURCE_MEMBER} source member is unreadable')
+        member_bytes = extracted.read()
+    lines = member_bytes.decode('utf-8').splitlines()
+    block_hashes = {name: hashlib.sha256(('\n'.join(lines[start - 1:end]) + '\n').encode()).hexdigest() for name, (start, end, _) in SOURCE_BLOCKS.items()}
+    expected = {name: expected_hash for name, (_, _, expected_hash) in SOURCE_BLOCKS.items()}
+    checks = {'archive_hash_matches': _sha256(SOURCE_ARCHIVE) == SOURCE_ARCHIVE_SHA256, 'member_hash_matches': hashlib.sha256(member_bytes).hexdigest() == SOURCE_MEMBER_SHA256, 'source_blocks_match': block_hashes == expected, 'outgoing_expansion_amplitude_references_exact': sum(('A_{rb}' in line for line in lines)) == 3, 'charge_split_label_unique': sum(('\\label{qsplit}' in line for line in lines)) == 1}
+    return {'block_hashes': block_hashes, 'checks': checks}
+
+def _entropy(matrix: sp.Matrix) -> sp.Expr:
+    return sp.simplify(-sum((value * multiplicity * sp.log(value) for value, multiplicity in matrix.eigenvals().items() if value != 0)))
+
+def _matrix_strings(matrix: sp.Matrix) -> list[list[str]]:
+    return [[str(sp.simplify(matrix[row, column])) for column in range(matrix.cols)] for row in range(matrix.rows)]
+
+def build_exact_result() -> dict[str, Any]:
+    source = _source_evidence()
+    half = sp.Rational(1, 2)
+    radiation_charges = (-1, 0, 0, 1)
+    horizon_charges = (1, 0, 0, -1)
+    amplitudes = sp.zeros(4)
+    for row, column in ((0, 0), (1, 1), (2, 1), (3, 3)):
+        amplitudes[row, column] = half
+    rho_r = sp.simplify(amplitudes * amplitudes.H)
+    rho_b = sp.simplify(amplitudes.H * amplitudes)
+    q_r = sp.diag(*radiation_charges)
+    q_b = sp.diag(*horizon_charges)
+    commutator = sp.simplify(q_r * rho_r - rho_r * q_r)
+    support = [(row, column) for row in range(4) for column in range(4) if amplitudes[row, column] != 0]
+    sector_indices = {-1: [0], 0: [1, 2], 1: [3]}
+    sector_rows = []
+    probabilities = []
+    weighted_sector_entropy = sp.S.Zero
+    for charge, indices in sector_indices.items():
+        block = rho_r.extract(indices, indices)
+        probability = sp.simplify(sp.trace(block))
+        normalized = sp.simplify(block / probability)
+        sector_entropy = _entropy(normalized)
+        probabilities.append(probability)
+        weighted_sector_entropy += probability * sector_entropy
+        sector_rows.append({'charge': charge, 'probability': str(probability), 'normalized_block': _matrix_strings(normalized), 'entropy': str(sector_entropy)})
+    shannon = sp.simplify(-sum((p * sp.log(p) for p in probabilities)))
+    radiation_entropy = _entropy(rho_r)
+    bad_amplitudes = sp.zeros(4)
+    bad_amplitudes[0, 1] = sp.sqrt(2) / 2
+    bad_amplitudes[1, 1] = sp.sqrt(2) / 2
+    bad_rho_r = sp.simplify(bad_amplitudes * bad_amplitudes.H)
+    bad_commutator = sp.simplify(q_r * bad_rho_r - bad_rho_r * q_r)
+    bad_support = [(row, column) for row in range(4) for column in range(4) if bad_amplitudes[row, column] != 0]
+    exact_checks = dict(source['checks'])
+    exact_checks.update({'witness_normalized': sp.trace(rho_r) == 1 and sp.trace(rho_b) == 1, 'fixed_total_charge_support': all((radiation_charges[r] + horizon_charges[b] == 0 for r, b in support)), 'radiation_commutator_zero': commutator == sp.zeros(4), 'degenerate_sector_coherence_retained': rho_r[1, 2] == sp.Rational(1, 4), 'sector_probabilities_exact': probabilities == [sp.Rational(1, 4), sp.Rational(1, 2), sp.Rational(1, 4)], 'entropy_direct_sum_exact': sp.simplify(radiation_entropy - shannon - weighted_sector_entropy) == 0, 'radiation_entropy_exact': sp.simplify(radiation_entropy - 3 * sp.log(2) / 2) == 0, 'charge_violating_counterexample_normalized': sp.trace(bad_rho_r) == 1, 'counterexample_has_multiple_total_charges': len({radiation_charges[r] + horizon_charges[b] for r, b in bad_support}) == 2, 'counterexample_commutator_nonzero': bad_commutator != sp.zeros(4)})
+    return {'result_version': 'sabrina_soft_charge_reduced_state_theorem_v1', 'status': 'complete' if all(exact_checks.values()) else 'failed', 'paper': {'arxiv_id': '2012.03850', 'title': 'HPS meets AMPS: How Soft Hair Dissolves the Firewall'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'hypothesis': 'rho_out is supported in one eigenspace of Q_total=Q_R tensor I + I tensor Q_B', 'conclusion': '[Q_R, Tr_B(rho_out)]=0, with arbitrary degeneracy inside each Q_R sector', 'proof': ['fixed total-charge support implies [Q_total,rho_out]=0', 'partial trace gives [Q_R,rho_R]=Tr_B([Q_total,rho_out])-Tr_B([I tensor Q_B,rho_out])', 'the first term vanishes by the hypothesis and the second by cyclicity of the partial trace on B'], 'entropy_identity': 'S(rho_R)=H({p_q})+sum_q p_q S(rho_q)', 'support_rule': 'nonzero amplitudes obey q_R+q_B=q_total'}, 'witness': {'amplitudes': _matrix_strings(amplitudes), 'rho_r': _matrix_strings(rho_r), 'rho_b': _matrix_strings(rho_b), 'sector_rows': sector_rows, 'shannon_entropy': str(shannon), 'weighted_sector_entropy': str(sp.simplify(weighted_sector_entropy)), 'radiation_entropy': str(radiation_entropy)}, 'necessity_counterexample': {'rho_r': _matrix_strings(bad_rho_r), 'commutator': _matrix_strings(bad_commutator), 'distinct_total_charge_count': 2}, 'exact_checks': exact_checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'unitarity_proved': False, 'information_recovery_proved': False, 'firewall_resolution_proved': False, 'soft_charge_observability_proved': False, 'mixed_total_charge_inputs_covered': False, 'source_error_claimed': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
+
+def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
+    if out_dir.exists():
+        raise FileExistsError(f'immutable result target already exists: {out_dir}')
+    out_dir.mkdir(parents=True)
+    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
+    report = build_exact_result() | {'generated_utc': generated}
+    report_path = out_dir / 'soft_charge_reduced_state_theorem_report.json'
+    certificate_path = out_dir / 'soft_charge_reduced_state_theorem_certificate.json'
+    handoff_path = out_dir / 'SOFT_CHARGE_REDUCED_STATE_THEOREM_PRIVATE_HANDOFF.md'
+    manifest_path = out_dir / 'receipt_manifest.json'
+    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    certificate_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'witness', 'necessity_counterexample', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    handoff_path.write_text('# Soft-charge reduced-state theorem - private handoff\n\nA fixed additive total soft-charge sector forces the radiation reduced state to be block diagonal in radiation soft charge, while preserving coherence inside degenerate sectors. Its entropy separates exactly into classical charge-sector uncertainty and average within-sector entropy. An exact normalized counterexample shows why fixed total-charge support is necessary.\n', encoding='utf-8')
+    artifacts = [report_path, certificate_path, handoff_path]
+    manifest = {'manifest_version': 'sabrina_soft_charge_reduced_state_theorem_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, **{name: expected for name, (_, _, expected) in SOURCE_BLOCKS.items()}}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    all_artifacts = [*artifacts, manifest_path]
+    ledger: Mapping[str, Any] = {'status': 'skipped'}
+    if register_ledger:
+        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
+    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
+
+def main(argv: Sequence[str] | None=None) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
+    parser.add_argument('--no-register-crystal-ledger', action='store_true')
+    args = parser.parse_args(argv)
+    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
+    print(json.dumps(result, sort_keys=True))
+    return 0 if result['status'] == 'complete' else 1
+if __name__ == '__main__':
+    raise SystemExit(main())
diff --git a/ouroboros_replay/kernels/run_sabrina_soft_dressing_factor_two_no_go.py b/ouroboros_replay/kernels/run_sabrina_soft_dressing_factor_two_no_go.py
new file mode 100644
index 0000000000000000000000000000000000000000..0795d6af2c2af5496abf52a66b520cc08d2a064e
--- /dev/null
+++ b/ouroboros_replay/kernels/run_sabrina_soft_dressing_factor_two_no_go.py
@@ -0,0 +1,119 @@
+from __future__ import annotations
+
+from ..source_runtime import fixture_path, source_path
+import argparse
+import hashlib
+import json
+import tarfile
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Mapping, Sequence
+import sympy as sp
+from .crystal_ledger import register_crystal_artifacts
+OUT_DIR = Path('.replay_outputs') / 'out_dir'
+LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
+SOURCE_ARCHIVE = source_path('113774c03094c55b8c0ea9ccf46c7aed866dc0634a7f5179f42b01a63028acf0')
+SOURCE_MEMBER = 'main.tex'
+SOURCE_ARCHIVE_SHA256 = '113774c03094c55b8c0ea9ccf46c7aed866dc0634a7f5179f42b01a63028acf0'
+SOURCE_MEMBER_SHA256 = '1c137c7fa60c65285dcceb27ed516b7bd6af078d6b66ff6934839324b7369959'
+SOURCE_BLOCKS = {'field_and_ccr': (297, 311, '05efaf99c7badaa85328b5c73e4e4d97df98576f8ee644de31579b86ff21dc98'), 'half_shift': (374, 385, '4b85e7e53bd48bf5133f0b915cf85654d06f0fe23ee20790e798ad2cbd935ec1'), 'linear_dressing': (548, 567, 'ac8c26c3a8bf5ac3d645084ed8c0a1973e7b46d13c8d0e524564825d7ab7d8fe'), 'factor_two_open_problem': (1097, 1148, '0ab39d092788011485c7abd38d5515f8855985276f9f6dbdcd69f386ec435b06')}
+PLAN_RECEIPT_SHA256 = '03868e7777014490fec181195c12826094ac3bd845af1e0b191060d8ad6b08aa'
+PLAN_GUARD_SHA256 = 'c96cef7024b3225d864b195e1da692d8f8ae85bde1124c4273cf15614324802c'
+PLAN_VERIFIER_SHA256 = '9a0e972f8f657ecc89e5f544d326263983235d09ac2fdbb5c3d494d1b2e76e9f'
+
+def _sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+def _source_evidence() -> dict[str, Any]:
+    with tarfile.open(SOURCE_ARCHIVE, 'r:gz') as archive:
+        members = [member for member in archive.getmembers() if member.name == SOURCE_MEMBER]
+        if len(members) != 1:
+            raise ValueError(f'expected exactly one {SOURCE_MEMBER}')
+        extracted = archive.extractfile(members[0])
+        if extracted is None:
+            raise ValueError(f'unreadable source member: {SOURCE_MEMBER}')
+        member_bytes = extracted.read()
+    lines = member_bytes.decode('utf-8').splitlines()
+    block_texts = {name: '\n'.join(lines[start - 1:end]) + '\n' for name, (start, end, _) in SOURCE_BLOCKS.items()}
+    block_hashes = {name: hashlib.sha256(text.encode()).hexdigest() for name, text in block_texts.items()}
+    expected = {name: expected_hash for name, (_, _, expected_hash) in SOURCE_BLOCKS.items()}
+    checks = {'archive_hash_matches': _sha256(SOURCE_ARCHIVE) == SOURCE_ARCHIVE_SHA256, 'member_hash_matches': hashlib.sha256(member_bytes).hexdigest() == SOURCE_MEMBER_SHA256, 'source_blocks_match': block_hashes == expected, 'half_shift_pair_in_derivation': block_texts['half_shift'].count('-\\frac{1}{2}\\partial_') == 2, 'half_and_full_pairs_in_open_problem': block_texts['factor_two_open_problem'].count('-\\frac{1}{2}\\partial_') == 2 and block_texts['factor_two_open_problem'].count('=-\\partial_') == 2, 'open_question_unique': sum(('not clear how one can obtain' in line for line in lines)) == 1, 'wilson_line_label_unique': sum(('\\label{wline}' in line for line in lines)) == 1}
+    return {'block_hashes': block_hashes, 'checks': checks}
+
+def algebraic_certificate() -> dict[str, Any]:
+    scale = sp.Symbol('lambda', real=True)
+    weights = sp.symbols('w0:4')
+    elementary_commutators = sp.symbols('c0:4')
+    target = sp.expand(sum((weight * commutator for weight, commutator in zip(weights, elementary_commutators))))
+    scaled = sp.expand(sum((weight * scale * commutator for weight, commutator in zip(weights, elementary_commutators))))
+    linearity_residual = sp.simplify(scaled - scale * target)
+    doubled_target_gap = sp.simplify(scaled.subs(scale, 2) - target)
+    half_weight_repair = sp.simplify((scaled / scale).subs(scale, 2) - target)
+    compensating_term = sp.simplify(target - scaled)
+    central, phi = sp.symbols('C Phi', commutative=True)
+    power_rows = []
+    for power in range(1, 13):
+        lhs = power * central * phi ** (power - 1)
+        expected = sp.diff(phi ** power, phi) * central
+        power_rows.append({'power': power, 'residual': str(sp.simplify(lhs - expected))})
+    truncated_exponential_residuals = []
+    for order in range(1, 13):
+        commutator_series = sum((power * central * phi ** (power - 1) / sp.factorial(power) for power in range(1, order + 1)))
+        expected_series = central * sum((phi ** power / sp.factorial(power) for power in range(order)))
+        truncated_exponential_residuals.append(str(sp.simplify(commutator_series - expected_series)))
+    parameter = sp.Symbol('t')
+    identity = sp.eye(2)
+    charge = sp.diag(1, 0)
+    photon_mode = sp.Matrix([[0, 1], [0, 0]])
+    dressing = parameter * photon_mode
+    wilson = identity + dressing
+    commutator = lambda left, right: sp.simplify(left * right - right * left)
+    base_phi = commutator(charge, dressing)
+    doubled_phi = commutator(2 * charge, dressing)
+    base_wilson = commutator(charge, wilson)
+    doubled_wilson = commutator(2 * charge, wilson)
+    repaired_phi = commutator(2 * charge, dressing / 2)
+    return {'derivation_linearity': {'target': str(target), 'scaled': str(scaled), 'residual': str(linearity_residual), 'lambda_two_gap': str(doubled_target_gap), 'half_weight_repair_residual': str(half_weight_repair), 'required_compensating_term': str(compensating_term.subs(scale, 2))}, 'central_exponential': {'identity': '[Q,exp(Phi)]=[Q,Phi]exp(Phi) when [Q,Phi] is central', 'power_rows': power_rows, 'truncated_orders_1_through_12_residuals': truncated_exponential_residuals}, 'matrix_witness': {'phi_squared_zero': dressing ** 2 == sp.zeros(2), 'base_phi_commutator': [[str(value) for value in row] for row in base_phi.tolist()], 'doubled_phi_residual': doubled_phi == 2 * base_phi, 'doubled_wilson_residual': doubled_wilson == 2 * base_wilson, 'half_weight_repair_exact': repaired_phi == base_phi}}
+
+def build_exact_result() -> dict[str, Any]:
+    source = _source_evidence()
+    certificate = algebraic_certificate()
+    derivation = certificate['derivation_linearity']
+    central = certificate['central_exponential']
+    witness = certificate['matrix_witness']
+    exact_checks = dict(source['checks'])
+    exact_checks.update({'derivation_linearity_exact': derivation['residual'] == '0', 'lambda_two_changes_nonzero_target': derivation['lambda_two_gap'] != '0', 'half_weight_repair_exact': derivation['half_weight_repair_residual'] == '0', 'central_power_rule_exact_through_12': all((row['residual'] == '0' for row in central['power_rows'])), 'central_exponential_series_exact_through_12': all((value == '0' for value in central['truncated_orders_1_through_12_residuals'])), 'matrix_witness_all_exact': all((value is True for key, value in witness.items() if key != 'base_phi_commutator'))})
+    return {'result_version': 'sabrina_soft_dressing_factor_two_no_go_v1', 'status': 'complete' if all(exact_checks.values()) else 'failed', 'paper': {'arxiv_id': '2604.19866', 'title': 'Asymptotic charges as detectors and the memory effect in massive QED and perturbative quantum gravity'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'assumptions': 'Phi is unchanged and linear in photon modes; the charge action is a derivation; every elementary charge-mode commutator is uniformly scaled by lambda', 'no_go': '[Q,Phi]_lambda=lambda[Q,Phi]_1, so lambda=2 cannot retain a nonzero target dressing commutator', 'wilson_corollary': 'if [Q,Phi] is central, the Wilson-line phase scales by the same lambda', 'necessary_repair_classes': ['rescale dressing weights by 1/lambda', 'add a compensating contribution equal to (1-lambda) times the original target', 'change the soft-mode algebra or projection so uniform scaling no longer applies']}, 'algebraic_certificate': certificate, 'exact_checks': exact_checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'modified_opposite_helicity_brackets_resolved': False, 'preferred_repair_class_selected': False, 'physical_soft_phase_space_constructed': False, 'gravity_extension_rederived': False, 'infrared_finiteness_reproved': False, 'source_inconsistency_claimed': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
+
+def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
+    if out_dir.exists():
+        raise FileExistsError(f'immutable result target already exists: {out_dir}')
+    out_dir.mkdir(parents=True)
+    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
+    report = build_exact_result() | {'generated_utc': generated}
+    report_path = out_dir / 'soft_dressing_factor_two_no_go_report.json'
+    certificate_path = out_dir / 'soft_dressing_factor_two_no_go_certificate.json'
+    handoff_path = out_dir / 'SOFT_DRESSING_FACTOR_TWO_NO_GO_PRIVATE_HANDOFF.md'
+    manifest_path = out_dir / 'receipt_manifest.json'
+    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    certificate_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'algebraic_certificate', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    handoff_path.write_text('# Soft-dressing factor-two no-go - private handoff\n\nAn unchanged dressing exponent linear in photon modes cannot retain its required commutator when every elementary charge-mode commutator is doubled. The Wilson-line phase doubles as well whenever the dressing commutator is central. A half-weight dressing, compensating term, or changed soft algebra/projection is therefore necessary; this theorem classifies the obstruction but does not choose or construct the physical modified-bracket repair.\n', encoding='utf-8')
+    artifacts = [report_path, certificate_path, handoff_path]
+    manifest = {'manifest_version': 'sabrina_soft_dressing_factor_two_no_go_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, **{name: expected for name, (_, _, expected) in SOURCE_BLOCKS.items()}}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    all_artifacts = [*artifacts, manifest_path]
+    ledger: Mapping[str, Any] = {'status': 'skipped'}
+    if register_ledger:
+        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
+    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
+
+def main(argv: Sequence[str] | None=None) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
+    parser.add_argument('--no-register-crystal-ledger', action='store_true')
+    args = parser.parse_args(argv)
+    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
+    print(json.dumps(result, sort_keys=True))
+    return 0 if result['status'] == 'complete' else 1
+if __name__ == '__main__':
+    raise SystemExit(main())
diff --git a/ouroboros_replay/kernels/run_sabrina_soft_mellin_residue_identity.py b/ouroboros_replay/kernels/run_sabrina_soft_mellin_residue_identity.py
new file mode 100644
index 0000000000000000000000000000000000000000..7e1f85dd247b798bfb4044edbf3ac1460bcd5352
--- /dev/null
+++ b/ouroboros_replay/kernels/run_sabrina_soft_mellin_residue_identity.py
@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+from ..source_runtime import fixture_path, source_path
+import argparse
+import gzip
+import hashlib
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Mapping, Sequence
+import sympy as sp
+from .crystal_ledger import register_crystal_artifacts
+OUT_DIR = Path('.replay_outputs') / 'out_dir'
+LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
+SOURCE_ARCHIVE = source_path('96fe817814bf7bfc432df67f49f60ea0afa72f6eeb335e93624b6d8bb54359f3')
+SOURCE_ARCHIVE_SHA256 = '96fe817814bf7bfc432df67f49f60ea0afa72f6eeb335e93624b6d8bb54359f3'
+SOURCE_MEMBER_SHA256 = '287cf9724f6184a8d4b3c4a78156dbf7308c4842fd95afb805a96582315693a0'
+SOURCE_BLOCK_HASHES = {'Mellin': '6bceb4357552b5aa5e81879be46ef7a2bca646b1766392f58887007fa4ffb310', 'mellinmode': 'e019183a7f11f077ce6d9e78ace905c0e421de10bd9940f9b6d1036b3f242122', 'eq:IDDelta1': '4972b66bb470f919154ab6fd3324c373869538b172947c553b8508ce4fcdaddf', 'eq:IDDelta2': 'c7e9d17afa4c3d9719ddce22c97340c3be4facd874f86d1bb519cc51c8902c5c'}
+PLAN_RECEIPT_SHA256 = '3a6f354921c5c0d40392839aa2e9d8705da9a2b493ae057cc275b76253ef1450'
+PLAN_GUARD_SHA256 = '1d72ebd78a6080a583044160a4c3711c046e9ae4eec71136aa8f9de483e878b8'
+PLAN_VERIFIER_SHA256 = '6dee7b22a6d01697025c568d4b409859a5dde78523a91c936d2d70f4b866cf0d'
+
+def _sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open('rb') as handle:
+        for chunk in iter(lambda: handle.read(1024 * 1024), b''):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+def _source_evidence() -> dict[str, Any]:
+    archive_bytes = SOURCE_ARCHIVE.read_bytes()
+    member_bytes = gzip.decompress(archive_bytes)
+    source = member_bytes.decode('utf-8')
+    block_hashes: dict[str, str] = {}
+    for label in SOURCE_BLOCK_HASHES:
+        marker = f'\\label{{{label}}}'
+        marker_index = source.index(marker)
+        starts = [source.rfind('\\begin{equation}', 0, marker_index), source.rfind('\\be', 0, marker_index)]
+        start = max(starts)
+        ends = []
+        for token in ('\\end{equation}', '\\ee'):
+            index = source.find(token, marker_index)
+            if index >= 0:
+                ends.append(index + len(token))
+        block = source[start:min(ends)].encode('utf-8')
+        block_hashes[label] = hashlib.sha256(block).hexdigest()
+    checks = {'archive_hash_matches': hashlib.sha256(archive_bytes).hexdigest() == SOURCE_ARCHIVE_SHA256, 'member_hash_matches': hashlib.sha256(member_bytes).hexdigest() == SOURCE_MEMBER_SHA256, 'source_blocks_match': block_hashes == SOURCE_BLOCK_HASHES, 'source_equation_labels_unique': all((source.count(f'\\label{{{label}}}') == 1 for label in SOURCE_BLOCK_HASHES))}
+    return {'block_hashes': block_hashes, 'checks': checks}
+
+def build_exact_result() -> dict[str, Any]:
+    source = _source_evidence()
+    n = sp.Symbol('n', integer=True, nonnegative=True)
+    derivative = sp.Symbol('g_n')
+    residue = derivative / sp.factorial(n)
+    all_n_relation = sp.simplify(derivative - sp.factorial(n) * residue)
+    finite_rows = []
+    for order in range(9):
+        factorial = sp.factorial(order)
+        annihilation_phase = sp.Pow(-sp.I, order)
+        creation_phase = sp.Pow(sp.I, order)
+        mellin_residue = sp.Integer(1)
+        fourier_derivative = factorial
+        source_ratio = sp.simplify(fourier_derivative / mellin_residue)
+        finite_rows.append({'n': order, 'mellin_test_function': f'a(omega)=omega^{order - 1} exp(-omega)', 'mellin_residue': str(mellin_residue), 'endpoint_derivative': str(fourier_derivative), 'source_formula_ratio': str(source_ratio), 'annihilation_coefficient': str(sp.simplify(sp.pi * annihilation_phase * fourier_derivative)), 'creation_coefficient': str(sp.simplify(sp.pi * creation_phase * fourier_derivative)), 'displayed_identity_matches': source_ratio == 1, 'factorial_corrected_identity_matches': source_ratio == factorial})
+    exact_checks = dict(source['checks'])
+    exact_checks.update({'fourier_annihilation_phase': sp.simplify(sp.Pow(sp.I, n) * sp.Pow(-1, n) - sp.Pow(-sp.I, n)) == 0, 'fourier_creation_phase': sp.simplify(sp.Pow(-sp.I, n) * sp.Pow(-1, n) - sp.Pow(sp.I, n)) == 0, 'mellin_residue_is_derivative_over_factorial': all_n_relation == 0, 'n0_source_identity_exact': finite_rows[0]['displayed_identity_matches'], 'n1_source_identity_exact': finite_rows[1]['displayed_identity_matches'], 'n2_is_exact_counterexample_to_unqualified_all_n_extension': not finite_rows[2]['displayed_identity_matches'], 'n2_mismatch_factor_is_two': finite_rows[2]['source_formula_ratio'] == '2', 'corrected_identity_passes_n0_through_n8': all((row['factorial_corrected_identity_matches'] for row in finite_rows))})
+    return {'result_version': 'sabrina_soft_mellin_residue_scope_theorem_v1', 'status': 'complete' if all(exact_checks.values()) else 'failed', 'paper': {'arxiv_id': '2105.09792', 'title': 'Revisiting the Conformally Soft Sector with Celestial Diamonds', 'source_equations': ['Mellin', 'mellinmode', 'eq:IDDelta1', 'eq:IDDelta2']}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, **source}, 'theorem': {'fourier_endpoint_rule': 'Integral_0^infinity g(omega) delta^(n)(c omega) d omega =(-1)^n g^(n)(0)/(2 c^(n+1)) under the symmetric endpoint convention.', 'mellin_residue_rule': 'Res_{Delta=1-n} Integral_0^infinity omega^(Delta-2) g(omega) d omega = g^(n)(0)/n!.', 'corrected_annihilation_identity': 'LHS=(-i)^n pi n! Res_{Delta=1-n}[a_Delta] (1+z zbar)^(-1-n).', 'corrected_creation_identity': 'LHS=(+i)^n pi n! Res_{Delta=1-n}[a_Delta^dagger] (1+z zbar)^(-1-n).', 'equivalent_source_form': 'Replace u_pm^n on the left by u_pm^n/n!.'}, 'classification': 'physical_n0_n1_exact_unqualified_all_n_extension_requires_factorial', 'finite_exact_rows': finite_rows, 'exact_checks': exact_checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'paper_leading_and_subleading_results_challenged': False, 'scope': 'The source immediately applies n=0 and n=1; both are exact because n!=1.', 'unqualified_n_ge_2_extension_challenged': True, 'distributional_endpoint_convention': 'symmetric half-line delta weight', 'smoothness_assumption': 'g(omega)=omega a(omega) is smooth at omega=0', 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
+
+def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
+    if out_dir.exists():
+        raise FileExistsError(f'immutable result target already exists: {out_dir}')
+    out_dir.mkdir(parents=True)
+    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
+    report = build_exact_result() | {'generated_utc': generated}
+    report_path = out_dir / 'soft_mellin_residue_scope_report.json'
+    certificate_path = out_dir / 'soft_mellin_residue_scope_certificate.json'
+    handoff_path = out_dir / 'SOFT_MELLIN_RESIDUE_SCOPE_PRIVATE_HANDOFF.md'
+    manifest_path = out_dir / 'receipt_manifest.json'
+    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    certificate_path.write_text(json.dumps({'generated_utc': generated, 'classification': report['classification'], 'theorem': report['theorem'], 'exact_checks': report['exact_checks'], 'n2_counterexample': report['finite_exact_rows'][2], 'claim_boundary': report['claim_boundary']}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    handoff_path.write_text("# Soft Mellin residue scope theorem - private handoff\n\nThe displayed identities are exact for the leading and sub-leading cases n=0,1 used by the paper. A formal extension to n>=2 needs an n! factor on the right, or equivalently u^n/n! on the left. The n=2 test function gives an exact factor-2 counterexample. This does not challenge the paper's physical n=0,1 conclusions.\n", encoding='utf-8')
+    artifacts = [report_path, certificate_path, handoff_path]
+    manifest = {'manifest_version': 'sabrina_soft_mellin_residue_scope_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, **SOURCE_BLOCK_HASHES}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    all_artifacts = [*artifacts, manifest_path]
+    ledger: Mapping[str, Any] = {'status': 'skipped'}
+    if register_ledger:
+        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
+    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
+
+def main(argv: Sequence[str] | None=None) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
+    parser.add_argument('--no-register-crystal-ledger', action='store_true')
+    args = parser.parse_args(argv)
+    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
+    print(json.dumps(result, sort_keys=True))
+    return 0 if result['status'] == 'complete' else 1
+if __name__ == '__main__':
+    raise SystemExit(main())
diff --git a/ouroboros_replay/kernels/run_sabrina_spin1_shadow_gauge_obstruction.py b/ouroboros_replay/kernels/run_sabrina_spin1_shadow_gauge_obstruction.py
new file mode 100644
index 0000000000000000000000000000000000000000..369bacdee2e8d580ea3c9b29050f4619c94144a0
--- /dev/null
+++ b/ouroboros_replay/kernels/run_sabrina_spin1_shadow_gauge_obstruction.py
@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+from ..source_runtime import fixture_path, source_path
+import argparse
+import hashlib
+import json
+import tarfile
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Mapping, Sequence
+import sympy as sp
+from .crystal_ledger import register_crystal_artifacts
+OUT_DIR = Path('.replay_outputs') / 'out_dir'
+LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
+SOURCE_ARCHIVE = source_path('07822bb391f95a0271d3c2c67516aa152a612c389a5879a155793ebfb9c1ba4f')
+SOURCE_MEMBER = 'PrincipalSeries.tex'
+SOURCE_ARCHIVE_SHA256 = '07822bb391f95a0271d3c2c67516aa152a612c389a5879a155793ebfb9c1ba4f'
+SOURCE_MEMBER_SHA256 = '167a25cccad50de1887a89fbca7497f7a40ce53fac1b906f21a28dc53aed15e4'
+SOURCE_BLOCK = (912, 981, 'eb2375ecda05e9207181cc729c3ffdb8d9e80a25e387568c037497bc5a0b8eb3')
+PLAN_RECEIPT_SHA256 = '72888d587e775162251b12e6d4fae2c7dbabb64bebda83ca5b6a97b60fd3a9a8'
+PLAN_GUARD_SHA256 = '190432737830610389d019dedf3a9faaeaac612062954f166d04f0093e9d1a91'
+PLAN_VERIFIER_SHA256 = '5bfb9e4b8841dfd00a60a05637ca83215c20417aee3c48872e06ffa0976cc359'
+
+def _sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+def _source_evidence() -> dict[str, Any]:
+    with tarfile.open(SOURCE_ARCHIVE, 'r:*') as archive:
+        member_bytes = archive.extractfile(SOURCE_MEMBER).read()
+    lines = member_bytes.decode('utf-8', errors='replace').splitlines()
+    start, end, expected = SOURCE_BLOCK
+    block = '\n'.join(lines[start - 1:end]) + '\n'
+    block_hash = hashlib.sha256(block.encode()).hexdigest()
+    checks = {'archive_hash_matches': _sha256(SOURCE_ARCHIVE) == SOURCE_ARCHIVE_SHA256, 'member_hash_matches': hashlib.sha256(member_bytes).hexdigest() == SOURCE_MEMBER_SHA256, 'source_block_matches': block_hash == expected, 'formal_shadow_formula_present': '(-X^2)^{\\frac d2-\\Delta} A_{\\mu a}^{d-\\Delta' in block, 'delta_one_pure_gauge_present': 'pure gauge only if $\\Delta =1$' in block, 'shadow_integral_singularity_caveat_present': 'not defined for $\\Delta=1$' in block and 'zero or singular' in block, 'analytic_continuation_order_present': 'generic value of $\\Delta$' in block and 'analytic continue' in block, 'd2_exception_present': 'When $d=2$' in block and '\\widetilde{A^{\\Delta=1' in block}
+    return {'block_sha256': block_hash, 'source_lines': f'{start}-{end}', 'checks': checks}
+
+def field_strength_factorization_certificate() -> dict[str, Any]:
+    dimension = sp.symbols('d', real=True)
+    alpha = dimension / 2 - 1
+    beta = dimension - 1
+    bare_wedge_coefficient = 1 - beta
+    radial_product_coefficient = -2 * alpha
+    checks = {'bare_field_strength_has_d_minus_two_factor': sp.simplify(bare_wedge_coefficient + (dimension - 2)) == 0, 'radial_product_rule_has_d_minus_two_factor': sp.simplify(radial_product_coefficient + (dimension - 2)) == 0, 'all_terms_share_global_obstruction': sp.factor(bare_wedge_coefficient) == sp.factor(radial_product_coefficient) == 2 - dimension, 'd2_field_strength_zero': bare_wedge_coefficient.subs(dimension, 2) == 0 and radial_product_coefficient.subs(dimension, 2) == 0, 'd2_shadow_prefactor_is_unity': alpha.subs(dimension, 2) == 0, 'd2_shadow_dimension_is_one': beta.subs(dimension, 2) == 1}
+    return {'formal_shadow': 'S_mu=r^alpha[e_mu s^-beta+u q_mu s^(-beta-1)]', 'definitions': {'r': '-X^2', 's': '-q.X', 'u': 'e.X', 'alpha': '(d-2)/2', 'beta': 'd-1'}, 'field_strength': 'F=-(d-2){r^alpha(e wedge q)s^-d+r^(alpha-1)[(X wedge e)s^(-(d-1))+u(X wedge q)s^-d]}', 'bare_wedge_coefficient': str(bare_wedge_coefficient), 'radial_product_coefficient': str(radial_product_coefficient), 'checks': checks}
+
+def coordinate_witness_certificate() -> dict[str, Any]:
+    time, x, z, dimension = sp.symbols('t x z d', real=True)
+    radius, soft, contraction = (time ** 2 - x ** 2 - z ** 2, time - z, x)
+    alpha, beta = (dimension / 2 - 1, dimension - 1)
+    coordinates = (time, x, z)
+    q_covector = (-1, 0, 1)
+    e_covector = (0, 1, 0)
+    shadow = [radius ** alpha * (e_covector[index] * soft ** (-beta) + contraction * q_covector[index] * soft ** (-beta - 1)) for index in range(3)]
+    field_xz = sp.factor(sp.diff(shadow[2], x) - sp.diff(shadow[1], z))
+    point_witness = sp.factor(field_xz.subs({time: 2, x: 0, z: 0}))
+    normalized_witness = sp.powsimp(point_witness, force=True)
+    dimension_rows = [{'d': value, 'field_xz': str(sp.simplify(normalized_witness.subs(dimension, value))), 'zero': normalized_witness.subs(dimension, value) == 0} for value in range(1, 11)]
+    checks = {'null_reference_vector': -1 ** 2 + 1 ** 2 == 0, 'transverse_polarization': 0 == 0, 'coordinate_witness_exact': sp.simplify(normalized_witness + (dimension - 2) / 4) == 0, 'only_d2_zero_in_d1_through_d10': [row['d'] for row in dimension_rows if row['zero']] == [2], 'all_other_dimensions_nonzero': all((row['zero'] is (row['d'] == 2) for row in dimension_rows))}
+    return {'configuration': 'q_cov=(-1,0,1), e_cov=(0,1,0), X=(2,0,0)', 'field_xz_at_witness': str(normalized_witness), 'dimension_rows': dimension_rows, 'checks': checks}
+
+def build_exact_result() -> dict[str, Any]:
+    source = _source_evidence()
+    factorization = field_strength_factorization_certificate()
+    witness = coordinate_witness_certificate()
+    checks = dict(source['checks'])
+    checks.update(factorization['checks'])
+    checks.update(witness['checks'])
+    return {'result_version': 'sabrina_spin1_shadow_gauge_obstruction_v1', 'status': 'complete' if all(checks.values()) else 'failed', 'paper': {'arxiv_id': '1705.01027', 'title': 'A Conformal Basis for Flat Space Amplitudes'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'obstruction': 'the formal Delta=1 shadow field strength has a global factor d-2', 'self_shadow_exception': 'at d=2 the radial factor is unity and the shadow dimension is one', 'explicit_witness': 'F_xz at q=(-1,0,1), e=(0,1,0), X=(2,0,0) equals -(d-2)/4'}, 'field_strength_factorization_certificate': factorization, 'coordinate_witness_certificate': witness, 'exact_checks': checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'formal_analytic_continuation_only': True, 'direct_delta_one_shadow_integral_convergence_claimed': False, 'spin_one_conformal_primary_family_only': True, 'arbitrary_gauge_fields_claimed': False, 'large_gauge_hilbert_space_status_claimed': False, 'interacting_amplitudes_claimed': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
+
+def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
+    if out_dir.exists():
+        raise FileExistsError(f'immutable result target already exists: {out_dir}')
+    out_dir.mkdir(parents=True)
+    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
+    report = build_exact_result() | {'generated_utc': generated}
+    report_path = out_dir / 'spin1_shadow_gauge_obstruction_report.json'
+    witness_path = out_dir / 'spin1_shadow_gauge_obstruction_witnesses.json'
+    handoff_path = out_dir / 'SPIN1_SHADOW_GAUGE_OBSTRUCTION_PRIVATE_HANDOFF.md'
+    manifest_path = out_dir / 'receipt_manifest.json'
+    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    witness_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'field_strength_factorization_certificate', 'coordinate_witness_certificate', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    handoff_path.write_text('# Spin-one shadow gauge obstruction - private handoff\n\nThe analytically continued formal shadow of the Delta=1 photon mode has field strength proportional to d-2. An explicit coordinate witness is nonzero in every tested d other than two; at d=2 the mode is exactly self-shadow and pure gauge. The direct Delta=1 shadow integral remains singular or undefined, as stated in the source.\n', encoding='utf-8')
+    artifacts = [report_path, witness_path, handoff_path]
+    manifest = {'manifest_version': 'sabrina_spin1_shadow_gauge_obstruction_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, 'source_lines_912_981': SOURCE_BLOCK[2]}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    all_artifacts = [*artifacts, manifest_path]
+    ledger: Mapping[str, Any] = {'status': 'skipped'}
+    if register_ledger:
+        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
+    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
+
+def main(argv: Sequence[str] | None=None) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
+    parser.add_argument('--no-register-crystal-ledger', action='store_true')
+    args = parser.parse_args(argv)
+    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
+    print(json.dumps(result, sort_keys=True))
+    return 0 if result['status'] == 'complete' else 1
+if __name__ == '__main__':
+    raise SystemExit(main())
diff --git a/ouroboros_replay/kernels/run_sabrina_subleading_soft_gauge_defect_theorem.py b/ouroboros_replay/kernels/run_sabrina_subleading_soft_gauge_defect_theorem.py
new file mode 100644
index 0000000000000000000000000000000000000000..0914dc6b0c2b1f4ae63b27e337b0de7732fffc01
--- /dev/null
+++ b/ouroboros_replay/kernels/run_sabrina_subleading_soft_gauge_defect_theorem.py
@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+from ..source_runtime import fixture_path, source_path
+import argparse
+import hashlib
+import json
+import tarfile
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Mapping, Sequence
+import sympy as sp
+from .crystal_ledger import register_crystal_artifacts
+OUT_DIR = Path('.replay_outputs') / 'out_dir'
+LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
+SOURCE_ARCHIVE = source_path('71c4e286fc787483d55585c3cd1846f7a5bde08fbdc45ecd68c195b08d48960c')
+SOURCE_MEMBER = 'BMSVirasoro.tex'
+SOURCE_ARCHIVE_SHA256 = '71c4e286fc787483d55585c3cd1846f7a5bde08fbdc45ecd68c195b08d48960c'
+SOURCE_MEMBER_SHA256 = 'b460d980cf426aa41cddf49bc70c1f356d9ed752ce70972e82cdd06c352c6e0d'
+SOURCE_BLOCKS = {'soft_factor_gauge_check': (538, 551, 'a7f43c2c41e714df48ba6ebee2b43ff30b16dd162241500609e90ecec06905e9')}
+PLAN_RECEIPT_SHA256 = 'dca87f0201feeb6c848d7d1a65a4b6c05d3a8d5f5c24c1770f1d0c9efab2773a'
+PLAN_GUARD_SHA256 = '324213b206d42655fc81ff6251b2b22d2446ee710f8444ba064d9a9047df7a83'
+PLAN_VERIFIER_SHA256 = '7b5ea78bb2d717d62e02d4b045f0392833ace2104dc66874ec4f6b4133bc26a3'
+
+def _sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+def _source_evidence() -> dict[str, Any]:
+    with tarfile.open(SOURCE_ARCHIVE, 'r:*') as archive:
+        extracted = archive.extractfile(SOURCE_MEMBER)
+        if extracted is None:
+            raise ValueError(f'unreadable source member: {SOURCE_MEMBER}')
+        member_bytes = extracted.read()
+    lines = member_bytes.decode('utf-8').splitlines()
+    texts = {name: '\n'.join(lines[start - 1:end]) + '\n' for name, (start, end, _) in SOURCE_BLOCKS.items()}
+    hashes = {name: hashlib.sha256(text.encode()).hexdigest() for name, text in texts.items()}
+    expected = {name: value for name, (_, _, value) in SOURCE_BLOCKS.items()}
+    block = texts['soft_factor_gauge_check']
+    checks = {'archive_hash_matches': _sha256(SOURCE_ARCHIVE) == SOURCE_ARCHIVE_SHA256, 'member_hash_matches': hashlib.sha256(member_bytes).hexdigest() == SOURCE_MEMBER_SHA256, 'source_blocks_match': hashes == expected, 'subleading_soft_factor_present': '\\label{sone}' in block, 'global_conservation_present': '\\sum J_{k\\lambda\\nu}=0' in block, 'pure_gauge_polarization_present': '\\e_\\Lambda^{\\mu\\nu}=q^\\mu\\Lambda^\\nu + q^\\nu\\Lambda^\\mu' in block, 'gauge_variation_present': 'iS^{(1)}(\\e_\\Lambda)' in block, 'tree_level_scope_present': 'tree-level gravitons' in block}
+    return {'block_hashes': hashes, 'checks': checks}
+
+def skew_symbolic_matrix(dimension: int, prefix: str) -> sp.Matrix:
+    matrix = sp.zeros(dimension)
+    for row in range(dimension):
+        for column in range(row + 1, dimension):
+            value = sp.symbols(f'{prefix}_{row}_{column}')
+            matrix[row, column], matrix[column, row] = (value, -value)
+    return matrix
+
+def dimension_certificate(dimension: int) -> dict[str, Any]:
+    q = sp.Matrix(sp.symbols(f'q0:{dimension}'))
+    gauge = sp.Matrix(sp.symbols(f'L0:{dimension}'))
+    weights = sp.symbols('alpha0:3')
+    angular_momenta = [skew_symbolic_matrix(dimension, f'J{index}') for index in range(3)]
+    defect = sum(angular_momenta, sp.zeros(dimension))
+    self_contractions = [sp.expand((q.T * matrix * q)[0]) for matrix in angular_momenta]
+    full_variation = sp.expand((q.T * defect * gauge)[0] + sum((weight * contraction for weight, contraction in zip(weights, self_contractions))))
+    defect_bilinear = sp.expand((q.T * defect * gauge)[0])
+    probes = sp.Matrix(dimension, dimension, lambda row, column: (sp.eye(dimension).col(row).T * defect * sp.eye(dimension).col(column))[0])
+    conserved = [angular_momenta[0], angular_momenta[1], -angular_momenta[0] - angular_momenta[1]]
+    conserved_variation = sp.expand((q.T * sum(conserved, sp.zeros(dimension)) * gauge)[0] + sum((weights[index] * (q.T * matrix * q)[0] for index, matrix in enumerate(conserved))))
+    witness_matrix = sp.zeros(dimension)
+    witness_matrix[0, 1], witness_matrix[1, 0] = (1, -1)
+    witness = (sp.eye(dimension).col(0).T * witness_matrix * sp.eye(dimension).col(1))[0]
+    checks = {'every_skew_self_contraction_zero': all((value == 0 for value in self_contractions)), 'variation_reduces_to_defect_bilinear': sp.simplify(full_variation - defect_bilinear) == 0, 'basis_probes_reconstruct_defect': probes == defect, 'conserved_variation_zero': conserved_variation == 0, 'nonzero_defect_has_basis_witness': witness == 1, 'probe_count_complete': probes.rows * probes.cols == dimension ** 2}
+    return {'dimension': dimension, 'independent_components': dimension * (dimension - 1) // 2, 'basis_probe_count': dimension ** 2, 'nonzero_witness': str(witness), 'checks': checks}
+
+def algebraic_certificate() -> dict[str, Any]:
+    dimensions = [dimension_certificate(value) for value in range(2, 9)]
+    checks = {'dimensions_two_through_eight_checked': [row['dimension'] for row in dimensions] == list(range(2, 9)), 'all_dimension_checks_pass': all((all(row['checks'].values()) for row in dimensions)), 'four_dimensional_component_count': dimensions[2]['independent_components'] == 6, 'four_dimensional_probe_count': dimensions[2]['basis_probe_count'] == 16}
+    return {'identity': 'i S^(1)(epsilon_Lambda)=q^T DeltaJ Lambda, with DeltaJ=sum_k J_k', 'converse': 'the pure-gauge variation vanishes for every q and Lambda iff DeltaJ=0', 'dimensions': dimensions, 'checks': checks}
+
+def build_exact_result() -> dict[str, Any]:
+    source = _source_evidence()
+    algebra = algebraic_certificate()
+    checks = dict(source['checks'])
+    checks.update(algebra['checks'])
+    return {'result_version': 'sabrina_subleading_soft_gauge_defect_theorem_v1', 'status': 'complete' if all(checks.values()) else 'failed', 'paper': {'arxiv_id': '1406.3312', 'title': 'Semiclassical Virasoro Symmetry of the Quantum Gravity S-Matrix'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'defect_identity': algebra['identity'], 'gauge_invariance_criterion': algebra['converse'], 'mechanism': 'q^T J_k q vanishes termwise by antisymmetry; basis polarizations recover every component of DeltaJ', 'failure_diagnostic': 'any nonzero DeltaJ component supplies a basis pair (q,Lambda) with nonzero pure-gauge variation'}, 'algebraic_certificate': algebra, 'exact_checks': checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'algebraic_identity_dimension_independent': True, 'physical_application_four_dimensional': True, 'tree_level_gravitons_only': True, 'loop_level_virasoro_symmetry_claimed': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
+
+def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
+    if out_dir.exists():
+        raise FileExistsError(f'immutable result target already exists: {out_dir}')
+    out_dir.mkdir(parents=True)
+    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
+    report = build_exact_result() | {'generated_utc': generated}
+    report_path = out_dir / 'subleading_soft_gauge_defect_theorem_report.json'
+    witness_path = out_dir / 'subleading_soft_gauge_defect_theorem_witnesses.json'
+    handoff_path = out_dir / 'SUBLEADING_SOFT_GAUGE_DEFECT_THEOREM_PRIVATE_HANDOFF.md'
+    manifest_path = out_dir / 'receipt_manifest.json'
+    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    witness_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'algebraic_certificate', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    handoff_path.write_text('# Subleading-soft gauge-defect theorem - private handoff\n\nThe pure-gauge subleading-soft variation is exactly the bilinear probe of the total angular-momentum defect. Antisymmetry removes every self-contraction, and basis probes show that gauge cancellation for all polarizations is equivalent to exact conservation. The physical claim remains restricted to four-dimensional tree-level graviton scattering.\n', encoding='utf-8')
+    artifacts = [report_path, witness_path, handoff_path]
+    manifest = {'manifest_version': 'sabrina_subleading_soft_gauge_defect_theorem_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, **{name: value for name, (_, _, value) in SOURCE_BLOCKS.items()}}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    all_artifacts = [*artifacts, manifest_path]
+    ledger: Mapping[str, Any] = {'status': 'skipped'}
+    if register_ledger:
+        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
+    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
+
+def main(argv: Sequence[str] | None=None) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
+    parser.add_argument('--no-register-crystal-ledger', action='store_true')
+    args = parser.parse_args(argv)
+    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
+    print(json.dumps(result, sort_keys=True))
+    return 0 if result['status'] == 'complete' else 1
+if __name__ == '__main__':
+    raise SystemExit(main())
diff --git a/ouroboros_replay/kernels/run_sabrina_super_bms_commutator_syzygy_family.py b/ouroboros_replay/kernels/run_sabrina_super_bms_commutator_syzygy_family.py
new file mode 100644
index 0000000000000000000000000000000000000000..d672d405659c12153b6052326b6c1347f02bb9c4
--- /dev/null
+++ b/ouroboros_replay/kernels/run_sabrina_super_bms_commutator_syzygy_family.py
@@ -0,0 +1,121 @@
+from __future__ import annotations
+
+from ..source_runtime import fixture_path, source_path
+import argparse
+import hashlib
+import json
+import tarfile
+from datetime import datetime, timezone
+from fractions import Fraction
+from pathlib import Path
+from typing import Any, Mapping, Sequence
+from .crystal_ledger import register_crystal_artifacts
+OUT_DIR = Path('.replay_outputs') / 'out_dir'
+LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
+SOURCE_ARCHIVE = source_path('52cceb32e1459fb57a0b32d1b24bb738a73e5888976775ff6fab8499df6fc401')
+SOURCE_MEMBER = 'PPP.tex'
+SOURCE_ARCHIVE_SHA256 = '52cceb32e1459fb57a0b32d1b24bb738a73e5888976775ff6fab8499df6fc401'
+SOURCE_MEMBER_SHA256 = 'a50867327474e55046979390bbde0d888cb6f4580542735f9cef07134d076d84'
+SOURCE_BLOCKS = {'super_bms_algebra': (1212, 1235, '07e4ff2b9792ed6e5d48af3637bf67478083b6626b46c173c8e856c90f542949'), 'soft_descendant_doublet': (1319, 1363, 'b7d31a7d00996cf3099ec467b32f8136ae24b4b472e7ebb843e01d36657ab13a'), 'source_mode_identity': (1364, 1367, '43a2b6078322a9c41d6001acb3bfb6eb2773be16651bf33ccae5b6eb16d9c426')}
+PLAN_RECEIPT_SHA256 = '33fcd86e322339225ee9537817d5ea0fe4821b26455ee5c7e9dee9ceed90d048'
+PLAN_GUARD_SHA256 = '0d74e39fc31718ba509a31015066cc87d3094ea7c253e2b525f952d197f7d31a'
+PLAN_VERIFIER_SHA256 = 'da732a48a7209411042d3d926bfbbb4ef290e3128a1aea22b90e8ac99f760525'
+
+def _sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+def _source_evidence() -> dict[str, Any]:
+    with tarfile.open(SOURCE_ARCHIVE, 'r:*') as archive:
+        extracted = archive.extractfile(SOURCE_MEMBER)
+        if extracted is None:
+            raise ValueError(f'unreadable source member: {SOURCE_MEMBER}')
+        member_bytes = extracted.read()
+    lines = member_bytes.decode('utf-8').splitlines()
+    texts = {name: '\n'.join(lines[start - 1:end]) + '\n' for name, (start, end, _) in SOURCE_BLOCKS.items()}
+    hashes = {name: hashlib.sha256(text.encode()).hexdigest() for name, text in texts.items()}
+    expected = {name: value for name, (_, _, value) in SOURCE_BLOCKS.items()}
+    checks = {'archive_hash_matches': _sha256(SOURCE_ARCHIVE) == SOURCE_ARCHIVE_SHA256, 'member_hash_matches': hashlib.sha256(member_bytes).hexdigest() == SOURCE_MEMBER_SHA256, 'source_blocks_match': hashes == expected, 'super_bms_bracket_present': all((marker in texts['super_bms_algebra'] for marker in ('[\\bar{L}_m,\\bar{G}_n]', '(\\frac{1}{2}m-n)\\bar{G}_{m+n}', '\\label{comm}'))), 'source_special_identity_present': all((marker in texts['source_mode_identity'] for marker in ('\\bar{G}_{-\\frac{1}{2}}', '\\bar{L}_{-2}', '\\bar{G}_{-\\frac{3}{2}}')))}
+    return {'block_hashes': hashes, 'checks': checks}
+
+def route_coefficient(target_mode: Fraction, lorentz_mode: int) -> Fraction:
+    return target_mode - Fraction(3 * lorentz_mode, 2)
+
+def route(target_mode: Fraction, lorentz_mode: int) -> dict[str, Any]:
+    coefficient = route_coefficient(target_mode, lorentz_mode)
+    return {'target_mode': str(target_mode), 'lorentz_mode': lorentz_mode, 'fermion_mode': str(target_mode - lorentz_mode), 'commutator': f'[G_({target_mode - lorentz_mode}),L_({lorentz_mode})]', 'target_coefficient': str(coefficient), 'exceptional_zero_route': coefficient == 0}
+
+def pair_syzygy_residual(target_mode: Fraction, left_mode: int, right_mode: int) -> Fraction:
+    left = route_coefficient(target_mode, left_mode)
+    right = route_coefficient(target_mode, right_mode)
+    return right * left - left * right
+
+def exceptional_mode(target_mode: Fraction) -> int | None:
+    candidate = Fraction(2, 3) * target_mode
+    return candidate.numerator if candidate.denominator == 1 else None
+
+def finite_exact_certificate() -> dict[str, Any]:
+    targets = [Fraction(value, 2) for value in range(-9, 10, 2)]
+    modes = list(range(-4, 5))
+    rows = []
+    all_pairwise = True
+    exceptional_rows = []
+    for target_mode in targets:
+        coefficients = [route_coefficient(target_mode, mode) for mode in modes]
+        pair_checks = [pair_syzygy_residual(target_mode, left, right) == 0 for left in modes for right in modes]
+        all_pairwise = all_pairwise and all(pair_checks)
+        exceptional = exceptional_mode(target_mode)
+        if exceptional is not None:
+            exceptional_rows.append(route(target_mode, exceptional))
+        nonzero_count = sum((coefficient != 0 for coefficient in coefficients))
+        rows.append({'target_mode': str(target_mode), 'route_count': len(modes), 'nonzero_route_count': nonzero_count, 'commutator_image_rank': 1 if nonzero_count else 0, 'syzygy_dimension': len(modes) - 1 if nonzero_count else len(modes), 'all_pairwise_syzygies_pass': all(pair_checks)})
+    return {'target_modes': [str(value) for value in targets], 'lorentz_modes': modes, 'rows': rows, 'exceptional_routes': exceptional_rows, 'all_pairwise_syzygies_pass': all_pairwise}
+
+def source_specialization() -> dict[str, Any]:
+    target = Fraction(-5, 2)
+    first = route_coefficient(target, -2)
+    second_as_g_l = route_coefficient(target, -1)
+    second_as_l_g = -second_as_g_l
+    residual = first - Fraction(1, 2) * second_as_l_g
+    return {'target_mode': str(target), 'first_route': route(target, -2), 'second_route_G_then_L': route(target, -1), 'second_route_L_then_G_coefficient': str(second_as_l_g), 'source_identity_residual': str(residual), 'source_identity_exact': residual == 0}
+
+def build_exact_result() -> dict[str, Any]:
+    source = _source_evidence()
+    certificate = finite_exact_certificate()
+    specialization = source_specialization()
+    exceptional_checks = [route_coefficient(Fraction(row['target_mode']), row['lorentz_mode']) == 0 and row['lorentz_mode'] == exceptional_mode(Fraction(row['target_mode'])) for row in certificate['exceptional_routes']]
+    checks = dict(source['checks'])
+    checks.update({'all_pairwise_syzygies_exact': certificate['all_pairwise_syzygies_pass'], 'exceptional_routes_exact': all(exceptional_checks), 'finite_rank_one_certificates_exact': all((row['commutator_image_rank'] == 1 and row['syzygy_dimension'] == row['route_count'] - 1 for row in certificate['rows'])), 'source_specialization_exact': specialization['source_identity_exact']})
+    return {'result_version': 'sabrina_super_bms_commutator_syzygy_family_v1', 'status': 'complete' if all(checks.values()) else 'failed', 'paper': {'arxiv_id': '2108.11422', 'title': 'Conformally Soft Fermions'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'route_formula': 'C_m(t):=[G_(t-m),L_m]=(t-3m/2)G_t', 'pairwise_syzygy': '(t-3n/2)C_m(t)-(t-3m/2)C_n(t)=0 for all integer m,n and half-integer t', 'exceptional_route': 'C_m(t)=0 exactly when m=2t/3 is an integer', 'finite_route_rank': 'for N selected routes containing a nonzero coefficient, the commutator image has rank one and the syzygy space has dimension N-1', 'source_special_case': 't=-5/2, m=-2, n=-1 reproduces [G_-1/2,L_-2]-(1/2)[L_-1,G_-3/2]=0'}, 'all_order_proof': {'antisymmetry_step': '[G_n,L_m]=-[L_m,G_n]=(n-m/2)G_(m+n)', 'fixed_target_step': 'substitute n=t-m to obtain (t-3m/2)G_t', 'syzygy_step': 'cross-multiply any two route coefficients', 'rank_step': 'all route images are scalar multiples of one basis vector G_t'}, 'finite_exact_certificate': certificate, 'source_specialization': specialization, 'exact_checks': checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'central_extensions_included': False, 'nonlinear_charge_algebra_claimed': False, 'quantum_anomalies_analyzed': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
+
+def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
+    if out_dir.exists():
+        raise FileExistsError(f'immutable result target already exists: {out_dir}')
+    out_dir.mkdir(parents=True)
+    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
+    report = build_exact_result() | {'generated_utc': generated}
+    report_path = out_dir / 'super_bms_commutator_syzygy_family_report.json'
+    witness_path = out_dir / 'super_bms_commutator_syzygy_family_witnesses.json'
+    handoff_path = out_dir / 'SUPER_BMS_COMMUTATOR_SYZYGY_FAMILY_PRIVATE_HANDOFF.md'
+    manifest_path = out_dir / 'receipt_manifest.json'
+    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    witness_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'all_order_proof', 'finite_exact_certificate', 'source_specialization', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    handoff_path.write_text("# Super-BMS commutator syzygy family - private handoff\n\nThe source's single mode identity extends to every pair of commutator routes reaching a fixed fermion mode. All routes are collinear, their complete pairwise syzygies are explicit, and exceptional zero routes are classified exactly. The result excludes central extensions, nonlinear charge algebra, quantum anomalies, and publication.\n", encoding='utf-8')
+    artifacts = [report_path, witness_path, handoff_path]
+    manifest = {'manifest_version': 'sabrina_super_bms_commutator_syzygy_family_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, **{name: value for name, (_, _, value) in SOURCE_BLOCKS.items()}}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    all_artifacts = [*artifacts, manifest_path]
+    ledger: Mapping[str, Any] = {'status': 'skipped'}
+    if register_ledger:
+        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
+    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
+
+def main(argv: Sequence[str] | None=None) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
+    parser.add_argument('--no-register-crystal-ledger', action='store_true')
+    args = parser.parse_args(argv)
+    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
+    print(json.dumps(result, sort_keys=True))
+    return 0 if result['status'] == 'complete' else 1
+if __name__ == '__main__':
+    raise SystemExit(main())
diff --git a/ouroboros_replay/kernels/run_sabrina_superrotation_charge_cancellation.py b/ouroboros_replay/kernels/run_sabrina_superrotation_charge_cancellation.py
new file mode 100644
index 0000000000000000000000000000000000000000..0876bafd336f7d298e39770a69560f75f0ae36fa
--- /dev/null
+++ b/ouroboros_replay/kernels/run_sabrina_superrotation_charge_cancellation.py
@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+from ..source_runtime import fixture_path, source_path
+import argparse
+import hashlib
+import json
+import tarfile
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Mapping, Sequence
+import sympy as sp
+from .crystal_ledger import register_crystal_artifacts
+OUT_DIR = Path('.replay_outputs') / 'out_dir'
+LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
+SOURCE_ARCHIVE = source_path('c3e707827b4e21604f131a38a77ff84650ac52232b376fab6cf39b36d6a92be8')
+SOURCE_MEMBER = 'ASandCCFT_ArXiv.tex'
+SOURCE_ARCHIVE_SHA256 = 'c3e707827b4e21604f131a38a77ff84650ac52232b376fab6cf39b36d6a92be8'
+SOURCE_MEMBER_SHA256 = '686a972b98e8bba30fac31685b979e77876ff4d0a2ad58fceb710a51ce1108bf'
+SOURCE_BLOCK_HASHES = {'mQY': '2b22626481d991b571e0522af2da1db4f732bbe94c519313bfd1138e37aa6b25', 'dQ': '397652f6ece651dfe3427c6aa4512743f8e83042e8e8e7baa4b64c5aa2121ef0', 'QYsoft': 'a9b55f82a2c4f72505a2e3517be55689d901d68067d0bb29b07c07e71a3510d7', 'udQ': 'd8ef18cee3e99b07c7a82ed04334c5bdf2c64c6d72eb9a17d3b34032e3157b41', 'QYfinal': '3382b7cf6e175a7d1bfd2b1fa33dbea984ddba40d32c7150e380b886e3020cb8'}
+PLAN_RECEIPT_SHA256 = 'b40be1113bf541dd41e77fb069e2e9f6718b6de773e794bab799f11a12a3da73'
+PLAN_GUARD_SHA256 = '96275ea0be6125689016f1cf19649dad1ee6ac0a56a606b25d700a8646805a2f'
+PLAN_VERIFIER_SHA256 = 'caf8d70bb710d642573894aecb43e4cee1902877c6cd2bca890027d4b040ab59'
+
+def _sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open('rb') as handle:
+        for chunk in iter(lambda: handle.read(1024 * 1024), b''):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+def _source_evidence() -> dict[str, Any]:
+    archive_hash = _sha256(SOURCE_ARCHIVE)
+    with tarfile.open(SOURCE_ARCHIVE, 'r:*') as archive:
+        stream = archive.extractfile(SOURCE_MEMBER)
+        if stream is None:
+            raise FileNotFoundError(SOURCE_MEMBER)
+        member_bytes = stream.read()
+    source = member_bytes.decode('utf-8')
+    block_hashes: dict[str, str] = {}
+    for label in SOURCE_BLOCK_HASHES:
+        marker = f'\\label{{{label}}}'
+        marker_index = source.index(marker)
+        start = max(source.rfind('\\begin{equation}', 0, marker_index), source.rfind('\\be', 0, marker_index))
+        ends = []
+        for token in ('\\end{equation}', '\\ee'):
+            index = source.find(token, marker_index)
+            if index >= 0:
+                ends.append(index + len(token))
+        block = source[start:min(ends)].encode('utf-8')
+        block_hashes[label] = hashlib.sha256(block).hexdigest()
+    restriction = 'For $Y^A=(Y^z,0)$' in source
+    reinstatement = 'reinstated $1/(32\\pi G)$' in source
+    checks = {'archive_hash_matches': archive_hash == SOURCE_ARCHIVE_SHA256, 'member_hash_matches': hashlib.sha256(member_bytes).hexdigest() == SOURCE_MEMBER_SHA256, 'source_blocks_match': block_hashes == SOURCE_BLOCK_HASHES, 'source_equation_labels_unique': all((source.count(f'\\label{{{label}}}') == 1 for label in SOURCE_BLOCK_HASHES)), 'holomorphic_restriction_present': restriction, 'normalization_reinstatement_present': reinstatement}
+    return {'block_hashes': block_hashes, 'checks': checks}
+
+def build_exact_result() -> dict[str, Any]:
+    source = _source_evidence()
+    pi, grav = (sp.pi, sp.Symbol('G', nonzero=True))
+    original = sp.Matrix([-1, -sp.Rational(1, 2), 1, -sp.Rational(1, 2)])
+    boundary = sp.Matrix([1, sp.Rational(1, 2), 1, sp.Rational(1, 2)])
+    combined = sp.simplify(original + boundary)
+    normalized = sp.simplify(combined / (32 * pi * grav))
+    expected = sp.Matrix([0, 0, 1 / (16 * pi * grav), 0])
+    independent_full_sector = sp.eye(4).row_join(sp.zeros(4, 4))
+    exact_checks = dict(source['checks'])
+    exact_checks.update({'both_shear_terms_cancel': combined[0] == 0 and combined[1] == 0, 'antiholomorphic_news_term_cancels': combined[3] == 0, 'holomorphic_news_term_doubles': combined[2] == 2, 'reinstated_normalization_is_exact': normalized == expected, 'holomorphic_source_map_rank_four': independent_full_sector.rank() == 4, 'unrestricted_extension_has_four_unfixed_components': 8 - independent_full_sector.rank() == 4})
+    return {'result_version': 'sabrina_superrotation_charge_cancellation_v1', 'status': 'complete' if all(exact_checks.values()) else 'failed', 'paper': {'arxiv_id': '2005.08990', 'title': 'Asymptotic Symmetries and Celestial CFT', 'source_equations': list(SOURCE_BLOCK_HASHES)}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, **source}, 'basis': ['D_z^3 Y^z C^zz', 'D^2 D_zbar Y_zbar C^zbarzbar', 'u D_z^3 Y^z N^zz', 'u D^2 D_zbar Y_zbar N^zbarzbar'], 'coefficient_certificate': {'renormalized_symplectic_charge': [str(value) for value in original], 'integrated_boundary_correction': [str(value) for value in boundary], 'sum_before_normalization': [str(value) for value in combined], 'sum_after_reinstating_1_over_32piG': [str(value) for value in normalized]}, 'classification': 'source_consistent_holomorphic_superrotation_charge_exactly_reduced', 'finding': "Under the source's explicit Y^A=(Y^z,0) restriction, the boundary term cancels both shear terms and the anti-holomorphic news term, doubles only the holomorphic news term, and yields exactly the displayed 1/(16 pi G) charge.", 'exact_checks': exact_checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'source_correction_claimed': False, 'holomorphic_restriction': 'Y^A=(Y^z,0)', 'unrestricted_two_component_extension_proven': False, 'unrestricted_extension_reason': 'The source-derived coefficient map fixes four holomorphic-sector components and leaves four independent conjugate-sector components unfixed.', 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
+
+def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
+    if out_dir.exists():
+        raise FileExistsError(f'immutable result target already exists: {out_dir}')
+    out_dir.mkdir(parents=True)
+    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
+    report = build_exact_result() | {'generated_utc': generated}
+    report_path = out_dir / 'superrotation_charge_cancellation_report.json'
+    certificate_path = out_dir / 'superrotation_charge_cancellation_certificate.json'
+    handoff_path = out_dir / 'SUPERROTATION_CHARGE_CANCELLATION_PRIVATE_HANDOFF.md'
+    manifest_path = out_dir / 'receipt_manifest.json'
+    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    certificate_path.write_text(json.dumps({'generated_utc': generated, 'classification': report['classification'], 'basis': report['basis'], 'coefficient_certificate': report['coefficient_certificate'], 'exact_checks': report['exact_checks'], 'claim_boundary': report['claim_boundary']}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    handoff_path.write_text('# Superrotation charge cancellation - private handoff\n\nThe five SHA-pinned source equations form an exact coefficient cancellation: (-1,-1/2,1,-1/2)+(1,1/2,1,1/2)=(0,0,2,0). Reinstating 1/(32 pi G) gives the displayed holomorphic 1/(16 pi G) soft charge. This is source-consistent and restricted to Y^A=(Y^z,0); it is not a paper correction or an unrestricted two-component-Y derivation.\n', encoding='utf-8')
+    artifacts = [report_path, certificate_path, handoff_path]
+    manifest = {'manifest_version': 'sabrina_superrotation_charge_cancellation_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, **SOURCE_BLOCK_HASHES}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    all_artifacts = [*artifacts, manifest_path]
+    ledger: Mapping[str, Any] = {'status': 'skipped'}
+    if register_ledger:
+        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
+    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
+
+def main(argv: Sequence[str] | None=None) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
+    parser.add_argument('--no-register-crystal-ledger', action='store_true')
+    args = parser.parse_args(argv)
+    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
+    print(json.dumps(result, sort_keys=True))
+    return 0 if result['status'] == 'complete' else 1
+if __name__ == '__main__':
+    raise SystemExit(main())
diff --git a/ouroboros_replay/kernels/run_sabrina_two_particle_kernel_variance.py b/ouroboros_replay/kernels/run_sabrina_two_particle_kernel_variance.py
new file mode 100644
index 0000000000000000000000000000000000000000..4d26f356428f419f1e8493218bbdf58e163aee66
--- /dev/null
+++ b/ouroboros_replay/kernels/run_sabrina_two_particle_kernel_variance.py
@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+from ..source_runtime import fixture_path, source_path
+import argparse
+import hashlib
+import json
+import tarfile
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Mapping, Sequence
+import sympy as sp
+from .crystal_ledger import register_crystal_artifacts
+OUT_DIR = Path('.replay_outputs') / 'out_dir'
+LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
+SOURCE_ARCHIVE = source_path('a6d1fa18157eefdb3f32c35fe8417c07e425eefb1c2e9e2e316e36dee2a530e2')
+SOURCE_MEMBER = 'main.tex'
+SOURCE_ARCHIVE_SHA256 = 'a6d1fa18157eefdb3f32c35fe8417c07e425eefb1c2e9e2e316e36dee2a530e2'
+SOURCE_MEMBER_SHA256 = '9c40bdf5a48077f22552d0bca2cd30ad739566fe687662fafccced4be7953d1b'
+SOURCE_BLOCKS = {'kernel_normalization_and_homogeneity': (809, 835, '7f9e049dc3049042069dfd440d9526fc79b11a5f1a6fb44229ddc5a9567e681b'), 'two_particle_ope_weight': (870, 885, 'ae0e4719372cdcb85d1120fab106463b7b669ccc767e3777fbf4ada73576e3f0')}
+PLAN_RECEIPT_SHA256 = '6fd107587cd1f0b739ab3af847c40c85417646d89a99e33d97659a20cac9908b'
+PLAN_GUARD_SHA256 = 'b71bf1cf48a6e1cbac2a816a306a24c2b64f532e7d4a797dc8146a2f0d709010'
+PLAN_VERIFIER_SHA256 = 'd53d75d04020f4f43a9bf4024822a7ddb7ff9ae99f7b292a530733f77809f7fa'
+
+def _sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+def _source_evidence() -> dict[str, Any]:
+    with tarfile.open(SOURCE_ARCHIVE, 'r:gz') as archive:
+        members = [member for member in archive.getmembers() if member.name == SOURCE_MEMBER]
+        if len(members) != 1:
+            raise ValueError(f'expected exactly one {SOURCE_MEMBER}')
+        extracted = archive.extractfile(members[0])
+        if extracted is None:
+            raise ValueError(f'unreadable source member: {SOURCE_MEMBER}')
+        member_bytes = extracted.read()
+    lines = member_bytes.decode('utf-8').splitlines()
+    texts = {name: '\n'.join(lines[start - 1:end]) + '\n' for name, (start, end, _) in SOURCE_BLOCKS.items()}
+    hashes = {name: hashlib.sha256(text.encode()).hexdigest() for name, text in texts.items()}
+    expected = {name: value for name, (_, _, value) in SOURCE_BLOCKS.items()}
+    checks = {'archive_hash_matches': _sha256(SOURCE_ARCHIVE) == SOURCE_ARCHIVE_SHA256, 'member_hash_matches': hashlib.sha256(member_bytes).hexdigest() == SOURCE_MEMBER_SHA256, 'source_blocks_match': hashes == expected, 'normalization_condition_present': texts['kernel_normalization_and_homogeneity'].count('\\label{equ:ft-cond}') == 1, 'kernel_declared_arbitrary': texts['kernel_normalization_and_homogeneity'].count('arbitrary function') == 1, 'single_integrated_kernel_in_displayed_ope': texts['two_particle_ope_weight'].count('\\int_0^{1}dt\\tilde{f}') == 1, 'quadratic_weight_present': texts['two_particle_ope_weight'].count('t(1-t)') == 2}
+    return {'block_hashes': hashes, 'checks': checks}
+
+def signed_kernel(parameter: sp.Expr, variable: sp.Symbol) -> sp.Expr:
+    return 1 + sp.sympify(parameter) * (6 * variable * (1 - variable) - 1)
+
+def kernel_normalization(kernel: sp.Expr, variable: sp.Symbol) -> sp.Expr:
+    return sp.simplify(sp.integrate(kernel, (variable, 0, 1)))
+
+def kernel_moment(kernel: sp.Expr, variable: sp.Symbol) -> sp.Expr:
+    return sp.simplify(sp.integrate(kernel * variable * (1 - variable), (variable, 0, 1)))
+
+def atomic_moment(points: Sequence[sp.Expr], weights: Sequence[sp.Expr]) -> dict[str, Any]:
+    if len(points) != len(weights):
+        raise ValueError('points and weights must have equal length')
+    ps = [sp.sympify(value) for value in points]
+    ws = [sp.sympify(value) for value in weights]
+    normalization = sp.simplify(sum(ws))
+    moment = sp.simplify(sum((weight * point * (1 - point) for point, weight in zip(ps, ws))))
+    centered_second = sp.simplify(sum((weight * (point - sp.Rational(1, 2)) ** 2 for point, weight in zip(ps, ws))))
+    return {'points': ps, 'weights': ws, 'normalization': normalization, 'moment': moment, 'centered_second': centered_second, 'variance_identity': moment == sp.Rational(1, 4) - centered_second, 'positive_probability': normalization == 1 and all((weight >= 0 for weight in ws)) and all((0 <= point <= 1 for point in ps))}
+
+def certificate_witnesses() -> dict[str, Any]:
+    t = sp.Symbol('t', real=True)
+    parameter_values = [sp.Rational(-90), sp.Rational(-30), sp.S.Zero, sp.Rational(30), sp.Rational(90)]
+    signed_rows = []
+    for parameter in parameter_values:
+        kernel = signed_kernel(parameter, t)
+        signed_rows.append({'parameter': parameter, 'normalization': kernel_normalization(kernel, t), 'moment': kernel_moment(kernel, t), 'expected_moment': sp.Rational(1, 6) + parameter / 30})
+    atomic_rows = [atomic_moment([0], [1]), atomic_moment([sp.Rational(1, 2)], [1]), atomic_moment([sp.Rational(1, 4), sp.Rational(3, 4)], [sp.Rational(1, 2), sp.Rational(1, 2)]), atomic_moment([0, sp.Rational(1, 3), 1], [sp.Rational(1, 5), sp.Rational(3, 5), sp.Rational(1, 5)])]
+    symmetric_rows = []
+    for distance in (sp.S.Zero, sp.Rational(1, 10), sp.Rational(1, 4), sp.Rational(1, 2)):
+        row = atomic_moment([sp.Rational(1, 2) - distance, sp.Rational(1, 2) + distance], [sp.Rational(1, 2), sp.Rational(1, 2)])
+        row['distance'] = distance
+        symmetric_rows.append(row)
+    parameter = sp.Symbol('A', real=True)
+    symbolic_kernel = signed_kernel(parameter, t)
+    return {'signed_normalized_family': signed_rows, 'positive_atomic_measures': atomic_rows, 'symmetric_energy_shares': symmetric_rows, 'symbolic_normalization': kernel_normalization(symbolic_kernel, t), 'symbolic_moment': kernel_moment(symbolic_kernel, t), 'positive_bound_polynomial_residual': sp.expand(t * (1 - t) - (sp.Rational(1, 4) - (t - sp.Rational(1, 2)) ** 2)), 'signed_family_positive_slope': sp.diff(kernel_moment(symbolic_kernel, t), parameter)}
+
+def build_exact_result() -> dict[str, Any]:
+    source = _source_evidence()
+    witnesses = certificate_witnesses()
+    signed = witnesses['signed_normalized_family']
+    positive = witnesses['positive_atomic_measures']
+    symmetric = witnesses['symmetric_energy_shares']
+    checks = dict(source['checks'])
+    checks.update({'signed_family_normalized_exactly': all((row['normalization'] == 1 for row in signed)), 'signed_family_moment_formula_exact': all((row['moment'] == row['expected_moment'] for row in signed)), 'normalization_alone_unbounded': witnesses['symbolic_normalization'] == 1 and witnesses['signed_family_positive_slope'] == sp.Rational(1, 30), 'variance_identity_polynomial_exact': witnesses['positive_bound_polynomial_residual'] == 0, 'positive_witnesses_inside_sharp_interval': all((row['positive_probability'] and 0 <= row['moment'] <= sp.Rational(1, 4) for row in positive)), 'sharp_endpoints_attained': positive[0]['moment'] == 0 and positive[1]['moment'] == sp.Rational(1, 4), 'symmetric_variance_identity_exact': all((row['variance_identity'] and row['moment'] == sp.Rational(1, 4) - row['distance'] ** 2 for row in symmetric))})
+    return {'result_version': 'sabrina_two_particle_kernel_variance_v1', 'status': 'complete' if all(checks.values()) else 'failed', 'paper': {'arxiv_id': '2402.18798', 'title': 'Multiparticle Contributions to the Celestial OPE'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'ambiguity_collapse': 'the displayed two-particle OPE weight depends on the arbitrary normalized kernel only through M[f]=integral f(t)t(1-t)dt', 'variance_identity': 'M[f]=1/4-integral f(t)(t-1/2)^2dt', 'conditional_sharp_bound': 'if f is a nonnegative normalized measure on [0,1], then 0<=M[f]<=1/4, with endpoint and equal-sharing extremizers', 'normalization_only_obstruction': 'the signed normalized family f_A=1+A(6t(1-t)-1) has M=1/6+A/30, so normalization alone gives no bound'}, 'certificate_witnesses': witnesses, 'exact_checks': checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'physical_kernel_positivity_proved': False, 'kernel_uniqueness_proved': False, 'higher_ope_functionals_classified': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
+
+def _jsonable(value: Any) -> Any:
+    if isinstance(value, dict):
+        return {key: _jsonable(item) for key, item in value.items()}
+    if isinstance(value, (list, tuple)):
+        return [_jsonable(item) for item in value]
+    if isinstance(value, sp.Basic):
+        return str(value)
+    return value
+
+def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
+    if out_dir.exists():
+        raise FileExistsError(f'immutable result target already exists: {out_dir}')
+    out_dir.mkdir(parents=True)
+    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
+    report = _jsonable(build_exact_result() | {'generated_utc': generated})
+    report_path = out_dir / 'two_particle_kernel_variance_report.json'
+    witness_path = out_dir / 'two_particle_kernel_variance_witnesses.json'
+    handoff_path = out_dir / 'TWO_PARTICLE_KERNEL_VARIANCE_PRIVATE_HANDOFF.md'
+    manifest_path = out_dir / 'receipt_manifest.json'
+    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    witness_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'certificate_witnesses', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    handoff_path.write_text('# Two-particle kernel variance theorem - private handoff\n\nThe arbitrary normalized energy-sharing kernel in the displayed two-particle OPE coefficient enters only through one quadratic moment. If the kernel is a positive probability measure, that moment is one quarter minus its centered second moment and lies sharply between zero and one quarter. Normalization alone gives no bound, as an exact signed polynomial family demonstrates. Positivity of the physical kernel is not established here.\n', encoding='utf-8')
+    artifacts = [report_path, witness_path, handoff_path]
+    expected = {name: value for name, (_, _, value) in SOURCE_BLOCKS.items()}
+    manifest = {'manifest_version': 'sabrina_two_particle_kernel_variance_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, **expected}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    all_artifacts = [*artifacts, manifest_path]
+    ledger: Mapping[str, Any] = {'status': 'skipped'}
+    if register_ledger:
+        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
+    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
+
+def main(argv: Sequence[str] | None=None) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
+    parser.add_argument('--no-register-crystal-ledger', action='store_true')
+    args = parser.parse_args(argv)
+    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
+    print(json.dumps(result, sort_keys=True))
+    return 0 if result['status'] == 'complete' else 1
+if __name__ == '__main__':
+    raise SystemExit(main())
diff --git a/ouroboros_replay/kernels/run_sabrina_weyl_double_copy_shadow_involution.py b/ouroboros_replay/kernels/run_sabrina_weyl_double_copy_shadow_involution.py
new file mode 100644
index 0000000000000000000000000000000000000000..cf3b66af4f1b7eac26ea4eb5bc2edc0c9d63b4bf
--- /dev/null
+++ b/ouroboros_replay/kernels/run_sabrina_weyl_double_copy_shadow_involution.py
@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+from ..source_runtime import fixture_path, source_path
+import argparse
+import hashlib
+import json
+import tarfile
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Mapping, Sequence
+import sympy as sp
+from .crystal_ledger import register_crystal_artifacts
+OUT_DIR = Path('.replay_outputs') / 'out_dir'
+LEDGER_DIR = Path('.replay_outputs') / 'ledger_dir'
+SOURCE_ARCHIVE = source_path('ff00948d397a3aaaa36cec9a65f63477b16c6315c982669e63259b0a8961fc46')
+SOURCE_MEMBER = 'shifting_spin.tex'
+SOURCE_ARCHIVE_SHA256 = 'ff00948d397a3aaaa36cec9a65f63477b16c6315c982669e63259b0a8961fc46'
+SOURCE_MEMBER_SHA256 = '17ed9a4bf99bf5a3a53a11d7da5c3000c4b99db7688432072e6703a597671794'
+SOURCE_BLOCKS = {'primary_shadow_curvatures': (819, 842, '8acb82a9be540c4a2d8eead0630fbcb8fe0c15fcbd76c81abfa1fadfcebe7a80'), 'weyl_double_copy_definition': (845, 877, '5cbf0c6d34e0ca8ba5607901422b27778f4b6c966fb2dae1468294d2fa0dbed4'), 'weyl_double_copy_table': (878, 910, '774c827ab158f3d9fbae9dbc062ceb3638202c3dc36940d488f19f968db13490')}
+PLAN_RECEIPT_SHA256 = '6d3732302a9769764541b1edd79fde10fdbda03dca4ed770466a49d5108a9078'
+PLAN_GUARD_SHA256 = 'a4c0c20b1de0c3d9150daf35702af592835b39f53ea642a2275368ebdc227b43'
+PLAN_VERIFIER_SHA256 = '0c65d152a8094760791a153742bca37a4860d76f97e3ced4f95c06faa34cf059'
+
+def _sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+def _source_evidence() -> dict[str, Any]:
+    with tarfile.open(SOURCE_ARCHIVE, 'r:*') as archive:
+        extracted = archive.extractfile(SOURCE_MEMBER)
+        if extracted is None:
+            raise ValueError(f'unreadable source member: {SOURCE_MEMBER}')
+        member_bytes = extracted.read()
+    lines = member_bytes.decode('utf-8').splitlines()
+    texts = {name: '\n'.join(lines[start - 1:end]) + '\n' for name, (start, end, _) in SOURCE_BLOCKS.items()}
+    hashes = {name: hashlib.sha256(text.encode()).hexdigest() for name, text in texts.items()}
+    expected = {name: value for name, (_, _, value) in SOURCE_BLOCKS.items()}
+    checks = {'archive_hash_matches': _sha256(SOURCE_ARCHIVE) == SOURCE_ARCHIVE_SHA256, 'member_hash_matches': hashlib.sha256(member_bytes).hexdigest() == SOURCE_MEMBER_SHA256, 'source_blocks_match': hashes == expected, 'primary_shadow_curvatures_present': all((marker in texts['primary_shadow_curvatures'] for marker in ('\\label{KSFieldStrength0}', '\\label{KSRiemann0}', '\\label{SHKSFieldStrength0}', '\\label{SHKSRiemann0}'))), 'weyl_double_copy_definition_present': 'C_{abcd}=\\frac{1}{S}f_{(ab}f_{cd)}' in texts['weyl_double_copy_definition'], 'coefficient_table_present': all((marker in texts['weyl_double_copy_table'] for marker in ('-2\\frac{\\Delta-1}{\\Delta}', '-2\\frac{\\Delta-1}{\\Delta-2}', '\\label{tab:WeylDC}')))}
+    return {'block_hashes': hashes, 'checks': checks}
+
+def coefficient_set(delta: Any) -> dict[str, Any]:
+    gauge_primary = delta - 1
+    gauge_shadow = 1 - delta
+    scalar_primary = -2 * (delta - 1) / delta
+    scalar_shadow = -2 * (delta - 1) / (delta - 2)
+    weyl_primary = sp.cancel(gauge_primary ** 2 / scalar_primary)
+    weyl_shadow = sp.cancel(gauge_shadow ** 2 / scalar_shadow)
+    return {'gauge_primary': gauge_primary, 'gauge_shadow': gauge_shadow, 'scalar_primary': scalar_primary, 'scalar_shadow': scalar_shadow, 'weyl_primary': weyl_primary, 'weyl_shadow': weyl_shadow}
+
+def involution_certificate() -> dict[str, Any]:
+    delta = sp.symbols('Delta')
+    tau = 2 - delta
+    coefficients = coefficient_set(delta)
+    transformed = coefficient_set(tau)
+    checks = {'tau_squared_identity': bool(sp.simplify(2 - tau - delta) == 0), 'gauge_pair_exchanged': bool(sp.simplify(transformed['gauge_primary'] - coefficients['gauge_shadow']) == 0 and sp.simplify(transformed['gauge_shadow'] - coefficients['gauge_primary']) == 0), 'scalar_pair_exchanged': bool(sp.simplify(transformed['scalar_primary'] - coefficients['scalar_shadow']) == 0 and sp.simplify(transformed['scalar_shadow'] - coefficients['scalar_primary']) == 0), 'weyl_pair_exchanged': bool(sp.simplify(transformed['weyl_primary'] - coefficients['weyl_shadow']) == 0 and sp.simplify(transformed['weyl_shadow'] - coefficients['weyl_primary']) == 0), 'primary_double_copy_exact': bool(sp.simplify(coefficients['weyl_primary'] - coefficients['gauge_primary'] ** 2 / coefficients['scalar_primary']) == 0), 'shadow_double_copy_exact': bool(sp.simplify(coefficients['weyl_shadow'] - coefficients['gauge_shadow'] ** 2 / coefficients['scalar_shadow']) == 0), 'source_primary_weyl_exact': bool(sp.simplify(coefficients['weyl_primary'] + delta * (delta - 1) / 2) == 0), 'source_shadow_weyl_exact': bool(sp.simplify(coefficients['weyl_shadow'] + (delta - 1) * (delta - 2) / 2) == 0)}
+    return {'tau': '2-Delta', 'coefficients': {key: str(sp.cancel(value)) for key, value in coefficients.items()}, 'checks': checks}
+
+def singularity_certificate() -> dict[str, Any]:
+    delta = sp.symbols('Delta')
+    c = coefficient_set(delta)
+    return {'scalar_primary': {'zero': 'Delta=1', 'pole': 'Delta=0'}, 'scalar_shadow': {'zero': 'Delta=1', 'pole': 'Delta=2'}, 'weyl_primary_zeros': [0, 1], 'weyl_shadow_zeros': [1, 2], 'self_shadow_point': 1, 'unreduced_quotient_at_self_shadow': '0/0', 'reduced_primary_limit': str(sp.limit(c['weyl_primary'], delta, 1)), 'reduced_shadow_limit': str(sp.limit(c['weyl_shadow'], delta, 1)), 'pole_exchange_exact': 2 - 0 == 2 and 2 - 2 == 0, 'fixed_zero_exact': 2 - 1 == 1, 'removable_limits_exact': sp.limit(c['weyl_primary'], delta, 1) == sp.limit(c['weyl_shadow'], delta, 1) == 0}
+
+def build_exact_result() -> dict[str, Any]:
+    source = _source_evidence()
+    involution = involution_certificate()
+    singularities = singularity_certificate()
+    checks = dict(source['checks'])
+    checks.update(involution['checks'])
+    checks.update({'pole_exchange_exact': singularities['pole_exchange_exact'], 'fixed_zero_exact': singularities['fixed_zero_exact'], 'removable_self_shadow_limits_exact': singularities['removable_limits_exact']})
+    return {'result_version': 'sabrina_weyl_double_copy_shadow_involution_v1', 'status': 'complete' if all(checks.values()) else 'failed', 'paper': {'arxiv_id': '2012.15694', 'title': 'Shifting Spin on the Celestial Sphere'}, 'source_evidence': {'archive_sha256': SOURCE_ARCHIVE_SHA256, 'member_sha256': SOURCE_MEMBER_SHA256, **source}, 'theorem': {'involution': 'tau(Delta)=2-Delta exchanges the stripped primary and shadow gauge, scalar, and Weyl double-copy coefficients', 'double_copy_equivariance': 'C_P=f_P^2/S_P and C_S=f_S^2/S_S are preserved under tau', 'divisor_exchange': 'the scalar prefactor poles Delta=0 and Delta=2 are exchanged, while Delta=1 is fixed', 'self_shadow_boundary': 'at Delta=1 the unreduced f^2/S quotient is 0/0; its reduced primary and shadow limits both equal zero'}, 'scope': {'universal_shadow_spacetime_factor_stripped': '2/X^2', 'chirality_exchange_applied': True, 'coefficient_level_only': True}, 'involution_certificate': involution, 'singularity_certificate': singularities, 'exact_checks': checks, 'authority': {'plan_receipt_sha256': PLAN_RECEIPT_SHA256, 'plan_guard_sha256': PLAN_GUARD_SHA256, 'plan_verifier_sha256': PLAN_VERIFIER_SHA256}, 'claim_boundary': {'full_shadow_kernel_normalization_claimed': False, 'interacting_double_copy_claimed': False, 'singular_state_physics_claimed': False, 'naive_self_shadow_substitution_allowed': False, 'publication_allowed': False, 'private_shadow_only': True, 'capabilities_removed': []}}
+
+def write_package(out_dir: Path, *, register_ledger: bool) -> dict[str, Any]:
+    if out_dir.exists():
+        raise FileExistsError(f'immutable result target already exists: {out_dir}')
+    out_dir.mkdir(parents=True)
+    generated = datetime.now(timezone.utc).isoformat(timespec='seconds')
+    report = build_exact_result() | {'generated_utc': generated}
+    report_path = out_dir / 'weyl_double_copy_shadow_involution_report.json'
+    witness_path = out_dir / 'weyl_double_copy_shadow_involution_witnesses.json'
+    handoff_path = out_dir / 'WEYL_DOUBLE_COPY_SHADOW_INVOLUTION_PRIVATE_HANDOFF.md'
+    manifest_path = out_dir / 'receipt_manifest.json'
+    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    witness_path.write_text(json.dumps({key: report[key] for key in ('theorem', 'scope', 'involution_certificate', 'singularity_certificate', 'exact_checks', 'claim_boundary')}, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    handoff_path.write_text('# Weyl double-copy shadow involution - private handoff\n\nAfter stripping the universal shadow spacetime factor and exchanging chirality, the complete gauge/scalar/Weyl coefficient triple is equivariant under Delta -> 2-Delta. The poles at 0 and 2 exchange, Delta=1 is fixed, and the unreduced quotient there is a removable 0/0 rather than a valid direct substitution. No full shadow-kernel, interacting-double-copy, singular-state, or publication claim is made.\n', encoding='utf-8')
+    artifacts = [report_path, witness_path, handoff_path]
+    manifest = {'manifest_version': 'sabrina_weyl_double_copy_shadow_involution_manifest_v1', 'generated_utc': generated, 'artifact_hashes': {path.name: _sha256(path) for path in artifacts}, 'source_hashes': {SOURCE_ARCHIVE.name: SOURCE_ARCHIVE_SHA256, SOURCE_MEMBER: SOURCE_MEMBER_SHA256, **{name: value for name, (_, _, value) in SOURCE_BLOCKS.items()}}, 'authority': report['authority'], 'status': report['status'], 'public_actions_allowed': False, 'shadow_only': True}
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + '\n', encoding='utf-8')
+    all_artifacts = [*artifacts, manifest_path]
+    ledger: Mapping[str, Any] = {'status': 'skipped'}
+    if register_ledger:
+        ledger = register_crystal_artifacts(all_artifacts, run_family='sabrina_pasterski_research_program', run_name=out_dir.name, manifest_path=manifest_path, generated_utc=generated, latest_dir=LEDGER_DIR)
+    return {'status': report['status'], 'artifact_count': len(all_artifacts), 'manifest_sha256': _sha256(manifest_path), 'ledger_status': ledger.get('status')}
+
+def main(argv: Sequence[str] | None=None) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--out-dir', type=Path, default=OUT_DIR)
+    parser.add_argument('--no-register-crystal-ledger', action='store_true')
+    args = parser.parse_args(argv)
+    result = write_package(args.out_dir, register_ledger=not args.no_register_crystal_ledger)
+    print(json.dumps(result, sort_keys=True))
+    return 0 if result['status'] == 'complete' else 1
+if __name__ == '__main__':
+    raise SystemExit(main())
diff --git a/ouroboros_replay/replay.py b/ouroboros_replay/replay.py
new file mode 100644
index 0000000000000000000000000000000000000000..4f985d141c31a1c2903ce570243a922ea9300382
--- /dev/null
+++ b/ouroboros_replay/replay.py
@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+import hashlib
+import importlib
+import inspect
+import json
+from pathlib import Path
+from typing import Any, Mapping
+
+from .source_runtime import fetch_all, source_path, verify_source
+
+KERNEL_NAMES = ["run_sabrina_ads_radiation_spectral_commutator","run_sabrina_ads_two_interval_scattering_feasibility","run_sabrina_all_even_d_ward_normalization","run_sabrina_all_m_transverse_nonlocality_chain","run_sabrina_ambidextrous_integer_prefactor_lattice","run_sabrina_boundary_soft_scale_cocycle","run_sabrina_carrollian_celestial_weyl_intertwiner","run_sabrina_carrollian_conglomerate_kernel_stratification","run_sabrina_causal_interior_inclusion_lemma","run_sabrina_cdqs_amplification_singleton_obstruction","run_sabrina_cdqs_fidelity_envelope_strengthening","run_sabrina_celestial_circle_convex_hull_certificate","run_sabrina_celestial_eikonal_logarithm_gauge","run_sabrina_celestial_euclidean_monodromy_cancellation","run_sabrina_celestial_momentum_rising_factorial","run_sabrina_celestial_recursion_pde_generating_function","run_sabrina_coulomb_branch_complexity_ratio","run_sabrina_detector_sum_identity_correction","run_sabrina_electromagnetic_memory_detector_tradeoff","run_sabrina_entanglement_scattering_slack_identity","run_sabrina_flat_boundary_corner_rank_drop","run_sabrina_inverted_mellin_equivalence","run_sabrina_late_time_three_cut_null_test","run_sabrina_late_time_two_cut_reconstruction","run_sabrina_logarithmic_mellin_pole_order_correction","run_sabrina_low_hard_generator_nonclosure","run_sabrina_m3_unclassified_module_construction","run_sabrina_multiparticle_beta_residue_factor_two","run_sabrina_near_extremal_radial_pushforward","run_sabrina_p4_spherical_entanglement_expansion","run_sabrina_p4_spherical_refined_entropy","run_sabrina_points_scattering_lower_slack_identity","run_sabrina_principal_series_plancherel_factorization","run_sabrina_projective_mellin_scale_theorem","run_sabrina_projective_simplex_positivity_theorem","run_sabrina_projective_simplex_rank_theorem","run_sabrina_quadrupole_spin_memory_cap_duality","run_sabrina_radial_einstein_square_factorization","run_sabrina_rt_area_boundary_identity","run_sabrina_soft_charge_cumulant_hierarchy","run_sabrina_soft_charge_reduced_state_theorem","run_sabrina_soft_dressing_factor_two_no_go","run_sabrina_soft_mellin_residue_identity","run_sabrina_spin1_shadow_gauge_obstruction","run_sabrina_subleading_soft_gauge_defect_theorem","run_sabrina_super_bms_commutator_syzygy_family","run_sabrina_superrotation_charge_cancellation","run_sabrina_two_particle_kernel_variance","run_sabrina_weyl_double_copy_shadow_involution"]
+PRIVATE_KEYS = ['authority', 'generated_utc', 'local_cache_path', 'private_shadow_only', 'publication_allowed', 'shadow_only']
+
+def _project(value: Any) -> Any:
+    if isinstance(value, Mapping):
+        return {str(key): _project(child) for key, child in value.items() if str(key) not in PRIVATE_KEYS}
+    if isinstance(value, list):
+        return [_project(child) for child in value]
+    return value
+
+def _canonical_hash(value: Any) -> str:
+    payload = json.dumps(_project(value), sort_keys=True, separators=(",", ":"), ensure_ascii=False).encode("utf-8")
+    return hashlib.sha256(payload).hexdigest()
+
+def compute_all(output_dir: Path) -> dict:
+    output_dir.mkdir(parents=True, exist_ok=False)
+    rows = []
+    for name in KERNEL_NAMES:
+        module = importlib.import_module(f"ouroboros_replay.kernels.{name}")
+        result = module.build_exact_result()
+        if hasattr(module, "_jsonable"):
+            result = module._jsonable(result)
+        projected = _project(result)
+        target = output_dir / f"{name}.json"
+        target.write_text(json.dumps(projected, indent=2, sort_keys=True, ensure_ascii=False) + "\n", encoding="utf-8")
+        checks = projected.get("exact_checks", {})
+        false_checks = sorted(key for key, value in checks.items() if value is False) if isinstance(checks, dict) else ["missing"]
+        rows.append({"kernel": name, "scientific_payload_sha256": _canonical_hash(projected), "false_check_count": len(false_checks)})
+    receipt = {"schema": "ouroboros_clean_compute_receipt_v1", "kernel_count": len(rows), "all_exact_checks_passed": all(row["false_check_count"] == 0 for row in rows), "rows": rows}
+    (output_dir / "compute_receipt.json").write_text(json.dumps(receipt, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+    return receipt
+
+def compare_all(actual_dir: Path, reference_dir: Path) -> dict:
+    rows = []
+    for name in KERNEL_NAMES:
+        actual = json.loads((actual_dir / f"{name}.json").read_text(encoding="utf-8"))
+        reference = json.loads((reference_dir / f"{name}.json").read_text(encoding="utf-8"))
+        actual_hash = _canonical_hash(actual)
+        expected_hash = reference["scientific_payload_sha256"]
+        rows.append({"kernel": name, "actual_sha256": actual_hash, "expected_sha256": expected_hash, "matches": actual_hash == expected_hash})
+    receipt = {"schema": "ouroboros_post_compute_comparison_receipt_v1", "kernel_count": len(rows), "all_match": all(row["matches"] for row in rows), "rows": rows}
+    (actual_dir / "comparison_receipt.json").write_text(json.dumps(receipt, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+    return receipt
+
+def run_falsifiers(actual_dir: Path, reference_dir: Path, temporary_dir: Path) -> dict:
+    temporary_dir.mkdir(parents=True, exist_ok=False)
+    first_name = KERNEL_NAMES[0]
+    reference = json.loads((reference_dir / f"{first_name}.json").read_text(encoding="utf-8"))
+    mutated = json.loads((actual_dir / f"{first_name}.json").read_text(encoding="utf-8"))
+    mutated["__adversarial_mutation__"] = 1
+    result_mutation_rejected = _canonical_hash(mutated) != reference["scientific_payload_sha256"]
+    from . import source_runtime
+    first_source = source_runtime._load_lock()["sources"][0]
+    original = source_path(first_source["sha256"]).read_bytes()
+    corrupted_path = temporary_dir / "corrupted.source"
+    corrupted_path.write_bytes(bytes([original[0] ^ 1]) + original[1:])
+    source_corruption_rejected = False
+    try:
+        verify_source(corrupted_path, first_source["sha256"])
+    except RuntimeError:
+        source_corruption_rejected = True
+    compute_source = inspect.getsource(compute_all)
+    expected_answer_isolation = "reference" not in compute_source.lower() and "expected" not in compute_source.lower()
+    receipt = {
+        "schema": "ouroboros_replay_falsifier_receipt_v1",
+        "result_mutation_rejected": result_mutation_rejected,
+        "source_corruption_rejected": source_corruption_rejected,
+        "expected_answer_isolation": expected_answer_isolation,
+    }
+    receipt["all_falsifiers_passed"] = all(receipt[key] is True for key in ("result_mutation_rejected", "source_corruption_rejected", "expected_answer_isolation"))
+    (temporary_dir / "falsifier_receipt.json").write_text(json.dumps(receipt, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+    return receipt
diff --git a/ouroboros_replay/source_runtime.py b/ouroboros_replay/source_runtime.py
new file mode 100644
index 0000000000000000000000000000000000000000..a7451527edb8b8d538588e489f6312523494eae7
--- /dev/null
+++ b/ouroboros_replay/source_runtime.py
@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import time
+import urllib.request
+from pathlib import Path
+
+PACKAGE_ROOT = Path(__file__).resolve().parents[1]
+LOCK_PATH = PACKAGE_ROOT / "data" / "sources.lock.json"
+
+def _load_lock() -> dict:
+    return json.loads(LOCK_PATH.read_text(encoding="utf-8"))
+
+def cache_root() -> Path:
+    override = os.environ.get("OUROBOROS_SOURCE_CACHE", "").strip()
+    return Path(override).expanduser().resolve() if override else Path.home() / ".cache" / "ouroboros-pasterski-v1" / "sources"
+
+def _sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+def _entry(expected_sha: str) -> dict:
+    for item in _load_lock()["sources"]:
+        if item["sha256"] == expected_sha:
+            return item
+    raise KeyError(f"source hash not present in lock: {expected_sha}")
+
+def verify_source(path: Path, expected_sha: str) -> Path:
+    actual = _sha256(path)
+    if actual != expected_sha:
+        raise RuntimeError(f"public source SHA mismatch: expected {expected_sha}, got {actual}")
+    return path
+
+def fetch_source(expected_sha: str, *, pause_seconds: float = 1.0) -> Path:
+    entry = _entry(expected_sha)
+    root = cache_root()
+    root.mkdir(parents=True, exist_ok=True)
+    target = root / f"{expected_sha}.source"
+    if target.is_file():
+        return verify_source(target, expected_sha)
+    errors = []
+    for url in entry["urls"]:
+        try:
+            request = urllib.request.Request(url, headers={"User-Agent": "Ouroboros-Pasterski-Replay/1.0 reproducibility@example.invalid"})
+            with urllib.request.urlopen(request, timeout=90) as response:
+                payload = response.read()
+            if hashlib.sha256(payload).hexdigest() != expected_sha:
+                errors.append("hash_mismatch")
+                continue
+            temporary = target.with_suffix(".partial")
+            temporary.write_bytes(payload)
+            os.replace(temporary, target)
+            time.sleep(max(0.0, pause_seconds))
+            return target
+        except Exception as exc:
+            errors.append(type(exc).__name__)
+    raise RuntimeError(f"unable to fetch SHA-pinned public source {entry['arxiv_id']}: {','.join(errors)}")
+
+def source_path(expected_sha: str) -> Path:
+    target = cache_root() / f"{expected_sha}.source"
+    if not target.is_file():
+        raise FileNotFoundError("public source cache is empty; run `python -m ouroboros_replay fetch` first")
+    return verify_source(target, expected_sha)
+
+def fixture_path(expected_sha: str) -> Path:
+    target = PACKAGE_ROOT / "data" / "predecessors" / f"{expected_sha}.json"
+    return verify_source(target, expected_sha)
+
+def fetch_all(*, pause_seconds: float = 1.0) -> list[dict]:
+    rows = []
+    for entry in _load_lock()["sources"]:
+        path = fetch_source(entry["sha256"], pause_seconds=pause_seconds)
+        rows.append({"arxiv_id": entry["arxiv_id"], "sha256": entry["sha256"], "byte_count": path.stat().st_size, "verified": True})
+    return rows
diff --git a/receipt_manifest.json b/receipt_manifest.json
new file mode 100644
index 0000000000000000000000000000000000000000..1712a2ba770f86673497886ba5cdec20026062a8
--- /dev/null
+++ b/receipt_manifest.json
@@ -0,0 +1,735 @@
+{
+  "capabilities_removed": [],
+  "derivation_test_count": 49,
+  "effect_contract_sha256": "7db5ba5d3206b6c0f642a8ec317020db0b3ca25864faa5d0b98fb4ce2b644c18",
+  "files": {
+    "ATTRIBUTION_AND_USE.md": {
+      "byte_count": 1627,
+      "sha256": "8f6419c7ba5c96c72cc1e9a6f82b6878a5cafab02f3ee60529a9b32eff00d371"
+    },
+    "CITATION.cff": {
+      "byte_count": 431,
+      "sha256": "6f107f919ccd46c664910b45c9eb8d960b3f011217d3f69a489809e7148d5c53"
+    },
+    "COMPUTE_AND_TIMELINE.md": {
+      "byte_count": 1912,
+      "sha256": "119d6e59bd89fe32fc23c2c1cb0cfc814417c7b2acb8fbebaba69fd36bb20c8f"
+    },
+    "LICENSE-CODE": {
+      "byte_count": 645,
+      "sha256": "8ee85ac08fe9b81eee3d6bbbb71553efb11922ab2817269a77037d4e42fdca88"
+    },
+    "LICENSE-CONTENT": {
+      "byte_count": 475,
+      "sha256": "008eef494dd4d31edfe50835be059d69aa8ec78df750c2cb71391519bf0b6d0f"
+    },
+    "NOTICE": {
+      "byte_count": 578,
+      "sha256": "85d9a0580d975a776fe74e3cdb4a5a1de5226b427627f8ab148d71bf807dc628"
+    },
+    "PAPER.md": {
+      "byte_count": 33059,
+      "sha256": "0793b2b0c5fdb2b55ef4bb83ef2fbe3fa7fa4c872e881a0db36e03aec93ee640"
+    },
+    "PUBLICATION_PLAN.md": {
+      "byte_count": 1900,
+      "sha256": "ff0bf547dbc68e185278f00482541f87757fc40b98fc9c6dfa1542b6490c578b"
+    },
+    "README.md": {
+      "byte_count": 1260,
+      "sha256": "63834c9a69633a8eb9ed0274945dceb7906f6ab8e287c0a1465ffa26d96a69f2"
+    },
+    "REPLAY_STANDARD.md": {
+      "byte_count": 2055,
+      "sha256": "3e9ec23e742f89f5a196fb55f2d9402cc5c098575cb03bde17aab6b21b1b446c"
+    },
+    "RESULT_ATLAS.md": {
+      "byte_count": 35013,
+      "sha256": "7dd335943e2ee05b8f9cffee285006fd5c54d63c74bb6aafb2bf4a666d2b9a62"
+    },
+    "VALIDATION.md": {
+      "byte_count": 850,
+      "sha256": "d65f3915a2f8d4b9b27ec4d6cbe6b0a5f13fececd8005f5683ec5b4fd86b2331"
+    },
+    "data/campaign_metrics.json": {
+      "byte_count": 959,
+      "sha256": "5ebbd8605c7c29b387f38296e912bee683ccc523ae54fe9671f51c50626b59c3"
+    },
+    "data/predecessors/1dc9e0a600bc5ff235fe3721a8d9e42aa9dc984bb9665b67b26d859bd8d0cd7c.json": {
+      "byte_count": 1535,
+      "sha256": "1dc9e0a600bc5ff235fe3721a8d9e42aa9dc984bb9665b67b26d859bd8d0cd7c"
+    },
+    "data/predecessors/2efa95a60d8c51c17d04edca6b52ad9d3de837ac9ec1ac0b767631537f992576.json": {
+      "byte_count": 1538,
+      "sha256": "2efa95a60d8c51c17d04edca6b52ad9d3de837ac9ec1ac0b767631537f992576"
+    },
+    "data/predecessors/764f819b652785e2394101cf78d0463dc893379e30a80732430a2261b20269f7.json": {
+      "byte_count": 1244,
+      "sha256": "764f819b652785e2394101cf78d0463dc893379e30a80732430a2261b20269f7"
+    },
+    "data/predecessors/7d5e9dad93e63528aa697e9ec29d0b959f0efdf01b7539aafa7d85d1279a71e2.json": {
+      "byte_count": 1338,
+      "sha256": "7d5e9dad93e63528aa697e9ec29d0b959f0efdf01b7539aafa7d85d1279a71e2"
+    },
+    "data/predecessors/b2bc412ca67f7d1e2e2e8908a53f5f8ccf8ceff151fc751a1b08cd66ef1efade.json": {
+      "byte_count": 1614,
+      "sha256": "b2bc412ca67f7d1e2e2e8908a53f5f8ccf8ceff151fc751a1b08cd66ef1efade"
+    },
+    "data/registered_artifact_dispositions.json": {
+      "byte_count": 5030,
+      "sha256": "6338b79ea56950e9a70a9d45d863938ececf56ac48b99918e2475e92ac278ef1"
+    },
+    "data/result_catalog.json": {
+      "byte_count": 46854,
+      "sha256": "df6c81920c83ba2f9d330821252477a11db5d6c96cbef2f2822fc992c570408d"
+    },
+    "data/sources.lock.json": {
+      "byte_count": 15078,
+      "sha256": "4a85ca3a61f18f72ed3350262622cb4808ba2a82fb113d966d0d3e44f7f81de0"
+    },
+    "ouroboros_replay/__init__.py": {
+      "byte_count": 85,
+      "sha256": "c87fe66fb8f7bbbed03e7fb2f1395ad2896db04f43f14dc2e758ea8a48501916"
+    },
+    "ouroboros_replay/__main__.py": {
+      "byte_count": 1690,
+      "sha256": "1a9aa51b8a76e84a99ac39c794c817ffd576847c05dfc91d29f69dab3b9f40b5"
+    },
+    "ouroboros_replay/kernels/__init__.py": {
+      "byte_count": 50,
+      "sha256": "c82cbf4e38a41f6eb62989221ae4a98aefafd57f6414b7cebfe4307c3ff222aa"
+    },
+    "ouroboros_replay/kernels/crystal_ledger.py": {
+      "byte_count": 240,
+      "sha256": "ab1c5b86f8910ee471647207a44e5c679e261201320a64e16dbedb4a62a477a6"
+    },
+    "ouroboros_replay/kernels/run_sabrina_ads_radiation_spectral_commutator.py": {
+      "byte_count": 10685,
+      "sha256": "610d5b86a9550c88f620cb5f3902237d0fe05d1b20bfd84599d0e03f73d063a2"
+    },
+    "ouroboros_replay/kernels/run_sabrina_ads_two_interval_scattering_feasibility.py": {
+      "byte_count": 9866,
+      "sha256": "d24c1836d7b96438164f3fbad42d5fd5fcbf9a2e6bd972b8562ec6898435ced7"
+    },
+    "ouroboros_replay/kernels/run_sabrina_all_even_d_ward_normalization.py": {
+      "byte_count": 9947,
+      "sha256": "a25c44fcf68e245daddcbf8fd137f69f0693fdb960b8b86beebef04398ac378f"
+    },
+    "ouroboros_replay/kernels/run_sabrina_all_m_transverse_nonlocality_chain.py": {
+      "byte_count": 8056,
+      "sha256": "783b2c11c2670174b419fb1ade63864a565fca62888e718a9e082870653bbdf4"
+    },
+    "ouroboros_replay/kernels/run_sabrina_ambidextrous_integer_prefactor_lattice.py": {
+      "byte_count": 12016,
+      "sha256": "c9765bd187b30305cdc98911ee6255d1bf5d95503f131e7ea59cb85a00337d6e"
+    },
+    "ouroboros_replay/kernels/run_sabrina_boundary_soft_scale_cocycle.py": {
+      "byte_count": 10723,
+      "sha256": "6e866448ed99bc76851e77de031e874a58330bc6e9c51f9c0bfa00697fe11f8b"
+    },
+    "ouroboros_replay/kernels/run_sabrina_carrollian_celestial_weyl_intertwiner.py": {
+      "byte_count": 9448,
+      "sha256": "4dafc8b12496bd675463e19d4e6b9b95f1548a3dd87d9d0a2f201917f83d6ffd"
+    },
+    "ouroboros_replay/kernels/run_sabrina_carrollian_conglomerate_kernel_stratification.py": {
+      "byte_count": 10313,
+      "sha256": "e60ec22189081b123353a8337b250f1e04e71b5d66d581f00f6691263fa2dc35"
+    },
+    "ouroboros_replay/kernels/run_sabrina_causal_interior_inclusion_lemma.py": {
+      "byte_count": 10396,
+      "sha256": "c7f710d6692d2b4ba40589601027e05ada5fc1c035fac6031a1bf59bb8994377"
+    },
+    "ouroboros_replay/kernels/run_sabrina_cdqs_amplification_singleton_obstruction.py": {
+      "byte_count": 11358,
+      "sha256": "226addea08fbddf91e9f652f7123e24cad69b7a21d729c8f1b46222e9cdd1bc5"
+    },
+    "ouroboros_replay/kernels/run_sabrina_cdqs_fidelity_envelope_strengthening.py": {
+      "byte_count": 10261,
+      "sha256": "7fc4c8e278126948c6644a333c4b15c9993957034523a46b656321cbb72f558e"
+    },
+    "ouroboros_replay/kernels/run_sabrina_celestial_circle_convex_hull_certificate.py": {
+      "byte_count": 11157,
+      "sha256": "34814f39aad9eb9a0e7fbae2662a1d2cafd08fe03aef4fdfa413248d6cd377d5"
+    },
+    "ouroboros_replay/kernels/run_sabrina_celestial_eikonal_logarithm_gauge.py": {
+      "byte_count": 11799,
+      "sha256": "435275d9613ff8a108ad7194e25dfe416c4c9b7d10509d15766f2bae8b7cca0c"
+    },
+    "ouroboros_replay/kernels/run_sabrina_celestial_euclidean_monodromy_cancellation.py": {
+      "byte_count": 9877,
+      "sha256": "b3177670ccf03ec08714c06840e0eaa62e1b368a6cb1c979819516142887dd3b"
+    },
+    "ouroboros_replay/kernels/run_sabrina_celestial_momentum_rising_factorial.py": {
+      "byte_count": 10085,
+      "sha256": "a3769816e162334241307276e607a27f837acb20ee5a7b1a4250aef2bf67069a"
+    },
+    "ouroboros_replay/kernels/run_sabrina_celestial_recursion_pde_generating_function.py": {
+      "byte_count": 11323,
+      "sha256": "80d7dd6e85e807794f988c2fdbc97bc06bb5413d173701888c59447a97c95cbe"
+    },
+    "ouroboros_replay/kernels/run_sabrina_coulomb_branch_complexity_ratio.py": {
+      "byte_count": 8813,
+      "sha256": "32971518f283dba7e04403bf081baecbabc3d887addf0dea42587dbe66cc030e"
+    },
+    "ouroboros_replay/kernels/run_sabrina_detector_sum_identity_correction.py": {
+      "byte_count": 11520,
+      "sha256": "6beb07c2a7be18fe8f6fd41ece1239585af359bc517a556d74192e8e7cb73a4f"
+    },
+    "ouroboros_replay/kernels/run_sabrina_electromagnetic_memory_detector_tradeoff.py": {
+      "byte_count": 10770,
+      "sha256": "493952a611698fdf53ea4af8022f09a4cbe3c09a9797442f391a6f0082845139"
+    },
+    "ouroboros_replay/kernels/run_sabrina_entanglement_scattering_slack_identity.py": {
+      "byte_count": 10465,
+      "sha256": "d93cff0e699914fbf90217d1d4040ca4d8099c49d472c99df5b567fa12091e8a"
+    },
+    "ouroboros_replay/kernels/run_sabrina_flat_boundary_corner_rank_drop.py": {
+      "byte_count": 9123,
+      "sha256": "1ad9b453adc73f49df0f1297c62ceffa8b3ddbf378daf4aa5575edb75d7d51ec"
+    },
+    "ouroboros_replay/kernels/run_sabrina_inverted_mellin_equivalence.py": {
+      "byte_count": 9269,
+      "sha256": "1fbf95b988788565e8c4d7d1b9639ce877778ff9634d044b74de63a4ba09c11b"
+    },
+    "ouroboros_replay/kernels/run_sabrina_late_time_three_cut_null_test.py": {
+      "byte_count": 11170,
+      "sha256": "3c30d24c3d9a67eb097fe0d73b7f5f5e3566fe18fd673fa8c51e403e5ba1e3d5"
+    },
+    "ouroboros_replay/kernels/run_sabrina_late_time_two_cut_reconstruction.py": {
+      "byte_count": 11594,
+      "sha256": "98753e5cc5bae2abd09cf65d4ed0935ec48000108b19289a3cdec5a06d9d5418"
+    },
+    "ouroboros_replay/kernels/run_sabrina_logarithmic_mellin_pole_order_correction.py": {
+      "byte_count": 11103,
+      "sha256": "787d75ea30d4c32bfb934129028792af955d93d1c4a95390b65811be1a9f7223"
+    },
+    "ouroboros_replay/kernels/run_sabrina_low_hard_generator_nonclosure.py": {
+      "byte_count": 9640,
+      "sha256": "81819238587abb0f44f5d7aa981d4b804be530955f940c137727f9ced09aebd6"
+    },
+    "ouroboros_replay/kernels/run_sabrina_m3_unclassified_module_construction.py": {
+      "byte_count": 49417,
+      "sha256": "448d54c0f29a10aaea9dbce716e883eb17d033e860d711f3ec066a27caf5a447"
+    },
+    "ouroboros_replay/kernels/run_sabrina_multiparticle_beta_residue_factor_two.py": {
+      "byte_count": 10715,
+      "sha256": "5ad5e69bd978b2afe729cd14ef903fda1dccabd83c2c9abecba73ed646f3efea"
+    },
+    "ouroboros_replay/kernels/run_sabrina_near_extremal_radial_pushforward.py": {
+      "byte_count": 10003,
+      "sha256": "dc15513b8954fa9f82817e898b871961c1283d90988db344b41c3778c070c7a1"
+    },
+    "ouroboros_replay/kernels/run_sabrina_p4_spherical_entanglement_expansion.py": {
+      "byte_count": 11556,
+      "sha256": "e70041c8a0453f69e169f8d18f194622e193cc82869bd1690ae20d2ec07c6fff"
+    },
+    "ouroboros_replay/kernels/run_sabrina_p4_spherical_refined_entropy.py": {
+      "byte_count": 12518,
+      "sha256": "00d648db51ce9abffe0c3ac0d0f22b015fff736f7392161615e43426e4a29ec9"
+    },
+    "ouroboros_replay/kernels/run_sabrina_points_scattering_lower_slack_identity.py": {
+      "byte_count": 9957,
+      "sha256": "d7d8dfe02923013b251589c8f9fb2a0e6189223c19c29631d31e10bc0e622340"
+    },
+    "ouroboros_replay/kernels/run_sabrina_principal_series_plancherel_factorization.py": {
+      "byte_count": 11349,
+      "sha256": "140079e7c119236cb60c27c770f8905f699fb124ec420f7ad01b78d4343be745"
+    },
+    "ouroboros_replay/kernels/run_sabrina_projective_mellin_scale_theorem.py": {
+      "byte_count": 10762,
+      "sha256": "f4b3bf8cd3a731311951763a70ec61145a002aaea2b49d25b9e21bdb2ff1b717"
+    },
+    "ouroboros_replay/kernels/run_sabrina_projective_simplex_positivity_theorem.py": {
+      "byte_count": 11583,
+      "sha256": "2922a9c2bd563a3b16ddfe1c7855ac51231601eca9c8d9e59d9cb0bac7bd7e9b"
+    },
+    "ouroboros_replay/kernels/run_sabrina_projective_simplex_rank_theorem.py": {
+      "byte_count": 11929,
+      "sha256": "fa46d4d9276be53086e0abae6e825a05d8b791e7b85b33c6aa3a695cb7b8a92e"
+    },
+    "ouroboros_replay/kernels/run_sabrina_quadrupole_spin_memory_cap_duality.py": {
+      "byte_count": 8791,
+      "sha256": "6cfe4da63d182be18612dc7b64b4797f1347b8a00fa074bf0bf08f123f99b13e"
+    },
+    "ouroboros_replay/kernels/run_sabrina_radial_einstein_square_factorization.py": {
+      "byte_count": 8861,
+      "sha256": "f69dced9ae5587faf44336c4a634f9bac2d0cbe8d11fdc861d53db1723f7517f"
+    },
+    "ouroboros_replay/kernels/run_sabrina_rt_area_boundary_identity.py": {
+      "byte_count": 12476,
+      "sha256": "29f1e83d68dcf645697b7d0dd35e56fcc5ecdc8e3ffc515028f8954e2bc7a122"
+    },
+    "ouroboros_replay/kernels/run_sabrina_soft_charge_cumulant_hierarchy.py": {
+      "byte_count": 12479,
+      "sha256": "1139774f6f3f7f2b406ae6f76f84688cb6922e63c3c1aaa50ab3353b0aeb5be9"
+    },
+    "ouroboros_replay/kernels/run_sabrina_soft_charge_reduced_state_theorem.py": {
+      "byte_count": 10932,
+      "sha256": "08fb39fd25d77f2501336624054e3408cb193ae2731f505ffb2cb7d55296640c"
+    },
+    "ouroboros_replay/kernels/run_sabrina_soft_dressing_factor_two_no_go.py": {
+      "byte_count": 11593,
+      "sha256": "1b46438f209e2d5829d3a83af9c88ff9da50882a39ec87b9eb47f986ce983b2e"
+    },
+    "ouroboros_replay/kernels/run_sabrina_soft_mellin_residue_identity.py": {
+      "byte_count": 9558,
+      "sha256": "0e63acbf3a38d764829ef7c0be7f91bce322e3e22aedfc8f382ad371bdd4999e"
+    },
+    "ouroboros_replay/kernels/run_sabrina_spin1_shadow_gauge_obstruction.py": {
+      "byte_count": 9797,
+      "sha256": "2734f89ceab2090d52e1a2b1250a657436edabfcec8d8f80bfa4e2f42c9fa265"
+    },
+    "ouroboros_replay/kernels/run_sabrina_subleading_soft_gauge_defect_theorem.py": {
+      "byte_count": 9978,
+      "sha256": "3d670d89e5adead866e5a81a9dec8c5df7119a9f7477aaf503b3fadb42104a64"
+    },
+    "ouroboros_replay/kernels/run_sabrina_super_bms_commutator_syzygy_family.py": {
+      "byte_count": 10934,
+      "sha256": "dfff233dfa769bc82cd7f0b46cce78008cb4b054ed6881aa59acd9c135e575db"
+    },
+    "ouroboros_replay/kernels/run_sabrina_superrotation_charge_cancellation.py": {
+      "byte_count": 9098,
+      "sha256": "5541dd9cf059d3700a9f9e4f560276d7079fb36e5440fdace44a23e6f0a7b296"
+    },
+    "ouroboros_replay/kernels/run_sabrina_two_particle_kernel_variance.py": {
+      "byte_count": 11836,
+      "sha256": "90bd243f4032086bc4d4e3d4b873b7ade1010b9f9cd0a54ad82593c18d7ad9f8"
+    },
+    "ouroboros_replay/kernels/run_sabrina_weyl_double_copy_shadow_involution.py": {
+      "byte_count": 10760,
+      "sha256": "f694889d4f30f8e543e29f7fca23c48791349c865dc9768cb853a92bc4f14819"
+    },
+    "ouroboros_replay/replay.py": {
+      "byte_count": 7099,
+      "sha256": "7b3709edb23398ce2b292c1ab65bf6a32980e6d737128ed9868ed4252bb613b2"
+    },
+    "ouroboros_replay/source_runtime.py": {
+      "byte_count": 3256,
+      "sha256": "016ba1f9f90b7fe09ff3fb5431c960c5aad3bf8e643caf0de9a951d1d1a30f0d"
+    },
+    "references/run_sabrina_ads_radiation_spectral_commutator.json": {
+      "byte_count": 3804,
+      "sha256": "97324deeb2e3e841310a4f26132682939446689ce2b2dc4136c8529c38028400"
+    },
+    "references/run_sabrina_ads_two_interval_scattering_feasibility.json": {
+      "byte_count": 4828,
+      "sha256": "29589429f93ef3c3f7cc65b4c9625fbf575c7c1bea8533fdf6fce53bbbd7e9d9"
+    },
+    "references/run_sabrina_all_even_d_ward_normalization.json": {
+      "byte_count": 4975,
+      "sha256": "bcde65d049c67e4f6df2cc58261f786e533dd2efd81805a1cd12c389b71f13ef"
+    },
+    "references/run_sabrina_all_m_transverse_nonlocality_chain.json": {
+      "byte_count": 7906,
+      "sha256": "f77a40345bfa1bf7d807f61375f34a2fd0da3986d0a028f318013f20b20adbc0"
+    },
+    "references/run_sabrina_ambidextrous_integer_prefactor_lattice.json": {
+      "byte_count": 12945,
+      "sha256": "153413631d3b7db585827079dcd46684567cb08c1e685dec37cec409ce512969"
+    },
+    "references/run_sabrina_boundary_soft_scale_cocycle.json": {
+      "byte_count": 7376,
+      "sha256": "c1b766076b48754b3a9573c404ef23bc7a0c139c697d09448978e434c4e88a53"
+    },
+    "references/run_sabrina_carrollian_celestial_weyl_intertwiner.json": {
+      "byte_count": 8795,
+      "sha256": "56fb3389402fedfcf2f2f5af04298500a9552cc75798714d0c2dca7414598c0e"
+    },
+    "references/run_sabrina_carrollian_conglomerate_kernel_stratification.json": {
+      "byte_count": 3843,
+      "sha256": "748025ad2e08b6168af32d43ee6133042fa8061af60a9383a66b0bc09cd7408f"
+    },
+    "references/run_sabrina_causal_interior_inclusion_lemma.json": {
+      "byte_count": 3336,
+      "sha256": "0c07362e9524848346892e84d3af37094a488601e7a9bee1a3516c07655071f8"
+    },
+    "references/run_sabrina_cdqs_amplification_singleton_obstruction.json": {
+      "byte_count": 5522,
+      "sha256": "c70195f45168dab6c6e54781ac795e0413ea778732b4900994631c53fc7322ec"
+    },
+    "references/run_sabrina_cdqs_fidelity_envelope_strengthening.json": {
+      "byte_count": 4233,
+      "sha256": "4f817a3f3b5209dd2f24bbc5fff30e77e5007bb3c57a5a6b37e96f08a7128834"
+    },
+    "references/run_sabrina_celestial_circle_convex_hull_certificate.json": {
+      "byte_count": 3449,
+      "sha256": "308a76fa99866577fd83211a7765b4812dbf185c28ce23832b3a6942e5a94cc4"
+    },
+    "references/run_sabrina_celestial_eikonal_logarithm_gauge.json": {
+      "byte_count": 4467,
+      "sha256": "ae0d72704e18fbc8facfecc19e33f5553391ac37a3e3729fc177d01b8acb74ca"
+    },
+    "references/run_sabrina_celestial_euclidean_monodromy_cancellation.json": {
+      "byte_count": 5086,
+      "sha256": "37b2ffc86276c686681a4f9cfa42ef0164c9a07a44b39eb23bbc044e841f759f"
+    },
+    "references/run_sabrina_celestial_momentum_rising_factorial.json": {
+      "byte_count": 7765,
+      "sha256": "7dfc695b4c8a9e95a72544699d68901b73544d09d9db8f90bd05c418616cd5b1"
+    },
+    "references/run_sabrina_celestial_recursion_pde_generating_function.json": {
+      "byte_count": 10423,
+      "sha256": "6730fe3a01a9f8a7229233537b5ad3ff66360bf437d53e4ad853315d3674e729"
+    },
+    "references/run_sabrina_coulomb_branch_complexity_ratio.json": {
+      "byte_count": 3764,
+      "sha256": "966b4449afa2dbd3497146b2fa72e7f97cbef99453738100b61ef47721939a50"
+    },
+    "references/run_sabrina_detector_sum_identity_correction.json": {
+      "byte_count": 39115,
+      "sha256": "e195113f12bb13f8fef79b50562581a82fe67fdac9469a5a31f02b9fc1ed7e8f"
+    },
+    "references/run_sabrina_electromagnetic_memory_detector_tradeoff.json": {
+      "byte_count": 4249,
+      "sha256": "b3211f20f191360abd7625409946997dfdd0abc52790ab89ec1b9d40a6bab7a3"
+    },
+    "references/run_sabrina_entanglement_scattering_slack_identity.json": {
+      "byte_count": 5689,
+      "sha256": "c5dbdb8162e165d094c40f209e2ae64d0ba1736668bb331d2be38ec74dbfdb47"
+    },
+    "references/run_sabrina_flat_boundary_corner_rank_drop.json": {
+      "byte_count": 5223,
+      "sha256": "8f54323b09eb37b1b0d934a9fceaba8a838b6608dd352bbdb0d5ef453f43b0ef"
+    },
+    "references/run_sabrina_inverted_mellin_equivalence.json": {
+      "byte_count": 2874,
+      "sha256": "e301ec531e811d2d05b36f0728a45ae471b6ad98927a0af7be07b93227d38814"
+    },
+    "references/run_sabrina_late_time_three_cut_null_test.json": {
+      "byte_count": 15062,
+      "sha256": "044bcb2b1cd8b525b499f60f4b815ae8f256416fe3f369bbd6248d4842d0616a"
+    },
+    "references/run_sabrina_late_time_two_cut_reconstruction.json": {
+      "byte_count": 5850,
+      "sha256": "961df9bf9f921443e66bd70bedc7b6b97920b85dc64e636a5772c18fde58d21c"
+    },
+    "references/run_sabrina_logarithmic_mellin_pole_order_correction.json": {
+      "byte_count": 6826,
+      "sha256": "ebec67787070e860a5888041c2c0619149331d0d9794f5f8daeaae5a65a0e549"
+    },
+    "references/run_sabrina_low_hard_generator_nonclosure.json": {
+      "byte_count": 11625,
+      "sha256": "7ffab4a805288735007420a38500a463e15fc67dd3bec87cde71cecd03ce4fda"
+    },
+    "references/run_sabrina_m3_unclassified_module_construction.json": {
+      "byte_count": 4526,
+      "sha256": "9252f385adee164c9a9d502c3fb33e88d0ddcfa4edf986a7e33c57f1f716262f"
+    },
+    "references/run_sabrina_multiparticle_beta_residue_factor_two.json": {
+      "byte_count": 8687,
+      "sha256": "c80bdaf6c58bced4cbe2457dc958f5dcf52133d8f7ff5a631232d26f3924d55a"
+    },
+    "references/run_sabrina_near_extremal_radial_pushforward.json": {
+      "byte_count": 3948,
+      "sha256": "6530da913f53bc65547619e472ceeb98981a1805dbec1f6523c9d6e5d40ed019"
+    },
+    "references/run_sabrina_p4_spherical_entanglement_expansion.json": {
+      "byte_count": 3944,
+      "sha256": "a0da052c8533654755d3948beabf43e7cee499c0a2e7476b0dbb6094b75c5e0a"
+    },
+    "references/run_sabrina_p4_spherical_refined_entropy.json": {
+      "byte_count": 4431,
+      "sha256": "c5a1565f4ebcbe1ced094c299a99d9980fd63a2b0859b9d88963aeda7fd2efa6"
+    },
+    "references/run_sabrina_points_scattering_lower_slack_identity.json": {
+      "byte_count": 5439,
+      "sha256": "db9757ce914f5e1401f736a52e30deae08572a57c643994baf84c52c28277c2e"
+    },
+    "references/run_sabrina_principal_series_plancherel_factorization.json": {
+      "byte_count": 8597,
+      "sha256": "fd7f8ae5c04e15496f476cf9dcbd1af52387fe4504890a9c697fabf62a0958c5"
+    },
+    "references/run_sabrina_projective_mellin_scale_theorem.json": {
+      "byte_count": 33431,
+      "sha256": "25b4fea370c5ddc0694151bf70941a5005eb1dcf63c512ea286c337e5f5435ad"
+    },
+    "references/run_sabrina_projective_simplex_positivity_theorem.json": {
+      "byte_count": 17353,
+      "sha256": "c5e56e26170a1a1c7be1e198a3360e544ded2276b17f495c6d12802f90b0f048"
+    },
+    "references/run_sabrina_projective_simplex_rank_theorem.json": {
+      "byte_count": 25718,
+      "sha256": "2063f4ab610aefb5e727e846189745b8b7d542eb079354471a59eba045780b63"
+    },
+    "references/run_sabrina_quadrupole_spin_memory_cap_duality.json": {
+      "byte_count": 3551,
+      "sha256": "1c183db096308513768b3327f8336e952817f04e5333fab8b9f2bbaf111eea53"
+    },
+    "references/run_sabrina_radial_einstein_square_factorization.json": {
+      "byte_count": 3559,
+      "sha256": "9ccbdae84c4a234be443f617180553988e191c193d6c561da27145f2f79f48b8"
+    },
+    "references/run_sabrina_rt_area_boundary_identity.json": {
+      "byte_count": 5168,
+      "sha256": "5b0c2877b7d7c8703a373681fbe00f8bdab0bcd01af49c961d7fbc6441aef3ce"
+    },
+    "references/run_sabrina_soft_charge_cumulant_hierarchy.json": {
+      "byte_count": 39987,
+      "sha256": "37ed7c8258ab3e0bb3f4e99187e0318c564cfafe60fe9b1c9cb52ceb530e3ac3"
+    },
+    "references/run_sabrina_soft_charge_reduced_state_theorem.json": {
+      "byte_count": 5733,
+      "sha256": "9e9967edf06b8e5f23ab38ce51734be1e44a8f14675b18351f02ddf151a8f7f2"
+    },
+    "references/run_sabrina_soft_dressing_factor_two_no_go.json": {
+      "byte_count": 5209,
+      "sha256": "2f73821d109465571dc221a314ec2ac10c4d5a166679bdab4fbd66452b4e3af8"
+    },
+    "references/run_sabrina_soft_mellin_residue_identity.json": {
+      "byte_count": 6566,
+      "sha256": "4a371c492dbb522e0cd40ac88d1bc9aeb9a4b1cd3b75800bc7b2dbbf890295c6"
+    },
+    "references/run_sabrina_spin1_shadow_gauge_obstruction.json": {
+      "byte_count": 4923,
+      "sha256": "33286011dc6270a92ba9550da36a5b009a303f823a974f66fb2db6af530d34ea"
+    },
+    "references/run_sabrina_subleading_soft_gauge_defect_theorem.json": {
+      "byte_count": 6449,
+      "sha256": "f9d13579364ac3504be7b95cf68ef99d06e34c845bf98f05f7e5a65aa08e6463"
+    },
+    "references/run_sabrina_super_bms_commutator_syzygy_family.json": {
+      "byte_count": 7134,
+      "sha256": "e84ad5ec5ef4cc005b316da3239b9a9c765af02d5f546678ab924cb25a991fd3"
+    },
+    "references/run_sabrina_superrotation_charge_cancellation.json": {
+      "byte_count": 3404,
+      "sha256": "458c5eacb05731e3a2ce8c027ebf2ba08bc201b3d9ec5862fbdcb8d86763e944"
+    },
+    "references/run_sabrina_two_particle_kernel_variance.json": {
+      "byte_count": 6523,
+      "sha256": "0b288ccb12e05f5b12e56c146b7daeab3d1fff0ce369455956cd5ca8cd19fb1e"
+    },
+    "references/run_sabrina_weyl_double_copy_shadow_involution.json": {
+      "byte_count": 4290,
+      "sha256": "9bde79c41f304d9d0a7f89ee7b6b8d0a7fdaf8b707fde60cf67b4714ca0a0d00"
+    },
+    "reproducibility_evidence.json": {
+      "byte_count": 998,
+      "sha256": "ed7b399905b1f84960307d15cf948a55642a01049eaa4c9513c00966fb1a5d84"
+    },
+    "requirements.txt": {
+      "byte_count": 30,
+      "sha256": "d1ea45fbc8820a5d697a1fac87cba63ec92fc8f94541f5d4e2066b5eb69bb6cf"
+    },
+    "review/Ouroboros_Pasterski_Research_Program_PAUSED.pdf": {
+      "byte_count": 42802,
+      "sha256": "9d7ae4042c0aec6bf3b0661e0a9c420b74d17b383feb1e71c6489fd952850d08"
+    },
+    "tests/test_replay_boundaries.py": {
+      "byte_count": 442,
+      "sha256": "5640bebc463c8f10be9e8c5e20266b117f05919036b31600c59ee22e86e032d0"
+    },
+    "tests/test_sabrina_ads_radiation_spectral_commutator.py": {
+      "byte_count": 536,
+      "sha256": "1d72c4b8081b670c71c475cafb9325ce71a178e038b3a1280fde49248ba304dc"
+    },
+    "tests/test_sabrina_ads_two_interval_scattering_feasibility.py": {
+      "byte_count": 548,
+      "sha256": "ca415473d3a48ae06765d090126e7485bd23bcc569496e1f213abf9850ce01e4"
+    },
+    "tests/test_sabrina_all_even_d_ward_normalization.py": {
+      "byte_count": 528,
+      "sha256": "97743e510bfab2cc9f050a1b44a48a950ff5c1b813a3ede1650185ac8412c032"
+    },
+    "tests/test_sabrina_all_m_transverse_nonlocality_chain.py": {
+      "byte_count": 538,
+      "sha256": "f29477fe1f24343be53587ff6016f4a36db87c2c2fe31854b97b055619208b56"
+    },
+    "tests/test_sabrina_ambidextrous_integer_prefactor_lattice.py": {
+      "byte_count": 546,
+      "sha256": "f7ad13a7817f4e1747fc6ff7115fc8d9d3b54dfd151c994f383dc1f1e2bc9225"
+    },
+    "tests/test_sabrina_boundary_soft_scale_cocycle.py": {
+      "byte_count": 524,
+      "sha256": "13c52b4b6ea3801807219bd91bf2e70cdd42e7adb794ab2794d27372eab52d49"
+    },
+    "tests/test_sabrina_carrollian_celestial_weyl_intertwiner.py": {
+      "byte_count": 544,
+      "sha256": "1ee203da674e12a29b5e3ea318b41e022859097efeb3d02a2d8a778181bb21f4"
+    },
+    "tests/test_sabrina_carrollian_conglomerate_kernel_stratification.py": {
+      "byte_count": 560,
+      "sha256": "b930fb70ee9010e999a65d62887621d0924d8772a30c025579e3ef554e658db5"
+    },
+    "tests/test_sabrina_causal_interior_inclusion_lemma.py": {
+      "byte_count": 532,
+      "sha256": "c9be7098175bbcef58f9e1bc758573cc1cd7aa50bcc713352f358d5a0d65939f"
+    },
+    "tests/test_sabrina_cdqs_amplification_singleton_obstruction.py": {
+      "byte_count": 550,
+      "sha256": "e85ffe1a339fa169233e4053de952349929edf540fedc2a68f5b31d0a02978d3"
+    },
+    "tests/test_sabrina_cdqs_fidelity_envelope_strengthening.py": {
+      "byte_count": 542,
+      "sha256": "820134006ec5b65225cb66cb8a2372afc7e7c548101c29f7fc6d8a70809841e0"
+    },
+    "tests/test_sabrina_celestial_circle_convex_hull_certificate.py": {
+      "byte_count": 550,
+      "sha256": "b766d2046aa737bff923c6b1cccbf3818b668d9eb005f0a1d4724d2076723c7d"
+    },
+    "tests/test_sabrina_celestial_eikonal_logarithm_gauge.py": {
+      "byte_count": 536,
+      "sha256": "705178ed84ad5048922d19f0f5a131bb7b15e51b36d88978b7f1a7fe95a1a8bb"
+    },
+    "tests/test_sabrina_celestial_euclidean_monodromy_cancellation.py": {
+      "byte_count": 554,
+      "sha256": "e1baea51dfb70a10730629a5d094d45cae9445f7a30f910618bae3b88f80de32"
+    },
+    "tests/test_sabrina_celestial_momentum_rising_factorial.py": {
+      "byte_count": 540,
+      "sha256": "f1a14585bd913e218c3c6563ace94fa80da185d9d42066e657411581a0364868"
+    },
+    "tests/test_sabrina_celestial_recursion_pde_generating_function.py": {
+      "byte_count": 556,
+      "sha256": "edd1c9e96f0745173c68143e47e636605efcf879cea0a78a394b8ed265ee5670"
+    },
+    "tests/test_sabrina_coulomb_branch_complexity_ratio.py": {
+      "byte_count": 532,
+      "sha256": "d159faacfd1ca89df8990684a7553f11b69303d8895abfdc13467f1e16d57d8a"
+    },
+    "tests/test_sabrina_detector_sum_identity_correction.py": {
+      "byte_count": 534,
+      "sha256": "47ef00ab1987dc4cccba0a729abd0437b94478505e5c3b736c4b537baf7bfce1"
+    },
+    "tests/test_sabrina_electromagnetic_memory_detector_tradeoff.py": {
+      "byte_count": 550,
+      "sha256": "8c6f800c10f45c5905aa68d26281a1b0beb3d10b49a3fee41aa218f8b951d38b"
+    },
+    "tests/test_sabrina_entanglement_scattering_slack_identity.py": {
+      "byte_count": 546,
+      "sha256": "ebd224b75110823863745bfeaaf696e5fb0b2a608051641904e73a1d4d528fd2"
+    },
+    "tests/test_sabrina_flat_boundary_corner_rank_drop.py": {
+      "byte_count": 530,
+      "sha256": "e76b16b3c7b94e97a208234ca503f81fd6f494ab596d75f6c5b34c32e21329cf"
+    },
+    "tests/test_sabrina_inverted_mellin_equivalence.py": {
+      "byte_count": 524,
+      "sha256": "61ee55c8d18a89986cc087bf7409fb0c2b434cb0bba45bb41d81623cbf9b5009"
+    },
+    "tests/test_sabrina_late_time_three_cut_null_test.py": {
+      "byte_count": 528,
+      "sha256": "c20ac3d7cc47508884d6e625a9942107079c69239b8e8a3277221b328b1997b5"
+    },
+    "tests/test_sabrina_late_time_two_cut_reconstruction.py": {
+      "byte_count": 534,
+      "sha256": "7e18813301e2cb1cea78e46473086b0772fad3ae2933d75a57574f51656f9d25"
+    },
+    "tests/test_sabrina_logarithmic_mellin_pole_order_correction.py": {
+      "byte_count": 550,
+      "sha256": "ece1fe08ab69ceec0a0ebcd78901d1eaca4a94c11cad5a3dc725b7c3a21c07bb"
+    },
+    "tests/test_sabrina_low_hard_generator_nonclosure.py": {
+      "byte_count": 528,
+      "sha256": "30ff8bb58d551b840d89967048c101fa1df3b48f03a23d0aff2e00624fab4042"
+    },
+    "tests/test_sabrina_m3_unclassified_module_construction.py": {
+      "byte_count": 540,
+      "sha256": "2b21d0e6811259295732d1084c8275b4b73c1362358c5afe7a427c22e6bc5499"
+    },
+    "tests/test_sabrina_multiparticle_beta_residue_factor_two.py": {
+      "byte_count": 544,
+      "sha256": "d941064eff902b9d654629adf4fd6fd92a043c8a3cdf67f7f2a1c890785bfd76"
+    },
+    "tests/test_sabrina_near_extremal_radial_pushforward.py": {
+      "byte_count": 534,
+      "sha256": "436fb3a2f5695e29b5f362075f63c1cb0d9bce6a31181ec4c1d875de9e997dfd"
+    },
+    "tests/test_sabrina_p4_spherical_entanglement_expansion.py": {
+      "byte_count": 540,
+      "sha256": "ece7f8fe6c07064ab939ab51c0244adb72d3a5d4f92547a36b3406aa2bfb286e"
+    },
+    "tests/test_sabrina_p4_spherical_refined_entropy.py": {
+      "byte_count": 526,
+      "sha256": "3be20c227406f3738b544f6b993967c42c2f5e259dd3069d679fb94161f1fe56"
+    },
+    "tests/test_sabrina_points_scattering_lower_slack_identity.py": {
+      "byte_count": 546,
+      "sha256": "7fa19d805ce204b493deda027422a5c4e14d01b91493ca31709cccd4fb86284f"
+    },
+    "tests/test_sabrina_principal_series_plancherel_factorization.py": {
+      "byte_count": 552,
+      "sha256": "29461eec43c27d07b760597be1ed7600c5d09ce5f51882959f8e24833e0be17a"
+    },
+    "tests/test_sabrina_projective_mellin_scale_theorem.py": {
+      "byte_count": 532,
+      "sha256": "09642b4617e06e0ae1b15a813355bd65583d10e7469a8189372e0d68e6317530"
+    },
+    "tests/test_sabrina_projective_simplex_positivity_theorem.py": {
+      "byte_count": 544,
+      "sha256": "3285192ad576304d309794cf2b2a15b43c9fce1f08c4a39bab521e7944901188"
+    },
+    "tests/test_sabrina_projective_simplex_rank_theorem.py": {
+      "byte_count": 532,
+      "sha256": "74764f72ddbbbb836916d81d8f0050e9f00f624390666c950497caf420521e47"
+    },
+    "tests/test_sabrina_quadrupole_spin_memory_cap_duality.py": {
+      "byte_count": 538,
+      "sha256": "16fd6faebb697a80278ca23e86bb7ab6d10d8ee3776d68901dacb1e8c47d48b0"
+    },
+    "tests/test_sabrina_radial_einstein_square_factorization.py": {
+      "byte_count": 542,
+      "sha256": "92bd300b29466f79aed20d533095252798cf5bb332ecfab8145a0243d0336381"
+    },
+    "tests/test_sabrina_rt_area_boundary_identity.py": {
+      "byte_count": 520,
+      "sha256": "9b76b1ffa78212fee7543d4dcdf018d8d5fc624fe726af9eaceb58d87885fb61"
+    },
+    "tests/test_sabrina_soft_charge_cumulant_hierarchy.py": {
+      "byte_count": 530,
+      "sha256": "a08314293da57f0d182d7777d0d2444a5eab3eb1b8b45f4ab71abeeb1d3e4190"
+    },
+    "tests/test_sabrina_soft_charge_reduced_state_theorem.py": {
+      "byte_count": 536,
+      "sha256": "9eb49cad50a2d4bbd83c83bec818d2c474aaa81ada21bd24128c037f8074a41e"
+    },
+    "tests/test_sabrina_soft_dressing_factor_two_no_go.py": {
+      "byte_count": 530,
+      "sha256": "21d8a9966fa815489c393bdccf540845aae51e5d669f59bd73e168e001e02c4c"
+    },
+    "tests/test_sabrina_soft_mellin_residue_identity.py": {
+      "byte_count": 526,
+      "sha256": "668812a2fe82101e539483b5b053006b7c67fda134a60fb8bd0dd0c7c102d1e3"
+    },
+    "tests/test_sabrina_spin1_shadow_gauge_obstruction.py": {
+      "byte_count": 530,
+      "sha256": "62e6e28dec001231671ca8162d0ce1cc9fd7fc45ce29eea68da2f3b9ad4f8144"
+    },
+    "tests/test_sabrina_subleading_soft_gauge_defect_theorem.py": {
+      "byte_count": 542,
+      "sha256": "b33a362e2d9d12d3092a208d0ab9bbe0712c1874bfd354a79ee12f5d118621cf"
+    },
+    "tests/test_sabrina_super_bms_commutator_syzygy_family.py": {
+      "byte_count": 538,
+      "sha256": "a0d66a9e55c77d95337b75c9585e86c23a8dab984fe8707be557842859e4e947"
+    },
+    "tests/test_sabrina_superrotation_charge_cancellation.py": {
+      "byte_count": 536,
+      "sha256": "10d9641db2ab1ad177965e7463e10f1871f2f67f3ed49248546f66d8e2d5465e"
+    },
+    "tests/test_sabrina_two_particle_kernel_variance.py": {
+      "byte_count": 526,
+      "sha256": "d07bd3908194c357be0076e21bb66c9eb484a8b8354212947269acd3100e6b83"
+    },
+    "tests/test_sabrina_weyl_double_copy_shadow_involution.py": {
+      "byte_count": 538,
+      "sha256": "21b50c1147503d339c783a07877d1933cf4903512c0baa8a902a41fd3e4aecb7"
+    },
+    "validation/clean_room_replay_receipt.json": {
+      "byte_count": 1569,
+      "sha256": "cbff2552ade97132ea4fd67981915fa7b20318b7dd54ca6fe2d1d61f6d53a0bd"
+    }
+  },
+  "generated_utc": "2026-08-12T22:05:57+00:00",
+  "kernel_count": 49,
+  "manifest_payload_sha256": "862880ee72cf78a4b5e6d8269fff95ea4f8c6d74f1c25b899fc484214a9d5dc0",
+  "private_hf_upload_ready": true,
+  "public_actions_allowed": false,
+  "public_visibility_authorized": false,
+  "review_required": true,
+  "schema": "ouroboros_paused_publication_stage_manifest_v1",
+  "source_count": 36,
+  "stage_is_immutable": true,
+  "status": "PAUSED_PRIVATE_REVIEW",
+  "upload_performed": false
+}
diff --git a/references/run_sabrina_ads_radiation_spectral_commutator.json b/references/run_sabrina_ads_radiation_spectral_commutator.json
new file mode 100644
index 0000000000000000000000000000000000000000..84408e2302732e90cb93233c39a473fd6268a6cf
--- /dev/null
+++ b/references/run_sabrina_ads_radiation_spectral_commutator.json
@@ -0,0 +1,80 @@
+{
+  "kernel": "run_sabrina_ads_radiation_spectral_commutator",
+  "role": "post-computation assertion only",
+  "schema": "ouroboros_scientific_reference_assertion_v1",
+  "scientific_payload": {
+    "claim_boundary": {
+      "capabilities_removed": [],
+      "cotton_cft_dictionary_constructed": false,
+      "flat_limit_rederived": false,
+      "local_cut_criterion_constructed": false,
+      "physical_ads_radiation_criterion_rigorously_proved": false
+    },
+    "exact_checks": {
+      "archive_hash_matches": true,
+      "commutator_form_unique": true,
+      "cotton_alone_insufficient_stated": true,
+      "member_hash_matches": true,
+      "misaligned_pair_detected": true,
+      "nonzero_commuting_counterexample": true,
+      "rational_witnesses_all_pass": true,
+      "source_blocks_match": true,
+      "super_poynting_label_unique": true,
+      "symbolic_identity_exact": true,
+      "two_exact_solution_classes_present": true
+    },
+    "paper": {
+      "arxiv_id": "2404.02146",
+      "title": "Radiation in Holography"
+    },
+    "result_version": "sabrina_ads_radiation_spectral_commutator_v1",
+    "source_evidence": {
+      "archive_sha256": "1a1275f84b2989c1956ca93f60d06baee3e055215413dbb77fba34ba28e0fbf2",
+      "block_hashes": {
+        "ads_cft_consequence": "8e347f43f7d95be26e202ab50962119cc31c340723e94a7c8b27c02fda833d92",
+        "exact_solution_contrast": "c91f230530dc24dcd3655ee27a14e1be008e3ef9f1678b267ce7830d0fbbf632",
+        "radiation_criterion": "4061b04e420a9bda4964f1db07018893583601f910aefd40fd70cdbb2fe63816"
+      },
+      "checks": {
+        "archive_hash_matches": true,
+        "commutator_form_unique": true,
+        "cotton_alone_insufficient_stated": true,
+        "member_hash_matches": true,
+        "source_blocks_match": true,
+        "super_poynting_label_unique": true,
+        "two_exact_solution_classes_present": true
+      },
+      "member_sha256": "3cc6daa2e0d3520d63eb64da653fd87b39e0ef362decbd75503fd58e8cc15f3e"
+    },
+    "spectral_certificate": {
+      "identity": "||[C,T]||_F^2 = 2 sum_{i<j} (c_i-c_j)^2 T_ij^2",
+      "misaligned_pair": {
+        "commutator_nonzero": true,
+        "frobenius_norm_squared": "18"
+      },
+      "nonzero_commuting_pair": {
+        "both_nonzero": true,
+        "commutator_zero": true,
+        "degenerate_block_mixing_nonzero": true
+      },
+      "rational_witness_count": 96,
+      "rational_witness_failures": [],
+      "selection_rules": {
+        "coordinate_free": "real symmetric C and T commute if and only if they are simultaneously orthogonally diagonalizable",
+        "degenerate_spectrum": "stress may mix vectors only within equal-Cotton-eigenvalue blocks",
+        "distinct_spectrum": "zero commutator forces every off-diagonal stress component to vanish in the Cotton eigenbasis"
+      },
+      "symbolic_lhs": "2*c1**2*t12**2 + 2*c1**2*t13**2 - 4*c1*c2*t12**2 - 4*c1*c3*t13**2 + 2*c2**2*t12**2 + 2*c2**2*t23**2 - 4*c2*c3*t23**2 + 2*c3**2*t13**2 + 2*c3**2*t23**2",
+      "symbolic_residual": "0",
+      "symbolic_rhs": "2*c1**2*t12**2 + 2*c1**2*t13**2 - 4*c1*c2*t12**2 - 4*c1*c3*t13**2 + 2*c2**2*t12**2 + 2*c2**2*t23**2 - 4*c2*c3*t23**2 + 2*c3**2*t13**2 + 2*c3**2*t23**2"
+    },
+    "status": "complete",
+    "theorem": {
+      "interpretation": "the criterion measures eigenframe misalignment, weighted by Cotton eigenvalue gaps",
+      "no_radiation_algebraic_condition": "the proposed super-Poynting criterion vanishes exactly when Cotton-York and stress commute",
+      "nonzero_not_sufficient": "nonzero Cotton-York and nonzero stress are necessary but not sufficient for a nonzero commutator",
+      "spectral_identity": "||[C,T]||_F^2 = 2 sum_{i<j} (c_i-c_j)^2 T_ij^2"
+    }
+  },
+  "scientific_payload_sha256": "241d637afce046d817e7a3107063956a87e7581ccc4ccb9230959c16a846ff1d"
+}
diff --git a/references/run_sabrina_ads_two_interval_scattering_feasibility.json b/references/run_sabrina_ads_two_interval_scattering_feasibility.json
new file mode 100644
index 0000000000000000000000000000000000000000..cb462f9dd1babdc54020708e3a8872c5ec19c71a
--- /dev/null
+++ b/references/run_sabrina_ads_two_interval_scattering_feasibility.json
@@ -0,0 +1,127 @@
+{
+  "kernel": "run_sabrina_ads_two_interval_scattering_feasibility",
+  "role": "post-computation assertion only",
+  "schema": "ouroboros_scientific_reference_assertion_v1",
+  "scientific_payload": {
+    "algebraic_certificate": {
+      "checks": {
+        "endpoint_linear_coefficient": true,
+        "endpoint_quadratic_coefficient": true,
+        "endpoint_saturates_both_constraints": true,
+        "feasibility_boundary_exact": true,
+        "feasibility_margin_exact": true,
+        "finite_samples_classified": true,
+        "linear_coefficients_have_equal_squares": true,
+        "mu_window_orientation_exact": true,
+        "physical_branch_is_positive": true,
+        "quadratic_coefficient_exact": true,
+        "threshold_ratio_is_one": true
+      },
+      "derivation": "tau_*<=pi-mu iff cos(tau_*)>=cos(pi-mu), hence (1+cos(mu))/2>=-cos(mu)",
+      "feasible_mu_window": "pi/2 <= mu <= arccos(-1/3)",
+      "feasible_tau_window": "arccos(cos^2(mu/2)) <= tau <= pi-mu",
+      "samples": [
+        {
+          "cos_mu": "0",
+          "endpoint_cosine": "0",
+          "feasible": true,
+          "margin": "1/2",
+          "threshold_cosine": "1/2"
+        },
+        {
+          "cos_mu": "-1/4",
+          "endpoint_cosine": "1/4",
+          "feasible": true,
+          "margin": "1/8",
+          "threshold_cosine": "3/8"
+        },
+        {
+          "cos_mu": "-1/3",
+          "endpoint_cosine": "1/3",
+          "feasible": true,
+          "margin": "0",
+          "threshold_cosine": "1/3"
+        },
+        {
+          "cos_mu": "-1/2",
+          "endpoint_cosine": "1/2",
+          "feasible": false,
+          "margin": "-1/4",
+          "threshold_cosine": "1/4"
+        }
+      ],
+      "threshold_expansion": {
+        "branch_domain": "-1/3 <= c <= 0, so 1-c>0, 3+c>0, and sin(tau_*)>0",
+        "checks": {
+          "endpoint_linear_coefficient": true,
+          "endpoint_quadratic_coefficient": true,
+          "linear_coefficients_have_equal_squares": true,
+          "physical_branch_is_positive": true,
+          "quadratic_coefficient_exact": true,
+          "threshold_ratio_is_one": true
+        },
+        "cos_mu_symbol": "c",
+        "linear_coefficient": "2*sqrt((c + 3)/(1 - c))",
+        "quadratic_coefficient": "(c + 1)/(1 - c)",
+        "threshold_cosine": "c/2 + 1/2",
+        "threshold_sine_positive_branch": "sqrt((1 - c)*(c + 3))/2"
+      }
+    },
+    "claim_boundary": {
+      "capabilities_removed": [],
+      "general_geometry_claimed": false,
+      "pure_ads_2_plus_1_only": true,
+      "quantum_correction_claimed": false,
+      "small_positive_epsilon_interior_required": true
+    },
+    "exact_checks": {
+      "archive_hash_matches": true,
+      "domain_constraints_present": true,
+      "endpoint_linear_coefficient": true,
+      "endpoint_quadratic_coefficient": true,
+      "endpoint_saturates_both_constraints": true,
+      "feasibility_boundary_exact": true,
+      "feasibility_margin_exact": true,
+      "finite_samples_classified": true,
+      "linear_coefficients_have_equal_squares": true,
+      "member_hash_matches": true,
+      "mu_window_orientation_exact": true,
+      "mutual_information_formula_present": true,
+      "physical_branch_is_positive": true,
+      "quadratic_coefficient_exact": true,
+      "scattering_constraint_present": true,
+      "source_blocks_match": true,
+      "threshold_and_order_claim_present": true,
+      "threshold_ratio_is_one": true
+    },
+    "paper": {
+      "arxiv_id": "2411.10527",
+      "title": "Cryptographic tests of the python's lunch conjecture"
+    },
+    "result_version": "sabrina_ads_two_interval_scattering_feasibility_v1",
+    "source_evidence": {
+      "archive_sha256": "8baa6e7011dca7bf30ffdbe423d39c14f931ba65ff1dcaa8ead4afc0137c545a",
+      "block_hashes": {
+        "two_interval_constraints_and_onset": "a6915f6d5df835fcae409953539fe7dc89ae9212bb79a1063fd8a7a4f822e34f"
+      },
+      "checks": {
+        "archive_hash_matches": true,
+        "domain_constraints_present": true,
+        "member_hash_matches": true,
+        "mutual_information_formula_present": true,
+        "scattering_constraint_present": true,
+        "source_blocks_match": true,
+        "threshold_and_order_claim_present": true
+      },
+      "member_sha256": "e3d17f1c009c436fd22ace55f64c97e34c509fcf9ce47b395d3fadf719885d7d"
+    },
+    "status": "complete",
+    "theorem": {
+      "endpoint": "at cos(mu)=-1/3 the tau interval collapses and the formal coefficients are 2 sqrt(2), 1/2",
+      "linear_onset": "2 sqrt((3+cos(mu))/(1-cos(mu))) epsilon",
+      "nonempty_scattering_domain": "pi/2 <= mu <= arccos(-1/3) and tau_*(mu) <= tau <= pi-mu",
+      "quadratic_onset": "((1+cos(mu))/(1-cos(mu))) epsilon^2"
+    }
+  },
+  "scientific_payload_sha256": "da08f86ea668e62889d14682aff488ad090f0b3c49d6ffc823e456f799cd580b"
+}
diff --git a/references/run_sabrina_all_even_d_ward_normalization.json b/references/run_sabrina_all_even_d_ward_normalization.json
new file mode 100644
index 0000000000000000000000000000000000000000..0269092658317f6b678c959b4967c2f3e0b282c4
--- /dev/null
+++ b/references/run_sabrina_all_even_d_ward_normalization.json
@@ -0,0 +1,142 @@
+{
+  "kernel": "run_sabrina_all_even_d_ward_normalization",
+  "role": "post-computation assertion only",
+  "schema": "ouroboros_scientific_reference_assertion_v1",
+  "scientific_payload": {
+    "claim_boundary": {
+      "capabilities_removed": [],
+      "odd_spacetime_dimensions_claimed": false,
+      "source_physics_correction_claimed": false,
+      "sphere_differential_identity_rederived": false
+    },
+    "classification": "all_even_d_soft_hard_ward_normalization_exact_and_m_independent",
+    "exact_checks": {
+      "archive_hash_matches": true,
+      "finite_m2_through_m10_close": true,
+      "future_coefficient_universally_minus_half": true,
+      "member_hash_matches": true,
+      "past_coefficient_universally_plus_half": true,
+      "scgen_blocks_are_distinct": true,
+      "scgen_label_occurs_exactly_twice": true,
+      "soft_difference_universally_minus_one": true,
+      "source_applies_softgen_to_both_mode_equations": true,
+      "source_blocks_match": true,
+      "ward_coefficient_universally_closes": true
+    },
+    "finite_exact_rows": [
+      {
+        "future_soft_coefficient": "-1/2",
+        "hard_plus_soft": "0",
+        "m": 2,
+        "past_soft_coefficient": "1/2",
+        "soft_ward_difference": "-1",
+        "spacetime_dimension": 6
+      },
+      {
+        "future_soft_coefficient": "-1/2",
+        "hard_plus_soft": "0",
+        "m": 3,
+        "past_soft_coefficient": "1/2",
+        "soft_ward_difference": "-1",
+        "spacetime_dimension": 8
+      },
+      {
+        "future_soft_coefficient": "-1/2",
+        "hard_plus_soft": "0",
+        "m": 4,
+        "past_soft_coefficient": "1/2",
+        "soft_ward_difference": "-1",
+        "spacetime_dimension": 10
+      },
+      {
+        "future_soft_coefficient": "-1/2",
+        "hard_plus_soft": "0",
+        "m": 5,
+        "past_soft_coefficient": "1/2",
+        "soft_ward_difference": "-1",
+        "spacetime_dimension": 12
+      },
+      {
+        "future_soft_coefficient": "-1/2",
+        "hard_plus_soft": "0",
+        "m": 6,
+        "past_soft_coefficient": "1/2",
+        "soft_ward_difference": "-1",
+        "spacetime_dimension": 14
+      },
+      {
+        "future_soft_coefficient": "-1/2",
+        "hard_plus_soft": "0",
+        "m": 7,
+        "past_soft_coefficient": "1/2",
+        "soft_ward_difference": "-1",
+        "spacetime_dimension": 16
+      },
+      {
+        "future_soft_coefficient": "-1/2",
+        "hard_plus_soft": "0",
+        "m": 8,
+        "past_soft_coefficient": "1/2",
+        "soft_ward_difference": "-1",
+        "spacetime_dimension": 18
+      },
+      {
+        "future_soft_coefficient": "-1/2",
+        "hard_plus_soft": "0",
+        "m": 9,
+        "past_soft_coefficient": "1/2",
+        "soft_ward_difference": "-1",
+        "spacetime_dimension": 20
+      },
+      {
+        "future_soft_coefficient": "-1/2",
+        "hard_plus_soft": "0",
+        "m": 10,
+        "past_soft_coefficient": "1/2",
+        "soft_ward_difference": "-1",
+        "spacetime_dimension": 22
+      }
+    ],
+    "label_audit": {
+      "blocks_distinct": true,
+      "classification": "latex_cross_reference_ambiguity_only",
+      "duplicate_label": "scgen",
+      "occurrence_count": 2,
+      "physics_error_claimed": false
+    },
+    "paper": {
+      "arxiv_id": "1502.07644",
+      "dimension_scope": "d=2m+2 with integer m>=2",
+      "title": "Higher-Dimensional Supertranslations and Weinberg's Soft Graviton Theorem"
+    },
+    "result_version": "sabrina_all_even_d_ward_normalization_v1",
+    "source_evidence": {
+      "archive_sha256": "e0aab59e43f1b3bcc32b6723491cd79b62a04087bd25ef83736a712a2d7d7b70",
+      "block_hashes": {
+        "out2": "b59c311a360ce3977ce06c1ed65afd81ca5b29616951560a56e25dda41959f4b",
+        "outmodes": "95200151af5d2fb032b74736b4d144803ff42e2663dcd601955427b057136e8c",
+        "qhard2": "4ca7384be2849ac35732fbfb3b7c7d8b64a95274097ab17df7ddd8c353234826",
+        "scgen_minus": "819a03f61ab13627ce60032725cb4517b5de990dff4ae007cd9ddf3c6a8434af",
+        "scgen_plus": "49cd900f1872be1864aec76f5ea30d64a991793cd691fcdba912dc121cbd3277",
+        "softgen": "4527cbfd47cab2fa9db71d37d946bb31e0be38ca76961538249854c4a96a85e7",
+        "wardid2m": "027149fcf9ed9fb988b191544af75cbc18f127fee5d10c7df0a10d9b5dc98866"
+      },
+      "checks": {
+        "archive_hash_matches": true,
+        "member_hash_matches": true,
+        "scgen_blocks_are_distinct": true,
+        "scgen_label_occurs_exactly_twice": true,
+        "source_applies_softgen_to_both_mode_equations": true,
+        "source_blocks_match": true
+      }
+    },
+    "status": "complete",
+    "universal_certificate": {
+      "future_soft_insertion_over_hard_imbalance": "-1/2",
+      "hard_plus_soft_ward_coefficient": "0",
+      "past_soft_insertion_over_hard_imbalance": "1/2",
+      "soft_ward_difference_over_hard_imbalance": "-1"
+    }
+  },
+  "scientific_payload_sha256": "36d368057821e69206d459c5b4f34e81d6d3b1df977de35db7a7bd523f3b529e"
+}
diff --git a/references/run_sabrina_all_m_transverse_nonlocality_chain.json b/references/run_sabrina_all_m_transverse_nonlocality_chain.json
new file mode 100644
index 0000000000000000000000000000000000000000..a6979b76fc447f9173353c38583a38b5d564af0c
--- /dev/null
+++ b/references/run_sabrina_all_m_transverse_nonlocality_chain.json
@@ -0,0 +1,284 @@
+{
+  "kernel": "run_sabrina_all_m_transverse_nonlocality_chain",
+  "role": "post-computation assertion only",
+  "schema": "ouroboros_scientific_reference_assertion_v1",
+  "scientific_payload": {
+    "claim_boundary": {
+      "boundary_condition_analysis_complete": false,
+      "capabilities_removed": [],
+      "independent_second_derivation_complete": false,
+      "public_replay_claim_allowed": true
+    },
+    "classification": "all_m_transverse_nonlocality_depth_saturation_and_distribution_order_multiplicity_exact",
+    "exact_checks": {
+      "all_three_public_source_archives_match": true,
+      "all_three_public_source_archives_nonempty": true,
+      "finite_difference_termination_identities": true,
+      "finite_m3_through_m8_depth_ladder": true,
+      "finite_m3_through_m8_multiplicities": true,
+      "generic_nonvanishing_slice_exact": true,
+      "generic_order_has_exact_Z_r_plus_2_factor": true,
+      "last_order_has_exact_Z_m_plus_1_factor": true,
+      "m3_m4_m5_progression": true,
+      "m_minus_2_boundary_cancels_exactly": true,
+      "minimal_depth_identity": true,
+      "order_zero_has_exact_Z2_factor": true
+    },
+    "finite_exact_rows": [
+      {
+        "last_nonzero_order": 2,
+        "m": 3,
+        "minimal_inverse_total_Z_depth": 0,
+        "orders_at_or_above_m_vanish": true,
+        "rows": [
+          {
+            "nonzero": true,
+            "r": 0,
+            "total_Z_multiplicity": 2
+          },
+          {
+            "nonzero": true,
+            "r": 1,
+            "total_Z_multiplicity": 3
+          },
+          {
+            "nonzero": true,
+            "r": 2,
+            "total_Z_multiplicity": 4
+          }
+        ]
+      },
+      {
+        "last_nonzero_order": 3,
+        "m": 4,
+        "minimal_inverse_total_Z_depth": 1,
+        "orders_at_or_above_m_vanish": true,
+        "rows": [
+          {
+            "nonzero": true,
+            "r": 0,
+            "total_Z_multiplicity": 2
+          },
+          {
+            "nonzero": true,
+            "r": 1,
+            "total_Z_multiplicity": 3
+          },
+          {
+            "nonzero": true,
+            "r": 2,
+            "total_Z_multiplicity": 4
+          },
+          {
+            "nonzero": true,
+            "r": 3,
+            "total_Z_multiplicity": 5
+          }
+        ]
+      },
+      {
+        "last_nonzero_order": 4,
+        "m": 5,
+        "minimal_inverse_total_Z_depth": 2,
+        "orders_at_or_above_m_vanish": true,
+        "rows": [
+          {
+            "nonzero": true,
+            "r": 0,
+            "total_Z_multiplicity": 2
+          },
+          {
+            "nonzero": true,
+            "r": 1,
+            "total_Z_multiplicity": 3
+          },
+          {
+            "nonzero": true,
+            "r": 2,
+            "total_Z_multiplicity": 4
+          },
+          {
+            "nonzero": true,
+            "r": 3,
+            "total_Z_multiplicity": 5
+          },
+          {
+            "nonzero": true,
+            "r": 4,
+            "total_Z_multiplicity": 6
+          }
+        ]
+      },
+      {
+        "last_nonzero_order": 5,
+        "m": 6,
+        "minimal_inverse_total_Z_depth": 3,
+        "orders_at_or_above_m_vanish": true,
+        "rows": [
+          {
+            "nonzero": true,
+            "r": 0,
+            "total_Z_multiplicity": 2
+          },
+          {
+            "nonzero": true,
+            "r": 1,
+            "total_Z_multiplicity": 3
+          },
+          {
+            "nonzero": true,
+            "r": 2,
+            "total_Z_multiplicity": 4
+          },
+          {
+            "nonzero": true,
+            "r": 3,
+            "total_Z_multiplicity": 5
+          },
+          {
+            "nonzero": true,
+            "r": 4,
+            "total_Z_multiplicity": 6
+          },
+          {
+            "nonzero": true,
+            "r": 5,
+            "total_Z_multiplicity": 7
+          }
+        ]
+      },
+      {
+        "last_nonzero_order": 6,
+        "m": 7,
+        "minimal_inverse_total_Z_depth": 4,
+        "orders_at_or_above_m_vanish": true,
+        "rows": [
+          {
+            "nonzero": true,
+            "r": 0,
+            "total_Z_multiplicity": 2
+          },
+          {
+            "nonzero": true,
+            "r": 1,
+            "total_Z_multiplicity": 3
+          },
+          {
+            "nonzero": true,
+            "r": 2,
+            "total_Z_multiplicity": 4
+          },
+          {
+            "nonzero": true,
+            "r": 3,
+            "total_Z_multiplicity": 5
+          },
+          {
+            "nonzero": true,
+            "r": 4,
+            "total_Z_multiplicity": 6
+          },
+          {
+            "nonzero": true,
+            "r": 5,
+            "total_Z_multiplicity": 7
+          },
+          {
+            "nonzero": true,
+            "r": 6,
+            "total_Z_multiplicity": 8
+          }
+        ]
+      },
+      {
+        "last_nonzero_order": 7,
+        "m": 8,
+        "minimal_inverse_total_Z_depth": 5,
+        "orders_at_or_above_m_vanish": true,
+        "rows": [
+          {
+            "nonzero": true,
+            "r": 0,
+            "total_Z_multiplicity": 2
+          },
+          {
+            "nonzero": true,
+            "r": 1,
+            "total_Z_multiplicity": 3
+          },
+          {
+            "nonzero": true,
+            "r": 2,
+            "total_Z_multiplicity": 4
+          },
+          {
+            "nonzero": true,
+            "r": 3,
+            "total_Z_multiplicity": 5
+          },
+          {
+            "nonzero": true,
+            "r": 4,
+            "total_Z_multiplicity": 6
+          },
+          {
+            "nonzero": true,
+            "r": 5,
+            "total_Z_multiplicity": 7
+          },
+          {
+            "nonzero": true,
+            "r": 6,
+            "total_Z_multiplicity": 8
+          },
+          {
+            "nonzero": true,
+            "r": 7,
+            "total_Z_multiplicity": 9
+          }
+        ]
+      }
+    ],
+    "result_version": "sabrina_all_m_transverse_nonlocality_chain_v1",
+    "source_evidence": {
+      "archive_sha256": {
+        "arxiv_2211_14287": "1299353b9514a296786e448ec1ec7adfc430eee66d055293cb24716dc23879db",
+        "arxiv_2307_16801": "98acf1e79b6d6fb929626e11f40fdb0d4a4029f174f6c493f7639e721c7424b0",
+        "arxiv_2607_28718": "bfa9d2a7941ed801f874bb92b4c3e898a99900d92990403d32c4b9408c48f2a1"
+      },
+      "checks": {
+        "all_three_public_source_archives_match": true,
+        "all_three_public_source_archives_nonempty": true
+      },
+      "observed_sha256": {
+        "arxiv_2211_14287": "1299353b9514a296786e448ec1ec7adfc430eee66d055293cb24716dc23879db",
+        "arxiv_2307_16801": "98acf1e79b6d6fb929626e11f40fdb0d4a4029f174f6c493f7639e721c7424b0",
+        "arxiv_2607_28718": "bfa9d2a7941ed801f874bb92b4c3e898a99900d92990403d32c4b9408c48f2a1"
+      }
+    },
+    "sources": {
+      "celestial_conformal_colliders": {
+        "arxiv_id": "2211.14287",
+        "title": "Celestial Conformal Colliders"
+      },
+      "detector_operators": {
+        "arxiv_id": "2307.16801",
+        "title": "Detector Operators for Celestial Symmetries"
+      },
+      "infinite_symmetry_algebras": {
+        "arxiv_id": "2607.28718",
+        "title": "Infinite Symmetry Algebras in Four-Dimensional Conformal Field Theories"
+      }
+    },
+    "status": "complete",
+    "theorem": {
+      "domain": "integer m>=3 in the complex-Hermitian conformal-scalar conventions",
+      "generic_distribution_orders": "for 0<=r<=m-2, R_(m,r) has exact total-Z multiplicity r+2",
+      "last_nonzero_order": "r=m-1 has exact total-Z multiplicity m+1",
+      "minimal_inverse_total_Z_depth": "d_min(m)=m-3",
+      "progression": "m=3 -> 0, m=4 -> 1, m=5 -> 2, then the all-m proof",
+      "vanishing_orders": "R_(m,r)=0 for r>=m"
+    }
+  },
+  "scientific_payload_sha256": "6600de93b5e0dbb7dc6744cfc31499e4d84760267f62e18bc2a1c9a0e8470db5"
+}
diff --git a/references/run_sabrina_ambidextrous_integer_prefactor_lattice.json b/references/run_sabrina_ambidextrous_integer_prefactor_lattice.json
new file mode 100644
index 0000000000000000000000000000000000000000..00ab09602addc79ceffcfa38f9df12d03e05409d
--- /dev/null
+++ b/references/run_sabrina_ambidextrous_integer_prefactor_lattice.json
@@ -0,0 +1,437 @@
+{
+  "kernel": "run_sabrina_ambidextrous_integer_prefactor_lattice",
+  "role": "post-computation assertion only",
+  "schema": "ouroboros_scientific_reference_assertion_v1",
+  "scientific_payload": {
+    "certificate_witnesses": {
+      "integer_lattice_minus10_to_10": [
+        {
+          "channels": {
+            "antisymmetric": {
+              "direct_match": true,
+              "finite_value": null,
+              "residue": "I*pi/9979200",
+              "status": "pole"
+            },
+            "symmetric": {
+              "direct_match": true,
+              "finite_value": "pi**2/19958400",
+              "residue": "0",
+              "status": "finite_cancellation"
+            }
+          },
+          "complementary": true,
+          "integer_delta": -10
+        },
+        {
+          "channels": {
+            "antisymmetric": {
+              "direct_match": true,
+              "finite_value": "I*pi**2/1814400",
+              "residue": "0",
+              "status": "finite_cancellation"
+            },
+            "symmetric": {
+              "direct_match": true,
+              "finite_value": null,
+              "residue": "-pi/907200",
+              "status": "pole"
+            }
+          },
+          "complementary": true,
+          "integer_delta": -9
+        },
+        {
+          "channels": {
+            "antisymmetric": {
+              "direct_match": true,
+              "finite_value": null,
+              "residue": "-I*pi/90720",
+              "status": "pole"
+            },
+            "symmetric": {
+              "direct_match": true,
+              "finite_value": "-pi**2/181440",
+              "residue": "0",
+              "status": "finite_cancellation"
+            }
+          },
+          "complementary": true,
+          "integer_delta": -8
+        },
+        {
+          "channels": {
+            "antisymmetric": {
+              "direct_match": true,
+              "finite_value": "-I*pi**2/20160",
+              "residue": "0",
+              "status": "finite_cancellation"
+            },
+            "symmetric": {
+              "direct_match": true,
+              "finite_value": null,
+              "residue": "pi/10080",
+              "status": "pole"
+            }
+          },
+          "complementary": true,
+          "integer_delta": -7
+        },
+        {
+          "channels": {
+            "antisymmetric": {
+              "direct_match": true,
+              "finite_value": null,
+              "residue": "I*pi/1260",
+              "status": "pole"
+            },
+            "symmetric": {
+              "direct_match": true,
+              "finite_value": "pi**2/2520",
+              "residue": "0",
+              "status": "finite_cancellation"
+            }
+          },
+          "complementary": true,
+          "integer_delta": -6
+        },
+        {
+          "channels": {
+            "antisymmetric": {
+              "direct_match": true,
+              "finite_value": "I*pi**2/360",
+              "residue": "0",
+              "status": "finite_cancellation"
+            },
+            "symmetric": {
+              "direct_match": true,
+              "finite_value": null,
+              "residue": "-pi/180",
+              "status": "pole"
+            }
+          },
+          "complementary": true,
+          "integer_delta": -5
+        },
+        {
+          "channels": {
+            "antisymmetric": {
+              "direct_match": true,
+              "finite_value": null,
+              "residue": "-I*pi/30",
+              "status": "pole"
+            },
+            "symmetric": {
+              "direct_match": true,
+              "finite_value": "-pi**2/60",
+              "residue": "0",
+              "status": "finite_cancellation"
+            }
+          },
+          "complementary": true,
+          "integer_delta": -4
+        },
+        {
+          "channels": {
+            "antisymmetric": {
+              "direct_match": true,
+              "finite_value": "-I*pi**2/12",
+              "residue": "0",
+              "status": "finite_cancellation"
+            },
+            "symmetric": {
+              "direct_match": true,
+              "finite_value": null,
+              "residue": "pi/6",
+              "status": "pole"
+            }
+          },
+          "complementary": true,
+          "integer_delta": -3
+        },
+        {
+          "channels": {
+            "antisymmetric": {
+              "direct_match": true,
+              "finite_value": null,
+              "residue": "2*I*pi/3",
+              "status": "pole"
+            },
+            "symmetric": {
+              "direct_match": true,
+              "finite_value": "pi**2/3",
+              "residue": "0",
+              "status": "finite_cancellation"
+            }
+          },
+          "complementary": true,
+          "integer_delta": -2
+        },
+        {
+          "channels": {
+            "antisymmetric": {
+              "direct_match": true,
+              "finite_value": "I*pi**2",
+              "residue": "0",
+              "status": "finite_cancellation"
+            },
+            "symmetric": {
+              "direct_match": true,
+              "finite_value": null,
+              "residue": "-2*pi",
+              "status": "pole"
+            }
+          },
+          "complementary": true,
+          "integer_delta": -1
+        },
+        {
+          "channels": {
+            "antisymmetric": {
+              "direct_match": true,
+              "finite_value": null,
+              "residue": "-4*I*pi",
+              "status": "pole"
+            },
+            "symmetric": {
+              "direct_match": true,
+              "finite_value": "-2*pi**2",
+              "residue": "0",
+              "status": "finite_cancellation"
+            }
+          },
+          "complementary": true,
+          "integer_delta": 0
+        },
+        {
+          "channels": {
+            "antisymmetric": {
+              "direct_match": true,
+              "finite_value": "-2*I*pi**2",
+              "residue": "0",
+              "status": "finite_cancellation"
+            },
+            "symmetric": {
+              "direct_match": true,
+              "finite_value": null,
+              "residue": "4*pi",
+              "status": "pole"
+            }
+          },
+          "complementary": true,
+          "integer_delta": 1
+        },
+        {
+          "channels": {
+            "antisymmetric": {
+              "direct_match": true,
+              "finite_value": "-4*I*pi",
+              "residue": "0",
+              "status": "finite"
+            },
+            "symmetric": {
+              "direct_match": true,
+              "finite_value": "0",
+              "residue": "0",
+              "status": "zero"
+            }
+          },
+          "complementary": true,
+          "integer_delta": 2
+        },
+        {
+          "channels": {
+            "antisymmetric": {
+              "direct_match": true,
+              "finite_value": "0",
+              "residue": "0",
+              "status": "zero"
+            },
+            "symmetric": {
+              "direct_match": true,
+              "finite_value": "-4*pi",
+              "residue": "0",
+              "status": "finite"
+            }
+          },
+          "complementary": true,
+          "integer_delta": 3
+        },
+        {
+          "channels": {
+            "antisymmetric": {
+              "direct_match": true,
+              "finite_value": "8*I*pi",
+              "residue": "0",
+              "status": "finite"
+            },
+            "symmetric": {
+              "direct_match": true,
+              "finite_value": "0",
+              "residue": "0",
+              "status": "zero"
+            }
+          },
+          "complementary": true,
+          "integer_delta": 4
+        },
+        {
+          "channels": {
+            "antisymmetric": {
+              "direct_match": true,
+              "finite_value": "0",
+              "residue": "0",
+              "status": "zero"
+            },
+            "symmetric": {
+              "direct_match": true,
+              "finite_value": "24*pi",
+              "residue": "0",
+              "status": "finite"
+            }
+          },
+          "complementary": true,
+          "integer_delta": 5
+        },
+        {
+          "channels": {
+            "antisymmetric": {
+              "direct_match": true,
+              "finite_value": "-96*I*pi",
+              "residue": "0",
+              "status": "finite"
+            },
+            "symmetric": {
+              "direct_match": true,
+              "finite_value": "0",
+              "residue": "0",
+              "status": "zero"
+            }
+          },
+          "complementary": true,
+          "integer_delta": 6
+        },
+        {
+          "channels": {
+            "antisymmetric": {
+              "direct_match": true,
+              "finite_value": "0",
+              "residue": "0",
+              "status": "zero"
+            },
+            "symmetric": {
+              "direct_match": true,
+              "finite_value": "-480*pi",
+              "residue": "0",
+              "status": "finite"
+            }
+          },
+          "complementary": true,
+          "integer_delta": 7
+        },
+        {
+          "channels": {
+            "antisymmetric": {
+              "direct_match": true,
+              "finite_value": "2880*I*pi",
+              "residue": "0",
+              "status": "finite"
+            },
+            "symmetric": {
+              "direct_match": true,
+              "finite_value": "0",
+              "residue": "0",
+              "status": "zero"
+            }
+          },
+          "complementary": true,
+          "integer_delta": 8
+        },
+        {
+          "channels": {
+            "antisymmetric": {
+              "direct_match": true,
+              "finite_value": "0",
+              "residue": "0",
+              "status": "zero"
+            },
+            "symmetric": {
+              "direct_match": true,
+              "finite_value": "20160*pi",
+              "residue": "0",
+              "status": "finite"
+            }
+          },
+          "complementary": true,
+          "integer_delta": 9
+        },
+        {
+          "channels": {
+            "antisymmetric": {
+              "direct_match": true,
+              "finite_value": "-161280*I*pi",
+              "residue": "0",
+              "status": "finite"
+            },
+            "symmetric": {
+              "direct_match": true,
+              "finite_value": "0",
+              "residue": "0",
+              "status": "zero"
+            }
+          },
+          "complementary": true,
+          "integer_delta": 10
+        }
+      ]
+    },
+    "claim_boundary": {
+      "amplitude_residue_computed": false,
+      "capabilities_removed": [],
+      "contact_support_regularized": false,
+      "full_distributional_wavefunction_classified": false
+    },
+    "exact_checks": {
+      "antisymmetric_prefactors_present": true,
+      "archive_hash_matches": true,
+      "closed_forms_match_direct_expansions": true,
+      "delta_one_special_case": true,
+      "delta_zero_special_case": true,
+      "distributional_support_present": true,
+      "integer_channels_are_complementary": true,
+      "member_hash_matches": true,
+      "positive_integer_zero_pattern": true,
+      "source_blocks_match": true,
+      "symmetric_prefactors_present": true
+    },
+    "paper": {
+      "arxiv_id": "2212.00962",
+      "title": "Celestial amplitudes in an ambidextrous basis"
+    },
+    "result_version": "sabrina_ambidextrous_integer_prefactor_lattice_v1",
+    "source_evidence": {
+      "archive_sha256": "2427287be8bd1a7795678aaa741678883d650e87fafd311bdbed06d30af1418a",
+      "block_hashes": {
+        "antisymmetric_light_prefactor": "f8960a1c62d8863ba211083ca3b94aa7ba02a82e3119aa7f6fbf20f34299e06f",
+        "symmetric_light_prefactor": "c7278952c5f94673ec6bb54a4bf5bd1147b6a6c122d6d16a25f7a358b64f3546"
+      },
+      "checks": {
+        "antisymmetric_prefactors_present": true,
+        "archive_hash_matches": true,
+        "distributional_support_present": true,
+        "member_hash_matches": true,
+        "source_blocks_match": true,
+        "symmetric_prefactors_present": true
+      },
+      "member_sha256": "27eedb08d211073e0e05f79802b92b5d76ca52d12d7afe71356f10bc6123dd59"
+    },
+    "status": "complete",
+    "theorem": {
+      "nonpositive_lattice": "at each nonpositive integer one channel has a simple pole while the complementary trigonometric zero cancels the gamma pole to a finite value",
+      "positive_lattice": "for integer Delta>=2 exactly one channel vanishes and the other is finite",
+      "prefactors": "C_s=4 pi Gamma(Delta-1) sin(pi Delta/2), C_a=4 pi i Gamma(Delta-1) cos(pi Delta/2)",
+      "special_points": "at Delta=0, C_s=-2 pi^2 and Res C_a=-4 pi i; at Delta=1, Res C_s=4 pi and C_a=-2 pi^2 i"
+    }
+  },
+  "scientific_payload_sha256": "77e01bb41ab0dd463176786be21185590dc2a06da27f2585d546e2a379c2ff4f"
+}
diff --git a/references/run_sabrina_boundary_soft_scale_cocycle.json b/references/run_sabrina_boundary_soft_scale_cocycle.json
new file mode 100644
index 0000000000000000000000000000000000000000..43bca403c9287e58f839b33f70a4c1698ee9e6e5
--- /dev/null
+++ b/references/run_sabrina_boundary_soft_scale_cocycle.json
@@ -0,0 +1,267 @@
+{
+  "kernel": "run_sabrina_boundary_soft_scale_cocycle",
+  "role": "post-computation assertion only",
+  "schema": "ouroboros_scientific_reference_assertion_v1",
+  "scientific_payload": {
+    "certificate_witnesses": {
+      "cocycle_compositions": [
+        {
+          "first": "-3/2",
+          "residual": "0",
+          "second": "-3/2"
+        },
+        {
+          "first": "-3/2",
+          "residual": "0",
+          "second": "-1/3"
+        },
+        {
+          "first": "-3/2",
+          "residual": "0",
+          "second": "0"
+        },
+        {
+          "first": "-3/2",
+          "residual": "0",
+          "second": "2/5"
+        },
+        {
+          "first": "-3/2",
+          "residual": "0",
+          "second": "7/4"
+        },
+        {
+          "first": "-1/3",
+          "residual": "0",
+          "second": "-3/2"
+        },
+        {
+          "first": "-1/3",
+          "residual": "0",
+          "second": "-1/3"
+        },
+        {
+          "first": "-1/3",
+          "residual": "0",
+          "second": "0"
+        },
+        {
+          "first": "-1/3",
+          "residual": "0",
+          "second": "2/5"
+        },
+        {
+          "first": "-1/3",
+          "residual": "0",
+          "second": "7/4"
+        },
+        {
+          "first": "0",
+          "residual": "0",
+          "second": "-3/2"
+        },
+        {
+          "first": "0",
+          "residual": "0",
+          "second": "-1/3"
+        },
+        {
+          "first": "0",
+          "residual": "0",
+          "second": "0"
+        },
+        {
+          "first": "0",
+          "residual": "0",
+          "second": "2/5"
+        },
+        {
+          "first": "0",
+          "residual": "0",
+          "second": "7/4"
+        },
+        {
+          "first": "2/5",
+          "residual": "0",
+          "second": "-3/2"
+        },
+        {
+          "first": "2/5",
+          "residual": "0",
+          "second": "-1/3"
+        },
+        {
+          "first": "2/5",
+          "residual": "0",
+          "second": "0"
+        },
+        {
+          "first": "2/5",
+          "residual": "0",
+          "second": "2/5"
+        },
+        {
+          "first": "2/5",
+          "residual": "0",
+          "second": "7/4"
+        },
+        {
+          "first": "7/4",
+          "residual": "0",
+          "second": "-3/2"
+        },
+        {
+          "first": "7/4",
+          "residual": "0",
+          "second": "-1/3"
+        },
+        {
+          "first": "7/4",
+          "residual": "0",
+          "second": "0"
+        },
+        {
+          "first": "7/4",
+          "residual": "0",
+          "second": "2/5"
+        },
+        {
+          "first": "7/4",
+          "residual": "0",
+          "second": "7/4"
+        }
+      ],
+      "contact_test_jets": [
+        {
+          "scale_response": "2/(9*pi)",
+          "test_value_at_contact": "-2"
+        },
+        {
+          "scale_response": "0",
+          "test_value_at_contact": "0"
+        },
+        {
+          "scale_response": "-1/(15*pi)",
+          "test_value_at_contact": "3/5"
+        }
+      ],
+      "d_d_log_scale": "-1/(4*pi)",
+      "d_d_log_time": "-1/(4*pi)",
+      "inverse_residuals": [
+        "0",
+        "0",
+        "0",
+        "0",
+        "0"
+      ],
+      "scale_changes": [
+        {
+          "contact_coefficient_difference": "3/(8*pi)",
+          "distribution_action_difference": "33/(104*pi)",
+          "expected_contact_shift": "3/(8*pi)",
+          "identity": true,
+          "log_ratio": "-3/2",
+          "log_scale": "5/7"
+        },
+        {
+          "contact_coefficient_difference": "1/(12*pi)",
+          "distribution_action_difference": "11/(156*pi)",
+          "expected_contact_shift": "1/(12*pi)",
+          "identity": true,
+          "log_ratio": "-1/3",
+          "log_scale": "5/7"
+        },
+        {
+          "contact_coefficient_difference": "0",
+          "distribution_action_difference": "0",
+          "expected_contact_shift": "0",
+          "identity": true,
+          "log_ratio": "0",
+          "log_scale": "5/7"
+        },
+        {
+          "contact_coefficient_difference": "-1/(10*pi)",
+          "distribution_action_difference": "-11/(130*pi)",
+          "expected_contact_shift": "-1/(10*pi)",
+          "identity": true,
+          "log_ratio": "2/5",
+          "log_scale": "5/7"
+        },
+        {
+          "contact_coefficient_difference": "-7/(16*pi)",
+          "distribution_action_difference": "-77/(208*pi)",
+          "expected_contact_shift": "-7/(16*pi)",
+          "identity": true,
+          "log_ratio": "7/4",
+          "log_scale": "5/7"
+        }
+      ],
+      "separated_points": [
+        {
+          "radius_squared": "1/9",
+          "scale_response": "0",
+          "value": "9/(4*pi**2)"
+        },
+        {
+          "radius_squared": "2/3",
+          "scale_response": "0",
+          "value": "3/(8*pi**2)"
+        },
+        {
+          "radius_squared": "7/2",
+          "scale_response": "0",
+          "value": "1/(14*pi**2)"
+        }
+      ]
+    },
+    "claim_boundary": {
+      "capabilities_removed": [],
+      "coincident_correlator_regulator_independent": false,
+      "soft_sector_dynamics_computed": false,
+      "u_zero_distribution_resolved": false
+    },
+    "exact_checks": {
+      "archive_hash_matches": true,
+      "cocycle_composition_exact": true,
+      "contact_support_explicit": true,
+      "corrected_operator_present": true,
+      "inverse_and_identity_exact": true,
+      "member_hash_matches": true,
+      "regulated_contact_correlator_present": true,
+      "scale_and_time_log_derivatives_universal": true,
+      "scale_change_identity_exact": true,
+      "separated_points_are_invariant": true,
+      "source_blocks_match": true,
+      "vanishing_contact_jet_is_invariant": true
+    },
+    "paper": {
+      "arxiv_id": "2410.20296",
+      "title": "A Comment on Boundary Correlators: Soft Omissions and the Massless S-Matrix"
+    },
+    "result_version": "sabrina_boundary_soft_scale_cocycle_v1",
+    "source_evidence": {
+      "archive_sha256": "9449818f67f5ea56945c7389f382057b410a452e387ea285b0b1e23e079fbe7b",
+      "block_hashes": {
+        "corrected_boundary_operator": "d1e30b5190f5f19d6b401fd31f64ec6b51ab9f780edcbc250a6384f1fe32b223",
+        "regulated_two_point_contact_term": "42bcaf00b7b2d4a3303653c2c936ec2699f4d588d4a7099383707417bf928184"
+      },
+      "checks": {
+        "archive_hash_matches": true,
+        "contact_support_explicit": true,
+        "corrected_operator_present": true,
+        "member_hash_matches": true,
+        "regulated_contact_correlator_present": true,
+        "source_blocks_match": true
+      },
+      "member_sha256": "d3cad9e521a6d2ad3b960db2374a1c5f32ff63acf3834731be6060645718967c"
+    },
+    "status": "complete",
+    "theorem": {
+      "composition": "the contact shifts add under successive positive rescalings and cancel under inverse rescaling",
+      "invariants": "separated-point correlators and the derivative with respect to log time separation are independent of the arbitrary scale",
+      "scale_cocycle": "for lambda>0, G_(lambda mu)-G_mu=-(log lambda)/(4 pi) delta^2(z)",
+      "support": "scale dependence acts only on the value of a test function at angular coincidence"
+    }
+  },
+  "scientific_payload_sha256": "a335d252d7be59f9c40e7abc990331da16b0b54eda70f70d4fa5172d95b2e084"
+}
diff --git a/references/run_sabrina_carrollian_celestial_weyl_intertwiner.json b/references/run_sabrina_carrollian_celestial_weyl_intertwiner.json
new file mode 100644
index 0000000000000000000000000000000000000000..b5cb94650747ddf998cd7a4ad76d4f74906605ca
--- /dev/null
+++ b/references/run_sabrina_carrollian_celestial_weyl_intertwiner.json
@@ -0,0 +1,364 @@
+{
+  "kernel": "run_sabrina_carrollian_celestial_weyl_intertwiner",
+  "role": "post-computation assertion only",
+  "schema": "ouroboros_scientific_reference_assertion_v1",
+  "scientific_payload": {
+    "algebraic_certificate": {
+      "checks": {
+        "finite_grid_actions_exact": true,
+        "finite_grid_coefficients_exact": true,
+        "grid_complete": true,
+        "weyl_commutator_exact": true
+      },
+      "commutator": "[D,U]=1",
+      "dictionary": {
+        "normal_order": "u^m partial_u^r -> product_(j=1)^m(nu-j) T_(r-m)",
+        "partial_u": "D=T_+",
+        "u": "U=(nu-1)T_-"
+      },
+      "grid": [
+        {
+          "action_exact": true,
+          "coefficient_exact": true,
+          "m": 0,
+          "r": 0
+        },
+        {
+          "action_exact": true,
+          "coefficient_exact": true,
+          "m": 0,
+          "r": 1
+        },
+        {
+          "action_exact": true,
+          "coefficient_exact": true,
+          "m": 0,
+          "r": 2
+        },
+        {
+          "action_exact": true,
+          "coefficient_exact": true,
+          "m": 0,
+          "r": 3
+        },
+        {
+          "action_exact": true,
+          "coefficient_exact": true,
+          "m": 0,
+          "r": 4
+        },
+        {
+          "action_exact": true,
+          "coefficient_exact": true,
+          "m": 0,
+          "r": 5
+        },
+        {
+          "action_exact": true,
+          "coefficient_exact": true,
+          "m": 0,
+          "r": 6
+        },
+        {
+          "action_exact": true,
+          "coefficient_exact": true,
+          "m": 1,
+          "r": 0
+        },
+        {
+          "action_exact": true,
+          "coefficient_exact": true,
+          "m": 1,
+          "r": 1
+        },
+        {
+          "action_exact": true,
+          "coefficient_exact": true,
+          "m": 1,
+          "r": 2
+        },
+        {
+          "action_exact": true,
+          "coefficient_exact": true,
+          "m": 1,
+          "r": 3
+        },
+        {
+          "action_exact": true,
+          "coefficient_exact": true,
+          "m": 1,
+          "r": 4
+        },
+        {
+          "action_exact": true,
+          "coefficient_exact": true,
+          "m": 1,
+          "r": 5
+        },
+        {
+          "action_exact": true,
+          "coefficient_exact": true,
+          "m": 1,
+          "r": 6
+        },
+        {
+          "action_exact": true,
+          "coefficient_exact": true,
+          "m": 2,
+          "r": 0
+        },
+        {
+          "action_exact": true,
+          "coefficient_exact": true,
+          "m": 2,
+          "r": 1
+        },
+        {
+          "action_exact": true,
+          "coefficient_exact": true,
+          "m": 2,
+          "r": 2
+        },
+        {
+          "action_exact": true,
+          "coefficient_exact": true,
+          "m": 2,
+          "r": 3
+        },
+        {
+          "action_exact": true,
+          "coefficient_exact": true,
+          "m": 2,
+          "r": 4
+        },
+        {
+          "action_exact": true,
+          "coefficient_exact": true,
+          "m": 2,
+          "r": 5
+        },
+        {
+          "action_exact": true,
+          "coefficient_exact": true,
+          "m": 2,
+          "r": 6
+        },
+        {
+          "action_exact": true,
+          "coefficient_exact": true,
+          "m": 3,
+          "r": 0
+        },
+        {
+          "action_exact": true,
+          "coefficient_exact": true,
+          "m": 3,
+          "r": 1
+        },
+        {
+          "action_exact": true,
+          "coefficient_exact": true,
+          "m": 3,
+          "r": 2
+        },
+        {
+          "action_exact": true,
+          "coefficient_exact": true,
+          "m": 3,
+          "r": 3
+        },
+        {
+          "action_exact": true,
+          "coefficient_exact": true,
+          "m": 3,
+          "r": 4
+        },
+        {
+          "action_exact": true,
+          "coefficient_exact": true,
+          "m": 3,
+          "r": 5
+        },
+        {
+          "action_exact": true,
+          "coefficient_exact": true,
+          "m": 3,
+          "r": 6
+        },
+        {
+          "action_exact": true,
+          "coefficient_exact": true,
+          "m": 4,
+          "r": 0
+        },
+        {
+          "action_exact": true,
+          "coefficient_exact": true,
+          "m": 4,
+          "r": 1
+        },
+        {
+          "action_exact": true,
+          "coefficient_exact": true,
+          "m": 4,
+          "r": 2
+        },
+        {
+          "action_exact": true,
+          "coefficient_exact": true,
+          "m": 4,
+          "r": 3
+        },
+        {
+          "action_exact": true,
+          "coefficient_exact": true,
+          "m": 4,
+          "r": 4
+        },
+        {
+          "action_exact": true,
+          "coefficient_exact": true,
+          "m": 4,
+          "r": 5
+        },
+        {
+          "action_exact": true,
+          "coefficient_exact": true,
+          "m": 4,
+          "r": 6
+        },
+        {
+          "action_exact": true,
+          "coefficient_exact": true,
+          "m": 5,
+          "r": 0
+        },
+        {
+          "action_exact": true,
+          "coefficient_exact": true,
+          "m": 5,
+          "r": 1
+        },
+        {
+          "action_exact": true,
+          "coefficient_exact": true,
+          "m": 5,
+          "r": 2
+        },
+        {
+          "action_exact": true,
+          "coefficient_exact": true,
+          "m": 5,
+          "r": 3
+        },
+        {
+          "action_exact": true,
+          "coefficient_exact": true,
+          "m": 5,
+          "r": 4
+        },
+        {
+          "action_exact": true,
+          "coefficient_exact": true,
+          "m": 5,
+          "r": 5
+        },
+        {
+          "action_exact": true,
+          "coefficient_exact": true,
+          "m": 5,
+          "r": 6
+        },
+        {
+          "action_exact": true,
+          "coefficient_exact": true,
+          "m": 6,
+          "r": 0
+        },
+        {
+          "action_exact": true,
+          "coefficient_exact": true,
+          "m": 6,
+          "r": 1
+        },
+        {
+          "action_exact": true,
+          "coefficient_exact": true,
+          "m": 6,
+          "r": 2
+        },
+        {
+          "action_exact": true,
+          "coefficient_exact": true,
+          "m": 6,
+          "r": 3
+        },
+        {
+          "action_exact": true,
+          "coefficient_exact": true,
+          "m": 6,
+          "r": 4
+        },
+        {
+          "action_exact": true,
+          "coefficient_exact": true,
+          "m": 6,
+          "r": 5
+        },
+        {
+          "action_exact": true,
+          "coefficient_exact": true,
+          "m": 6,
+          "r": 6
+        }
+      ]
+    },
+    "claim_boundary": {
+      "analytic_continuation_outside_convergence_strip_required": true,
+      "capabilities_removed": [],
+      "distributional_contour_prescription_claimed": false,
+      "physical_null_state_interpretation_claimed": false,
+      "vanishing_boundary_terms_required": true
+    },
+    "exact_checks": {
+      "archive_hash_matches": true,
+      "celestial_weight_map_present": true,
+      "finite_grid_actions_exact": true,
+      "finite_grid_coefficients_exact": true,
+      "gamma_normalized_transform_present": true,
+      "grid_complete": true,
+      "member_hash_matches": true,
+      "nu_translation_present": true,
+      "source_blocks_match": true,
+      "weyl_commutator_exact": true
+    },
+    "paper": {
+      "arxiv_id": "2501.00462",
+      "title": "Multiparticle States for the Flat Hologram"
+    },
+    "result_version": "sabrina_carrollian_celestial_weyl_intertwiner_v1",
+    "source_evidence": {
+      "archive_sha256": "917ad8f25057f1316600fb9b9afb6b6c169b1ca05ad088781a84a025a23f0d38",
+      "block_hashes": {
+        "carrollian_celestial_transform": "99b2236cb63d76c4ac4930ce950570908609b9d211e0209b82dac6ffc9871a74"
+      },
+      "checks": {
+        "archive_hash_matches": true,
+        "celestial_weight_map_present": true,
+        "gamma_normalized_transform_present": true,
+        "member_hash_matches": true,
+        "nu_translation_present": true,
+        "source_blocks_match": true
+      },
+      "member_sha256": "2a2443a343ab2528110bacf66f32464a515ce3252fc36295895f57f9d6fb1e09"
+    },
+    "status": "complete",
+    "theorem": {
+      "all_orders_transform": "Z_nu[u^m partial_u^r Phi]=Gamma(nu)/Gamma(nu-m) Z_(nu+r-m)[Phi]",
+      "derivative_normalization": "Z_nu[partial_u^r Phi]=Z_(nu+r)[Phi] with unit coefficient",
+      "polynomial_reduction": "Gamma(nu)/Gamma(nu-m)=product_(j=1)^m(nu-j)",
+      "weyl_intertwining": "D=T_+ and U=(nu-1)T_- obey [D,U]=1"
+    }
+  },
+  "scientific_payload_sha256": "d0b52d420b0b0aae1fb470163344d5fb5916c44ba5527310e10482165c6132cd"
+}
diff --git a/references/run_sabrina_carrollian_conglomerate_kernel_stratification.json b/references/run_sabrina_carrollian_conglomerate_kernel_stratification.json
new file mode 100644
index 0000000000000000000000000000000000000000..809e10e4481a411d30a5ce19e0b04af25a7dfe5b
--- /dev/null
+++ b/references/run_sabrina_carrollian_conglomerate_kernel_stratification.json
@@ -0,0 +1,124 @@
+{
+  "kernel": "run_sabrina_carrollian_conglomerate_kernel_stratification",
+  "role": "post-computation assertion only",
+  "schema": "ouroboros_scientific_reference_assertion_v1",
+  "scientific_payload": {
+    "algebraic_certificate": {
+      "checks": {
+        "constraint_factorization_exact": true,
+        "generic_kernel_identity_exact": true,
+        "generic_outer_product_exact": true,
+        "left_boundary_basis_exact": true,
+        "rank_nullity_formula_exhaustive": true,
+        "right_boundary_basis_exact": true
+      },
+      "factorization": "A(alpha)=0 iff (k1,k2)X=0 and X(bar_k1,bar_k2)^T=0",
+      "generic_generator": [
+        "b*d",
+        "-b*c",
+        "-a*d",
+        "a*c"
+      ],
+      "kernel_isomorphism": "ker(A) is Hom(C^2/span(bar_k), ker(k))",
+      "matrix": [
+        [
+          "a",
+          "0",
+          "b",
+          "0"
+        ],
+        [
+          "0",
+          "a",
+          "0",
+          "b"
+        ],
+        [
+          "c",
+          "d",
+          "0",
+          "0"
+        ],
+        [
+          "0",
+          "0",
+          "c",
+          "d"
+        ]
+      ],
+      "strata": [
+        {
+          "constraint_rank": 3,
+          "left_pair_rank": 1,
+          "nullity": 1,
+          "right_pair_rank": 1
+        },
+        {
+          "constraint_rank": 2,
+          "left_pair_rank": 0,
+          "nullity": 2,
+          "right_pair_rank": 1
+        },
+        {
+          "constraint_rank": 2,
+          "left_pair_rank": 1,
+          "nullity": 2,
+          "right_pair_rank": 0
+        },
+        {
+          "constraint_rank": 0,
+          "left_pair_rank": 0,
+          "nullity": 4,
+          "right_pair_rank": 0
+        }
+      ]
+    },
+    "claim_boundary": {
+      "capabilities_removed": [],
+      "interacting_spectrum_claimed": false,
+      "null_state_quotient_claimed": false,
+      "physical_admissibility_of_zero_weight_strata_claimed": false
+    },
+    "exact_checks": {
+      "archive_hash_matches": true,
+      "both_lorentz_constraints_present": true,
+      "constraint_factorization_exact": true,
+      "four_coefficient_operator_present": true,
+      "generic_kernel_identity_exact": true,
+      "generic_outer_product_exact": true,
+      "left_boundary_basis_exact": true,
+      "member_hash_matches": true,
+      "published_kernel_vector_present": true,
+      "rank_nullity_formula_exhaustive": true,
+      "right_boundary_basis_exact": true,
+      "source_blocks_match": true
+    },
+    "paper": {
+      "arxiv_id": "2501.00462",
+      "title": "Multiparticle States for the Flat Hologram"
+    },
+    "result_version": "sabrina_carrollian_conglomerate_kernel_stratification_v1",
+    "source_evidence": {
+      "archive_sha256": "917ad8f25057f1316600fb9b9afb6b6c169b1ca05ad088781a84a025a23f0d38",
+      "block_hashes": {
+        "conglomerate_coefficient_system": "c505de34f3e7cce7148daa0c0951bdbd1bbc60c53945ea22cdda08b86c1d8e04"
+      },
+      "checks": {
+        "archive_hash_matches": true,
+        "both_lorentz_constraints_present": true,
+        "four_coefficient_operator_present": true,
+        "member_hash_matches": true,
+        "published_kernel_vector_present": true,
+        "source_blocks_match": true
+      },
+      "member_sha256": "2a2443a343ab2528110bacf66f32464a515ce3252fc36295895f57f9d6fb1e09"
+    },
+    "status": "complete",
+    "theorem": {
+      "boundary_locus": "if exactly one chiral pair vanishes the kernel is two-dimensional; if both vanish it is four-dimensional",
+      "generic_locus": "the published coefficient vector spans the kernel exactly when both chiral weight pairs are nonzero",
+      "precise_correction": "the scalar-multiple uniqueness statement requires the nonzero-pair hypothesis"
+    }
+  },
+  "scientific_payload_sha256": "3bd160a7dfa798b30b4390d34d11f59d48bd1398ec53c50dcc434e3fe64a4737"
+}
diff --git a/references/run_sabrina_causal_interior_inclusion_lemma.json b/references/run_sabrina_causal_interior_inclusion_lemma.json
new file mode 100644
index 0000000000000000000000000000000000000000..296ddba6b4f202f3dbb03a5beb62921fe5f349bb
--- /dev/null
+++ b/references/run_sabrina_causal_interior_inclusion_lemma.json
@@ -0,0 +1,89 @@
+{
+  "kernel": "run_sabrina_causal_interior_inclusion_lemma",
+  "role": "post-computation assertion only",
+  "schema": "ouroboros_scientific_reference_assertion_v1",
+  "scientific_payload": {
+    "claim_boundary": {
+      "capabilities_removed": [],
+      "closedness_automatic_without_causal_assumption": false,
+      "conformal_boundary_extension_proved": false,
+      "full_connected_wedge_theorem_reproved": false,
+      "mixed_state_extension_proved": false,
+      "n_to_n_extension_proved": false,
+      "source_error_claimed": false
+    },
+    "exact_checks": {
+      "archive_hash_matches": true,
+      "countermodel_failure_is_reflexive_point": true,
+      "dropping_interior_has_countermodel": true,
+      "expected_boundary_use_occurs_once": true,
+      "expected_inclusion_occurs_once": true,
+      "finite_push_up_models_all_pass": true,
+      "finite_push_up_models_nonempty": true,
+      "iff_statement_present": true,
+      "member_hash_matches": true,
+      "source_blocks_match": true
+    },
+    "paper": {
+      "arxiv_id": "2509.26264",
+      "title": "On sufficient conditions for holographic scattering"
+    },
+    "relation_certificate": {
+      "dropped_interior_countermodel": {
+        "A_equals_B": [
+          1
+        ],
+        "both_inclusions_fail": true,
+        "future_missing_points": [
+          1
+        ],
+        "past_missing_points": [
+          1
+        ],
+        "universe": [
+          0,
+          1,
+          2
+        ]
+      },
+      "finite_chain_models_checked": 2472,
+      "models_per_size": {
+        "3": 8,
+        "4": 22,
+        "5": 63,
+        "6": 185,
+        "7": 550,
+        "8": 1644
+      },
+      "violation_count": 0,
+      "violations": []
+    },
+    "result_version": "sabrina_causal_interior_inclusion_lemma_v1",
+    "source_evidence": {
+      "archive_sha256": "17edb31380f6f0e8856d0f3541a36ab4a6023551894698a45dbf44e7a37991e0",
+      "block_hashes": {
+        "connected_wedge_interior_step": "0acd2ad7d5f826b3491f5a93434815a10221b0c36a1e3d3ba717f8a5032bd280",
+        "future_directions": "991b34fb34ee0d068b2e68a8486d9ee42faca7752e729f0e2defa0f5d90e54e5",
+        "iff_summary": "b3c1294ca9af051db3b58680b34f87e19b3321c273f3196054d1e1532e65a0bc"
+      },
+      "checks": {
+        "archive_hash_matches": true,
+        "expected_boundary_use_occurs_once": true,
+        "expected_inclusion_occurs_once": true,
+        "iff_statement_present": true,
+        "member_hash_matches": true,
+        "source_blocks_match": true
+      },
+      "member_sha256": "0a4c40bb1e3e38c2da8a3c2ad0ced1f39e9071d9c9ec31dcab1ffd848f4ee9cb"
+    },
+    "status": "complete",
+    "theorem": {
+      "boundary_corollary": "if J^+(A) (respectively J^-(A)) is closed, then its boundary lies in that causal set and is disjoint from the boundary of J^+(B) (respectively J^-(B))",
+      "future": "J^+(A) is contained in I^+(B), hence in the interior of J^+(B)",
+      "hypotheses": "M is a time-oriented spacetime and A is a subset of the manifold interior of B",
+      "past": "J^-(A) is contained in I^-(B), hence in the interior of J^-(B)",
+      "proof": "for a in A choose b_- << a and b_+ >> a inside B; push-up gives b_- << y from a <= y and y << b_+ from y <= a"
+    }
+  },
+  "scientific_payload_sha256": "d99b817c432380bbff4836ba0a169029b609c9519bb2ee813a581878f4ac7531"
+}
diff --git a/references/run_sabrina_cdqs_amplification_singleton_obstruction.json b/references/run_sabrina_cdqs_amplification_singleton_obstruction.json
new file mode 100644
index 0000000000000000000000000000000000000000..505fc3af834a5ca74b95e285bfd17259b750cada
--- /dev/null
+++ b/references/run_sabrina_cdqs_amplification_singleton_obstruction.json
@@ -0,0 +1,94 @@
+{
+  "kernel": "run_sabrina_cdqs_amplification_singleton_obstruction",
+  "role": "post-computation assertion only",
+  "schema": "ouroboros_scientific_reference_assertion_v1",
+  "scientific_payload": {
+    "claim_boundary": {
+      "amplification_impossible_by_all_methods": false,
+      "capabilities_removed": [],
+      "cdqs_amplification_theorem_disproved": false,
+      "corrected_amplification_constructed": false,
+      "external_primary_source_locally_hash_pinned": false
+    },
+    "exact_checks": {
+      "arbitrary_error_claim_present": true,
+      "archive_hash_matches": true,
+      "base_error_exceeds_feasible_critical_value": true,
+      "base_error_present": true,
+      "chosen_alpha_repeated_consistently": true,
+      "chosen_beta_present": true,
+      "chosen_code_violates_singleton": true,
+      "claimed_gamma_present": true,
+      "dense_feasible_interval_all_positive": true,
+      "endpoint_sign_reduced_exactly": true,
+      "feasible_endpoint_exponent_positive": true,
+      "formal_chosen_exponent_is_negative": true,
+      "iid_threshold_has_nonempty_feasible_overlap": true,
+      "member_hash_matches": true,
+      "source_blocks_match": true
+    },
+    "obstruction_certificate": {
+      "iid_bound_exponent": {
+        "base_error_above_critical": true,
+        "chosen_alpha_exponent": "log((16069380442589902755419620923411626025222029937827928353013760000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000*exp(99)/342243006754497214485443249645813990751059732070716568543936815868940301575034686735225336447729307468584115174245740122709611535009385886402561100780239308476935874720288061945977461246662053274637340836487355792890658595154376799029579756193350955933659009857590063321243470034670724972781837355257414191)**(1/(200*log(2))))",
+        "chosen_alpha_would_decay": true,
+        "concavity_argument": "q is concave, q(0)=0, and q(1/4)>0, so q(alpha)>0 throughout 0<alpha<=1/4",
+        "critical_base_error_at_zero_rate_boundary": "27*exp(-1)/256",
+        "critical_base_error_decimal": "0.0387997848110",
+        "definition": "q_epsilon(alpha)=H2(alpha)+alpha log2(e epsilon); exponential decay from the cited estimate requires q_epsilon(alpha)<0",
+        "endpoint_exponent": "(log(64/75) + 1)/(4*log(2))",
+        "endpoint_positive": true,
+        "endpoint_sign_equivalent_to_256e_gt_300": true,
+        "singleton_feasible_interval": "0<alpha<=1/4"
+      },
+      "quantum_singleton": {
+        "chosen_alpha": "99/200",
+        "chosen_parameters_impossible": true,
+        "claimed_beta": "log((369729637649726772657187905628805440595668764281741102430259972423552570455277523421410650010128232727940978889548326540119429996769494359451621570193644014418071060667659301384999779999159200499899/88817841970012523233890533447265625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000)**(1/(50*log(2))))",
+        "claimed_beta_decimal": "0.838413728208",
+        "primary_reference": "https://arxiv.org/abs/2010.07902",
+        "singleton_rate_ceiling": "-49/50",
+        "statement": "for an [[m,k,d]] code, k+2(d-1)<=m; correcting arbitrary t-qubit errors needs d>=2t+1, hence k<=m-4t"
+      },
+      "rational_feasible_witness_count": 250,
+      "rational_feasible_witness_failures": [],
+      "threshold_applicable_witness_count": 168
+    },
+    "paper": {
+      "arxiv_id": "2404.14491",
+      "title": "Conditional disclosure of secrets with quantum resources"
+    },
+    "result": {
+      "exponent_obstruction": "after enforcing alpha<=1/4, the cited i.i.d. bound has positive rather than negative asymptotic exponent at epsilon=0.09",
+      "repair_classes": [
+        "first reduce the one-qubit base error below the feasible coding threshold",
+        "replace the cited arbitrary-error code/i.i.d. estimate with a compatible threshold theorem",
+        "supply a different amplification construction not requiring the inconsistent parameters"
+      ],
+      "singleton_obstruction": "the alpha=0.495, beta approximately 0.838 code used in the proof cannot correct arbitrary t-qubit errors"
+    },
+    "result_version": "sabrina_cdqs_amplification_singleton_obstruction_v1",
+    "source_evidence": {
+      "archive_sha256": "cbeaadef653abc7c51e2c763ac8c01ae7628c881c294903e367361e2704ac3c8",
+      "block_hashes": {
+        "cdqs_amplification_statement": "605c5df3fe268dcc4550521c2355e154c88ce950d1e19861e9d3ee589f7aafc9",
+        "discussion_scope": "d1ccd56634eb89812a8c42d9c36ddda4de7f5cb6047be60e9d78048aadb5f48b",
+        "good_code_claim": "69d0d37947b1286a3d03d6d4fb907b51ffd7c81748e2152a3fdfa37ee991873f",
+        "routing_amplification_proof": "7a1fc06464b25f40ce6c5a4414c75cf0edcd20527c10937c07b5143746abed85"
+      },
+      "checks": {
+        "arbitrary_error_claim_present": true,
+        "archive_hash_matches": true,
+        "base_error_present": true,
+        "chosen_alpha_repeated_consistently": true,
+        "chosen_beta_present": true,
+        "claimed_gamma_present": true,
+        "member_hash_matches": true,
+        "source_blocks_match": true
+      },
+      "member_sha256": "8e992c4195a75419859c17fadfa62b8e646a9056de804fc2e0334ac21d0a1ac0"
+    },
+    "status": "complete"
+  },
+  "scientific_payload_sha256": "030824c1879fcf5639d3fb849067dcd70eb43ab728bad7d3961c5fe44ac5f1b5"
+}
diff --git a/references/run_sabrina_cdqs_fidelity_envelope_strengthening.json b/references/run_sabrina_cdqs_fidelity_envelope_strengthening.json
new file mode 100644
index 0000000000000000000000000000000000000000..d5d12a38e802b258f074ea93344a5e714ca94408
--- /dev/null
+++ b/references/run_sabrina_cdqs_fidelity_envelope_strengthening.json
@@ -0,0 +1,110 @@
+{
+  "kernel": "run_sabrina_cdqs_fidelity_envelope_strengthening",
+  "role": "post-computation assertion only",
+  "schema": "ouroboros_scientific_reference_assertion_v1",
+  "scientific_payload": {
+    "claim_boundary": {
+      "alpha_zero_resolved": false,
+      "capabilities_removed": [],
+      "complexity_mutual_information_conjecture_proved": false,
+      "correctness_security_dependence_removed": false,
+      "finite_secret_dependence_removed": false,
+      "python_lunch_conjecture_proved": false
+    },
+    "envelope_certificate": {
+      "a_definition": "d_Q^(-1/2) + delta + epsilon",
+      "active_branch_difference": "-log(a) - 2*log(2) + 1",
+      "branch_thresholds": {
+        "active_region_margin_floor": "2 - 2*log(2)",
+        "exp_minus_one_less_than_half": true,
+        "margin_floor_positive": true,
+        "paper_bound_zero_at": "exp(-1)",
+        "strengthened_bound_zero_at": "1/2"
+      },
+      "dominance_proof": [
+        "for 0<a<exp(-1), both relevant expressions are active and the difference exceeds 2-2 log(2)>0",
+        "for exp(-1)<=a<1/2, the displayed bound is nonpositive while the strengthened bound is positive",
+        "for a>=1/2, the strengthened bound is zero while the displayed bound is strictly negative"
+      ],
+      "fidelity_cap": "F <= min(1, 2a)",
+      "paper_displayed_bound": "-log(a)-1",
+      "parameter_witnesses": [
+        {
+          "a": "14/25",
+          "d_Q": 4,
+          "delta": "1/20",
+          "epsilon": "1/100",
+          "strengthened_ge_displayed": true
+        },
+        {
+          "a": "27/100",
+          "d_Q": 16,
+          "delta": "1/100",
+          "epsilon": "1/100",
+          "strengthened_ge_displayed": true
+        },
+        {
+          "a": "8/125",
+          "d_Q": 256,
+          "delta": "1/1000",
+          "epsilon": "1/2000",
+          "strengthened_ge_displayed": true
+        },
+        {
+          "a": "3/5 + sqrt(2)/2",
+          "d_Q": 2,
+          "delta": "1/2",
+          "epsilon": "1/10",
+          "strengthened_ge_displayed": true
+        }
+      ],
+      "rational_witness_count": 400,
+      "rational_witness_failures": [],
+      "strengthened_envelope": "max(0, -2 log(2a))"
+    },
+    "exact_checks": {
+      "active_margin_positive": true,
+      "archive_hash_matches": true,
+      "dense_rational_witnesses_all_pass": true,
+      "fidelity_cap_present": true,
+      "future_direction_names_log_delta": true,
+      "member_hash_matches": true,
+      "parameter_witnesses_all_pass": true,
+      "relative_entropy_factor_two_present": true,
+      "source_blocks_match": true,
+      "stated_bound_label_unique": true,
+      "threshold_order_exact": true
+    },
+    "paper": {
+      "arxiv_id": "2411.10527",
+      "title": "Cryptographic tests of the python's lunch conjecture"
+    },
+    "result_version": "sabrina_cdqs_fidelity_envelope_strengthening_v1",
+    "source_evidence": {
+      "archive_sha256": "8baa6e7011dca7bf30ffdbe423d39c14f931ba65ff1dcaa8ead4afc0137c545a",
+      "block_hashes": {
+        "alpha_future_direction": "e915cd5863088a3df1ed4b46305f283db0f3c2975567c7ba77c5ded483a44017",
+        "fidelity_to_information_proof": "55529d90ddbc233f0fb3fa8d26e7cf6be3bea23729a93a2f86178592e7f08e18",
+        "stated_cdqs_bound": "9d38eccf29047e3b3f7da055d1c5249e3133e020a655cde20db8aaf4b1b772c4"
+      },
+      "checks": {
+        "archive_hash_matches": true,
+        "fidelity_cap_present": true,
+        "future_direction_names_log_delta": true,
+        "member_hash_matches": true,
+        "relative_entropy_factor_two_present": true,
+        "source_blocks_match": true,
+        "stated_bound_label_unique": true
+      },
+      "member_sha256": "e3d17f1c009c436fd22ace55f64c97e34c509fcf9ce47b395d3fadf719885d7d"
+    },
+    "status": "complete",
+    "theorem": {
+      "comparison": "the strengthened envelope strictly exceeds the displayed -ln(a)-1 lower bound for every a>0",
+      "derivation": "the proof gives F<=2a and I>=-2 ln F; universal F<=1 gives F<=min(1,2a)",
+      "parameter": "a=d_Q^(-1/2)+delta+epsilon>0",
+      "strengthened_bound": "I(A:B)_Psi >= max{0,-2 ln(2a)}"
+    }
+  },
+  "scientific_payload_sha256": "a74b4d88eeb5eac12a40fce9ce013f2e18f9e4a748ea1a973380efcbeadd519b"
+}
diff --git a/references/run_sabrina_celestial_circle_convex_hull_certificate.json b/references/run_sabrina_celestial_circle_convex_hull_certificate.json
new file mode 100644
index 0000000000000000000000000000000000000000..7c1608c3e2bd45e380f83cb47c3cb07c85503bfa
--- /dev/null
+++ b/references/run_sabrina_celestial_circle_convex_hull_certificate.json
@@ -0,0 +1,93 @@
+{
+  "kernel": "run_sabrina_celestial_circle_convex_hull_certificate",
+  "role": "post-computation assertion only",
+  "schema": "ouroboros_scientific_reference_assertion_v1",
+  "scientific_payload": {
+    "certificate_examples": {
+      "compact_intersection": {
+        "checks": {
+          "barycenters_equal": true,
+          "incoming_support_at_most_four": true,
+          "lengths_match": true,
+          "outgoing_support_at_most_four": true,
+          "weights_nonnegative": true,
+          "weights_normalized": true
+        },
+        "intersection_point": [
+          "0",
+          "0",
+          "0"
+        ],
+        "valid": true
+      },
+      "intersecting_hulls_reject_separator": true,
+      "strict_separator": {
+        "incoming_margins": [
+          "1",
+          "4/5",
+          "4/5",
+          "4/5"
+        ],
+        "minimum_margin": "4/5",
+        "outgoing_margins": [
+          "1",
+          "4/5",
+          "4/5",
+          "4/5"
+        ],
+        "valid": true
+      }
+    },
+    "claim_boundary": {
+      "amplitude_dynamics_computed": false,
+      "capabilities_removed": [],
+      "complexified_points_supported": false,
+      "degenerate_boundary_channel_classified": false,
+      "floating_point_robustness_guaranteed": false
+    },
+    "exact_checks": {
+      "archive_hash_matches": true,
+      "circle_rule_unique": true,
+      "compact_intersection_valid": true,
+      "dual_cone_argument_present": true,
+      "hyperplane_circle_map_present": true,
+      "intersecting_example_rejects_separator": true,
+      "member_hash_matches": true,
+      "source_blocks_match": true,
+      "strict_separator_margin_positive": "True",
+      "strict_separator_valid": true,
+      "strict_sign_condition_present": true
+    },
+    "paper": {
+      "arxiv_id": "2204.02505",
+      "title": "Celestial Geometry"
+    },
+    "result_version": "sabrina_celestial_circle_convex_hull_certificate_v1",
+    "source_evidence": {
+      "archive_sha256": "1268f6f1bc7479f48f32e0611e1aefae14149a7f4cdb5d858365165da08f6849",
+      "block_hashes": {
+        "circle_hyperplane_map": "406501fc02c2b0bcc3abd70083baf5b756ed4548786a2edee02b8ab53730e9fc",
+        "positive_cone_certificate": "bbf1c58529b9cf8e62af9f6df70d1eff9f16b52add24e10a84c6e6f949f130fd",
+        "selection_rule_summary": "5004306f2c3a3cd932686c791f3be3a4fec2dda6805c28717e8eaa6590eb8289"
+      },
+      "checks": {
+        "archive_hash_matches": true,
+        "circle_rule_unique": true,
+        "dual_cone_argument_present": true,
+        "hyperplane_circle_map_present": true,
+        "member_hash_matches": true,
+        "source_blocks_match": true,
+        "strict_sign_condition_present": true
+      },
+      "member_sha256": "df41a04ca45e7b4262ff4fb6b3623d4fa11264a1eb35aeeb9c4332ce9b90b3d9"
+    },
+    "status": "complete",
+    "theorem": {
+      "compactness": "Caratheodory's theorem reduces each side of an R^3 intersection certificate to at most four points",
+      "equivalence": "a strict celestial circle separates finite incoming and outgoing embedded points iff their convex hulls in R^3 are disjoint",
+      "obstruction_certificate": "an equal convex combination from each side proves hull intersection and forbids strict separation",
+      "separator_certificate": "a normal n and offset b with n.p_in>b>n.p_out for every point"
+    }
+  },
+  "scientific_payload_sha256": "e838335f66a4c68f81f7e6f5678fe10cea02f297400cd6d76dda8ab4d73e73eb"
+}
diff --git a/references/run_sabrina_celestial_eikonal_logarithm_gauge.json b/references/run_sabrina_celestial_eikonal_logarithm_gauge.json
new file mode 100644
index 0000000000000000000000000000000000000000..1cd52a8708c83e7ffd76a46621c2f387ea340bc3
--- /dev/null
+++ b/references/run_sabrina_celestial_eikonal_logarithm_gauge.json
@@ -0,0 +1,161 @@
+{
+  "kernel": "run_sabrina_celestial_eikonal_logarithm_gauge",
+  "role": "post-computation assertion only",
+  "schema": "ouroboros_scientific_reference_assertion_v1",
+  "scientific_payload": {
+    "certificate_witnesses": {
+      "conserved_spanning_witness": {
+        "all_null": true,
+        "contracted_shift": "0",
+        "direct_shift": "0",
+        "momenta": [
+          [
+            1,
+            1,
+            0,
+            0
+          ],
+          [
+            1,
+            -1,
+            0,
+            0
+          ],
+          [
+            1,
+            0,
+            1,
+            0
+          ],
+          [
+            1,
+            0,
+            -1,
+            0
+          ],
+          [
+            -2,
+            0,
+            0,
+            2
+          ],
+          [
+            -2,
+            0,
+            0,
+            -2
+          ]
+        ],
+        "rank": 4,
+        "total": [
+          0,
+          0,
+          0,
+          0
+        ]
+      },
+      "degenerate_converse_boundary": {
+        "direct_shift": "0",
+        "momenta": [
+          [
+            1,
+            0,
+            0,
+            1
+          ],
+          [
+            2,
+            0,
+            0,
+            2
+          ]
+        ],
+        "rank": 1,
+        "row_contractions": [
+          0,
+          0
+        ],
+        "total": [
+          3,
+          0,
+          0,
+          3
+        ]
+      },
+      "nonconserved_falsifier": {
+        "contracted_shift": "-4",
+        "direct_shift": "-4",
+        "momenta": [
+          [
+            1,
+            1,
+            0,
+            0
+          ],
+          [
+            1,
+            -1,
+            0,
+            0
+          ]
+        ],
+        "total": [
+          2,
+          0,
+          0,
+          0
+        ]
+      }
+    },
+    "claim_boundary": {
+      "capabilities_removed": [],
+      "full_loop_finite_remainder_computed": false,
+      "normalization_conventions_changed": false,
+      "stress_tensor_ope_derived": false
+    },
+    "exact_checks": {
+      "archive_hash_matches": true,
+      "conserved_shift_cancels": true,
+      "conserved_witness_is_null_spanning_and_closed": true,
+      "degenerate_converse_is_not_overclaimed": true,
+      "eikonal_factor_present": true,
+      "goldstone_memory_replacement_present": true,
+      "member_hash_matches": true,
+      "nonconserved_shift_is_detected": true,
+      "source_blocks_match": true,
+      "symbolic_master_identity": true,
+      "wilson_dressing_present": true
+    },
+    "paper": {
+      "arxiv_id": "2205.10901",
+      "title": "A Comment on Loop Corrections to the Celestial Stress Tensor"
+    },
+    "result_version": "sabrina_celestial_eikonal_logarithm_gauge_v1",
+    "source_evidence": {
+      "archive_sha256": "eb03e2135b623ef961155841b0f1fb48f90fc86e47b8d8ccd3f73c7b4174522b",
+      "block_hashes": {
+        "eikonal_soft_loop": "d1a6896c759364bb6fba03654a53da45d5dbe3ecdb746b7a521c481b349a2622",
+        "goldstone_memory_stress": "1a2bda42a3b56b59d2265125bf2bc35ee7157334aa5b0cfea6dd178cd06f49a2",
+        "goldstone_wilson_dressing": "86ffc890a6e025062ad912e11d896d2cb93c7b8bdc37da6e3970dd5e7788d2fe"
+      },
+      "checks": {
+        "archive_hash_matches": true,
+        "eikonal_factor_present": true,
+        "goldstone_memory_replacement_present": true,
+        "member_hash_matches": true,
+        "source_blocks_match": true,
+        "wilson_dressing_present": true
+      },
+      "member_sha256": "724cdb5aaf9f999c497e21788a00721b030c3219aecda095bc174a512f496b87"
+    },
+    "status": "complete",
+    "theorem": {
+      "boundary": "without the spanning condition, parallel null nonconserved momenta can cancel every separable shift, so cancellation alone does not prove momentum conservation",
+      "exact_converse": "cancellation for every independent a_i implies p_i dot P=0 for every participating leg (and hence P dot P=0)",
+      "forward": "signed momentum conservation P=0 removes every leg-separable logarithm shift a_i+a_j+c from the Eikonal/Wilson-line exponent",
+      "master_identity": "Delta=2 sum_i a_i (p_i dot P)+c(P dot P), P=sum_i p_i, for null external momenta and ordered i!=j pair sums",
+      "spanning_converse": "if the participating momenta span a nondegenerate four-dimensional momentum space, those row contractions force P=0"
+    }
+  },
+  "scientific_payload_sha256": "496aa27aa4e52fa3a6f9da412561aaa652cf21690744c98593d94d0ffbe1e6f8"
+}
diff --git a/references/run_sabrina_celestial_euclidean_monodromy_cancellation.json b/references/run_sabrina_celestial_euclidean_monodromy_cancellation.json
new file mode 100644
index 0000000000000000000000000000000000000000..7bfb7eb8be477e624aeec81504b2889df2b0f31f
--- /dev/null
+++ b/references/run_sabrina_celestial_euclidean_monodromy_cancellation.json
@@ -0,0 +1,163 @@
+{
+  "kernel": "run_sabrina_celestial_euclidean_monodromy_cancellation",
+  "role": "post-computation assertion only",
+  "schema": "ouroboros_scientific_reference_assertion_v1",
+  "scientific_payload": {
+    "claim_boundary": {
+      "branch_term_vanishes": false,
+      "capabilities_removed": [],
+      "complexified_branch_cut_removed": false,
+      "full_ope_associativity_reproved": false,
+      "hard_celestial_jacobi_restored": false
+    },
+    "exact_checks": {
+      "arbitrary_branch_cuts_allowed": true,
+      "archive_hash_matches": true,
+      "branch_asymptotic_unique": true,
+      "double_residue_formula_present": true,
+      "euclidean_cancellation_exact": true,
+      "euclidean_cancellation_stated": true,
+      "generic_off_locus_nontrivial": true,
+      "integer_spin_single_valued": true,
+      "member_hash_matches": true,
+      "rational_euclidean_grid_passes": true,
+      "source_blocks_match": true
+    },
+    "monodromy_certificate": {
+      "domain_distinction": {
+        "complexified_contour": "eta and bar-eta are independent; holding bar-eta fixed leaves exp(2 pi i alpha)",
+        "contour_consequence": "the off-locus branch discontinuity obstructs ordinary meromorphic contour pulling",
+        "euclidean_locus": "bar-eta is the complex conjugate and winds oppositely, so scalar alpha=beta monodromy cancels"
+      },
+      "euclidean_scalar_cancels": true,
+      "euclidean_scalar_factor": "1",
+      "generic_off_locus_witness": {
+        "alpha": "1/3",
+        "factor": "exp(2*I*pi/3)",
+        "nontrivial": true
+      },
+      "holomorphic_fixed_bar_eta_factor": "exp(2*I*pi*alpha)",
+      "integer_spin_rows": [
+        {
+          "factor": "1",
+          "spin": -8,
+          "trivial": true
+        },
+        {
+          "factor": "1",
+          "spin": -7,
+          "trivial": true
+        },
+        {
+          "factor": "1",
+          "spin": -6,
+          "trivial": true
+        },
+        {
+          "factor": "1",
+          "spin": -5,
+          "trivial": true
+        },
+        {
+          "factor": "1",
+          "spin": -4,
+          "trivial": true
+        },
+        {
+          "factor": "1",
+          "spin": -3,
+          "trivial": true
+        },
+        {
+          "factor": "1",
+          "spin": -2,
+          "trivial": true
+        },
+        {
+          "factor": "1",
+          "spin": -1,
+          "trivial": true
+        },
+        {
+          "factor": "1",
+          "spin": 0,
+          "trivial": true
+        },
+        {
+          "factor": "1",
+          "spin": 1,
+          "trivial": true
+        },
+        {
+          "factor": "1",
+          "spin": 2,
+          "trivial": true
+        },
+        {
+          "factor": "1",
+          "spin": 3,
+          "trivial": true
+        },
+        {
+          "factor": "1",
+          "spin": 4,
+          "trivial": true
+        },
+        {
+          "factor": "1",
+          "spin": 5,
+          "trivial": true
+        },
+        {
+          "factor": "1",
+          "spin": 6,
+          "trivial": true
+        },
+        {
+          "factor": "1",
+          "spin": 7,
+          "trivial": true
+        },
+        {
+          "factor": "1",
+          "spin": 8,
+          "trivial": true
+        }
+      ],
+      "paired_opposite_winding_factor": "exp(2*I*pi*(alpha - beta))",
+      "rational_euclidean_witness_count": 143,
+      "rational_euclidean_witness_failures": []
+    },
+    "paper": {
+      "arxiv_id": "2309.16602",
+      "title": "Multicollinear Singularities in Celestial CFT"
+    },
+    "result_version": "sabrina_celestial_euclidean_monodromy_cancellation_v1",
+    "source_evidence": {
+      "archive_sha256": "d1ffa83185733baeb25b8254be688a99db0101bf43540afc8980c1cf2f8f9ff0",
+      "block_hashes": {
+        "double_residue_contours": "1b403d9e4962269f8c86a8d203bc2415677cb6af855faa8d9d2742265cc35661",
+        "locality_and_new_ope": "85f7b814ea1a5127899bd8aae5759e43601d498d00f86bda24fe842d21dde240",
+        "master_branch_asymptotic": "259196b8dc95cec88c0e2f9e9d63bb5d5667af07866ce60f0adba320e4e821f8"
+      },
+      "checks": {
+        "arbitrary_branch_cuts_allowed": true,
+        "archive_hash_matches": true,
+        "branch_asymptotic_unique": true,
+        "double_residue_formula_present": true,
+        "euclidean_cancellation_stated": true,
+        "member_hash_matches": true,
+        "source_blocks_match": true
+      },
+      "member_sha256": "7fad289115b12dffed9a1e89d10b6d2f6010b43aa4ca2ddb6ddf603f8e464d12"
+    },
+    "status": "complete",
+    "theorem": {
+      "complexified_obstruction": "with bar-eta fixed, eta^alpha retains exp(2 pi i alpha), generically obstructing contour pulling",
+      "euclidean_scalar": "for beta=alpha the paired monodromy is exactly one",
+      "integer_spin_extension": "paired Euclidean monodromy is single-valued whenever alpha-beta is an integer",
+      "paired_monodromy": "eta^alpha bar-eta^beta acquires exp(2 pi i(alpha-beta)) under opposite winding"
+    }
+  },
+  "scientific_payload_sha256": "a1a2263b72c97030c657dcafd5ebb59be09b6c15290e6578fd342c0c83eba049"
+}
diff --git a/references/run_sabrina_celestial_momentum_rising_factorial.json b/references/run_sabrina_celestial_momentum_rising_factorial.json
new file mode 100644
index 0000000000000000000000000000000000000000..9d3e04477fa38b6c64bbbd58cac74be3942e4f63
--- /dev/null
+++ b/references/run_sabrina_celestial_momentum_rising_factorial.json
@@ -0,0 +1,201 @@
+{
+  "kernel": "run_sabrina_celestial_momentum_rising_factorial",
+  "role": "post-computation assertion only",
+  "schema": "ouroboros_scientific_reference_assertion_v1",
+  "scientific_payload": {
+    "all_order_proof": {
+      "division_step": "the coefficient ratio is (Delta)_r/Delta^r",
+      "fixed_K_product": "product_i K^Delta_(mui)=Delta^r product_i q_(mui)/(-q dot X)^r",
+      "normalized_wavefunction_ratio": "phi^(Delta+r)/phi^Delta=(Delta)_r/(-q dot X)^r",
+      "shift_iteration": "P^r contributes q_(mu1)...q_(mur) phi^(Delta+r)"
+    },
+    "claim_boundary": {
+      "analytic_continuation_required_at_divisor": true,
+      "capabilities_removed": [],
+      "interacting_amplitude_validity_claimed": false,
+      "on_shell_operator_subtleties_resolved": false,
+      "singular_weight_factors_separately_evaluable": false
+    },
+    "exact_checks": {
+      "all_normalized_shift_ratios_exact": true,
+      "all_product_formulas_exact": true,
+      "all_recurrences_exact": true,
+      "archive_hash_matches": true,
+      "divisor_rows_exact": true,
+      "member_hash_matches": true,
+      "operator_ordering_warning_present": true,
+      "source_blocks_match": true,
+      "source_double_action_present": true,
+      "source_order_two_factor_exact": true,
+      "translation_shift_present": true
+    },
+    "exact_rows": [
+      {
+        "coefficient_ratio_matches": true,
+        "fixed_celestial_momentum_product_coefficient": "1",
+        "normalized_wavefunction_shift_coefficient": "1",
+        "order": 0,
+        "pole_order_at_delta_zero": 0,
+        "prefactor": "1",
+        "product_formula_matches": true,
+        "recurrence_matches": true,
+        "simple_prefactor_zeros": []
+      },
+      {
+        "coefficient_ratio_matches": true,
+        "fixed_celestial_momentum_product_coefficient": "Delta",
+        "normalized_wavefunction_shift_coefficient": "Delta",
+        "order": 1,
+        "pole_order_at_delta_zero": 0,
+        "prefactor": "1",
+        "product_formula_matches": true,
+        "recurrence_matches": true,
+        "simple_prefactor_zeros": []
+      },
+      {
+        "coefficient_ratio_matches": true,
+        "fixed_celestial_momentum_product_coefficient": "Delta**2",
+        "normalized_wavefunction_shift_coefficient": "Delta*(Delta + 1)",
+        "order": 2,
+        "pole_order_at_delta_zero": 1,
+        "prefactor": "(Delta + 1)/Delta",
+        "product_formula_matches": true,
+        "recurrence_matches": true,
+        "simple_prefactor_zeros": [
+          "-1"
+        ]
+      },
+      {
+        "coefficient_ratio_matches": true,
+        "fixed_celestial_momentum_product_coefficient": "Delta**3",
+        "normalized_wavefunction_shift_coefficient": "Delta*(Delta + 1)*(Delta + 2)",
+        "order": 3,
+        "pole_order_at_delta_zero": 2,
+        "prefactor": "(Delta**2 + 3*Delta + 2)/Delta**2",
+        "product_formula_matches": true,
+        "recurrence_matches": true,
+        "simple_prefactor_zeros": [
+          "-1",
+          "-2"
+        ]
+      },
+      {
+        "coefficient_ratio_matches": true,
+        "fixed_celestial_momentum_product_coefficient": "Delta**4",
+        "normalized_wavefunction_shift_coefficient": "Delta*(Delta + 1)*(Delta + 2)*(Delta + 3)",
+        "order": 4,
+        "pole_order_at_delta_zero": 3,
+        "prefactor": "(Delta**3 + 6*Delta**2 + 11*Delta + 6)/Delta**3",
+        "product_formula_matches": true,
+        "recurrence_matches": true,
+        "simple_prefactor_zeros": [
+          "-1",
+          "-2",
+          "-3"
+        ]
+      },
+      {
+        "coefficient_ratio_matches": true,
+        "fixed_celestial_momentum_product_coefficient": "Delta**5",
+        "normalized_wavefunction_shift_coefficient": "Delta*(Delta + 1)*(Delta + 2)*(Delta + 3)*(Delta + 4)",
+        "order": 5,
+        "pole_order_at_delta_zero": 4,
+        "prefactor": "(Delta**4 + 10*Delta**3 + 35*Delta**2 + 50*Delta + 24)/Delta**4",
+        "product_formula_matches": true,
+        "recurrence_matches": true,
+        "simple_prefactor_zeros": [
+          "-1",
+          "-2",
+          "-3",
+          "-4"
+        ]
+      },
+      {
+        "coefficient_ratio_matches": true,
+        "fixed_celestial_momentum_product_coefficient": "Delta**6",
+        "normalized_wavefunction_shift_coefficient": "Delta*(Delta + 1)*(Delta + 2)*(Delta + 3)*(Delta + 4)*(Delta + 5)",
+        "order": 6,
+        "pole_order_at_delta_zero": 5,
+        "prefactor": "(Delta**5 + 15*Delta**4 + 85*Delta**3 + 225*Delta**2 + 274*Delta + 120)/Delta**5",
+        "product_formula_matches": true,
+        "recurrence_matches": true,
+        "simple_prefactor_zeros": [
+          "-1",
+          "-2",
+          "-3",
+          "-4",
+          "-5"
+        ]
+      },
+      {
+        "coefficient_ratio_matches": true,
+        "fixed_celestial_momentum_product_coefficient": "Delta**7",
+        "normalized_wavefunction_shift_coefficient": "Delta*(Delta + 1)*(Delta + 2)*(Delta + 3)*(Delta + 4)*(Delta + 5)*(Delta + 6)",
+        "order": 7,
+        "pole_order_at_delta_zero": 6,
+        "prefactor": "(Delta**6 + 21*Delta**5 + 175*Delta**4 + 735*Delta**3 + 1624*Delta**2 + 1764*Delta + 720)/Delta**6",
+        "product_formula_matches": true,
+        "recurrence_matches": true,
+        "simple_prefactor_zeros": [
+          "-1",
+          "-2",
+          "-3",
+          "-4",
+          "-5",
+          "-6"
+        ]
+      },
+      {
+        "coefficient_ratio_matches": true,
+        "fixed_celestial_momentum_product_coefficient": "Delta**8",
+        "normalized_wavefunction_shift_coefficient": "Delta*(Delta + 1)*(Delta + 2)*(Delta + 3)*(Delta + 4)*(Delta + 5)*(Delta + 6)*(Delta + 7)",
+        "order": 8,
+        "pole_order_at_delta_zero": 7,
+        "prefactor": "(Delta**7 + 28*Delta**6 + 322*Delta**5 + 1960*Delta**4 + 6769*Delta**3 + 13132*Delta**2 + 13068*Delta + 5040)/Delta**7",
+        "product_formula_matches": true,
+        "recurrence_matches": true,
+        "simple_prefactor_zeros": [
+          "-1",
+          "-2",
+          "-3",
+          "-4",
+          "-5",
+          "-6",
+          "-7"
+        ]
+      }
+    ],
+    "paper": {
+      "arxiv_id": "2012.15694",
+      "title": "Shifting Spin on the Celestial Sphere"
+    },
+    "result_version": "sabrina_celestial_momentum_rising_factorial_v1",
+    "source_evidence": {
+      "archive_sha256": "ff00948d397a3aaaa36cec9a65f63477b16c6315c982669e63259b0a8961fc46",
+      "block_hashes": {
+        "celestial_momentum_double_action": "d884d68039e9c2aa2a19ee2127b3d1d60772dafcaec39591795d980805574763",
+        "operator_ordering_boundary": "16f999a9960a0f011eb2591446ed5dbc559a33fca3d2098ec4f2fff7a9c25eda",
+        "translation_shift": "3f9d6612c648c75b53b6d68fd334a629f865d07e62e9368e70aa712d86b62a2a"
+      },
+      "checks": {
+        "archive_hash_matches": true,
+        "member_hash_matches": true,
+        "operator_ordering_warning_present": true,
+        "source_blocks_match": true,
+        "source_double_action_present": true,
+        "translation_shift_present": true
+      },
+      "member_sha256": "17ed9a4bf99bf5a3a53a11d7da5c3000c4b99db7688432072e6703a597671794"
+    },
+    "status": "complete",
+    "theorem": {
+      "all_order_identity": "P_(mu1)...P_(mur) phi^Delta = [(Delta)_r/Delta^r] product_i K^Delta_(mui) phi^Delta",
+      "divisor": "R_r has a pole of order r-1 at Delta=0 and simple zeros at Delta=-1,...,-(r-1)",
+      "initial_values": "R_0(Delta)=R_1(Delta)=1",
+      "product_form": "R_r(Delta)=product_(j=1)^(r-1)(Delta+j)/Delta^(r-1) for r>=2",
+      "recurrence": "R_(r+1)(Delta)=R_r(Delta)(1+r/Delta)",
+      "source_special_case": "R_2=(Delta+1)/Delta=1+1/Delta"
+    }
+  },
+  "scientific_payload_sha256": "643a45bec4e1890d5a2fb13854b61ccd5e0eccb5cce7a7a293ce045edef79e9c"
+}
diff --git a/references/run_sabrina_celestial_recursion_pde_generating_function.json b/references/run_sabrina_celestial_recursion_pde_generating_function.json
new file mode 100644
index 0000000000000000000000000000000000000000..44b723279a2666f3ca82c6a974e9734b4390772d
--- /dev/null
+++ b/references/run_sabrina_celestial_recursion_pde_generating_function.json
@@ -0,0 +1,449 @@
+{
+  "kernel": "run_sabrina_celestial_recursion_pde_generating_function",
+  "role": "post-computation assertion only",
+  "schema": "ouroboros_scientific_reference_assertion_v1",
+  "scientific_payload": {
+    "certificate_witnesses": {
+      "generating_function": "1/((1-a*x)*(1-b*x))",
+      "rational_kinematics": [
+        {
+          "a": "1/2",
+          "all_exact": true,
+          "b": "2/3",
+          "coefficients": [
+            "1",
+            "-7/10",
+            "37/100",
+            "-7/40",
+            "781/10000",
+            "-3367/100000",
+            "14197/1000000",
+            "-2359/400000",
+            "242461/100000000",
+            "-989527/1000000000",
+            "4017157/10000000000",
+            "-649831/4000000000",
+            "65514541/1000000000000"
+          ],
+          "coincident": false,
+          "coincident_residuals": [],
+          "divided_difference_residuals": [
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0"
+          ],
+          "generating_function_residuals": [
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0"
+          ],
+          "max_p": 12,
+          "omega": "3/5",
+          "recurrence_residuals": [
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0"
+          ]
+        },
+        {
+          "a": "-1/3",
+          "all_exact": true,
+          "b": "4/5",
+          "coefficients": [
+            "1",
+            "-49/60",
+            "5341/3600",
+            "-405769/216000",
+            "35585221/12960000",
+            "-2936636689/777600000",
+            "248515747501/46656000000",
+            "-20810983493209/2799360000000",
+            "1750374488820181/167961600000000",
+            "-146952641422223329/10077696000000000",
+            "12346780426820275261/604661760000000000",
+            "-1037033006695530075049/36279705600000000000",
+            "87114151782932582944741/2176782336000000000000"
+          ],
+          "coincident": false,
+          "coincident_residuals": [],
+          "divided_difference_residuals": [
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0"
+          ],
+          "generating_function_residuals": [
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0"
+          ],
+          "max_p": 12,
+          "omega": "7/4",
+          "recurrence_residuals": [
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0"
+          ]
+        },
+        {
+          "a": "2",
+          "all_exact": true,
+          "b": "2",
+          "coefficients": [
+            "1",
+            "-4/3",
+            "4/3",
+            "-32/27",
+            "80/81",
+            "-64/81",
+            "448/729",
+            "-1024/2187",
+            "256/729",
+            "-5120/19683",
+            "11264/59049",
+            "-8192/59049",
+            "53248/531441"
+          ],
+          "coincident": true,
+          "coincident_residuals": [
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0"
+          ],
+          "divided_difference_residuals": [
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0"
+          ],
+          "generating_function_residuals": [
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0"
+          ],
+          "max_p": 12,
+          "omega": "1/3",
+          "recurrence_residuals": [
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0"
+          ]
+        },
+        {
+          "a": "0",
+          "all_exact": true,
+          "b": "0",
+          "coefficients": [
+            "1",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0"
+          ],
+          "coincident": true,
+          "coincident_residuals": [
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0"
+          ],
+          "divided_difference_residuals": [
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0"
+          ],
+          "generating_function_residuals": [
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0"
+          ],
+          "max_p": 12,
+          "omega": "5/7",
+          "recurrence_residuals": [
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0"
+          ]
+        },
+        {
+          "a": "3/4",
+          "all_exact": true,
+          "b": "3/4",
+          "coefficients": [
+            "1",
+            "3/5",
+            "27/100",
+            "27/250",
+            "81/2000",
+            "729/50000",
+            "5103/1000000",
+            "2187/1250000",
+            "59049/100000000",
+            "19683/100000000",
+            "649539/10000000000",
+            "531441/25000000000",
+            "6908733/1000000000000"
+          ],
+          "coincident": true,
+          "coincident_residuals": [
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0"
+          ],
+          "divided_difference_residuals": [
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0"
+          ],
+          "generating_function_residuals": [
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0"
+          ],
+          "max_p": 12,
+          "omega": "-2/5",
+          "recurrence_residuals": [
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0",
+            "0"
+          ]
+        }
+      ],
+      "resummed_pde_kernel": "1/((1+Omega*a*x)*(1+Omega*b*x))",
+      "symbolic_recurrence_residuals_p0_to_p5": [
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0"
+      ]
+    },
+    "claim_boundary": {
+      "capabilities_removed": [],
+      "convergence_beyond_formal_series_proved": false,
+      "free_operator_commutativity_asserted": false,
+      "non_mhv_sector_proved": false
+    },
+    "exact_checks": {
+      "archive_hash_matches": true,
+      "coincident_limits_exact": true,
+      "complete_homogeneous_sum_present": true,
+      "distinct_divided_differences_exact": true,
+      "exponential_shift_seed_present": true,
+      "member_hash_matches": true,
+      "p_indexed_tower_present": true,
+      "rational_generating_function_exact": true,
+      "rational_witnesses_exact_through_p12": true,
+      "source_blocks_match": true,
+      "symbolic_second_order_recurrence_exact": true,
+      "taylor_seed_present": true
+    },
+    "paper": {
+      "arxiv_id": "2208.11635",
+      "title": "Celestial Recursion"
+    },
+    "result_version": "sabrina_celestial_recursion_pde_generating_function_v1",
+    "source_evidence": {
+      "archive_sha256": "bb41217149756d1b5a56ca91fd7a5c99c511d0be8b8e54f15c900914c712bd77",
+      "block_hashes": {
+        "pde_tower": "651b7d2e3f252acd15cde8eb3cf9cb048ac454c58bfc0fcb493f3bafbe9197ea",
+        "shift_taylor_seed": "cf5e7223ab84469191344fea116685d7c771dfc6ac5f485d811224cd54a25f5c"
+      },
+      "checks": {
+        "archive_hash_matches": true,
+        "complete_homogeneous_sum_present": true,
+        "exponential_shift_seed_present": true,
+        "member_hash_matches": true,
+        "p_indexed_tower_present": true,
+        "source_blocks_match": true,
+        "taylor_seed_present": true
+      },
+      "member_sha256": "2774400bc31506d0693cc7c189a7618ee8d7ae8983b96d8fb8cb4d4f427dd650"
+    },
+    "status": "complete",
+    "theorem": {
+      "coefficient_closed_form": "S_p(a,b)=sum_(l=0)^p a^(p-l)b^l=(a^(p+1)-b^(p+1))/(a-b)",
+      "coincident_limit": "the removable a=b limit is S_p(a,a)=(p+1)a^p",
+      "generating_function": "sum_(p>=0) S_p x^p=1/((1-ax)(1-bx))",
+      "pde_resummation": "the termwise Taylor identities resum on the amplitude to exp(xD)A=A/((1+Omega*a*x)(1+Omega*b*x))",
+      "recurrence": "S_(p+2)=(a+b)S_(p+1)-ab S_p"
+    }
+  },
+  "scientific_payload_sha256": "94cf744ae42b66c5db61c4d853a7867562d928a7eb80e7cc3297657eb8fcf1cd"
+}
diff --git a/references/run_sabrina_coulomb_branch_complexity_ratio.json b/references/run_sabrina_coulomb_branch_complexity_ratio.json
new file mode 100644
index 0000000000000000000000000000000000000000..dd1a8990deb76782afe34322e20e5b619baa374c
--- /dev/null
+++ b/references/run_sabrina_coulomb_branch_complexity_ratio.json
@@ -0,0 +1,104 @@
+{
+  "kernel": "run_sabrina_coulomb_branch_complexity_ratio",
+  "role": "post-computation assertion only",
+  "schema": "ouroboros_scientific_reference_assertion_v1",
+  "scientific_payload": {
+    "algebraic_certificate": {
+      "checks": {
+        "deficit_factorization_exact": true,
+        "derivative_factorization_exact": true,
+        "formation_is_negative": true,
+        "half_plus_square_decomposition_exact": true,
+        "physical_bounds_exact": true,
+        "physical_table_exact": true,
+        "ratio_from_source_coefficients_exact": true,
+        "unique_physical_minimum_at_p3": true
+      },
+      "derivative": "-(p - 15)*(p - 3)/(16*(p - 9)**2)",
+      "fractional_deficit": "(p - 7)*(p + 9)/(16*(p - 9))",
+      "half_plus_square": "1/2 + (p - 3)**2/(144 - 16*p)",
+      "physical_table": [
+        {
+          "flat_over_throat": "9/16",
+          "fractional_deficit": "7/16",
+          "p": 0
+        },
+        {
+          "flat_over_throat": "17/32",
+          "fractional_deficit": "15/32",
+          "p": 1
+        },
+        {
+          "flat_over_throat": "57/112",
+          "fractional_deficit": "55/112",
+          "p": 2
+        },
+        {
+          "flat_over_throat": "1/2",
+          "fractional_deficit": "1/2",
+          "p": 3
+        },
+        {
+          "flat_over_throat": "41/80",
+          "fractional_deficit": "39/80",
+          "p": 4
+        }
+      ],
+      "ratio": "-(p**2 - 14*p + 81)/(16*(p - 9))"
+    },
+    "claim_boundary": {
+      "capabilities_removed": [],
+      "complexity_equals_action_claimed": false,
+      "complexity_equals_volume_only": true,
+      "field_theory_circuit_complexity_equality_claimed": false,
+      "physical_integer_p_zero_through_four_only": true
+    },
+    "exact_checks": {
+      "archive_hash_matches": true,
+      "deficit_factorization_exact": true,
+      "derivative_factorization_exact": true,
+      "flat_formula_present": true,
+      "formation_formula_present": true,
+      "formation_is_negative": true,
+      "half_plus_square_decomposition_exact": true,
+      "member_hash_matches": true,
+      "physical_bounds_exact": true,
+      "physical_p_range_present": true,
+      "physical_table_exact": true,
+      "ratio_from_source_coefficients_exact": true,
+      "source_blocks_match": true,
+      "throat_formula_present": true,
+      "unique_physical_minimum_at_p3": true
+    },
+    "paper": {
+      "arxiv_id": "2606.13889",
+      "title": "Flat Space Entanglement: A Coulomb Branch Perspective"
+    },
+    "result_version": "sabrina_coulomb_branch_complexity_ratio_v1",
+    "source_evidence": {
+      "archive_sha256": "0c66795a0adac63d23dac9ad3207a4bd586f7453365221b95159bca9380edbc3",
+      "block_hashes": {
+        "complexity_volume_formulas": "c7ab6918da6e15b37f48e4de2ea3403897be7be511e54772e0bc51b985e2a334"
+      },
+      "checks": {
+        "archive_hash_matches": true,
+        "flat_formula_present": true,
+        "formation_formula_present": true,
+        "member_hash_matches": true,
+        "physical_p_range_present": true,
+        "source_blocks_match": true,
+        "throat_formula_present": true
+      },
+      "member_sha256": "3612980847a10a3a07708a1af3dcee65afedc85ffc8106af673e69ae3d42585e"
+    },
+    "status": "complete",
+    "theorem": {
+      "manifest_minimum": "ratio=1/2+(p-3)^2/[16(9-p)]",
+      "maximal_reduction": "p=3 uniquely gives a one-half fractional complexity reduction",
+      "parameter_cancellation": "R, r_p, G_10, Omega_(8-p), and V_p cancel from the ratio",
+      "physical_bounds": "1/2 <= C_flat/C_throat <= 9/16 for p=0,1,2,3,4",
+      "universal_ratio": "C_flat/C_throat=[32+(7-p)^2]/[16(9-p)]"
+    }
+  },
+  "scientific_payload_sha256": "0a48392a955f724766d46453ed8d209ae2f1cfca84d21c71d0807b479504eb06"
+}
diff --git a/references/run_sabrina_detector_sum_identity_correction.json b/references/run_sabrina_detector_sum_identity_correction.json
new file mode 100644
index 0000000000000000000000000000000000000000..54ea8b8e1ab5ffab03c4d13c73e5a839af8dc411
--- /dev/null
+++ b/references/run_sabrina_detector_sum_identity_correction.json
@@ -0,0 +1,1435 @@
+{
+  "kernel": "run_sabrina_detector_sum_identity_correction",
+  "role": "post-computation assertion only",
+  "schema": "ouroboros_scientific_reference_assertion_v1",
+  "scientific_payload": {
+    "claim_boundary": {
+      "capabilities_removed": [],
+      "downstream_physics_correction_established": false,
+      "notation_ambiguity_requires_erratum": false,
+      "source_equation_correction_established": false
+    },
+    "classification": "v1_false_positive_superseded_source_local_falling_factorial_identity_exact",
+    "convention_certificate": {
+      "closed_form": "sum rising_factorial(kprime,n)/n! = binomial(kprime+K,K)",
+      "derivative_rule": "d^n omega^a / d omega^n = falling_factorial(a,n) omega^(a-n)",
+      "sign_conversion": "falling_factorial(-kprime,n)(-1)^n = rising_factorial(kprime,n)",
+      "source_local_notation": "falling_factorial(a,n)=Gamma(a+1)/Gamma(a-n+1)",
+      "symbolic_recurrence_residual": "0"
+    },
+    "exact_checks": {
+      "archive_hash_matches": true,
+      "derivative_falling_factorial_holds_through_order_12": true,
+      "displayed_final_kprime2_cutoff2_is_six": true,
+      "downstream_reference_contexts_match": true,
+      "downstream_reference_count_is_two": true,
+      "falling_negative_to_rising_positive_holds_through_order_12": true,
+      "main_tex_hash_matches": true,
+      "predecessor_manifest_hash_matches": true,
+      "source_equation_blocks_match": true,
+      "source_local_identity_holds_on_full_0_through_12_grid": true,
+      "source_local_kprime2_cutoff2_is_six": true,
+      "source_markers_are_unique": true,
+      "symbolic_base_case_is_one": true,
+      "symbolic_recurrence_residual_is_zero": true,
+      "v1_rising_misread_kprime2_cutoff2_is_four": true
+    },
+    "grid_rows": [
+      {
+        "cutoff": 0,
+        "displayed_final": "1",
+        "kprime": 0,
+        "rising_misread_sum": "1",
+        "source_local_falling_sum": "1",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 1,
+        "displayed_final": "1",
+        "kprime": 0,
+        "rising_misread_sum": "1",
+        "source_local_falling_sum": "1",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 2,
+        "displayed_final": "1",
+        "kprime": 0,
+        "rising_misread_sum": "1",
+        "source_local_falling_sum": "1",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 3,
+        "displayed_final": "1",
+        "kprime": 0,
+        "rising_misread_sum": "1",
+        "source_local_falling_sum": "1",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 4,
+        "displayed_final": "1",
+        "kprime": 0,
+        "rising_misread_sum": "1",
+        "source_local_falling_sum": "1",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 5,
+        "displayed_final": "1",
+        "kprime": 0,
+        "rising_misread_sum": "1",
+        "source_local_falling_sum": "1",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 6,
+        "displayed_final": "1",
+        "kprime": 0,
+        "rising_misread_sum": "1",
+        "source_local_falling_sum": "1",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 7,
+        "displayed_final": "1",
+        "kprime": 0,
+        "rising_misread_sum": "1",
+        "source_local_falling_sum": "1",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 8,
+        "displayed_final": "1",
+        "kprime": 0,
+        "rising_misread_sum": "1",
+        "source_local_falling_sum": "1",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 9,
+        "displayed_final": "1",
+        "kprime": 0,
+        "rising_misread_sum": "1",
+        "source_local_falling_sum": "1",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 10,
+        "displayed_final": "1",
+        "kprime": 0,
+        "rising_misread_sum": "1",
+        "source_local_falling_sum": "1",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 11,
+        "displayed_final": "1",
+        "kprime": 0,
+        "rising_misread_sum": "1",
+        "source_local_falling_sum": "1",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 12,
+        "displayed_final": "1",
+        "kprime": 0,
+        "rising_misread_sum": "1",
+        "source_local_falling_sum": "1",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 0,
+        "displayed_final": "1",
+        "kprime": 1,
+        "rising_misread_sum": "1",
+        "source_local_falling_sum": "1",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 1,
+        "displayed_final": "2",
+        "kprime": 1,
+        "rising_misread_sum": "2",
+        "source_local_falling_sum": "2",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 2,
+        "displayed_final": "3",
+        "kprime": 1,
+        "rising_misread_sum": "2",
+        "source_local_falling_sum": "3",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 3,
+        "displayed_final": "4",
+        "kprime": 1,
+        "rising_misread_sum": "2",
+        "source_local_falling_sum": "4",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 4,
+        "displayed_final": "5",
+        "kprime": 1,
+        "rising_misread_sum": "2",
+        "source_local_falling_sum": "5",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 5,
+        "displayed_final": "6",
+        "kprime": 1,
+        "rising_misread_sum": "2",
+        "source_local_falling_sum": "6",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 6,
+        "displayed_final": "7",
+        "kprime": 1,
+        "rising_misread_sum": "2",
+        "source_local_falling_sum": "7",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 7,
+        "displayed_final": "8",
+        "kprime": 1,
+        "rising_misread_sum": "2",
+        "source_local_falling_sum": "8",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 8,
+        "displayed_final": "9",
+        "kprime": 1,
+        "rising_misread_sum": "2",
+        "source_local_falling_sum": "9",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 9,
+        "displayed_final": "10",
+        "kprime": 1,
+        "rising_misread_sum": "2",
+        "source_local_falling_sum": "10",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 10,
+        "displayed_final": "11",
+        "kprime": 1,
+        "rising_misread_sum": "2",
+        "source_local_falling_sum": "11",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 11,
+        "displayed_final": "12",
+        "kprime": 1,
+        "rising_misread_sum": "2",
+        "source_local_falling_sum": "12",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 12,
+        "displayed_final": "13",
+        "kprime": 1,
+        "rising_misread_sum": "2",
+        "source_local_falling_sum": "13",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 0,
+        "displayed_final": "1",
+        "kprime": 2,
+        "rising_misread_sum": "1",
+        "source_local_falling_sum": "1",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 1,
+        "displayed_final": "3",
+        "kprime": 2,
+        "rising_misread_sum": "3",
+        "source_local_falling_sum": "3",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 2,
+        "displayed_final": "6",
+        "kprime": 2,
+        "rising_misread_sum": "4",
+        "source_local_falling_sum": "6",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 3,
+        "displayed_final": "10",
+        "kprime": 2,
+        "rising_misread_sum": "4",
+        "source_local_falling_sum": "10",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 4,
+        "displayed_final": "15",
+        "kprime": 2,
+        "rising_misread_sum": "4",
+        "source_local_falling_sum": "15",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 5,
+        "displayed_final": "21",
+        "kprime": 2,
+        "rising_misread_sum": "4",
+        "source_local_falling_sum": "21",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 6,
+        "displayed_final": "28",
+        "kprime": 2,
+        "rising_misread_sum": "4",
+        "source_local_falling_sum": "28",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 7,
+        "displayed_final": "36",
+        "kprime": 2,
+        "rising_misread_sum": "4",
+        "source_local_falling_sum": "36",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 8,
+        "displayed_final": "45",
+        "kprime": 2,
+        "rising_misread_sum": "4",
+        "source_local_falling_sum": "45",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 9,
+        "displayed_final": "55",
+        "kprime": 2,
+        "rising_misread_sum": "4",
+        "source_local_falling_sum": "55",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 10,
+        "displayed_final": "66",
+        "kprime": 2,
+        "rising_misread_sum": "4",
+        "source_local_falling_sum": "66",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 11,
+        "displayed_final": "78",
+        "kprime": 2,
+        "rising_misread_sum": "4",
+        "source_local_falling_sum": "78",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 12,
+        "displayed_final": "91",
+        "kprime": 2,
+        "rising_misread_sum": "4",
+        "source_local_falling_sum": "91",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 0,
+        "displayed_final": "1",
+        "kprime": 3,
+        "rising_misread_sum": "1",
+        "source_local_falling_sum": "1",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 1,
+        "displayed_final": "4",
+        "kprime": 3,
+        "rising_misread_sum": "4",
+        "source_local_falling_sum": "4",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 2,
+        "displayed_final": "10",
+        "kprime": 3,
+        "rising_misread_sum": "7",
+        "source_local_falling_sum": "10",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 3,
+        "displayed_final": "20",
+        "kprime": 3,
+        "rising_misread_sum": "8",
+        "source_local_falling_sum": "20",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 4,
+        "displayed_final": "35",
+        "kprime": 3,
+        "rising_misread_sum": "8",
+        "source_local_falling_sum": "35",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 5,
+        "displayed_final": "56",
+        "kprime": 3,
+        "rising_misread_sum": "8",
+        "source_local_falling_sum": "56",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 6,
+        "displayed_final": "84",
+        "kprime": 3,
+        "rising_misread_sum": "8",
+        "source_local_falling_sum": "84",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 7,
+        "displayed_final": "120",
+        "kprime": 3,
+        "rising_misread_sum": "8",
+        "source_local_falling_sum": "120",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 8,
+        "displayed_final": "165",
+        "kprime": 3,
+        "rising_misread_sum": "8",
+        "source_local_falling_sum": "165",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 9,
+        "displayed_final": "220",
+        "kprime": 3,
+        "rising_misread_sum": "8",
+        "source_local_falling_sum": "220",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 10,
+        "displayed_final": "286",
+        "kprime": 3,
+        "rising_misread_sum": "8",
+        "source_local_falling_sum": "286",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 11,
+        "displayed_final": "364",
+        "kprime": 3,
+        "rising_misread_sum": "8",
+        "source_local_falling_sum": "364",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 12,
+        "displayed_final": "455",
+        "kprime": 3,
+        "rising_misread_sum": "8",
+        "source_local_falling_sum": "455",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 0,
+        "displayed_final": "1",
+        "kprime": 4,
+        "rising_misread_sum": "1",
+        "source_local_falling_sum": "1",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 1,
+        "displayed_final": "5",
+        "kprime": 4,
+        "rising_misread_sum": "5",
+        "source_local_falling_sum": "5",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 2,
+        "displayed_final": "15",
+        "kprime": 4,
+        "rising_misread_sum": "11",
+        "source_local_falling_sum": "15",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 3,
+        "displayed_final": "35",
+        "kprime": 4,
+        "rising_misread_sum": "15",
+        "source_local_falling_sum": "35",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 4,
+        "displayed_final": "70",
+        "kprime": 4,
+        "rising_misread_sum": "16",
+        "source_local_falling_sum": "70",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 5,
+        "displayed_final": "126",
+        "kprime": 4,
+        "rising_misread_sum": "16",
+        "source_local_falling_sum": "126",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 6,
+        "displayed_final": "210",
+        "kprime": 4,
+        "rising_misread_sum": "16",
+        "source_local_falling_sum": "210",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 7,
+        "displayed_final": "330",
+        "kprime": 4,
+        "rising_misread_sum": "16",
+        "source_local_falling_sum": "330",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 8,
+        "displayed_final": "495",
+        "kprime": 4,
+        "rising_misread_sum": "16",
+        "source_local_falling_sum": "495",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 9,
+        "displayed_final": "715",
+        "kprime": 4,
+        "rising_misread_sum": "16",
+        "source_local_falling_sum": "715",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 10,
+        "displayed_final": "1001",
+        "kprime": 4,
+        "rising_misread_sum": "16",
+        "source_local_falling_sum": "1001",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 11,
+        "displayed_final": "1365",
+        "kprime": 4,
+        "rising_misread_sum": "16",
+        "source_local_falling_sum": "1365",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 12,
+        "displayed_final": "1820",
+        "kprime": 4,
+        "rising_misread_sum": "16",
+        "source_local_falling_sum": "1820",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 0,
+        "displayed_final": "1",
+        "kprime": 5,
+        "rising_misread_sum": "1",
+        "source_local_falling_sum": "1",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 1,
+        "displayed_final": "6",
+        "kprime": 5,
+        "rising_misread_sum": "6",
+        "source_local_falling_sum": "6",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 2,
+        "displayed_final": "21",
+        "kprime": 5,
+        "rising_misread_sum": "16",
+        "source_local_falling_sum": "21",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 3,
+        "displayed_final": "56",
+        "kprime": 5,
+        "rising_misread_sum": "26",
+        "source_local_falling_sum": "56",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 4,
+        "displayed_final": "126",
+        "kprime": 5,
+        "rising_misread_sum": "31",
+        "source_local_falling_sum": "126",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 5,
+        "displayed_final": "252",
+        "kprime": 5,
+        "rising_misread_sum": "32",
+        "source_local_falling_sum": "252",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 6,
+        "displayed_final": "462",
+        "kprime": 5,
+        "rising_misread_sum": "32",
+        "source_local_falling_sum": "462",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 7,
+        "displayed_final": "792",
+        "kprime": 5,
+        "rising_misread_sum": "32",
+        "source_local_falling_sum": "792",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 8,
+        "displayed_final": "1287",
+        "kprime": 5,
+        "rising_misread_sum": "32",
+        "source_local_falling_sum": "1287",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 9,
+        "displayed_final": "2002",
+        "kprime": 5,
+        "rising_misread_sum": "32",
+        "source_local_falling_sum": "2002",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 10,
+        "displayed_final": "3003",
+        "kprime": 5,
+        "rising_misread_sum": "32",
+        "source_local_falling_sum": "3003",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 11,
+        "displayed_final": "4368",
+        "kprime": 5,
+        "rising_misread_sum": "32",
+        "source_local_falling_sum": "4368",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 12,
+        "displayed_final": "6188",
+        "kprime": 5,
+        "rising_misread_sum": "32",
+        "source_local_falling_sum": "6188",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 0,
+        "displayed_final": "1",
+        "kprime": 6,
+        "rising_misread_sum": "1",
+        "source_local_falling_sum": "1",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 1,
+        "displayed_final": "7",
+        "kprime": 6,
+        "rising_misread_sum": "7",
+        "source_local_falling_sum": "7",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 2,
+        "displayed_final": "28",
+        "kprime": 6,
+        "rising_misread_sum": "22",
+        "source_local_falling_sum": "28",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 3,
+        "displayed_final": "84",
+        "kprime": 6,
+        "rising_misread_sum": "42",
+        "source_local_falling_sum": "84",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 4,
+        "displayed_final": "210",
+        "kprime": 6,
+        "rising_misread_sum": "57",
+        "source_local_falling_sum": "210",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 5,
+        "displayed_final": "462",
+        "kprime": 6,
+        "rising_misread_sum": "63",
+        "source_local_falling_sum": "462",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 6,
+        "displayed_final": "924",
+        "kprime": 6,
+        "rising_misread_sum": "64",
+        "source_local_falling_sum": "924",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 7,
+        "displayed_final": "1716",
+        "kprime": 6,
+        "rising_misread_sum": "64",
+        "source_local_falling_sum": "1716",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 8,
+        "displayed_final": "3003",
+        "kprime": 6,
+        "rising_misread_sum": "64",
+        "source_local_falling_sum": "3003",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 9,
+        "displayed_final": "5005",
+        "kprime": 6,
+        "rising_misread_sum": "64",
+        "source_local_falling_sum": "5005",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 10,
+        "displayed_final": "8008",
+        "kprime": 6,
+        "rising_misread_sum": "64",
+        "source_local_falling_sum": "8008",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 11,
+        "displayed_final": "12376",
+        "kprime": 6,
+        "rising_misread_sum": "64",
+        "source_local_falling_sum": "12376",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 12,
+        "displayed_final": "18564",
+        "kprime": 6,
+        "rising_misread_sum": "64",
+        "source_local_falling_sum": "18564",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 0,
+        "displayed_final": "1",
+        "kprime": 7,
+        "rising_misread_sum": "1",
+        "source_local_falling_sum": "1",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 1,
+        "displayed_final": "8",
+        "kprime": 7,
+        "rising_misread_sum": "8",
+        "source_local_falling_sum": "8",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 2,
+        "displayed_final": "36",
+        "kprime": 7,
+        "rising_misread_sum": "29",
+        "source_local_falling_sum": "36",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 3,
+        "displayed_final": "120",
+        "kprime": 7,
+        "rising_misread_sum": "64",
+        "source_local_falling_sum": "120",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 4,
+        "displayed_final": "330",
+        "kprime": 7,
+        "rising_misread_sum": "99",
+        "source_local_falling_sum": "330",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 5,
+        "displayed_final": "792",
+        "kprime": 7,
+        "rising_misread_sum": "120",
+        "source_local_falling_sum": "792",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 6,
+        "displayed_final": "1716",
+        "kprime": 7,
+        "rising_misread_sum": "127",
+        "source_local_falling_sum": "1716",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 7,
+        "displayed_final": "3432",
+        "kprime": 7,
+        "rising_misread_sum": "128",
+        "source_local_falling_sum": "3432",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 8,
+        "displayed_final": "6435",
+        "kprime": 7,
+        "rising_misread_sum": "128",
+        "source_local_falling_sum": "6435",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 9,
+        "displayed_final": "11440",
+        "kprime": 7,
+        "rising_misread_sum": "128",
+        "source_local_falling_sum": "11440",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 10,
+        "displayed_final": "19448",
+        "kprime": 7,
+        "rising_misread_sum": "128",
+        "source_local_falling_sum": "19448",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 11,
+        "displayed_final": "31824",
+        "kprime": 7,
+        "rising_misread_sum": "128",
+        "source_local_falling_sum": "31824",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 12,
+        "displayed_final": "50388",
+        "kprime": 7,
+        "rising_misread_sum": "128",
+        "source_local_falling_sum": "50388",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 0,
+        "displayed_final": "1",
+        "kprime": 8,
+        "rising_misread_sum": "1",
+        "source_local_falling_sum": "1",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 1,
+        "displayed_final": "9",
+        "kprime": 8,
+        "rising_misread_sum": "9",
+        "source_local_falling_sum": "9",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 2,
+        "displayed_final": "45",
+        "kprime": 8,
+        "rising_misread_sum": "37",
+        "source_local_falling_sum": "45",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 3,
+        "displayed_final": "165",
+        "kprime": 8,
+        "rising_misread_sum": "93",
+        "source_local_falling_sum": "165",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 4,
+        "displayed_final": "495",
+        "kprime": 8,
+        "rising_misread_sum": "163",
+        "source_local_falling_sum": "495",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 5,
+        "displayed_final": "1287",
+        "kprime": 8,
+        "rising_misread_sum": "219",
+        "source_local_falling_sum": "1287",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 6,
+        "displayed_final": "3003",
+        "kprime": 8,
+        "rising_misread_sum": "247",
+        "source_local_falling_sum": "3003",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 7,
+        "displayed_final": "6435",
+        "kprime": 8,
+        "rising_misread_sum": "255",
+        "source_local_falling_sum": "6435",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 8,
+        "displayed_final": "12870",
+        "kprime": 8,
+        "rising_misread_sum": "256",
+        "source_local_falling_sum": "12870",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 9,
+        "displayed_final": "24310",
+        "kprime": 8,
+        "rising_misread_sum": "256",
+        "source_local_falling_sum": "24310",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 10,
+        "displayed_final": "43758",
+        "kprime": 8,
+        "rising_misread_sum": "256",
+        "source_local_falling_sum": "43758",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 11,
+        "displayed_final": "75582",
+        "kprime": 8,
+        "rising_misread_sum": "256",
+        "source_local_falling_sum": "75582",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 12,
+        "displayed_final": "125970",
+        "kprime": 8,
+        "rising_misread_sum": "256",
+        "source_local_falling_sum": "125970",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 0,
+        "displayed_final": "1",
+        "kprime": 9,
+        "rising_misread_sum": "1",
+        "source_local_falling_sum": "1",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 1,
+        "displayed_final": "10",
+        "kprime": 9,
+        "rising_misread_sum": "10",
+        "source_local_falling_sum": "10",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 2,
+        "displayed_final": "55",
+        "kprime": 9,
+        "rising_misread_sum": "46",
+        "source_local_falling_sum": "55",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 3,
+        "displayed_final": "220",
+        "kprime": 9,
+        "rising_misread_sum": "130",
+        "source_local_falling_sum": "220",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 4,
+        "displayed_final": "715",
+        "kprime": 9,
+        "rising_misread_sum": "256",
+        "source_local_falling_sum": "715",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 5,
+        "displayed_final": "2002",
+        "kprime": 9,
+        "rising_misread_sum": "382",
+        "source_local_falling_sum": "2002",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 6,
+        "displayed_final": "5005",
+        "kprime": 9,
+        "rising_misread_sum": "466",
+        "source_local_falling_sum": "5005",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 7,
+        "displayed_final": "11440",
+        "kprime": 9,
+        "rising_misread_sum": "502",
+        "source_local_falling_sum": "11440",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 8,
+        "displayed_final": "24310",
+        "kprime": 9,
+        "rising_misread_sum": "511",
+        "source_local_falling_sum": "24310",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 9,
+        "displayed_final": "48620",
+        "kprime": 9,
+        "rising_misread_sum": "512",
+        "source_local_falling_sum": "48620",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 10,
+        "displayed_final": "92378",
+        "kprime": 9,
+        "rising_misread_sum": "512",
+        "source_local_falling_sum": "92378",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 11,
+        "displayed_final": "167960",
+        "kprime": 9,
+        "rising_misread_sum": "512",
+        "source_local_falling_sum": "167960",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 12,
+        "displayed_final": "293930",
+        "kprime": 9,
+        "rising_misread_sum": "512",
+        "source_local_falling_sum": "293930",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 0,
+        "displayed_final": "1",
+        "kprime": 10,
+        "rising_misread_sum": "1",
+        "source_local_falling_sum": "1",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 1,
+        "displayed_final": "11",
+        "kprime": 10,
+        "rising_misread_sum": "11",
+        "source_local_falling_sum": "11",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 2,
+        "displayed_final": "66",
+        "kprime": 10,
+        "rising_misread_sum": "56",
+        "source_local_falling_sum": "66",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 3,
+        "displayed_final": "286",
+        "kprime": 10,
+        "rising_misread_sum": "176",
+        "source_local_falling_sum": "286",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 4,
+        "displayed_final": "1001",
+        "kprime": 10,
+        "rising_misread_sum": "386",
+        "source_local_falling_sum": "1001",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 5,
+        "displayed_final": "3003",
+        "kprime": 10,
+        "rising_misread_sum": "638",
+        "source_local_falling_sum": "3003",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 6,
+        "displayed_final": "8008",
+        "kprime": 10,
+        "rising_misread_sum": "848",
+        "source_local_falling_sum": "8008",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 7,
+        "displayed_final": "19448",
+        "kprime": 10,
+        "rising_misread_sum": "968",
+        "source_local_falling_sum": "19448",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 8,
+        "displayed_final": "43758",
+        "kprime": 10,
+        "rising_misread_sum": "1013",
+        "source_local_falling_sum": "43758",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 9,
+        "displayed_final": "92378",
+        "kprime": 10,
+        "rising_misread_sum": "1023",
+        "source_local_falling_sum": "92378",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 10,
+        "displayed_final": "184756",
+        "kprime": 10,
+        "rising_misread_sum": "1024",
+        "source_local_falling_sum": "184756",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 11,
+        "displayed_final": "352716",
+        "kprime": 10,
+        "rising_misread_sum": "1024",
+        "source_local_falling_sum": "352716",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 12,
+        "displayed_final": "646646",
+        "kprime": 10,
+        "rising_misread_sum": "1024",
+        "source_local_falling_sum": "646646",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 0,
+        "displayed_final": "1",
+        "kprime": 11,
+        "rising_misread_sum": "1",
+        "source_local_falling_sum": "1",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 1,
+        "displayed_final": "12",
+        "kprime": 11,
+        "rising_misread_sum": "12",
+        "source_local_falling_sum": "12",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 2,
+        "displayed_final": "78",
+        "kprime": 11,
+        "rising_misread_sum": "67",
+        "source_local_falling_sum": "78",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 3,
+        "displayed_final": "364",
+        "kprime": 11,
+        "rising_misread_sum": "232",
+        "source_local_falling_sum": "364",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 4,
+        "displayed_final": "1365",
+        "kprime": 11,
+        "rising_misread_sum": "562",
+        "source_local_falling_sum": "1365",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 5,
+        "displayed_final": "4368",
+        "kprime": 11,
+        "rising_misread_sum": "1024",
+        "source_local_falling_sum": "4368",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 6,
+        "displayed_final": "12376",
+        "kprime": 11,
+        "rising_misread_sum": "1486",
+        "source_local_falling_sum": "12376",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 7,
+        "displayed_final": "31824",
+        "kprime": 11,
+        "rising_misread_sum": "1816",
+        "source_local_falling_sum": "31824",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 8,
+        "displayed_final": "75582",
+        "kprime": 11,
+        "rising_misread_sum": "1981",
+        "source_local_falling_sum": "75582",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 9,
+        "displayed_final": "167960",
+        "kprime": 11,
+        "rising_misread_sum": "2036",
+        "source_local_falling_sum": "167960",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 10,
+        "displayed_final": "352716",
+        "kprime": 11,
+        "rising_misread_sum": "2047",
+        "source_local_falling_sum": "352716",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 11,
+        "displayed_final": "705432",
+        "kprime": 11,
+        "rising_misread_sum": "2048",
+        "source_local_falling_sum": "705432",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 12,
+        "displayed_final": "1352078",
+        "kprime": 11,
+        "rising_misread_sum": "2048",
+        "source_local_falling_sum": "1352078",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 0,
+        "displayed_final": "1",
+        "kprime": 12,
+        "rising_misread_sum": "1",
+        "source_local_falling_sum": "1",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 1,
+        "displayed_final": "13",
+        "kprime": 12,
+        "rising_misread_sum": "13",
+        "source_local_falling_sum": "13",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 2,
+        "displayed_final": "91",
+        "kprime": 12,
+        "rising_misread_sum": "79",
+        "source_local_falling_sum": "91",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 3,
+        "displayed_final": "455",
+        "kprime": 12,
+        "rising_misread_sum": "299",
+        "source_local_falling_sum": "455",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 4,
+        "displayed_final": "1820",
+        "kprime": 12,
+        "rising_misread_sum": "794",
+        "source_local_falling_sum": "1820",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 5,
+        "displayed_final": "6188",
+        "kprime": 12,
+        "rising_misread_sum": "1586",
+        "source_local_falling_sum": "6188",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 6,
+        "displayed_final": "18564",
+        "kprime": 12,
+        "rising_misread_sum": "2510",
+        "source_local_falling_sum": "18564",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 7,
+        "displayed_final": "50388",
+        "kprime": 12,
+        "rising_misread_sum": "3302",
+        "source_local_falling_sum": "50388",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 8,
+        "displayed_final": "125970",
+        "kprime": 12,
+        "rising_misread_sum": "3797",
+        "source_local_falling_sum": "125970",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 9,
+        "displayed_final": "293930",
+        "kprime": 12,
+        "rising_misread_sum": "4017",
+        "source_local_falling_sum": "293930",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 10,
+        "displayed_final": "646646",
+        "kprime": 12,
+        "rising_misread_sum": "4083",
+        "source_local_falling_sum": "646646",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 11,
+        "displayed_final": "1352078",
+        "kprime": 12,
+        "rising_misread_sum": "4095",
+        "source_local_falling_sum": "1352078",
+        "source_local_matches": true
+      },
+      {
+        "cutoff": 12,
+        "displayed_final": "2704156",
+        "kprime": 12,
+        "rising_misread_sum": "4096",
+        "source_local_falling_sum": "2704156",
+        "source_local_matches": true
+      }
+    ],
+    "kprime2_cutoff2": {
+      "cutoff": 2,
+      "displayed_final": "6",
+      "kprime": 2,
+      "rising_misread_sum": "4",
+      "source_local_falling_sum": "6",
+      "source_local_matches": true
+    },
+    "paper": {
+      "arxiv_id": "2307.16801",
+      "title": "Detector Operators for Celestial Symmetries"
+    },
+    "result_version": "sabrina_detector_sum_identity_convention_reaudit_v2",
+    "source_evidence": {
+      "archive_sha256": "98acf1e79b6d6fb929626e11f40fdb0d4a4029f174f6c493f7639e721c7424b0",
+      "block_hashes": {
+        "first_derivative_use": "097ac2823f2a3abd9516d03b01d804b0c0456ccc8a83fe9863646c41930695f7",
+        "identity": "92c7292e6f133f1b9c99b185a20a6e0e4f8b09b52d3d2ea47948c9bbff8d33a3",
+        "second_derivative_use": "90fd4d54db45a0b1e3bae6b70d265748a47ce79f30e3d1b11dceb3df54f3b3e1"
+      },
+      "checks": {
+        "archive_hash_matches": true,
+        "downstream_reference_contexts_match": true,
+        "downstream_reference_count_is_two": true,
+        "main_tex_hash_matches": true,
+        "predecessor_manifest_hash_matches": true,
+        "source_equation_blocks_match": true,
+        "source_markers_are_unique": true
+      },
+      "main_tex_sha256": "6c5a28fae38e51e317326891ba2758e38766bf8eed98f5cb6941c8a46ade7dd6",
+      "reference_context_sha256": [
+        "817f663507d9b9bd5f2bd14a48c291d1d490449b265a1c3251558bb785445458",
+        "b3d35603938e2b2c7f94b9d2ad11b9f56cb6eb265c7480ec0601375bc6073c9d"
+      ]
+    },
+    "status": "complete",
+    "supersession": {
+      "predecessor_artifacts_mutated": false,
+      "predecessor_claim_valid": false,
+      "predecessor_manifest_sha256": "764f819b652785e2394101cf78d0463dc893379e30a80732430a2261b20269f7",
+      "reason": "v1 interpreted source-local falling-factorial notation as standard rising Pochhammer"
+    }
+  },
+  "scientific_payload_sha256": "a1b7a157ca0f6b33a4e558a471219f1c3b5c077bbca275918db542a467ec6aad"
+}
diff --git a/references/run_sabrina_electromagnetic_memory_detector_tradeoff.json b/references/run_sabrina_electromagnetic_memory_detector_tradeoff.json
new file mode 100644
index 0000000000000000000000000000000000000000..fc8b9cf7c600921177bff2ccd8b326a76d0f78b2
--- /dev/null
+++ b/references/run_sabrina_electromagnetic_memory_detector_tradeoff.json
@@ -0,0 +1,106 @@
+{
+  "kernel": "run_sabrina_electromagnetic_memory_detector_tradeoff",
+  "role": "post-computation assertion only",
+  "schema": "ouroboros_scientific_reference_assertion_v1",
+  "scientific_payload": {
+    "brownian_tradeoff_certificate": {
+      "checks": {
+        "overdamped_displacement_variance_exact": true,
+        "slow_ramp_snr_tends_to_zero": true,
+        "snr_fluence_identity_exact": true,
+        "snr_squared_exact": true
+      },
+      "displacement_variance": "2*T*kBT/sigma",
+      "signal_displacement": "M*Q/sigma",
+      "snr_fluence_identity": "SNR^2=Q^2*Phi/(2*kBT*sigma)",
+      "snr_squared": "M**2*Q**2/(2*T*kBT*sigma)"
+    },
+    "claim_boundary": {
+      "arbitrary_noise_or_nonlinear_drag_claimed": false,
+      "brownian_result_overdamped_equilibrium_white_noise_only": true,
+      "capabilities_removed": [],
+      "experimental_feasibility_claimed": false,
+      "full_electromagnetic_energy_normalization_claimed": false,
+      "linear_drag_only": true,
+      "quadratic_fluence_proxy_only": true,
+      "rest_endpoints_required_for_shape_independence": true
+    },
+    "endpoint_memory_certificate": {
+      "checks": {
+        "endpoint_correction_exact": true,
+        "integrated_dynamics_exact": true,
+        "pulse_shape_absent_after_integration": true,
+        "rest_endpoint_displacement_exact": true
+      },
+      "endpoint_corrected_displacement": "(-Delta_v*m + M*Q)/sigma",
+      "integrated_identity": "sigma*Delta_x=Q*M-m*Delta_v",
+      "rest_endpoint_displacement": "M*Q/sigma"
+    },
+    "exact_checks": {
+      "archive_hash_matches": true,
+      "brownian_limit_present": true,
+      "constant_pulse_memory_exact": true,
+      "constant_pulse_saturates_bound": true,
+      "displacement_relation_present": true,
+      "endpoint_correction_exact": true,
+      "integrated_dynamics_exact": true,
+      "linear_drag_present": true,
+      "member_hash_matches": true,
+      "overdamped_displacement_variance_exact": true,
+      "pulse_shape_absent_after_integration": true,
+      "rest_endpoint_displacement_exact": true,
+      "slow_ramp_claim_present": true,
+      "slow_ramp_fluence_tends_to_zero": true,
+      "slow_ramp_snr_tends_to_zero": true,
+      "snr_fluence_identity_exact": true,
+      "snr_squared_exact": true,
+      "source_blocks_match": true,
+      "time_integrated_field_present": true,
+      "triangle_has_same_memory": true,
+      "triangle_is_strictly_above_bound": true
+    },
+    "fluence_certificate": {
+      "cauchy_schwarz_bound": "Phi*T>=M^2",
+      "checks": {
+        "constant_pulse_memory_exact": true,
+        "constant_pulse_saturates_bound": true,
+        "slow_ramp_fluence_tends_to_zero": true,
+        "triangle_has_same_memory": true,
+        "triangle_is_strictly_above_bound": true
+      },
+      "constant_ramp_fluence": "M**2/T",
+      "triangle_ramp_fluence": "4*M**2/(3*T)"
+    },
+    "paper": {
+      "arxiv_id": "1505.00716",
+      "title": "Asymptotic Symmetries and Electromagnetic Memory"
+    },
+    "result_version": "sabrina_electromagnetic_memory_detector_tradeoff_v1",
+    "source_evidence": {
+      "archive_sha256": "7713c97d18c7b5ac41c1cb8884d73bddd6d1639551b3e91aef46d1a715fe67e4",
+      "block_hashes": {
+        "memory_integral": "7105277fbcefb26d56dba812d7d60bdd1b1091ecb47159d4710c7beddb8e9217",
+        "viscous_detector": "f6a7472106636a01427a5880472e49258b6f3087b4901d55e5eadfc47b241a9e"
+      },
+      "checks": {
+        "archive_hash_matches": true,
+        "brownian_limit_present": true,
+        "displacement_relation_present": true,
+        "linear_drag_present": true,
+        "member_hash_matches": true,
+        "slow_ramp_claim_present": true,
+        "source_blocks_match": true,
+        "time_integrated_field_present": true
+      },
+      "member_sha256": "6fbd3de4c6141084f8081ce6bfc8c6fe3e96a09bb464522372e8dcedefde275a"
+    },
+    "status": "complete",
+    "theorem": {
+      "constant_ramp_tradeoff": "Phi=M^2/T and SNR^2=Q^2 Phi/(2 kBT sigma)",
+      "endpoint_identity": "sigma Delta x=Q M-m Delta v",
+      "fixed_memory_fluence_bound": "Phi>=M^2/T",
+      "rest_endpoint_memory": "Delta x=Q M/sigma"
+    }
+  },
+  "scientific_payload_sha256": "015631d9110b4b95c4a08337ca93d0143257d133d51159fe68736db9947d926e"
+}
diff --git a/references/run_sabrina_entanglement_scattering_slack_identity.json b/references/run_sabrina_entanglement_scattering_slack_identity.json
new file mode 100644
index 0000000000000000000000000000000000000000..bc05fb9abdc807f07119539413242c28492c74d8
--- /dev/null
+++ b/references/run_sabrina_entanglement_scattering_slack_identity.json
@@ -0,0 +1,180 @@
+{
+  "kernel": "run_sabrina_entanglement_scattering_slack_identity",
+  "role": "post-computation assertion only",
+  "schema": "ouroboros_scientific_reference_assertion_v1",
+  "scientific_payload": {
+    "claim_boundary": {
+      "capabilities_removed": [],
+      "flat_space_limit_extended": false,
+      "general_configuration_reproved": false,
+      "matter_entropy_terms_rederived": false,
+      "quantum_task_dual_constructed": false,
+      "source_error_claimed": false
+    },
+    "exact_checks": {
+      "all_symbolic_residuals_zero": true,
+      "archive_hash_matches": true,
+      "entanglement_ridge_bound_present": true,
+      "equality_iff_all_slacks_zero": true,
+      "member_hash_matches": true,
+      "mutual_information_equation_present": true,
+      "mutual_information_ridge_bound_present": true,
+      "numerical_witness_exact": true,
+      "numerical_witness_geometric": true,
+      "source_blocks_match": true,
+      "two_focusing_equations_present": true
+    },
+    "paper": {
+      "arxiv_id": "2604.22612",
+      "title": "Generalized Entanglement Wedges and the Connected Wedge Theorem"
+    },
+    "result_version": "sabrina_entanglement_scattering_slack_identity_v1",
+    "source_evidence": {
+      "archive_sha256": "8a55509c4b902e68016cb16a722efeb692056e6530cb2d6838b87fe77d6d84f6",
+      "block_hashes": {
+        "future_work_scope": "53879de714d7277342abc026d9e3697f1d6779fa225bcb29545c76cbc6b177f4",
+        "mutual_information_definition": "180f95e32264465f0b06a545094bbc73fe1b5a07fc6e5b02e2dce4ec06bec1a1",
+        "warmup_entanglement_ridge": "ba55cae873427b912363ea39970fb97d305e2e96912512479cbd6dfe54cf36ba",
+        "warmup_mutual_information_ridge": "2c8e40f06fdad817d5882b4e71e7ab6cc8d678c36ec327735d5c729b84d9047a"
+      },
+      "checks": {
+        "archive_hash_matches": true,
+        "entanglement_ridge_bound_present": true,
+        "member_hash_matches": true,
+        "mutual_information_equation_present": true,
+        "mutual_information_ridge_bound_present": true,
+        "source_blocks_match": true,
+        "two_focusing_equations_present": true
+      },
+      "member_sha256": "67a3bec7a35d950e982ea7edeccca1c7f0401539106bd1edbfea9e3b80013b0e"
+    },
+    "status": "complete",
+    "symbolic_certificate": {
+      "definitions": {
+        "delta_min": "Area(D) - [Area(E(V_1)) + Area(E(V_2))]",
+        "sigma_ent": "4 G_N S_gen(s_ent) - 2 Area(R_ent)",
+        "sigma_lift": "-[Area(D) - Area(A) - 2 Area(R_ent)]",
+        "sigma_slope": "Area(E(X_1 union X_2)) - Area(A)"
+      },
+      "equality_grid": [
+        {
+          "all_slacks_zero": true,
+          "gap_zero": true,
+          "mask": 0,
+          "numerator": "0"
+        },
+        {
+          "all_slacks_zero": false,
+          "gap_zero": false,
+          "mask": 1,
+          "numerator": "1"
+        },
+        {
+          "all_slacks_zero": false,
+          "gap_zero": false,
+          "mask": 2,
+          "numerator": "1"
+        },
+        {
+          "all_slacks_zero": false,
+          "gap_zero": false,
+          "mask": 3,
+          "numerator": "2"
+        },
+        {
+          "all_slacks_zero": false,
+          "gap_zero": false,
+          "mask": 4,
+          "numerator": "1"
+        },
+        {
+          "all_slacks_zero": false,
+          "gap_zero": false,
+          "mask": 5,
+          "numerator": "2"
+        },
+        {
+          "all_slacks_zero": false,
+          "gap_zero": false,
+          "mask": 6,
+          "numerator": "2"
+        },
+        {
+          "all_slacks_zero": false,
+          "gap_zero": false,
+          "mask": 7,
+          "numerator": "3"
+        },
+        {
+          "all_slacks_zero": false,
+          "gap_zero": false,
+          "mask": 8,
+          "numerator": "1"
+        },
+        {
+          "all_slacks_zero": false,
+          "gap_zero": false,
+          "mask": 9,
+          "numerator": "2"
+        },
+        {
+          "all_slacks_zero": false,
+          "gap_zero": false,
+          "mask": 10,
+          "numerator": "2"
+        },
+        {
+          "all_slacks_zero": false,
+          "gap_zero": false,
+          "mask": 11,
+          "numerator": "3"
+        },
+        {
+          "all_slacks_zero": false,
+          "gap_zero": false,
+          "mask": 12,
+          "numerator": "2"
+        },
+        {
+          "all_slacks_zero": false,
+          "gap_zero": false,
+          "mask": 13,
+          "numerator": "3"
+        },
+        {
+          "all_slacks_zero": false,
+          "gap_zero": false,
+          "mask": 14,
+          "numerator": "3"
+        },
+        {
+          "all_slacks_zero": false,
+          "gap_zero": false,
+          "mask": 15,
+          "numerator": "4"
+        }
+      ],
+      "gap": "(delta_min + sigma_ent + sigma_lift + sigma_slope)/(4*G_N)",
+      "gap_numerator": "delta_min + sigma_ent + sigma_lift + sigma_slope",
+      "numerical_witness": {
+        "all_primitive_areas_positive": true,
+        "expected_gap": "51/28",
+        "gap": "51/28"
+      },
+      "residuals": {
+        "entanglement_focusing": "0",
+        "gap_identity": "0",
+        "lift_focusing": "0",
+        "minimality": "0",
+        "slope_focusing": "0"
+      }
+    },
+    "theorem": {
+      "identity": "S_gen(s_ent)-I(V_1;V_2)=(sigma_ent+delta_min+sigma_lift+sigma_slope)/(4 G_N)",
+      "positivity": "all four slacks are nonnegative when G_N>0",
+      "regime": "the paper's warm-up entanglement-scattering configuration and its stated focusing/minimality assumptions",
+      "saturation": "equality holds if and only if all four slacks vanish"
+    }
+  },
+  "scientific_payload_sha256": "65ed4ac892b7bc06c0e00a75b8253eceebe84a4342dbbdfc165c226b7a62fdf3"
+}
diff --git a/references/run_sabrina_flat_boundary_corner_rank_drop.json b/references/run_sabrina_flat_boundary_corner_rank_drop.json
new file mode 100644
index 0000000000000000000000000000000000000000..6a632d6eaf2ccb771b0ef184efee8390c19401e7
--- /dev/null
+++ b/references/run_sabrina_flat_boundary_corner_rank_drop.json
@@ -0,0 +1,225 @@
+{
+  "kernel": "run_sabrina_flat_boundary_corner_rank_drop",
+  "role": "post-computation assertion only",
+  "schema": "ouroboros_scientific_reference_assertion_v1",
+  "scientific_payload": {
+    "algebraic_certificate": {
+      "checks": {
+        "finite_determinant_exact": true,
+        "finite_inverse_left_exact": true,
+        "finite_inverse_right_exact": true,
+        "finite_rank_eight": true,
+        "flat_kernel_exactly_endpoint_times": true,
+        "flat_offset_drops_all_time_data": true,
+        "flat_rank_four": true
+      },
+      "corner_order": [
+        "V1_tau_left",
+        "V1_phi_left",
+        "V1_tau_right",
+        "V1_phi_right",
+        "V2_tau_left",
+        "V2_phi_left",
+        "V2_tau_right",
+        "V2_phi_right"
+      ],
+      "finite_affine_offset": [
+        "0",
+        "-pi/2",
+        "0",
+        "pi/2",
+        "0",
+        "-pi/2",
+        "0",
+        "pi/2"
+      ],
+      "finite_determinant": "-1/ell**4",
+      "finite_inverse_matrix": [
+        [
+          "ell/2",
+          "ell/2",
+          "ell/2",
+          "-ell/2",
+          "0",
+          "0",
+          "0",
+          "0"
+        ],
+        [
+          "0",
+          "0",
+          "0",
+          "0",
+          "ell/2",
+          "ell/2",
+          "ell/2",
+          "-ell/2"
+        ],
+        [
+          "ell/2",
+          "-ell/2",
+          "0",
+          "0",
+          "0",
+          "0",
+          "ell/2",
+          "ell/2"
+        ],
+        [
+          "0",
+          "0",
+          "ell/2",
+          "ell/2",
+          "ell/2",
+          "-ell/2",
+          "0",
+          "0"
+        ],
+        [
+          "1/2",
+          "1/2",
+          "-1/2",
+          "1/2",
+          "0",
+          "0",
+          "0",
+          "0"
+        ],
+        [
+          "0",
+          "0",
+          "0",
+          "0",
+          "1/2",
+          "1/2",
+          "-1/2",
+          "1/2"
+        ],
+        [
+          "-1/2",
+          "1/2",
+          "0",
+          "0",
+          "0",
+          "0",
+          "1/2",
+          "1/2"
+        ],
+        [
+          "0",
+          "0",
+          "1/2",
+          "1/2",
+          "-1/2",
+          "1/2",
+          "0",
+          "0"
+        ]
+      ],
+      "finite_rank": 8,
+      "flat_kernel_basis": [
+        [
+          "1",
+          "0",
+          "0",
+          "0",
+          "0",
+          "0",
+          "0",
+          "0"
+        ],
+        [
+          "0",
+          "1",
+          "0",
+          "0",
+          "0",
+          "0",
+          "0",
+          "0"
+        ],
+        [
+          "0",
+          "0",
+          "1",
+          "0",
+          "0",
+          "0",
+          "0",
+          "0"
+        ],
+        [
+          "0",
+          "0",
+          "0",
+          "1",
+          "0",
+          "0",
+          "0",
+          "0"
+        ]
+      ],
+      "flat_rank": 4,
+      "variable_order": [
+        "v_c1",
+        "v_c2",
+        "u_r1",
+        "u_r2",
+        "phi_c1",
+        "phi_c2",
+        "phi_r1",
+        "phi_r2"
+      ]
+    },
+    "claim_boundary": {
+      "capabilities_removed": [],
+      "interacting_dynamics_claimed": false,
+      "kinematic_affine_map_only": true,
+      "strict_flat_limit_only": true
+    },
+    "exact_checks": {
+      "archive_hash_matches": true,
+      "finite_corner_formulas_present": true,
+      "finite_determinant_exact": true,
+      "finite_inverse_left_exact": true,
+      "finite_inverse_right_exact": true,
+      "finite_rank_eight": true,
+      "flat_corner_limits_present": true,
+      "flat_kernel_exactly_endpoint_times": true,
+      "flat_offset_drops_all_time_data": true,
+      "flat_rank_four": true,
+      "flat_segments_present": true,
+      "member_hash_matches": true,
+      "source_blocks_match": true
+    },
+    "paper": {
+      "arxiv_id": "2604.22612",
+      "title": "Generalized Entanglement Wedges and the Connected Wedge Theorem"
+    },
+    "result_version": "sabrina_flat_boundary_corner_rank_drop_v1",
+    "source_evidence": {
+      "archive_sha256": "8a55509c4b902e68016cb16a722efeb692056e6530cb2d6838b87fe77d6d84f6",
+      "block_hashes": {
+        "flat_boundary_corner_map": "c8086752e1d81c01be54a1b0652123b78d6971e3703e807527617dfe84763cc6"
+      },
+      "checks": {
+        "archive_hash_matches": true,
+        "finite_corner_formulas_present": true,
+        "flat_corner_limits_present": true,
+        "flat_segments_present": true,
+        "member_hash_matches": true,
+        "source_blocks_match": true
+      },
+      "member_sha256": "67a3bec7a35d950e982ea7edeccca1c7f0401539106bd1edbfea9e3b80013b0e"
+    },
+    "status": "complete",
+    "theorem": {
+      "exact_reconstruction": "all eight endpoint variables are recovered by the exact affine inverse at finite ell",
+      "finite_scale_bijection": "det(J_ell)=-ell^-4 and rank(J_ell)=8 for ell nonzero",
+      "flat_rank_drop": "rank(lim_(ell->infinity) J_ell)=4",
+      "interpretation": "the strict flat boundary-corner data retain angular geometry but erase all four endpoint times",
+      "lost_subspace": "the limiting kernel is exactly span(v_c1,v_c2,u_r1,u_r2)"
+    }
+  },
+  "scientific_payload_sha256": "0853ed3bb32e027bf8d6f6b380fcb29ace7776981e3c033036dac278b99443a6"
+}
diff --git a/references/run_sabrina_inverted_mellin_equivalence.json b/references/run_sabrina_inverted_mellin_equivalence.json
new file mode 100644
index 0000000000000000000000000000000000000000..ab878722107749c201c03036dc50631852e0c8e4
--- /dev/null
+++ b/references/run_sabrina_inverted_mellin_equivalence.json
@@ -0,0 +1,61 @@
+{
+  "kernel": "run_sabrina_inverted_mellin_equivalence",
+  "role": "post-computation assertion only",
+  "schema": "ouroboros_scientific_reference_assertion_v1",
+  "scientific_payload": {
+    "claim_boundary": {
+      "capabilities_removed": [],
+      "paper_correction_claimed": false,
+      "physics_beyond_source_equivalence_claimed": false
+    },
+    "classification": "source_equation_consistent_normalization_rescaling_made_explicit",
+    "derivation": {
+      "canonical_variable": "t=tau/2=(2u)^-1",
+      "final_argument": "-t qhat",
+      "final_prefactor": "-2^(Delta-1)",
+      "first_variable": "tau=1/u on each open half-line",
+      "negative_u_branch": "(u-i0)^(-Delta)=|u|^(-Delta) exp(i pi Delta)",
+      "null_infinity_asymptotic": "r Phi -> -(2u)^-1 tildePhi(-qhat/(2u))",
+      "oriented_measure": "du[-1/(2u)] -> -d tau/(2 tau)",
+      "regulator_rename": "epsilon_t=2 epsilon>0",
+      "weight_identity": "(1/(2t)-i epsilon)^(-Delta)=2^Delta(1/t-2i epsilon)^(-Delta)"
+    },
+    "exact_checks": {
+      "archive_hash_matches": true,
+      "canonical_rescaling_measure": true,
+      "displayed_argument": true,
+      "displayed_power_of_two": true,
+      "equation_environment_bounded": true,
+      "equation_hash_matches": true,
+      "equation_label_unique": true,
+      "member_hash_matches": true,
+      "negative_half_line_orientation": true,
+      "outgoing_negative_branch_phase": true,
+      "positive_half_line_orientation": true,
+      "raw_inversion_measure": true,
+      "regulator_rescales_by_two": true,
+      "source_asymptotic_prefactor": true
+    },
+    "finding": "The displayed equivalence is exact. The prose change t=u^-1 suppresses the subsequent positive rescaling t=(2u)^-1 and regulator rename; it does not create a normalization or branch error.",
+    "paper": {
+      "arxiv_id": "2310.02186",
+      "equation_label": "eq:intgrlequiv",
+      "title": "Equating Extrapolate Dictionaries for Massless Scattering"
+    },
+    "parents": {
+      "corpus_selection_result_sha256": "50be0f97900ed089adcef02591c307e87fe1abedcdee435b7072a868449032b3",
+      "source_archive_sha256": "98df70f13d2aeecec1c192dab76dbe6c52c85a2794e2b46531afc1f846fae4f5",
+      "source_member_sha256": "dec660af87a0f34503f8b719e96a95968b83fc665089b19cb627b92b34b0eb6a"
+    },
+    "result_version": "sabrina_inverted_mellin_equivalence_v1",
+    "source_evidence": {
+      "archive_sha256": "98df70f13d2aeecec1c192dab76dbe6c52c85a2794e2b46531afc1f846fae4f5",
+      "equation_block_byte_count": 310,
+      "equation_block_sha256": "31a82fb57e91a1ff55cba7c2d48213cd1c54bb5ec8c2b1c6e40b76747f17e431",
+      "equation_label_count": 1,
+      "member_sha256": "dec660af87a0f34503f8b719e96a95968b83fc665089b19cb627b92b34b0eb6a"
+    },
+    "status": "complete"
+  },
+  "scientific_payload_sha256": "8238ba9f3410ddad34f4ba9d8b58fed3f8b73f2da4ac14bd651fe311098aed7e"
+}
diff --git a/references/run_sabrina_late_time_three_cut_null_test.json b/references/run_sabrina_late_time_three_cut_null_test.json
new file mode 100644
index 0000000000000000000000000000000000000000..9800cbaf7fbdfe0fd727b145ef4eccec68f08eba
--- /dev/null
+++ b/references/run_sabrina_late_time_three_cut_null_test.json
@@ -0,0 +1,718 @@
+{
+  "kernel": "run_sabrina_late_time_three_cut_null_test",
+  "role": "post-computation assertion only",
+  "schema": "ouroboros_scientific_reference_assertion_v1",
+  "scientific_payload": {
+    "claim_boundary": {
+      "capabilities_removed": [],
+      "higher_than_quadratic_contamination_reconstructed": false,
+      "nonzero_residual_means_non_affine_only": true,
+      "pairwise_distinct_cuts_required": true,
+      "physical_cause_identified_from_residual": false,
+      "source_error_claimed": false
+    },
+    "classification": "late_time_three_cut_affine_null_test_and_quadratic_curvature_extraction_exact",
+    "exact_checks": {
+      "Hminus_affine_residual_zero": true,
+      "Hzero_affine_residual_zero": true,
+      "all_60_rational_rows_exact": true,
+      "all_six_permutations_recover_same_curvature": true,
+      "archive_hash_matches": true,
+      "equation_hash_matches": true,
+      "equation_marker_unique": true,
+      "member_hash_matches": true,
+      "predecessor_manifest_hash_matches": true,
+      "quadratic_residual_factors_as_e_times_vandermonde": true,
+      "repeated_cuts_rejected": true,
+      "symbolic_quadratic_coefficient_recovered": true
+    },
+    "finite_exact_rows": [
+      {
+        "affine_null": true,
+        "cuts": [
+          "-3",
+          "-1",
+          "1/2"
+        ],
+        "exact": true,
+        "quadratic_coefficient": "0",
+        "recovered": "0"
+      },
+      {
+        "affine_null": true,
+        "cuts": [
+          "-3",
+          "-1",
+          "1/2"
+        ],
+        "exact": true,
+        "quadratic_coefficient": "4/3",
+        "recovered": "4/3"
+      },
+      {
+        "affine_null": true,
+        "cuts": [
+          "-3",
+          "-1",
+          "1/2"
+        ],
+        "exact": true,
+        "quadratic_coefficient": "-3/5",
+        "recovered": "-3/5"
+      },
+      {
+        "affine_null": true,
+        "cuts": [
+          "-3",
+          "-1",
+          "2"
+        ],
+        "exact": true,
+        "quadratic_coefficient": "0",
+        "recovered": "0"
+      },
+      {
+        "affine_null": true,
+        "cuts": [
+          "-3",
+          "-1",
+          "2"
+        ],
+        "exact": true,
+        "quadratic_coefficient": "4/3",
+        "recovered": "4/3"
+      },
+      {
+        "affine_null": true,
+        "cuts": [
+          "-3",
+          "-1",
+          "2"
+        ],
+        "exact": true,
+        "quadratic_coefficient": "-3/5",
+        "recovered": "-3/5"
+      },
+      {
+        "affine_null": true,
+        "cuts": [
+          "-3",
+          "-1",
+          "7/2"
+        ],
+        "exact": true,
+        "quadratic_coefficient": "0",
+        "recovered": "0"
+      },
+      {
+        "affine_null": true,
+        "cuts": [
+          "-3",
+          "-1",
+          "7/2"
+        ],
+        "exact": true,
+        "quadratic_coefficient": "4/3",
+        "recovered": "4/3"
+      },
+      {
+        "affine_null": true,
+        "cuts": [
+          "-3",
+          "-1",
+          "7/2"
+        ],
+        "exact": true,
+        "quadratic_coefficient": "-3/5",
+        "recovered": "-3/5"
+      },
+      {
+        "affine_null": true,
+        "cuts": [
+          "-3",
+          "-1",
+          "5"
+        ],
+        "exact": true,
+        "quadratic_coefficient": "0",
+        "recovered": "0"
+      },
+      {
+        "affine_null": true,
+        "cuts": [
+          "-3",
+          "-1",
+          "5"
+        ],
+        "exact": true,
+        "quadratic_coefficient": "4/3",
+        "recovered": "4/3"
+      },
+      {
+        "affine_null": true,
+        "cuts": [
+          "-3",
+          "-1",
+          "5"
+        ],
+        "exact": true,
+        "quadratic_coefficient": "-3/5",
+        "recovered": "-3/5"
+      },
+      {
+        "affine_null": true,
+        "cuts": [
+          "-3",
+          "1/2",
+          "2"
+        ],
+        "exact": true,
+        "quadratic_coefficient": "0",
+        "recovered": "0"
+      },
+      {
+        "affine_null": true,
+        "cuts": [
+          "-3",
+          "1/2",
+          "2"
+        ],
+        "exact": true,
+        "quadratic_coefficient": "4/3",
+        "recovered": "4/3"
+      },
+      {
+        "affine_null": true,
+        "cuts": [
+          "-3",
+          "1/2",
+          "2"
+        ],
+        "exact": true,
+        "quadratic_coefficient": "-3/5",
+        "recovered": "-3/5"
+      },
+      {
+        "affine_null": true,
+        "cuts": [
+          "-3",
+          "1/2",
+          "7/2"
+        ],
+        "exact": true,
+        "quadratic_coefficient": "0",
+        "recovered": "0"
+      },
+      {
+        "affine_null": true,
+        "cuts": [
+          "-3",
+          "1/2",
+          "7/2"
+        ],
+        "exact": true,
+        "quadratic_coefficient": "4/3",
+        "recovered": "4/3"
+      },
+      {
+        "affine_null": true,
+        "cuts": [
+          "-3",
+          "1/2",
+          "7/2"
+        ],
+        "exact": true,
+        "quadratic_coefficient": "-3/5",
+        "recovered": "-3/5"
+      },
+      {
+        "affine_null": true,
+        "cuts": [
+          "-3",
+          "1/2",
+          "5"
+        ],
+        "exact": true,
+        "quadratic_coefficient": "0",
+        "recovered": "0"
+      },
+      {
+        "affine_null": true,
+        "cuts": [
+          "-3",
+          "1/2",
+          "5"
+        ],
+        "exact": true,
+        "quadratic_coefficient": "4/3",
+        "recovered": "4/3"
+      },
+      {
+        "affine_null": true,
+        "cuts": [
+          "-3",
+          "1/2",
+          "5"
+        ],
+        "exact": true,
+        "quadratic_coefficient": "-3/5",
+        "recovered": "-3/5"
+      },
+      {
+        "affine_null": true,
+        "cuts": [
+          "-3",
+          "2",
+          "7/2"
+        ],
+        "exact": true,
+        "quadratic_coefficient": "0",
+        "recovered": "0"
+      },
+      {
+        "affine_null": true,
+        "cuts": [
+          "-3",
+          "2",
+          "7/2"
+        ],
+        "exact": true,
+        "quadratic_coefficient": "4/3",
+        "recovered": "4/3"
+      },
+      {
+        "affine_null": true,
+        "cuts": [
+          "-3",
+          "2",
+          "7/2"
+        ],
+        "exact": true,
+        "quadratic_coefficient": "-3/5",
+        "recovered": "-3/5"
+      },
+      {
+        "affine_null": true,
+        "cuts": [
+          "-3",
+          "2",
+          "5"
+        ],
+        "exact": true,
+        "quadratic_coefficient": "0",
+        "recovered": "0"
+      },
+      {
+        "affine_null": true,
+        "cuts": [
+          "-3",
+          "2",
+          "5"
+        ],
+        "exact": true,
+        "quadratic_coefficient": "4/3",
+        "recovered": "4/3"
+      },
+      {
+        "affine_null": true,
+        "cuts": [
+          "-3",
+          "2",
+          "5"
+        ],
+        "exact": true,
+        "quadratic_coefficient": "-3/5",
+        "recovered": "-3/5"
+      },
+      {
+        "affine_null": true,
+        "cuts": [
+          "-3",
+          "7/2",
+          "5"
+        ],
+        "exact": true,
+        "quadratic_coefficient": "0",
+        "recovered": "0"
+      },
+      {
+        "affine_null": true,
+        "cuts": [
+          "-3",
+          "7/2",
+          "5"
+        ],
+        "exact": true,
+        "quadratic_coefficient": "4/3",
+        "recovered": "4/3"
+      },
+      {
+        "affine_null": true,
+        "cuts": [
+          "-3",
+          "7/2",
+          "5"
+        ],
+        "exact": true,
+        "quadratic_coefficient": "-3/5",
+        "recovered": "-3/5"
+      },
+      {
+        "affine_null": true,
+        "cuts": [
+          "-1",
+          "1/2",
+          "2"
+        ],
+        "exact": true,
+        "quadratic_coefficient": "0",
+        "recovered": "0"
+      },
+      {
+        "affine_null": true,
+        "cuts": [
+          "-1",
+          "1/2",
+          "2"
+        ],
+        "exact": true,
+        "quadratic_coefficient": "4/3",
+        "recovered": "4/3"
+      },
+      {
+        "affine_null": true,
+        "cuts": [
+          "-1",
+          "1/2",
+          "2"
+        ],
+        "exact": true,
+        "quadratic_coefficient": "-3/5",
+        "recovered": "-3/5"
+      },
+      {
+        "affine_null": true,
+        "cuts": [
+          "-1",
+          "1/2",
+          "7/2"
+        ],
+        "exact": true,
+        "quadratic_coefficient": "0",
+        "recovered": "0"
+      },
+      {
+        "affine_null": true,
+        "cuts": [
+          "-1",
+          "1/2",
+          "7/2"
+        ],
+        "exact": true,
+        "quadratic_coefficient": "4/3",
+        "recovered": "4/3"
+      },
+      {
+        "affine_null": true,
+        "cuts": [
+          "-1",
+          "1/2",
+          "7/2"
+        ],
+        "exact": true,
+        "quadratic_coefficient": "-3/5",
+        "recovered": "-3/5"
+      },
+      {
+        "affine_null": true,
+        "cuts": [
+          "-1",
+          "1/2",
+          "5"
+        ],
+        "exact": true,
+        "quadratic_coefficient": "0",
+        "recovered": "0"
+      },
+      {
+        "affine_null": true,
+        "cuts": [
+          "-1",
+          "1/2",
+          "5"
+        ],
+        "exact": true,
+        "quadratic_coefficient": "4/3",
+        "recovered": "4/3"
+      },
+      {
+        "affine_null": true,
+        "cuts": [
+          "-1",
+          "1/2",
+          "5"
+        ],
+        "exact": true,
+        "quadratic_coefficient": "-3/5",
+        "recovered": "-3/5"
+      },
+      {
+        "affine_null": true,
+        "cuts": [
+          "-1",
+          "2",
+          "7/2"
+        ],
+        "exact": true,
+        "quadratic_coefficient": "0",
+        "recovered": "0"
+      },
+      {
+        "affine_null": true,
+        "cuts": [
+          "-1",
+          "2",
+          "7/2"
+        ],
+        "exact": true,
+        "quadratic_coefficient": "4/3",
+        "recovered": "4/3"
+      },
+      {
+        "affine_null": true,
+        "cuts": [
+          "-1",
+          "2",
+          "7/2"
+        ],
+        "exact": true,
+        "quadratic_coefficient": "-3/5",
+        "recovered": "-3/5"
+      },
+      {
+        "affine_null": true,
+        "cuts": [
+          "-1",
+          "2",
+          "5"
+        ],
+        "exact": true,
+        "quadratic_coefficient": "0",
+        "recovered": "0"
+      },
+      {
+        "affine_null": true,
+        "cuts": [
+          "-1",
+          "2",
+          "5"
+        ],
+        "exact": true,
+        "quadratic_coefficient": "4/3",
+        "recovered": "4/3"
+      },
+      {
+        "affine_null": true,
+        "cuts": [
+          "-1",
+          "2",
+          "5"
+        ],
+        "exact": true,
+        "quadratic_coefficient": "-3/5",
+        "recovered": "-3/5"
+      },
+      {
+        "affine_null": true,
+        "cuts": [
+          "-1",
+          "7/2",
+          "5"
+        ],
+        "exact": true,
+        "quadratic_coefficient": "0",
+        "recovered": "0"
+      },
+      {
+        "affine_null": true,
+        "cuts": [
+          "-1",
+          "7/2",
+          "5"
+        ],
+        "exact": true,
+        "quadratic_coefficient": "4/3",
+        "recovered": "4/3"
+      },
+      {
+        "affine_null": true,
+        "cuts": [
+          "-1",
+          "7/2",
+          "5"
+        ],
+        "exact": true,
+        "quadratic_coefficient": "-3/5",
+        "recovered": "-3/5"
+      },
+      {
+        "affine_null": true,
+        "cuts": [
+          "1/2",
+          "2",
+          "7/2"
+        ],
+        "exact": true,
+        "quadratic_coefficient": "0",
+        "recovered": "0"
+      },
+      {
+        "affine_null": true,
+        "cuts": [
+          "1/2",
+          "2",
+          "7/2"
+        ],
+        "exact": true,
+        "quadratic_coefficient": "4/3",
+        "recovered": "4/3"
+      },
+      {
+        "affine_null": true,
+        "cuts": [
+          "1/2",
+          "2",
+          "7/2"
+        ],
+        "exact": true,
+        "quadratic_coefficient": "-3/5",
+        "recovered": "-3/5"
+      },
+      {
+        "affine_null": true,
+        "cuts": [
+          "1/2",
+          "2",
+          "5"
+        ],
+        "exact": true,
+        "quadratic_coefficient": "0",
+        "recovered": "0"
+      },
+      {
+        "affine_null": true,
+        "cuts": [
+          "1/2",
+          "2",
+          "5"
+        ],
+        "exact": true,
+        "quadratic_coefficient": "4/3",
+        "recovered": "4/3"
+      },
+      {
+        "affine_null": true,
+        "cuts": [
+          "1/2",
+          "2",
+          "5"
+        ],
+        "exact": true,
+        "quadratic_coefficient": "-3/5",
+        "recovered": "-3/5"
+      },
+      {
+        "affine_null": true,
+        "cuts": [
+          "1/2",
+          "7/2",
+          "5"
+        ],
+        "exact": true,
+        "quadratic_coefficient": "0",
+        "recovered": "0"
+      },
+      {
+        "affine_null": true,
+        "cuts": [
+          "1/2",
+          "7/2",
+          "5"
+        ],
+        "exact": true,
+        "quadratic_coefficient": "4/3",
+        "recovered": "4/3"
+      },
+      {
+        "affine_null": true,
+        "cuts": [
+          "1/2",
+          "7/2",
+          "5"
+        ],
+        "exact": true,
+        "quadratic_coefficient": "-3/5",
+        "recovered": "-3/5"
+      },
+      {
+        "affine_null": true,
+        "cuts": [
+          "2",
+          "7/2",
+          "5"
+        ],
+        "exact": true,
+        "quadratic_coefficient": "0",
+        "recovered": "0"
+      },
+      {
+        "affine_null": true,
+        "cuts": [
+          "2",
+          "7/2",
+          "5"
+        ],
+        "exact": true,
+        "quadratic_coefficient": "4/3",
+        "recovered": "4/3"
+      },
+      {
+        "affine_null": true,
+        "cuts": [
+          "2",
+          "7/2",
+          "5"
+        ],
+        "exact": true,
+        "quadratic_coefficient": "-3/5",
+        "recovered": "-3/5"
+      }
+    ],
+    "paper": {
+      "arxiv_id": "1905.10052",
+      "title": "Implications of Superrotations"
+    },
+    "result_version": "sabrina_late_time_three_cut_null_test_v1",
+    "source_evidence": {
+      "archive_sha256": "f6dbbd7baa6b7eb93cb06b6460877b26f09ba30bacd6b447641ccf6843828df6",
+      "checks": {
+        "archive_hash_matches": true,
+        "equation_hash_matches": true,
+        "equation_marker_unique": true,
+        "member_hash_matches": true,
+        "predecessor_manifest_hash_matches": true
+      },
+      "equation_sha256": "04b21882801dbf4f2f657ec7e880d361534f652f9529bc0c293c67b5a546a073",
+      "member_sha256": "7f18a6972ebb356c2f7c90ad69823468e11323b04d918ed05cb46aed28edf100"
+    },
+    "status": "complete",
+    "theorem": {
+      "affine_result": "zero for pairwise distinct cuts",
+      "null_residual": "(u2-u3)H(u1)+(u3-u1)H(u2)+(u1-u2)H(u3)",
+      "permutation_invariant_ratio": true,
+      "quadratic_factorization": "e*(u1 - u2)*(u1 - u3)*(u2 - u3)",
+      "quadratic_reconstruction": "e=residual/[(u1-u2)(u1-u3)(u2-u3)]"
+    }
+  },
+  "scientific_payload_sha256": "fc350a6e78c22144f885c36d6387db83ad9717444e32af7a851e5a32136bcbe8"
+}
diff --git a/references/run_sabrina_late_time_two_cut_reconstruction.json b/references/run_sabrina_late_time_two_cut_reconstruction.json
new file mode 100644
index 0000000000000000000000000000000000000000..9dfc5187209ab3594e3dea04f58882600b6482a4
--- /dev/null
+++ b/references/run_sabrina_late_time_two_cut_reconstruction.json
@@ -0,0 +1,224 @@
+{
+  "kernel": "run_sabrina_late_time_two_cut_reconstruction",
+  "role": "post-computation assertion only",
+  "schema": "ouroboros_scientific_reference_assertion_v1",
+  "scientific_payload": {
+    "claim_boundary": {
+      "capabilities_removed": [],
+      "cross_order_relation_origin_invariant_without_La_zero_claimed": false,
+      "distinct_cuts_required": true,
+      "global_modes_reconstructed": false,
+      "intercepts_origin_invariant_claimed": false,
+      "source_error_claimed": false,
+      "sphere_operator_inversion_claimed": false,
+      "sphere_operator_kernels_resolved": false
+    },
+    "classification": "late_time_two_cut_image_reconstruction_exact_with_origin_covariance",
+    "exact_checks": {
+      "all_30_rational_reconstructions_exact": true,
+      "archive_hash_matches": true,
+      "coincident_cuts_rejected": true,
+      "context_hash_matches": true,
+      "context_marker_unique": true,
+      "equation_hash_matches": true,
+      "equation_marker_unique": true,
+      "fixed_origin_cross_order_residual_zero": true,
+      "member_hash_matches": true,
+      "origin_shift_minus_intercept_covariant": true,
+      "origin_shift_zero_intercept_covariant": true,
+      "shifted_residual_is_tau_La_over_two": true,
+      "symbolic_F2_reconstruction_exact": true,
+      "symbolic_LF2_reconstruction_exact": true,
+      "symbolic_V1_reconstruction_exact": true,
+      "symbolic_Y3_reconstruction_exact": true
+    },
+    "finite_exact_rows": [
+      {
+        "reconstruction_exact": true,
+        "u1": "-3",
+        "u2": "-1"
+      },
+      {
+        "reconstruction_exact": true,
+        "u1": "-3",
+        "u2": "-1"
+      },
+      {
+        "reconstruction_exact": true,
+        "u1": "-3",
+        "u2": "-1"
+      },
+      {
+        "reconstruction_exact": true,
+        "u1": "-3",
+        "u2": "1/2"
+      },
+      {
+        "reconstruction_exact": true,
+        "u1": "-3",
+        "u2": "1/2"
+      },
+      {
+        "reconstruction_exact": true,
+        "u1": "-3",
+        "u2": "1/2"
+      },
+      {
+        "reconstruction_exact": true,
+        "u1": "-3",
+        "u2": "2"
+      },
+      {
+        "reconstruction_exact": true,
+        "u1": "-3",
+        "u2": "2"
+      },
+      {
+        "reconstruction_exact": true,
+        "u1": "-3",
+        "u2": "2"
+      },
+      {
+        "reconstruction_exact": true,
+        "u1": "-3",
+        "u2": "7/2"
+      },
+      {
+        "reconstruction_exact": true,
+        "u1": "-3",
+        "u2": "7/2"
+      },
+      {
+        "reconstruction_exact": true,
+        "u1": "-3",
+        "u2": "7/2"
+      },
+      {
+        "reconstruction_exact": true,
+        "u1": "-1",
+        "u2": "1/2"
+      },
+      {
+        "reconstruction_exact": true,
+        "u1": "-1",
+        "u2": "1/2"
+      },
+      {
+        "reconstruction_exact": true,
+        "u1": "-1",
+        "u2": "1/2"
+      },
+      {
+        "reconstruction_exact": true,
+        "u1": "-1",
+        "u2": "2"
+      },
+      {
+        "reconstruction_exact": true,
+        "u1": "-1",
+        "u2": "2"
+      },
+      {
+        "reconstruction_exact": true,
+        "u1": "-1",
+        "u2": "2"
+      },
+      {
+        "reconstruction_exact": true,
+        "u1": "-1",
+        "u2": "7/2"
+      },
+      {
+        "reconstruction_exact": true,
+        "u1": "-1",
+        "u2": "7/2"
+      },
+      {
+        "reconstruction_exact": true,
+        "u1": "-1",
+        "u2": "7/2"
+      },
+      {
+        "reconstruction_exact": true,
+        "u1": "1/2",
+        "u2": "2"
+      },
+      {
+        "reconstruction_exact": true,
+        "u1": "1/2",
+        "u2": "2"
+      },
+      {
+        "reconstruction_exact": true,
+        "u1": "1/2",
+        "u2": "2"
+      },
+      {
+        "reconstruction_exact": true,
+        "u1": "1/2",
+        "u2": "7/2"
+      },
+      {
+        "reconstruction_exact": true,
+        "u1": "1/2",
+        "u2": "7/2"
+      },
+      {
+        "reconstruction_exact": true,
+        "u1": "1/2",
+        "u2": "7/2"
+      },
+      {
+        "reconstruction_exact": true,
+        "u1": "2",
+        "u2": "7/2"
+      },
+      {
+        "reconstruction_exact": true,
+        "u1": "2",
+        "u2": "7/2"
+      },
+      {
+        "reconstruction_exact": true,
+        "u1": "2",
+        "u2": "7/2"
+      }
+    ],
+    "paper": {
+      "arxiv_id": "1905.10052",
+      "title": "Implications of Superrotations"
+    },
+    "result_version": "sabrina_late_time_two_cut_reconstruction_v1",
+    "source_evidence": {
+      "archive_sha256": "f6dbbd7baa6b7eb93cb06b6460877b26f09ba30bacd6b447641ccf6843828df6",
+      "checks": {
+        "archive_hash_matches": true,
+        "context_hash_matches": true,
+        "context_marker_unique": true,
+        "equation_hash_matches": true,
+        "equation_marker_unique": true,
+        "member_hash_matches": true
+      },
+      "context_sha256": "ac3cfdbbe3f446d97cf5ce608da5c078c9d481be3e07a76bc44f67611471adf4",
+      "equation_sha256": "04b21882801dbf4f2f657ec7e880d361534f652f9529bc0c293c67b5a546a073",
+      "member_sha256": "7f18a6972ebb356c2f7c90ad69823468e11323b04d918ed05cb46aed28edf100"
+    },
+    "status": "complete",
+    "theorem": {
+      "fixed_origin_cross_order_relation": "slope(Hzero)+one_half L(intercept(Hminus))=0",
+      "origin_invariance_extra_condition": "L(a)=0",
+      "origin_shift_law": "under v=u-tau: slopes fixed, b'=b+tau a, d'=d+tau c",
+      "recovered_images": {
+        "F2": "F2",
+        "LF2": "LF2",
+        "V1": "V1",
+        "Y3": "Y3"
+      },
+      "shifted_cross_order_residual": "L_a*tau/2",
+      "source_form": "Hminus(u)=-u Y3-2F2; Hzero(u)=u LF2+2V1",
+      "two_cut_intercept": "[u2 H(u1)-u1 H(u2)]/(u2-u1)",
+      "two_cut_slope": "[H(u2)-H(u1)]/(u2-u1)"
+    }
+  },
+  "scientific_payload_sha256": "db1fd19b1f87b4ae81f8df3e51fb7af41553eddcc0138d1b499afb0ace0a7614"
+}
diff --git a/references/run_sabrina_logarithmic_mellin_pole_order_correction.json b/references/run_sabrina_logarithmic_mellin_pole_order_correction.json
new file mode 100644
index 0000000000000000000000000000000000000000..0ac497ee5789fbe5efbb1d09bcf7b0d0cf757f7d
--- /dev/null
+++ b/references/run_sabrina_logarithmic_mellin_pole_order_correction.json
@@ -0,0 +1,222 @@
+{
+  "kernel": "run_sabrina_logarithmic_mellin_pole_order_correction",
+  "role": "post-computation assertion only",
+  "schema": "ouroboros_scientific_reference_assertion_v1",
+  "scientific_payload": {
+    "all_order_proof": {
+      "analytic_split": "Lambda^s/s=s^-1+an analytic function at s=0",
+      "binomial_rule": "expand (partial_s-log(mu))^r and apply the derivative rule termwise",
+      "derivative_rule": "partial_s^j(s^-1)=(-1)^j j! s^(-j-1)"
+    },
+    "claim_boundary": {
+      "capabilities_removed": [],
+      "existing_smooth_amplitude_residue_theorem_duplicated": false,
+      "full_amplitude_reconstructed": false,
+      "uv_completion_claimed": false
+    },
+    "exact_checks": {
+      "archive_hash_matches": true,
+      "finite_laurent_rows_exact": true,
+      "generic_loop_and_two_minus_k_statements_present": true,
+      "highest_pole_scale_invariant": true,
+      "leading_factorial_coefficient_exact": true,
+      "member_hash_matches": true,
+      "one_loop_double_pole_present": true,
+      "pole_order_is_log_power_plus_one": true,
+      "source_blocks_match": true,
+      "source_one_loop_double_pole_reproduced": true,
+      "source_two_minus_k_bound_reconciled": true
+    },
+    "finite_exact_rows": [
+      {
+        "all_coefficients_match": true,
+        "coefficient_checks": {
+          "1": true
+        },
+        "leading_coefficient": 1,
+        "log_power": 0,
+        "pole_order": 1,
+        "principal_part_coefficients": {
+          "1": "1"
+        }
+      },
+      {
+        "all_coefficients_match": true,
+        "coefficient_checks": {
+          "1": true,
+          "2": true
+        },
+        "leading_coefficient": -1,
+        "log_power": 1,
+        "pole_order": 2,
+        "principal_part_coefficients": {
+          "1": "-log_mu",
+          "2": "-1"
+        }
+      },
+      {
+        "all_coefficients_match": true,
+        "coefficient_checks": {
+          "1": true,
+          "2": true,
+          "3": true
+        },
+        "leading_coefficient": 2,
+        "log_power": 2,
+        "pole_order": 3,
+        "principal_part_coefficients": {
+          "1": "log_mu**2",
+          "2": "2*log_mu",
+          "3": "2"
+        }
+      },
+      {
+        "all_coefficients_match": true,
+        "coefficient_checks": {
+          "1": true,
+          "2": true,
+          "3": true,
+          "4": true
+        },
+        "leading_coefficient": -6,
+        "log_power": 3,
+        "pole_order": 4,
+        "principal_part_coefficients": {
+          "1": "-log_mu**3",
+          "2": "-3*log_mu**2",
+          "3": "-6*log_mu",
+          "4": "-6"
+        }
+      },
+      {
+        "all_coefficients_match": true,
+        "coefficient_checks": {
+          "1": true,
+          "2": true,
+          "3": true,
+          "4": true,
+          "5": true
+        },
+        "leading_coefficient": 24,
+        "log_power": 4,
+        "pole_order": 5,
+        "principal_part_coefficients": {
+          "1": "log_mu**4",
+          "2": "4*log_mu**3",
+          "3": "12*log_mu**2",
+          "4": "24*log_mu",
+          "5": "24"
+        }
+      },
+      {
+        "all_coefficients_match": true,
+        "coefficient_checks": {
+          "1": true,
+          "2": true,
+          "3": true,
+          "4": true,
+          "5": true,
+          "6": true
+        },
+        "leading_coefficient": -120,
+        "log_power": 5,
+        "pole_order": 6,
+        "principal_part_coefficients": {
+          "1": "-log_mu**5",
+          "2": "-5*log_mu**4",
+          "3": "-20*log_mu**3",
+          "4": "-60*log_mu**2",
+          "5": "-120*log_mu",
+          "6": "-120"
+        }
+      },
+      {
+        "all_coefficients_match": true,
+        "coefficient_checks": {
+          "1": true,
+          "2": true,
+          "3": true,
+          "4": true,
+          "5": true,
+          "6": true,
+          "7": true
+        },
+        "leading_coefficient": 720,
+        "log_power": 6,
+        "pole_order": 7,
+        "principal_part_coefficients": {
+          "1": "log_mu**6",
+          "2": "6*log_mu**5",
+          "3": "30*log_mu**4",
+          "4": "120*log_mu**3",
+          "5": "360*log_mu**2",
+          "6": "720*log_mu",
+          "7": "720"
+        }
+      }
+    ],
+    "paper": {
+      "arxiv_id": "2202.11127",
+      "title": "Goldilocks Modes and the Three Scattering Bases"
+    },
+    "result_version": "sabrina_logarithmic_mellin_pole_order_correction_v1",
+    "source_evidence": {
+      "archive_sha256": "507d405bf10b9686f8fbc678b9a7eaaa73c6f45b4f68e59edbcaecddd7ecfcc4",
+      "block_hashes": {
+        "celestial_log_poles": "639fe1734f4dca2e2353cbbe1546b63df06548efe7b38ac0a065db7e3aa6b731",
+        "loop_soft_expansion": "c95d01373419bc7154c7ef912c9385a6d4748760314d862f7e9ab55b4f83c2f5",
+        "mellin_integral_core": "e2fd500e79027edf58292614ba23f37c1f6f3fde9e8f8206d80a0684fddd039d"
+      },
+      "checks": {
+        "archive_hash_matches": true,
+        "generic_loop_and_two_minus_k_statements_present": true,
+        "member_hash_matches": true,
+        "one_loop_double_pole_present": true,
+        "source_blocks_match": true
+      },
+      "member_sha256": "ad9e1a424a413fa2b56841d94f4ae2243a852254cfcf8661c789ee859beca3a6"
+    },
+    "source_reconciliation": {
+      "one_loop_derivative_identity": true,
+      "one_loop_double_pole_coefficient": -1,
+      "one_loop_simple_pole_coefficient_for_log_omega": 0,
+      "two_minus_k_reconciles": true,
+      "two_minus_k_rows": [
+        {
+          "corrected_pole_order": 1,
+          "k": 1,
+          "loop_log_power": 0,
+          "source_bound": 1
+        },
+        {
+          "corrected_pole_order": 2,
+          "k": 0,
+          "loop_log_power": 1,
+          "source_bound": 2
+        },
+        {
+          "corrected_pole_order": 3,
+          "k": -1,
+          "loop_log_power": 2,
+          "source_bound": 3
+        },
+        {
+          "corrected_pole_order": 4,
+          "k": -2,
+          "loop_log_power": 3,
+          "source_bound": 4
+        }
+      ]
+    },
+    "status": "complete",
+    "theorem": {
+      "exact_principal_part": "sum_(j=0)^r binom(r,j)(-log(mu))^(r-j)(-1)^j j!/s^(j+1)",
+      "integral_identity": "I_r(s;Lambda,mu)=(partial_s-log(mu))^r[Lambda^s/s], s=Delta+m",
+      "leading_coefficient": "(-1)^r r!, independent of Lambda and mu",
+      "pole_order": "a nonzero omega^m[log(omega/mu)]^r term produces a pole of exact order r+1 at Delta=-m",
+      "scale_boundary": "changing mu mixes lower poles but cannot change the highest pole or its coefficient",
+      "source_correction": "the generic ell-loop sentence requires pole order ell+1 rather than ell; this agrees with the source's one-loop double pole and order 2-k statement"
+    }
+  },
+  "scientific_payload_sha256": "7e71ad1c811616ad2bae1d0eff9e16fe5a8aca3e975f7016352c215d2a8062a2"
+}
diff --git a/references/run_sabrina_low_hard_generator_nonclosure.json b/references/run_sabrina_low_hard_generator_nonclosure.json
new file mode 100644
index 0000000000000000000000000000000000000000..74965d03c68b8216da1db68835bcbcf2b23201e9
--- /dev/null
+++ b/references/run_sabrina_low_hard_generator_nonclosure.json
@@ -0,0 +1,467 @@
+{
+  "kernel": "run_sabrina_low_hard_generator_nonclosure",
+  "role": "post-computation assertion only",
+  "schema": "ouroboros_scientific_reference_assertion_v1",
+  "scientific_payload": {
+    "claim_boundary": {
+      "capabilities_removed": [],
+      "full_soft_plus_hard_algebra_failure_claimed": false,
+      "hard_scalar_truncation_only": true,
+      "massless_qed_context_only": true
+    },
+    "commutator_certificate": {
+      "angular_component": "0",
+      "checks": {
+        "angular_component_zero": true,
+        "connection_derivative_cancels": true,
+        "energy_component_exact": true,
+        "same_family_requires_zero_label": true,
+        "zero_obstruction_gives_zero_commutator": true
+      },
+      "energy_component": "-(Gamma*Y*Z_1 - Gamma*Y_1*Z + Y*Z_2 - Y_2*Z)/E",
+      "expected_energy_component": "(-Gamma*(Y*Z_1 - Y_1*Z) - Y*Z_2 + Y_2*Z)/E"
+    },
+    "exact_checks": {
+      "all_forty_nine_pairs_checked": true,
+      "all_mode_formulas_exact": true,
+      "angular_component_zero": true,
+      "archive_hash_matches": true,
+      "connection_derivative_cancels": true,
+      "decompressed_member_hash_matches": true,
+      "energy_component_exact": true,
+      "explicit_m1_n2_witness": true,
+      "generic_nonclosure_count": true,
+      "incoming_hard_charge_present": true,
+      "outgoing_hard_charge_present": true,
+      "same_family_requires_zero_label": true,
+      "scalar_hard_operator_present": true,
+      "soft_plus_hard_completion_present": true,
+      "source_blocks_match": true,
+      "ward_identity_present": true,
+      "zero_locus_exact": true,
+      "zero_obstruction_gives_zero_commutator": true
+    },
+    "monomial_certificate": {
+      "checks": {
+        "all_forty_nine_pairs_checked": true,
+        "all_mode_formulas_exact": true,
+        "explicit_m1_n2_witness": true,
+        "generic_nonclosure_count": true,
+        "zero_locus_exact": true
+      },
+      "rows": [
+        {
+          "coefficient": "0",
+          "commutator_zero": true,
+          "formula_exact": true,
+          "m": 0,
+          "n": 0
+        },
+        {
+          "coefficient": "0",
+          "commutator_zero": true,
+          "formula_exact": true,
+          "m": 0,
+          "n": 1
+        },
+        {
+          "coefficient": "-2",
+          "commutator_zero": false,
+          "formula_exact": true,
+          "m": 0,
+          "n": 2
+        },
+        {
+          "coefficient": "-6*z",
+          "commutator_zero": false,
+          "formula_exact": true,
+          "m": 0,
+          "n": 3
+        },
+        {
+          "coefficient": "-12*z**2",
+          "commutator_zero": false,
+          "formula_exact": true,
+          "m": 0,
+          "n": 4
+        },
+        {
+          "coefficient": "-20*z**3",
+          "commutator_zero": false,
+          "formula_exact": true,
+          "m": 0,
+          "n": 5
+        },
+        {
+          "coefficient": "-30*z**4",
+          "commutator_zero": false,
+          "formula_exact": true,
+          "m": 0,
+          "n": 6
+        },
+        {
+          "coefficient": "0",
+          "commutator_zero": true,
+          "formula_exact": true,
+          "m": 1,
+          "n": 0
+        },
+        {
+          "coefficient": "0",
+          "commutator_zero": true,
+          "formula_exact": true,
+          "m": 1,
+          "n": 1
+        },
+        {
+          "coefficient": "-2*z",
+          "commutator_zero": false,
+          "formula_exact": true,
+          "m": 1,
+          "n": 2
+        },
+        {
+          "coefficient": "-6*z**2",
+          "commutator_zero": false,
+          "formula_exact": true,
+          "m": 1,
+          "n": 3
+        },
+        {
+          "coefficient": "-12*z**3",
+          "commutator_zero": false,
+          "formula_exact": true,
+          "m": 1,
+          "n": 4
+        },
+        {
+          "coefficient": "-20*z**4",
+          "commutator_zero": false,
+          "formula_exact": true,
+          "m": 1,
+          "n": 5
+        },
+        {
+          "coefficient": "-30*z**5",
+          "commutator_zero": false,
+          "formula_exact": true,
+          "m": 1,
+          "n": 6
+        },
+        {
+          "coefficient": "2",
+          "commutator_zero": false,
+          "formula_exact": true,
+          "m": 2,
+          "n": 0
+        },
+        {
+          "coefficient": "2*z",
+          "commutator_zero": false,
+          "formula_exact": true,
+          "m": 2,
+          "n": 1
+        },
+        {
+          "coefficient": "0",
+          "commutator_zero": true,
+          "formula_exact": true,
+          "m": 2,
+          "n": 2
+        },
+        {
+          "coefficient": "-4*z**3",
+          "commutator_zero": false,
+          "formula_exact": true,
+          "m": 2,
+          "n": 3
+        },
+        {
+          "coefficient": "-10*z**4",
+          "commutator_zero": false,
+          "formula_exact": true,
+          "m": 2,
+          "n": 4
+        },
+        {
+          "coefficient": "-18*z**5",
+          "commutator_zero": false,
+          "formula_exact": true,
+          "m": 2,
+          "n": 5
+        },
+        {
+          "coefficient": "-28*z**6",
+          "commutator_zero": false,
+          "formula_exact": true,
+          "m": 2,
+          "n": 6
+        },
+        {
+          "coefficient": "6*z",
+          "commutator_zero": false,
+          "formula_exact": true,
+          "m": 3,
+          "n": 0
+        },
+        {
+          "coefficient": "6*z**2",
+          "commutator_zero": false,
+          "formula_exact": true,
+          "m": 3,
+          "n": 1
+        },
+        {
+          "coefficient": "4*z**3",
+          "commutator_zero": false,
+          "formula_exact": true,
+          "m": 3,
+          "n": 2
+        },
+        {
+          "coefficient": "0",
+          "commutator_zero": true,
+          "formula_exact": true,
+          "m": 3,
+          "n": 3
+        },
+        {
+          "coefficient": "-6*z**5",
+          "commutator_zero": false,
+          "formula_exact": true,
+          "m": 3,
+          "n": 4
+        },
+        {
+          "coefficient": "-14*z**6",
+          "commutator_zero": false,
+          "formula_exact": true,
+          "m": 3,
+          "n": 5
+        },
+        {
+          "coefficient": "-24*z**7",
+          "commutator_zero": false,
+          "formula_exact": true,
+          "m": 3,
+          "n": 6
+        },
+        {
+          "coefficient": "12*z**2",
+          "commutator_zero": false,
+          "formula_exact": true,
+          "m": 4,
+          "n": 0
+        },
+        {
+          "coefficient": "12*z**3",
+          "commutator_zero": false,
+          "formula_exact": true,
+          "m": 4,
+          "n": 1
+        },
+        {
+          "coefficient": "10*z**4",
+          "commutator_zero": false,
+          "formula_exact": true,
+          "m": 4,
+          "n": 2
+        },
+        {
+          "coefficient": "6*z**5",
+          "commutator_zero": false,
+          "formula_exact": true,
+          "m": 4,
+          "n": 3
+        },
+        {
+          "coefficient": "0",
+          "commutator_zero": true,
+          "formula_exact": true,
+          "m": 4,
+          "n": 4
+        },
+        {
+          "coefficient": "-8*z**7",
+          "commutator_zero": false,
+          "formula_exact": true,
+          "m": 4,
+          "n": 5
+        },
+        {
+          "coefficient": "-18*z**8",
+          "commutator_zero": false,
+          "formula_exact": true,
+          "m": 4,
+          "n": 6
+        },
+        {
+          "coefficient": "20*z**3",
+          "commutator_zero": false,
+          "formula_exact": true,
+          "m": 5,
+          "n": 0
+        },
+        {
+          "coefficient": "20*z**4",
+          "commutator_zero": false,
+          "formula_exact": true,
+          "m": 5,
+          "n": 1
+        },
+        {
+          "coefficient": "18*z**5",
+          "commutator_zero": false,
+          "formula_exact": true,
+          "m": 5,
+          "n": 2
+        },
+        {
+          "coefficient": "14*z**6",
+          "commutator_zero": false,
+          "formula_exact": true,
+          "m": 5,
+          "n": 3
+        },
+        {
+          "coefficient": "8*z**7",
+          "commutator_zero": false,
+          "formula_exact": true,
+          "m": 5,
+          "n": 4
+        },
+        {
+          "coefficient": "0",
+          "commutator_zero": true,
+          "formula_exact": true,
+          "m": 5,
+          "n": 5
+        },
+        {
+          "coefficient": "-10*z**9",
+          "commutator_zero": false,
+          "formula_exact": true,
+          "m": 5,
+          "n": 6
+        },
+        {
+          "coefficient": "30*z**4",
+          "commutator_zero": false,
+          "formula_exact": true,
+          "m": 6,
+          "n": 0
+        },
+        {
+          "coefficient": "30*z**5",
+          "commutator_zero": false,
+          "formula_exact": true,
+          "m": 6,
+          "n": 1
+        },
+        {
+          "coefficient": "28*z**6",
+          "commutator_zero": false,
+          "formula_exact": true,
+          "m": 6,
+          "n": 2
+        },
+        {
+          "coefficient": "24*z**7",
+          "commutator_zero": false,
+          "formula_exact": true,
+          "m": 6,
+          "n": 3
+        },
+        {
+          "coefficient": "18*z**8",
+          "commutator_zero": false,
+          "formula_exact": true,
+          "m": 6,
+          "n": 4
+        },
+        {
+          "coefficient": "10*z**9",
+          "commutator_zero": false,
+          "formula_exact": true,
+          "m": 6,
+          "n": 5
+        },
+        {
+          "coefficient": "0",
+          "commutator_zero": true,
+          "formula_exact": true,
+          "m": 6,
+          "n": 6
+        }
+      ],
+      "zero_pairs": [
+        [
+          0,
+          0
+        ],
+        [
+          0,
+          1
+        ],
+        [
+          1,
+          0
+        ],
+        [
+          1,
+          1
+        ],
+        [
+          2,
+          2
+        ],
+        [
+          3,
+          3
+        ],
+        [
+          4,
+          4
+        ],
+        [
+          5,
+          5
+        ],
+        [
+          6,
+          6
+        ]
+      ]
+    },
+    "paper": {
+      "arxiv_id": "1407.3814",
+      "title": "Low's Subleading Soft Theorem as a Symmetry of QED"
+    },
+    "result_version": "sabrina_low_hard_generator_nonclosure_v1",
+    "source_evidence": {
+      "archive_sha256": "56dd48c217761e4cfc914fc3480831c01049a5e34b6ed4ef11893fc445964043",
+      "block_hashes": {
+        "soft_to_symmetry_hard_generator": "a85fe5207d3e2b66985bb44637b1ec1e6a838b5729964b31b85ec5f077e3430c"
+      },
+      "checks": {
+        "archive_hash_matches": true,
+        "decompressed_member_hash_matches": true,
+        "incoming_hard_charge_present": true,
+        "outgoing_hard_charge_present": true,
+        "scalar_hard_operator_present": true,
+        "soft_plus_hard_completion_present": true,
+        "source_blocks_match": true,
+        "ward_identity_present": true
+      },
+      "member_sha256": "b136e79a81fe707dac8d99c8bc5e9c72fe7162ba771dd2887cd878305aadce66"
+    },
+    "status": "complete",
+    "theorem": {
+      "angular_component": "zero",
+      "closure_obstruction": "the commutator is in the same X_U family only when the displayed covariant derivative vanishes",
+      "commutator": "[X_Y,X_Z]=-E^-1 D_z(Y partial_z Z-Z partial_z Y) partial_E",
+      "monomial_modes": "for Y=z^m,Z=z^n and Gamma=0, the coefficient is -(n-m)(m+n-1)z^(m+n-2)/E"
+    }
+  },
+  "scientific_payload_sha256": "923662d26ef1703e8e9b20da3584065e853328708a7abc6c4e522e16abb2d9b5"
+}
diff --git a/references/run_sabrina_m3_unclassified_module_construction.json b/references/run_sabrina_m3_unclassified_module_construction.json
new file mode 100644
index 0000000000000000000000000000000000000000..01df9775ee4dfda8a285894d5de55577abb7c61b
--- /dev/null
+++ b/references/run_sabrina_m3_unclassified_module_construction.json
@@ -0,0 +1,181 @@
+{
+  "kernel": "run_sabrina_m3_unclassified_module_construction",
+  "role": "post-computation assertion only",
+  "schema": "ouroboros_scientific_reference_assertion_v1",
+  "scientific_payload": {
+    "canonical_basis": {
+      "N2": {
+        "r1": "I*(a + b)*(2*a - b)/3",
+        "r2": "I*w*(a - b)*(a + b)/2"
+      },
+      "Y2": {
+        "r1": "2*I*b**2",
+        "r2": "2*I*w*(a + b)*(a + 2*b)",
+        "r3": "I*w**2*(a + b)**2"
+      },
+      "partial_z2_L2": {
+        "r1": "I*(a + b)**2",
+        "r2": "3*I*w*(a + b)**2",
+        "r3": "I*w**2*(a + b)**2"
+      }
+    },
+    "capabilities_removed": [],
+    "claim_boundary": {
+      "all_theories_claimed": false,
+      "ordered_complex_conformal_scalar_witness": true,
+      "promotion_ready": false,
+      "public_actions_allowed": false
+    },
+    "exact_checks": {
+      "augmented_rank_four": true,
+      "capabilities_removed_empty": true,
+      "exact_linear_solution_absent": true,
+      "k3_not_executed": true,
+      "left_null_annihilates_every_basis_column": true,
+      "left_null_target_value_exact": true,
+      "local_basis_rank_three": true,
+      "pu_kernel_directions_only_change_r0": true,
+      "source_2211_hash_exact": true,
+      "source_2607_hash_exact": true,
+      "source_convention_Z_equals_a_plus_b": true
+    },
+    "linear_system": {
+      "decisive_left_null_witness": {
+        "basis_value": [
+          [
+            "0",
+            "0",
+            "0"
+          ]
+        ],
+        "identity": "-2*r1[a^2]-r1[ab]-2*r1[b^2]+2*r2[a^2]",
+        "row_weights": [
+          "-2",
+          "-1",
+          "-2",
+          "2",
+          "0",
+          "0",
+          "0",
+          "0",
+          "0"
+        ],
+        "target_value": "105/16"
+      },
+      "matrix": [
+        [
+          "0",
+          "1",
+          "2/3"
+        ],
+        [
+          "0",
+          "2",
+          "1/3"
+        ],
+        [
+          "2",
+          "1",
+          "-1/3"
+        ],
+        [
+          "2",
+          "3",
+          "1/2"
+        ],
+        [
+          "6",
+          "6",
+          "0"
+        ],
+        [
+          "4",
+          "3",
+          "-1/2"
+        ],
+        [
+          "1",
+          "1",
+          "0"
+        ],
+        [
+          "2",
+          "2",
+          "0"
+        ],
+        [
+          "1",
+          "1",
+          "0"
+        ]
+      ],
+      "rhs": [
+        "-33/16",
+        "-9/4",
+        "3/4",
+        "27/32",
+        "9/4",
+        "45/32",
+        "1/8",
+        "1/4",
+        "1/8"
+      ],
+      "row_labels": [
+        "r1:a**2",
+        "r1:a*b",
+        "r1:b**2",
+        "r2:a**2",
+        "r2:a*b",
+        "r2:b**2",
+        "r3:a**2",
+        "r3:a*b",
+        "r3:b**2"
+      ]
+    },
+    "result": {
+      "augmented_rank": 4,
+      "finite_m2_stress_basis_fit": false,
+      "k3_executed": false,
+      "local_holomorphic_basis_rank": 3,
+      "next_required_extension": "operator content outside the finite stress-tensor light-ray basis"
+    },
+    "schema_version": "sabrina_m3_unclassified_module_construction_v2",
+    "source_basis": {
+      "cft_absences": [
+        "trace directions",
+        "T_rr^(5)"
+      ],
+      "full_m2_pu_kernel_ambiguities": [
+        "partial_bar2 T_zz^(3)",
+        "partial_bar2 partial_z T_rz^(4)",
+        "partial_bar partial_z2 T_rbarz^(4)",
+        "partial_z2 T_barzbarz^(3)"
+      ],
+      "local_holomorphic_weight_2_0": [
+        "Y2",
+        "partial_z2_L2",
+        "N2=int du u^2 partial_z T_uz^(2)"
+      ],
+      "primary_redundancies": [
+        "V2=Y2/64 modulo ker(partial_bar) in conformal field theory",
+        "partial_z X2 is a descendant direction of L2"
+      ],
+      "support_fact": "Every surviving P_u-kernel ambiguity is an integrated u^0 term and can change r0 only."
+    },
+    "sources": {
+      "arxiv_2211_14287": "1299353b9514a296786e448ec1ec7adfc430eee66d055293cb24716dc23879db",
+      "arxiv_2607_28718": "bfa9d2a7941ed801f874bb92b4c3e898a99900d92990403d32c4b9408c48f2a1"
+    },
+    "status": "exact_full_stress_basis_exclusion",
+    "supersedes": {
+      "manifest_sha256": "46616896421848cc3193614709dadfbf3f133154cc1fe21f0270e357e959a87b",
+      "reason": "v1 used Z=a-b; the source-authoritative convention is Z=a+b"
+    },
+    "target_r1_r3": {
+      "r1": "-3*I*(11*a**2 + 12*a*b - 4*b**2)/16",
+      "r2": "9*I*w*(a + b)*(3*a + 5*b)/32",
+      "r3": "I*w**2*(a + b)**2/8"
+    }
+  },
+  "scientific_payload_sha256": "87a52883c1ab297c98ffbc371b709b01fb9e2a6054647a4be0487d54f0768bc7"
+}
diff --git a/references/run_sabrina_multiparticle_beta_residue_factor_two.json b/references/run_sabrina_multiparticle_beta_residue_factor_two.json
new file mode 100644
index 0000000000000000000000000000000000000000..8fb9f4678a61205e0f52a2e88e506a0399da88fe
--- /dev/null
+++ b/references/run_sabrina_multiparticle_beta_residue_factor_two.json
@@ -0,0 +1,304 @@
+{
+  "kernel": "run_sabrina_multiparticle_beta_residue_factor_two",
+  "role": "post-computation assertion only",
+  "schema": "ouroboros_scientific_reference_assertion_v1",
+  "scientific_payload": {
+    "certificate_witnesses": {
+      "coincident_towers": [
+        {
+          "closed_form": "-4",
+          "coalesced_residue": "-4",
+          "corrected_branch_limit": "-2",
+          "corrected_branch_sum": "-4",
+          "k": 0,
+          "printed_branch_limit": "-1",
+          "sum_matches_collision": true
+        },
+        {
+          "closed_form": "-8",
+          "coalesced_residue": "-8",
+          "corrected_branch_limit": "-4",
+          "corrected_branch_sum": "-8",
+          "k": 1,
+          "printed_branch_limit": "-2",
+          "sum_matches_collision": true
+        },
+        {
+          "closed_form": "-24",
+          "coalesced_residue": "-24",
+          "corrected_branch_limit": "-12",
+          "corrected_branch_sum": "-24",
+          "k": 2,
+          "printed_branch_limit": "-6",
+          "sum_matches_collision": true
+        },
+        {
+          "closed_form": "-80",
+          "coalesced_residue": "-80",
+          "corrected_branch_limit": "-40",
+          "corrected_branch_sum": "-80",
+          "k": 3,
+          "printed_branch_limit": "-20",
+          "sum_matches_collision": true
+        },
+        {
+          "closed_form": "-280",
+          "coalesced_residue": "-280",
+          "corrected_branch_limit": "-140",
+          "corrected_branch_sum": "-280",
+          "k": 4,
+          "printed_branch_limit": "-70",
+          "sum_matches_collision": true
+        },
+        {
+          "closed_form": "-1008",
+          "coalesced_residue": "-1008",
+          "corrected_branch_limit": "-504",
+          "corrected_branch_sum": "-1008",
+          "k": 5,
+          "printed_branch_limit": "-252",
+          "sum_matches_collision": true
+        },
+        {
+          "closed_form": "-3696",
+          "coalesced_residue": "-3696",
+          "corrected_branch_limit": "-1848",
+          "corrected_branch_sum": "-3696",
+          "k": 6,
+          "printed_branch_limit": "-924",
+          "sum_matches_collision": true
+        },
+        {
+          "closed_form": "-13728",
+          "coalesced_residue": "-13728",
+          "corrected_branch_limit": "-6864",
+          "corrected_branch_sum": "-13728",
+          "k": 7,
+          "printed_branch_limit": "-3432",
+          "sum_matches_collision": true
+        },
+        {
+          "closed_form": "-51480",
+          "coalesced_residue": "-51480",
+          "corrected_branch_limit": "-25740",
+          "corrected_branch_sum": "-51480",
+          "k": 8,
+          "printed_branch_limit": "-12870",
+          "sum_matches_collision": true
+        }
+      ],
+      "delta_argument_slope": "-1/2",
+      "delta_residue_jacobian": -2,
+      "generic_poles": [
+        {
+          "branch_exchange_residual": "0",
+          "factor_ratio": "2",
+          "k": 0,
+          "nu": "1/3"
+        },
+        {
+          "branch_exchange_residual": "0",
+          "factor_ratio": "2",
+          "k": 0,
+          "nu": "2/5"
+        },
+        {
+          "branch_exchange_residual": "0",
+          "factor_ratio": "2",
+          "k": 0,
+          "nu": "7/4"
+        },
+        {
+          "branch_exchange_residual": "0",
+          "factor_ratio": "2",
+          "k": 1,
+          "nu": "1/3"
+        },
+        {
+          "branch_exchange_residual": "0",
+          "factor_ratio": "2",
+          "k": 1,
+          "nu": "2/5"
+        },
+        {
+          "branch_exchange_residual": "0",
+          "factor_ratio": "2",
+          "k": 1,
+          "nu": "7/4"
+        },
+        {
+          "branch_exchange_residual": "0",
+          "factor_ratio": "2",
+          "k": 2,
+          "nu": "1/3"
+        },
+        {
+          "branch_exchange_residual": "0",
+          "factor_ratio": "2",
+          "k": 2,
+          "nu": "2/5"
+        },
+        {
+          "branch_exchange_residual": "0",
+          "factor_ratio": "2",
+          "k": 2,
+          "nu": "7/4"
+        },
+        {
+          "branch_exchange_residual": "0",
+          "factor_ratio": "2",
+          "k": 3,
+          "nu": "1/3"
+        },
+        {
+          "branch_exchange_residual": "0",
+          "factor_ratio": "2",
+          "k": 3,
+          "nu": "2/5"
+        },
+        {
+          "branch_exchange_residual": "0",
+          "factor_ratio": "2",
+          "k": 3,
+          "nu": "7/4"
+        },
+        {
+          "branch_exchange_residual": "0",
+          "factor_ratio": "2",
+          "k": 4,
+          "nu": "1/3"
+        },
+        {
+          "branch_exchange_residual": "0",
+          "factor_ratio": "2",
+          "k": 4,
+          "nu": "2/5"
+        },
+        {
+          "branch_exchange_residual": "0",
+          "factor_ratio": "2",
+          "k": 4,
+          "nu": "7/4"
+        },
+        {
+          "branch_exchange_residual": "0",
+          "factor_ratio": "2",
+          "k": 5,
+          "nu": "1/3"
+        },
+        {
+          "branch_exchange_residual": "0",
+          "factor_ratio": "2",
+          "k": 5,
+          "nu": "2/5"
+        },
+        {
+          "branch_exchange_residual": "0",
+          "factor_ratio": "2",
+          "k": 5,
+          "nu": "7/4"
+        },
+        {
+          "branch_exchange_residual": "0",
+          "factor_ratio": "2",
+          "k": 6,
+          "nu": "1/3"
+        },
+        {
+          "branch_exchange_residual": "0",
+          "factor_ratio": "2",
+          "k": 6,
+          "nu": "2/5"
+        },
+        {
+          "branch_exchange_residual": "0",
+          "factor_ratio": "2",
+          "k": 6,
+          "nu": "7/4"
+        },
+        {
+          "branch_exchange_residual": "0",
+          "factor_ratio": "2",
+          "k": 7,
+          "nu": "1/3"
+        },
+        {
+          "branch_exchange_residual": "0",
+          "factor_ratio": "2",
+          "k": 7,
+          "nu": "2/5"
+        },
+        {
+          "branch_exchange_residual": "0",
+          "factor_ratio": "2",
+          "k": 7,
+          "nu": "7/4"
+        },
+        {
+          "branch_exchange_residual": "0",
+          "factor_ratio": "2",
+          "k": 8,
+          "nu": "1/3"
+        },
+        {
+          "branch_exchange_residual": "0",
+          "factor_ratio": "2",
+          "k": 8,
+          "nu": "2/5"
+        },
+        {
+          "branch_exchange_residual": "0",
+          "factor_ratio": "2",
+          "k": 8,
+          "nu": "7/4"
+        }
+      ]
+    },
+    "claim_boundary": {
+      "capabilities_removed": [],
+      "contour_orientation_changed": false,
+      "overall_kernel_normalization_fixed": false,
+      "physical_ope_coefficients_recomputed": false
+    },
+    "exact_checks": {
+      "archive_hash_matches": true,
+      "beta_kernel_present": true,
+      "branch_exchange_symmetry_exact": true,
+      "branch_limit_is_minus_two_central_binomial": true,
+      "coalesced_residue_equals_branch_sum": true,
+      "coalesced_residue_is_minus_four_central_binomial": true,
+      "displayed_residue_present": true,
+      "generic_residue_is_twice_displayed": true,
+      "half_argument_jacobian_is_two": true,
+      "member_hash_matches": true,
+      "source_blocks_match": true
+    },
+    "paper": {
+      "arxiv_id": "2501.00462",
+      "title": "Multiparticle States for the Flat Hologram"
+    },
+    "result_version": "sabrina_multiparticle_beta_residue_factor_two_v1",
+    "source_evidence": {
+      "archive_sha256": "917ad8f25057f1316600fb9b9afb6b6c169b1ca05ad088781a84a025a23f0d38",
+      "block_hashes": {
+        "beta_kernel_and_residues": "337fc8d9a84f2d58c2e78b6ea909046ce0661e05008e2ea31f22abf57edbe664"
+      },
+      "checks": {
+        "archive_hash_matches": true,
+        "beta_kernel_present": true,
+        "displayed_residue_present": true,
+        "member_hash_matches": true,
+        "source_blocks_match": true
+      },
+      "member_sha256": "2a2443a343ab2528110bacf66f32464a515ce3252fc36295895f57f9d6fb1e09"
+    },
+    "status": "complete",
+    "theorem": {
+      "branch_collision": "as nu_12 tends to zero each corrected branch residue tends to -2 binomial(2k,k)",
+      "cause": "the pole-bearing gamma argument has derivative -1/2 with respect to Delta, producing a residue Jacobian -2",
+      "coalesced_tower": "the coincident beta pole has residue -4 binomial(2k,k), exactly the sum of the two corrected branch limits",
+      "generic_correction": "the residue with respect to Delta at each displayed beta-function pole is twice the residue printed in eq:3ptPoles"
+    }
+  },
+  "scientific_payload_sha256": "6485daa678a208dfd8860503be6c60a553e2d767188c34ec80b762520c23e455"
+}
diff --git a/references/run_sabrina_near_extremal_radial_pushforward.json b/references/run_sabrina_near_extremal_radial_pushforward.json
new file mode 100644
index 0000000000000000000000000000000000000000..e654ac12ebd4c5c2fcbe1ee4e2daa97de8983fe4
--- /dev/null
+++ b/references/run_sabrina_near_extremal_radial_pushforward.json
@@ -0,0 +1,97 @@
+{
+  "kernel": "run_sabrina_near_extremal_radial_pushforward",
+  "role": "post-computation assertion only",
+  "schema": "ouroboros_scientific_reference_assertion_v1",
+  "scientific_payload": {
+    "claim_boundary": {
+      "arbitrary_mass_kinematics_claimed": false,
+      "capabilities_removed": [],
+      "convergence_claimed": false,
+      "delta_support_kinematics_only": true,
+      "epsilon_strictly_positive": true,
+      "full_amplitude_evaluated": false,
+      "mass_family_2_one_plus_epsilon_m_m_m_only": true
+    },
+    "exact_checks": {
+      "archive_hash_matches": true,
+      "delta_support_present": true,
+      "derivative_is_increasing": true,
+      "endpoint_inverse_exact": true,
+      "endpoint_product_exact": true,
+      "endpoint_width_exact": true,
+      "exact_radius_present": true,
+      "full_amplitude_context_present": true,
+      "inverse_sample_compositions_exact": true,
+      "jacobian_exact": true,
+      "jacobian_positive": true,
+      "median_and_geometric_mean_exact": true,
+      "member_hash_matches": true,
+      "minimum_derivative_exact": true,
+      "minimum_derivative_positive": true,
+      "near_extremal_limit_present": true,
+      "pushforward_normalization_exact": true,
+      "quadratic_witness_exact": true,
+      "source_block_matches": true,
+      "support_quadratic_exact": true
+    },
+    "paper": {
+      "arxiv_id": "1701.00049",
+      "title": "Flat Space Amplitudes and Conformal Symmetry of the Celestial Sphere"
+    },
+    "pushforward_certificate": {
+      "checks": {
+        "endpoint_inverse_exact": true,
+        "inverse_sample_compositions_exact": true,
+        "jacobian_exact": true,
+        "jacobian_positive": true,
+        "pushforward_normalization_exact": true,
+        "quadratic_witness_exact": true
+      },
+      "exact_sample_count": 20,
+      "inverse_map": "(-2*epsilon + rho**2)/(2*epsilon*rho)",
+      "pushforward_density": "(2*epsilon + rho**2)/(2*epsilon*rho**2)",
+      "second_moment": "4*epsilon*(epsilon + 3)/3",
+      "total_measure": "2"
+    },
+    "result_version": "sabrina_near_extremal_radial_pushforward_v1",
+    "source_evidence": {
+      "archive_sha256": "7553fb8bd01cf4423c26ec5da779dcc70589a21c5c3ee63e95ba43ac08460aa4",
+      "block_sha256": "325d049c1635e32ee6c00a22bcc5228172913da086678dcd026678204efd9fa4",
+      "checks": {
+        "archive_hash_matches": true,
+        "delta_support_present": true,
+        "exact_radius_present": true,
+        "full_amplitude_context_present": true,
+        "member_hash_matches": true,
+        "near_extremal_limit_present": true,
+        "source_block_matches": true
+      },
+      "member_sha256": "23a588d9aaade9d5f0868c951a1c98f766732e8e2238cf20cd201a741c9c5fb2",
+      "source_lines": "303-360"
+    },
+    "status": "complete",
+    "support_map_certificate": {
+      "checks": {
+        "derivative_is_increasing": true,
+        "endpoint_product_exact": true,
+        "endpoint_width_exact": true,
+        "median_and_geometric_mean_exact": true,
+        "minimum_derivative_exact": true,
+        "minimum_derivative_positive": true,
+        "support_quadratic_exact": true
+      },
+      "derivative": "c*epsilon**(3/2)/sqrt(c**2*epsilon + 2) + epsilon",
+      "derivative_minimum": "epsilon*(-sqrt(epsilon)/sqrt(epsilon + 2) + 1)",
+      "lower_endpoint": "sqrt(epsilon)*sqrt(epsilon + 2) - epsilon",
+      "rho_of_c": "c*epsilon + sqrt(epsilon)*sqrt(c**2*epsilon + 2)",
+      "upper_endpoint": "sqrt(epsilon)*sqrt(epsilon + 2) + epsilon"
+    },
+    "theorem": {
+      "endpoint_invariants": "width=2 epsilon, product=2 epsilon, median=sqrt(2 epsilon)",
+      "inverse": "c=(rho^2-2 epsilon)/(2 epsilon rho)",
+      "pushforward": "dc=(rho^2+2 epsilon)/(2 epsilon rho^2) drho",
+      "radial_support": "rho in [sqrt(epsilon(2+epsilon))-epsilon, sqrt(epsilon(2+epsilon))+epsilon]"
+    }
+  },
+  "scientific_payload_sha256": "2e51bc35b918b5683ba9f4c83c8ff6e0488713eb143c0d120e66640262410e4e"
+}
diff --git a/references/run_sabrina_p4_spherical_entanglement_expansion.json b/references/run_sabrina_p4_spherical_entanglement_expansion.json
new file mode 100644
index 0000000000000000000000000000000000000000..d73b75d5b9d3642774ac59ef6052a76d9c9cd43b
--- /dev/null
+++ b/references/run_sabrina_p4_spherical_entanglement_expansion.json
@@ -0,0 +1,92 @@
+{
+  "kernel": "run_sabrina_p4_spherical_entanglement_expansion",
+  "role": "post-computation assertion only",
+  "schema": "ouroboros_scientific_reference_assertion_v1",
+  "scientific_payload": {
+    "claim_boundary": {
+      "capabilities_removed": [],
+      "entropic_c_function_derived": false,
+      "finite_P_convergence_proved": false,
+      "numerical_full_profiles_reproduced": false,
+      "source_error_claimed": false,
+      "supergravity_validity_outside_source_domain_claimed": false,
+      "terms_through_order_P_inverse_derived": false
+    },
+    "exact_checks": {
+      "all_symbolic_residuals_zero": true,
+      "archive_hash_matches": true,
+      "both_regional_integrals_exact": true,
+      "member_hash_matches": true,
+      "p4_future_work_statement_unique": true,
+      "regional_area_labels_unique": true,
+      "renormalized_limit_exact": true,
+      "shell_matching_exact": true,
+      "source_blocks_match": true,
+      "sphere_volume_product_exact": true,
+      "throat_and_flat_eom_exact": true
+    },
+    "paper": {
+      "arxiv_id": "2606.13889",
+      "title": "Flat Space Entanglement: A Coulomb Branch Perspective"
+    },
+    "result_version": "sabrina_p4_spherical_entanglement_expansion_v1",
+    "source_evidence": {
+      "archive_sha256": "0c66795a0adac63d23dac9ad3207a4bd586f7453365221b95159bca9380edbc3",
+      "block_hashes": {
+        "area_and_matching": "1a4ecbae9b625bb0cd553031504ffd9c5c9d3da16f973e7e87afd827f92106f1",
+        "p4_future_work": "48ef8f3d699b9bc045849a9cfe7ceec0aa4e5c8388d2fc1b0a24579c6d715793",
+        "precedent_expansions": "a56135ef73575f190dd2e05ce7316f75e652a207bdad7a07bd59739e65b811a5",
+        "spherical_eom": "809aea156968448d52e6189e6dcce138f090bcd434ea12da753fb390b14742f4"
+      },
+      "checks": {
+        "archive_hash_matches": true,
+        "member_hash_matches": true,
+        "p4_future_work_statement_unique": true,
+        "regional_area_labels_unique": true,
+        "source_blocks_match": true
+      },
+      "member_sha256": "3612980847a10a3a07708a1af3dcee65afedc85ffc8106af673e69ae3d42585e"
+    },
+    "status": "complete",
+    "symbolic_derivation": {
+      "area": {
+        "divergent_over_Omega4_Omega3": "P**3*g*r_uv**2/2 - 27*P*g**2*r_uv/8",
+        "renormalized_over_Omega4_Omega3": "-3*P**3*R**2*g/10 + 81*P*R*g**2/35",
+        "renormalized_with_sphere_volumes": "8*pi**4*P*R*g*(-7*P**2*R + 54*g)/35",
+        "through_order_P_over_Omega4_Omega3": "-P*g*(420*P**2*R**2*r_uv**3 - 700*P**2*r_uv**5 + 189*R**4*g - 630*R**2*g*r_uv**2 - 3240*R*g*r_uv**3 + 4725*g*r_uv**4)/(1400*r_uv**3)"
+      },
+      "integrand_coefficients": {
+        "flat_P": "9*g*r**4*(-25*R**2 + 6*r**2)/(50*R**3)",
+        "flat_P3": "r**4",
+        "throat_P": "-9*g*(-9*R**4 + 10*R**2*r**2 + 75*r**4)/(200*r**4)",
+        "throat_P3": "r"
+      },
+      "profiles": {
+        "flat_s": "-3*g/(2*R) + 3*g*r**2/(10*R**3)",
+        "rho_at_origin": "P-3*g/(2*R*P)+O(P^-3)",
+        "throat_s": "3*R**2*g/(10*r**3) - 3*g/(2*r)"
+      },
+      "residuals": {
+        "flat_eom": "0",
+        "leading_area": "0",
+        "order_P_area": "0",
+        "renormalized_area": "0",
+        "shell_derivative_matching": "0",
+        "shell_value_matching": "0",
+        "throat_eom": "0"
+      }
+    },
+    "theorem": {
+      "area_over_Omega4_Omega3": "g P^3(r_uv^2/2-3R^2/10)+g^2 P[-27r_uv/8+81R/35+9R^2/(20r_uv)-27R^4/(200r_uv^3)]+O(P^-1)",
+      "definitions": "g=r_4^3 and Omega4*Omega3=16*pi^4/3",
+      "matched_profiles": {
+        "flat_s": "-3*g/(2*R) + 3*g*r**2/(10*R**3)",
+        "rho_at_origin": "P-3*g/(2*R*P)+O(P^-3)",
+        "throat_s": "3*R**2*g/(10*r**3) - 3*g/(2*r)"
+      },
+      "regime": "p=4, S3 entangling surface, P large, rho=P+s/P+O(P^-3), surface reaches r=0",
+      "renormalized_area_over_Omega4_Omega3": "-3gR^2P^3/10+81g^2RP/35+O(P^-1)"
+    }
+  },
+  "scientific_payload_sha256": "15b684b9177c314bc5aeca308c80eae5ad95abfcd73c261eb7e7e51848f6b300"
+}
diff --git a/references/run_sabrina_p4_spherical_refined_entropy.json b/references/run_sabrina_p4_spherical_refined_entropy.json
new file mode 100644
index 0000000000000000000000000000000000000000..ef45d38e5a0d49e0b9573efdee3b707c8eb9fe50
--- /dev/null
+++ b/references/run_sabrina_p4_spherical_refined_entropy.json
@@ -0,0 +1,84 @@
+{
+  "kernel": "run_sabrina_p4_spherical_refined_entropy",
+  "role": "post-computation assertion only",
+  "schema": "ouroboros_scientific_reference_assertion_v1",
+  "scientific_payload": {
+    "claim_boundary": {
+      "capabilities_removed": [],
+      "finite_counterterm_scheme_independence_claimed": false,
+      "moderate_P_monotonicity_proved": false,
+      "normalization_to_field_theory_N_and_G10_fixed": false,
+      "numerical_profiles_reproduced": false,
+      "supergravity_domain_extended": false,
+      "terms_through_order_P_minus_3_derived": false
+    },
+    "exact_checks": {
+      "P_inverse_area_integral_exact": true,
+      "all_symbolic_residuals_zero": true,
+      "archive_hash_matches": true,
+      "both_t_equations_exact": true,
+      "lower_local_terms_annihilated": true,
+      "member_hash_matches": true,
+      "prior_expansion_manifest_matches": true,
+      "refined_entropy_labels_unique": true,
+      "refined_entropy_operator_exact": true,
+      "source_blocks_match": true,
+      "t_shell_matching_exact": true
+    },
+    "paper": {
+      "arxiv_id": "2606.13889",
+      "title": "Flat Space Entanglement: A Coulomb Branch Perspective"
+    },
+    "result_version": "sabrina_p4_spherical_refined_entropy_v1",
+    "source_evidence": {
+      "archive_sha256": "0c66795a0adac63d23dac9ad3207a4bd586f7453365221b95159bca9380edbc3",
+      "block_hashes": {
+        "area_and_matching": "1a4ecbae9b625bb0cd553031504ffd9c5c9d3da16f973e7e87afd827f92106f1",
+        "degrees_of_freedom": "2c8a4bf8604eb2a36146b59ca8da1550f327eb96871479a884141ff7fde76632",
+        "four_dim_refined_entropy": "99f9b70ee6d83190d0f8ff99c04babcc7a0a7a07ae5c3453be5b9a0829b1bc25",
+        "p4_future_work": "48ef8f3d699b9bc045849a9cfe7ceec0aa4e5c8388d2fc1b0a24579c6d715793",
+        "precedent_expansions": "a56135ef73575f190dd2e05ce7316f75e652a207bdad7a07bd59739e65b811a5",
+        "spherical_eom": "809aea156968448d52e6189e6dcce138f090bcd434ea12da753fb390b14742f4",
+        "three_dim_refined_entropy": "c0baeac9de982295f3f174e15cabd5e01863df355056b06a870934983b0c6a2c"
+      },
+      "checks": {
+        "archive_hash_matches": true,
+        "member_hash_matches": true,
+        "prior_expansion_manifest_matches": true,
+        "refined_entropy_labels_unique": true,
+        "source_blocks_match": true
+      },
+      "member_sha256": "3612980847a10a3a07708a1af3dcee65afedc85ffc8106af673e69ae3d42585e",
+      "prior_manifest_sha256": "1dc9e0a600bc5ff235fe3721a8d9e42aa9dc984bb9665b67b26d859bd8d0cd7c"
+    },
+    "status": "complete",
+    "symbolic_derivation": {
+      "asymptotic_decrease_threshold_P_over_R": "exp(1492067/1575000)",
+      "profiles": {
+        "t_flat": "-9*g**2*(17199*R**4 - 5600*R**2*r**2 + 304*r**4)/(112000*R**6)",
+        "t_throat": "-9*g**2*(-567*R**6 + 4620*R**4*r**2 - 19250*R**2*r**4 + 9600*R*r**5 + 17500*r**6)/(112000*r**8)"
+      },
+      "raw_P_inverse_coefficient_over_Omega4_Omega3": "g**3*(-19683*R**8/(640000*r_uv**8) + 8019*R**6/(32000*r_uv**6) - 5859*R**4/(6400*r_uv**4) + 243*R**3/(350*r_uv**3) + 81*R**2/(128*r_uv**2) - 81*R/(70*r_uv) + 135*log(r_uv/R)/128 + 3792549/4480000)",
+      "refined_entropy_area_over_Omega4_Omega3": "g**3*(45*log(P/R)/16 + 82933/560000)/P",
+      "residuals": {
+        "flat_t_eom": "0",
+        "integrated_P_inverse": "0",
+        "local_P3_and_P_annihilated": "0",
+        "refined_entropy": "0",
+        "shell_t_derivative": "0",
+        "shell_t_value": "0",
+        "throat_t_eom": "0"
+      },
+      "subtracted_area_through_P_inverse_over_Omega4_Omega3": "-3*P**3*R**2*g/10 + 81*P*R*g**2/35 + g**3*(135*log(P/R)/128 + 3792549/4480000)/P",
+      "universal_substitution": "log(r_uv/R) -> log(P/R) after subtracting the p=4 universal logarithmic UV term"
+    },
+    "theorem": {
+      "infrared_behavior": "positive for P>=R, tends to zero as log(P/R)/P, and decreases beyond the recorded exact threshold",
+      "raw_cutoff_result": "g**3*(-19683*R**8/(640000*r_uv**8) + 8019*R**6/(32000*r_uv**6) - 5859*R**4/(6400*r_uv**4) + 243*R**3/(350*r_uv**3) + 81*R**2/(128*r_uv**2) - 81*R/(70*r_uv) + 135*log(r_uv/R)/128 + 3792549/4480000)",
+      "refined_entropy_area_over_Omega4_Omega3": "g^3/P*[45/16 log(P/R)+82933/560000]+O(P^-3)",
+      "refined_operator": "(P*d/dP-1)(P*d/dP-3)/3",
+      "regime": "p=4, P large, rho=P+s/P+t/P^3+O(P^-5)"
+    }
+  },
+  "scientific_payload_sha256": "391c082d381a39de409e09c5d5d1798607ab16101326c4103bafbd5f220a2345"
+}
diff --git a/references/run_sabrina_points_scattering_lower_slack_identity.json b/references/run_sabrina_points_scattering_lower_slack_identity.json
new file mode 100644
index 0000000000000000000000000000000000000000..e1edac4ad0229cb759ad679688264791b7038f75
--- /dev/null
+++ b/references/run_sabrina_points_scattering_lower_slack_identity.json
@@ -0,0 +1,181 @@
+{
+  "kernel": "run_sabrina_points_scattering_lower_slack_identity",
+  "role": "post-computation assertion only",
+  "schema": "ouroboros_scientific_reference_assertion_v1",
+  "scientific_payload": {
+    "claim_boundary": {
+      "capabilities_removed": [],
+      "new_dynamical_equivalence_claimed": false,
+      "semiclassical_entropy_inequalities_only": true
+    },
+    "exact_checks": {
+      "all_chain_residuals_zero": true,
+      "all_sixteen_masks_checked": true,
+      "all_slacks_nonnegative": true,
+      "archive_hash_matches": true,
+      "cwt_ridge_bound_present": true,
+      "final_lower_chain_present": true,
+      "gap_is_exact_slack_sum": true,
+      "max_wedge_bound_present": true,
+      "member_hash_matches": true,
+      "points_focus_bound_present": true,
+      "ridge_order_present": true,
+      "saturation_iff_all_slacks_zero": true,
+      "source_blocks_match": true,
+      "unique_binary_saturation_mask": true
+    },
+    "paper": {
+      "arxiv_id": "2604.22612",
+      "title": "Generalized Entanglement Wedges and the Connected Wedge Theorem"
+    },
+    "result_version": "sabrina_points_scattering_lower_slack_identity_v1",
+    "source_evidence": {
+      "archive_sha256": "8a55509c4b902e68016cb16a722efeb692056e6530cb2d6838b87fe77d6d84f6",
+      "block_hashes": {
+        "cwt_ridge_bound": "53d435b08fb84b5368ad548c6a03644afd5a9e8bf7e040d7d25d1bb83d1ccba5",
+        "max_wedge_entropy_bound": "83e0923ad85ce26ff185b4eb4ca49f7c292dd40adda74bc8cacd7800e4ea4bc5",
+        "points_lower_bound_chain": "647182fc3b6ffc3b9af688727b199766ce64c44b9573f4ce8798f2f0d5974689"
+      },
+      "checks": {
+        "archive_hash_matches": true,
+        "cwt_ridge_bound_present": true,
+        "final_lower_chain_present": true,
+        "max_wedge_bound_present": true,
+        "member_hash_matches": true,
+        "points_focus_bound_present": true,
+        "ridge_order_present": true,
+        "source_blocks_match": true
+      },
+      "member_sha256": "67a3bec7a35d950e982ea7edeccca1c7f0401539106bd1edbfea9e3b80013b0e"
+    },
+    "status": "complete",
+    "symbolic_certificate": {
+      "checks": {
+        "all_chain_residuals_zero": true,
+        "all_sixteen_masks_checked": true,
+        "all_slacks_nonnegative": true,
+        "gap_is_exact_slack_sum": true,
+        "saturation_iff_all_slacks_zero": true,
+        "unique_binary_saturation_mask": true
+      },
+      "equality_rows": [
+        {
+          "all_slacks_zero": true,
+          "gap": "0",
+          "gap_zero": true,
+          "mask": 0
+        },
+        {
+          "all_slacks_zero": false,
+          "gap": "1",
+          "gap_zero": false,
+          "mask": 1
+        },
+        {
+          "all_slacks_zero": false,
+          "gap": "1",
+          "gap_zero": false,
+          "mask": 2
+        },
+        {
+          "all_slacks_zero": false,
+          "gap": "2",
+          "gap_zero": false,
+          "mask": 3
+        },
+        {
+          "all_slacks_zero": false,
+          "gap": "1",
+          "gap_zero": false,
+          "mask": 4
+        },
+        {
+          "all_slacks_zero": false,
+          "gap": "2",
+          "gap_zero": false,
+          "mask": 5
+        },
+        {
+          "all_slacks_zero": false,
+          "gap": "2",
+          "gap_zero": false,
+          "mask": 6
+        },
+        {
+          "all_slacks_zero": false,
+          "gap": "3",
+          "gap_zero": false,
+          "mask": 7
+        },
+        {
+          "all_slacks_zero": false,
+          "gap": "1",
+          "gap_zero": false,
+          "mask": 8
+        },
+        {
+          "all_slacks_zero": false,
+          "gap": "2",
+          "gap_zero": false,
+          "mask": 9
+        },
+        {
+          "all_slacks_zero": false,
+          "gap": "2",
+          "gap_zero": false,
+          "mask": 10
+        },
+        {
+          "all_slacks_zero": false,
+          "gap": "3",
+          "gap_zero": false,
+          "mask": 11
+        },
+        {
+          "all_slacks_zero": false,
+          "gap": "2",
+          "gap_zero": false,
+          "mask": 12
+        },
+        {
+          "all_slacks_zero": false,
+          "gap": "3",
+          "gap_zero": false,
+          "mask": 13
+        },
+        {
+          "all_slacks_zero": false,
+          "gap": "3",
+          "gap_zero": false,
+          "mask": 14
+        },
+        {
+          "all_slacks_zero": false,
+          "gap": "4",
+          "gap_zero": false,
+          "mask": 15
+        }
+      ],
+      "gap_identity": "I(V1;V2)-S_gen(e_max(s_pts''))=delta_CWT+delta_ridge+delta_focus+delta_max",
+      "residuals": {
+        "cwt_step": "0",
+        "focus_step": "0",
+        "gap_identity": "0",
+        "max_wedge_step": "0",
+        "ridge_step": "0"
+      },
+      "symbolic_gap": "delta_CWT + delta_focus + delta_max + delta_ridge"
+    },
+    "theorem": {
+      "lower_gap_identity": "I(V1;V2)-S_gen(e_max(s_pts''))=delta_CWT+delta_ridge+delta_focus+delta_max",
+      "saturation": "the lower bound saturates if and only if all four source inequalities saturate simultaneously",
+      "slack_meanings": {
+        "delta_CWT": "I(V1;V2)-Area(R_reg)/(2G_N)",
+        "delta_focus": "Area(R_pts)/(2G_N)-S_gen(s_pts'')",
+        "delta_max": "S_gen(s_pts'')-S_gen(e_max(s_pts''))",
+        "delta_ridge": "[Area(R_reg)-Area(R_pts)]/(2G_N)"
+      }
+    }
+  },
+  "scientific_payload_sha256": "7f9b013510e795182939e14d751abafa52301bf7e7cd140ff4fa5a32a2b8db69"
+}
diff --git a/references/run_sabrina_principal_series_plancherel_factorization.json b/references/run_sabrina_principal_series_plancherel_factorization.json
new file mode 100644
index 0000000000000000000000000000000000000000..357e23397530428e4fba6f47251c4f78a0804396
--- /dev/null
+++ b/references/run_sabrina_principal_series_plancherel_factorization.json
@@ -0,0 +1,242 @@
+{
+  "kernel": "run_sabrina_principal_series_plancherel_factorization",
+  "role": "post-computation assertion only",
+  "schema": "ouroboros_scientific_reference_assertion_v1",
+  "scientific_payload": {
+    "claim_boundary": {
+      "capabilities_removed": [],
+      "direct_gamma_substitution_at_nu_zero_used": false,
+      "mass_independence_rederived": false,
+      "off_principal_series_gauge_zero_modes_resolved": false,
+      "source_completeness_extended_beyond_assumptions": false,
+      "source_error_claimed": false,
+      "strict_positivity_at_nu_zero_claimed": false
+    },
+    "classification": "principal_series_plancherel_measure_all_integer_d_factorization_exact",
+    "dimension_rows": [
+      {
+        "closed_form": "nu*tanh(pi*nu)/(4*pi**2)",
+        "d": 1,
+        "measure_at_origin_by_limit": "0",
+        "parity": "odd",
+        "quadratic_zero_coefficient": "1/(4*pi)",
+        "quadratic_zero_coefficient_positive": true,
+        "shadow_even": true,
+        "strict_positivity_domain": "real nu != 0"
+      },
+      {
+        "closed_form": "nu**2/(4*pi**3)",
+        "d": 2,
+        "measure_at_origin_by_limit": "0",
+        "parity": "even",
+        "quadratic_zero_coefficient": "1/(4*pi**3)",
+        "quadratic_zero_coefficient_positive": true,
+        "shadow_even": true,
+        "strict_positivity_domain": "real nu != 0"
+      },
+      {
+        "closed_form": "nu*(4*nu**2 + 1)*tanh(pi*nu)/(16*pi**4)",
+        "d": 3,
+        "measure_at_origin_by_limit": "0",
+        "parity": "odd",
+        "quadratic_zero_coefficient": "1/(16*pi**3)",
+        "quadratic_zero_coefficient_positive": true,
+        "shadow_even": true,
+        "strict_positivity_domain": "real nu != 0"
+      },
+      {
+        "closed_form": "nu**2*(nu**2 + 1)/(4*pi**5)",
+        "d": 4,
+        "measure_at_origin_by_limit": "0",
+        "parity": "even",
+        "quadratic_zero_coefficient": "1/(4*pi**5)",
+        "quadratic_zero_coefficient_positive": true,
+        "shadow_even": true,
+        "strict_positivity_domain": "real nu != 0"
+      },
+      {
+        "closed_form": "nu*(4*nu**2 + 1)*(4*nu**2 + 9)*tanh(pi*nu)/(64*pi**6)",
+        "d": 5,
+        "measure_at_origin_by_limit": "0",
+        "parity": "odd",
+        "quadratic_zero_coefficient": "9/(64*pi**5)",
+        "quadratic_zero_coefficient_positive": true,
+        "shadow_even": true,
+        "strict_positivity_domain": "real nu != 0"
+      },
+      {
+        "closed_form": "nu**2*(nu**2 + 1)*(nu**2 + 4)/(4*pi**7)",
+        "d": 6,
+        "measure_at_origin_by_limit": "0",
+        "parity": "even",
+        "quadratic_zero_coefficient": "pi**(-7)",
+        "quadratic_zero_coefficient_positive": true,
+        "shadow_even": true,
+        "strict_positivity_domain": "real nu != 0"
+      },
+      {
+        "closed_form": "nu*(4*nu**2 + 1)*(4*nu**2 + 9)*(4*nu**2 + 25)*tanh(pi*nu)/(256*pi**8)",
+        "d": 7,
+        "measure_at_origin_by_limit": "0",
+        "parity": "odd",
+        "quadratic_zero_coefficient": "225/(256*pi**7)",
+        "quadratic_zero_coefficient_positive": true,
+        "shadow_even": true,
+        "strict_positivity_domain": "real nu != 0"
+      },
+      {
+        "closed_form": "nu**2*(nu**2 + 1)*(nu**2 + 4)*(nu**2 + 9)/(4*pi**9)",
+        "d": 8,
+        "measure_at_origin_by_limit": "0",
+        "parity": "even",
+        "quadratic_zero_coefficient": "9/pi**9",
+        "quadratic_zero_coefficient_positive": true,
+        "shadow_even": true,
+        "strict_positivity_domain": "real nu != 0"
+      },
+      {
+        "closed_form": "nu*(4*nu**2 + 1)*(4*nu**2 + 9)*(4*nu**2 + 25)*(4*nu**2 + 49)*tanh(pi*nu)/(1024*pi**10)",
+        "d": 9,
+        "measure_at_origin_by_limit": "0",
+        "parity": "odd",
+        "quadratic_zero_coefficient": "11025/(1024*pi**9)",
+        "quadratic_zero_coefficient_positive": true,
+        "shadow_even": true,
+        "strict_positivity_domain": "real nu != 0"
+      },
+      {
+        "closed_form": "nu**2*(nu**2 + 1)*(nu**2 + 4)*(nu**2 + 9)*(nu**2 + 16)/(4*pi**11)",
+        "d": 10,
+        "measure_at_origin_by_limit": "0",
+        "parity": "even",
+        "quadratic_zero_coefficient": "144/pi**11",
+        "quadratic_zero_coefficient_positive": true,
+        "shadow_even": true,
+        "strict_positivity_domain": "real nu != 0"
+      },
+      {
+        "closed_form": "nu*(4*nu**2 + 1)*(4*nu**2 + 9)*(4*nu**2 + 25)*(4*nu**2 + 49)*(4*nu**2 + 81)*tanh(pi*nu)/(4096*pi**12)",
+        "d": 11,
+        "measure_at_origin_by_limit": "0",
+        "parity": "odd",
+        "quadratic_zero_coefficient": "893025/(4096*pi**11)",
+        "quadratic_zero_coefficient_positive": true,
+        "shadow_even": true,
+        "strict_positivity_domain": "real nu != 0"
+      },
+      {
+        "closed_form": "nu**2*(nu**2 + 1)*(nu**2 + 4)*(nu**2 + 9)*(nu**2 + 16)*(nu**2 + 25)/(4*pi**13)",
+        "d": 12,
+        "measure_at_origin_by_limit": "0",
+        "parity": "even",
+        "quadratic_zero_coefficient": "3600/pi**13",
+        "quadratic_zero_coefficient_positive": true,
+        "shadow_even": true,
+        "strict_positivity_domain": "real nu != 0"
+      }
+    ],
+    "exact_checks": {
+      "all_d1_through_d12_are_shadow_even": true,
+      "all_d1_through_d12_vanish_at_origin": true,
+      "all_quadratic_zero_coefficients_positive": true,
+      "all_ten_dimension_recurrences_exact": true,
+      "archive_hash_matches": true,
+      "d1_base_is_nu_tanh_over_4pi2": true,
+      "d2_base_is_nu2_over_4pi3": true,
+      "member_hash_matches": true,
+      "principal_shadow_maps_nu_to_minus_nu": true,
+      "shadow_context_hash_matches": true,
+      "shadow_context_unique": true,
+      "source_equation_blocks_match": true,
+      "source_equation_markers_unique": true,
+      "source_states_mass_independence": true
+    },
+    "paper": {
+      "arxiv_id": "1905.10052",
+      "title": "Implications of Superrotations"
+    },
+    "recurrence_rows": [
+      {
+        "d_to_d_plus_2": "1->3",
+        "exact": true,
+        "residual": "0"
+      },
+      {
+        "d_to_d_plus_2": "2->4",
+        "exact": true,
+        "residual": "0"
+      },
+      {
+        "d_to_d_plus_2": "3->5",
+        "exact": true,
+        "residual": "0"
+      },
+      {
+        "d_to_d_plus_2": "4->6",
+        "exact": true,
+        "residual": "0"
+      },
+      {
+        "d_to_d_plus_2": "5->7",
+        "exact": true,
+        "residual": "0"
+      },
+      {
+        "d_to_d_plus_2": "6->8",
+        "exact": true,
+        "residual": "0"
+      },
+      {
+        "d_to_d_plus_2": "7->9",
+        "exact": true,
+        "residual": "0"
+      },
+      {
+        "d_to_d_plus_2": "8->10",
+        "exact": true,
+        "residual": "0"
+      },
+      {
+        "d_to_d_plus_2": "9->11",
+        "exact": true,
+        "residual": "0"
+      },
+      {
+        "d_to_d_plus_2": "10->12",
+        "exact": true,
+        "residual": "0"
+      }
+    ],
+    "result_version": "sabrina_principal_series_plancherel_factorization_v1",
+    "source_evidence": {
+      "archive_sha256": "f6dbbd7baa6b7eb93cb06b6460877b26f09ba30bacd6b447641ccf6843828df6",
+      "block_hashes": {
+        "orthonormality": "33ab352d1fe06108a33c8a2a706e2a52b1a11bdfdad1b1a807ce72b75fadd14f",
+        "plancherel_measure": "5ba93a88abf2a4b0c64cfd76d2cf8fdad928059bf2a32876b19fbfaf768ee495",
+        "principal_series": "2e1210ae9acd758068aa25342ee9c67505de433b6d850e0528cd6f50c3ea2c04"
+      },
+      "checks": {
+        "archive_hash_matches": true,
+        "member_hash_matches": true,
+        "shadow_context_hash_matches": true,
+        "shadow_context_unique": true,
+        "source_equation_blocks_match": true,
+        "source_equation_markers_unique": true,
+        "source_states_mass_independence": true
+      },
+      "member_sha256": "0e505e56e7acd99f9a6190e4fe4a3625ea620a5067c3ea8d270ee947dffdab8c",
+      "shadow_context_sha256": "1fbbaa27d16b0df0791fb61f386b558f7de3540e468b1ee2ab3c2dc65e4f3e55"
+    },
+    "status": "complete",
+    "theorem": {
+      "dimension_recurrence": "mu_(d+2)=((d/2)^2+nu^2) mu_d/pi^2",
+      "even_d_2m": "nu^2 product_(k=1)^(m-1)(nu^2+k^2)/(4 pi^(2m+1))",
+      "odd_d_2m_plus_1": "nu tanh(pi nu) product_(k=0)^(m-1)(nu^2+(k+1/2)^2)/(4 pi^(2m+2))",
+      "origin": "quadratic zero obtained by limit, never direct gamma substitution",
+      "positivity": "strict for real nu != 0",
+      "shadow_action": "nu -> -nu",
+      "source_measure": "Gamma(d/2+i nu)Gamma(d/2-i nu)/(4 pi^(d+1) Gamma(i nu)Gamma(-i nu))"
+    }
+  },
+  "scientific_payload_sha256": "4047efe441ad0800b95a0d64b4354de371b4f6fdf6be4f1cbe59763680be8178"
+}
diff --git a/references/run_sabrina_projective_mellin_scale_theorem.json b/references/run_sabrina_projective_mellin_scale_theorem.json
new file mode 100644
index 0000000000000000000000000000000000000000..993dca283e88188884022bc596ff245845f19f8d
--- /dev/null
+++ b/references/run_sabrina_projective_mellin_scale_theorem.json
@@ -0,0 +1,1288 @@
+{
+  "kernel": "run_sabrina_projective_mellin_scale_theorem",
+  "role": "post-computation assertion only",
+  "schema": "ouroboros_scientific_reference_assertion_v1",
+  "scientific_payload": {
+    "claim_boundary": {
+      "capabilities_removed": [],
+      "extra_physical_scales_included": false,
+      "massive_amplitudes_included": false,
+      "massless_canonical_external_scaling_required": true,
+      "noncanonical_external_dimensions_included": false,
+      "physical_theorem_dimension_scope": "D>=3; D=2 retained only as a formal algebraic boundary check",
+      "scale_anomalies_included": false,
+      "source_error_claimed": false
+    },
+    "classification": "all_D_all_n_projective_mellin_radial_scale_cancellation_exact_under_canonical_scaling",
+    "exact_checks": {
+      "D2_through_D12_n2_through_n12_all_cancel": true,
+      "D4_principal_mellin_real_weight_vanishes": true,
+      "archive_hash_matches": true,
+      "finite_grid_has_121_points": true,
+      "member_hash_matches": true,
+      "source_blocks_match": true,
+      "source_markers_are_unique": true,
+      "source_states_four_dimensional_delta_scaling": true,
+      "source_states_full_amplitude_degree_minus_n": true,
+      "symbolic_all_D_all_n_total_is_minus_one": true,
+      "symbolic_full_amplitude_degree_specializes_to_minus_n_at_D4": true,
+      "symbolic_stripped_degree_specializes_to_4_minus_n": true
+    },
+    "finite_exact_grid": [
+      {
+        "D": 2,
+        "cancels_to_minus_one": true,
+        "jacobian": "1",
+        "momentum_delta": "-2",
+        "n": 2,
+        "principal_mellin_real": "-2",
+        "stripped_amplitude": "2",
+        "total_real": "-1"
+      },
+      {
+        "D": 2,
+        "cancels_to_minus_one": true,
+        "jacobian": "2",
+        "momentum_delta": "-2",
+        "n": 3,
+        "principal_mellin_real": "-3",
+        "stripped_amplitude": "2",
+        "total_real": "-1"
+      },
+      {
+        "D": 2,
+        "cancels_to_minus_one": true,
+        "jacobian": "3",
+        "momentum_delta": "-2",
+        "n": 4,
+        "principal_mellin_real": "-4",
+        "stripped_amplitude": "2",
+        "total_real": "-1"
+      },
+      {
+        "D": 2,
+        "cancels_to_minus_one": true,
+        "jacobian": "4",
+        "momentum_delta": "-2",
+        "n": 5,
+        "principal_mellin_real": "-5",
+        "stripped_amplitude": "2",
+        "total_real": "-1"
+      },
+      {
+        "D": 2,
+        "cancels_to_minus_one": true,
+        "jacobian": "5",
+        "momentum_delta": "-2",
+        "n": 6,
+        "principal_mellin_real": "-6",
+        "stripped_amplitude": "2",
+        "total_real": "-1"
+      },
+      {
+        "D": 2,
+        "cancels_to_minus_one": true,
+        "jacobian": "6",
+        "momentum_delta": "-2",
+        "n": 7,
+        "principal_mellin_real": "-7",
+        "stripped_amplitude": "2",
+        "total_real": "-1"
+      },
+      {
+        "D": 2,
+        "cancels_to_minus_one": true,
+        "jacobian": "7",
+        "momentum_delta": "-2",
+        "n": 8,
+        "principal_mellin_real": "-8",
+        "stripped_amplitude": "2",
+        "total_real": "-1"
+      },
+      {
+        "D": 2,
+        "cancels_to_minus_one": true,
+        "jacobian": "8",
+        "momentum_delta": "-2",
+        "n": 9,
+        "principal_mellin_real": "-9",
+        "stripped_amplitude": "2",
+        "total_real": "-1"
+      },
+      {
+        "D": 2,
+        "cancels_to_minus_one": true,
+        "jacobian": "9",
+        "momentum_delta": "-2",
+        "n": 10,
+        "principal_mellin_real": "-10",
+        "stripped_amplitude": "2",
+        "total_real": "-1"
+      },
+      {
+        "D": 2,
+        "cancels_to_minus_one": true,
+        "jacobian": "10",
+        "momentum_delta": "-2",
+        "n": 11,
+        "principal_mellin_real": "-11",
+        "stripped_amplitude": "2",
+        "total_real": "-1"
+      },
+      {
+        "D": 2,
+        "cancels_to_minus_one": true,
+        "jacobian": "11",
+        "momentum_delta": "-2",
+        "n": 12,
+        "principal_mellin_real": "-12",
+        "stripped_amplitude": "2",
+        "total_real": "-1"
+      },
+      {
+        "D": 3,
+        "cancels_to_minus_one": true,
+        "jacobian": "1",
+        "momentum_delta": "-3",
+        "n": 2,
+        "principal_mellin_real": "-1",
+        "stripped_amplitude": "2",
+        "total_real": "-1"
+      },
+      {
+        "D": 3,
+        "cancels_to_minus_one": true,
+        "jacobian": "2",
+        "momentum_delta": "-3",
+        "n": 3,
+        "principal_mellin_real": "-3/2",
+        "stripped_amplitude": "3/2",
+        "total_real": "-1"
+      },
+      {
+        "D": 3,
+        "cancels_to_minus_one": true,
+        "jacobian": "3",
+        "momentum_delta": "-3",
+        "n": 4,
+        "principal_mellin_real": "-2",
+        "stripped_amplitude": "1",
+        "total_real": "-1"
+      },
+      {
+        "D": 3,
+        "cancels_to_minus_one": true,
+        "jacobian": "4",
+        "momentum_delta": "-3",
+        "n": 5,
+        "principal_mellin_real": "-5/2",
+        "stripped_amplitude": "1/2",
+        "total_real": "-1"
+      },
+      {
+        "D": 3,
+        "cancels_to_minus_one": true,
+        "jacobian": "5",
+        "momentum_delta": "-3",
+        "n": 6,
+        "principal_mellin_real": "-3",
+        "stripped_amplitude": "0",
+        "total_real": "-1"
+      },
+      {
+        "D": 3,
+        "cancels_to_minus_one": true,
+        "jacobian": "6",
+        "momentum_delta": "-3",
+        "n": 7,
+        "principal_mellin_real": "-7/2",
+        "stripped_amplitude": "-1/2",
+        "total_real": "-1"
+      },
+      {
+        "D": 3,
+        "cancels_to_minus_one": true,
+        "jacobian": "7",
+        "momentum_delta": "-3",
+        "n": 8,
+        "principal_mellin_real": "-4",
+        "stripped_amplitude": "-1",
+        "total_real": "-1"
+      },
+      {
+        "D": 3,
+        "cancels_to_minus_one": true,
+        "jacobian": "8",
+        "momentum_delta": "-3",
+        "n": 9,
+        "principal_mellin_real": "-9/2",
+        "stripped_amplitude": "-3/2",
+        "total_real": "-1"
+      },
+      {
+        "D": 3,
+        "cancels_to_minus_one": true,
+        "jacobian": "9",
+        "momentum_delta": "-3",
+        "n": 10,
+        "principal_mellin_real": "-5",
+        "stripped_amplitude": "-2",
+        "total_real": "-1"
+      },
+      {
+        "D": 3,
+        "cancels_to_minus_one": true,
+        "jacobian": "10",
+        "momentum_delta": "-3",
+        "n": 11,
+        "principal_mellin_real": "-11/2",
+        "stripped_amplitude": "-5/2",
+        "total_real": "-1"
+      },
+      {
+        "D": 3,
+        "cancels_to_minus_one": true,
+        "jacobian": "11",
+        "momentum_delta": "-3",
+        "n": 12,
+        "principal_mellin_real": "-6",
+        "stripped_amplitude": "-3",
+        "total_real": "-1"
+      },
+      {
+        "D": 4,
+        "cancels_to_minus_one": true,
+        "jacobian": "1",
+        "momentum_delta": "-4",
+        "n": 2,
+        "principal_mellin_real": "0",
+        "stripped_amplitude": "2",
+        "total_real": "-1"
+      },
+      {
+        "D": 4,
+        "cancels_to_minus_one": true,
+        "jacobian": "2",
+        "momentum_delta": "-4",
+        "n": 3,
+        "principal_mellin_real": "0",
+        "stripped_amplitude": "1",
+        "total_real": "-1"
+      },
+      {
+        "D": 4,
+        "cancels_to_minus_one": true,
+        "jacobian": "3",
+        "momentum_delta": "-4",
+        "n": 4,
+        "principal_mellin_real": "0",
+        "stripped_amplitude": "0",
+        "total_real": "-1"
+      },
+      {
+        "D": 4,
+        "cancels_to_minus_one": true,
+        "jacobian": "4",
+        "momentum_delta": "-4",
+        "n": 5,
+        "principal_mellin_real": "0",
+        "stripped_amplitude": "-1",
+        "total_real": "-1"
+      },
+      {
+        "D": 4,
+        "cancels_to_minus_one": true,
+        "jacobian": "5",
+        "momentum_delta": "-4",
+        "n": 6,
+        "principal_mellin_real": "0",
+        "stripped_amplitude": "-2",
+        "total_real": "-1"
+      },
+      {
+        "D": 4,
+        "cancels_to_minus_one": true,
+        "jacobian": "6",
+        "momentum_delta": "-4",
+        "n": 7,
+        "principal_mellin_real": "0",
+        "stripped_amplitude": "-3",
+        "total_real": "-1"
+      },
+      {
+        "D": 4,
+        "cancels_to_minus_one": true,
+        "jacobian": "7",
+        "momentum_delta": "-4",
+        "n": 8,
+        "principal_mellin_real": "0",
+        "stripped_amplitude": "-4",
+        "total_real": "-1"
+      },
+      {
+        "D": 4,
+        "cancels_to_minus_one": true,
+        "jacobian": "8",
+        "momentum_delta": "-4",
+        "n": 9,
+        "principal_mellin_real": "0",
+        "stripped_amplitude": "-5",
+        "total_real": "-1"
+      },
+      {
+        "D": 4,
+        "cancels_to_minus_one": true,
+        "jacobian": "9",
+        "momentum_delta": "-4",
+        "n": 10,
+        "principal_mellin_real": "0",
+        "stripped_amplitude": "-6",
+        "total_real": "-1"
+      },
+      {
+        "D": 4,
+        "cancels_to_minus_one": true,
+        "jacobian": "10",
+        "momentum_delta": "-4",
+        "n": 11,
+        "principal_mellin_real": "0",
+        "stripped_amplitude": "-7",
+        "total_real": "-1"
+      },
+      {
+        "D": 4,
+        "cancels_to_minus_one": true,
+        "jacobian": "11",
+        "momentum_delta": "-4",
+        "n": 12,
+        "principal_mellin_real": "0",
+        "stripped_amplitude": "-8",
+        "total_real": "-1"
+      },
+      {
+        "D": 5,
+        "cancels_to_minus_one": true,
+        "jacobian": "1",
+        "momentum_delta": "-5",
+        "n": 2,
+        "principal_mellin_real": "1",
+        "stripped_amplitude": "2",
+        "total_real": "-1"
+      },
+      {
+        "D": 5,
+        "cancels_to_minus_one": true,
+        "jacobian": "2",
+        "momentum_delta": "-5",
+        "n": 3,
+        "principal_mellin_real": "3/2",
+        "stripped_amplitude": "1/2",
+        "total_real": "-1"
+      },
+      {
+        "D": 5,
+        "cancels_to_minus_one": true,
+        "jacobian": "3",
+        "momentum_delta": "-5",
+        "n": 4,
+        "principal_mellin_real": "2",
+        "stripped_amplitude": "-1",
+        "total_real": "-1"
+      },
+      {
+        "D": 5,
+        "cancels_to_minus_one": true,
+        "jacobian": "4",
+        "momentum_delta": "-5",
+        "n": 5,
+        "principal_mellin_real": "5/2",
+        "stripped_amplitude": "-5/2",
+        "total_real": "-1"
+      },
+      {
+        "D": 5,
+        "cancels_to_minus_one": true,
+        "jacobian": "5",
+        "momentum_delta": "-5",
+        "n": 6,
+        "principal_mellin_real": "3",
+        "stripped_amplitude": "-4",
+        "total_real": "-1"
+      },
+      {
+        "D": 5,
+        "cancels_to_minus_one": true,
+        "jacobian": "6",
+        "momentum_delta": "-5",
+        "n": 7,
+        "principal_mellin_real": "7/2",
+        "stripped_amplitude": "-11/2",
+        "total_real": "-1"
+      },
+      {
+        "D": 5,
+        "cancels_to_minus_one": true,
+        "jacobian": "7",
+        "momentum_delta": "-5",
+        "n": 8,
+        "principal_mellin_real": "4",
+        "stripped_amplitude": "-7",
+        "total_real": "-1"
+      },
+      {
+        "D": 5,
+        "cancels_to_minus_one": true,
+        "jacobian": "8",
+        "momentum_delta": "-5",
+        "n": 9,
+        "principal_mellin_real": "9/2",
+        "stripped_amplitude": "-17/2",
+        "total_real": "-1"
+      },
+      {
+        "D": 5,
+        "cancels_to_minus_one": true,
+        "jacobian": "9",
+        "momentum_delta": "-5",
+        "n": 10,
+        "principal_mellin_real": "5",
+        "stripped_amplitude": "-10",
+        "total_real": "-1"
+      },
+      {
+        "D": 5,
+        "cancels_to_minus_one": true,
+        "jacobian": "10",
+        "momentum_delta": "-5",
+        "n": 11,
+        "principal_mellin_real": "11/2",
+        "stripped_amplitude": "-23/2",
+        "total_real": "-1"
+      },
+      {
+        "D": 5,
+        "cancels_to_minus_one": true,
+        "jacobian": "11",
+        "momentum_delta": "-5",
+        "n": 12,
+        "principal_mellin_real": "6",
+        "stripped_amplitude": "-13",
+        "total_real": "-1"
+      },
+      {
+        "D": 6,
+        "cancels_to_minus_one": true,
+        "jacobian": "1",
+        "momentum_delta": "-6",
+        "n": 2,
+        "principal_mellin_real": "2",
+        "stripped_amplitude": "2",
+        "total_real": "-1"
+      },
+      {
+        "D": 6,
+        "cancels_to_minus_one": true,
+        "jacobian": "2",
+        "momentum_delta": "-6",
+        "n": 3,
+        "principal_mellin_real": "3",
+        "stripped_amplitude": "0",
+        "total_real": "-1"
+      },
+      {
+        "D": 6,
+        "cancels_to_minus_one": true,
+        "jacobian": "3",
+        "momentum_delta": "-6",
+        "n": 4,
+        "principal_mellin_real": "4",
+        "stripped_amplitude": "-2",
+        "total_real": "-1"
+      },
+      {
+        "D": 6,
+        "cancels_to_minus_one": true,
+        "jacobian": "4",
+        "momentum_delta": "-6",
+        "n": 5,
+        "principal_mellin_real": "5",
+        "stripped_amplitude": "-4",
+        "total_real": "-1"
+      },
+      {
+        "D": 6,
+        "cancels_to_minus_one": true,
+        "jacobian": "5",
+        "momentum_delta": "-6",
+        "n": 6,
+        "principal_mellin_real": "6",
+        "stripped_amplitude": "-6",
+        "total_real": "-1"
+      },
+      {
+        "D": 6,
+        "cancels_to_minus_one": true,
+        "jacobian": "6",
+        "momentum_delta": "-6",
+        "n": 7,
+        "principal_mellin_real": "7",
+        "stripped_amplitude": "-8",
+        "total_real": "-1"
+      },
+      {
+        "D": 6,
+        "cancels_to_minus_one": true,
+        "jacobian": "7",
+        "momentum_delta": "-6",
+        "n": 8,
+        "principal_mellin_real": "8",
+        "stripped_amplitude": "-10",
+        "total_real": "-1"
+      },
+      {
+        "D": 6,
+        "cancels_to_minus_one": true,
+        "jacobian": "8",
+        "momentum_delta": "-6",
+        "n": 9,
+        "principal_mellin_real": "9",
+        "stripped_amplitude": "-12",
+        "total_real": "-1"
+      },
+      {
+        "D": 6,
+        "cancels_to_minus_one": true,
+        "jacobian": "9",
+        "momentum_delta": "-6",
+        "n": 10,
+        "principal_mellin_real": "10",
+        "stripped_amplitude": "-14",
+        "total_real": "-1"
+      },
+      {
+        "D": 6,
+        "cancels_to_minus_one": true,
+        "jacobian": "10",
+        "momentum_delta": "-6",
+        "n": 11,
+        "principal_mellin_real": "11",
+        "stripped_amplitude": "-16",
+        "total_real": "-1"
+      },
+      {
+        "D": 6,
+        "cancels_to_minus_one": true,
+        "jacobian": "11",
+        "momentum_delta": "-6",
+        "n": 12,
+        "principal_mellin_real": "12",
+        "stripped_amplitude": "-18",
+        "total_real": "-1"
+      },
+      {
+        "D": 7,
+        "cancels_to_minus_one": true,
+        "jacobian": "1",
+        "momentum_delta": "-7",
+        "n": 2,
+        "principal_mellin_real": "3",
+        "stripped_amplitude": "2",
+        "total_real": "-1"
+      },
+      {
+        "D": 7,
+        "cancels_to_minus_one": true,
+        "jacobian": "2",
+        "momentum_delta": "-7",
+        "n": 3,
+        "principal_mellin_real": "9/2",
+        "stripped_amplitude": "-1/2",
+        "total_real": "-1"
+      },
+      {
+        "D": 7,
+        "cancels_to_minus_one": true,
+        "jacobian": "3",
+        "momentum_delta": "-7",
+        "n": 4,
+        "principal_mellin_real": "6",
+        "stripped_amplitude": "-3",
+        "total_real": "-1"
+      },
+      {
+        "D": 7,
+        "cancels_to_minus_one": true,
+        "jacobian": "4",
+        "momentum_delta": "-7",
+        "n": 5,
+        "principal_mellin_real": "15/2",
+        "stripped_amplitude": "-11/2",
+        "total_real": "-1"
+      },
+      {
+        "D": 7,
+        "cancels_to_minus_one": true,
+        "jacobian": "5",
+        "momentum_delta": "-7",
+        "n": 6,
+        "principal_mellin_real": "9",
+        "stripped_amplitude": "-8",
+        "total_real": "-1"
+      },
+      {
+        "D": 7,
+        "cancels_to_minus_one": true,
+        "jacobian": "6",
+        "momentum_delta": "-7",
+        "n": 7,
+        "principal_mellin_real": "21/2",
+        "stripped_amplitude": "-21/2",
+        "total_real": "-1"
+      },
+      {
+        "D": 7,
+        "cancels_to_minus_one": true,
+        "jacobian": "7",
+        "momentum_delta": "-7",
+        "n": 8,
+        "principal_mellin_real": "12",
+        "stripped_amplitude": "-13",
+        "total_real": "-1"
+      },
+      {
+        "D": 7,
+        "cancels_to_minus_one": true,
+        "jacobian": "8",
+        "momentum_delta": "-7",
+        "n": 9,
+        "principal_mellin_real": "27/2",
+        "stripped_amplitude": "-31/2",
+        "total_real": "-1"
+      },
+      {
+        "D": 7,
+        "cancels_to_minus_one": true,
+        "jacobian": "9",
+        "momentum_delta": "-7",
+        "n": 10,
+        "principal_mellin_real": "15",
+        "stripped_amplitude": "-18",
+        "total_real": "-1"
+      },
+      {
+        "D": 7,
+        "cancels_to_minus_one": true,
+        "jacobian": "10",
+        "momentum_delta": "-7",
+        "n": 11,
+        "principal_mellin_real": "33/2",
+        "stripped_amplitude": "-41/2",
+        "total_real": "-1"
+      },
+      {
+        "D": 7,
+        "cancels_to_minus_one": true,
+        "jacobian": "11",
+        "momentum_delta": "-7",
+        "n": 12,
+        "principal_mellin_real": "18",
+        "stripped_amplitude": "-23",
+        "total_real": "-1"
+      },
+      {
+        "D": 8,
+        "cancels_to_minus_one": true,
+        "jacobian": "1",
+        "momentum_delta": "-8",
+        "n": 2,
+        "principal_mellin_real": "4",
+        "stripped_amplitude": "2",
+        "total_real": "-1"
+      },
+      {
+        "D": 8,
+        "cancels_to_minus_one": true,
+        "jacobian": "2",
+        "momentum_delta": "-8",
+        "n": 3,
+        "principal_mellin_real": "6",
+        "stripped_amplitude": "-1",
+        "total_real": "-1"
+      },
+      {
+        "D": 8,
+        "cancels_to_minus_one": true,
+        "jacobian": "3",
+        "momentum_delta": "-8",
+        "n": 4,
+        "principal_mellin_real": "8",
+        "stripped_amplitude": "-4",
+        "total_real": "-1"
+      },
+      {
+        "D": 8,
+        "cancels_to_minus_one": true,
+        "jacobian": "4",
+        "momentum_delta": "-8",
+        "n": 5,
+        "principal_mellin_real": "10",
+        "stripped_amplitude": "-7",
+        "total_real": "-1"
+      },
+      {
+        "D": 8,
+        "cancels_to_minus_one": true,
+        "jacobian": "5",
+        "momentum_delta": "-8",
+        "n": 6,
+        "principal_mellin_real": "12",
+        "stripped_amplitude": "-10",
+        "total_real": "-1"
+      },
+      {
+        "D": 8,
+        "cancels_to_minus_one": true,
+        "jacobian": "6",
+        "momentum_delta": "-8",
+        "n": 7,
+        "principal_mellin_real": "14",
+        "stripped_amplitude": "-13",
+        "total_real": "-1"
+      },
+      {
+        "D": 8,
+        "cancels_to_minus_one": true,
+        "jacobian": "7",
+        "momentum_delta": "-8",
+        "n": 8,
+        "principal_mellin_real": "16",
+        "stripped_amplitude": "-16",
+        "total_real": "-1"
+      },
+      {
+        "D": 8,
+        "cancels_to_minus_one": true,
+        "jacobian": "8",
+        "momentum_delta": "-8",
+        "n": 9,
+        "principal_mellin_real": "18",
+        "stripped_amplitude": "-19",
+        "total_real": "-1"
+      },
+      {
+        "D": 8,
+        "cancels_to_minus_one": true,
+        "jacobian": "9",
+        "momentum_delta": "-8",
+        "n": 10,
+        "principal_mellin_real": "20",
+        "stripped_amplitude": "-22",
+        "total_real": "-1"
+      },
+      {
+        "D": 8,
+        "cancels_to_minus_one": true,
+        "jacobian": "10",
+        "momentum_delta": "-8",
+        "n": 11,
+        "principal_mellin_real": "22",
+        "stripped_amplitude": "-25",
+        "total_real": "-1"
+      },
+      {
+        "D": 8,
+        "cancels_to_minus_one": true,
+        "jacobian": "11",
+        "momentum_delta": "-8",
+        "n": 12,
+        "principal_mellin_real": "24",
+        "stripped_amplitude": "-28",
+        "total_real": "-1"
+      },
+      {
+        "D": 9,
+        "cancels_to_minus_one": true,
+        "jacobian": "1",
+        "momentum_delta": "-9",
+        "n": 2,
+        "principal_mellin_real": "5",
+        "stripped_amplitude": "2",
+        "total_real": "-1"
+      },
+      {
+        "D": 9,
+        "cancels_to_minus_one": true,
+        "jacobian": "2",
+        "momentum_delta": "-9",
+        "n": 3,
+        "principal_mellin_real": "15/2",
+        "stripped_amplitude": "-3/2",
+        "total_real": "-1"
+      },
+      {
+        "D": 9,
+        "cancels_to_minus_one": true,
+        "jacobian": "3",
+        "momentum_delta": "-9",
+        "n": 4,
+        "principal_mellin_real": "10",
+        "stripped_amplitude": "-5",
+        "total_real": "-1"
+      },
+      {
+        "D": 9,
+        "cancels_to_minus_one": true,
+        "jacobian": "4",
+        "momentum_delta": "-9",
+        "n": 5,
+        "principal_mellin_real": "25/2",
+        "stripped_amplitude": "-17/2",
+        "total_real": "-1"
+      },
+      {
+        "D": 9,
+        "cancels_to_minus_one": true,
+        "jacobian": "5",
+        "momentum_delta": "-9",
+        "n": 6,
+        "principal_mellin_real": "15",
+        "stripped_amplitude": "-12",
+        "total_real": "-1"
+      },
+      {
+        "D": 9,
+        "cancels_to_minus_one": true,
+        "jacobian": "6",
+        "momentum_delta": "-9",
+        "n": 7,
+        "principal_mellin_real": "35/2",
+        "stripped_amplitude": "-31/2",
+        "total_real": "-1"
+      },
+      {
+        "D": 9,
+        "cancels_to_minus_one": true,
+        "jacobian": "7",
+        "momentum_delta": "-9",
+        "n": 8,
+        "principal_mellin_real": "20",
+        "stripped_amplitude": "-19",
+        "total_real": "-1"
+      },
+      {
+        "D": 9,
+        "cancels_to_minus_one": true,
+        "jacobian": "8",
+        "momentum_delta": "-9",
+        "n": 9,
+        "principal_mellin_real": "45/2",
+        "stripped_amplitude": "-45/2",
+        "total_real": "-1"
+      },
+      {
+        "D": 9,
+        "cancels_to_minus_one": true,
+        "jacobian": "9",
+        "momentum_delta": "-9",
+        "n": 10,
+        "principal_mellin_real": "25",
+        "stripped_amplitude": "-26",
+        "total_real": "-1"
+      },
+      {
+        "D": 9,
+        "cancels_to_minus_one": true,
+        "jacobian": "10",
+        "momentum_delta": "-9",
+        "n": 11,
+        "principal_mellin_real": "55/2",
+        "stripped_amplitude": "-59/2",
+        "total_real": "-1"
+      },
+      {
+        "D": 9,
+        "cancels_to_minus_one": true,
+        "jacobian": "11",
+        "momentum_delta": "-9",
+        "n": 12,
+        "principal_mellin_real": "30",
+        "stripped_amplitude": "-33",
+        "total_real": "-1"
+      },
+      {
+        "D": 10,
+        "cancels_to_minus_one": true,
+        "jacobian": "1",
+        "momentum_delta": "-10",
+        "n": 2,
+        "principal_mellin_real": "6",
+        "stripped_amplitude": "2",
+        "total_real": "-1"
+      },
+      {
+        "D": 10,
+        "cancels_to_minus_one": true,
+        "jacobian": "2",
+        "momentum_delta": "-10",
+        "n": 3,
+        "principal_mellin_real": "9",
+        "stripped_amplitude": "-2",
+        "total_real": "-1"
+      },
+      {
+        "D": 10,
+        "cancels_to_minus_one": true,
+        "jacobian": "3",
+        "momentum_delta": "-10",
+        "n": 4,
+        "principal_mellin_real": "12",
+        "stripped_amplitude": "-6",
+        "total_real": "-1"
+      },
+      {
+        "D": 10,
+        "cancels_to_minus_one": true,
+        "jacobian": "4",
+        "momentum_delta": "-10",
+        "n": 5,
+        "principal_mellin_real": "15",
+        "stripped_amplitude": "-10",
+        "total_real": "-1"
+      },
+      {
+        "D": 10,
+        "cancels_to_minus_one": true,
+        "jacobian": "5",
+        "momentum_delta": "-10",
+        "n": 6,
+        "principal_mellin_real": "18",
+        "stripped_amplitude": "-14",
+        "total_real": "-1"
+      },
+      {
+        "D": 10,
+        "cancels_to_minus_one": true,
+        "jacobian": "6",
+        "momentum_delta": "-10",
+        "n": 7,
+        "principal_mellin_real": "21",
+        "stripped_amplitude": "-18",
+        "total_real": "-1"
+      },
+      {
+        "D": 10,
+        "cancels_to_minus_one": true,
+        "jacobian": "7",
+        "momentum_delta": "-10",
+        "n": 8,
+        "principal_mellin_real": "24",
+        "stripped_amplitude": "-22",
+        "total_real": "-1"
+      },
+      {
+        "D": 10,
+        "cancels_to_minus_one": true,
+        "jacobian": "8",
+        "momentum_delta": "-10",
+        "n": 9,
+        "principal_mellin_real": "27",
+        "stripped_amplitude": "-26",
+        "total_real": "-1"
+      },
+      {
+        "D": 10,
+        "cancels_to_minus_one": true,
+        "jacobian": "9",
+        "momentum_delta": "-10",
+        "n": 10,
+        "principal_mellin_real": "30",
+        "stripped_amplitude": "-30",
+        "total_real": "-1"
+      },
+      {
+        "D": 10,
+        "cancels_to_minus_one": true,
+        "jacobian": "10",
+        "momentum_delta": "-10",
+        "n": 11,
+        "principal_mellin_real": "33",
+        "stripped_amplitude": "-34",
+        "total_real": "-1"
+      },
+      {
+        "D": 10,
+        "cancels_to_minus_one": true,
+        "jacobian": "11",
+        "momentum_delta": "-10",
+        "n": 12,
+        "principal_mellin_real": "36",
+        "stripped_amplitude": "-38",
+        "total_real": "-1"
+      },
+      {
+        "D": 11,
+        "cancels_to_minus_one": true,
+        "jacobian": "1",
+        "momentum_delta": "-11",
+        "n": 2,
+        "principal_mellin_real": "7",
+        "stripped_amplitude": "2",
+        "total_real": "-1"
+      },
+      {
+        "D": 11,
+        "cancels_to_minus_one": true,
+        "jacobian": "2",
+        "momentum_delta": "-11",
+        "n": 3,
+        "principal_mellin_real": "21/2",
+        "stripped_amplitude": "-5/2",
+        "total_real": "-1"
+      },
+      {
+        "D": 11,
+        "cancels_to_minus_one": true,
+        "jacobian": "3",
+        "momentum_delta": "-11",
+        "n": 4,
+        "principal_mellin_real": "14",
+        "stripped_amplitude": "-7",
+        "total_real": "-1"
+      },
+      {
+        "D": 11,
+        "cancels_to_minus_one": true,
+        "jacobian": "4",
+        "momentum_delta": "-11",
+        "n": 5,
+        "principal_mellin_real": "35/2",
+        "stripped_amplitude": "-23/2",
+        "total_real": "-1"
+      },
+      {
+        "D": 11,
+        "cancels_to_minus_one": true,
+        "jacobian": "5",
+        "momentum_delta": "-11",
+        "n": 6,
+        "principal_mellin_real": "21",
+        "stripped_amplitude": "-16",
+        "total_real": "-1"
+      },
+      {
+        "D": 11,
+        "cancels_to_minus_one": true,
+        "jacobian": "6",
+        "momentum_delta": "-11",
+        "n": 7,
+        "principal_mellin_real": "49/2",
+        "stripped_amplitude": "-41/2",
+        "total_real": "-1"
+      },
+      {
+        "D": 11,
+        "cancels_to_minus_one": true,
+        "jacobian": "7",
+        "momentum_delta": "-11",
+        "n": 8,
+        "principal_mellin_real": "28",
+        "stripped_amplitude": "-25",
+        "total_real": "-1"
+      },
+      {
+        "D": 11,
+        "cancels_to_minus_one": true,
+        "jacobian": "8",
+        "momentum_delta": "-11",
+        "n": 9,
+        "principal_mellin_real": "63/2",
+        "stripped_amplitude": "-59/2",
+        "total_real": "-1"
+      },
+      {
+        "D": 11,
+        "cancels_to_minus_one": true,
+        "jacobian": "9",
+        "momentum_delta": "-11",
+        "n": 10,
+        "principal_mellin_real": "35",
+        "stripped_amplitude": "-34",
+        "total_real": "-1"
+      },
+      {
+        "D": 11,
+        "cancels_to_minus_one": true,
+        "jacobian": "10",
+        "momentum_delta": "-11",
+        "n": 11,
+        "principal_mellin_real": "77/2",
+        "stripped_amplitude": "-77/2",
+        "total_real": "-1"
+      },
+      {
+        "D": 11,
+        "cancels_to_minus_one": true,
+        "jacobian": "11",
+        "momentum_delta": "-11",
+        "n": 12,
+        "principal_mellin_real": "42",
+        "stripped_amplitude": "-43",
+        "total_real": "-1"
+      },
+      {
+        "D": 12,
+        "cancels_to_minus_one": true,
+        "jacobian": "1",
+        "momentum_delta": "-12",
+        "n": 2,
+        "principal_mellin_real": "8",
+        "stripped_amplitude": "2",
+        "total_real": "-1"
+      },
+      {
+        "D": 12,
+        "cancels_to_minus_one": true,
+        "jacobian": "2",
+        "momentum_delta": "-12",
+        "n": 3,
+        "principal_mellin_real": "12",
+        "stripped_amplitude": "-3",
+        "total_real": "-1"
+      },
+      {
+        "D": 12,
+        "cancels_to_minus_one": true,
+        "jacobian": "3",
+        "momentum_delta": "-12",
+        "n": 4,
+        "principal_mellin_real": "16",
+        "stripped_amplitude": "-8",
+        "total_real": "-1"
+      },
+      {
+        "D": 12,
+        "cancels_to_minus_one": true,
+        "jacobian": "4",
+        "momentum_delta": "-12",
+        "n": 5,
+        "principal_mellin_real": "20",
+        "stripped_amplitude": "-13",
+        "total_real": "-1"
+      },
+      {
+        "D": 12,
+        "cancels_to_minus_one": true,
+        "jacobian": "5",
+        "momentum_delta": "-12",
+        "n": 6,
+        "principal_mellin_real": "24",
+        "stripped_amplitude": "-18",
+        "total_real": "-1"
+      },
+      {
+        "D": 12,
+        "cancels_to_minus_one": true,
+        "jacobian": "6",
+        "momentum_delta": "-12",
+        "n": 7,
+        "principal_mellin_real": "28",
+        "stripped_amplitude": "-23",
+        "total_real": "-1"
+      },
+      {
+        "D": 12,
+        "cancels_to_minus_one": true,
+        "jacobian": "7",
+        "momentum_delta": "-12",
+        "n": 8,
+        "principal_mellin_real": "32",
+        "stripped_amplitude": "-28",
+        "total_real": "-1"
+      },
+      {
+        "D": 12,
+        "cancels_to_minus_one": true,
+        "jacobian": "8",
+        "momentum_delta": "-12",
+        "n": 9,
+        "principal_mellin_real": "36",
+        "stripped_amplitude": "-33",
+        "total_real": "-1"
+      },
+      {
+        "D": 12,
+        "cancels_to_minus_one": true,
+        "jacobian": "9",
+        "momentum_delta": "-12",
+        "n": 10,
+        "principal_mellin_real": "40",
+        "stripped_amplitude": "-38",
+        "total_real": "-1"
+      },
+      {
+        "D": 12,
+        "cancels_to_minus_one": true,
+        "jacobian": "10",
+        "momentum_delta": "-12",
+        "n": 11,
+        "principal_mellin_real": "44",
+        "stripped_amplitude": "-43",
+        "total_real": "-1"
+      },
+      {
+        "D": 12,
+        "cancels_to_minus_one": true,
+        "jacobian": "11",
+        "momentum_delta": "-12",
+        "n": 12,
+        "principal_mellin_real": "48",
+        "stripped_amplitude": "-48",
+        "total_real": "-1"
+      }
+    ],
+    "paper": {
+      "arxiv_id": "1706.03917",
+      "title": "Gluon Amplitudes as 2d Conformal Correlators"
+    },
+    "result_version": "sabrina_projective_mellin_scale_theorem_v1",
+    "source_D4_specialization": {
+      "full_amplitude": "-n",
+      "jacobian": "n - 1",
+      "momentum_delta": "-4",
+      "principal_mellin_real": "0",
+      "stripped_amplitude": "4 - n",
+      "total_real": "-1"
+    },
+    "source_evidence": {
+      "archive_sha256": "af2756072965c969be2a74c492fe25a797fe9f85e24d61605cf088e355d06244",
+      "block_hashes": {
+        "mellin_delta": "053d6a8df0aad576174dca42758bca9a0a38eede5987db0d7b3fa11b9d374f4e",
+        "simplex_jacobian": "e26ade3af18e50461fef068c453c0895b8a3b1833f6c02b9862e6971447277d4",
+        "simplex_result": "24194f455371e8599a13a472c41489b7a6ccdbfa6911705547e0adb3ec882a9e",
+        "source_scaling": "3e7ca7bf148633f6af58ebd99e65ee9f392365e29cac93b521a91e6dc4a719e8",
+        "stripped_factorization": "66664eaf805d9eeafcf7ac1d981024c7ae07ba958e2054bee8f60a1cb79a75bb"
+      },
+      "checks": {
+        "archive_hash_matches": true,
+        "member_hash_matches": true,
+        "source_blocks_match": true,
+        "source_markers_are_unique": true,
+        "source_states_four_dimensional_delta_scaling": true,
+        "source_states_full_amplitude_degree_minus_n": true
+      },
+      "member_sha256": "88253eb755b1b2418d0ac3480c1d4b67d9bb3985f8f6f6c3b0f79c85784f4bfe"
+    },
+    "status": "complete",
+    "theorem": {
+      "canonical_stripped_amplitude_degree": "D-n(D-2)/2",
+      "mellin_real_weight_degree": "n(D-4)/2",
+      "momentum_delta_degree": "-D",
+      "principal_series_dimension": "Delta_i=(D-2)/2+i lambda_i",
+      "projective_jacobian_degree": "n-1",
+      "radial_distribution": "integral_0^infinity ds s^(-1+i Lambda)=2 pi delta(Lambda)",
+      "radial_exponent": "-1+i sum_i lambda_i",
+      "symbolic_real_residual": "-1"
+    }
+  },
+  "scientific_payload_sha256": "bb866693a5cac8a1a30c7d4d3dec8feea3e6911173eca33cae0c27c503449354"
+}
diff --git a/references/run_sabrina_projective_simplex_positivity_theorem.json b/references/run_sabrina_projective_simplex_positivity_theorem.json
new file mode 100644
index 0000000000000000000000000000000000000000..4812f7085c63323b6b48d3cc0496a8b8302a1684
--- /dev/null
+++ b/references/run_sabrina_projective_simplex_positivity_theorem.json
@@ -0,0 +1,640 @@
+{
+  "kernel": "run_sabrina_projective_simplex_positivity_theorem",
+  "role": "post-computation assertion only",
+  "schema": "ouroboros_scientific_reference_assertion_v1",
+  "scientific_payload": {
+    "claim_boundary": {
+      "capabilities_removed": [],
+      "invertibility_required": true,
+      "rank_deficient_unique_localization_claimed": false,
+      "rectangular_jacobian_claimed": false,
+      "source_error_claimed": false,
+      "square_n_equals_D_plus_1_only": true,
+      "witness_matrices_claimed_as_physical_null_momenta": false
+    },
+    "classification": "square_projective_simplex_signed_minor_support_and_jacobian_theorem_exact",
+    "exact_checks": {
+      "all_27_witnesses_classify_correctly": true,
+      "all_coordinates_have_unit_sum": true,
+      "all_cramer_coordinates_match_direct_solve": true,
+      "archive_hash_matches": true,
+      "finite_witness_grid_has_27_rows": true,
+      "member_hash_matches": true,
+      "orientation_reversal_preserves_absolute_jacobian": true,
+      "orientation_reversal_preserves_all_coordinates": true,
+      "predecessor_manifest_hash_matches": true,
+      "singular_counterexample_has_zero_determinant": true,
+      "singular_counterexample_not_uniquely_localized": true,
+      "source_blocks_match": true,
+      "source_markers_unique": true
+    },
+    "finite_exact_witnesses": [
+      {
+        "D": 2,
+        "absolute_jacobian_denominator": "3",
+        "coordinates": [
+          "1/3",
+          "1/3",
+          "1/3"
+        ],
+        "cramer_matches_direct": true,
+        "determinant": "3",
+        "expected_class": "interior",
+        "n": 3,
+        "observed_class": "interior",
+        "orientation_invariant_absolute_determinant": true,
+        "orientation_invariant_coordinates": true,
+        "unit_sum": true
+      },
+      {
+        "D": 2,
+        "absolute_jacobian_denominator": "1",
+        "coordinates": [
+          "0",
+          "0",
+          "1"
+        ],
+        "cramer_matches_direct": true,
+        "determinant": "1",
+        "expected_class": "boundary",
+        "n": 3,
+        "observed_class": "boundary",
+        "orientation_invariant_absolute_determinant": true,
+        "orientation_invariant_coordinates": true,
+        "unit_sum": true
+      },
+      {
+        "D": 2,
+        "absolute_jacobian_denominator": "1",
+        "coordinates": [
+          "1",
+          "1",
+          "-1"
+        ],
+        "cramer_matches_direct": true,
+        "determinant": "-1",
+        "expected_class": "outside",
+        "n": 3,
+        "observed_class": "outside",
+        "orientation_invariant_absolute_determinant": true,
+        "orientation_invariant_coordinates": true,
+        "unit_sum": true
+      },
+      {
+        "D": 3,
+        "absolute_jacobian_denominator": "4",
+        "coordinates": [
+          "1/4",
+          "1/4",
+          "1/4",
+          "1/4"
+        ],
+        "cramer_matches_direct": true,
+        "determinant": "4",
+        "expected_class": "interior",
+        "n": 4,
+        "observed_class": "interior",
+        "orientation_invariant_absolute_determinant": true,
+        "orientation_invariant_coordinates": true,
+        "unit_sum": true
+      },
+      {
+        "D": 3,
+        "absolute_jacobian_denominator": "1",
+        "coordinates": [
+          "0",
+          "0",
+          "0",
+          "1"
+        ],
+        "cramer_matches_direct": true,
+        "determinant": "1",
+        "expected_class": "boundary",
+        "n": 4,
+        "observed_class": "boundary",
+        "orientation_invariant_absolute_determinant": true,
+        "orientation_invariant_coordinates": true,
+        "unit_sum": true
+      },
+      {
+        "D": 3,
+        "absolute_jacobian_denominator": "2",
+        "coordinates": [
+          "1/2",
+          "1/2",
+          "1/2",
+          "-1/2"
+        ],
+        "cramer_matches_direct": true,
+        "determinant": "-2",
+        "expected_class": "outside",
+        "n": 4,
+        "observed_class": "outside",
+        "orientation_invariant_absolute_determinant": true,
+        "orientation_invariant_coordinates": true,
+        "unit_sum": true
+      },
+      {
+        "D": 4,
+        "absolute_jacobian_denominator": "5",
+        "coordinates": [
+          "1/5",
+          "1/5",
+          "1/5",
+          "1/5",
+          "1/5"
+        ],
+        "cramer_matches_direct": true,
+        "determinant": "5",
+        "expected_class": "interior",
+        "n": 5,
+        "observed_class": "interior",
+        "orientation_invariant_absolute_determinant": true,
+        "orientation_invariant_coordinates": true,
+        "unit_sum": true
+      },
+      {
+        "D": 4,
+        "absolute_jacobian_denominator": "1",
+        "coordinates": [
+          "0",
+          "0",
+          "0",
+          "0",
+          "1"
+        ],
+        "cramer_matches_direct": true,
+        "determinant": "1",
+        "expected_class": "boundary",
+        "n": 5,
+        "observed_class": "boundary",
+        "orientation_invariant_absolute_determinant": true,
+        "orientation_invariant_coordinates": true,
+        "unit_sum": true
+      },
+      {
+        "D": 4,
+        "absolute_jacobian_denominator": "3",
+        "coordinates": [
+          "1/3",
+          "1/3",
+          "1/3",
+          "1/3",
+          "-1/3"
+        ],
+        "cramer_matches_direct": true,
+        "determinant": "-3",
+        "expected_class": "outside",
+        "n": 5,
+        "observed_class": "outside",
+        "orientation_invariant_absolute_determinant": true,
+        "orientation_invariant_coordinates": true,
+        "unit_sum": true
+      },
+      {
+        "D": 5,
+        "absolute_jacobian_denominator": "6",
+        "coordinates": [
+          "1/6",
+          "1/6",
+          "1/6",
+          "1/6",
+          "1/6",
+          "1/6"
+        ],
+        "cramer_matches_direct": true,
+        "determinant": "6",
+        "expected_class": "interior",
+        "n": 6,
+        "observed_class": "interior",
+        "orientation_invariant_absolute_determinant": true,
+        "orientation_invariant_coordinates": true,
+        "unit_sum": true
+      },
+      {
+        "D": 5,
+        "absolute_jacobian_denominator": "1",
+        "coordinates": [
+          "0",
+          "0",
+          "0",
+          "0",
+          "0",
+          "1"
+        ],
+        "cramer_matches_direct": true,
+        "determinant": "1",
+        "expected_class": "boundary",
+        "n": 6,
+        "observed_class": "boundary",
+        "orientation_invariant_absolute_determinant": true,
+        "orientation_invariant_coordinates": true,
+        "unit_sum": true
+      },
+      {
+        "D": 5,
+        "absolute_jacobian_denominator": "4",
+        "coordinates": [
+          "1/4",
+          "1/4",
+          "1/4",
+          "1/4",
+          "1/4",
+          "-1/4"
+        ],
+        "cramer_matches_direct": true,
+        "determinant": "-4",
+        "expected_class": "outside",
+        "n": 6,
+        "observed_class": "outside",
+        "orientation_invariant_absolute_determinant": true,
+        "orientation_invariant_coordinates": true,
+        "unit_sum": true
+      },
+      {
+        "D": 6,
+        "absolute_jacobian_denominator": "7",
+        "coordinates": [
+          "1/7",
+          "1/7",
+          "1/7",
+          "1/7",
+          "1/7",
+          "1/7",
+          "1/7"
+        ],
+        "cramer_matches_direct": true,
+        "determinant": "7",
+        "expected_class": "interior",
+        "n": 7,
+        "observed_class": "interior",
+        "orientation_invariant_absolute_determinant": true,
+        "orientation_invariant_coordinates": true,
+        "unit_sum": true
+      },
+      {
+        "D": 6,
+        "absolute_jacobian_denominator": "1",
+        "coordinates": [
+          "0",
+          "0",
+          "0",
+          "0",
+          "0",
+          "0",
+          "1"
+        ],
+        "cramer_matches_direct": true,
+        "determinant": "1",
+        "expected_class": "boundary",
+        "n": 7,
+        "observed_class": "boundary",
+        "orientation_invariant_absolute_determinant": true,
+        "orientation_invariant_coordinates": true,
+        "unit_sum": true
+      },
+      {
+        "D": 6,
+        "absolute_jacobian_denominator": "5",
+        "coordinates": [
+          "1/5",
+          "1/5",
+          "1/5",
+          "1/5",
+          "1/5",
+          "1/5",
+          "-1/5"
+        ],
+        "cramer_matches_direct": true,
+        "determinant": "-5",
+        "expected_class": "outside",
+        "n": 7,
+        "observed_class": "outside",
+        "orientation_invariant_absolute_determinant": true,
+        "orientation_invariant_coordinates": true,
+        "unit_sum": true
+      },
+      {
+        "D": 7,
+        "absolute_jacobian_denominator": "8",
+        "coordinates": [
+          "1/8",
+          "1/8",
+          "1/8",
+          "1/8",
+          "1/8",
+          "1/8",
+          "1/8",
+          "1/8"
+        ],
+        "cramer_matches_direct": true,
+        "determinant": "8",
+        "expected_class": "interior",
+        "n": 8,
+        "observed_class": "interior",
+        "orientation_invariant_absolute_determinant": true,
+        "orientation_invariant_coordinates": true,
+        "unit_sum": true
+      },
+      {
+        "D": 7,
+        "absolute_jacobian_denominator": "1",
+        "coordinates": [
+          "0",
+          "0",
+          "0",
+          "0",
+          "0",
+          "0",
+          "0",
+          "1"
+        ],
+        "cramer_matches_direct": true,
+        "determinant": "1",
+        "expected_class": "boundary",
+        "n": 8,
+        "observed_class": "boundary",
+        "orientation_invariant_absolute_determinant": true,
+        "orientation_invariant_coordinates": true,
+        "unit_sum": true
+      },
+      {
+        "D": 7,
+        "absolute_jacobian_denominator": "6",
+        "coordinates": [
+          "1/6",
+          "1/6",
+          "1/6",
+          "1/6",
+          "1/6",
+          "1/6",
+          "1/6",
+          "-1/6"
+        ],
+        "cramer_matches_direct": true,
+        "determinant": "-6",
+        "expected_class": "outside",
+        "n": 8,
+        "observed_class": "outside",
+        "orientation_invariant_absolute_determinant": true,
+        "orientation_invariant_coordinates": true,
+        "unit_sum": true
+      },
+      {
+        "D": 8,
+        "absolute_jacobian_denominator": "9",
+        "coordinates": [
+          "1/9",
+          "1/9",
+          "1/9",
+          "1/9",
+          "1/9",
+          "1/9",
+          "1/9",
+          "1/9",
+          "1/9"
+        ],
+        "cramer_matches_direct": true,
+        "determinant": "9",
+        "expected_class": "interior",
+        "n": 9,
+        "observed_class": "interior",
+        "orientation_invariant_absolute_determinant": true,
+        "orientation_invariant_coordinates": true,
+        "unit_sum": true
+      },
+      {
+        "D": 8,
+        "absolute_jacobian_denominator": "1",
+        "coordinates": [
+          "0",
+          "0",
+          "0",
+          "0",
+          "0",
+          "0",
+          "0",
+          "0",
+          "1"
+        ],
+        "cramer_matches_direct": true,
+        "determinant": "1",
+        "expected_class": "boundary",
+        "n": 9,
+        "observed_class": "boundary",
+        "orientation_invariant_absolute_determinant": true,
+        "orientation_invariant_coordinates": true,
+        "unit_sum": true
+      },
+      {
+        "D": 8,
+        "absolute_jacobian_denominator": "7",
+        "coordinates": [
+          "1/7",
+          "1/7",
+          "1/7",
+          "1/7",
+          "1/7",
+          "1/7",
+          "1/7",
+          "1/7",
+          "-1/7"
+        ],
+        "cramer_matches_direct": true,
+        "determinant": "-7",
+        "expected_class": "outside",
+        "n": 9,
+        "observed_class": "outside",
+        "orientation_invariant_absolute_determinant": true,
+        "orientation_invariant_coordinates": true,
+        "unit_sum": true
+      },
+      {
+        "D": 9,
+        "absolute_jacobian_denominator": "10",
+        "coordinates": [
+          "1/10",
+          "1/10",
+          "1/10",
+          "1/10",
+          "1/10",
+          "1/10",
+          "1/10",
+          "1/10",
+          "1/10",
+          "1/10"
+        ],
+        "cramer_matches_direct": true,
+        "determinant": "10",
+        "expected_class": "interior",
+        "n": 10,
+        "observed_class": "interior",
+        "orientation_invariant_absolute_determinant": true,
+        "orientation_invariant_coordinates": true,
+        "unit_sum": true
+      },
+      {
+        "D": 9,
+        "absolute_jacobian_denominator": "1",
+        "coordinates": [
+          "0",
+          "0",
+          "0",
+          "0",
+          "0",
+          "0",
+          "0",
+          "0",
+          "0",
+          "1"
+        ],
+        "cramer_matches_direct": true,
+        "determinant": "1",
+        "expected_class": "boundary",
+        "n": 10,
+        "observed_class": "boundary",
+        "orientation_invariant_absolute_determinant": true,
+        "orientation_invariant_coordinates": true,
+        "unit_sum": true
+      },
+      {
+        "D": 9,
+        "absolute_jacobian_denominator": "8",
+        "coordinates": [
+          "1/8",
+          "1/8",
+          "1/8",
+          "1/8",
+          "1/8",
+          "1/8",
+          "1/8",
+          "1/8",
+          "1/8",
+          "-1/8"
+        ],
+        "cramer_matches_direct": true,
+        "determinant": "-8",
+        "expected_class": "outside",
+        "n": 10,
+        "observed_class": "outside",
+        "orientation_invariant_absolute_determinant": true,
+        "orientation_invariant_coordinates": true,
+        "unit_sum": true
+      },
+      {
+        "D": 10,
+        "absolute_jacobian_denominator": "11",
+        "coordinates": [
+          "1/11",
+          "1/11",
+          "1/11",
+          "1/11",
+          "1/11",
+          "1/11",
+          "1/11",
+          "1/11",
+          "1/11",
+          "1/11",
+          "1/11"
+        ],
+        "cramer_matches_direct": true,
+        "determinant": "11",
+        "expected_class": "interior",
+        "n": 11,
+        "observed_class": "interior",
+        "orientation_invariant_absolute_determinant": true,
+        "orientation_invariant_coordinates": true,
+        "unit_sum": true
+      },
+      {
+        "D": 10,
+        "absolute_jacobian_denominator": "1",
+        "coordinates": [
+          "0",
+          "0",
+          "0",
+          "0",
+          "0",
+          "0",
+          "0",
+          "0",
+          "0",
+          "0",
+          "1"
+        ],
+        "cramer_matches_direct": true,
+        "determinant": "1",
+        "expected_class": "boundary",
+        "n": 11,
+        "observed_class": "boundary",
+        "orientation_invariant_absolute_determinant": true,
+        "orientation_invariant_coordinates": true,
+        "unit_sum": true
+      },
+      {
+        "D": 10,
+        "absolute_jacobian_denominator": "9",
+        "coordinates": [
+          "1/9",
+          "1/9",
+          "1/9",
+          "1/9",
+          "1/9",
+          "1/9",
+          "1/9",
+          "1/9",
+          "1/9",
+          "1/9",
+          "-1/9"
+        ],
+        "cramer_matches_direct": true,
+        "determinant": "-9",
+        "expected_class": "outside",
+        "n": 11,
+        "observed_class": "outside",
+        "orientation_invariant_absolute_determinant": true,
+        "orientation_invariant_coordinates": true,
+        "unit_sum": true
+      }
+    ],
+    "paper": {
+      "arxiv_id": "1706.03917",
+      "title": "Gluon Amplitudes as 2d Conformal Correlators"
+    },
+    "result_version": "sabrina_projective_simplex_positivity_theorem_v1",
+    "singular_counterexample": {
+      "D": 4,
+      "determinant": "0",
+      "n": 5,
+      "rank": 4
+    },
+    "source_evidence": {
+      "archive_sha256": "af2756072965c969be2a74c492fe25a797fe9f85e24d61605cf088e355d06244",
+      "block_hashes": {
+        "delta_product_rewrite": "8a2029c1a1fe7989bbb77b99449ca37fd43965e0b9169abe60c01d969c5f6f20",
+        "indicator": "d7e7be03a59b4e0c7702a241e5024b8fc57226ce0ac48928c307baa567ce18a0",
+        "simplex_result": "24194f455371e8599a13a472c41489b7a6ccdbfa6911705547e0adb3ec882a9e"
+      },
+      "checks": {
+        "archive_hash_matches": true,
+        "member_hash_matches": true,
+        "predecessor_manifest_hash_matches": true,
+        "source_blocks_match": true,
+        "source_markers_unique": true
+      },
+      "member_sha256": "88253eb755b1b2418d0ac3480c1d4b67d9bb3985f8f6f6c3b0f79c85784f4bfe"
+    },
+    "status": "complete",
+    "theorem": {
+      "boundary": "all ratios are nonnegative and at least one is zero",
+      "coordinates": "sigma_i=det(M_i)/det(M), where M_i replaces column i by b=(0,...,0,1)",
+      "distributional_jacobian": "delta(M sigma-b)=delta(sigma-sigma*)/abs(det M)",
+      "interior": "all signed determinant ratios are strictly positive",
+      "orientation_invariance": "common sign reversal of det(M) and det(M_i) leaves ratios and abs(det M) unchanged",
+      "outside": "at least one ratio is negative",
+      "scope": "square invertible augmented matrix M with n=D+1",
+      "unit_sum": "the final all-ones row enforces sum_i sigma_i=1"
+    }
+  },
+  "scientific_payload_sha256": "04b196f77ef38f277dfbb7ebeccf2b1964f90157335f9a1dc268c6654d548af4"
+}
diff --git a/references/run_sabrina_projective_simplex_rank_theorem.json b/references/run_sabrina_projective_simplex_rank_theorem.json
new file mode 100644
index 0000000000000000000000000000000000000000..664f5831004f2dd3eafd903d2b141bde1e572f3a
--- /dev/null
+++ b/references/run_sabrina_projective_simplex_rank_theorem.json
@@ -0,0 +1,981 @@
+{
+  "kernel": "run_sabrina_projective_simplex_rank_theorem",
+  "role": "post-computation assertion only",
+  "schema": "ouroboros_scientific_reference_assertion_v1",
+  "scientific_payload": {
+    "claim_boundary": {
+      "capabilities_removed": [],
+      "compatibility_required": true,
+      "integer_witness_matrices_claimed_as_physical_null_momenta": false,
+      "non_square_distributional_jacobian_derived": false,
+      "rank_deficiency_allowed_but_not_unique": true,
+      "simplex_positivity_required": true,
+      "source_error_claimed": false
+    },
+    "classification": "all_D_projective_simplex_localization_rank_theorem_exact_with_support_and_positivity_boundaries",
+    "counterexamples": {
+      "incompatible": {
+        "augmented_rank": 2,
+        "matrix_rank": 1
+      },
+      "rank_deficient_compatible": {
+        "nullity": 1,
+        "rank": 2
+      },
+      "unique_but_not_simplex_positive": {
+        "solution": [
+          "1",
+          "1",
+          "-1"
+        ]
+      }
+    },
+    "exact_checks": {
+      "D4_n2_through_n5_have_zero_affine_moduli": true,
+      "D4_n3_has_two_external_compatibility_constraints": true,
+      "D4_n4_has_one_external_compatibility_constraint": true,
+      "D4_n5_is_square_unique_on_support": true,
+      "D4_n6_has_one_affine_modulus": true,
+      "all_99_integer_witnesses_have_expected_rank": true,
+      "archive_hash_matches": true,
+      "finite_grid_has_99_points": true,
+      "incompatible_example_fails_rank_test": true,
+      "localization_statement_hash_matches": true,
+      "localization_statement_unique": true,
+      "member_hash_matches": true,
+      "predecessor_manifest_hash_matches": true,
+      "rank_deficient_example_has_one_modulus": true,
+      "rank_deficient_example_is_compatible": true,
+      "source_equation_blocks_match": true,
+      "source_equation_markers_unique": true,
+      "unique_solution_can_fail_simplex_positivity": true
+    },
+    "finite_exact_grid": [
+      {
+        "D": 2,
+        "affine_solution_dimension_on_support": 0,
+        "expected_rank": 2,
+        "external_compatibility_codimension": 1,
+        "full_rank": true,
+        "n": 2,
+        "rank": 2
+      },
+      {
+        "D": 2,
+        "affine_solution_dimension_on_support": 0,
+        "expected_rank": 3,
+        "external_compatibility_codimension": 0,
+        "full_rank": true,
+        "n": 3,
+        "rank": 3
+      },
+      {
+        "D": 2,
+        "affine_solution_dimension_on_support": 1,
+        "expected_rank": 3,
+        "external_compatibility_codimension": 0,
+        "full_rank": true,
+        "n": 4,
+        "rank": 3
+      },
+      {
+        "D": 2,
+        "affine_solution_dimension_on_support": 2,
+        "expected_rank": 3,
+        "external_compatibility_codimension": 0,
+        "full_rank": true,
+        "n": 5,
+        "rank": 3
+      },
+      {
+        "D": 2,
+        "affine_solution_dimension_on_support": 3,
+        "expected_rank": 3,
+        "external_compatibility_codimension": 0,
+        "full_rank": true,
+        "n": 6,
+        "rank": 3
+      },
+      {
+        "D": 2,
+        "affine_solution_dimension_on_support": 4,
+        "expected_rank": 3,
+        "external_compatibility_codimension": 0,
+        "full_rank": true,
+        "n": 7,
+        "rank": 3
+      },
+      {
+        "D": 2,
+        "affine_solution_dimension_on_support": 5,
+        "expected_rank": 3,
+        "external_compatibility_codimension": 0,
+        "full_rank": true,
+        "n": 8,
+        "rank": 3
+      },
+      {
+        "D": 2,
+        "affine_solution_dimension_on_support": 6,
+        "expected_rank": 3,
+        "external_compatibility_codimension": 0,
+        "full_rank": true,
+        "n": 9,
+        "rank": 3
+      },
+      {
+        "D": 2,
+        "affine_solution_dimension_on_support": 7,
+        "expected_rank": 3,
+        "external_compatibility_codimension": 0,
+        "full_rank": true,
+        "n": 10,
+        "rank": 3
+      },
+      {
+        "D": 2,
+        "affine_solution_dimension_on_support": 8,
+        "expected_rank": 3,
+        "external_compatibility_codimension": 0,
+        "full_rank": true,
+        "n": 11,
+        "rank": 3
+      },
+      {
+        "D": 2,
+        "affine_solution_dimension_on_support": 9,
+        "expected_rank": 3,
+        "external_compatibility_codimension": 0,
+        "full_rank": true,
+        "n": 12,
+        "rank": 3
+      },
+      {
+        "D": 3,
+        "affine_solution_dimension_on_support": 0,
+        "expected_rank": 2,
+        "external_compatibility_codimension": 2,
+        "full_rank": true,
+        "n": 2,
+        "rank": 2
+      },
+      {
+        "D": 3,
+        "affine_solution_dimension_on_support": 0,
+        "expected_rank": 3,
+        "external_compatibility_codimension": 1,
+        "full_rank": true,
+        "n": 3,
+        "rank": 3
+      },
+      {
+        "D": 3,
+        "affine_solution_dimension_on_support": 0,
+        "expected_rank": 4,
+        "external_compatibility_codimension": 0,
+        "full_rank": true,
+        "n": 4,
+        "rank": 4
+      },
+      {
+        "D": 3,
+        "affine_solution_dimension_on_support": 1,
+        "expected_rank": 4,
+        "external_compatibility_codimension": 0,
+        "full_rank": true,
+        "n": 5,
+        "rank": 4
+      },
+      {
+        "D": 3,
+        "affine_solution_dimension_on_support": 2,
+        "expected_rank": 4,
+        "external_compatibility_codimension": 0,
+        "full_rank": true,
+        "n": 6,
+        "rank": 4
+      },
+      {
+        "D": 3,
+        "affine_solution_dimension_on_support": 3,
+        "expected_rank": 4,
+        "external_compatibility_codimension": 0,
+        "full_rank": true,
+        "n": 7,
+        "rank": 4
+      },
+      {
+        "D": 3,
+        "affine_solution_dimension_on_support": 4,
+        "expected_rank": 4,
+        "external_compatibility_codimension": 0,
+        "full_rank": true,
+        "n": 8,
+        "rank": 4
+      },
+      {
+        "D": 3,
+        "affine_solution_dimension_on_support": 5,
+        "expected_rank": 4,
+        "external_compatibility_codimension": 0,
+        "full_rank": true,
+        "n": 9,
+        "rank": 4
+      },
+      {
+        "D": 3,
+        "affine_solution_dimension_on_support": 6,
+        "expected_rank": 4,
+        "external_compatibility_codimension": 0,
+        "full_rank": true,
+        "n": 10,
+        "rank": 4
+      },
+      {
+        "D": 3,
+        "affine_solution_dimension_on_support": 7,
+        "expected_rank": 4,
+        "external_compatibility_codimension": 0,
+        "full_rank": true,
+        "n": 11,
+        "rank": 4
+      },
+      {
+        "D": 3,
+        "affine_solution_dimension_on_support": 8,
+        "expected_rank": 4,
+        "external_compatibility_codimension": 0,
+        "full_rank": true,
+        "n": 12,
+        "rank": 4
+      },
+      {
+        "D": 4,
+        "affine_solution_dimension_on_support": 0,
+        "expected_rank": 2,
+        "external_compatibility_codimension": 3,
+        "full_rank": true,
+        "n": 2,
+        "rank": 2
+      },
+      {
+        "D": 4,
+        "affine_solution_dimension_on_support": 0,
+        "expected_rank": 3,
+        "external_compatibility_codimension": 2,
+        "full_rank": true,
+        "n": 3,
+        "rank": 3
+      },
+      {
+        "D": 4,
+        "affine_solution_dimension_on_support": 0,
+        "expected_rank": 4,
+        "external_compatibility_codimension": 1,
+        "full_rank": true,
+        "n": 4,
+        "rank": 4
+      },
+      {
+        "D": 4,
+        "affine_solution_dimension_on_support": 0,
+        "expected_rank": 5,
+        "external_compatibility_codimension": 0,
+        "full_rank": true,
+        "n": 5,
+        "rank": 5
+      },
+      {
+        "D": 4,
+        "affine_solution_dimension_on_support": 1,
+        "expected_rank": 5,
+        "external_compatibility_codimension": 0,
+        "full_rank": true,
+        "n": 6,
+        "rank": 5
+      },
+      {
+        "D": 4,
+        "affine_solution_dimension_on_support": 2,
+        "expected_rank": 5,
+        "external_compatibility_codimension": 0,
+        "full_rank": true,
+        "n": 7,
+        "rank": 5
+      },
+      {
+        "D": 4,
+        "affine_solution_dimension_on_support": 3,
+        "expected_rank": 5,
+        "external_compatibility_codimension": 0,
+        "full_rank": true,
+        "n": 8,
+        "rank": 5
+      },
+      {
+        "D": 4,
+        "affine_solution_dimension_on_support": 4,
+        "expected_rank": 5,
+        "external_compatibility_codimension": 0,
+        "full_rank": true,
+        "n": 9,
+        "rank": 5
+      },
+      {
+        "D": 4,
+        "affine_solution_dimension_on_support": 5,
+        "expected_rank": 5,
+        "external_compatibility_codimension": 0,
+        "full_rank": true,
+        "n": 10,
+        "rank": 5
+      },
+      {
+        "D": 4,
+        "affine_solution_dimension_on_support": 6,
+        "expected_rank": 5,
+        "external_compatibility_codimension": 0,
+        "full_rank": true,
+        "n": 11,
+        "rank": 5
+      },
+      {
+        "D": 4,
+        "affine_solution_dimension_on_support": 7,
+        "expected_rank": 5,
+        "external_compatibility_codimension": 0,
+        "full_rank": true,
+        "n": 12,
+        "rank": 5
+      },
+      {
+        "D": 5,
+        "affine_solution_dimension_on_support": 0,
+        "expected_rank": 2,
+        "external_compatibility_codimension": 4,
+        "full_rank": true,
+        "n": 2,
+        "rank": 2
+      },
+      {
+        "D": 5,
+        "affine_solution_dimension_on_support": 0,
+        "expected_rank": 3,
+        "external_compatibility_codimension": 3,
+        "full_rank": true,
+        "n": 3,
+        "rank": 3
+      },
+      {
+        "D": 5,
+        "affine_solution_dimension_on_support": 0,
+        "expected_rank": 4,
+        "external_compatibility_codimension": 2,
+        "full_rank": true,
+        "n": 4,
+        "rank": 4
+      },
+      {
+        "D": 5,
+        "affine_solution_dimension_on_support": 0,
+        "expected_rank": 5,
+        "external_compatibility_codimension": 1,
+        "full_rank": true,
+        "n": 5,
+        "rank": 5
+      },
+      {
+        "D": 5,
+        "affine_solution_dimension_on_support": 0,
+        "expected_rank": 6,
+        "external_compatibility_codimension": 0,
+        "full_rank": true,
+        "n": 6,
+        "rank": 6
+      },
+      {
+        "D": 5,
+        "affine_solution_dimension_on_support": 1,
+        "expected_rank": 6,
+        "external_compatibility_codimension": 0,
+        "full_rank": true,
+        "n": 7,
+        "rank": 6
+      },
+      {
+        "D": 5,
+        "affine_solution_dimension_on_support": 2,
+        "expected_rank": 6,
+        "external_compatibility_codimension": 0,
+        "full_rank": true,
+        "n": 8,
+        "rank": 6
+      },
+      {
+        "D": 5,
+        "affine_solution_dimension_on_support": 3,
+        "expected_rank": 6,
+        "external_compatibility_codimension": 0,
+        "full_rank": true,
+        "n": 9,
+        "rank": 6
+      },
+      {
+        "D": 5,
+        "affine_solution_dimension_on_support": 4,
+        "expected_rank": 6,
+        "external_compatibility_codimension": 0,
+        "full_rank": true,
+        "n": 10,
+        "rank": 6
+      },
+      {
+        "D": 5,
+        "affine_solution_dimension_on_support": 5,
+        "expected_rank": 6,
+        "external_compatibility_codimension": 0,
+        "full_rank": true,
+        "n": 11,
+        "rank": 6
+      },
+      {
+        "D": 5,
+        "affine_solution_dimension_on_support": 6,
+        "expected_rank": 6,
+        "external_compatibility_codimension": 0,
+        "full_rank": true,
+        "n": 12,
+        "rank": 6
+      },
+      {
+        "D": 6,
+        "affine_solution_dimension_on_support": 0,
+        "expected_rank": 2,
+        "external_compatibility_codimension": 5,
+        "full_rank": true,
+        "n": 2,
+        "rank": 2
+      },
+      {
+        "D": 6,
+        "affine_solution_dimension_on_support": 0,
+        "expected_rank": 3,
+        "external_compatibility_codimension": 4,
+        "full_rank": true,
+        "n": 3,
+        "rank": 3
+      },
+      {
+        "D": 6,
+        "affine_solution_dimension_on_support": 0,
+        "expected_rank": 4,
+        "external_compatibility_codimension": 3,
+        "full_rank": true,
+        "n": 4,
+        "rank": 4
+      },
+      {
+        "D": 6,
+        "affine_solution_dimension_on_support": 0,
+        "expected_rank": 5,
+        "external_compatibility_codimension": 2,
+        "full_rank": true,
+        "n": 5,
+        "rank": 5
+      },
+      {
+        "D": 6,
+        "affine_solution_dimension_on_support": 0,
+        "expected_rank": 6,
+        "external_compatibility_codimension": 1,
+        "full_rank": true,
+        "n": 6,
+        "rank": 6
+      },
+      {
+        "D": 6,
+        "affine_solution_dimension_on_support": 0,
+        "expected_rank": 7,
+        "external_compatibility_codimension": 0,
+        "full_rank": true,
+        "n": 7,
+        "rank": 7
+      },
+      {
+        "D": 6,
+        "affine_solution_dimension_on_support": 1,
+        "expected_rank": 7,
+        "external_compatibility_codimension": 0,
+        "full_rank": true,
+        "n": 8,
+        "rank": 7
+      },
+      {
+        "D": 6,
+        "affine_solution_dimension_on_support": 2,
+        "expected_rank": 7,
+        "external_compatibility_codimension": 0,
+        "full_rank": true,
+        "n": 9,
+        "rank": 7
+      },
+      {
+        "D": 6,
+        "affine_solution_dimension_on_support": 3,
+        "expected_rank": 7,
+        "external_compatibility_codimension": 0,
+        "full_rank": true,
+        "n": 10,
+        "rank": 7
+      },
+      {
+        "D": 6,
+        "affine_solution_dimension_on_support": 4,
+        "expected_rank": 7,
+        "external_compatibility_codimension": 0,
+        "full_rank": true,
+        "n": 11,
+        "rank": 7
+      },
+      {
+        "D": 6,
+        "affine_solution_dimension_on_support": 5,
+        "expected_rank": 7,
+        "external_compatibility_codimension": 0,
+        "full_rank": true,
+        "n": 12,
+        "rank": 7
+      },
+      {
+        "D": 7,
+        "affine_solution_dimension_on_support": 0,
+        "expected_rank": 2,
+        "external_compatibility_codimension": 6,
+        "full_rank": true,
+        "n": 2,
+        "rank": 2
+      },
+      {
+        "D": 7,
+        "affine_solution_dimension_on_support": 0,
+        "expected_rank": 3,
+        "external_compatibility_codimension": 5,
+        "full_rank": true,
+        "n": 3,
+        "rank": 3
+      },
+      {
+        "D": 7,
+        "affine_solution_dimension_on_support": 0,
+        "expected_rank": 4,
+        "external_compatibility_codimension": 4,
+        "full_rank": true,
+        "n": 4,
+        "rank": 4
+      },
+      {
+        "D": 7,
+        "affine_solution_dimension_on_support": 0,
+        "expected_rank": 5,
+        "external_compatibility_codimension": 3,
+        "full_rank": true,
+        "n": 5,
+        "rank": 5
+      },
+      {
+        "D": 7,
+        "affine_solution_dimension_on_support": 0,
+        "expected_rank": 6,
+        "external_compatibility_codimension": 2,
+        "full_rank": true,
+        "n": 6,
+        "rank": 6
+      },
+      {
+        "D": 7,
+        "affine_solution_dimension_on_support": 0,
+        "expected_rank": 7,
+        "external_compatibility_codimension": 1,
+        "full_rank": true,
+        "n": 7,
+        "rank": 7
+      },
+      {
+        "D": 7,
+        "affine_solution_dimension_on_support": 0,
+        "expected_rank": 8,
+        "external_compatibility_codimension": 0,
+        "full_rank": true,
+        "n": 8,
+        "rank": 8
+      },
+      {
+        "D": 7,
+        "affine_solution_dimension_on_support": 1,
+        "expected_rank": 8,
+        "external_compatibility_codimension": 0,
+        "full_rank": true,
+        "n": 9,
+        "rank": 8
+      },
+      {
+        "D": 7,
+        "affine_solution_dimension_on_support": 2,
+        "expected_rank": 8,
+        "external_compatibility_codimension": 0,
+        "full_rank": true,
+        "n": 10,
+        "rank": 8
+      },
+      {
+        "D": 7,
+        "affine_solution_dimension_on_support": 3,
+        "expected_rank": 8,
+        "external_compatibility_codimension": 0,
+        "full_rank": true,
+        "n": 11,
+        "rank": 8
+      },
+      {
+        "D": 7,
+        "affine_solution_dimension_on_support": 4,
+        "expected_rank": 8,
+        "external_compatibility_codimension": 0,
+        "full_rank": true,
+        "n": 12,
+        "rank": 8
+      },
+      {
+        "D": 8,
+        "affine_solution_dimension_on_support": 0,
+        "expected_rank": 2,
+        "external_compatibility_codimension": 7,
+        "full_rank": true,
+        "n": 2,
+        "rank": 2
+      },
+      {
+        "D": 8,
+        "affine_solution_dimension_on_support": 0,
+        "expected_rank": 3,
+        "external_compatibility_codimension": 6,
+        "full_rank": true,
+        "n": 3,
+        "rank": 3
+      },
+      {
+        "D": 8,
+        "affine_solution_dimension_on_support": 0,
+        "expected_rank": 4,
+        "external_compatibility_codimension": 5,
+        "full_rank": true,
+        "n": 4,
+        "rank": 4
+      },
+      {
+        "D": 8,
+        "affine_solution_dimension_on_support": 0,
+        "expected_rank": 5,
+        "external_compatibility_codimension": 4,
+        "full_rank": true,
+        "n": 5,
+        "rank": 5
+      },
+      {
+        "D": 8,
+        "affine_solution_dimension_on_support": 0,
+        "expected_rank": 6,
+        "external_compatibility_codimension": 3,
+        "full_rank": true,
+        "n": 6,
+        "rank": 6
+      },
+      {
+        "D": 8,
+        "affine_solution_dimension_on_support": 0,
+        "expected_rank": 7,
+        "external_compatibility_codimension": 2,
+        "full_rank": true,
+        "n": 7,
+        "rank": 7
+      },
+      {
+        "D": 8,
+        "affine_solution_dimension_on_support": 0,
+        "expected_rank": 8,
+        "external_compatibility_codimension": 1,
+        "full_rank": true,
+        "n": 8,
+        "rank": 8
+      },
+      {
+        "D": 8,
+        "affine_solution_dimension_on_support": 0,
+        "expected_rank": 9,
+        "external_compatibility_codimension": 0,
+        "full_rank": true,
+        "n": 9,
+        "rank": 9
+      },
+      {
+        "D": 8,
+        "affine_solution_dimension_on_support": 1,
+        "expected_rank": 9,
+        "external_compatibility_codimension": 0,
+        "full_rank": true,
+        "n": 10,
+        "rank": 9
+      },
+      {
+        "D": 8,
+        "affine_solution_dimension_on_support": 2,
+        "expected_rank": 9,
+        "external_compatibility_codimension": 0,
+        "full_rank": true,
+        "n": 11,
+        "rank": 9
+      },
+      {
+        "D": 8,
+        "affine_solution_dimension_on_support": 3,
+        "expected_rank": 9,
+        "external_compatibility_codimension": 0,
+        "full_rank": true,
+        "n": 12,
+        "rank": 9
+      },
+      {
+        "D": 9,
+        "affine_solution_dimension_on_support": 0,
+        "expected_rank": 2,
+        "external_compatibility_codimension": 8,
+        "full_rank": true,
+        "n": 2,
+        "rank": 2
+      },
+      {
+        "D": 9,
+        "affine_solution_dimension_on_support": 0,
+        "expected_rank": 3,
+        "external_compatibility_codimension": 7,
+        "full_rank": true,
+        "n": 3,
+        "rank": 3
+      },
+      {
+        "D": 9,
+        "affine_solution_dimension_on_support": 0,
+        "expected_rank": 4,
+        "external_compatibility_codimension": 6,
+        "full_rank": true,
+        "n": 4,
+        "rank": 4
+      },
+      {
+        "D": 9,
+        "affine_solution_dimension_on_support": 0,
+        "expected_rank": 5,
+        "external_compatibility_codimension": 5,
+        "full_rank": true,
+        "n": 5,
+        "rank": 5
+      },
+      {
+        "D": 9,
+        "affine_solution_dimension_on_support": 0,
+        "expected_rank": 6,
+        "external_compatibility_codimension": 4,
+        "full_rank": true,
+        "n": 6,
+        "rank": 6
+      },
+      {
+        "D": 9,
+        "affine_solution_dimension_on_support": 0,
+        "expected_rank": 7,
+        "external_compatibility_codimension": 3,
+        "full_rank": true,
+        "n": 7,
+        "rank": 7
+      },
+      {
+        "D": 9,
+        "affine_solution_dimension_on_support": 0,
+        "expected_rank": 8,
+        "external_compatibility_codimension": 2,
+        "full_rank": true,
+        "n": 8,
+        "rank": 8
+      },
+      {
+        "D": 9,
+        "affine_solution_dimension_on_support": 0,
+        "expected_rank": 9,
+        "external_compatibility_codimension": 1,
+        "full_rank": true,
+        "n": 9,
+        "rank": 9
+      },
+      {
+        "D": 9,
+        "affine_solution_dimension_on_support": 0,
+        "expected_rank": 10,
+        "external_compatibility_codimension": 0,
+        "full_rank": true,
+        "n": 10,
+        "rank": 10
+      },
+      {
+        "D": 9,
+        "affine_solution_dimension_on_support": 1,
+        "expected_rank": 10,
+        "external_compatibility_codimension": 0,
+        "full_rank": true,
+        "n": 11,
+        "rank": 10
+      },
+      {
+        "D": 9,
+        "affine_solution_dimension_on_support": 2,
+        "expected_rank": 10,
+        "external_compatibility_codimension": 0,
+        "full_rank": true,
+        "n": 12,
+        "rank": 10
+      },
+      {
+        "D": 10,
+        "affine_solution_dimension_on_support": 0,
+        "expected_rank": 2,
+        "external_compatibility_codimension": 9,
+        "full_rank": true,
+        "n": 2,
+        "rank": 2
+      },
+      {
+        "D": 10,
+        "affine_solution_dimension_on_support": 0,
+        "expected_rank": 3,
+        "external_compatibility_codimension": 8,
+        "full_rank": true,
+        "n": 3,
+        "rank": 3
+      },
+      {
+        "D": 10,
+        "affine_solution_dimension_on_support": 0,
+        "expected_rank": 4,
+        "external_compatibility_codimension": 7,
+        "full_rank": true,
+        "n": 4,
+        "rank": 4
+      },
+      {
+        "D": 10,
+        "affine_solution_dimension_on_support": 0,
+        "expected_rank": 5,
+        "external_compatibility_codimension": 6,
+        "full_rank": true,
+        "n": 5,
+        "rank": 5
+      },
+      {
+        "D": 10,
+        "affine_solution_dimension_on_support": 0,
+        "expected_rank": 6,
+        "external_compatibility_codimension": 5,
+        "full_rank": true,
+        "n": 6,
+        "rank": 6
+      },
+      {
+        "D": 10,
+        "affine_solution_dimension_on_support": 0,
+        "expected_rank": 7,
+        "external_compatibility_codimension": 4,
+        "full_rank": true,
+        "n": 7,
+        "rank": 7
+      },
+      {
+        "D": 10,
+        "affine_solution_dimension_on_support": 0,
+        "expected_rank": 8,
+        "external_compatibility_codimension": 3,
+        "full_rank": true,
+        "n": 8,
+        "rank": 8
+      },
+      {
+        "D": 10,
+        "affine_solution_dimension_on_support": 0,
+        "expected_rank": 9,
+        "external_compatibility_codimension": 2,
+        "full_rank": true,
+        "n": 9,
+        "rank": 9
+      },
+      {
+        "D": 10,
+        "affine_solution_dimension_on_support": 0,
+        "expected_rank": 10,
+        "external_compatibility_codimension": 1,
+        "full_rank": true,
+        "n": 10,
+        "rank": 10
+      },
+      {
+        "D": 10,
+        "affine_solution_dimension_on_support": 0,
+        "expected_rank": 11,
+        "external_compatibility_codimension": 0,
+        "full_rank": true,
+        "n": 11,
+        "rank": 11
+      },
+      {
+        "D": 10,
+        "affine_solution_dimension_on_support": 1,
+        "expected_rank": 11,
+        "external_compatibility_codimension": 0,
+        "full_rank": true,
+        "n": 12,
+        "rank": 11
+      }
+    ],
+    "paper": {
+      "arxiv_id": "1706.03917",
+      "title": "Gluon Amplitudes as 2d Conformal Correlators"
+    },
+    "result_version": "sabrina_projective_simplex_rank_theorem_v1",
+    "source_evidence": {
+      "archive_sha256": "af2756072965c969be2a74c492fe25a797fe9f85e24d61605cf088e355d06244",
+      "block_hashes": {
+        "delta_product_rewrite": "8a2029c1a1fe7989bbb77b99449ca37fd43965e0b9169abe60c01d969c5f6f20",
+        "simplex_result": "24194f455371e8599a13a472c41489b7a6ccdbfa6911705547e0adb3ec882a9e"
+      },
+      "checks": {
+        "archive_hash_matches": true,
+        "localization_statement_hash_matches": true,
+        "localization_statement_unique": true,
+        "member_hash_matches": true,
+        "predecessor_manifest_hash_matches": true,
+        "source_equation_blocks_match": true,
+        "source_equation_markers_unique": true
+      },
+      "localization_line_sha256": "56cabb68b24099425e4158af718ec6b892423facfa4910a1878990f84cc769e6",
+      "member_sha256": "88253eb755b1b2418d0ac3480c1d4b67d9bb3985f8f6f6c3b0f79c85784f4bfe"
+    },
+    "status": "complete",
+    "theorem": {
+      "constraint_matrix_shape": "(D+1) by n",
+      "external_compatibility_codimension": "D+1-r",
+      "generic_n_above_D_plus_1": "n-D-1 unfixed simplex moduli",
+      "generic_n_at_most_D_plus_1": "unique sigma on compatible support; D+1-n residual external constraints",
+      "generic_rank": "r=min(D+1,n)",
+      "on_support_affine_solution_dimension": "n-r",
+      "square_distributional_jacobian": "for n=D+1 and det(M)!=0 only: delta(M sigma-b)=delta(sigma-sigma*)/abs(det(M))"
+    }
+  },
+  "scientific_payload_sha256": "a4be65bfe6724693b679405e1985b33302d94ec8113edf75512620fcc58045f7"
+}
diff --git a/references/run_sabrina_quadrupole_spin_memory_cap_duality.json b/references/run_sabrina_quadrupole_spin_memory_cap_duality.json
new file mode 100644
index 0000000000000000000000000000000000000000..a6f6267b42b05dc266b0df2a1157582316384800
--- /dev/null
+++ b/references/run_sabrina_quadrupole_spin_memory_cap_duality.json
@@ -0,0 +1,95 @@
+{
+  "kernel": "run_sabrina_quadrupole_spin_memory_cap_duality",
+  "role": "post-computation assertion only",
+  "schema": "ouroboros_scientific_reference_assertion_v1",
+  "scientific_payload": {
+    "cap_integral_certificate": {
+      "area_fraction": "x=R^2/(1+R^2)",
+      "cap_integral": "2*pi*x*(x - 1)*(2*x - 1)*(3*x**2 - 3*x - 1)/15",
+      "checks": {
+        "cap_integral_exact": true,
+        "sphere_measure_is_four_pi": true,
+        "stereographic_substitution_exact": true,
+        "time_delay_prefactor_exact": true
+      },
+      "normalized_time_delay": "2*x*(x - 1)*(2*x - 1)*(3*x**2 - 3*x - 1)/5",
+      "reduced_density": "t**4 - 2*t**3 + t**2 - 1/30",
+      "response_polynomial": "x**5/5 - x**4/2 + x**3/3 - x/30"
+    },
+    "claim_boundary": {
+      "arbitrary_contours_claimed": false,
+      "arbitrary_waveforms_claimed": false,
+      "capabilities_removed": [],
+      "centered_stereographic_caps_only": true,
+      "nonlinear_or_quantum_extension_claimed": false,
+      "paper_quadrupole_example_only": true
+    },
+    "duality_certificate": {
+      "checks": {
+        "complement_antisymmetry_exact": true,
+        "factorization_exact": true,
+        "hemisphere_response_zero": true,
+        "physical_zero_set_complete": true,
+        "remaining_roots_outside_cap_domain": true
+      },
+      "complement_sum": "0",
+      "factorization": "x*(x - 1)*(2*x - 1)*(3*x**2 - 3*x - 1)",
+      "outside_roots": [
+        "1/2 - sqrt(21)/6",
+        "1/2 + sqrt(21)/6"
+      ],
+      "physical_roots": [
+        "0",
+        "1/2",
+        "1"
+      ]
+    },
+    "exact_checks": {
+      "angular_momentum_flux_present": true,
+      "archive_hash_matches": true,
+      "asymptotic_scaling_present": true,
+      "cap_integral_exact": true,
+      "complement_antisymmetry_exact": true,
+      "decompressed_member_hash_matches": true,
+      "factorization_exact": true,
+      "hemisphere_response_zero": true,
+      "physical_zero_set_complete": true,
+      "quadrupole_news_present": true,
+      "remaining_roots_outside_cap_domain": true,
+      "source_block_matches": true,
+      "sphere_measure_is_four_pi": true,
+      "stereographic_substitution_exact": true,
+      "time_delay_integral_present": true,
+      "time_delay_prefactor_exact": true
+    },
+    "paper": {
+      "arxiv_id": "1502.06120",
+      "title": "New Gravitational Memories"
+    },
+    "result_version": "sabrina_quadrupole_spin_memory_cap_duality_v1",
+    "source_evidence": {
+      "archive_sha256": "baaae174875149f3dd2f3e5e6a6b56b9011e0a608c67eac33d5cb12c238a92f6",
+      "block_sha256": "ea32e1918a59ef5192bc0a30613a14cf6d2a20602788fa74874ef3697ccfd72d",
+      "checks": {
+        "angular_momentum_flux_present": true,
+        "archive_hash_matches": true,
+        "asymptotic_scaling_present": true,
+        "decompressed_member_hash_matches": true,
+        "quadrupole_news_present": true,
+        "source_block_matches": true,
+        "time_delay_integral_present": true
+      },
+      "member_sha256": "d7aaabb46c5cacfe789e353f86441eb5a6829cd1ef5c19f781c9075fd4ad9150",
+      "source_lines": "667-677"
+    },
+    "status": "complete",
+    "theorem": {
+      "antipodal_complement_duality": "F(1-x)=-F(x)",
+      "cap_response": "Delta^+u=(12 alpha^2 omega/L)F(x), x=R^2/(1+R^2)",
+      "complete_physical_zero_set": "x in {0,1/2,1}",
+      "factorization": "30F=x(x-1)(2x-1)(3x^2-3x-1)",
+      "polynomial": "F(x)=x^5/5-x^4/2+x^3/3-x/30"
+    }
+  },
+  "scientific_payload_sha256": "ec237ce1930d800c155dbce44a6eb3a8c2c5c9d65bcf638d05a6583ce813ba9a"
+}
diff --git a/references/run_sabrina_radial_einstein_square_factorization.json b/references/run_sabrina_radial_einstein_square_factorization.json
new file mode 100644
index 0000000000000000000000000000000000000000..7b608bcf533f8f9c02429925bad585031daa1f72
--- /dev/null
+++ b/references/run_sabrina_radial_einstein_square_factorization.json
@@ -0,0 +1,97 @@
+{
+  "kernel": "run_sabrina_radial_einstein_square_factorization",
+  "role": "post-computation assertion only",
+  "schema": "ouroboros_scientific_reference_assertion_v1",
+  "scientific_payload": {
+    "claim_boundary": {
+      "boundary_conditions_analyzed": false,
+      "capabilities_removed": [],
+      "nonlinear_gravity_claimed": false,
+      "physical_mode_admissibility_claimed": false
+    },
+    "exact_checks": {
+      "archive_hash_matches": true,
+      "constant_factor_matches": true,
+      "cross_factor_matches": true,
+      "factor_kernel_witnesses_exact": true,
+      "leading_weyl_shift_factor_matches": true,
+      "member_hash_matches": true,
+      "proper_generalized_kernel_witnesses_exact": true,
+      "published_operator_terms_present": true,
+      "radial_gauge_anchor_present": true,
+      "source_blocks_match": true
+    },
+    "factorization_certificate": {
+      "checks": {
+        "constant_factor_matches": true,
+        "cross_factor_matches": true,
+        "leading_weyl_shift_factor_matches": true
+      },
+      "definitions": {
+        "D": "rho partial_rho",
+        "F": "rho^2(D^2-4)+4L",
+        "L": "partial_z partial_zbar",
+        "weyl_shift": "f(D) rho^2 = rho^2 f(D+2)"
+      },
+      "expanded_coefficients": {
+        "constant_L_squared": 16,
+        "cross_D_polynomial": "8*D**2 - 32",
+        "leading_D_polynomial": "D**4 + 4*D**3 - 4*D**2 - 16*D"
+      }
+    },
+    "monomial_witnesses": {
+      "-2": {
+        "F_coefficient": 0,
+        "F_squared_coefficient": 0,
+        "classification": "factor_kernel",
+        "radial_power": -2
+      },
+      "-4": {
+        "F_coefficient": 12,
+        "F_squared_coefficient": 0,
+        "classification": "proper_generalized_kernel",
+        "radial_power": -4
+      },
+      "0": {
+        "F_coefficient": -4,
+        "F_squared_coefficient": 0,
+        "classification": "proper_generalized_kernel",
+        "radial_power": 0
+      },
+      "2": {
+        "F_coefficient": 0,
+        "F_squared_coefficient": 0,
+        "classification": "factor_kernel",
+        "radial_power": 2
+      }
+    },
+    "paper": {
+      "arxiv_id": "1905.09809",
+      "title": "Uplifting AdS3/CFT2 to Flat Space Holography"
+    },
+    "result_version": "sabrina_radial_einstein_square_factorization_v1",
+    "source_evidence": {
+      "archive_sha256": "d91ca33f76b1d78eef4dc241257749edc9c7732b3e3e37c0a016fa2e318b628d",
+      "block_hashes": {
+        "linearized_einstein_components": "61b63627f259f0b68f4cea515d48be8388e82556628e79d9e9761c546bbb9ace",
+        "radial_master_equation": "99d867966127c00a4b16f971463d27014e1f84cb11de7075861d745ae11fc266"
+      },
+      "checks": {
+        "archive_hash_matches": true,
+        "member_hash_matches": true,
+        "published_operator_terms_present": true,
+        "radial_gauge_anchor_present": true,
+        "source_blocks_match": true
+      },
+      "member_sha256": "f21b2cf78cf1ab774361ae937384448221a89008da149b604cda583678304b83"
+    },
+    "status": "complete",
+    "theorem": {
+      "factor_kernel": "at L=0, rho^2 and rho^-2 are killed already by F",
+      "factorization": "E=[rho^2(D^2-4)+4L]^2, with D=rho partial_rho and L=partial_z partial_zbar",
+      "generalized_kernel_boundary": "ker(F) is a proper subset of ker(F^2): at L=0, rho^0 and rho^-4 are killed by F^2 but not by F",
+      "operator_identity": "the published fourth-order radial equation is the exact square of F=rho^2(D^2-4)+4L"
+    }
+  },
+  "scientific_payload_sha256": "7ecf43b482eecb12234e230a243c73209adfdb80078a068221722a2dd1380e56"
+}
diff --git a/references/run_sabrina_rt_area_boundary_identity.json b/references/run_sabrina_rt_area_boundary_identity.json
new file mode 100644
index 0000000000000000000000000000000000000000..6f09edb30cccf935046270e12cb0527d53c4d5f0
--- /dev/null
+++ b/references/run_sabrina_rt_area_boundary_identity.json
@@ -0,0 +1,127 @@
+{
+  "kernel": "run_sabrina_rt_area_boundary_identity",
+  "role": "post-computation assertion only",
+  "schema": "ouroboros_scientific_reference_assertion_v1",
+  "scientific_payload": {
+    "claim_boundary": {
+      "capabilities_removed": [],
+      "finite_cutoff_exact_stationary_locations_proved": false,
+      "full_nonlinear_monotonicity_proved": false,
+      "higher_asymptotic_orders_cannot_shift_or_lift_zeros_claimed": false,
+      "holographic_prescription_validated": false,
+      "numerical_profiles_reproduced": false,
+      "physical_range_extended_beyond_p_0_through_4": false
+    },
+    "exact_checks": {
+      "C3_coefficient_symbolic": true,
+      "archive_hash_matches": true,
+      "area_and_derivative_labels_unique": true,
+      "constant_solution_on_shell_witness_exact": true,
+      "derivative_amplitude_saturation_symbolic": true,
+      "displayed_derivative_constant_sign_mismatch": true,
+      "displayed_table_equality_exact": true,
+      "member_hash_matches": true,
+      "off_shell_hamiltonian_identity_exact": true,
+      "open_question_phrase_unique": true,
+      "physical_p_beta_real": true,
+      "physical_p_rows_exact": true,
+      "source_blocks_match": true,
+      "tail_exponent_identity_symbolic": true
+    },
+    "paper": {
+      "arxiv_id": "2606.13889",
+      "title": "Flat Space Entanglement: A Coulomb Branch Perspective"
+    },
+    "physical_p_rows": [
+      {
+        "C3_coefficient": "7/9",
+        "alpha": "9/4",
+        "alpha_squared_plus_beta_squared": "7",
+        "beta_squared": "31/16",
+        "derivative_constant": "-7/2",
+        "derivative_oscillation_amplitude": "7/2",
+        "n": "9/2",
+        "p": 0
+      },
+      {
+        "C3_coefficient": "3/4",
+        "alpha": "2",
+        "alpha_squared_plus_beta_squared": "6",
+        "beta_squared": "2",
+        "derivative_constant": "-3",
+        "derivative_oscillation_amplitude": "3",
+        "n": "4",
+        "p": 1
+      },
+      {
+        "C3_coefficient": "5/7",
+        "alpha": "7/4",
+        "alpha_squared_plus_beta_squared": "5",
+        "beta_squared": "31/16",
+        "derivative_constant": "-5/2",
+        "derivative_oscillation_amplitude": "5/2",
+        "n": "7/2",
+        "p": 2
+      },
+      {
+        "C3_coefficient": "2/3",
+        "alpha": "3/2",
+        "alpha_squared_plus_beta_squared": "4",
+        "beta_squared": "7/4",
+        "derivative_constant": "-2",
+        "derivative_oscillation_amplitude": "2",
+        "n": "3",
+        "p": 3
+      },
+      {
+        "C3_coefficient": "3/5",
+        "alpha": "5/4",
+        "alpha_squared_plus_beta_squared": "3",
+        "beta_squared": "23/16",
+        "derivative_constant": "-3/2",
+        "derivative_oscillation_amplitude": "3/2",
+        "n": "5/2",
+        "p": 4
+      }
+    ],
+    "result_version": "sabrina_rt_area_boundary_identity_v1",
+    "source_evidence": {
+      "archive_sha256": "0c66795a0adac63d23dac9ad3207a4bd586f7453365221b95159bca9380edbc3",
+      "block_hashes": {
+        "area_functional": "b3e799b987a9ae1fd8863116670fa0811fd66470d6e2e08259e88ead17ff3638",
+        "asymptotic_tail": "5817e4297a1daea433957224fc62678ec1d1955ed4d769ecf5918d8d1062694c",
+        "open_equality": "ae6341f0b08c3c64cc43880daaa0583de5c26c9d0407cbc010b77cbcc1b7d58a",
+        "particle_action_constraint": "bbd466f95f2f89bfa6acd9b89ebed746890511af9d8f1841dce4e915e0a57830",
+        "tail_coefficient_table": "b3cd2e56665b56279e3c978c0ae3b3023ad2cb017a669675305dd49e039515e2"
+      },
+      "checks": {
+        "archive_hash_matches": true,
+        "area_and_derivative_labels_unique": true,
+        "member_hash_matches": true,
+        "open_question_phrase_unique": true,
+        "source_blocks_match": true
+      },
+      "member_sha256": "3612980847a10a3a07708a1af3dcee65afedc85ffc8106af673e69ae3d42585e"
+    },
+    "status": "complete",
+    "symbolic_certificate": {
+      "constant_solution_witness_residual": "0",
+      "derivative_amplitude_saturation_residual": "0",
+      "derivative_mean": "-(C1**2 + C2**2)*(alpha**2 + beta**2)/2",
+      "derivative_oscillation_amplitude_squared": "(C1**2 + C2**2)**2*(alpha**2 + beta**2)**2/4",
+      "hamiltonian": "-f(q)*exp(n*u)/sqrt(velocity**2 + 1)",
+      "off_shell_identity": "dH/du+nL=theta_dot*EulerLagrange",
+      "off_shell_identity_residual": "0",
+      "tail_quadratic_mean": "(C1**2 + C2**2)*(alpha**2 + beta**2)"
+    },
+    "theorem": {
+      "derivative_result": "the quadratic asymptotic derivative has negative mean and equal oscillation amplitude, hence range [-b(C1^2+C2^2),0]",
+      "exact_boundary_identity": "A/(K r_c^n)=[H(0)-H(U)]/n=exp(nU) cos(theta(U))^b/(n sqrt(1+theta_dot(U)^2)) for a smooth cap",
+      "mechanism": "alpha^2+beta^2=7-p fixes the nonoscillatory quadratic boundary term",
+      "parameters": "n=(9-p)/2, b=7-p, U=log(r_uv/r_c)",
+      "resolved_equality": "C3^(p)=(7-p)/(9-p)*((C1^(p))^2+(C2^(p))^2)",
+      "sign_audit": "d[-C3*r_c^n]/dr_c=-n*C3*r_c^(n-1); the positive displayed constant in source equation DpdA is inconsistent with source equation DpA"
+    }
+  },
+  "scientific_payload_sha256": "ee27f366b07f19111f42a6487e69e75576daa09711cfb41f9012311047bff850"
+}
diff --git a/references/run_sabrina_soft_charge_cumulant_hierarchy.json b/references/run_sabrina_soft_charge_cumulant_hierarchy.json
new file mode 100644
index 0000000000000000000000000000000000000000..6cfc9e373ba08e651f5e68656d6819e55ae9536a
--- /dev/null
+++ b/references/run_sabrina_soft_charge_cumulant_hierarchy.json
@@ -0,0 +1,1619 @@
+{
+  "kernel": "run_sabrina_soft_charge_cumulant_hierarchy",
+  "role": "post-computation assertion only",
+  "schema": "ouroboros_scientific_reference_assertion_v1",
+  "scientific_payload": {
+    "certificate_witnesses": {
+      "correlated_hard_soft": [
+        {
+          "full_identity": true,
+          "full_rhs": "4/9",
+          "lhs": "4/9",
+          "mixed_terms": [
+            {
+              "coefficient": -1,
+              "contribution": "-8/9",
+              "cumulant": "8/9",
+              "hard_indices": [
+                2
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "-8/9",
+              "cumulant": "8/9",
+              "hard_indices": [
+                1
+              ]
+            }
+          ],
+          "n": 2,
+          "reduced_identity": false,
+          "reduced_rhs": "20/9"
+        },
+        {
+          "full_identity": true,
+          "full_rhs": "4/9",
+          "lhs": "4/9",
+          "mixed_terms": [
+            {
+              "coefficient": -1,
+              "contribution": "-16/9",
+              "cumulant": "16/9",
+              "hard_indices": [
+                3
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "-16/9",
+              "cumulant": "16/9",
+              "hard_indices": [
+                2
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "8/9",
+              "cumulant": "8/9",
+              "hard_indices": [
+                2,
+                3
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "-16/9",
+              "cumulant": "16/9",
+              "hard_indices": [
+                1
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "8/9",
+              "cumulant": "8/9",
+              "hard_indices": [
+                1,
+                3
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "8/9",
+              "cumulant": "8/9",
+              "hard_indices": [
+                1,
+                2
+              ]
+            }
+          ],
+          "n": 3,
+          "reduced_identity": false,
+          "reduced_rhs": "28/9"
+        },
+        {
+          "full_identity": true,
+          "full_rhs": "-16/9",
+          "lhs": "-16/9",
+          "mixed_terms": [
+            {
+              "coefficient": -1,
+              "contribution": "128/9",
+              "cumulant": "-128/9",
+              "hard_indices": [
+                4
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "128/9",
+              "cumulant": "-128/9",
+              "hard_indices": [
+                3
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "-64/9",
+              "cumulant": "-64/9",
+              "hard_indices": [
+                3,
+                4
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "128/9",
+              "cumulant": "-128/9",
+              "hard_indices": [
+                2
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "-64/9",
+              "cumulant": "-64/9",
+              "hard_indices": [
+                2,
+                4
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "-64/9",
+              "cumulant": "-64/9",
+              "hard_indices": [
+                2,
+                3
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "32/9",
+              "cumulant": "-32/9",
+              "hard_indices": [
+                2,
+                3,
+                4
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "128/9",
+              "cumulant": "-128/9",
+              "hard_indices": [
+                1
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "-64/9",
+              "cumulant": "-64/9",
+              "hard_indices": [
+                1,
+                4
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "-64/9",
+              "cumulant": "-64/9",
+              "hard_indices": [
+                1,
+                3
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "32/9",
+              "cumulant": "-32/9",
+              "hard_indices": [
+                1,
+                3,
+                4
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "-64/9",
+              "cumulant": "-64/9",
+              "hard_indices": [
+                1,
+                2
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "32/9",
+              "cumulant": "-32/9",
+              "hard_indices": [
+                1,
+                2,
+                4
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "32/9",
+              "cumulant": "-32/9",
+              "hard_indices": [
+                1,
+                2,
+                3
+              ]
+            }
+          ],
+          "n": 4,
+          "reduced_identity": false,
+          "reduced_rhs": "-272/9"
+        },
+        {
+          "full_identity": true,
+          "full_rhs": "-400/27",
+          "lhs": "-400/27",
+          "mixed_terms": [
+            {
+              "coefficient": -1,
+              "contribution": "6400/27",
+              "cumulant": "-6400/27",
+              "hard_indices": [
+                5
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "6400/27",
+              "cumulant": "-6400/27",
+              "hard_indices": [
+                4
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "-3200/27",
+              "cumulant": "-3200/27",
+              "hard_indices": [
+                4,
+                5
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "6400/27",
+              "cumulant": "-6400/27",
+              "hard_indices": [
+                3
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "-3200/27",
+              "cumulant": "-3200/27",
+              "hard_indices": [
+                3,
+                5
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "-3200/27",
+              "cumulant": "-3200/27",
+              "hard_indices": [
+                3,
+                4
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "1600/27",
+              "cumulant": "-1600/27",
+              "hard_indices": [
+                3,
+                4,
+                5
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "6400/27",
+              "cumulant": "-6400/27",
+              "hard_indices": [
+                2
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "-3200/27",
+              "cumulant": "-3200/27",
+              "hard_indices": [
+                2,
+                5
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "-3200/27",
+              "cumulant": "-3200/27",
+              "hard_indices": [
+                2,
+                4
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "1600/27",
+              "cumulant": "-1600/27",
+              "hard_indices": [
+                2,
+                4,
+                5
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "-3200/27",
+              "cumulant": "-3200/27",
+              "hard_indices": [
+                2,
+                3
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "1600/27",
+              "cumulant": "-1600/27",
+              "hard_indices": [
+                2,
+                3,
+                5
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "1600/27",
+              "cumulant": "-1600/27",
+              "hard_indices": [
+                2,
+                3,
+                4
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "-800/27",
+              "cumulant": "-800/27",
+              "hard_indices": [
+                2,
+                3,
+                4,
+                5
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "6400/27",
+              "cumulant": "-6400/27",
+              "hard_indices": [
+                1
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "-3200/27",
+              "cumulant": "-3200/27",
+              "hard_indices": [
+                1,
+                5
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "-3200/27",
+              "cumulant": "-3200/27",
+              "hard_indices": [
+                1,
+                4
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "1600/27",
+              "cumulant": "-1600/27",
+              "hard_indices": [
+                1,
+                4,
+                5
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "-3200/27",
+              "cumulant": "-3200/27",
+              "hard_indices": [
+                1,
+                3
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "1600/27",
+              "cumulant": "-1600/27",
+              "hard_indices": [
+                1,
+                3,
+                5
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "1600/27",
+              "cumulant": "-1600/27",
+              "hard_indices": [
+                1,
+                3,
+                4
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "-800/27",
+              "cumulant": "-800/27",
+              "hard_indices": [
+                1,
+                3,
+                4,
+                5
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "-3200/27",
+              "cumulant": "-3200/27",
+              "hard_indices": [
+                1,
+                2
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "1600/27",
+              "cumulant": "-1600/27",
+              "hard_indices": [
+                1,
+                2,
+                5
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "1600/27",
+              "cumulant": "-1600/27",
+              "hard_indices": [
+                1,
+                2,
+                4
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "-800/27",
+              "cumulant": "-800/27",
+              "hard_indices": [
+                1,
+                2,
+                4,
+                5
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "1600/27",
+              "cumulant": "-1600/27",
+              "hard_indices": [
+                1,
+                2,
+                3
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "-800/27",
+              "cumulant": "-800/27",
+              "hard_indices": [
+                1,
+                2,
+                3,
+                5
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "-800/27",
+              "cumulant": "-800/27",
+              "hard_indices": [
+                1,
+                2,
+                3,
+                4
+              ]
+            }
+          ],
+          "n": 5,
+          "reduced_identity": false,
+          "reduced_rhs": "-12400/27"
+        }
+      ],
+      "independent_hard_soft": [
+        {
+          "full_identity": true,
+          "full_rhs": "424/225",
+          "lhs": "424/225",
+          "mixed_terms": [
+            {
+              "coefficient": -1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                2
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                1
+              ]
+            }
+          ],
+          "n": 2,
+          "reduced_identity": true,
+          "reduced_rhs": "424/225"
+        },
+        {
+          "full_identity": true,
+          "full_rhs": "796/1125",
+          "lhs": "796/1125",
+          "mixed_terms": [
+            {
+              "coefficient": -1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                3
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                2
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                2,
+                3
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                1
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                1,
+                3
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                1,
+                2
+              ]
+            }
+          ],
+          "n": 3,
+          "reduced_identity": true,
+          "reduced_rhs": "796/1125"
+        },
+        {
+          "full_identity": true,
+          "full_rhs": "-16256/1125",
+          "lhs": "-16256/1125",
+          "mixed_terms": [
+            {
+              "coefficient": -1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                4
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                3
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                3,
+                4
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                2
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                2,
+                4
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                2,
+                3
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                2,
+                3,
+                4
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                1
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                1,
+                4
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                1,
+                3
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                1,
+                3,
+                4
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                1,
+                2
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                1,
+                2,
+                4
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                1,
+                2,
+                3
+              ]
+            }
+          ],
+          "n": 4,
+          "reduced_identity": true,
+          "reduced_rhs": "-16256/1125"
+        },
+        {
+          "full_identity": true,
+          "full_rhs": "-846416/16875",
+          "lhs": "-846416/16875",
+          "mixed_terms": [
+            {
+              "coefficient": -1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                5
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                4
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                4,
+                5
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                3
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                3,
+                5
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                3,
+                4
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                3,
+                4,
+                5
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                2
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                2,
+                5
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                2,
+                4
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                2,
+                4,
+                5
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                2,
+                3
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                2,
+                3,
+                5
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                2,
+                3,
+                4
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                2,
+                3,
+                4,
+                5
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                1
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                1,
+                5
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                1,
+                4
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                1,
+                4,
+                5
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                1,
+                3
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                1,
+                3,
+                5
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                1,
+                3,
+                4
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                1,
+                3,
+                4,
+                5
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                1,
+                2
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                1,
+                2,
+                5
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                1,
+                2,
+                4
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                1,
+                2,
+                4,
+                5
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                1,
+                2,
+                3
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                1,
+                2,
+                3,
+                5
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                1,
+                2,
+                3,
+                4
+              ]
+            }
+          ],
+          "n": 5,
+          "reduced_identity": true,
+          "reduced_rhs": "-846416/16875"
+        }
+      ],
+      "independent_zero_shift": [
+        {
+          "full_identity": true,
+          "full_rhs": "424/225",
+          "lhs": "424/225",
+          "mixed_terms": [
+            {
+              "coefficient": -1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                2
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                1
+              ]
+            }
+          ],
+          "n": 2,
+          "reduced_identity": true,
+          "reduced_rhs": "424/225"
+        },
+        {
+          "full_identity": true,
+          "full_rhs": "796/1125",
+          "lhs": "796/1125",
+          "mixed_terms": [
+            {
+              "coefficient": -1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                3
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                2
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                2,
+                3
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                1
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                1,
+                3
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                1,
+                2
+              ]
+            }
+          ],
+          "n": 3,
+          "reduced_identity": true,
+          "reduced_rhs": "796/1125"
+        },
+        {
+          "full_identity": true,
+          "full_rhs": "-16256/1125",
+          "lhs": "-16256/1125",
+          "mixed_terms": [
+            {
+              "coefficient": -1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                4
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                3
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                3,
+                4
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                2
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                2,
+                4
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                2,
+                3
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                2,
+                3,
+                4
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                1
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                1,
+                4
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                1,
+                3
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                1,
+                3,
+                4
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                1,
+                2
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                1,
+                2,
+                4
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                1,
+                2,
+                3
+              ]
+            }
+          ],
+          "n": 4,
+          "reduced_identity": true,
+          "reduced_rhs": "-16256/1125"
+        },
+        {
+          "full_identity": true,
+          "full_rhs": "-846416/16875",
+          "lhs": "-846416/16875",
+          "mixed_terms": [
+            {
+              "coefficient": -1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                5
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                4
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                4,
+                5
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                3
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                3,
+                5
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                3,
+                4
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                3,
+                4,
+                5
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                2
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                2,
+                5
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                2,
+                4
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                2,
+                4,
+                5
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                2,
+                3
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                2,
+                3,
+                5
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                2,
+                3,
+                4
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                2,
+                3,
+                4,
+                5
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                1
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                1,
+                5
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                1,
+                4
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                1,
+                4,
+                5
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                1,
+                3
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                1,
+                3,
+                5
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                1,
+                3,
+                4
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                1,
+                3,
+                4,
+                5
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                1,
+                2
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                1,
+                2,
+                5
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                1,
+                2,
+                4
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                1,
+                2,
+                4,
+                5
+              ]
+            },
+            {
+              "coefficient": -1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                1,
+                2,
+                3
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                1,
+                2,
+                3,
+                5
+              ]
+            },
+            {
+              "coefficient": 1,
+              "contribution": "0",
+              "cumulant": "0",
+              "hard_indices": [
+                1,
+                2,
+                3,
+                4
+              ]
+            }
+          ],
+          "n": 5,
+          "reduced_identity": true,
+          "reduced_rhs": "-846416/16875"
+        }
+      ]
+    },
+    "claim_boundary": {
+      "capabilities_removed": [],
+      "infrared_regulator_removed": false,
+      "loop_level_dynamics_computed": false,
+      "physical_mixed_cumulant_factorization_proved": false
+    },
+    "exact_checks": {
+      "archive_hash_matches": true,
+      "connected_two_point_present": true,
+      "correlated_mixed_cumulants_nonzero": true,
+      "correlated_reduction_fails_n2_to_n5": true,
+      "deterministic_shift_drops_from_connected_orders": true,
+      "factorized_mixed_cumulants_vanish": true,
+      "factorized_reduction_exact_n2_to_n5": true,
+      "full_hierarchy_exact_n2_to_n5": true,
+      "member_hash_matches": true,
+      "one_point_identity_present": true,
+      "paper_two_point_sign_recovered": true,
+      "source_blocks_match": true,
+      "two_point_seed_present": true
+    },
+    "paper": {
+      "arxiv_id": "2512.02825",
+      "title": "Memory Correlators and Ward Identities in the 'in-in' Formalism"
+    },
+    "result_version": "sabrina_soft_charge_cumulant_hierarchy_v1",
+    "source_evidence": {
+      "archive_sha256": "8d7eb8d846a8d632cea6032ceac8553720b36bde75a3ea45bb3d81dfb8882905",
+      "block_hashes": {
+        "one_point_charge_identity": "64662757ac621c2f661120727526498dd71bd4144be372e97e327c33c8879a04",
+        "two_point_connected_identity": "893ef92e9828d79ab61085be97b53559b157a296a414f8a7d14e2b1d14ea72bc"
+      },
+      "checks": {
+        "archive_hash_matches": true,
+        "connected_two_point_present": true,
+        "member_hash_matches": true,
+        "one_point_identity_present": true,
+        "source_blocks_match": true,
+        "two_point_seed_present": true
+      },
+      "member_sha256": "62c649b64370d8f1dc4489188ef1a4765af5d8f4b6dc3d8bd06e83670de508b3"
+    },
+    "status": "complete",
+    "theorem": {
+      "deterministic_shift": "incoming hard-charge eigenvalues do not affect connected cumulants of order n>=2",
+      "factorized_reduction": "if every mixed hard-outgoing/soft-incoming cumulant vanishes, kappa_n(S^+)=(-1)^n kappa_n(H^+)+kappa_n(S^-)",
+      "full_hierarchy": "for n>=2, kappa(S_1^+,...,S_n^+) is the sum over A subset [n] of (-1)^|A| kappa(H_A^+,S_[n]\\A^-)",
+      "obstruction": "Ward conservation alone gives the full mixed expansion; it does not remove mixed cumulants"
+    }
+  },
+  "scientific_payload_sha256": "8ed6c8d8dcc8eabf62402d94d7fdfcc3c000f15edec4ba8c1f437a6040cb2731"
+}
diff --git a/references/run_sabrina_soft_charge_reduced_state_theorem.json b/references/run_sabrina_soft_charge_reduced_state_theorem.json
new file mode 100644
index 0000000000000000000000000000000000000000..0a5dd076b61198cf9a16062375b95f8aee18093d
--- /dev/null
+++ b/references/run_sabrina_soft_charge_reduced_state_theorem.json
@@ -0,0 +1,243 @@
+{
+  "kernel": "run_sabrina_soft_charge_reduced_state_theorem",
+  "role": "post-computation assertion only",
+  "schema": "ouroboros_scientific_reference_assertion_v1",
+  "scientific_payload": {
+    "claim_boundary": {
+      "capabilities_removed": [],
+      "firewall_resolution_proved": false,
+      "information_recovery_proved": false,
+      "mixed_total_charge_inputs_covered": false,
+      "soft_charge_observability_proved": false,
+      "source_error_claimed": false,
+      "unitarity_proved": false
+    },
+    "exact_checks": {
+      "archive_hash_matches": true,
+      "charge_split_label_unique": true,
+      "charge_violating_counterexample_normalized": true,
+      "counterexample_commutator_nonzero": true,
+      "counterexample_has_multiple_total_charges": true,
+      "degenerate_sector_coherence_retained": true,
+      "entropy_direct_sum_exact": true,
+      "fixed_total_charge_support": true,
+      "member_hash_matches": true,
+      "outgoing_expansion_amplitude_references_exact": true,
+      "radiation_commutator_zero": true,
+      "radiation_entropy_exact": true,
+      "sector_probabilities_exact": true,
+      "source_blocks_match": true,
+      "witness_normalized": true
+    },
+    "necessity_counterexample": {
+      "commutator": [
+        [
+          "0",
+          "-1/2",
+          "0",
+          "0"
+        ],
+        [
+          "1/2",
+          "0",
+          "0",
+          "0"
+        ],
+        [
+          "0",
+          "0",
+          "0",
+          "0"
+        ],
+        [
+          "0",
+          "0",
+          "0",
+          "0"
+        ]
+      ],
+      "distinct_total_charge_count": 2,
+      "rho_r": [
+        [
+          "1/2",
+          "1/2",
+          "0",
+          "0"
+        ],
+        [
+          "1/2",
+          "1/2",
+          "0",
+          "0"
+        ],
+        [
+          "0",
+          "0",
+          "0",
+          "0"
+        ],
+        [
+          "0",
+          "0",
+          "0",
+          "0"
+        ]
+      ]
+    },
+    "paper": {
+      "arxiv_id": "2012.03850",
+      "title": "HPS meets AMPS: How Soft Hair Dissolves the Firewall"
+    },
+    "result_version": "sabrina_soft_charge_reduced_state_theorem_v1",
+    "source_evidence": {
+      "archive_sha256": "cd4abca013519ff0f5500fe09d8b4eb1033df2e33b42f4de32c9325dbae9c2eb",
+      "block_hashes": {
+        "charge_split": "b7ef731a7b3b931f0637a79202a34ef31128804b02006c4cb9ef21d9c3a78461",
+        "combined": "64e694be57eadd9b64e0a137c953c96544a58a280d573feb043b7c85641c73c0",
+        "evolution_context": "81fe3d9a13f113d89ded0e81a9851d9fbf29a262e206927161abf279a96089a8",
+        "outgoing_expansion": "e54beca2638848901c018855b983e5a5d254ea9063242230aaf3f90fcaa57e3f"
+      },
+      "checks": {
+        "archive_hash_matches": true,
+        "charge_split_label_unique": true,
+        "member_hash_matches": true,
+        "outgoing_expansion_amplitude_references_exact": true,
+        "source_blocks_match": true
+      },
+      "member_sha256": "0e88d6b5003a27b57fb43b5893fa79947c070012527bca3b1dd792f343a85e93"
+    },
+    "status": "complete",
+    "theorem": {
+      "conclusion": "[Q_R, Tr_B(rho_out)]=0, with arbitrary degeneracy inside each Q_R sector",
+      "entropy_identity": "S(rho_R)=H({p_q})+sum_q p_q S(rho_q)",
+      "hypothesis": "rho_out is supported in one eigenspace of Q_total=Q_R tensor I + I tensor Q_B",
+      "proof": [
+        "fixed total-charge support implies [Q_total,rho_out]=0",
+        "partial trace gives [Q_R,rho_R]=Tr_B([Q_total,rho_out])-Tr_B([I tensor Q_B,rho_out])",
+        "the first term vanishes by the hypothesis and the second by cyclicity of the partial trace on B"
+      ],
+      "support_rule": "nonzero amplitudes obey q_R+q_B=q_total"
+    },
+    "witness": {
+      "amplitudes": [
+        [
+          "1/2",
+          "0",
+          "0",
+          "0"
+        ],
+        [
+          "0",
+          "1/2",
+          "0",
+          "0"
+        ],
+        [
+          "0",
+          "1/2",
+          "0",
+          "0"
+        ],
+        [
+          "0",
+          "0",
+          "0",
+          "1/2"
+        ]
+      ],
+      "radiation_entropy": "3*log(2)/2",
+      "rho_b": [
+        [
+          "1/4",
+          "0",
+          "0",
+          "0"
+        ],
+        [
+          "0",
+          "1/2",
+          "0",
+          "0"
+        ],
+        [
+          "0",
+          "0",
+          "0",
+          "0"
+        ],
+        [
+          "0",
+          "0",
+          "0",
+          "1/4"
+        ]
+      ],
+      "rho_r": [
+        [
+          "1/4",
+          "0",
+          "0",
+          "0"
+        ],
+        [
+          "0",
+          "1/4",
+          "1/4",
+          "0"
+        ],
+        [
+          "0",
+          "1/4",
+          "1/4",
+          "0"
+        ],
+        [
+          "0",
+          "0",
+          "0",
+          "1/4"
+        ]
+      ],
+      "sector_rows": [
+        {
+          "charge": -1,
+          "entropy": "0",
+          "normalized_block": [
+            [
+              "1"
+            ]
+          ],
+          "probability": "1/4"
+        },
+        {
+          "charge": 0,
+          "entropy": "0",
+          "normalized_block": [
+            [
+              "1/2",
+              "1/2"
+            ],
+            [
+              "1/2",
+              "1/2"
+            ]
+          ],
+          "probability": "1/2"
+        },
+        {
+          "charge": 1,
+          "entropy": "0",
+          "normalized_block": [
+            [
+              "1"
+            ]
+          ],
+          "probability": "1/4"
+        }
+      ],
+      "shannon_entropy": "3*log(2)/2",
+      "weighted_sector_entropy": "0"
+    }
+  },
+  "scientific_payload_sha256": "1934ba760699c1f3d024f8428611b3b7b3dde43b9a45a54fd868c65b4cc5a8f6"
+}
diff --git a/references/run_sabrina_soft_dressing_factor_two_no_go.json b/references/run_sabrina_soft_dressing_factor_two_no_go.json
new file mode 100644
index 0000000000000000000000000000000000000000..e609527eb747eb508c6bbe2509b36be4d8167daa
--- /dev/null
+++ b/references/run_sabrina_soft_dressing_factor_two_no_go.json
@@ -0,0 +1,160 @@
+{
+  "kernel": "run_sabrina_soft_dressing_factor_two_no_go",
+  "role": "post-computation assertion only",
+  "schema": "ouroboros_scientific_reference_assertion_v1",
+  "scientific_payload": {
+    "algebraic_certificate": {
+      "central_exponential": {
+        "identity": "[Q,exp(Phi)]=[Q,Phi]exp(Phi) when [Q,Phi] is central",
+        "power_rows": [
+          {
+            "power": 1,
+            "residual": "0"
+          },
+          {
+            "power": 2,
+            "residual": "0"
+          },
+          {
+            "power": 3,
+            "residual": "0"
+          },
+          {
+            "power": 4,
+            "residual": "0"
+          },
+          {
+            "power": 5,
+            "residual": "0"
+          },
+          {
+            "power": 6,
+            "residual": "0"
+          },
+          {
+            "power": 7,
+            "residual": "0"
+          },
+          {
+            "power": 8,
+            "residual": "0"
+          },
+          {
+            "power": 9,
+            "residual": "0"
+          },
+          {
+            "power": 10,
+            "residual": "0"
+          },
+          {
+            "power": 11,
+            "residual": "0"
+          },
+          {
+            "power": 12,
+            "residual": "0"
+          }
+        ],
+        "truncated_orders_1_through_12_residuals": [
+          "0",
+          "0",
+          "0",
+          "0",
+          "0",
+          "0",
+          "0",
+          "0",
+          "0",
+          "0",
+          "0",
+          "0"
+        ]
+      },
+      "derivation_linearity": {
+        "half_weight_repair_residual": "0",
+        "lambda_two_gap": "c0*w0 + c1*w1 + c2*w2 + c3*w3",
+        "required_compensating_term": "-c0*w0 - c1*w1 - c2*w2 - c3*w3",
+        "residual": "0",
+        "scaled": "c0*lambda*w0 + c1*lambda*w1 + c2*lambda*w2 + c3*lambda*w3",
+        "target": "c0*w0 + c1*w1 + c2*w2 + c3*w3"
+      },
+      "matrix_witness": {
+        "base_phi_commutator": [
+          [
+            "0",
+            "t"
+          ],
+          [
+            "0",
+            "0"
+          ]
+        ],
+        "doubled_phi_residual": true,
+        "doubled_wilson_residual": true,
+        "half_weight_repair_exact": true,
+        "phi_squared_zero": true
+      }
+    },
+    "claim_boundary": {
+      "capabilities_removed": [],
+      "gravity_extension_rederived": false,
+      "infrared_finiteness_reproved": false,
+      "modified_opposite_helicity_brackets_resolved": false,
+      "physical_soft_phase_space_constructed": false,
+      "preferred_repair_class_selected": false,
+      "source_inconsistency_claimed": false
+    },
+    "exact_checks": {
+      "archive_hash_matches": true,
+      "central_exponential_series_exact_through_12": true,
+      "central_power_rule_exact_through_12": true,
+      "derivation_linearity_exact": true,
+      "half_and_full_pairs_in_open_problem": true,
+      "half_shift_pair_in_derivation": true,
+      "half_weight_repair_exact": true,
+      "lambda_two_changes_nonzero_target": true,
+      "matrix_witness_all_exact": true,
+      "member_hash_matches": true,
+      "open_question_unique": true,
+      "source_blocks_match": true,
+      "wilson_line_label_unique": true
+    },
+    "paper": {
+      "arxiv_id": "2604.19866",
+      "title": "Asymptotic charges as detectors and the memory effect in massive QED and perturbative quantum gravity"
+    },
+    "result_version": "sabrina_soft_dressing_factor_two_no_go_v1",
+    "source_evidence": {
+      "archive_sha256": "113774c03094c55b8c0ea9ccf46c7aed866dc0634a7f5179f42b01a63028acf0",
+      "block_hashes": {
+        "factor_two_open_problem": "0ab39d092788011485c7abd38d5515f8855985276f9f6dbdcd69f386ec435b06",
+        "field_and_ccr": "05efaf99c7badaa85328b5c73e4e4d97df98576f8ee644de31579b86ff21dc98",
+        "half_shift": "4b85e7e53bd48bf5133f0b915cf85654d06f0fe23ee20790e798ad2cbd935ec1",
+        "linear_dressing": "ac8c26c3a8bf5ac3d645084ed8c0a1973e7b46d13c8d0e524564825d7ab7d8fe"
+      },
+      "checks": {
+        "archive_hash_matches": true,
+        "half_and_full_pairs_in_open_problem": true,
+        "half_shift_pair_in_derivation": true,
+        "member_hash_matches": true,
+        "open_question_unique": true,
+        "source_blocks_match": true,
+        "wilson_line_label_unique": true
+      },
+      "member_sha256": "1c137c7fa60c65285dcceb27ed516b7bd6af078d6b66ff6934839324b7369959"
+    },
+    "status": "complete",
+    "theorem": {
+      "assumptions": "Phi is unchanged and linear in photon modes; the charge action is a derivation; every elementary charge-mode commutator is uniformly scaled by lambda",
+      "necessary_repair_classes": [
+        "rescale dressing weights by 1/lambda",
+        "add a compensating contribution equal to (1-lambda) times the original target",
+        "change the soft-mode algebra or projection so uniform scaling no longer applies"
+      ],
+      "no_go": "[Q,Phi]_lambda=lambda[Q,Phi]_1, so lambda=2 cannot retain a nonzero target dressing commutator",
+      "wilson_corollary": "if [Q,Phi] is central, the Wilson-line phase scales by the same lambda"
+    }
+  },
+  "scientific_payload_sha256": "694c94424ad44968ecc374bad8ce5fce735e410342d9142b79c566066a0ca029"
+}
diff --git a/references/run_sabrina_soft_mellin_residue_identity.json b/references/run_sabrina_soft_mellin_residue_identity.json
new file mode 100644
index 0000000000000000000000000000000000000000..af6f9fb5c3fab9838d978f1eae3d2cffe34d6f99
--- /dev/null
+++ b/references/run_sabrina_soft_mellin_residue_identity.json
@@ -0,0 +1,166 @@
+{
+  "kernel": "run_sabrina_soft_mellin_residue_identity",
+  "role": "post-computation assertion only",
+  "schema": "ouroboros_scientific_reference_assertion_v1",
+  "scientific_payload": {
+    "claim_boundary": {
+      "capabilities_removed": [],
+      "distributional_endpoint_convention": "symmetric half-line delta weight",
+      "paper_leading_and_subleading_results_challenged": false,
+      "scope": "The source immediately applies n=0 and n=1; both are exact because n!=1.",
+      "smoothness_assumption": "g(omega)=omega a(omega) is smooth at omega=0",
+      "unqualified_n_ge_2_extension_challenged": true
+    },
+    "classification": "physical_n0_n1_exact_unqualified_all_n_extension_requires_factorial",
+    "exact_checks": {
+      "archive_hash_matches": true,
+      "corrected_identity_passes_n0_through_n8": true,
+      "fourier_annihilation_phase": true,
+      "fourier_creation_phase": true,
+      "mellin_residue_is_derivative_over_factorial": true,
+      "member_hash_matches": true,
+      "n0_source_identity_exact": true,
+      "n1_source_identity_exact": true,
+      "n2_is_exact_counterexample_to_unqualified_all_n_extension": true,
+      "n2_mismatch_factor_is_two": true,
+      "source_blocks_match": true,
+      "source_equation_labels_unique": true
+    },
+    "finite_exact_rows": [
+      {
+        "annihilation_coefficient": "pi",
+        "creation_coefficient": "pi",
+        "displayed_identity_matches": true,
+        "endpoint_derivative": "1",
+        "factorial_corrected_identity_matches": true,
+        "mellin_residue": "1",
+        "mellin_test_function": "a(omega)=omega^-1 exp(-omega)",
+        "n": 0,
+        "source_formula_ratio": "1"
+      },
+      {
+        "annihilation_coefficient": "-I*pi",
+        "creation_coefficient": "I*pi",
+        "displayed_identity_matches": true,
+        "endpoint_derivative": "1",
+        "factorial_corrected_identity_matches": true,
+        "mellin_residue": "1",
+        "mellin_test_function": "a(omega)=omega^0 exp(-omega)",
+        "n": 1,
+        "source_formula_ratio": "1"
+      },
+      {
+        "annihilation_coefficient": "-2*pi",
+        "creation_coefficient": "-2*pi",
+        "displayed_identity_matches": false,
+        "endpoint_derivative": "2",
+        "factorial_corrected_identity_matches": true,
+        "mellin_residue": "1",
+        "mellin_test_function": "a(omega)=omega^1 exp(-omega)",
+        "n": 2,
+        "source_formula_ratio": "2"
+      },
+      {
+        "annihilation_coefficient": "6*I*pi",
+        "creation_coefficient": "-6*I*pi",
+        "displayed_identity_matches": false,
+        "endpoint_derivative": "6",
+        "factorial_corrected_identity_matches": true,
+        "mellin_residue": "1",
+        "mellin_test_function": "a(omega)=omega^2 exp(-omega)",
+        "n": 3,
+        "source_formula_ratio": "6"
+      },
+      {
+        "annihilation_coefficient": "24*pi",
+        "creation_coefficient": "24*pi",
+        "displayed_identity_matches": false,
+        "endpoint_derivative": "24",
+        "factorial_corrected_identity_matches": true,
+        "mellin_residue": "1",
+        "mellin_test_function": "a(omega)=omega^3 exp(-omega)",
+        "n": 4,
+        "source_formula_ratio": "24"
+      },
+      {
+        "annihilation_coefficient": "-120*I*pi",
+        "creation_coefficient": "120*I*pi",
+        "displayed_identity_matches": false,
+        "endpoint_derivative": "120",
+        "factorial_corrected_identity_matches": true,
+        "mellin_residue": "1",
+        "mellin_test_function": "a(omega)=omega^4 exp(-omega)",
+        "n": 5,
+        "source_formula_ratio": "120"
+      },
+      {
+        "annihilation_coefficient": "-720*pi",
+        "creation_coefficient": "-720*pi",
+        "displayed_identity_matches": false,
+        "endpoint_derivative": "720",
+        "factorial_corrected_identity_matches": true,
+        "mellin_residue": "1",
+        "mellin_test_function": "a(omega)=omega^5 exp(-omega)",
+        "n": 6,
+        "source_formula_ratio": "720"
+      },
+      {
+        "annihilation_coefficient": "5040*I*pi",
+        "creation_coefficient": "-5040*I*pi",
+        "displayed_identity_matches": false,
+        "endpoint_derivative": "5040",
+        "factorial_corrected_identity_matches": true,
+        "mellin_residue": "1",
+        "mellin_test_function": "a(omega)=omega^6 exp(-omega)",
+        "n": 7,
+        "source_formula_ratio": "5040"
+      },
+      {
+        "annihilation_coefficient": "40320*pi",
+        "creation_coefficient": "40320*pi",
+        "displayed_identity_matches": false,
+        "endpoint_derivative": "40320",
+        "factorial_corrected_identity_matches": true,
+        "mellin_residue": "1",
+        "mellin_test_function": "a(omega)=omega^7 exp(-omega)",
+        "n": 8,
+        "source_formula_ratio": "40320"
+      }
+    ],
+    "paper": {
+      "arxiv_id": "2105.09792",
+      "source_equations": [
+        "Mellin",
+        "mellinmode",
+        "eq:IDDelta1",
+        "eq:IDDelta2"
+      ],
+      "title": "Revisiting the Conformally Soft Sector with Celestial Diamonds"
+    },
+    "result_version": "sabrina_soft_mellin_residue_scope_theorem_v1",
+    "source_evidence": {
+      "archive_sha256": "96fe817814bf7bfc432df67f49f60ea0afa72f6eeb335e93624b6d8bb54359f3",
+      "block_hashes": {
+        "Mellin": "6bceb4357552b5aa5e81879be46ef7a2bca646b1766392f58887007fa4ffb310",
+        "eq:IDDelta1": "4972b66bb470f919154ab6fd3324c373869538b172947c553b8508ce4fcdaddf",
+        "eq:IDDelta2": "c7e9d17afa4c3d9719ddce22c97340c3be4facd874f86d1bb519cc51c8902c5c",
+        "mellinmode": "e019183a7f11f077ce6d9e78ace905c0e421de10bd9940f9b6d1036b3f242122"
+      },
+      "checks": {
+        "archive_hash_matches": true,
+        "member_hash_matches": true,
+        "source_blocks_match": true,
+        "source_equation_labels_unique": true
+      }
+    },
+    "status": "complete",
+    "theorem": {
+      "corrected_annihilation_identity": "LHS=(-i)^n pi n! Res_{Delta=1-n}[a_Delta] (1+z zbar)^(-1-n).",
+      "corrected_creation_identity": "LHS=(+i)^n pi n! Res_{Delta=1-n}[a_Delta^dagger] (1+z zbar)^(-1-n).",
+      "equivalent_source_form": "Replace u_pm^n on the left by u_pm^n/n!.",
+      "fourier_endpoint_rule": "Integral_0^infinity g(omega) delta^(n)(c omega) d omega =(-1)^n g^(n)(0)/(2 c^(n+1)) under the symmetric endpoint convention.",
+      "mellin_residue_rule": "Res_{Delta=1-n} Integral_0^infinity omega^(Delta-2) g(omega) d omega = g^(n)(0)/n!."
+    }
+  },
+  "scientific_payload_sha256": "2bac79f473b925a796d826a6c2d4fdd4003b5c269b8843d9f37dd83ed0e4d58f"
+}
diff --git a/references/run_sabrina_spin1_shadow_gauge_obstruction.json b/references/run_sabrina_spin1_shadow_gauge_obstruction.json
new file mode 100644
index 0000000000000000000000000000000000000000..9bc78130a0b524889550f3c54810d75afdee70c6
--- /dev/null
+++ b/references/run_sabrina_spin1_shadow_gauge_obstruction.json
@@ -0,0 +1,149 @@
+{
+  "kernel": "run_sabrina_spin1_shadow_gauge_obstruction",
+  "role": "post-computation assertion only",
+  "schema": "ouroboros_scientific_reference_assertion_v1",
+  "scientific_payload": {
+    "claim_boundary": {
+      "arbitrary_gauge_fields_claimed": false,
+      "capabilities_removed": [],
+      "direct_delta_one_shadow_integral_convergence_claimed": false,
+      "formal_analytic_continuation_only": true,
+      "interacting_amplitudes_claimed": false,
+      "large_gauge_hilbert_space_status_claimed": false,
+      "spin_one_conformal_primary_family_only": true
+    },
+    "coordinate_witness_certificate": {
+      "checks": {
+        "all_other_dimensions_nonzero": true,
+        "coordinate_witness_exact": true,
+        "null_reference_vector": true,
+        "only_d2_zero_in_d1_through_d10": true,
+        "transverse_polarization": true
+      },
+      "configuration": "q_cov=(-1,0,1), e_cov=(0,1,0), X=(2,0,0)",
+      "dimension_rows": [
+        {
+          "d": 1,
+          "field_xz": "1/4",
+          "zero": false
+        },
+        {
+          "d": 2,
+          "field_xz": "0",
+          "zero": true
+        },
+        {
+          "d": 3,
+          "field_xz": "-1/4",
+          "zero": false
+        },
+        {
+          "d": 4,
+          "field_xz": "-1/2",
+          "zero": false
+        },
+        {
+          "d": 5,
+          "field_xz": "-3/4",
+          "zero": false
+        },
+        {
+          "d": 6,
+          "field_xz": "-1",
+          "zero": false
+        },
+        {
+          "d": 7,
+          "field_xz": "-5/4",
+          "zero": false
+        },
+        {
+          "d": 8,
+          "field_xz": "-3/2",
+          "zero": false
+        },
+        {
+          "d": 9,
+          "field_xz": "-7/4",
+          "zero": false
+        },
+        {
+          "d": 10,
+          "field_xz": "-2",
+          "zero": false
+        }
+      ],
+      "field_xz_at_witness": "1/2 - d/4"
+    },
+    "exact_checks": {
+      "all_other_dimensions_nonzero": true,
+      "all_terms_share_global_obstruction": true,
+      "analytic_continuation_order_present": true,
+      "archive_hash_matches": true,
+      "bare_field_strength_has_d_minus_two_factor": true,
+      "coordinate_witness_exact": true,
+      "d2_exception_present": true,
+      "d2_field_strength_zero": true,
+      "d2_shadow_dimension_is_one": true,
+      "d2_shadow_prefactor_is_unity": true,
+      "delta_one_pure_gauge_present": true,
+      "formal_shadow_formula_present": true,
+      "member_hash_matches": true,
+      "null_reference_vector": true,
+      "only_d2_zero_in_d1_through_d10": true,
+      "radial_product_rule_has_d_minus_two_factor": true,
+      "shadow_integral_singularity_caveat_present": true,
+      "source_block_matches": true,
+      "transverse_polarization": true
+    },
+    "field_strength_factorization_certificate": {
+      "bare_wedge_coefficient": "2 - d",
+      "checks": {
+        "all_terms_share_global_obstruction": true,
+        "bare_field_strength_has_d_minus_two_factor": true,
+        "d2_field_strength_zero": true,
+        "d2_shadow_dimension_is_one": true,
+        "d2_shadow_prefactor_is_unity": true,
+        "radial_product_rule_has_d_minus_two_factor": true
+      },
+      "definitions": {
+        "alpha": "(d-2)/2",
+        "beta": "d-1",
+        "r": "-X^2",
+        "s": "-q.X",
+        "u": "e.X"
+      },
+      "field_strength": "F=-(d-2){r^alpha(e wedge q)s^-d+r^(alpha-1)[(X wedge e)s^(-(d-1))+u(X wedge q)s^-d]}",
+      "formal_shadow": "S_mu=r^alpha[e_mu s^-beta+u q_mu s^(-beta-1)]",
+      "radial_product_coefficient": "2 - d"
+    },
+    "paper": {
+      "arxiv_id": "1705.01027",
+      "title": "A Conformal Basis for Flat Space Amplitudes"
+    },
+    "result_version": "sabrina_spin1_shadow_gauge_obstruction_v1",
+    "source_evidence": {
+      "archive_sha256": "07822bb391f95a0271d3c2c67516aa152a612c389a5879a155793ebfb9c1ba4f",
+      "block_sha256": "eb2375ecda05e9207181cc729c3ffdb8d9e80a25e387568c037497bc5a0b8eb3",
+      "checks": {
+        "analytic_continuation_order_present": true,
+        "archive_hash_matches": true,
+        "d2_exception_present": true,
+        "delta_one_pure_gauge_present": true,
+        "formal_shadow_formula_present": true,
+        "member_hash_matches": true,
+        "shadow_integral_singularity_caveat_present": true,
+        "source_block_matches": true
+      },
+      "member_sha256": "167a25cccad50de1887a89fbca7497f7a40ce53fac1b906f21a28dc53aed15e4",
+      "source_lines": "912-981"
+    },
+    "status": "complete",
+    "theorem": {
+      "explicit_witness": "F_xz at q=(-1,0,1), e=(0,1,0), X=(2,0,0) equals -(d-2)/4",
+      "obstruction": "the formal Delta=1 shadow field strength has a global factor d-2",
+      "self_shadow_exception": "at d=2 the radial factor is unity and the shadow dimension is one"
+    }
+  },
+  "scientific_payload_sha256": "147d7f9336fd649e66d2d1995c6287514571d2ae8c83f798615712be5580eda5"
+}
diff --git a/references/run_sabrina_subleading_soft_gauge_defect_theorem.json b/references/run_sabrina_subleading_soft_gauge_defect_theorem.json
new file mode 100644
index 0000000000000000000000000000000000000000..49549d65d7233cb1da92d3283144c9334c282f6f
--- /dev/null
+++ b/references/run_sabrina_subleading_soft_gauge_defect_theorem.json
@@ -0,0 +1,168 @@
+{
+  "kernel": "run_sabrina_subleading_soft_gauge_defect_theorem",
+  "role": "post-computation assertion only",
+  "schema": "ouroboros_scientific_reference_assertion_v1",
+  "scientific_payload": {
+    "algebraic_certificate": {
+      "checks": {
+        "all_dimension_checks_pass": true,
+        "dimensions_two_through_eight_checked": true,
+        "four_dimensional_component_count": true,
+        "four_dimensional_probe_count": true
+      },
+      "converse": "the pure-gauge variation vanishes for every q and Lambda iff DeltaJ=0",
+      "dimensions": [
+        {
+          "basis_probe_count": 4,
+          "checks": {
+            "basis_probes_reconstruct_defect": true,
+            "conserved_variation_zero": true,
+            "every_skew_self_contraction_zero": true,
+            "nonzero_defect_has_basis_witness": true,
+            "probe_count_complete": true,
+            "variation_reduces_to_defect_bilinear": true
+          },
+          "dimension": 2,
+          "independent_components": 1,
+          "nonzero_witness": "1"
+        },
+        {
+          "basis_probe_count": 9,
+          "checks": {
+            "basis_probes_reconstruct_defect": true,
+            "conserved_variation_zero": true,
+            "every_skew_self_contraction_zero": true,
+            "nonzero_defect_has_basis_witness": true,
+            "probe_count_complete": true,
+            "variation_reduces_to_defect_bilinear": true
+          },
+          "dimension": 3,
+          "independent_components": 3,
+          "nonzero_witness": "1"
+        },
+        {
+          "basis_probe_count": 16,
+          "checks": {
+            "basis_probes_reconstruct_defect": true,
+            "conserved_variation_zero": true,
+            "every_skew_self_contraction_zero": true,
+            "nonzero_defect_has_basis_witness": true,
+            "probe_count_complete": true,
+            "variation_reduces_to_defect_bilinear": true
+          },
+          "dimension": 4,
+          "independent_components": 6,
+          "nonzero_witness": "1"
+        },
+        {
+          "basis_probe_count": 25,
+          "checks": {
+            "basis_probes_reconstruct_defect": true,
+            "conserved_variation_zero": true,
+            "every_skew_self_contraction_zero": true,
+            "nonzero_defect_has_basis_witness": true,
+            "probe_count_complete": true,
+            "variation_reduces_to_defect_bilinear": true
+          },
+          "dimension": 5,
+          "independent_components": 10,
+          "nonzero_witness": "1"
+        },
+        {
+          "basis_probe_count": 36,
+          "checks": {
+            "basis_probes_reconstruct_defect": true,
+            "conserved_variation_zero": true,
+            "every_skew_self_contraction_zero": true,
+            "nonzero_defect_has_basis_witness": true,
+            "probe_count_complete": true,
+            "variation_reduces_to_defect_bilinear": true
+          },
+          "dimension": 6,
+          "independent_components": 15,
+          "nonzero_witness": "1"
+        },
+        {
+          "basis_probe_count": 49,
+          "checks": {
+            "basis_probes_reconstruct_defect": true,
+            "conserved_variation_zero": true,
+            "every_skew_self_contraction_zero": true,
+            "nonzero_defect_has_basis_witness": true,
+            "probe_count_complete": true,
+            "variation_reduces_to_defect_bilinear": true
+          },
+          "dimension": 7,
+          "independent_components": 21,
+          "nonzero_witness": "1"
+        },
+        {
+          "basis_probe_count": 64,
+          "checks": {
+            "basis_probes_reconstruct_defect": true,
+            "conserved_variation_zero": true,
+            "every_skew_self_contraction_zero": true,
+            "nonzero_defect_has_basis_witness": true,
+            "probe_count_complete": true,
+            "variation_reduces_to_defect_bilinear": true
+          },
+          "dimension": 8,
+          "independent_components": 28,
+          "nonzero_witness": "1"
+        }
+      ],
+      "identity": "i S^(1)(epsilon_Lambda)=q^T DeltaJ Lambda, with DeltaJ=sum_k J_k"
+    },
+    "claim_boundary": {
+      "algebraic_identity_dimension_independent": true,
+      "capabilities_removed": [],
+      "loop_level_virasoro_symmetry_claimed": false,
+      "physical_application_four_dimensional": true,
+      "tree_level_gravitons_only": true
+    },
+    "exact_checks": {
+      "all_dimension_checks_pass": true,
+      "archive_hash_matches": true,
+      "dimensions_two_through_eight_checked": true,
+      "four_dimensional_component_count": true,
+      "four_dimensional_probe_count": true,
+      "gauge_variation_present": true,
+      "global_conservation_present": true,
+      "member_hash_matches": true,
+      "pure_gauge_polarization_present": true,
+      "source_blocks_match": true,
+      "subleading_soft_factor_present": true,
+      "tree_level_scope_present": true
+    },
+    "paper": {
+      "arxiv_id": "1406.3312",
+      "title": "Semiclassical Virasoro Symmetry of the Quantum Gravity S-Matrix"
+    },
+    "result_version": "sabrina_subleading_soft_gauge_defect_theorem_v1",
+    "source_evidence": {
+      "archive_sha256": "71c4e286fc787483d55585c3cd1846f7a5bde08fbdc45ecd68c195b08d48960c",
+      "block_hashes": {
+        "soft_factor_gauge_check": "a7f43c2c41e714df48ba6ebee2b43ff30b16dd162241500609e90ecec06905e9"
+      },
+      "checks": {
+        "archive_hash_matches": true,
+        "gauge_variation_present": true,
+        "global_conservation_present": true,
+        "member_hash_matches": true,
+        "pure_gauge_polarization_present": true,
+        "source_blocks_match": true,
+        "subleading_soft_factor_present": true,
+        "tree_level_scope_present": true
+      },
+      "member_sha256": "b460d980cf426aa41cddf49bc70c1f356d9ed752ce70972e82cdd06c352c6e0d"
+    },
+    "status": "complete",
+    "theorem": {
+      "defect_identity": "i S^(1)(epsilon_Lambda)=q^T DeltaJ Lambda, with DeltaJ=sum_k J_k",
+      "failure_diagnostic": "any nonzero DeltaJ component supplies a basis pair (q,Lambda) with nonzero pure-gauge variation",
+      "gauge_invariance_criterion": "the pure-gauge variation vanishes for every q and Lambda iff DeltaJ=0",
+      "mechanism": "q^T J_k q vanishes termwise by antisymmetry; basis polarizations recover every component of DeltaJ"
+    }
+  },
+  "scientific_payload_sha256": "f7f1619f5cf9b96d1c0093c8a1f8c0aff35360814eeaa17ab81bc686a50a3b61"
+}
diff --git a/references/run_sabrina_super_bms_commutator_syzygy_family.json b/references/run_sabrina_super_bms_commutator_syzygy_family.json
new file mode 100644
index 0000000000000000000000000000000000000000..2cd50788167d6fd2a923c70c84f4492c59980caf
--- /dev/null
+++ b/references/run_sabrina_super_bms_commutator_syzygy_family.json
@@ -0,0 +1,224 @@
+{
+  "kernel": "run_sabrina_super_bms_commutator_syzygy_family",
+  "role": "post-computation assertion only",
+  "schema": "ouroboros_scientific_reference_assertion_v1",
+  "scientific_payload": {
+    "all_order_proof": {
+      "antisymmetry_step": "[G_n,L_m]=-[L_m,G_n]=(n-m/2)G_(m+n)",
+      "fixed_target_step": "substitute n=t-m to obtain (t-3m/2)G_t",
+      "rank_step": "all route images are scalar multiples of one basis vector G_t",
+      "syzygy_step": "cross-multiply any two route coefficients"
+    },
+    "claim_boundary": {
+      "capabilities_removed": [],
+      "central_extensions_included": false,
+      "nonlinear_charge_algebra_claimed": false,
+      "quantum_anomalies_analyzed": false
+    },
+    "exact_checks": {
+      "all_pairwise_syzygies_exact": true,
+      "archive_hash_matches": true,
+      "exceptional_routes_exact": true,
+      "finite_rank_one_certificates_exact": true,
+      "member_hash_matches": true,
+      "source_blocks_match": true,
+      "source_special_identity_present": true,
+      "source_specialization_exact": true,
+      "super_bms_bracket_present": true
+    },
+    "finite_exact_certificate": {
+      "all_pairwise_syzygies_pass": true,
+      "exceptional_routes": [
+        {
+          "commutator": "[G_(-3/2),L_(-3)]",
+          "exceptional_zero_route": true,
+          "fermion_mode": "-3/2",
+          "lorentz_mode": -3,
+          "target_coefficient": "0",
+          "target_mode": "-9/2"
+        },
+        {
+          "commutator": "[G_(-1/2),L_(-1)]",
+          "exceptional_zero_route": true,
+          "fermion_mode": "-1/2",
+          "lorentz_mode": -1,
+          "target_coefficient": "0",
+          "target_mode": "-3/2"
+        },
+        {
+          "commutator": "[G_(1/2),L_(1)]",
+          "exceptional_zero_route": true,
+          "fermion_mode": "1/2",
+          "lorentz_mode": 1,
+          "target_coefficient": "0",
+          "target_mode": "3/2"
+        },
+        {
+          "commutator": "[G_(3/2),L_(3)]",
+          "exceptional_zero_route": true,
+          "fermion_mode": "3/2",
+          "lorentz_mode": 3,
+          "target_coefficient": "0",
+          "target_mode": "9/2"
+        }
+      ],
+      "lorentz_modes": [
+        -4,
+        -3,
+        -2,
+        -1,
+        0,
+        1,
+        2,
+        3,
+        4
+      ],
+      "rows": [
+        {
+          "all_pairwise_syzygies_pass": true,
+          "commutator_image_rank": 1,
+          "nonzero_route_count": 8,
+          "route_count": 9,
+          "syzygy_dimension": 8,
+          "target_mode": "-9/2"
+        },
+        {
+          "all_pairwise_syzygies_pass": true,
+          "commutator_image_rank": 1,
+          "nonzero_route_count": 9,
+          "route_count": 9,
+          "syzygy_dimension": 8,
+          "target_mode": "-7/2"
+        },
+        {
+          "all_pairwise_syzygies_pass": true,
+          "commutator_image_rank": 1,
+          "nonzero_route_count": 9,
+          "route_count": 9,
+          "syzygy_dimension": 8,
+          "target_mode": "-5/2"
+        },
+        {
+          "all_pairwise_syzygies_pass": true,
+          "commutator_image_rank": 1,
+          "nonzero_route_count": 8,
+          "route_count": 9,
+          "syzygy_dimension": 8,
+          "target_mode": "-3/2"
+        },
+        {
+          "all_pairwise_syzygies_pass": true,
+          "commutator_image_rank": 1,
+          "nonzero_route_count": 9,
+          "route_count": 9,
+          "syzygy_dimension": 8,
+          "target_mode": "-1/2"
+        },
+        {
+          "all_pairwise_syzygies_pass": true,
+          "commutator_image_rank": 1,
+          "nonzero_route_count": 9,
+          "route_count": 9,
+          "syzygy_dimension": 8,
+          "target_mode": "1/2"
+        },
+        {
+          "all_pairwise_syzygies_pass": true,
+          "commutator_image_rank": 1,
+          "nonzero_route_count": 8,
+          "route_count": 9,
+          "syzygy_dimension": 8,
+          "target_mode": "3/2"
+        },
+        {
+          "all_pairwise_syzygies_pass": true,
+          "commutator_image_rank": 1,
+          "nonzero_route_count": 9,
+          "route_count": 9,
+          "syzygy_dimension": 8,
+          "target_mode": "5/2"
+        },
+        {
+          "all_pairwise_syzygies_pass": true,
+          "commutator_image_rank": 1,
+          "nonzero_route_count": 9,
+          "route_count": 9,
+          "syzygy_dimension": 8,
+          "target_mode": "7/2"
+        },
+        {
+          "all_pairwise_syzygies_pass": true,
+          "commutator_image_rank": 1,
+          "nonzero_route_count": 8,
+          "route_count": 9,
+          "syzygy_dimension": 8,
+          "target_mode": "9/2"
+        }
+      ],
+      "target_modes": [
+        "-9/2",
+        "-7/2",
+        "-5/2",
+        "-3/2",
+        "-1/2",
+        "1/2",
+        "3/2",
+        "5/2",
+        "7/2",
+        "9/2"
+      ]
+    },
+    "paper": {
+      "arxiv_id": "2108.11422",
+      "title": "Conformally Soft Fermions"
+    },
+    "result_version": "sabrina_super_bms_commutator_syzygy_family_v1",
+    "source_evidence": {
+      "archive_sha256": "52cceb32e1459fb57a0b32d1b24bb738a73e5888976775ff6fab8499df6fc401",
+      "block_hashes": {
+        "soft_descendant_doublet": "b7d31a7d00996cf3099ec467b32f8136ae24b4b472e7ebb843e01d36657ab13a",
+        "source_mode_identity": "43a2b6078322a9c41d6001acb3bfb6eb2773be16651bf33ccae5b6eb16d9c426",
+        "super_bms_algebra": "07e4ff2b9792ed6e5d48af3637bf67478083b6626b46c173c8e856c90f542949"
+      },
+      "checks": {
+        "archive_hash_matches": true,
+        "member_hash_matches": true,
+        "source_blocks_match": true,
+        "source_special_identity_present": true,
+        "super_bms_bracket_present": true
+      },
+      "member_sha256": "a50867327474e55046979390bbde0d888cb6f4580542735f9cef07134d076d84"
+    },
+    "source_specialization": {
+      "first_route": {
+        "commutator": "[G_(-1/2),L_(-2)]",
+        "exceptional_zero_route": false,
+        "fermion_mode": "-1/2",
+        "lorentz_mode": -2,
+        "target_coefficient": "1/2",
+        "target_mode": "-5/2"
+      },
+      "second_route_G_then_L": {
+        "commutator": "[G_(-3/2),L_(-1)]",
+        "exceptional_zero_route": false,
+        "fermion_mode": "-3/2",
+        "lorentz_mode": -1,
+        "target_coefficient": "-1",
+        "target_mode": "-5/2"
+      },
+      "second_route_L_then_G_coefficient": "1",
+      "source_identity_exact": true,
+      "source_identity_residual": "0",
+      "target_mode": "-5/2"
+    },
+    "status": "complete",
+    "theorem": {
+      "exceptional_route": "C_m(t)=0 exactly when m=2t/3 is an integer",
+      "finite_route_rank": "for N selected routes containing a nonzero coefficient, the commutator image has rank one and the syzygy space has dimension N-1",
+      "pairwise_syzygy": "(t-3n/2)C_m(t)-(t-3m/2)C_n(t)=0 for all integer m,n and half-integer t",
+      "route_formula": "C_m(t):=[G_(t-m),L_m]=(t-3m/2)G_t",
+      "source_special_case": "t=-5/2, m=-2, n=-1 reproduces [G_-1/2,L_-2]-(1/2)[L_-1,G_-3/2]=0"
+    }
+  },
+  "scientific_payload_sha256": "0c0559f924de94f512ba19fd2d867bfef93412978ddcb2cfd055a85cdcf94086"
+}
diff --git a/references/run_sabrina_superrotation_charge_cancellation.json b/references/run_sabrina_superrotation_charge_cancellation.json
new file mode 100644
index 0000000000000000000000000000000000000000..205a829faaab4f1c0bccd812e9edbda15dba36f5
--- /dev/null
+++ b/references/run_sabrina_superrotation_charge_cancellation.json
@@ -0,0 +1,94 @@
+{
+  "kernel": "run_sabrina_superrotation_charge_cancellation",
+  "role": "post-computation assertion only",
+  "schema": "ouroboros_scientific_reference_assertion_v1",
+  "scientific_payload": {
+    "basis": [
+      "D_z^3 Y^z C^zz",
+      "D^2 D_zbar Y_zbar C^zbarzbar",
+      "u D_z^3 Y^z N^zz",
+      "u D^2 D_zbar Y_zbar N^zbarzbar"
+    ],
+    "claim_boundary": {
+      "capabilities_removed": [],
+      "holomorphic_restriction": "Y^A=(Y^z,0)",
+      "source_correction_claimed": false,
+      "unrestricted_extension_reason": "The source-derived coefficient map fixes four holomorphic-sector components and leaves four independent conjugate-sector components unfixed.",
+      "unrestricted_two_component_extension_proven": false
+    },
+    "classification": "source_consistent_holomorphic_superrotation_charge_exactly_reduced",
+    "coefficient_certificate": {
+      "integrated_boundary_correction": [
+        "1",
+        "1/2",
+        "1",
+        "1/2"
+      ],
+      "renormalized_symplectic_charge": [
+        "-1",
+        "-1/2",
+        "1",
+        "-1/2"
+      ],
+      "sum_after_reinstating_1_over_32piG": [
+        "0",
+        "0",
+        "1/(16*pi*G)",
+        "0"
+      ],
+      "sum_before_normalization": [
+        "0",
+        "0",
+        "2",
+        "0"
+      ]
+    },
+    "exact_checks": {
+      "antiholomorphic_news_term_cancels": true,
+      "archive_hash_matches": true,
+      "both_shear_terms_cancel": true,
+      "holomorphic_news_term_doubles": true,
+      "holomorphic_restriction_present": true,
+      "holomorphic_source_map_rank_four": true,
+      "member_hash_matches": true,
+      "normalization_reinstatement_present": true,
+      "reinstated_normalization_is_exact": true,
+      "source_blocks_match": true,
+      "source_equation_labels_unique": true,
+      "unrestricted_extension_has_four_unfixed_components": true
+    },
+    "finding": "Under the source's explicit Y^A=(Y^z,0) restriction, the boundary term cancels both shear terms and the anti-holomorphic news term, doubles only the holomorphic news term, and yields exactly the displayed 1/(16 pi G) charge.",
+    "paper": {
+      "arxiv_id": "2005.08990",
+      "source_equations": [
+        "mQY",
+        "dQ",
+        "QYsoft",
+        "udQ",
+        "QYfinal"
+      ],
+      "title": "Asymptotic Symmetries and Celestial CFT"
+    },
+    "result_version": "sabrina_superrotation_charge_cancellation_v1",
+    "source_evidence": {
+      "archive_sha256": "c3e707827b4e21604f131a38a77ff84650ac52232b376fab6cf39b36d6a92be8",
+      "block_hashes": {
+        "QYfinal": "3382b7cf6e175a7d1bfd2b1fa33dbea984ddba40d32c7150e380b886e3020cb8",
+        "QYsoft": "a9b55f82a2c4f72505a2e3517be55689d901d68067d0bb29b07c07e71a3510d7",
+        "dQ": "397652f6ece651dfe3427c6aa4512743f8e83042e8e8e7baa4b64c5aa2121ef0",
+        "mQY": "2b22626481d991b571e0522af2da1db4f732bbe94c519313bfd1138e37aa6b25",
+        "udQ": "d8ef18cee3e99b07c7a82ed04334c5bdf2c64c6d72eb9a17d3b34032e3157b41"
+      },
+      "checks": {
+        "archive_hash_matches": true,
+        "holomorphic_restriction_present": true,
+        "member_hash_matches": true,
+        "normalization_reinstatement_present": true,
+        "source_blocks_match": true,
+        "source_equation_labels_unique": true
+      }
+    },
+    "status": "complete"
+  },
+  "scientific_payload_sha256": "9081bdaa476d9558567b5363b9a85389cdaf84998fd93684f74822acd8c1ad47"
+}
diff --git a/references/run_sabrina_two_particle_kernel_variance.json b/references/run_sabrina_two_particle_kernel_variance.json
new file mode 100644
index 0000000000000000000000000000000000000000..fb2ae569339c75d670f1ca7a74fe10ca339d30cd
--- /dev/null
+++ b/references/run_sabrina_two_particle_kernel_variance.json
@@ -0,0 +1,223 @@
+{
+  "kernel": "run_sabrina_two_particle_kernel_variance",
+  "role": "post-computation assertion only",
+  "schema": "ouroboros_scientific_reference_assertion_v1",
+  "scientific_payload": {
+    "certificate_witnesses": {
+      "positive_atomic_measures": [
+        {
+          "centered_second": "1/4",
+          "moment": "0",
+          "normalization": "1",
+          "points": [
+            "0"
+          ],
+          "positive_probability": true,
+          "variance_identity": true,
+          "weights": [
+            "1"
+          ]
+        },
+        {
+          "centered_second": "0",
+          "moment": "1/4",
+          "normalization": "1",
+          "points": [
+            "1/2"
+          ],
+          "positive_probability": true,
+          "variance_identity": true,
+          "weights": [
+            "1"
+          ]
+        },
+        {
+          "centered_second": "1/16",
+          "moment": "3/16",
+          "normalization": "1",
+          "points": [
+            "1/4",
+            "3/4"
+          ],
+          "positive_probability": true,
+          "variance_identity": true,
+          "weights": [
+            "1/2",
+            "1/2"
+          ]
+        },
+        {
+          "centered_second": "7/60",
+          "moment": "2/15",
+          "normalization": "1",
+          "points": [
+            "0",
+            "1/3",
+            "1"
+          ],
+          "positive_probability": true,
+          "variance_identity": true,
+          "weights": [
+            "1/5",
+            "3/5",
+            "1/5"
+          ]
+        }
+      ],
+      "positive_bound_polynomial_residual": "0",
+      "signed_family_positive_slope": "1/30",
+      "signed_normalized_family": [
+        {
+          "expected_moment": "-17/6",
+          "moment": "-17/6",
+          "normalization": "1",
+          "parameter": "-90"
+        },
+        {
+          "expected_moment": "-5/6",
+          "moment": "-5/6",
+          "normalization": "1",
+          "parameter": "-30"
+        },
+        {
+          "expected_moment": "1/6",
+          "moment": "1/6",
+          "normalization": "1",
+          "parameter": "0"
+        },
+        {
+          "expected_moment": "7/6",
+          "moment": "7/6",
+          "normalization": "1",
+          "parameter": "30"
+        },
+        {
+          "expected_moment": "19/6",
+          "moment": "19/6",
+          "normalization": "1",
+          "parameter": "90"
+        }
+      ],
+      "symbolic_moment": "A/30 + 1/6",
+      "symbolic_normalization": "1",
+      "symmetric_energy_shares": [
+        {
+          "centered_second": "0",
+          "distance": "0",
+          "moment": "1/4",
+          "normalization": "1",
+          "points": [
+            "1/2",
+            "1/2"
+          ],
+          "positive_probability": true,
+          "variance_identity": true,
+          "weights": [
+            "1/2",
+            "1/2"
+          ]
+        },
+        {
+          "centered_second": "1/100",
+          "distance": "1/10",
+          "moment": "6/25",
+          "normalization": "1",
+          "points": [
+            "2/5",
+            "3/5"
+          ],
+          "positive_probability": true,
+          "variance_identity": true,
+          "weights": [
+            "1/2",
+            "1/2"
+          ]
+        },
+        {
+          "centered_second": "1/16",
+          "distance": "1/4",
+          "moment": "3/16",
+          "normalization": "1",
+          "points": [
+            "1/4",
+            "3/4"
+          ],
+          "positive_probability": true,
+          "variance_identity": true,
+          "weights": [
+            "1/2",
+            "1/2"
+          ]
+        },
+        {
+          "centered_second": "1/4",
+          "distance": "1/2",
+          "moment": "0",
+          "normalization": "1",
+          "points": [
+            "0",
+            "1"
+          ],
+          "positive_probability": true,
+          "variance_identity": true,
+          "weights": [
+            "1/2",
+            "1/2"
+          ]
+        }
+      ]
+    },
+    "claim_boundary": {
+      "capabilities_removed": [],
+      "higher_ope_functionals_classified": false,
+      "kernel_uniqueness_proved": false,
+      "physical_kernel_positivity_proved": false
+    },
+    "exact_checks": {
+      "archive_hash_matches": true,
+      "kernel_declared_arbitrary": true,
+      "member_hash_matches": true,
+      "normalization_alone_unbounded": true,
+      "normalization_condition_present": true,
+      "positive_witnesses_inside_sharp_interval": true,
+      "quadratic_weight_present": true,
+      "sharp_endpoints_attained": true,
+      "signed_family_moment_formula_exact": true,
+      "signed_family_normalized_exactly": true,
+      "single_integrated_kernel_in_displayed_ope": true,
+      "source_blocks_match": true,
+      "symmetric_variance_identity_exact": true,
+      "variance_identity_polynomial_exact": true
+    },
+    "paper": {
+      "arxiv_id": "2402.18798",
+      "title": "Multiparticle Contributions to the Celestial OPE"
+    },
+    "result_version": "sabrina_two_particle_kernel_variance_v1",
+    "source_evidence": {
+      "archive_sha256": "a6d1fa18157eefdb3f32c35fe8417c07e425eefb1c2e9e2e316e36dee2a530e2",
+      "block_hashes": {
+        "kernel_normalization_and_homogeneity": "7f9e049dc3049042069dfd440d9526fc79b11a5f1a6fb44229ddc5a9567e681b",
+        "two_particle_ope_weight": "ae0e4719372cdcb85d1120fab106463b7b669ccc767e3777fbf4ada73576e3f0"
+      },
+      "checks": {
+        "archive_hash_matches": true,
+        "kernel_declared_arbitrary": true,
+        "member_hash_matches": true,
+        "normalization_condition_present": true,
+        "quadratic_weight_present": true,
+        "single_integrated_kernel_in_displayed_ope": true,
+        "source_blocks_match": true
+      },
+      "member_sha256": "9c40bdf5a48077f22552d0bca2cd30ad739566fe687662fafccced4be7953d1b"
+    },
+    "status": "complete",
+    "theorem": {
+      "ambiguity_collapse": "the displayed two-particle OPE weight depends on the arbitrary normalized kernel only through M[f]=integral f(t)t(1-t)dt",
+      "conditional_sharp_bound": "if f is a nonnegative normalized measure on [0,1], then 0<=M[f]<=1/4, with endpoint and equal-sharing extremizers",
+      "normalization_only_obstruction": "the signed normalized family f_A=1+A(6t(1-t)-1) has M=1/6+A/30, so normalization alone gives no bound",
+      "variance_identity": "M[f]=1/4-integral f(t)(t-1/2)^2dt"
+    }
+  },
+  "scientific_payload_sha256": "7b1aa48423c6010da14e5d02a47c618b324310dbf80b043db8546fbcc3ee59b6"
+}
diff --git a/references/run_sabrina_weyl_double_copy_shadow_involution.json b/references/run_sabrina_weyl_double_copy_shadow_involution.json
new file mode 100644
index 0000000000000000000000000000000000000000..921d22a9962318501850a9b723fb9b66ad15e8a8
--- /dev/null
+++ b/references/run_sabrina_weyl_double_copy_shadow_involution.json
@@ -0,0 +1,114 @@
+{
+  "kernel": "run_sabrina_weyl_double_copy_shadow_involution",
+  "role": "post-computation assertion only",
+  "schema": "ouroboros_scientific_reference_assertion_v1",
+  "scientific_payload": {
+    "claim_boundary": {
+      "capabilities_removed": [],
+      "full_shadow_kernel_normalization_claimed": false,
+      "interacting_double_copy_claimed": false,
+      "naive_self_shadow_substitution_allowed": false,
+      "singular_state_physics_claimed": false
+    },
+    "exact_checks": {
+      "archive_hash_matches": true,
+      "coefficient_table_present": true,
+      "fixed_zero_exact": true,
+      "gauge_pair_exchanged": true,
+      "member_hash_matches": true,
+      "pole_exchange_exact": true,
+      "primary_double_copy_exact": true,
+      "primary_shadow_curvatures_present": true,
+      "removable_self_shadow_limits_exact": true,
+      "scalar_pair_exchanged": true,
+      "shadow_double_copy_exact": true,
+      "source_blocks_match": true,
+      "source_primary_weyl_exact": true,
+      "source_shadow_weyl_exact": true,
+      "tau_squared_identity": true,
+      "weyl_double_copy_definition_present": true,
+      "weyl_pair_exchanged": true
+    },
+    "involution_certificate": {
+      "checks": {
+        "gauge_pair_exchanged": true,
+        "primary_double_copy_exact": true,
+        "scalar_pair_exchanged": true,
+        "shadow_double_copy_exact": true,
+        "source_primary_weyl_exact": true,
+        "source_shadow_weyl_exact": true,
+        "tau_squared_identity": true,
+        "weyl_pair_exchanged": true
+      },
+      "coefficients": {
+        "gauge_primary": "Delta - 1",
+        "gauge_shadow": "1 - Delta",
+        "scalar_primary": "(2 - 2*Delta)/Delta",
+        "scalar_shadow": "(2 - 2*Delta)/(Delta - 2)",
+        "weyl_primary": "-Delta**2/2 + Delta/2",
+        "weyl_shadow": "-Delta**2/2 + 3*Delta/2 - 1"
+      },
+      "tau": "2-Delta"
+    },
+    "paper": {
+      "arxiv_id": "2012.15694",
+      "title": "Shifting Spin on the Celestial Sphere"
+    },
+    "result_version": "sabrina_weyl_double_copy_shadow_involution_v1",
+    "scope": {
+      "chirality_exchange_applied": true,
+      "coefficient_level_only": true,
+      "universal_shadow_spacetime_factor_stripped": "2/X^2"
+    },
+    "singularity_certificate": {
+      "fixed_zero_exact": true,
+      "pole_exchange_exact": true,
+      "reduced_primary_limit": "0",
+      "reduced_shadow_limit": "0",
+      "removable_limits_exact": true,
+      "scalar_primary": {
+        "pole": "Delta=0",
+        "zero": "Delta=1"
+      },
+      "scalar_shadow": {
+        "pole": "Delta=2",
+        "zero": "Delta=1"
+      },
+      "self_shadow_point": 1,
+      "unreduced_quotient_at_self_shadow": "0/0",
+      "weyl_primary_zeros": [
+        0,
+        1
+      ],
+      "weyl_shadow_zeros": [
+        1,
+        2
+      ]
+    },
+    "source_evidence": {
+      "archive_sha256": "ff00948d397a3aaaa36cec9a65f63477b16c6315c982669e63259b0a8961fc46",
+      "block_hashes": {
+        "primary_shadow_curvatures": "8acb82a9be540c4a2d8eead0630fbcb8fe0c15fcbd76c81abfa1fadfcebe7a80",
+        "weyl_double_copy_definition": "5cbf0c6d34e0ca8ba5607901422b27778f4b6c966fb2dae1468294d2fa0dbed4",
+        "weyl_double_copy_table": "774c827ab158f3d9fbae9dbc062ceb3638202c3dc36940d488f19f968db13490"
+      },
+      "checks": {
+        "archive_hash_matches": true,
+        "coefficient_table_present": true,
+        "member_hash_matches": true,
+        "primary_shadow_curvatures_present": true,
+        "source_blocks_match": true,
+        "weyl_double_copy_definition_present": true
+      },
+      "member_sha256": "17ed9a4bf99bf5a3a53a11d7da5c3000c4b99db7688432072e6703a597671794"
+    },
+    "status": "complete",
+    "theorem": {
+      "divisor_exchange": "the scalar prefactor poles Delta=0 and Delta=2 are exchanged, while Delta=1 is fixed",
+      "double_copy_equivariance": "C_P=f_P^2/S_P and C_S=f_S^2/S_S are preserved under tau",
+      "involution": "tau(Delta)=2-Delta exchanges the stripped primary and shadow gauge, scalar, and Weyl double-copy coefficients",
+      "self_shadow_boundary": "at Delta=1 the unreduced f^2/S quotient is 0/0; its reduced primary and shadow limits both equal zero"
+    }
+  },
+  "scientific_payload_sha256": "f6243bc6dfdd05769cab60b02d4e23c53ef9c0119f2ac7a10d54eda023956fee"
+}
diff --git a/reproducibility_evidence.json b/reproducibility_evidence.json
new file mode 100644
index 0000000000000000000000000000000000000000..03432eb5572ab0ac1558d1b1b63cad21472ca216
--- /dev/null
+++ b/reproducibility_evidence.json
@@ -0,0 +1,22 @@
+{
+  "artifact_integrity_verifiable": true,
+  "campaign_execution_reproducible_from_bundle": false,
+  "claim_scope": "scientific payload replay, not autonomous campaign execution",
+  "complete_executable_workflow_included": true,
+  "declared_tier": "end_to_end_public_inputs",
+  "environment_fully_pinned": true,
+  "external_runtime_reprovisionable": true,
+  "independent_end_to_end_reproduction_passed": true,
+  "independent_reproduction_receipt": {
+    "path": "validation/clean_room_replay_receipt.json",
+    "sha256": "cbff2552ade97132ea4fd67981915fa7b20318b7dd54ca6fe2d1d61f6d53a0bd"
+  },
+  "public_input_boundary": "SHA-pinned public source archives are retrieved at replay time and are not redistributed",
+  "public_input_count": 36,
+  "public_input_lock": {
+    "path": "data/sources.lock.json",
+    "sha256": "4a85ca3a61f18f72ed3350262622cb4808ba2a82fb113d966d0d3e44f7f81de0"
+  },
+  "schema": "publication_reproducibility_evidence_v1",
+  "scientific_payloads_end_to_end_replayable": true
+}
diff --git a/requirements.txt b/requirements.txt
new file mode 100644
index 0000000000000000000000000000000000000000..53bed5c973488298dcb668914661e3e8a79d80ea
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1,2 @@
+pytest==8.4.2
+sympy==1.14.0
diff --git a/review/Ouroboros_Pasterski_Research_Program_PAUSED.pdf b/review/Ouroboros_Pasterski_Research_Program_PAUSED.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..e4dc6a2de4f3fa3018f9a8b860526782789649d9
--- /dev/null
+++ b/review/Ouroboros_Pasterski_Research_Program_PAUSED.pdf
@@ -0,0 +1,398 @@
+%PDF-1.4
+%“Œ‹ž ReportLab Generated PDF document http://www.reportlab.com
+1 0 obj
+<<
+/F1 2 0 R /F2 3 0 R
+>>
+endobj
+2 0 obj
+<<
+/BaseFont /Helvetica /Encoding /WinAnsiEncoding /Name /F1 /Subtype /Type1 /Type /Font
+>>
+endobj
+3 0 obj
+<<
+/BaseFont /Helvetica-Bold /Encoding /WinAnsiEncoding /Name /F2 /Subtype /Type1 /Type /Font
+>>
+endobj
+4 0 obj
+<<
+/Contents 25 0 R /MediaBox [ 0 0 612 792 ] /Parent 24 0 R /Resources <<
+/Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ]
+>> /Rotate 0 /Trans <<
+
+>> 
+  /Type /Page
+>>
+endobj
+5 0 obj
+<<
+/Contents 26 0 R /MediaBox [ 0 0 612 792 ] /Parent 24 0 R /Resources <<
+/Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ]
+>> /Rotate 0 /Trans <<
+
+>> 
+  /Type /Page
+>>
+endobj
+6 0 obj
+<<
+/Contents 27 0 R /MediaBox [ 0 0 612 792 ] /Parent 24 0 R /Resources <<
+/Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ]
+>> /Rotate 0 /Trans <<
+
+>> 
+  /Type /Page
+>>
+endobj
+7 0 obj
+<<
+/Contents 28 0 R /MediaBox [ 0 0 612 792 ] /Parent 24 0 R /Resources <<
+/Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ]
+>> /Rotate 0 /Trans <<
+
+>> 
+  /Type /Page
+>>
+endobj
+8 0 obj
+<<
+/Contents 29 0 R /MediaBox [ 0 0 612 792 ] /Parent 24 0 R /Resources <<
+/Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ]
+>> /Rotate 0 /Trans <<
+
+>> 
+  /Type /Page
+>>
+endobj
+9 0 obj
+<<
+/Contents 30 0 R /MediaBox [ 0 0 612 792 ] /Parent 24 0 R /Resources <<
+/Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ]
+>> /Rotate 0 /Trans <<
+
+>> 
+  /Type /Page
+>>
+endobj
+10 0 obj
+<<
+/Contents 31 0 R /MediaBox [ 0 0 612 792 ] /Parent 24 0 R /Resources <<
+/Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ]
+>> /Rotate 0 /Trans <<
+
+>> 
+  /Type /Page
+>>
+endobj
+11 0 obj
+<<
+/Contents 32 0 R /MediaBox [ 0 0 612 792 ] /Parent 24 0 R /Resources <<
+/Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ]
+>> /Rotate 0 /Trans <<
+
+>> 
+  /Type /Page
+>>
+endobj
+12 0 obj
+<<
+/Contents 33 0 R /MediaBox [ 0 0 612 792 ] /Parent 24 0 R /Resources <<
+/Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ]
+>> /Rotate 0 /Trans <<
+
+>> 
+  /Type /Page
+>>
+endobj
+13 0 obj
+<<
+/Contents 34 0 R /MediaBox [ 0 0 612 792 ] /Parent 24 0 R /Resources <<
+/Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ]
+>> /Rotate 0 /Trans <<
+
+>> 
+  /Type /Page
+>>
+endobj
+14 0 obj
+<<
+/Contents 35 0 R /MediaBox [ 0 0 612 792 ] /Parent 24 0 R /Resources <<
+/Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ]
+>> /Rotate 0 /Trans <<
+
+>> 
+  /Type /Page
+>>
+endobj
+15 0 obj
+<<
+/Contents 36 0 R /MediaBox [ 0 0 612 792 ] /Parent 24 0 R /Resources <<
+/Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ]
+>> /Rotate 0 /Trans <<
+
+>> 
+  /Type /Page
+>>
+endobj
+16 0 obj
+<<
+/Contents 37 0 R /MediaBox [ 0 0 612 792 ] /Parent 24 0 R /Resources <<
+/Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ]
+>> /Rotate 0 /Trans <<
+
+>> 
+  /Type /Page
+>>
+endobj
+17 0 obj
+<<
+/Contents 38 0 R /MediaBox [ 0 0 612 792 ] /Parent 24 0 R /Resources <<
+/Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ]
+>> /Rotate 0 /Trans <<
+
+>> 
+  /Type /Page
+>>
+endobj
+18 0 obj
+<<
+/Contents 39 0 R /MediaBox [ 0 0 612 792 ] /Parent 24 0 R /Resources <<
+/Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ]
+>> /Rotate 0 /Trans <<
+
+>> 
+  /Type /Page
+>>
+endobj
+19 0 obj
+<<
+/Contents 40 0 R /MediaBox [ 0 0 612 792 ] /Parent 24 0 R /Resources <<
+/Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ]
+>> /Rotate 0 /Trans <<
+
+>> 
+  /Type /Page
+>>
+endobj
+20 0 obj
+<<
+/Contents 41 0 R /MediaBox [ 0 0 612 792 ] /Parent 24 0 R /Resources <<
+/Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ]
+>> /Rotate 0 /Trans <<
+
+>> 
+  /Type /Page
+>>
+endobj
+21 0 obj
+<<
+/Contents 42 0 R /MediaBox [ 0 0 612 792 ] /Parent 24 0 R /Resources <<
+/Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ]
+>> /Rotate 0 /Trans <<
+
+>> 
+  /Type /Page
+>>
+endobj
+22 0 obj
+<<
+/PageMode /UseNone /Pages 24 0 R /Type /Catalog
+>>
+endobj
+23 0 obj
+<<
+/Author (Ouroboros AI System) /CreationDate (D:20260812180601-04'00') /Creator (\(unspecified\)) /Keywords () /ModDate (D:20260812180601-04'00') /Producer (ReportLab PDF Library - www.reportlab.com) 
+  /Subject (PAUSED research / private review stage) /Title (Advancing the Pasterski Research Program) /Trapped /False
+>>
+endobj
+24 0 obj
+<<
+/Count 18 /Kids [ 4 0 R 5 0 R 6 0 R 7 0 R 8 0 R 9 0 R 10 0 R 11 0 R 12 0 R 13 0 R 
+  14 0 R 15 0 R 16 0 R 17 0 R 18 0 R 19 0 R 20 0 R 21 0 R ] /Type /Pages
+>>
+endobj
+25 0 obj
+<<
+/Filter [ /ASCII85Decode /FlateDecode ] /Length 2206
+>>
+stream
+Gat=,9on$e&A@7.bUqSdFtEH!m05RedhFB1T\HOUo[!std2'&$WK<>bpXf-K.EUH6.P?;VN&<&(hTWWX1NYr^r$C;XX,)5[d$pX@8lFC0.%*ln[/#\FCgMO=Q*a=>d`IAaPM8Zd(U-(4lZW:8Y9s3^Gd"tU.4$K..8BW.j`6O.(>.I(FE<cjK[,h=P:n3;$g4@/O,?+n-\]eP]!l9i7J.[<51/M>)IL2f7"=.`)62eE(/b$SB=/T1R9f?9Tsq2K6VphMb0:qL2brK[`bBVVpVPVtHh6)nFlS0W7Z3GdMlIP-YA&=jIfA2+ZSg;n])/o,m,m70kBf](HqO]-QsTA,3e4;,K**852]lT[Kp1SJ<W58XGCMf(pk`f+rO5a1FheJf%S@f<Z+YNXg3BWeD5ji3KWT2]5.L`CRLDGg$moeqSGcfH4itjtGq1ZMF[1l(&>8hV2QTt5#'9Ae[1lP3RF-;DH'slC^c3r?@n0LUg7'!f*:ItmVl\p93Ck+A&gL+'.nhC.H0T0R)G4FZUmoT\\oD8(oH:SCBlR!B6K^U1Q3+:D2qC]ZJbF8%COcm+k%djUQaObep*$bb.8F>Vios*"G6"MVG)s9Ofd#_>aONUmY(G>sEojs^R3r6.KG`45#-\[[PqP+8cSf1=&h:PC/>Naf0\BdsIBD"mlGDE*fZ33<Bfn(130BJ#/kLL(D"gnG%ED8L=3<$"gR2b4_Lj59]&\Pc*]7!s'0P>d1o86u(&F$pGW'@XN]8G:U.eaoFt,k)n<:0?5j0&[0p!8'4j5,G?mF*\AN]/F4=mgcS<uoL`eGBEm/t#4';`Uo*;SI^(6ETgB1&Y!Ygb#*V2*J(XRT`$s"8uFb.V720_rk3>S/GQ4&F,BYr90MR4-`--[]F!pCVbU6oVgkScgGnBkL-TNih0_7ei?@][aUtka^ha:?\i3R7TOZC>f4,A_VlKL!1UogMfhV_Uks"2B,A/Do^EKZ!!!e$Kt*MmnjNpK'54"d>#Sg&)UKY_M<07OX,*h't^o+=)B]i'Lk_V@"hrU2?X7?%tSQBL/D;chA$cpc\=ht[Tn2c1`"Q,6j#k?9lFrg=.tp<+_+B4Pp7Od_1BAH:s=N'Q93(PL-lCd"lc=l0/])Pm&1<S,/1-#fW:0`PV\K*Fse7@!\%-o%/SMdVraGb\jlU[kZIkLRj3/%EX*]NiKq/rXYbZFM'qXsl2ZKsc&_o2JNAI9BXA.80\-I8!B[fXE(V1JeZq;mStuF9Kj"M'/e7]RNiLIXimB5T)CR">ENX'OY8]HW3\8+T;ZI_=$$M)IX+P^).pF(gAddQ)/-[9'Eec&WG/62ACd=E8K>`*Vf!Zc*T0P]se@tZZG8MbF?Gq/'S>Rqdj&9o+JpA[G]JgjgJGhm%i@6reXLMC>lYHgVb!P7PhD5*ul<%d$CD>L+b7r,;(>CZO+ms0O*[:%E$?9]Gh%&*70![j"0h94m6'";Not!9j7*pHEe'A\1@i^plLA^M[W^7L_"BD5`":B2">1;gG"=7?G1PV8%fg@?al'+_0qn+>Pa?^[nPKT,L;XKC`E,(Gp%E!msr7ZkM_(!/@g0\?bN-hV8ZpqaRVm/0'\E*0(IcYBef4'_Nlt=FtarY,sD%5ZAJ]PRSkDo*#anuCo%K;t)K@o%`UcD]kV)_fl.9F)S^1GGZT_/cZf"+2u>oD-?)\jT:"mC=>BX7Uq5'#\'c'IH3*Eo$:LCkfl@Ho\\d%F7W!TMsZ0VKGP=d3S]%gALbJl8,q*?#:;';tRg6SFCEYp1&Z`BrCD+8+RP'XM@.!&R@M%5n`SB,LFJV%=5E9Jmhhc8:In34@QrB@IE7g07LeY%pE*XY`0YW;9q:GY3@`Nh"@M(KNrJ1`t%b5l6fRJR+Qdb`)<<^gF%W's]0e5n9uNaI4ZoM6,t&I&6brE9<.o!cBn!DLLoL[2ch"e9ihSXf;Ih7gM7J&ArDLfE.8$hD^gm=s:eb>%.PHW_-Yajb?,Hj,R.i['0)G6/%5GC9,^Nq;touV]^P,k%s$DZMH=rh.;;b'rO1d4jeEJGf(Aha'!6;Ii\AiDmnZ)"!>@u5di`1hqQTFL2r9c,Yp%+V(K[_2U>sV9WWg_GJlYfA1t2rOM@1-q_Yar?A+pjers\BgVm\]:"IL@-F<MoRaPaG/8pG,c-f0kcV'NtJ#DPuoD:8UH1?K6J`tM^NaL(5B.N_Hj5^MoHM&r0fOa%~>endstream
+endobj
+26 0 obj
+<<
+/Filter [ /ASCII85Decode /FlateDecode ] /Length 1194
+>>
+stream
+Gat=i9lK&M&;KZL'm!%bNag*PZ("Z-9n<K%mM>?Lp-MV$M/,^_8BQthlhaRXr/ki2?t$j*ki'`I1XD"hRc5"Thm+I&\=q[7@u:rRj:oq83Gnbga3E0+<BOG;P%[:.a^(.h!m[_B\Ljt'2*Q9&rG(gYm6)c3ca>U;=*;\34/l4c:lAs\r8QD\6L0XMd5oRI?YK&%2BP9H^[_+CH9=UqiLf6&K!*el5D<rHBG+;i<)Jjg/3IRld]dj>*!EQ`]gt"Z-%*i0;Gq1[Cb&I*dGo;+,?)2\+ibVTj+F9dP$4g,d@Mr)VKL]6fapR%hN0OqQ$eda(A9*RcI0=O._E\CR,d-\FG\^cEP0h%WR4=)L(!^c:`B?K>dG/KrA,i_`(V$d1A*q@-LhKBr.;:5j19$&AEWMaPKH2r?6Sla$YIhNKP$JoFWW5hj;;TaY0!do64'bon1>,9/N;6kX]2!;NTd_]=as:KeQ>ZcTO=L[I%frNjh#A:bhi4ERJf>]o7;Z"YkL8]H6-Z1rQ2c1f`ah7H\rSsT*K@Slo*I-:F0b@Wu[B-I]+e%`d-(erCTeRU@U;G3$dR+X.0Oq^)pdpjUoVdAp0u0gqq,1)8erid1qq?ZQh_fZ_?gmdYrmQ>/:Jm+%YV?6:\qt.-D0NH<mSh:P"/7<CD<SW_CDN0WUr?7keL'l2j=KT;nK:._%/fU^WQ:Bh_fr!7:mMb#k+40gi5[o#>@[b*X<=#CAP+-YM/3(ViHU/6WjG3s7a:j\!Tl+n9I@2B+(`OX_AD=E.ngGCe5^i]SdRl^t'V2.^3-)<Rd"U-^058jf?jHa?U'rCkg6\!9-B'=&/eC>jhG82+Edd?DC'Dm=1_A$<EsK$'@V'6!625WP9Om-?!TkVMLXNAq9e5m%V<<ES'rok(%n2pag'W4bc>R/=,NCY/;tLmN<2+Pf%cq)0W8#MT"Z1-,0DRD8o.O44H9E(cTVbp6C7%3QOq%(u9q:1,fQg_l>b?Rk7S_^["pnD8/%e!R@j,C2?&<^!p=XF/rZc&S6])WfeAN'[#P*%mC#bH:)'Hj7uCh?`9G\u+C^Ym\4gf-e4i0Aojor]45CYMX"ONRu@@U=joW9aIraF)i%;RO(hGbH=(=etg;(7h;6UW<:$QI7o_bqXX.Kl1)5-8@LiUm6]ncmhG5Gj`7*g1]Z;akGr*W04E`cB8P$d^F>h:/H~>endstream
+endobj
+27 0 obj
+<<
+/Filter [ /ASCII85Decode /FlateDecode ] /Length 3299
+>>
+stream
+Gb!;e?$"c3&UjDW5i1Q@OX<UkU69M/*9X*1;`Ba(44EHEFU'*6M()"E+DJmlofW[ZU_MQmU;$9>N^XPqmUC0TFr0)\_[e\Uj.*A52sfTgBA@,Y$cYOmA2f!Nmr"0"*:]ohaEJje$+T;2^sT&M/RHosjiB7Hp$rATH)h/_F6N*:h<9Yc_]X'Sqb/Qa<OudGQ??5na6_qE]D7/fIsS2/*)3'1?lY.!>7a3R"AI9#-MYT6S!>NNX(9'+9VcsUb*BPNeOhSKMPXiu@D9Z(?]0#/Ydn!e/aYWbY;9<Q-E9b(/q^)-Q54I@-[8_N=(DhA)RHhP&;+=eCo0.Q?YY_"eH="UU1-Q^9:a'H_g%JJYX6l$Q:%P?[&RYgOU56f\u_Dg(#PffCjd3Wq%\XNW@H%6Sjco#-EUiai>(LNF1`<kb#2gZVs+2D$^"l[CK763H3[G,V>N/h.clI;F)k<t"6H*'V'Mn*MQO^7VTN(P!80b'P;KaLcpU*^p,gqWKiIgt0AW4Roq,F?OSPZmS_@Xt]kPOg*1,\q11oa22(iQV-_;9]OV]d.:YZPT`"p*Q$N4eP(bMUX5kqcnh!)n8;!(NniP^Ail,4Ztdrl:`d.R9%4*(;`EJGU7IQ2Jj4]4:kq'Y:paEqBR4*#U+IUYWlEd;.e(m)o_9-$M-\2N.*faT$?D:BRa$F-14-oJNe*n>+O%NI<i'9SM.IE-g:=DKcq>*TQU4:=gM'4MI&F!6)3>Z><6)esY!;_\0B1gM'#peH.YJNHU7H<?V_DRa,sM//gdXY"6IHUMJa(Q1sd::V.FA61^N\?4)dp`&WYLH+6QEuMobX1CiT#4X%GW/.'Ri12D<L6d`d)Q.7W/`Ek?]Lu71Ae1uEf5%3KL99\l&SDWXfQhEt)m!\mVmF4X_<8pV0W!+QB7k8CRqB^Mr_%Y3]<?\mfmR&+/>((0-&T(R4$M/5<l-<il<LLq7aGY"O&K_:Sg,21F:NZG:Q9G(gpQZ&)^*F,m+SPj]:qW*b9U3%HH"05e':saWI3"JJG8(=]*.`/\(KL.&c/-a*V7>.f]>C59qSg1e3.XLrR5HWfRuBpEohUYQ__ONec`Q$fRl(Hg2G4,=@6?N22$&qVVqQ,E'Z)k8PW,e&1Z9L&6CUQrHO#FA3qrGF%HgMa%h:WXm2_dMM^`%\lT<6[aODG$L(/1=G(%G;l%C\js@<0)TpNIPS\#d"aDCs?JYIE\%rCF?:K<flX*qh"J_;*B7nB3LX2"X!7q#1cN(.g++$*\YP6&kgR4:lMmSS&".Q]%5BL[o,cVAWUB'i^5T3k1Z\NF,GALZ%/[_OA-F0SA^gMdB[Y,%C]Qpa"nmDA;N``0E=SJ"0n.m+\N;RB$S;bH/rr(4e,+'A]gB<Tn:XW-AJp(I(/2Y/m0r(%-jEW*:94TTTeV]IoHXYHMkg'5[s%q;CTX#h3T)>4DS1c^n5Y_niA^W;[\M^oje,-q'YVBcB^/ZePi\i0RDY7gR^7OEYm+@O.'JGY27`6"\;@;eLZl5-rI`YIF[$JIl=X?g?*LI\18RZjX44)7W6oDFjq;O9,n@,27,qt7%R!s`5'GIEle30Uk`]^^qK-*;5j=NTUT<0u]:^PAZ!%+5nXL.?:Pj;Eoi+TFgN@::`[#H'_o3IAUGd7i??6:J%)a(f;f4n/C(Ga1<$P?7?lR;i30MH^*p;G\`iN4_+G-jf:/a8-FS^L'!;JdDoMAM7lYD`i.HdS3-2$g!g9;FiWd\)-regXo6]@t_3Qn<(k9'Eq5"HBW^_]CI+]cf>8PFC8H>,XsqrP9V2_Y\mm9U0dS\OB6D!;r,3%q]9QJfngD=l1"gD'.'3]_Kr8]0]Ce7+uVU\LJ@A8d"=b[N3^?q9SK#Es_>;[*W_iOfK[O$p3m:;"m_^rZ9_^dIcA(rd+<4+H_qsYH5@#FT[=]%$&!<ds8/o$FO/^[WR[O08Q*@O"4<`l4O<I$)!T:/@HO>:=7dU;1RlYl1S)M&E$*\OfG["(ji7AeOnoDrE8rXcW0[b)m8R78@pQkEJrNQ6d1+@%@aUPm\mHAL+UkFTsGHh9GL+^7bL)*.Z$iF&_[!PV\/`JZ^)]&4JF[EW<HQ4aTkKZ3Th'W(O-U[O!B_SK:h&A4jV%7_X(s0;-5#':aP0ZRsAcQBbCoP`]m4Rr6U,`SNmCAUuaWN%g4PkBMfQ]LaG6eJ=GgfNU7T+?sD!hD^]9O%58)$)]KgDoqDFimb,CO!cn?n5kb;0'?K*u[4,WWE1%m6@h(`n.314Lp,0Hh8J%7\DBs'-+?HdjFW2'e&`.Bb`Yq0IDAa3He7=]H66Imt%>kGHMa2`)k-hn1f<dan!m(dAle3ZaX$UQq7K*RA,EKI.(QS6phmAGep7t6+N]F_m-)t-Q`b<XQHb^Hf_inAN8&>s$7]tebS7.ZlraJ)eKBAOZ/^iDo(0eC$E*DE%$hV,%=P6*mXIDWKD[`$Co%EPImKB^"iRmYkg.\Qho*bUNX_m,V!LN(SnE`f?D+[h<0t`G4bt2kQYVNn-FO'=<$tRln[>Fooo_"tC[p^<1"hSL#Oo=<sFZa#f[!8+lEUNDEO!_arZKiilJcXT"$'4d&0Us,3WWiU?*B#?JGC%!FXA%'t'b+ON]GEdtJ3e9r./qJE2!@hkWAATmQ6;.7(^&J114metNC$Y+^d_<;)-MT_H^QKf<Th,%&[g0"P7X#4OP!:Vq,P@JSg(F5j:^-jam9^GathYBSu:58H>?#K2-<^1g>+m([A#Tr'<<%1>4`l770c?7%p9@LB,_AGPYV!Z[G9noa99?%R>J]9UQ82INdAO+mjfltIrKMClo\RNFBA,M.IrX^(r-?UX%%Stf+%ruOd]Z($4JMSh3QqLT9^"!-1`9A#PV0Z[:L:5PZsT_%7>D`Oac!+$9%L4'f[Qm.(6cH^]]!A3MO'b=pYWdTs4EK,pH5EBkDGS4/<M"5W*A)\&(j[0$M__G7qu[c&$M.i3b6CoC<PL04tA4dd3_._!V.;ID=eAk9G15MBY8qm_n/70umodomCrUiQ1[^m!e9k/N9"Vp,QX7VT!?-H96&XSR/c'WR:FZY%]W:D2YrjCKesRVM/pJm!F%nhjOq^k.Q%X>Kf67dpen-/bUsE[b0cO`S@.E/`sT\i>Yql[!?G)a6[U5fZk]--5![a32\t$&c8s&P9ASdfr)"?do0>JIb7nr51/A6/^7R*F/:^2mb6Hh=n0;/3*jr!m._0op+>fN?)aCnNEr#:c"=[S@@(WA?,(_ZfdJU^jOGWB0&L*@1:i("pJ`t$[r8FX'gV[VN&iPWkfSJtW3W2u!l\0dWW~>endstream
+endobj
+28 0 obj
+<<
+/Filter [ /ASCII85Decode /FlateDecode ] /Length 2320
+>>
+stream
+GatU4gN)%.&q0LUo\2>CPNGRRRFuCV`lVb7CG3f^1YLT)eJ(\C'!`e!!2(@WfC&aVMe#Dff.!&'&sr#UpZ^.$KG<>lm/@b8d>q@Nr_l?r6s!"g'0i1k^X9ZoP:n:l^N(+c)9q3gO0IU(j5*JVc[7_Z\oG,=J^AAc",Rb77$-9iaK1-FR84X)C.`A'-+Tq`DG*>)TaQ.heV9G?R=7G'TBYX;[HHSajtt8BfTa\PLM[BFUN#^q1Fh[K\ls0QQqGX>RdPi3e(pH1qIckiNDrdhf7r+G6Eg4%Vb>^CJlBQ*Y0Mj&Iu.AB$XOc\2J5uSOqp\f0I(+fq0G@).k?Q[XEj?niH1uOChn[ZS93LB;Ai?8BIS04',36<Y/m\INS,6[afXNjQI67`EfT`5n^K*Ri2MCh0_K)(:O\BQ+_'JepbttTlf#2h/)rV^k;3PZntJ/:dIJSofUlS<O:M_2+lp0[IQiZ4P5IF:joGVIo4XHN_kq+55t/73%BQj`\RD*&$SjqrRaa%6rGZ](NmphY;8#=XCnY;c);qhL*jE&cCC=?c6'(fb9$-H^^bnDk7/>6/Koli!ZW2E7$JD0mj)!kU!(;cB5,9nqW3FU#o6ZRso+C"BmPoU?LbV?-h&PPJ#87rop),t_`*l7B_lY@2ZEiGC;66QsHAX;-Z_^L8^kb/HpUqWmEsR7dGCDrfV2n*f7V]ZAWQ^Y%6#Ps?SO`'hbA%t'mAQ]5J7*WXjmn*^7b6G2V4+p1EeZKnE_V;?=t37#X=A2)&)A<$_@5Y$QDu.&M2e!OJR#:$IETd!HRmZlGBdJacGYV$Z5;s]'rs;o6F0Rkl3\f6O4/u=99_mJ5^,<n`om]:GKcAR#*07UGt#K,!>79g/5*NOXBE0bE#u6bqMM!m8GjS;PB<8)Y\8Bkj]cst.UH8T*M&i.1^q;bmJh#2PclXH]9#k0cGthR^ki/*%mhQ2j!,\'I!XCY0mD%Z2%2uc8Ab^[L3b`2]oWsBO+K73+FZNV%\jR1hh&8%26Rq)fhr>I>]mlMnC`WhM#PmAEr)6)G'[c#.&=R@otp=qqF+I<8+R1*It)`l>.'_72dgTNBnTQqB*`i][L9.iiOLLB@hX[MMae%X(m+lrW&[d<EW+=k"fe=G8Cj4K.bWY<J.3")24=:!;rN%r2N;\nKk=:nUMULWo[0mTA(Isb%S]>q(MfP>rX8q<MBBWU)#@YpMroARG">kYVT"NCJQct.&#VS?O+KB=.[X*#+5sil@#fY];jJK>jgDQ/i!^(VJFb.cVEe9j!iPs9M#6Z$3DATagX!_-:LHHE[>p0s;>#@uRQ$^D/+cW_:T&^1Ynru(CFa>>)^#U65YJTp64-a0]Gs(XHGduJmho<PV=c68.t0tVPoX0TaA[G@W<KPU!);PAJ85U7h=CnKDETj4dpqkVj7m#jUV4jB$K.OBr[:HYVeD'%?.tGFWiU?r`Cb>EqSYgN_q"%aaX*;)%IY$,L[mc5pQ=+'4.HJ:+3`1Zfg@\#BL]Y]2O*SQrmeNHDeJ>hR/7CQ'$%hZ3,hsK\HHm!g]M&PZ=)cj7_/Z=OPI!lh)i^jOQYMYn0=llcT8")U)'#rGI=d18Ae'g56Re:N#7D"W\hJ#$`Npu`Tt[)J$AmN;<"J?N[3-VRM:k>Dko[*Kb"^APbN[a80R$;>01qFPlLu-U!!fHge#@!c*#Goh[hr*rA6OeCA^<C7l9K!F>ZO/2"Vkg<9[jTYj;iu8!^-<.%?j&q?']*RK_['-m;2;L=n7BM"PNL9U8<1%jGO2od*gE*ud55\s.N=>hh\roMkJ'fsBEII%S0QDEpm&%>(V-f5eom'C8#%D98#b)YaAfQp63"3#L<6)3)&\<##Wh$\p,!jYR%Q7NiP_r+IFeX$fHV1W/GfDSLei[X4&'H=G)86I.9C\E-(mkqf^.U?qaBVW>0)Ak5$9ll/ulg^/(sAPogJ:<XKif7tX*MW@*ZNa"&\h/@RQf^#2o(I",hag^ssUT55l,##V!&a6m\e60$C\DNq[d>--Ne/m[bZk%@[P`>(QXD9qgag9immQ,MT&>)bfJ&Um>'0i%!=d5"4&&LF<nNY.Cir/HI`/eMP[rm0tFl3,b\YRDd-KmsPSWR;mQ(("FgKf0u1YqXVj6eh\N-cUXm$3;E[nl$tGAGTeGL+0#G=CI;\jn\#L,Q6;<UOSUXuNb[`cfWj9lhBeh$h7gIfo>jJ]_H"s0>Gtb7?i*I2dCE`L#CuhV*=PaF3Moh/U+'$XIYW!TRHUd@<D5q=X=7>75ebnS!g+Of@?k-E#k4K&>N3Pc_Ci@p8uPVb&d\q1,<+m!s[_rWgGlV0)~>endstream
+endobj
+29 0 obj
+<<
+/Filter [ /ASCII85Decode /FlateDecode ] /Length 2062
+>>
+stream
+Gb!#\968iG&AJ$ClqpMPRW"$XF0M429dZIMQ-scOC,un0RRf\q#!a^(YO;N,.ERmM`9EtjYmFljh8Sfk&'tOlJ%klRPlMU63.:%D+2B-,5B8!9]R^l_UY@#C[5*ab$:\obbAl,+d`D/Qi;33c-K#(NDiQ;P)>YC,MS0:c?jMo^rWIM6heGG2$G-IuBD1")DAic$'&5=#L)r*DLHuoVrMC]*SaLFMip.s8'#'R5mtL.pfQZ@]>j_IG'qO#?CUW/Pd38kEU$K0GgYCobp,?5(-*dhbA@SGtr='1l2H%bP'FNtrA`A`mjY9Fm_;pFbEK.`@(dA;]dGmZD.#<Vc4K:6+EMa((h^^E$`TY6J2!b4I8#!asi)hfkUMpPX-VCY6AOJ=O_.b98JB.&Tmj[3umO2embX9]N>>9G?]sB)g.R"\"Te[j:BU).o\.D@l-ZTMcjP!HKi=n&0/Mg-4ffTc79OF!QmLaeKOQqR#2kUNcXNDiOF:PEh<No^Y9?DjOPS5VoLl*io[KL5(i8Or#.;*]W4[,DH,,j2e(c3bBl:kr8UPOX<M-MN)1(A<I20fOdejL-Fk>!U2V)O&UgbK+F:F+CXaYLmjm<R")/U-EC4,OEBdJFCiP"N?AO:hsVI]]0LbS.suKuhCd)g:MjfqIL9cJ_Zc,t34o.\4b/eLoHd3.is^&`/f^_'Q,T9PBH8m1l@U;l*mg>S/R@(JD"Y,6)%pB+RIu`W@eaP;VUQJFs?7(LtRP73,*6Bm:"WbOs<@2rK$p'#SH_6*nmPYGi)Q?LUrKH#C+s:.#iC3Hp-E(Fcj>;@:^s1X6`SB-0JCF>oJ2_($oF5hf(%PkGr-:CqeTP"Og;N?`IW5*g_Tdu<e2Ru\3='b$I]S:*]EA+$$;]7JKQ!T*/=$Rn_(*E3K"]H95so_>6R-j"AEAB7.OVG&\OkZskWnO:r,=r48m6HnZADYubd*%YJkiq`3AanriEq1hf5-UTif5nmZ`>Vg.(bUtU#(ku]1%.?o@^-oZm=+P?>8bipfZ0/`j(F?m"E0<'_,cr@m(bT#aFDqMdhR?r/.mKchEG-B'(sCG=(T$X5FZr`,;=k*m550paD4J)5#Wr*&(j<=U&R_`1<P?;SVE'NE-Hk2lbbSMIC/_ClL:.D5;:#Y^65O;Y-4,G2AN,<4Ho#K#@Xio#<<#cDSm&e/:ACe;CJ='rM`PH*PFXrl"@=1Rd$PN^:AUt+eJr#Qo:'l&MMmE6KW7!/?N[]<en@FNd(8qXR>jQBhhT8Nca%?O*CsjjH\<+'8fEE?[eZ*nl*)YtNHHAAR$nNCF6%P)dW`aSWuNW3B4u\DU8&tKb6=O4\sO1YEFNSr]`)V+36,?ug[GR-0C[dC`n/L!RU^%Z]u_'mo3238Ts-UT<($*YF;'rSgEd^gbgG]5a&(02GmK@KgbhZ-LCOu=chKCT^9'XXI;!4>1i-b_M!Xdf=s2B"b=j:[[B0PC@%"Sl&gYl=injNXmFWLQPbE:D2=:-$P2Pp,ob^5V[dO$'e%M#GY=gk+2,'?2p'mEFn96d"D1;DO-VU7&DjuX/l[h7jgaGUpME+FqWY2lNA5%S2L<82'Y&i@U(aug;;RL)*jI;%U$6>MedVZMJq8(DEj-bB8=ZEPaa'@cP?%Y49)&-KHW.e]X*Aq-@N%!CP!Y=at:U^s:9sW++"rdam\BSPd*\h062\:?ockh["n#Ym0nnkG2ndsl8.s_Kl]57C.Ge`SVN]8j35Rb^<)fCeAlQaY"eZItQgL(]OP^"Zh)5nPrXV]r54\GYXTWb1'\^Q0<mXo3iqVss,IuSrMNnbm$NIhGkU$&<[?GhOqMEUBG^DsdM%#^)u#,T"E[ponX9CZ&hhU[Xp[Ap(lg>.3kBIW>YVqA0Z.uG?kPkH=g952F0`=';'*-JU]UHgnXL[DbCO"f"@<paR!YL&R:6Yf2-g@[TO`?nh7J+_(J\j_e`c0?pPX?JSQiQAU&[4Rt^42]!MR%Qn)``Ilc="mr1NHh&SjUC":^E:48DX^#MbR2"PfCl47EU&S3Ko*X8c.h`b!+_]iUU?>1-IUm*:r(JnrY>6%~>endstream
+endobj
+30 0 obj
+<<
+/Filter [ /ASCII85Decode /FlateDecode ] /Length 2074
+>>
+stream
+GatUtD0+Dj&BE\k;s_,kS`!VijrqFp9TD;1DgKm0E"=TWf+CK&;IR,!9u;>TgQh[:+ZW^e9Ydp/eS=d3^Xd!.ieP)5F:Ia*'JA5r?kH'K^u?Jkl$IY<4o9QFWh)cjEAS+#fH'Dbi@&;S#Q_i85p([abjm=&SimiuV^.4p)\'Rg=?K(moVjl>_d;.B@6me6#t@L>-6X6!j$AJ*7tW4H8'R]5'X33UHZn)HRCGHi7c.gE0bt1t5p7i>d&rl,adMJ1Ke@>l6.fY&7K[bg7;[5_CNb60:=j/+Jg"87dJr[/o:\!eVN&#<QT!A5@CFKiH4/3b1rV>$g1aY'"iJfeqJ4%XB]g&;i%l\H9$EotYr>?1gsL(;,Or^2m*Q+e\hpC:$V2#A<\@q*$`PqlW9<L)EgteoS-Y[.S7sY#r<W/DH.'(gHP-NGmgB4)'7)IQ]dI_0!gjZkABSF.1,4RSX6U'CjBO*91dUSdCa51i`N`]^4aGP.C=XCiC58K=f'AaJA@@.MDO/Soro`BHAiC`R*q>_4E$pPY]^lTI<:/KIPf?S)PsWa__r`hk^ZgF7^=Q)7bhP<B#?r%5(91Z7D5'9Zi%M@%/&&uqFPTb5fjukdAN#<t2B[fKi-Wq,_(fbPr>O2!&E3$O=GT(#QS:>P][0<ho9E"C5\;V3"o6rT-JoRhSc*(bQ!(\M<+iZa/P>&M\1ZS7/N9"-To9.+9VOi-1aY%4Wu+hehMY1ap!4X\08XsocZ)Xi''U50A1S9qA7BL-Zr$g5TlAhNX)9C]WWXnn,OW1E;Q1uMWA'&#mO5X)s(B^B$!4:p+JlJ1;#+Tic4*Nb0q0q$#`r2hf>JHFB^2m*CAK<umfGT2(:qTS&:'&9VG3>3g3P+.F!T/:&nmOG\8dVeP)0tt0K4Xc?I.u>/"R&4<dA2_nn(R$<^P+i19>,uMDB<8<5f:EVB"N^]bBNFe8,uR>'N*X9`X&X]bX$_q0T&0@2sqt&gdj^0)ZV\#P#3d)m2SpP5"Rg=Kk#M02"d4CMkeUfCFjFE31N>gu-2S@EH](S%gE/7+VnYJ;;pc,fFcc'QPRA8UA.k\7J+>-F0^,)h/\BZ,T_o<YD=KZKn3Q+kWp?FsRsDH/g]#NCna1&ihl5R?Q(L2V32k8dd)g>uAbj5n_>*_Ru7o>i6F[!EldH'SppBL"]GnPT8\]B';f0;jg^GJ!Me?"akti_hMfKGTZ%4-+3O7"Y8hG8AC;=/&2gV@L'E/pKHa>f4/ZVE62Y4,mm*L2]]?8?/\an<h%-#:Jd9G+Zgh&""LVdD?>M*)H?EMY<r!DW/lbq'1n7IoJ0EK:@JZhbOjTRFfTJn4<+BMaD-G):<l)b\[J;YXWr%G*0IRl`-C;X"sh4j!HJJZ:OAA1G]tJA="q9PkbMpN_Ti3mViB;9MoM"FU?[u1;3d)%^/:9:P!li8Fq/^HM-7b/)]F<tLe5"\D<kG`HP0^6p.0G]Ua29t<3=^'^;Pm<,nH2QH]7_FWF]NlC2jljD[$.7;IS-jV.:p_JI*s?<29XpZolNJL\:2,kon`nE"oO*5E$)nDE!.W-=$!\d&m`7];NNF5ki.,!rIG>P5qbMl=r[Af:MfGMRN2E&Y>(oFU,etneA/iTk<k)=26-H[oXRT#.?S[nPM$(..)>YaCV@_FQ;gakESksqIam.Y5U0=<3`CMAW"Fs"?!;L@De$eLOTIj/E)dk-C/=X,APZo\LVT=NJQmhA)>8L@/5akSGedE/*6O2$]57]-04tL7k/Yi=!-l:EfO/K,@tkN<@1B8U\K@<?3>`"QrBM(dHUG+T9rBJo/HTZ4U_,.E#?P*$pll;j2:a:*ardZl0VUb-#g?bSmh#Xbl'E%_R5'Ih/MgX\C\p55;q61T("?2\nQ0Q+K?3$?+9T1&&-"i2_FIr6Ik(ulPB4M_)JksJ"Nthjo]nkYBG?[3VB:.J(:u55<pTiUl&=J[cZ<86^Uj!i;Mpu7F8*pgN2mRWqJ5%_;I_Q[@Oc==79P&[08&/9b\&pj4,68f<6k_/.*TP,o;X^X?A<,N7^[@LX-0P\bkHm3rtf=a2<(dO4Y3DHXOYBIqdUCm/~>endstream
+endobj
+31 0 obj
+<<
+/Filter [ /ASCII85Decode /FlateDecode ] /Length 2092
+>>
+stream
+GatU4gN)%,&:O:Sm%^(?1r6eo8S9$`agBMR:95_3M%U=eJJ(kD:jA,iIXMaBM^6KS>^&$5+9L1YfKD2rJru$'1]QKokgc&\hCrCKN>#cmjjEi63ZB1=4CIPIh]pGV/Jl=pe?VRc@hDiP?XZ3c6cJsGa%4foeqe_.US/?!+XhU?)uA"nE'g`Ii%rPpLKGeYJP!.:JJ[#o3!p\`)tfC7(RT)9g9So=hJlq=4HHbj(ph)7m2BKDc1WBn^tC&Rc;*"SEhWid:"2(6Ys&9Dml5q;LE^SHUjrD1KD0M^VQ*H=c"%]mPpgM[C&EV'ca8T@poN:*a0DA:]DAhk's7FkZJs>4Q4#FZf:s;\<e+^M#l6n0fprU+<*dFoN[RYJ=is.P]TObBUX%`sbO$D/!b!&6n?`pBhh>p"V!m21@Y;;t$_u'X)GPn?CG[THkVQ;9Qr,D4XBtI>=GXI>apmfl\]@2?5l$q53fi_p[ZcgQ!G]7Y'WZ&<MFp]jP@^I<A5#X]hW--g6L#/W<Rt;EPp1B.),(6NaKHtHqKo6W%uKIt-AT$@qi2%k=#:K?99kDT$a'Wp_^1(.=k,;okHE3&k-2sK'%]7KW4GmE":\@-@1iYR<Pe8^D6fN!/$!`$C]!k2`X+_uDFMGP[.%U3#W@:_7B^4H0qEKEU5rN817@.@?ZL8t5B^Ql(:a@TlVnPcR+AefhTk5u6o/%'cTM-<_8g'!e!lH;$PEDEhFdt?dWV5)b0ZkY\\prcZ-$!FV^e/GVhfQ0kcm#S\X(c?PEJ(^A0\RIn9aY`mQkoWV?iW*=U74=]\k;CFZ_'^NeC4;F<[QW:g&kLoJ-G5N_V7.7A4u!nuM*S1)Yb_jlGpCoBk`l$RULgrq5X^/RQ(gkON7;dMnWbnI7!)IP!@#!Ek0cSgGDeRaia3efLYsU#.<LP<&@AbFjb>LN8sI(!l'BaKTrMHSd*URcp#.':g@n9*'PnZ-1G.%P6a3d:e<+%CbUdq<QPe`C9g3>\(SIFH)51\e&R2N)]o;WM#M4.$G5FCmR<gEi.rog36MiDSZ9"&WrB5K[]U6eKWEKFN$o4Pjl$o:s)]$^k7iYQM)c9Lu:'@hk`p.0NB64NuYK(UBa9I['JbmTf3jiKe2oPEtp>D*-,:t<M$5_KjeY)P.Kb=lk;,;Z8of:=d=Zh<JN5.q+;/uq/`m7Zk^E8<+6])7@Csr6G!@(`(\DK&tJcRcn<-thdVWmq!0Q-n!@2u<DcYgMY0I,2><h.O$pNOCY+=>+L9Z1Xih1QR':&M:#%Z!/5Kf]7slCQplW6[m2k3_aJ*l&;oR"ckBW6A,2WBYZYq0iP3h.R`/pSH`&%mP-nTAq'5Wud?qY+9ONa#u-MKUg^/W8X\o_XWZar/[C&Ha?Bi`<?WDmbD<`=!:deQ4u-\GcqYF"^l4%GZ`-*%3+T/BD%LD/\i.03rM$7_8l:!U>%TJp&s3R3.`V1uOD5Z`cM,1%)6RPoir8/ul?o70Btg;OPs+OnBL@gIL7/\8#_Kd1A-g!+9QPUV6k'^0LHnTcbZfI$,Me:rGK)?:.gWP.6/OubqV<7S+348A-Ga7@iAp5%f.r,lgkl]<%EJ?CB[!%7%X[eDh..?FM+8*[Nu_p)+j>F2[;^8-Z[P[9P>GmS\Y_r5Nt_.WK$Z\'/2C1kD8KAQrLSWQO[TXoXbkIHt$UZQt:ZFp8:QF+LQN6Zcg0E6D0Bq^\kh7c^j/e^f'L;GEq)r3td@pIg;+dogO5kCh[,5/;9Y+#(!aR<>3Pc"!nXC<u04fU/E2K/A+6?K6F@ZFpHd18UG<?\Z[.Lteu-Xb4_'h:WFRF"s13B\GqiOpN9*Ig9`XMBl@a!3+AfdOXoGj(,`&q>:U?o^DVD;6">jt42Zj+K-MG5KeGH=CfPCARCfh-;fo4\`QW1%tukO(if$br%i:e$SunF'$`^R!.(k/d@aSdqkU3VK]45f!I??\`QT4I8+M5pYcmoI(ei.VnIBOd*PFlW-t9Jg+*EOD<'rNpgQ\H>LQ)]S45q+DAGurK.`ITaCp0l1-.YqFE."X^J:L762>i&CTS>=O%1]LY&rp6jr(gL3e7%AMq24[0pKO,@aMs+EBs50~>endstream
+endobj
+32 0 obj
+<<
+/Filter [ /ASCII85Decode /FlateDecode ] /Length 2082
+>>
+stream
+Gau0DgN)%,&:O:SCu:biU^;pS7!J3`2GPTiB%kc"jh[,uR"Q_1,b]a]*V\lH!0@oVS".]E1mTTMZAZ&%cS!<f_M>\jU*f_N8LL\ZZ'^h-@S)s6nlIkV*dp4]rQI*lK]QX&l*q[%H,A3c6AC!]N5CtSqP_6S)(*TVN=lTX3GCd[kLd\$q?_-_%hl5Pp@D5"4H6TlKmB!.,A`anj#"lu7I^dM\O@qTe,/iMF,&NK^6/*O.Jkm?_YN6h]$5,243e[nM]?^+*S;!n7;9:$W(g?u0`oqoZGndW/aP+#rV\5es41n,WO-E>P\m+sKYD_$bE'#XDG@daB4lt<0oULdWP:CId*A4r%DSuT]+O.W(2&O^bRhu,_0jHN]@YuOl?"35KSkYrX^&u")lX`:)=/C(\Dus\:./uD=IR)HcZAmA4;l1XSNZSI0Udd@3jV*8XYV[>l#d.4/lgMf>i,[<dZ)VLH1QkbXgSIRO0]\IGg(@1JEc/"FHVV?,%q?j#nftC<O+>Yo.A(MGXFg#2^Tqa/XdG_n;8j[7o;7YY,0fJ.?)W]Cj9Fo7tW4Kk#oQ_a4GDQLoU:_,X9XeB1SJW>,,Y;BOq][a]]V:nCA\*Kuh&E8X4#oW:5KWVRdp\*OS7eK7SS@K=T'k.Ac`U[G`:_`,h`\")JLGF9XRQ<"I:XYQ<@,3iDU>+@Nl*s,)ub)T/%e,ll<u_=?EW>`71(`HqQjC)XU;fkt2fL(GabCA6K=i;+O@Fc)h]8JoJcMg%NQ>IL+aTE<:E]<PZ.j5@-[p\cAQTk_(1Y6gmuM9Ys?.Q4$re38[)L`JWRXU#7.!3bFEhDRnMHg#\3J8D/]]!e:!jjgX2grV(nY:7BjWj@(2,lH7kh(k->$V(oSH>)$@i]$@#Hnh(.'t>[-E^q85+AI6hM;Z`AFckb>/_>e8BN\!,8$h(8i<hB+[YrjW]<*>p>^?Tm<@a'A&l<S;DHKKm`PliP>s.uq0J[Ap0MVF`g'(Z]4#j,0#Sdd>>5[<V1l<nOL13NS[g+JkXd))7#AftA'm1&*=_92Re+2G`EsIU_ak70EdG%_)Se@HqJs5Xgi(C@.SV)c\N<-[Tk0H;m-t\D(%eEn;1ml9pX-HjO8FtoA1hUNO5XQXEmo`3)N><]dTPoi\<h-,QWeq4Bfca*<Cabc[.Gldm$g$c74)H+0.f^"n#'C,g5VuVed-N:>fRiC`+D`b[^4Q!8S\nse>.M'sDjALe)'[ZF6rstu^Mk,]'tu9nAI!>ElIHO_A10=j.B)J&'fV]?D-JChMhORa3%pf!9ALL_[m;bTXpLAs(\*.5ALUHcbM=EQfi,HY[RPRhY-c]baEi0hD/K8s>h_=CAN:YL(.IInC%c?^,O[>!MhI:a@S#h^GT/l4[s<'\%j03^"MDEK[ob.r5,h9_"qWK"/+.,)DA.<3%^\J3[NX60.%rA_R+mo(>J>Y5oi<qXdF]N4El]UCjbo*L)@MXN/XrEhaH\pMoiR9#=\@`O);+T5YRb<m&F@q8Er.F6(r&N:@Hh!h9l1!/OU:699X0//*?o<c$j-%F>5Ng>F[+#9=7ICnZ_rt-[Q#CGO,u.,l&D]8=Xhug2n4UNR8#8kn^OKpU6!,c2@_mEI'Z>OJV[eu4h;R3dV@@J67YsA=S!'2p$dUJ3-IM^C/f;\?#_N[[LXYL0;@$Mk8i131ZE#]Is<7h_d<Op='#]7g@@:)c\ph6Tk2%1ms[Y=d!OIa^4WWN(Kc<_hS>t'R':05G/X,t_dB17P>Jqkjf\!A[(.SVPH%DCEV0!LCHpOt&5U:8r!l^Si?$]Z(n"?i4UTub>BYh3^YnS@;4+2<7@[16O'&"4fmTIQBS-8/EtlVC>u+c_eF(0.?WV@;7\]m"[!*nOS)q]Z>OC<Cp^r!=Njr.%rJ8',7f8_\5N8le&bgUF+*#oMLjPKH#Mc/jc^7E;l^>MVqDNE[DTD\*DX@<R7\r#jP,Nk5oA7s=ZDW0Tchb*biN1(Dk4$?Hp9QIW33a:?aifL,Ds@1s22M58*olJYQ[bU!]s<%rg'9IO-ce:>L;rr4=&N;`=`[Ke@!-2agLkaX(p3^RbKF@U(j,Bl65L2P~>endstream
+endobj
+33 0 obj
+<<
+/Filter [ /ASCII85Decode /FlateDecode ] /Length 2120
+>>
+stream
+GatU4;0/3d&:Vs/fXFN-(aB&>Usk)W9m_*5?BZ_L]8''lA<:Z9J>aa[qL8CFKY]WCimo,G@Z7,=e[OFb=s2b`LUd@u!V#piL2RA0$9(m+TbkSjHapRGqK>9X1SYMu@-e%V*Ue<'&eYh08+::V!fqr%*L/T?n;3JsjG,F^@o+/Bcd7FFX=)A7fM76Y(TjT[8OUrOGf_?Rqe.Z$djRo$75VfImP!;"9?-&Um1S]nG"48>J&&3Cp8I-i38Xa,G@1f0`\G&DW:a5S/d'\i9n?n)`7@OiJ%pd!O0t,aWMG8BkYs1E>+NIR(V"a&?!Q?$j+^Cq`J;)%B?gp%r,HT+,StdPZU[._ETE*5R233.4H]pi?HZNK*/9R;9PZ?t.5O;V0Pp\.j*&&hpO_n*FnE$Eo8"Rs>pS8$]tKJq:^E"C@Y9NNYmZ;H4ErNG0P;jSb]q5E1K$Lfb;>Qs<dZ"U@>OrUEh,>Pq.@nqPsnOhk>>!j/7fV*FKoNWXYCr+jfHaqZAU28o$ZHe/k<r?>cpAW@*l,W@O=^5_itl[?\'cuhf@"8@%]$A>'SHAJgnO_:kjKR&FK^W"Y4H\oo%,$MZfpoZBU&.Rt])5;l/PAA/tC=.Mo'<+=GmA3jhQ.hELASEQcob["=F*T:uLg#@!+(bF^QueScA/lUfB)-H[32bGja#7X1ch"X%ssY#e'.NETJLY:e\A8T#;Bs,+c5Wh,:B(6`\nEc0!Eeg#dceQUa%q7B-qZk4Ms/2`O7H2:N*$38N)J"!H&.d\Hs*IDbaS4l@#$jT1jCH\%=/NSs5r-Omag6NFRG4@??6Xc,\XgJ*RL#4(m)n$o@GikB]oC)H[:8KFB50tabP[+Vp@[s?6Fu'MYDt_P3^#WW\2hTjpHKsCZZs,?!eEA6'@u@D(mFBa?@c^[uW&R:^MqhkL=?S1=2E'iCXB4*u&\8]UjNe48SIKX]4uItucLWqji!Yk&bTP/i`.UNG1>56416,Nu4IFP=!r-$/ZA=$[OBJ,m&3@kSC.iAu_qNc\9OqF@:pF"Q=gg\1#MriUOF<WG5K[[Qq'b\:Z9%^;6_,/n0kEb1M4AP&#+0k%eXPAj0bC;g<[C\D'Mff1*d5%6OoshAJu*O8pf9CZ@4#5Ie%0WrTop7g-'VPi[,G;eKOl1*UW*HdX#1,j2MGk3%43&`(Y.dk.gcJSc"bF'B2.Qpi\2KBC3BF`cOG6KW:g@^M`K.oo/oOn4md&D($4B+GXk\TdA.7p+"?!h@QE$hc8'F^eQtGgn<YGI40-uQ<ReBQNG\u>F-NZ]AM.VQ'g&e"&N5og+-,OpRFdD\hs.(i\AsJ6icC8&9'4'E^G*W/A11iaJLEPsSsgT2e9[,d/FehZ6f,aG:mZ$7d<5ocLrU_QXPX51lafk%##7!+I9`^YRB03cXW5Wu^pE[pmBN,'48PHKYI)A^H$_;7]l&=N)neDVnG<n9B4c%.']<P'8Mk1/L(*/OkiSs]<h?mJ"\8;5k\nW9XPTQ8UM:LNg9ZK/'Hi2raAb[Hl\]+.^V]#&R+h6nr<DT#4k-pOM*@'J3S'P%!+&`J^2=t#g5N;sZ6(DT>]+84C#]:U*OKP0rBc!+Wi?#ne.-j/i@o<4;YX?"A#6&K).G*V\#j)"h'cjEKq(5!_\0c6HbW0OdONKB7,Nk(\uNZ6D/-E!15o:Q*VT^n#Z:k/*XMINYA^FC\NUdoXClT%Ro?#fEP4C+Jd2*_Rpak<?p>n*['!^+Br<Fe3eiIjcoP*qFf#D[m*cug]F0J4Iiag,*W:(?%&2o,DiZR?#%Ts;IoV>Pr4_BkkcB^3'qEH.Qc0)6]<_\oEJ'OAe&<r%l,Xrl,`(Jd,-P^,0D>]cnXoUNjiAB0ED/ahY]u<C50]/+"<6Q#muBLK_6WgpTl?(Xbr+(F)tDO(rN/0\euWK]U".EbMIrZpmRGu)M=l\:DF^.>&^<jfh2So\%dO^Nh2]"S$dF46D!hrL@r^/BR]CmRpoo@OY[br.B'ee(Ij/**+^Mjs\S=ZG\[$Z4+0FF)Gek<U^u:4!D3n[ai6[3t^"3q$r]iJcrUha+e%t.HcdrtOC`@sr+HgDOq]^En['d.MI#2,lS+WDQq[V!N.#^)k/o`?d>Ju&errGsQ(,>~>endstream
+endobj
+34 0 obj
+<<
+/Filter [ /ASCII85Decode /FlateDecode ] /Length 2110
+>>
+stream
+Gau1/D0+/c&BE]&;sZSD/o`F,,]T6!;$plB?mmkIc!1`J[?X-f>=Oe1L/3:L.CPF(V<$e&:lJK,Y5\=IC2F#9rXerg/HDA<@<bCp">HAKM7a+kDrKgMi9(,DO,P<>8E(pT*:J3&&eQl"O5N7_&U4>t`Bf>*6Q?e,lpi`8`ZQ/CTAgjQB0@A.JnDg>2p^/#?4mK&-$[N[)Z)L&1(N:lBcdZaO5,%pCL/bC(u9,U9*k(-m\-"mnQkb?amSiW#j5FNJm5NL&GiXjEN3k>7G8.e^XE7^$".4S8^.4l6LT=S`J'C?6,lnS/t#rb_Xoo`T,JLfn>C=pJcMA.mHVlXC?YRMV<LFoeWOM<H421+2o9*c0UWGs,^2:3(UZpS$mElp;LHbgWjsNdf_FdkEnf>-K(/0ok\3uX@-fgk[eB)ZI#QRp6=>a+@5JYA]nn']*h78M1mFa4`MA%Lc_ugkZ8jR@2INAIU0<+[ZIk:q?ka_5%gA0P'?Y;pjXXXi5VF#1oIMI=W>6,RY]bs<<4,,j;OR^"Y%XenM@4mT<#bksCH+HR4,P0tMcoLbpi1I:,bmRN5n\piGi[nWJ,X\RQEPp[G1_RB.'@Ooi2-*u0PHd2s5oKeNX4-G_$^ISbTLCEF\rN#qK]]W#tMLAX3[(_;=%FlenT$be&^17Es/C$14*>)`9:d3Bt;;fJO1BbnK#N(W,kg@^iN)jF9uSRWf!WbD0D!]7HInSnd%&6@n>QhP'!Q7_rd*/5Y+qK^7%'1EQP=!W`DQbL#sh]9@^T@T)ZHSn<)B1m$adidNqP9W-]7GPS)I9^*j4-S-`NeJO7D5Wl[jcY*]?We+?-L2pY;OY'6.q^u(45.>$U8/nbElB>)XPg#lad3&prH@-+K1^(p9del1HUXe%YC*R5.G.jn0-EnJnGLcN[6h+`h1ht+*tO3ki\oPh""CdBYQ-XWa!O??aO5!G+[$CBSXBVHGPn6`?2=:%qKY..f4(&30,@g8[O<s(X)h"Z&=7<L3<A#\NY8Q"p8RZ-:(#jon0.otX^chT6LF.6RHRJXj?RE@/-k]C9E8BhXPL3D5!@=&gTOV\-F'&4\enS(EI>?V`D'W_]3>tdbLAX^P$QMs%8%Queso)Vb6(/,2n36TR$As29CEp"9oOR#='J/XoCk+(3/lO*Acat&nk'T.I0-l>slkmQ&ci%5@;R"Ck"Pj>KH<[(n9U>Rk0LhY%TO.!m+n@,MO+>Ql5m:,VP03m&lK=G;>bWG#=0kbK8eOaO*=dcSp<af00Abek#=trH1CRQ-4;d5prMl3gh]F2HCCD&Q@BlC.](Iek'*ebQFNUsg&;b[Vd/@TRE#rXZZpZ(#<;IlNNiD'B!qW9E_(Z<5M)P,dK2fei1khD1l,Y3<,k7G:9H-X$@Z"W<f18GlX56g3U_=[(]nu"61]$QWhD>-l"UcD?\9F/(Q.P5pG@J`>bk&d.;?nU6N(#t4Km^HU@_GmJF(h>2Le.phXOb5SL'c.kUD8m?SiV%3uCs+tZ"ebF<CMY\*SJL@(f;?ONP5N0k9dOgrKG&Ea:"q:J7o@`pD/"Vs8G),GSCd!(\5<=:Tn8rlCfl@1&I%HE@^]KY]!OP$`]"IT%hg_4PNA*k?-ie:Kf5IfW,iJ7)e1,?V,2/:3kOgC_\]1+/U2!`d>`AmH95he^>D?OeDL?7$^`bFL#K?ucW<`FU(8W7(8f"&%*G0tb4`]\da]ZD=gO(kfEEEb6>!mK(0<Z*aJWmg`pO*YV@o_;D-8fG!.(ZG8k@cnXpNeFV0];ZE.rI^"r#)^;O\iorUpY<2[K+BA4SB'XHtXNmq.?ed#S*@\+)\(h$V\H\p[8[9A]o$\-r-lq"OZ:2i8uH+9HKJP@T>"ro5EC*qnWp"##JhC?$7%@GgA+FUmTciihhI>Bg"I;9jXBe*b\>Zaf>P@_Z9O/bZc\\Bbr9iiZLDrALphf^$Od5=@J`]l`uT0tZ70k,pUP$gfr_D!n=0ICOi.Cpn*>YJ9^WE,6DFf'i(&od:5&>jE>4IBerQn)kP,$!_o7pl]Xp)U@`AKintGiU$?gq9'T:`JIHKDeMMe>[?>q`*8Ru?(#o_Y,+RjRgt#V0"pptL'+]PD/fR]rrS&U*Q8~>endstream
+endobj
+35 0 obj
+<<
+/Filter [ /ASCII85Decode /FlateDecode ] /Length 2197
+>>
+stream
+Gat=,CNJ5g(B*Z.EPGLk/=HQ1M0(,9ELf)V::m"6l=6]kB.+CUOH9SIP)bfurU5(5P'TO)j_0m70J=IPpRZ_O"@b"-b^Lp"d8(E:^LkDD:$0BAa/@%_oQkQKl%F1B".st-3ruqQXlDl7@j*i@O7A#G:3pnXTVpt4S1t2M:I@;m/SP,HjtNFAK,aJ(7]mVA]/W['0dSj-a</$]0H0PuO8;/tO0J9.K6HBg@H;[j3\TNU_k*HD'KT+C_mI/Cd6#X]NoPJ(o?$#6-FR78*lZ\B@+a-Xa#';Q1Q0p8VA]<0d;#PcW[O-4U@*\@S^QR$9tiPZ]YeBg%--+LO'h1uAR*\r4]0c"/<eU^UlV\BKn2$(O*M#n;_,-Y(VEV):'@+dP/UEIk;%m0W<t]Tf,J,0ldoKpE:*!oC"plp$k[rHA8U3mikfT<0H)2"5SF425m,9XAX3d4;5r(NOjrqs$nIa4RCFUb(E_8-lD7<\j9O\[`t<^j'UIqp,hGXe9[ghY(MnCYS?7ML-*!nY*Qt1S4Kc*)-T.fU.,^`9JtlQdG/RN<4Zt#TU^e_'Y`WZ>4GiqpWMsS%RF#Oi/Lm/HE<\c^FFhGD]o%?;.H^2-Ut!"$=)!jiMMj>L#*gTH*S7#PBDJM=B/EO]OiD]i7^>Qa?6Y95%.>pnb[8Pf;,&pLR^,o(#)IuW7HGL3)\9Tqrp4mY%iicucA>bCmChBjmXj;+%;9pA]u[cV!BI<=Dmj\_MRh.qgi0*s(0Olmh)`oOA,Vb,]-)i#ij`=5`Z*Bl+n>fUQ:<b`B!^;'+68K2n])Ei0lbhL-s;GgA+ccb5^+8YMau3Dm*N?k:3BL89Mea3@[N'YknPLa\]/At+mVKQLU.8a`A(ViJ<!aX:p:)c"A)"VJ--@P7+V"0!=-I2ca$lo:s2b5EAfY$b![kD&*@H2b&^Eu9&niU3afl&l06A7>5'?gg(C`cEk/4.l\rO`Xf)jirRX2BkPU;;YN;WehY;S\0;[csSanQ:1f_Y,6,F=GUr3?!\VuH#3(.$fH$sfrR_&M7TBV>qmpp94`Ru0]D^K^,4@%Br8%(Kggta2i(L=Z?LNe*$X/"iuQ&WdC303-8kg92dPmH)ZM8CNK6)kXQ,\B]:XlpTYeYabFiW*[q&G6:i&Yq"JmVns^6;oOm8uJVb\qMR5^n,,N=&EKZZjb7:']Zt$;VcBCm9;dHVl)3G?iR[uB1Rb=J\ZeG[`"s:7ARh^.*Wql[25$TPZ`aKB.I3OGP=1d25orC?<[TUD;##,!?Iu9kOk,%BWD&l'V<og(ROBGGCFZtiD_>=7Qk$%]d[G>J=fi=(-4osmZTSM"6dtUNV:H*B#&E1Fe?o`GMLB2DeEqj;1U9(R2Q98J\r9'9Mjkj_ltoN?R("aZ+P?O]oAW/UrR_,fiPW]BI9.AKUN5JCetER=e`hSIZgS<p39s]G7qqRptHg%)d,.NOt]3*a56*5Y.WNRTLA%8%`Ujuc_lE:4TCu_Y#oJ.T&0#SplfXqr9(.5nHM629KeY@^58\@T2NRu3%L=M7aFJ^a%NLQLrs5af:A\)Ca_q.<F6P"8pu'Y>cdI$67FaZb%L>[:An]pDhY@:<^Z:PRZAR2QktMSP`GL:;HX9po!Zf(LKNq.Qdu)FQVlX6C>X0t]#c^XS(C$G8h[uK->tZ0`G;DFM=f<>o&/u%&7>>)BhA5%FT.6,'p=j/GAXUm8p>?*=3V/o3s9.j7aD+,H$8@/"r7K+&[g91)Kie(j868m[M<BCA,CMmJ"RK26:5\7b(Rop>>sWE8#0=R&C!oY7P?'`<GnW(h?(KlX[Y7KPt3;F21st-'"\gpoZc'O&uJ,!09CTcUhu_k]_<Le.^X9l>giZ'MSUkN]VG5'pO?o##?1r`?oRZtA>CcjgB]MaV#+ER8V;OZQLKt@&*dfnr/0&Vg0&gH<KCaDG:4.(L&W5iS5BiPga?b$Z=q2GoHT^Oq_ol4&*WW9F[g7%!8;Tc2qHu3Dr$sCmS9t:rm9m&(8S:hG&M)u3a,22mOdf87r)hnCQ#mGkUa0u>O7nLCTu(W4_#i1%'m=LNQhhK-tI.2CL__c("iYX_bkV,oWDbq+]e>9J(3;/3*tcTch\GB(Nq<(?nP$pPuGDFl#HM,h5haoEgh#4VRMo,hn4DLIOkal$9C]J80kr(P"@tY=*;1.epZ9\i5ZJfXRR&HZ1/i@d)l:g'i?BN~>endstream
+endobj
+36 0 obj
+<<
+/Filter [ /ASCII85Decode /FlateDecode ] /Length 2205
+>>
+stream
+Gat=,gN)%,&:O:SCu1=M8/!*pMU(;!9q#CcRG*pqp;,2qLkI%\,bT[\'_Ue(!-jVWflAhh`s`d:4kMoE+UCL26eoFF%Ij<:>^de\.,6D),[gau^VUM*(S<?O[k^Z#M.i:9EdSfqGs]Rd6@s]m$%s#bnj;?Y31bd@Ueq0obs6>PI"scL:VS$pqZW2)mW2%<4Jeth_L.MW&Lu!\RO3<pM'b6OG+5cgS=J##1(r_u8P3slZh+kKiE77S3RI*K5J!S5>iZkpO5-$d9Oll?]XGS5$k]^OmqPfh@;<4&PG4M4^U77iPu\?YU++THleO)$qZlQ'ZR0S[B/Dt(%B&*$lH^2$0\YQH@Im)J.pbDS0qP6ZLR?!sbbm"TP6P["eHL_$-n<e)@Nc(jKT^<-gO"dt*F:r1&NT5lC#@0W3XoS[A<7lWM,<WE&BI1Id7b.a7?`fEAnkb+@`@u&@uSU>i+7FV0RQ,BY>k$FQk`\kf4Q9nZQ-[M'Unq3/0DeH?@l%/<BZkL?*BMOYYaPi`ZjUYJnCkKSo\"R*u(`X>C>35ZN=R(!Pd7[)V/0Fp`>fo$_s-H6-5HuEm9I^#hb#s")#R[3qMdpYCXe.G(Nel6SN38?W^`e9;C%kC-qN-eHgq%8As!H_C.RK=BBA"YR)0eMS_/SUM8MMT*&.AC$8+=H#V*-^$C$Z?,9;q1T3=SdpIU;RGn1rFuY=i!;scgLA.EV<41t<rBY,2AQ@h-\s5th,rSgi,=99R_*t-_S`TIn+bMI,\h-UV8$D<daM%AU8,"MV.<rTC.pi/.4R*cZ4dOjeP=.da4i2O!Z+e^-F&4Jt_/)48ZW/,JYZ0dVN[^5VAXd;_e4J\MaHC>;K]GfoXcRR:gN(<^b^(;K@cOGigBqY!\!7QkC1i*<>7?'a]LM=nYqC2>mrEq]Em8f)Z$K`^?@h=W\m;9Bc1GX5fJ;[^>MjNPhI:J9;CVcagrB!k;5:&MIp=KXf!9;F<irY'em(+X!kB<#Btd&cSKg2;;X@r77%[:_^7RdblXj5%Z&4@394Q3?YnWGX\C>9uGLsK.etn9.$8?ITV7!GOGgP1ehRga/4cmd,4P+2@oB2E2e(1bQCa70l3)_/$&s@W'R2fdq,?eGSSH\JXZ0\JkQ@4]fj\#I+>Tmh<\&Y\tQ+5#&O1[g-G*sOVKlP\4(FQfD_ed.\ktIs<ee7C)5-73p=*SO4qH/XW/?U:>+.\DjqV5P:ZEXQ.U4[XNU=u;0TdX+T@V!:Fn,&IBrmgtjkl0,/I.8*n(BjZr)Def?9G`FF3p5LM+Q#YlM2MqZ7?qNi_;Ion#ipHgm,tBe<uunX/XVY+'=X69,>,SDrEK--B/>1odI]CSYQuT%c&CQU7bI^i6$oN*4Y.X_GM!46^,`_^q@6.m@r/[4$W\c\2THLZ;2S:lQI@(9H_1KZ-=>(?;!&Iil#SkUkMJ>l,fo1,2IQ[3MNqoa9@b`9PZDk_[E]FIO3S/?:\!09*o?M2YdX_!Kq1#9gZ3C3mOssY_@sSICnjCTj!jGa%V7mW.gP,ck#V%+=R-?'L'$`h'8]<@3*X+A9Ab8_'b2ftf9+JjY80D/^f@uEL@(L`FjY3K+;p:;%G#`PNj=kEY;tK&Zs8Y;L$r/s;!e9I<6U;[>r0^YlPbh#g6*Q,P@TuN,bis(4\L?3[)"^,c'fH7Kr7HAk=1d8\Wi)OBBnCgUeQuY/]OC8\e-bW:L.L_P2"!!EkZkZHRV;Shnn.fUdj8kZ!k55^t$;'ciG4JHlYj=9\L",+$2^%BZ,i<01M8\`ol06[+qgolnm;$/c0RF-!:J\Z;V9W>CU7W47J0)YiY["Qs5T03YcNFs#H%HDS%RD%RI"$aGb1N5#lsEL<25X$ie1I+I>;!bo6N<**KqlK,V\Y\am0J.t67m/)7_o,;WMN3G*OL9u8k:a#-sM!mKoEk'J3dSht(/IC9L_K"q=jKTgL=V$VfX7.LZ#^I]JDq#/6kOJ]8<],%C%7=p#l@-/_3pGP'W'-41Fnl*1!D+Z0qcb78(R<XR<mNqk0`(U%"+E?!VS]!\c&pO*/"n'dQ-cG/Q7HU69Z,KX':0F!7)J-Ag\<XX1be)&p>>HrrU[H94dbUpVETc63q%qF!->[EM>PoVJGBn6-1X(#EYA:YG1kV:`5@umtgA.:Rr5cRi=l+U@fHFfNpssmbO)5H1mMhft4SiIG"rBVH[@S1RnNZ,V9\9~>endstream
+endobj
+37 0 obj
+<<
+/Filter [ /ASCII85Decode /FlateDecode ] /Length 1971
+>>
+stream
+Gat=+D0)1+&H88.Z/<jk`#)o:OA8$9C!u<A3dn8[]pYaA,D0g^!2:+YEI[qh`/AWp`+d4)#IDkHUYTQ)8H`l-&G$oR!3^#h\g0N\Qn<iuQ4(#L\<n<84<i$@cNQ65X8n%9>K[L^63=@srpqLF3?XYY3KA2D)eXN+$U_r>a^FW?IHXHg^_sT`4CWT\&1dAmF9tu-EIAcHL;)]Y@69>@`!Ys-g@7h+0(?g1Gb3pHN4_6MF5(<G2Hb%fjhq=84@*4!-2guB9<SO]bKu4NJbB`AhcDN,:e<AX;CI@3MStCobq[Fk_!HabnHhG70Z7rbn';L:25)=4j"XQ^H-0.(iWg]g"4*EDV0pMN@hHi>J5]=eLqs@kPUaWg4JF,<3K2[:"'fa<q@3ecGfN?:BssQN7q^Ys@9_b1#m&p-)G=K6#)bRJi*F(T3A28KWaKlBqY_*PO_%Na9-HAjC@c5Igq\MR4?ZXO&rn^+@u.u,n=6=(85YXG5q.?$K&<jN(//>-$6DJ[@`2Er*,Ul$2a`_6*a7J>>r&'u=1a$NZOOVKG"\SC$HhJ!/+d89Erp,`-KqK^"U8JG&M%tcB`eOi$-O4;V":"fElucH\,r7gCaj(5*T.:p]p>3NM*TM#3Yfp9HPpN2fCJ#;c:,GY18AQpJZ2b9E*9)-RFh]\Q2g@(.6,6U/4*U^fp^4Z$;V7Q;f%mTfj%G!.?@V<o!0e2TN>XpqsPRH:EaOP)'piF;%Kha"bKY84dVML"b2D/A3q%<@PlT!U>0I>6'P3&jc4!qYr(:g0)(atP#e?-PF5eKQq8\>UlMFp+".l57EQi]6IJ4N;*ZCf1mSe2HnME]VK)bbQE.jUV/7n&a?L@X.ZI_Jm[@i(CXVsHZaDPU:*:>&4N.dB3ALWUG0V-GY?ab$8.epcDCkEdQ]R0/#@ml>LUYmU:hTABP9%,4]tI)\g6QUQ_$%*QIM/d/e0Z\<;'P/e-Hd6<O/[R9gY1-7SDfW(N_OeJ3P3U^g\*0[#XeJ1j6NPm7Dgri%Q^3J@5i(6:S`1O5*t#TKe!eRJkB9ib2A#rS>EHaP&#5_jhsIlag)#5%ddnDm0n:0iSt*gCsJ@^$38#G@!Si1AOqt'[Geks'H;i;j%pMX8I+kc\&J)CAE45)0ndO=TY*J.Y9=cDf>mnPEVU4STm4[\3mNnl)BLBh>[^T2Y&NAZqZIpf7p/T3\kPR#Uu!J5W^WQ"))#!llqJF"\`ku)X8"I%qh>]g6]@VHQEu@nY%Nlp9(Vp0/U:Dn'P\o`]IH!_2UrLR`EOBnmdKc"[2k/.IMgl#ELeSc_OV,g_DdiGA8P@TnAiM;\5/sq3&i%FNt=F\i%*QX_cj!nOXN++IOs%jC7_Us>!50Va#5u.%_^c([%rf2_Ajkl@Ju[qm9sC\6#ZT+c'LP"66Yk1+ZDkJmsn`mC<94975UjHelBCYLadX.Pf;<L+d]S]?#?>qaM`NSIT@k?\E.mO[@\K?9ksk)Q#/iIGQqJo-)<T?jF+W;4#ENUHr4Vadt6bB$?R]*`17YMnnjEl'BH;T$/IbBN\8dmYs0c<W7pWKY()8<J)T:G,AZ9BJ`D@DgE`<Ic,Orp4<B!$HXo,XXF$;<bhR%"B3^\+fZdWIkDd/2Wj_Ac?/OHVMg91lo`_J+eBa])fj^qQ>Dp%4eHYVI^W1+9G(kr`5P5VI"+i)N[ea]RqfITHSo-.3DgHel`HfPa3X9cCD>USf0-"4tGd=M3@GLW9WM%mLGatfK;nA`G6g/8PCJ6.JMH&DBc/tSfr!(ob..h3[$2XI,qW2Jchq@A]ChdPObFTto.E"Sk7\bY"Ca^0\nQ(FWL;N@8]%m.]bdgJ(]ONXkUDc;NA9@tCT[Ta7\H+Y@]1I&G[`/dL`eJeAK&%\tW3/mD>3]C8cedXV8!PWXCV3fea0RGJM`:JlM(#,%YDXf&.p?[^=`Ln$fita'ep[TH5e_=p53b3A)=OX7NrB9d,*&K~>endstream
+endobj
+38 0 obj
+<<
+/Filter [ /ASCII85Decode /FlateDecode ] /Length 2317
+>>
+stream
+Gat=,?#SIW(4FN4\8RjB,T9=aPBcrRh<A;P=J24Uls_%0Kr2"(:*`[[.D,TRHS-bhDEEl0U-OjnjS_48SBL!#^qW#2Y?Ra95LU--kEHeT>Z&5X<qQ;CqXAn(HBXC;f1#C$O39X9E8fs2Dn]A5hn7esiob3'"/G\Y#8UP=-t#47GS1Or%iP>8qaMSTe1-R.@8K[>,feWIr=IW]Q(J#KkJ'SB^OGMBiG!?VTSMY*m=:Ku.3`<9L_1@VU?@ue#A:Xhq`t+aD2]guS!#kXA39p))M=ekL&-fj)rdbZ=N;^F>jg6UoY/4+eI2d,e!>3To5l[[`d-!)f3D(]h0M.B=BA8LB$V>d&/>FU;dV'$A@FkHFoI=,9gL6&]@k[,La%uH9%<2<ecA!6COE1%3uOK>'iVG3e+V@HPg4#20C1`;P+`n?m$*m>L8KN-5;_l0Nf@&8(SbYD20:krgC^MZ7ZK!B;PX-;TR4cUL^82lb?Y[[ZX]NecTP$BH*98Y?q2Z3N';Du]cte9')s\,ji5@jHB7UA^.<Oq:;ZMR'qc8-J?jW+^($>"iW;pVL+uZ,""GAETfhecCM3Jt6!A>j3hsSlR8,Wh%IFo9A#Xff]$uD![S"<]_%'12-+?Do8.k!qp%V\k7(WR]FG0lOpn;o?*44Cf`e7hks$U_ljr0<JK0'cFi)_]S<6hos0N.NUbi!Kr`ZA)MAbKBF7#_<N:(%8c8$>+9POU[Z"'Pb,Opi7=93<rTCt=OrpfGPomd,I_/QLB06Ncu=TT]2!5R"#a1OK*N2bBOKf"V&1QB*F-.`uHL<MNtrmO-M^Zr&IHa*)5E<Xe.&1$e;('a=qbp4-M_PffseEiOKVGGh]&4#nh!OnfM7(f#o],9lf<roZlQM['kK`Z8DPjEgcL$'G#ul7*i-;HK\5D^pC58j`[n;eVE!&U;>X'PJ#Oim&d8I>#d6<)D0RHrnb;6c(;%%cG)oR3loXqPLOojW/A*_/d,Ui,Noj%Bo<1HP\2WcC6V8`8ck^Ya_jLg,$5e!4^Y!qF78U@%P%Yij^o=lc$i:?X+5Le`1i[fjdJn-BZZ7d*`Zj>-0Hs[T\'nE[?n,R6j3u69P0GB_2"ZD4SH!RLU=\!:]ePag<DZ3RaM/p:!8k1]):`j9SZgScJ4Z\B9+/)"JIuPA'%sFnn$@=FXo/f,3%/W@-n4kCu/gWeo4N<[X?!.8>]@-.7bb6:cGuF:B9TR3)3g(4t)3Fs1c![>1&f#oYha,X",J0tR,7<;4`lBD3BW:*4VrM(Uh#W&W03;ZI_uJmbWmBT"#g5#QV1e(uT76[ddPLh%4oEj"XaO=rPZJ@(g`ju[ej5V[+RYTQ7kb=uQ;`Z@rt"nEXV2.j8Kgt..`X-J7,e,\h&61(V]fK%[qqU?kES=3A'2BSu_U,"p`G8(E)mZ[g9ZhlH`<sh%#]VCO?ZWlasV^*QnI[SQNDnC(jN>`*7,u,0QBVB#I*SB`DE4$SL9>%Q8/MDO9?WfYnS8k-NlM(>SmDD`L1?]9XMSNHj1@jZEr`NQ<^nS=OcU2[i2A=k9M"ag00"+p&'3%dY:qh`^E3)A/#=e*Eo!1Bk(s&W,27VQ>g@Q9]''OkH]o(!)C9IiAh"aJn=(5\4"PRY>dSh72,gX0h:V0Y4-.#NU]AP^;\J%u(cOG/P7"uTt'XDX<h$c(8J@]FABd(?`U=eir+9LBINV.qa&Tnpm//r0]?AG@ao&>cC=tkf;d(#6ilS(5J\N9sY`]He%>+s5bp;t2;^]ULZ,a#L!A@bO9Ce^#Yh;L9Es)SafO*cr-,l%8VaIX'KWtI?W63^tSQmJa8X4_9?=5(8V&nnB6@pd$:I1O*I@luG>2p(&P5&pSQ%UBC,HUfDZBfR>(XH!].kAGH%6:>Q(VP0!"_'X\pa33ab?l/X8]dge*l+\CC#ZmHW2A42>>"fRS7&Z3K$UWp;'3$m.AZ+M:e>15b0hcL[H&ageLWLp.qnE+e2R`G6>`!IB'^JfcTpIP@WKuc/qI3/_knM9'`?ju6.S^YOk_&LV4t16#&uq)+,?H;l3Z-NPD)\Z2pPURU*Z+,O4Win],XMefq\\Rrb`Q6q*k%>VBa=C4jYWqN9H0V/6Ie8:pY);V3#>R^<^ft=7!2$2)O8s'MI[;D(hY=8NHdNm=5=><Clg2qQc;PR+#+9U5(;@C7Xf@=c<$?#1s\,<_p4a1ra>g/9U'8;SoGPJ>FYjTr[m8(XDP7unLlU7#^c0);moqJ('S9MY6%k1BN\k#R+mhe^&Ne83s#gBrN@Uj-c)25p]h]P(E`#R+/C9ro2s<Z'MjO)p@1]SSZfcKMf/M)lp\!U~>endstream
+endobj
+39 0 obj
+<<
+/Filter [ /ASCII85Decode /FlateDecode ] /Length 1797
+>>
+stream
+Gat=+9on$e&A@P9Qt'=PMC$rfG&g4(/J+RG[TM_D$SBa=@u=5Vb)ZILhb`ma-?T_"$Y21Q3M5cR)5f=/:E'6b)PTIIo_PbUdYua]9'=<depl0/qX3ZT3o4+Pacc'6<_8#N31n02=5DhLHEsuHdCL2hc(_1r%D>rsOp]UD6</b$01upplg-R\L`gh9q/f2fdTTd@N@h!(@!C&oKKcqE\uFL\)c7If\l+^`+hi:jo+a:MV/SjtXXJ@eP5[CDJ"cQ(oL]7,[]=/1T?h]01nX/AfVV]\j/WKo](8m'fA]lfQVI\%_T0M1AZ?((V,LSuN9@o6TpB$\#mjP%I(%j#O*@Hb^bAp(X/.3XqIjT\.@P!T3Is:\<B42*OWbilmn>u?#N:d\@OWUpETrK$PO_[&?YCBOG`aL:@GkuI$\@kHb@NC/^8Nj%CKp*+?Jr=iSr8!#SM"oQ[.KrSfieUcC6)J3@0j-Ya2jA].=C;h"+)DF)h_B%f-g26OSi-moYnl*lp@$9p19#ce[2cUj2="AiFqMQhG.('9D`CmMS@Fm3ViaNrkZnk!6bZJrqOV6in>dUiocu*&"(TAr.s$;`,%J-ke1X5R\iE4)PK+20#[27LbcRXj^RcL9*G+@3P2QAHA2Ede1%(gel$@odW+rgc8Hrh)H=/RW+IWu#/@:X.JHc\<WePqHuS9ZTVbD!>,fl!Ll283aYTN(fH)1!n9cnYZi^[r#Qrh5l.9,!AHW'0"g\QC#k.n]T]:`r7^S\RH4g9E%<2GeUA3Fk#=b4'%nrK)it=h6D6:6H:NfC>"]p5CNKt#k'M^D>7.ft;(4jY-91EtG1n--uM&WrcOr_<NB7qJ':'X!De!FQdHd9(k!Y4^I"FuX;e\P/G<@:Y"TQD_,,(a-'<YLQ*/IEmrK>T9rF,hBWh[62G77^@e&1^t8(),DDJM$R@:^q!i/q?q[3mlNe?oe4."%Ron7N&!-97676Eu']+$7=r:)jnj9=%"&<D[#1"ZuSE"TnPhNMLr)k7XfpEVU^gpO[BF<7Cbgo+gX=RUpYZ9OX!uRJ.T<UFF8j5YcC',e=O;@HQ]I_k]&7t(G@L@/fY*sRg@A(l5s5G%JV.lA;)K6ede,7'pSA"#\BllB:+m[!d(/3*E8uPlh_g6Db1H<Xc!N==\k%U/o<l)[XA9raVl`f&q[jO+O>?T$TMScNd-J>)Gb;DH+plDkN+R$RP45=;TL\gc[OdnB;<>'d,rqHb?$XrMX:?-?=Dmqj36o#]3?Y.Rdu=:I[6*GTT1KEDbNjUS-[j/eAq&U(pb#TH1ul],F[9AO;6)FU^0ns#(?EVrp]oLY8fEpjBY2SOcbb?IZt5fKpi%iF?]34/YYObkTFDp!8Y]W!<9mC!FhOiT#J^cfZE0;5Z#bp<)dtgT.G$pN%fqsIU<&%FU\?Ho%NTW(V_jj1CR&pYSd/)dk[P&$S,H<JAi77H5?c7T#C>pk"RG%Ht+CZ/Z&.h5KCSsXFHW0Q<-`T9b_"kWm`X2C]gMn/<4$8IcE8$[;tuVCcr<Go+^G',Q'Mu8(iW?7QDFG!*+Utm=skY-.*/Ol52TQZ,7^VDpFOK2H7?1P8"D$1os;)VX=i2&qdk4dIu:OdLV8QQo`6M(o$Q+(%Ku)$[;^nMlI1[a1?Ysq\Kr+Pr8!1SU!:FndA%0-?A%2R.H1KY[pnkKP>U0Vm;)5o-`R"Q6l9RQ/%F-=H\&tY3o4\o(d$d&\c?!`6;[cH'UkF^A:(Bs-mR1o^qSCoAcHU@(\['`Q>fFhSe7L,)])!fb-$2Hp$r9OY0sN9R$L;P_pV4~>endstream
+endobj
+40 0 obj
+<<
+/Filter [ /ASCII85Decode /FlateDecode ] /Length 1444
+>>
+stream
+GatU3hfGPN&:Vr4Z&cWM&-Nh(Ds@4flV+5>2I)mF,(g;=KL@,jchH%8-#CUnl>YdDB+eE>g2D2MDg*?9i.nhWAIJ!#!On[,O:[9YOP#Vfp^KD&2uhZp_p1^7B98;+&+KY&#B!i!2gCRWDSpNIh@p%5lqLo%midV-:U1fZ(DY0NX0rsn##nW"n<OA5ffLV]L>jTMSo$pnJ)KJnL1D0](g]Eu(N6&V7s*s-i;@]\B(nIU#F!'jmd'hl%s*i4LCul[G!KaXkSh2baX[=Ho`D^8GmW;Y>_DHqUa`C"[G[l_.btO<RXM#Hc]s/@X/X;d%)Tpj167M@%.cI%(W"E`O9`T)egS*Jd3l(k%pPq,L9h4D1Q:V)JW?%WZt<s<_BOdJ:em/q_A#[O,4QU\U4ZmY<eIKPhS[6);"Kppl3Im;[S`JZh_7kI_cSCJcgYc4ek4Y>Ph5Kb?%)o<4*-1QkX?PU+)tqU>t%?Jc0&T*]j>so*\]lALD"`n>E(L*#ddi'7)2J]8LChA#*ck4H1m71XI3T(%[t[@&9g),TZ%Np-F(M4s,H+Tk>9%cEl)^9]`p]?drS[c@$k?`81,[D6%5L9=Hu5fKA&S\9jf*qX7#t@C!Bi(-'pL9IUk-E,(A9q]Y'i!.l<,l?kQI.41aR+pNo]?Wb*0Vg)9*j<q,VmSnK1@kldgSH>;<e[Dj\PV-7AJW*u:p_2T>"!P7M-R8gboJq(7\_AWngr*dd[1d/7CU&sA$!1:(.LupCbl8U(+ML:q!C/4:uZ$gAXZ1B\k55qO9\q+0N15SCTr<0@o'!Q%ArDE9\0eR9**4-bc51W.2/hdu,9.^l5e$SGJqW<6b4[`V2AO$N***Q>s0u>k5I*i\XT%\E@XX3FkMOj/qfC&!jZE4^U,D"Ie_4sMpi:5LVJ9!X;SjOk0/'I,#dOnI4`A0[MX`@Z2R5K>JjW=dmGAY*99m<\Sa:G@u<p1!fPn1V[=BcSQmF@Z"+7qt=A$-#MWOJX'V21tbd/f+/6`6ob:D;'5I4GI*_RRm$=@]d4Usg<1&fr#hE*MI5c.R?S`@u45H_-.PE?n./&n5j;WDRmT;a7%;Fqi]r_=\6hqgjV2I,kpS0UZYfaT]OjLi(YH<VEHagb]!mV&t,qK+/:nR$I3p6Pu]EFKFP&+L,*3'>.\#`Cr7oiKQAf*\]Pt3,5uu/]3)8;[P*&Zr69^)rq$B8*C0KM!5TTB3`nhCHFD0$6$KeQEVt0Xao2l8'9_\;\R<%.?GJ#;]Rr5bKr+dMWr@1!L?_6&+l<^+b,W.EN5j3$HcT.L'O/W^8S7nYoXH+Sj7@of1ObSN^aUbCF2RfSeo)XRtMa\Q[Wt"O78op//&)6'JG(MnGV?l3YsO!c?I3qI2TCq/$068r<i:GN.23nG_Z=uWUJ_JR;Bpl^ZB8::8MT*cOGOF@Q`=G=ZM],R9sq)06>El;Z~>endstream
+endobj
+41 0 obj
+<<
+/Filter [ /ASCII85Decode /FlateDecode ] /Length 594
+>>
+stream
+GasbV:N)aW&B4*cMKdiV]*-@W@F\;VVGa6_h'hpHMq8Bq"u*<qXSDK0.+rJPV6,h1iUP.h]pX]hnJ>!!C4M?_DEc*s"gS4"3a<p,MRtEa$KCmC7YE468K8(4#ju%gU,hcY7+8h$""kL!FLYet)M5"c)X43)3*:#K/?+hU\u1gg\le3oZ_jXT=q<KhRbf4bM<t0HFT5NjS*o0ag*W<(6RCu8.Wuk-<+;TE.d`m>dn*iR3(o$sC4.?X4k0Z$WJ)lc=\(O;jES@kl,L6<.ncG<SoSpRpDj$JH])&gYM0]@SB?_C`#b3&e.>b/rE,,M25NQ<Z7T5>D!YY/S$Q>)N457%=YJ0deV.&PCXY&,<>@N4k?lmt)DR?FN,TA1ZBIdaCHnJc`n95PZq%9?[)UF<BFK(dB@:AQ-S3-6c,nPSaSfqBHC\!8#i*ESR9S`\$M^m0h<A$WFcj)m82;;P;NJ,Zn/oO`D[otsIj4JJVrLVJiHF)?0T"ff2Fa(8pQ5Goq9+KEXHA<Xg=4*NP;Pj?NPk-"4:L#G#![dniGe\miU.@3gc&;UmPUQo4PRAdE@i;2B"Vdsp`\YQ$c`O%!WVTo4T~>endstream
+endobj
+42 0 obj
+<<
+/Filter [ /ASCII85Decode /FlateDecode ] /Length 1530
+>>
+stream
+Gat=*bAQ?"&A70VqWM'A)G-7m^n*[A/.c3NR@ST,=<JD`C0MZVUr%o#rqgP1ZCQac0*25>80V2B<F+qo@eqD0^Sh1I/E$,l#p^rN<fgih#)f[(]=<0u9"H\I1n)9,R7&JUT]^<>Y1Ha^1catnlY>-&Kk0Im8lNK#15_js,brtL&dEDm2.&DfPoRY:K0s%PKR$Ff0qVkD$PpLnont,Lj"L8B_D7^B=tFUL9_5tWH2`<`B7Yo=a$9?M:QB3AJXs"eT_<oZHGRSBq[h1qMh0B6",=VM?nMR![ksCBbI7`q%5M3g:i]L5/aE9G9%873>%T?)bN6<H[q='V6M&2`UK-Ocrse<k,;c?#9%R%tEY#Uq6X>=_:915>b/!ob*qmT_*PnI:W#TXZMA@tJ1`3TK*N8'Q/3L9_iM;fEDJ2uH(Q2&SL,o:PIp9.g@=0Y^a3uk_3UZ+=Ejfu=[($JiX]E;8[/uc4k^D%R=eG3Zpk&!,G*_g9/!Ss#&IDDd.p:n(V&HjpS^NuN']]X>i=&qaK#[,P8M=GZ`^Uh@V![.?gZ%Y`2M+"nnguL8'1XO2Ek3B%(m/LK-FB)fl-<=eT%)%f@)=<o&sM)`Br#,rJ="2P=@/#W7PNbSXuI:&)>t-e-S-eh(T"Z1B0PXV1Jdl(U_iBG^;I\U!i82(!DqPV-lZM!VXn)9*Ci\a:@ecCFtgGHSSo#\8KCOFeMYeq4$0TBHIEPdNEZ`r4DR8q)),eQ[9B8"$7DejiC5%"h0Pj]g5@\8)^',[4,[S=Jjh8DCeVY)i8t6XqucTRnP]QTYRt\I*Dr!Dk1)K`L9sD5=G/MgIB.Bo?8kR4rR"7@:b)@DksW.X%-;3))400FXlkr2C[TR]ZMK_kZ>lKeZFhh#ZZPgO^YC>)=].1dNRD-`Q1Vm2NFs?UiWlpA`!Um)eE>P%GbD5aed?Q`dZTrgl`P$:UO9idI>i9hgCtgm2JeAk\tBGXe%Q&Q*i!*h\W&Y-`CZAMQ;YD*h^7l%/M";(desJJcDSB8)S%c%ek3!Se$ASH.4QX22AL/aN"#gM:F>6l)a<D.i$Y"YMRN5dQj27+&2s1b2iPb)RZI$RQl`(G\t;dWbJG+T)oUe(RcFOqU^q*!^#7/,9-ZuK#`-j8#GEPO..#?OJn%.gO+Qr!97<LkNDCK\[mj27fX5=BFF+t<0J"4:kdEP[eQ$Nf\.$Ygi9sU,:*tBg>\_a8oIL`$-dr-7R:n6"''9oqe)$JQ6PM%(+58P'fMYP?9&U!gXk^L62H^H>bA3_bZs>WV^lI1784Jt<%RWiem0t_9TWQ(j/8YN2H%8:)e>*]`6Sh<lRs'sd9'RrgJsn,VTV49;n8?e/"qaVt=Z7OX;-RHZ`UH]+TpgBk/'o*>RIPi).uVFYPn)7QQd/[\5)nLo`0i!,N5Ud#*hZc%WVi0&FmTD00SRiIEAu05UH"[$'8T-2/5Cc9r0KJ,)7<id>^^MhK?#g>_"[ZNLYG$g(B.!lqQU^GN!#MGfD#d%o)mDiq<3(CGMa+VoEBQNq@>B6R'c~>endstream
+endobj
+xref
+0 43
+0000000000 65535 f 
+0000000073 00000 n 
+0000000114 00000 n 
+0000000221 00000 n 
+0000000333 00000 n 
+0000000528 00000 n 
+0000000723 00000 n 
+0000000918 00000 n 
+0000001113 00000 n 
+0000001308 00000 n 
+0000001503 00000 n 
+0000001699 00000 n 
+0000001895 00000 n 
+0000002091 00000 n 
+0000002287 00000 n 
+0000002483 00000 n 
+0000002679 00000 n 
+0000002875 00000 n 
+0000003071 00000 n 
+0000003267 00000 n 
+0000003463 00000 n 
+0000003659 00000 n 
+0000003855 00000 n 
+0000003925 00000 n 
+0000004265 00000 n 
+0000004443 00000 n 
+0000006741 00000 n 
+0000008027 00000 n 
+0000011418 00000 n 
+0000013830 00000 n 
+0000015984 00000 n 
+0000018150 00000 n 
+0000020334 00000 n 
+0000022508 00000 n 
+0000024720 00000 n 
+0000026922 00000 n 
+0000029211 00000 n 
+0000031508 00000 n 
+0000033571 00000 n 
+0000035980 00000 n 
+0000037869 00000 n 
+0000039405 00000 n 
+0000040090 00000 n 
+trailer
+<<
+/ID 
+[<17101b4e73c42ad3c69edb43bada0062><17101b4e73c42ad3c69edb43bada0062>]
+% ReportLab generated PDF document -- digest (http://www.reportlab.com)
+
+/Info 23 0 R
+/Root 22 0 R
+/Size 43
+>>
+startxref
+41712
+%%EOF
diff --git a/tests/test_replay_boundaries.py b/tests/test_replay_boundaries.py
new file mode 100644
index 0000000000000000000000000000000000000000..a90db6bc89a939c793f536d350f8df00fadfc2aa
--- /dev/null
+++ b/tests/test_replay_boundaries.py
@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+import inspect
+
+from ouroboros_replay.replay import KERNEL_NAMES, compute_all
+
+def test_derivation_inventory_is_exact() -> None:
+    assert len(KERNEL_NAMES) == 49
+    assert len(set(KERNEL_NAMES)) == 49
+
+def test_compute_path_cannot_read_expected_answers() -> None:
+    source = inspect.getsource(compute_all).lower()
+    assert "reference" not in source
+    assert "expected" not in source
diff --git a/tests/test_sabrina_ads_radiation_spectral_commutator.py b/tests/test_sabrina_ads_radiation_spectral_commutator.py
new file mode 100644
index 0000000000000000000000000000000000000000..91e3b2528150458d07d6591ecd77ba496b18721e
--- /dev/null
+++ b/tests/test_sabrina_ads_radiation_spectral_commutator.py
@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from ouroboros_replay.kernels.run_sabrina_ads_radiation_spectral_commutator import build_exact_result
+
+def test_sabrina_ads_radiation_spectral_commutator_recomputes_with_all_exact_checks_passing() -> None:
+    result = build_exact_result()
+    checks = result.get("exact_checks")
+    assert isinstance(checks, dict) and checks
+    assert all(value is not False for value in checks.values())
+    assert isinstance(result.get("status"), str) and result["status"]
+    assert len(result) >= 5
diff --git a/tests/test_sabrina_ads_two_interval_scattering_feasibility.py b/tests/test_sabrina_ads_two_interval_scattering_feasibility.py
new file mode 100644
index 0000000000000000000000000000000000000000..5839cc6ba6458b371287acabc130676cbc93dc64
--- /dev/null
+++ b/tests/test_sabrina_ads_two_interval_scattering_feasibility.py
@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from ouroboros_replay.kernels.run_sabrina_ads_two_interval_scattering_feasibility import build_exact_result
+
+def test_sabrina_ads_two_interval_scattering_feasibility_recomputes_with_all_exact_checks_passing() -> None:
+    result = build_exact_result()
+    checks = result.get("exact_checks")
+    assert isinstance(checks, dict) and checks
+    assert all(value is not False for value in checks.values())
+    assert isinstance(result.get("status"), str) and result["status"]
+    assert len(result) >= 5
diff --git a/tests/test_sabrina_all_even_d_ward_normalization.py b/tests/test_sabrina_all_even_d_ward_normalization.py
new file mode 100644
index 0000000000000000000000000000000000000000..3fcd221daf4d9061baff60c2837b3531c17e0aae
--- /dev/null
+++ b/tests/test_sabrina_all_even_d_ward_normalization.py
@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from ouroboros_replay.kernels.run_sabrina_all_even_d_ward_normalization import build_exact_result
+
+def test_sabrina_all_even_d_ward_normalization_recomputes_with_all_exact_checks_passing() -> None:
+    result = build_exact_result()
+    checks = result.get("exact_checks")
+    assert isinstance(checks, dict) and checks
+    assert all(value is not False for value in checks.values())
+    assert isinstance(result.get("status"), str) and result["status"]
+    assert len(result) >= 5
diff --git a/tests/test_sabrina_all_m_transverse_nonlocality_chain.py b/tests/test_sabrina_all_m_transverse_nonlocality_chain.py
new file mode 100644
index 0000000000000000000000000000000000000000..3e52486e4b1f3cc409c94d05654f4eb43a38d035
--- /dev/null
+++ b/tests/test_sabrina_all_m_transverse_nonlocality_chain.py
@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from ouroboros_replay.kernels.run_sabrina_all_m_transverse_nonlocality_chain import build_exact_result
+
+def test_sabrina_all_m_transverse_nonlocality_chain_recomputes_with_all_exact_checks_passing() -> None:
+    result = build_exact_result()
+    checks = result.get("exact_checks")
+    assert isinstance(checks, dict) and checks
+    assert all(value is not False for value in checks.values())
+    assert isinstance(result.get("status"), str) and result["status"]
+    assert len(result) >= 5
diff --git a/tests/test_sabrina_ambidextrous_integer_prefactor_lattice.py b/tests/test_sabrina_ambidextrous_integer_prefactor_lattice.py
new file mode 100644
index 0000000000000000000000000000000000000000..0535530d88b61a42ebb6247aac87b4d0ced926d4
--- /dev/null
+++ b/tests/test_sabrina_ambidextrous_integer_prefactor_lattice.py
@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from ouroboros_replay.kernels.run_sabrina_ambidextrous_integer_prefactor_lattice import build_exact_result
+
+def test_sabrina_ambidextrous_integer_prefactor_lattice_recomputes_with_all_exact_checks_passing() -> None:
+    result = build_exact_result()
+    checks = result.get("exact_checks")
+    assert isinstance(checks, dict) and checks
+    assert all(value is not False for value in checks.values())
+    assert isinstance(result.get("status"), str) and result["status"]
+    assert len(result) >= 5
diff --git a/tests/test_sabrina_boundary_soft_scale_cocycle.py b/tests/test_sabrina_boundary_soft_scale_cocycle.py
new file mode 100644
index 0000000000000000000000000000000000000000..c5d7e708f05b01033b6de0aed2990a9ed3fb2a03
--- /dev/null
+++ b/tests/test_sabrina_boundary_soft_scale_cocycle.py
@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from ouroboros_replay.kernels.run_sabrina_boundary_soft_scale_cocycle import build_exact_result
+
+def test_sabrina_boundary_soft_scale_cocycle_recomputes_with_all_exact_checks_passing() -> None:
+    result = build_exact_result()
+    checks = result.get("exact_checks")
+    assert isinstance(checks, dict) and checks
+    assert all(value is not False for value in checks.values())
+    assert isinstance(result.get("status"), str) and result["status"]
+    assert len(result) >= 5
diff --git a/tests/test_sabrina_carrollian_celestial_weyl_intertwiner.py b/tests/test_sabrina_carrollian_celestial_weyl_intertwiner.py
new file mode 100644
index 0000000000000000000000000000000000000000..beb8856ad186a5121769bf1ce37707ad186335bf
--- /dev/null
+++ b/tests/test_sabrina_carrollian_celestial_weyl_intertwiner.py
@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from ouroboros_replay.kernels.run_sabrina_carrollian_celestial_weyl_intertwiner import build_exact_result
+
+def test_sabrina_carrollian_celestial_weyl_intertwiner_recomputes_with_all_exact_checks_passing() -> None:
+    result = build_exact_result()
+    checks = result.get("exact_checks")
+    assert isinstance(checks, dict) and checks
+    assert all(value is not False for value in checks.values())
+    assert isinstance(result.get("status"), str) and result["status"]
+    assert len(result) >= 5
diff --git a/tests/test_sabrina_carrollian_conglomerate_kernel_stratification.py b/tests/test_sabrina_carrollian_conglomerate_kernel_stratification.py
new file mode 100644
index 0000000000000000000000000000000000000000..0e28f53412ddefd451574a7e7c702af48e4c1522
--- /dev/null
+++ b/tests/test_sabrina_carrollian_conglomerate_kernel_stratification.py
@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from ouroboros_replay.kernels.run_sabrina_carrollian_conglomerate_kernel_stratification import build_exact_result
+
+def test_sabrina_carrollian_conglomerate_kernel_stratification_recomputes_with_all_exact_checks_passing() -> None:
+    result = build_exact_result()
+    checks = result.get("exact_checks")
+    assert isinstance(checks, dict) and checks
+    assert all(value is not False for value in checks.values())
+    assert isinstance(result.get("status"), str) and result["status"]
+    assert len(result) >= 5
diff --git a/tests/test_sabrina_causal_interior_inclusion_lemma.py b/tests/test_sabrina_causal_interior_inclusion_lemma.py
new file mode 100644
index 0000000000000000000000000000000000000000..e7f7e86f09cb88106aa3a7b123575301d968a784
--- /dev/null
+++ b/tests/test_sabrina_causal_interior_inclusion_lemma.py
@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from ouroboros_replay.kernels.run_sabrina_causal_interior_inclusion_lemma import build_exact_result
+
+def test_sabrina_causal_interior_inclusion_lemma_recomputes_with_all_exact_checks_passing() -> None:
+    result = build_exact_result()
+    checks = result.get("exact_checks")
+    assert isinstance(checks, dict) and checks
+    assert all(value is not False for value in checks.values())
+    assert isinstance(result.get("status"), str) and result["status"]
+    assert len(result) >= 5
diff --git a/tests/test_sabrina_cdqs_amplification_singleton_obstruction.py b/tests/test_sabrina_cdqs_amplification_singleton_obstruction.py
new file mode 100644
index 0000000000000000000000000000000000000000..94b446e85a6fcba59f820e3d40ef5c48d848b67c
--- /dev/null
+++ b/tests/test_sabrina_cdqs_amplification_singleton_obstruction.py
@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from ouroboros_replay.kernels.run_sabrina_cdqs_amplification_singleton_obstruction import build_exact_result
+
+def test_sabrina_cdqs_amplification_singleton_obstruction_recomputes_with_all_exact_checks_passing() -> None:
+    result = build_exact_result()
+    checks = result.get("exact_checks")
+    assert isinstance(checks, dict) and checks
+    assert all(value is not False for value in checks.values())
+    assert isinstance(result.get("status"), str) and result["status"]
+    assert len(result) >= 5
diff --git a/tests/test_sabrina_cdqs_fidelity_envelope_strengthening.py b/tests/test_sabrina_cdqs_fidelity_envelope_strengthening.py
new file mode 100644
index 0000000000000000000000000000000000000000..10d793da68cf96f112df3320af38fa3c268425dd
--- /dev/null
+++ b/tests/test_sabrina_cdqs_fidelity_envelope_strengthening.py
@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from ouroboros_replay.kernels.run_sabrina_cdqs_fidelity_envelope_strengthening import build_exact_result
+
+def test_sabrina_cdqs_fidelity_envelope_strengthening_recomputes_with_all_exact_checks_passing() -> None:
+    result = build_exact_result()
+    checks = result.get("exact_checks")
+    assert isinstance(checks, dict) and checks
+    assert all(value is not False for value in checks.values())
+    assert isinstance(result.get("status"), str) and result["status"]
+    assert len(result) >= 5
diff --git a/tests/test_sabrina_celestial_circle_convex_hull_certificate.py b/tests/test_sabrina_celestial_circle_convex_hull_certificate.py
new file mode 100644
index 0000000000000000000000000000000000000000..386a26462954ab4d2c942f3e3b9ddbf9b37f741f
--- /dev/null
+++ b/tests/test_sabrina_celestial_circle_convex_hull_certificate.py
@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from ouroboros_replay.kernels.run_sabrina_celestial_circle_convex_hull_certificate import build_exact_result
+
+def test_sabrina_celestial_circle_convex_hull_certificate_recomputes_with_all_exact_checks_passing() -> None:
+    result = build_exact_result()
+    checks = result.get("exact_checks")
+    assert isinstance(checks, dict) and checks
+    assert all(value is not False for value in checks.values())
+    assert isinstance(result.get("status"), str) and result["status"]
+    assert len(result) >= 5
diff --git a/tests/test_sabrina_celestial_eikonal_logarithm_gauge.py b/tests/test_sabrina_celestial_eikonal_logarithm_gauge.py
new file mode 100644
index 0000000000000000000000000000000000000000..940bb496aa1c3444c8beaa963eb315ac777eab1d
--- /dev/null
+++ b/tests/test_sabrina_celestial_eikonal_logarithm_gauge.py
@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from ouroboros_replay.kernels.run_sabrina_celestial_eikonal_logarithm_gauge import build_exact_result
+
+def test_sabrina_celestial_eikonal_logarithm_gauge_recomputes_with_all_exact_checks_passing() -> None:
+    result = build_exact_result()
+    checks = result.get("exact_checks")
+    assert isinstance(checks, dict) and checks
+    assert all(value is not False for value in checks.values())
+    assert isinstance(result.get("status"), str) and result["status"]
+    assert len(result) >= 5
diff --git a/tests/test_sabrina_celestial_euclidean_monodromy_cancellation.py b/tests/test_sabrina_celestial_euclidean_monodromy_cancellation.py
new file mode 100644
index 0000000000000000000000000000000000000000..97ab135bbcc5175c04940935ec2c0dd4bf1e2635
--- /dev/null
+++ b/tests/test_sabrina_celestial_euclidean_monodromy_cancellation.py
@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from ouroboros_replay.kernels.run_sabrina_celestial_euclidean_monodromy_cancellation import build_exact_result
+
+def test_sabrina_celestial_euclidean_monodromy_cancellation_recomputes_with_all_exact_checks_passing() -> None:
+    result = build_exact_result()
+    checks = result.get("exact_checks")
+    assert isinstance(checks, dict) and checks
+    assert all(value is not False for value in checks.values())
+    assert isinstance(result.get("status"), str) and result["status"]
+    assert len(result) >= 5
diff --git a/tests/test_sabrina_celestial_momentum_rising_factorial.py b/tests/test_sabrina_celestial_momentum_rising_factorial.py
new file mode 100644
index 0000000000000000000000000000000000000000..641f7f950e94defbfe845c8104c829e3e7f104ab
--- /dev/null
+++ b/tests/test_sabrina_celestial_momentum_rising_factorial.py
@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from ouroboros_replay.kernels.run_sabrina_celestial_momentum_rising_factorial import build_exact_result
+
+def test_sabrina_celestial_momentum_rising_factorial_recomputes_with_all_exact_checks_passing() -> None:
+    result = build_exact_result()
+    checks = result.get("exact_checks")
+    assert isinstance(checks, dict) and checks
+    assert all(value is not False for value in checks.values())
+    assert isinstance(result.get("status"), str) and result["status"]
+    assert len(result) >= 5
diff --git a/tests/test_sabrina_celestial_recursion_pde_generating_function.py b/tests/test_sabrina_celestial_recursion_pde_generating_function.py
new file mode 100644
index 0000000000000000000000000000000000000000..eaacabafa72a8bf2e589d5c54786e962f48cba10
--- /dev/null
+++ b/tests/test_sabrina_celestial_recursion_pde_generating_function.py
@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from ouroboros_replay.kernels.run_sabrina_celestial_recursion_pde_generating_function import build_exact_result
+
+def test_sabrina_celestial_recursion_pde_generating_function_recomputes_with_all_exact_checks_passing() -> None:
+    result = build_exact_result()
+    checks = result.get("exact_checks")
+    assert isinstance(checks, dict) and checks
+    assert all(value is not False for value in checks.values())
+    assert isinstance(result.get("status"), str) and result["status"]
+    assert len(result) >= 5
diff --git a/tests/test_sabrina_coulomb_branch_complexity_ratio.py b/tests/test_sabrina_coulomb_branch_complexity_ratio.py
new file mode 100644
index 0000000000000000000000000000000000000000..c6753eadf76de6205e8f110ccc2a0b8fb24ca1e2
--- /dev/null
+++ b/tests/test_sabrina_coulomb_branch_complexity_ratio.py
@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from ouroboros_replay.kernels.run_sabrina_coulomb_branch_complexity_ratio import build_exact_result
+
+def test_sabrina_coulomb_branch_complexity_ratio_recomputes_with_all_exact_checks_passing() -> None:
+    result = build_exact_result()
+    checks = result.get("exact_checks")
+    assert isinstance(checks, dict) and checks
+    assert all(value is not False for value in checks.values())
+    assert isinstance(result.get("status"), str) and result["status"]
+    assert len(result) >= 5
diff --git a/tests/test_sabrina_detector_sum_identity_correction.py b/tests/test_sabrina_detector_sum_identity_correction.py
new file mode 100644
index 0000000000000000000000000000000000000000..594d53258591c3b7b412abd003c23c1efeb08be9
--- /dev/null
+++ b/tests/test_sabrina_detector_sum_identity_correction.py
@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from ouroboros_replay.kernels.run_sabrina_detector_sum_identity_correction import build_exact_result
+
+def test_sabrina_detector_sum_identity_correction_recomputes_with_all_exact_checks_passing() -> None:
+    result = build_exact_result()
+    checks = result.get("exact_checks")
+    assert isinstance(checks, dict) and checks
+    assert all(value is not False for value in checks.values())
+    assert isinstance(result.get("status"), str) and result["status"]
+    assert len(result) >= 5
diff --git a/tests/test_sabrina_electromagnetic_memory_detector_tradeoff.py b/tests/test_sabrina_electromagnetic_memory_detector_tradeoff.py
new file mode 100644
index 0000000000000000000000000000000000000000..eb9ab2213a532e5867eb85bdabb83bee8df25b94
--- /dev/null
+++ b/tests/test_sabrina_electromagnetic_memory_detector_tradeoff.py
@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from ouroboros_replay.kernels.run_sabrina_electromagnetic_memory_detector_tradeoff import build_exact_result
+
+def test_sabrina_electromagnetic_memory_detector_tradeoff_recomputes_with_all_exact_checks_passing() -> None:
+    result = build_exact_result()
+    checks = result.get("exact_checks")
+    assert isinstance(checks, dict) and checks
+    assert all(value is not False for value in checks.values())
+    assert isinstance(result.get("status"), str) and result["status"]
+    assert len(result) >= 5
diff --git a/tests/test_sabrina_entanglement_scattering_slack_identity.py b/tests/test_sabrina_entanglement_scattering_slack_identity.py
new file mode 100644
index 0000000000000000000000000000000000000000..a437ee8192b6ef5fe78650328da86bbf6784931c
--- /dev/null
+++ b/tests/test_sabrina_entanglement_scattering_slack_identity.py
@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from ouroboros_replay.kernels.run_sabrina_entanglement_scattering_slack_identity import build_exact_result
+
+def test_sabrina_entanglement_scattering_slack_identity_recomputes_with_all_exact_checks_passing() -> None:
+    result = build_exact_result()
+    checks = result.get("exact_checks")
+    assert isinstance(checks, dict) and checks
+    assert all(value is not False for value in checks.values())
+    assert isinstance(result.get("status"), str) and result["status"]
+    assert len(result) >= 5
diff --git a/tests/test_sabrina_flat_boundary_corner_rank_drop.py b/tests/test_sabrina_flat_boundary_corner_rank_drop.py
new file mode 100644
index 0000000000000000000000000000000000000000..a059209f0f102c95b897bdc1db77aaaa09c4422d
--- /dev/null
+++ b/tests/test_sabrina_flat_boundary_corner_rank_drop.py
@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from ouroboros_replay.kernels.run_sabrina_flat_boundary_corner_rank_drop import build_exact_result
+
+def test_sabrina_flat_boundary_corner_rank_drop_recomputes_with_all_exact_checks_passing() -> None:
+    result = build_exact_result()
+    checks = result.get("exact_checks")
+    assert isinstance(checks, dict) and checks
+    assert all(value is not False for value in checks.values())
+    assert isinstance(result.get("status"), str) and result["status"]
+    assert len(result) >= 5
diff --git a/tests/test_sabrina_inverted_mellin_equivalence.py b/tests/test_sabrina_inverted_mellin_equivalence.py
new file mode 100644
index 0000000000000000000000000000000000000000..fb8497cb08ee438f70b14fa5e638736d21cb9bb2
--- /dev/null
+++ b/tests/test_sabrina_inverted_mellin_equivalence.py
@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from ouroboros_replay.kernels.run_sabrina_inverted_mellin_equivalence import build_exact_result
+
+def test_sabrina_inverted_mellin_equivalence_recomputes_with_all_exact_checks_passing() -> None:
+    result = build_exact_result()
+    checks = result.get("exact_checks")
+    assert isinstance(checks, dict) and checks
+    assert all(value is not False for value in checks.values())
+    assert isinstance(result.get("status"), str) and result["status"]
+    assert len(result) >= 5
diff --git a/tests/test_sabrina_late_time_three_cut_null_test.py b/tests/test_sabrina_late_time_three_cut_null_test.py
new file mode 100644
index 0000000000000000000000000000000000000000..c073948287f038449e23c005bea59a7dcf9d0466
--- /dev/null
+++ b/tests/test_sabrina_late_time_three_cut_null_test.py
@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from ouroboros_replay.kernels.run_sabrina_late_time_three_cut_null_test import build_exact_result
+
+def test_sabrina_late_time_three_cut_null_test_recomputes_with_all_exact_checks_passing() -> None:
+    result = build_exact_result()
+    checks = result.get("exact_checks")
+    assert isinstance(checks, dict) and checks
+    assert all(value is not False for value in checks.values())
+    assert isinstance(result.get("status"), str) and result["status"]
+    assert len(result) >= 5
diff --git a/tests/test_sabrina_late_time_two_cut_reconstruction.py b/tests/test_sabrina_late_time_two_cut_reconstruction.py
new file mode 100644
index 0000000000000000000000000000000000000000..386d6c37630efea1cf04f4aaaca8cf04529373ac
--- /dev/null
+++ b/tests/test_sabrina_late_time_two_cut_reconstruction.py
@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from ouroboros_replay.kernels.run_sabrina_late_time_two_cut_reconstruction import build_exact_result
+
+def test_sabrina_late_time_two_cut_reconstruction_recomputes_with_all_exact_checks_passing() -> None:
+    result = build_exact_result()
+    checks = result.get("exact_checks")
+    assert isinstance(checks, dict) and checks
+    assert all(value is not False for value in checks.values())
+    assert isinstance(result.get("status"), str) and result["status"]
+    assert len(result) >= 5
diff --git a/tests/test_sabrina_logarithmic_mellin_pole_order_correction.py b/tests/test_sabrina_logarithmic_mellin_pole_order_correction.py
new file mode 100644
index 0000000000000000000000000000000000000000..ca5d2e5d0f447b627c74c3ea0d81f8cf590f8166
--- /dev/null
+++ b/tests/test_sabrina_logarithmic_mellin_pole_order_correction.py
@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from ouroboros_replay.kernels.run_sabrina_logarithmic_mellin_pole_order_correction import build_exact_result
+
+def test_sabrina_logarithmic_mellin_pole_order_correction_recomputes_with_all_exact_checks_passing() -> None:
+    result = build_exact_result()
+    checks = result.get("exact_checks")
+    assert isinstance(checks, dict) and checks
+    assert all(value is not False for value in checks.values())
+    assert isinstance(result.get("status"), str) and result["status"]
+    assert len(result) >= 5
diff --git a/tests/test_sabrina_low_hard_generator_nonclosure.py b/tests/test_sabrina_low_hard_generator_nonclosure.py
new file mode 100644
index 0000000000000000000000000000000000000000..7df0e32325c0a3bc5e8507e1f052db4ba43e90ab
--- /dev/null
+++ b/tests/test_sabrina_low_hard_generator_nonclosure.py
@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from ouroboros_replay.kernels.run_sabrina_low_hard_generator_nonclosure import build_exact_result
+
+def test_sabrina_low_hard_generator_nonclosure_recomputes_with_all_exact_checks_passing() -> None:
+    result = build_exact_result()
+    checks = result.get("exact_checks")
+    assert isinstance(checks, dict) and checks
+    assert all(value is not False for value in checks.values())
+    assert isinstance(result.get("status"), str) and result["status"]
+    assert len(result) >= 5
diff --git a/tests/test_sabrina_m3_unclassified_module_construction.py b/tests/test_sabrina_m3_unclassified_module_construction.py
new file mode 100644
index 0000000000000000000000000000000000000000..fab63c41d134d8c5fd3ce38ffe261e8f36b3d69f
--- /dev/null
+++ b/tests/test_sabrina_m3_unclassified_module_construction.py
@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from ouroboros_replay.kernels.run_sabrina_m3_unclassified_module_construction import build_exact_result
+
+def test_sabrina_m3_unclassified_module_construction_recomputes_with_all_exact_checks_passing() -> None:
+    result = build_exact_result()
+    checks = result.get("exact_checks")
+    assert isinstance(checks, dict) and checks
+    assert all(value is not False for value in checks.values())
+    assert isinstance(result.get("status"), str) and result["status"]
+    assert len(result) >= 5
diff --git a/tests/test_sabrina_multiparticle_beta_residue_factor_two.py b/tests/test_sabrina_multiparticle_beta_residue_factor_two.py
new file mode 100644
index 0000000000000000000000000000000000000000..6abd2d64b2a1bdaaa9be59b33986b6c812cdf5c2
--- /dev/null
+++ b/tests/test_sabrina_multiparticle_beta_residue_factor_two.py
@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from ouroboros_replay.kernels.run_sabrina_multiparticle_beta_residue_factor_two import build_exact_result
+
+def test_sabrina_multiparticle_beta_residue_factor_two_recomputes_with_all_exact_checks_passing() -> None:
+    result = build_exact_result()
+    checks = result.get("exact_checks")
+    assert isinstance(checks, dict) and checks
+    assert all(value is not False for value in checks.values())
+    assert isinstance(result.get("status"), str) and result["status"]
+    assert len(result) >= 5
diff --git a/tests/test_sabrina_near_extremal_radial_pushforward.py b/tests/test_sabrina_near_extremal_radial_pushforward.py
new file mode 100644
index 0000000000000000000000000000000000000000..628c6bbb1cd90b81d0f4b48965cfb6c0bbeab54e
--- /dev/null
+++ b/tests/test_sabrina_near_extremal_radial_pushforward.py
@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from ouroboros_replay.kernels.run_sabrina_near_extremal_radial_pushforward import build_exact_result
+
+def test_sabrina_near_extremal_radial_pushforward_recomputes_with_all_exact_checks_passing() -> None:
+    result = build_exact_result()
+    checks = result.get("exact_checks")
+    assert isinstance(checks, dict) and checks
+    assert all(value is not False for value in checks.values())
+    assert isinstance(result.get("status"), str) and result["status"]
+    assert len(result) >= 5
diff --git a/tests/test_sabrina_p4_spherical_entanglement_expansion.py b/tests/test_sabrina_p4_spherical_entanglement_expansion.py
new file mode 100644
index 0000000000000000000000000000000000000000..d263d232e3e0ec747800e16cf380554c5145f841
--- /dev/null
+++ b/tests/test_sabrina_p4_spherical_entanglement_expansion.py
@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from ouroboros_replay.kernels.run_sabrina_p4_spherical_entanglement_expansion import build_exact_result
+
+def test_sabrina_p4_spherical_entanglement_expansion_recomputes_with_all_exact_checks_passing() -> None:
+    result = build_exact_result()
+    checks = result.get("exact_checks")
+    assert isinstance(checks, dict) and checks
+    assert all(value is not False for value in checks.values())
+    assert isinstance(result.get("status"), str) and result["status"]
+    assert len(result) >= 5
diff --git a/tests/test_sabrina_p4_spherical_refined_entropy.py b/tests/test_sabrina_p4_spherical_refined_entropy.py
new file mode 100644
index 0000000000000000000000000000000000000000..5692463ca3b2479b69590ceba2abe414cca8e42e
--- /dev/null
+++ b/tests/test_sabrina_p4_spherical_refined_entropy.py
@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from ouroboros_replay.kernels.run_sabrina_p4_spherical_refined_entropy import build_exact_result
+
+def test_sabrina_p4_spherical_refined_entropy_recomputes_with_all_exact_checks_passing() -> None:
+    result = build_exact_result()
+    checks = result.get("exact_checks")
+    assert isinstance(checks, dict) and checks
+    assert all(value is not False for value in checks.values())
+    assert isinstance(result.get("status"), str) and result["status"]
+    assert len(result) >= 5
diff --git a/tests/test_sabrina_points_scattering_lower_slack_identity.py b/tests/test_sabrina_points_scattering_lower_slack_identity.py
new file mode 100644
index 0000000000000000000000000000000000000000..3af2877aac0b0496d442a6ba816748a083c2ea57
--- /dev/null
+++ b/tests/test_sabrina_points_scattering_lower_slack_identity.py
@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from ouroboros_replay.kernels.run_sabrina_points_scattering_lower_slack_identity import build_exact_result
+
+def test_sabrina_points_scattering_lower_slack_identity_recomputes_with_all_exact_checks_passing() -> None:
+    result = build_exact_result()
+    checks = result.get("exact_checks")
+    assert isinstance(checks, dict) and checks
+    assert all(value is not False for value in checks.values())
+    assert isinstance(result.get("status"), str) and result["status"]
+    assert len(result) >= 5
diff --git a/tests/test_sabrina_principal_series_plancherel_factorization.py b/tests/test_sabrina_principal_series_plancherel_factorization.py
new file mode 100644
index 0000000000000000000000000000000000000000..df4afbac315e287e18f28636cf96474ba83bcbad
--- /dev/null
+++ b/tests/test_sabrina_principal_series_plancherel_factorization.py
@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from ouroboros_replay.kernels.run_sabrina_principal_series_plancherel_factorization import build_exact_result
+
+def test_sabrina_principal_series_plancherel_factorization_recomputes_with_all_exact_checks_passing() -> None:
+    result = build_exact_result()
+    checks = result.get("exact_checks")
+    assert isinstance(checks, dict) and checks
+    assert all(value is not False for value in checks.values())
+    assert isinstance(result.get("status"), str) and result["status"]
+    assert len(result) >= 5
diff --git a/tests/test_sabrina_projective_mellin_scale_theorem.py b/tests/test_sabrina_projective_mellin_scale_theorem.py
new file mode 100644
index 0000000000000000000000000000000000000000..30983fb498ae0875d8ef585b875240be407438e2
--- /dev/null
+++ b/tests/test_sabrina_projective_mellin_scale_theorem.py
@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from ouroboros_replay.kernels.run_sabrina_projective_mellin_scale_theorem import build_exact_result
+
+def test_sabrina_projective_mellin_scale_theorem_recomputes_with_all_exact_checks_passing() -> None:
+    result = build_exact_result()
+    checks = result.get("exact_checks")
+    assert isinstance(checks, dict) and checks
+    assert all(value is not False for value in checks.values())
+    assert isinstance(result.get("status"), str) and result["status"]
+    assert len(result) >= 5
diff --git a/tests/test_sabrina_projective_simplex_positivity_theorem.py b/tests/test_sabrina_projective_simplex_positivity_theorem.py
new file mode 100644
index 0000000000000000000000000000000000000000..b3df583ef6aa26f2f97720fe33539a1da3ffebe0
--- /dev/null
+++ b/tests/test_sabrina_projective_simplex_positivity_theorem.py
@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from ouroboros_replay.kernels.run_sabrina_projective_simplex_positivity_theorem import build_exact_result
+
+def test_sabrina_projective_simplex_positivity_theorem_recomputes_with_all_exact_checks_passing() -> None:
+    result = build_exact_result()
+    checks = result.get("exact_checks")
+    assert isinstance(checks, dict) and checks
+    assert all(value is not False for value in checks.values())
+    assert isinstance(result.get("status"), str) and result["status"]
+    assert len(result) >= 5
diff --git a/tests/test_sabrina_projective_simplex_rank_theorem.py b/tests/test_sabrina_projective_simplex_rank_theorem.py
new file mode 100644
index 0000000000000000000000000000000000000000..955d75d5253703ec695db4bc6264770aa0f4a71d
--- /dev/null
+++ b/tests/test_sabrina_projective_simplex_rank_theorem.py
@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from ouroboros_replay.kernels.run_sabrina_projective_simplex_rank_theorem import build_exact_result
+
+def test_sabrina_projective_simplex_rank_theorem_recomputes_with_all_exact_checks_passing() -> None:
+    result = build_exact_result()
+    checks = result.get("exact_checks")
+    assert isinstance(checks, dict) and checks
+    assert all(value is not False for value in checks.values())
+    assert isinstance(result.get("status"), str) and result["status"]
+    assert len(result) >= 5
diff --git a/tests/test_sabrina_quadrupole_spin_memory_cap_duality.py b/tests/test_sabrina_quadrupole_spin_memory_cap_duality.py
new file mode 100644
index 0000000000000000000000000000000000000000..e34dcc99c86e3dc05d59c039d049b2dadbb93099
--- /dev/null
+++ b/tests/test_sabrina_quadrupole_spin_memory_cap_duality.py
@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from ouroboros_replay.kernels.run_sabrina_quadrupole_spin_memory_cap_duality import build_exact_result
+
+def test_sabrina_quadrupole_spin_memory_cap_duality_recomputes_with_all_exact_checks_passing() -> None:
+    result = build_exact_result()
+    checks = result.get("exact_checks")
+    assert isinstance(checks, dict) and checks
+    assert all(value is not False for value in checks.values())
+    assert isinstance(result.get("status"), str) and result["status"]
+    assert len(result) >= 5
diff --git a/tests/test_sabrina_radial_einstein_square_factorization.py b/tests/test_sabrina_radial_einstein_square_factorization.py
new file mode 100644
index 0000000000000000000000000000000000000000..0bc77ae34bb1f7ad4c6bbefefe7e48bba13efd30
--- /dev/null
+++ b/tests/test_sabrina_radial_einstein_square_factorization.py
@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from ouroboros_replay.kernels.run_sabrina_radial_einstein_square_factorization import build_exact_result
+
+def test_sabrina_radial_einstein_square_factorization_recomputes_with_all_exact_checks_passing() -> None:
+    result = build_exact_result()
+    checks = result.get("exact_checks")
+    assert isinstance(checks, dict) and checks
+    assert all(value is not False for value in checks.values())
+    assert isinstance(result.get("status"), str) and result["status"]
+    assert len(result) >= 5
diff --git a/tests/test_sabrina_rt_area_boundary_identity.py b/tests/test_sabrina_rt_area_boundary_identity.py
new file mode 100644
index 0000000000000000000000000000000000000000..19606d3f8605cccb4a9a1845f279a38b8f0e9912
--- /dev/null
+++ b/tests/test_sabrina_rt_area_boundary_identity.py
@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from ouroboros_replay.kernels.run_sabrina_rt_area_boundary_identity import build_exact_result
+
+def test_sabrina_rt_area_boundary_identity_recomputes_with_all_exact_checks_passing() -> None:
+    result = build_exact_result()
+    checks = result.get("exact_checks")
+    assert isinstance(checks, dict) and checks
+    assert all(value is not False for value in checks.values())
+    assert isinstance(result.get("status"), str) and result["status"]
+    assert len(result) >= 5
diff --git a/tests/test_sabrina_soft_charge_cumulant_hierarchy.py b/tests/test_sabrina_soft_charge_cumulant_hierarchy.py
new file mode 100644
index 0000000000000000000000000000000000000000..ffb1fa227f62fe33ca36aaad98a9fd11026a0375
--- /dev/null
+++ b/tests/test_sabrina_soft_charge_cumulant_hierarchy.py
@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from ouroboros_replay.kernels.run_sabrina_soft_charge_cumulant_hierarchy import build_exact_result
+
+def test_sabrina_soft_charge_cumulant_hierarchy_recomputes_with_all_exact_checks_passing() -> None:
+    result = build_exact_result()
+    checks = result.get("exact_checks")
+    assert isinstance(checks, dict) and checks
+    assert all(value is not False for value in checks.values())
+    assert isinstance(result.get("status"), str) and result["status"]
+    assert len(result) >= 5
diff --git a/tests/test_sabrina_soft_charge_reduced_state_theorem.py b/tests/test_sabrina_soft_charge_reduced_state_theorem.py
new file mode 100644
index 0000000000000000000000000000000000000000..c672e7ddf9657241dfdbf74c16d8054d6e9d1658
--- /dev/null
+++ b/tests/test_sabrina_soft_charge_reduced_state_theorem.py
@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from ouroboros_replay.kernels.run_sabrina_soft_charge_reduced_state_theorem import build_exact_result
+
+def test_sabrina_soft_charge_reduced_state_theorem_recomputes_with_all_exact_checks_passing() -> None:
+    result = build_exact_result()
+    checks = result.get("exact_checks")
+    assert isinstance(checks, dict) and checks
+    assert all(value is not False for value in checks.values())
+    assert isinstance(result.get("status"), str) and result["status"]
+    assert len(result) >= 5
diff --git a/tests/test_sabrina_soft_dressing_factor_two_no_go.py b/tests/test_sabrina_soft_dressing_factor_two_no_go.py
new file mode 100644
index 0000000000000000000000000000000000000000..a19f4575a2df532e6068e212d5dbfb3aa4e06d0b
--- /dev/null
+++ b/tests/test_sabrina_soft_dressing_factor_two_no_go.py
@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from ouroboros_replay.kernels.run_sabrina_soft_dressing_factor_two_no_go import build_exact_result
+
+def test_sabrina_soft_dressing_factor_two_no_go_recomputes_with_all_exact_checks_passing() -> None:
+    result = build_exact_result()
+    checks = result.get("exact_checks")
+    assert isinstance(checks, dict) and checks
+    assert all(value is not False for value in checks.values())
+    assert isinstance(result.get("status"), str) and result["status"]
+    assert len(result) >= 5
diff --git a/tests/test_sabrina_soft_mellin_residue_identity.py b/tests/test_sabrina_soft_mellin_residue_identity.py
new file mode 100644
index 0000000000000000000000000000000000000000..5353556980c7284a30f48f51446b160396ccd00b
--- /dev/null
+++ b/tests/test_sabrina_soft_mellin_residue_identity.py
@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from ouroboros_replay.kernels.run_sabrina_soft_mellin_residue_identity import build_exact_result
+
+def test_sabrina_soft_mellin_residue_identity_recomputes_with_all_exact_checks_passing() -> None:
+    result = build_exact_result()
+    checks = result.get("exact_checks")
+    assert isinstance(checks, dict) and checks
+    assert all(value is not False for value in checks.values())
+    assert isinstance(result.get("status"), str) and result["status"]
+    assert len(result) >= 5
diff --git a/tests/test_sabrina_spin1_shadow_gauge_obstruction.py b/tests/test_sabrina_spin1_shadow_gauge_obstruction.py
new file mode 100644
index 0000000000000000000000000000000000000000..e8e8f916a9120f1ca372e09e6893916093c90501
--- /dev/null
+++ b/tests/test_sabrina_spin1_shadow_gauge_obstruction.py
@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from ouroboros_replay.kernels.run_sabrina_spin1_shadow_gauge_obstruction import build_exact_result
+
+def test_sabrina_spin1_shadow_gauge_obstruction_recomputes_with_all_exact_checks_passing() -> None:
+    result = build_exact_result()
+    checks = result.get("exact_checks")
+    assert isinstance(checks, dict) and checks
+    assert all(value is not False for value in checks.values())
+    assert isinstance(result.get("status"), str) and result["status"]
+    assert len(result) >= 5
diff --git a/tests/test_sabrina_subleading_soft_gauge_defect_theorem.py b/tests/test_sabrina_subleading_soft_gauge_defect_theorem.py
new file mode 100644
index 0000000000000000000000000000000000000000..cf371e01fb6d38b9f097a863a18a3f2fd4112563
--- /dev/null
+++ b/tests/test_sabrina_subleading_soft_gauge_defect_theorem.py
@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from ouroboros_replay.kernels.run_sabrina_subleading_soft_gauge_defect_theorem import build_exact_result
+
+def test_sabrina_subleading_soft_gauge_defect_theorem_recomputes_with_all_exact_checks_passing() -> None:
+    result = build_exact_result()
+    checks = result.get("exact_checks")
+    assert isinstance(checks, dict) and checks
+    assert all(value is not False for value in checks.values())
+    assert isinstance(result.get("status"), str) and result["status"]
+    assert len(result) >= 5
diff --git a/tests/test_sabrina_super_bms_commutator_syzygy_family.py b/tests/test_sabrina_super_bms_commutator_syzygy_family.py
new file mode 100644
index 0000000000000000000000000000000000000000..a7282604693698c2aeada6c350c7ed22a2cbbfde
--- /dev/null
+++ b/tests/test_sabrina_super_bms_commutator_syzygy_family.py
@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from ouroboros_replay.kernels.run_sabrina_super_bms_commutator_syzygy_family import build_exact_result
+
+def test_sabrina_super_bms_commutator_syzygy_family_recomputes_with_all_exact_checks_passing() -> None:
+    result = build_exact_result()
+    checks = result.get("exact_checks")
+    assert isinstance(checks, dict) and checks
+    assert all(value is not False for value in checks.values())
+    assert isinstance(result.get("status"), str) and result["status"]
+    assert len(result) >= 5
diff --git a/tests/test_sabrina_superrotation_charge_cancellation.py b/tests/test_sabrina_superrotation_charge_cancellation.py
new file mode 100644
index 0000000000000000000000000000000000000000..f9d0b2cb161ad4ed68839f51211d3cfde0a82062
--- /dev/null
+++ b/tests/test_sabrina_superrotation_charge_cancellation.py
@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from ouroboros_replay.kernels.run_sabrina_superrotation_charge_cancellation import build_exact_result
+
+def test_sabrina_superrotation_charge_cancellation_recomputes_with_all_exact_checks_passing() -> None:
+    result = build_exact_result()
+    checks = result.get("exact_checks")
+    assert isinstance(checks, dict) and checks
+    assert all(value is not False for value in checks.values())
+    assert isinstance(result.get("status"), str) and result["status"]
+    assert len(result) >= 5
diff --git a/tests/test_sabrina_two_particle_kernel_variance.py b/tests/test_sabrina_two_particle_kernel_variance.py
new file mode 100644
index 0000000000000000000000000000000000000000..7b822aeffe6d3a0df0e38f80ff9dd80f70a090fb
--- /dev/null
+++ b/tests/test_sabrina_two_particle_kernel_variance.py
@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from ouroboros_replay.kernels.run_sabrina_two_particle_kernel_variance import build_exact_result
+
+def test_sabrina_two_particle_kernel_variance_recomputes_with_all_exact_checks_passing() -> None:
+    result = build_exact_result()
+    checks = result.get("exact_checks")
+    assert isinstance(checks, dict) and checks
+    assert all(value is not False for value in checks.values())
+    assert isinstance(result.get("status"), str) and result["status"]
+    assert len(result) >= 5
diff --git a/tests/test_sabrina_weyl_double_copy_shadow_involution.py b/tests/test_sabrina_weyl_double_copy_shadow_involution.py
new file mode 100644
index 0000000000000000000000000000000000000000..5d74f88a8c40f741db71b11ade6c5760ca8612eb
--- /dev/null
+++ b/tests/test_sabrina_weyl_double_copy_shadow_involution.py
@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from ouroboros_replay.kernels.run_sabrina_weyl_double_copy_shadow_involution import build_exact_result
+
+def test_sabrina_weyl_double_copy_shadow_involution_recomputes_with_all_exact_checks_passing() -> None:
+    result = build_exact_result()
+    checks = result.get("exact_checks")
+    assert isinstance(checks, dict) and checks
+    assert all(value is not False for value in checks.values())
+    assert isinstance(result.get("status"), str) and result["status"]
+    assert len(result) >= 5
diff --git a/validation/clean_room_replay_receipt.json b/validation/clean_room_replay_receipt.json
new file mode 100644
index 0000000000000000000000000000000000000000..0510fb6c93b2812fddb981dcce4d559f778b6834
--- /dev/null
+++ b/validation/clean_room_replay_receipt.json
@@ -0,0 +1,31 @@
+{
+  "all_exact_checks_passed": true,
+  "all_falsifiers_passed": true,
+  "all_generated_payloads_match": true,
+  "all_public_source_hashes_verified": true,
+  "candidate_is_byte_identical_to_cleanroom_validated_replay_scope": true,
+  "candidate_replay_scope_file_count": 160,
+  "candidate_replay_scope_sha256": "114a559fb22dba10c81804d08edf61aec6678ce602ab4a0dc9b3ccf77783b69d",
+  "cleanroom_contract_sha256": "ef3879b8b5f97168f1c5e20be1718584bf943522b4951bb703944e210036f88e",
+  "cleanroom_target_declared_absent": true,
+  "derivation_kernel_count": 49,
+  "post_compute_comparison_count": 49,
+  "public_actions_allowed": false,
+  "public_source_count": 36,
+  "pytest_status": "passed",
+  "pytest_test_count": 51,
+  "receipt_hashes": {
+    "comparison": "35b2aea1cf2c1f81d04cf9597bb91e1feccc68c87c44fbd8324e609ad64a89be",
+    "compute": "e41c9cc6cc6c67eeb1bb7d22d9b1e09c9fc11c753773c75593f7e2e25b46a493",
+    "falsifier": "eecde8eaee63c4cebd832d9865df4f6564eabf6ca904b631209b80a02dea2d22"
+  },
+  "receipt_sha256": "43f7bb37973f96cbb6cf7c872ab4ee20e8de42fd9b110b66f76adeb45503ca9c",
+  "receipt_verification_is_scientific_replay": false,
+  "schema": "ouroboros_public_cleanroom_validation_receipt_v1",
+  "source_cache_initial_state": "absent target declared by admitted create-files contract",
+  "upload_performed": false,
+  "validated_replay_scope_file_count": 160,
+  "validated_replay_scope_sha256": "114a559fb22dba10c81804d08edf61aec6678ce602ab4a0dc9b3ccf77783b69d",
+  "validation_class": "independent_compute_before_reference_comparison",
+  "validation_passed": true
+}