diff --git a/.github/workflows/sw1-m1-nd-salvage-phase-diagram.yml b/.github/workflows/sw1-m1-nd-salvage-phase-diagram.yml
new file mode 100644
index 00000000..3af6b287
--- /dev/null
+++ b/.github/workflows/sw1-m1-nd-salvage-phase-diagram.yml
@@ -0,0 +1,63 @@
+name: SW1 M1-ND salvage phase diagram
+
+on:
+  push:
+    branches:
+      - research/sw1-m1-nd-salvage-phase-diagram
+    paths:
+      - 'audits/P11_R32_SW1_M1_ND_SALVAGE_A0_PHASE_DIAGRAM_FIREWALL.md'
+      - 'scripts/certify_sw1_m1_nd_salvage_a0_counting_firewall.py'
+      - 'scripts/probe_sw1_m1_nd_salvage_phase_diagram.py'
+      - 'scripts/certify_sw1_m1_nd_salvage_a1_a2_uniform_blind_wedge.py'
+      - 'scripts/certify_sw1_m1_nd_salvage_direct_complement_crosscheck.py'
+      - 'scripts/certify_sw1_m1_nd_salvage_uniform_raw_word_graph.py'
+      - 'audits/P11_R32_SW1_M1_ND_SALVAGE_A1_A2_UNIFORM_BLIND_WEDGE_CANDIDATE.md'
+      - 'audits/P11_R32_SW1_M1_ND_SALVAGE_A1_A2_REVIEW_PACKET.md'
+      - 'audits/P11_R32_SW1_M1_ND_SALVAGE_A1_A2_ANALYTIC_HANDOFF_CANDIDATE.md'
+      - '.github/workflows/sw1-m1-nd-salvage-phase-diagram.yml'
+  workflow_dispatch:
+
+jobs:
+  salvage:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+
+      - name: Install SymPy
+        run: python -m pip install sympy==1.14.0
+
+      - name: Record provenance
+        run: |
+          python --version
+          python -c "import sympy; print('sympy='+sympy.__version__)"
+          git rev-parse HEAD
+          git hash-object audits/P11_R32_SW1_M1_ND_SALVAGE_A0_PHASE_DIAGRAM_FIREWALL.md
+          git hash-object scripts/certify_sw1_m1_nd_salvage_a0_counting_firewall.py
+          git hash-object scripts/probe_sw1_m1_nd_salvage_phase_diagram.py
+          git hash-object audits/P11_R32_SW1_M1_ND_SALVAGE_A1_A2_ANALYTIC_HANDOFF_CANDIDATE.md
+          git hash-object audits/P11_R32_SW1_M1_ND_SALVAGE_A1_A2_REVIEW_PACKET.md
+          git hash-object scripts/certify_sw1_m1_nd_salvage_a1_a2_uniform_blind_wedge.py
+          git hash-object scripts/certify_sw1_m1_nd_salvage_direct_complement_crosscheck.py
+          git hash-object scripts/certify_sw1_m1_nd_salvage_uniform_raw_word_graph.py
+          git hash-object audits/P11_R32_SW1_M1_ND_SALVAGE_A1_A2_UNIFORM_BLIND_WEDGE_CANDIDATE.md
+
+      - name: Run counting firewall certificate
+        run: python scripts/certify_sw1_m1_nd_salvage_a0_counting_firewall.py
+
+      - name: Run full-saturation phase diagram probe
+        run: python scripts/probe_sw1_m1_nd_salvage_phase_diagram.py
+
+      - name: Run exact uniform blind wedge certificate
+        run: python scripts/certify_sw1_m1_nd_salvage_a1_a2_uniform_blind_wedge.py
+
+      - name: Run direct complement invariance cross-check
+        run: python scripts/certify_sw1_m1_nd_salvage_direct_complement_crosscheck.py
+
+      - name: Run epsilon-uniform raw-word graph cross-check
+        run: python scripts/certify_sw1_m1_nd_salvage_uniform_raw_word_graph.py
diff --git a/audits/P11_R32_SW1_M1_ND_SALVAGE_A0_PHASE_DIAGRAM_FIREWALL.md b/audits/P11_R32_SW1_M1_ND_SALVAGE_A0_PHASE_DIAGRAM_FIREWALL.md
new file mode 100644
index 00000000..15872cb9
--- /dev/null
+++ b/audits/P11_R32_SW1_M1_ND_SALVAGE_A0_PHASE_DIAGRAM_FIREWALL.md
@@ -0,0 +1,468 @@
+# P11/R32 — SW1 M1-ND SALVAGE-A0 Phase-Diagram Firewall
+
+> **Stand:** 1. September 2026  
+> **Branch:** `research/sw1-m1-nd-salvage-phase-diagram`  
+> **Status:** Arbeitsdefinition / AI-GREEN candidate scope only; keine Promotion.  
+> **Input:** `M1-ND-IMG4-SMALLR: ✓[M]_neg`, IMG3 linear visibility,
+> A7/A8 FREE graphing, IMG4 Mass-Transport/Reducing mechanism.
+
+---
+
+## 1. Zweck
+
+Nach der negativen Promotion des expliziten Small-`R`-Witness ist die
+universelle SW1-Injektivitätsfrage beendet. Die neue Frage ist nicht
+
+\[
+\ker\mathscr N_R=\{0\}\quad\text{auf ganz SW1?}
+\]
+
+sondern:
+
+> Wo liegt die tatsächliche geometrische Degenerationsregion, und wo beginnt
+> überhaupt ein Parameterbereich, in dem Transversalität noch möglich ist?
+
+Dieses Dokument verhindert insbesondere den Fehlschluss
+
+\[
+\boxed{
+\text{volle geometrische Sichtbarkeit}
+\not\Longrightarrow
+\ker\mathscr N_R=\{0\}.
+}
+\tag{S0.1}
+\]
+
+---
+
+## 2. Parameterraum und Defekt
+
+Im unteren SW1-Chamber betrachten wir
+
+\[
+0<\varepsilon<\Delta/2,
+\qquad
+0<R<\varepsilon,
+\qquad
+0<\sigma<R.
+\]
+
+Sei \(U_R\) die Vereinigung der sechs KNF-Samplinghalbfenster und
+
+\[
+V_{\varepsilon,R}
+:=
+\operatorname{Sat}_{\mathcal E_\varepsilon}(U_R)
+\]
+
+ihre vollständige Sättigung unter dem tatsächlichen A7/A8-FREE-Graphing.
+
+Sei \(W^{\rm vis}_{\varepsilon,R,\sigma}\subset(R,S)\),
+\(S=T+\sigma\), die **tatsächliche** positive Annulus-Sichtbarkeitsmenge
+unter den sechs Hub-Source-Maps
+
+\[
+|x-a|,\ x+a,\ |x-b|,\ x+b,\ |x-T|,\ x+T.
+\]
+
+Definiere den geometrischen Defekt
+
+\[
+\boxed{
+\beta(\varepsilon,R,\sigma)
+:=
+\bigl|(R,S)\setminus
+W^{\rm vis}_{\varepsilon,R,\sigma}\bigr|.
+}
+\tag{S0.2}
+\]
+
+Die degenerierte geometrische Region ist
+
+\[
+\mathcal D_{\rm blind}
+=
+\{(\varepsilon,R,\sigma):\beta>0\}.
+\]
+
+IMG4 liefert dort durch denselben Reducing-/Blindset-Mechanismus einen
+nichttrivialen zulässigen Kernel.
+
+---
+
+## 3. Drei logisch verschiedene Regime
+
+### BLIND
+
+\[
+\boxed{\beta>0.}
+\]
+
+Dann existiert ein positiver Annulus-Blindsetanteil. Unter den bereits
+promotierten IMG4-Gates folgt ein nichttrivialer zulässiger Kernel.
+
+### VISIBLE
+
+\[
+\boxed{\beta=0.}
+\]
+
+Dies bedeutet ausschließlich geometrische Supportdeckung.
+
+Es folgt **nicht**
+
+\[
+\ker\mathscr N_R=\{0\}.
+\]
+
+Koeffizientencancellation, lineare Abhängigkeit und fehlende Transversalität
+bleiben möglich.
+
+### TRANSVERSAL
+
+Erst eine quantitative Operatorabschätzung der Form
+
+\[
+\boxed{
+\|\mathscr N_R(f,g)\|
+\ge
+c(\varepsilon,R,\sigma)
+\bigl(\|f\|+\|g\|\bigr),
+\qquad c>0,
+}
+\tag{S0.3}
+\]
+
+oder eine äquivalente exakte Injektivitäts-/Coercivity-Aussage würde den
+nichtdegeneraten Bereich schließen.
+
+Damit gilt die zwingende Reihenfolge
+
+\[
+\boxed{
+\text{BLIND}
+\to
+\text{VISIBLE}
+\to
+\text{TRANSVERSAL}.
+}
+\tag{S0.4}
+\]
+
+Keine Stufe darf übersprungen werden.
+
+---
+
+## 4. Wände und Randstrata
+
+Explizit getrennt zu behandeln sind mindestens
+
+\[
+\sigma=R,
+\qquad
+R=\varepsilon,
+\qquad
+\varepsilon=\Delta/2.
+\]
+
+Der aktuelle SALVAGE-Angriff benutzt zunächst nur das offene untere Gebiet.
+Der Rand \(R=\varepsilon\) darf als **monotone Majoranten-Geometrie**
+verwendet werden, aber nicht als admissibler SW1-Punkt.
+
+---
+
+## 5. Warum \(M_N\le288N+144\) keine uniforme Blindheit beweist
+
+IMG3 liefert für endliche Neumann-Tiefe \(N\)
+
+\[
+M_N^{\rm lin}
+\le
+288N+144
+\]
+
+mögliche affine Annulus-Samplingmaps und damit
+
+\[
+|W^{\rm vis}_{N}|
+\le
+(288N+144)R.
+\tag{S0.5}
+\]
+
+Für fixes \(N\) und \(R\downarrow0\) ist das stark.
+
+Für adaptive Tiefe \(N=N(R)\) folgt aber nur die notwendige
+Deckungsbedingung
+
+\[
+(288N+144)R\ge S-R.
+\]
+
+Insbesondere ist
+
+\[
+N=\Omega(1/R)
+\]
+
+notwendig, aber die Phasenzahl allein erzwingt **keinen**
+\(R\)-unabhängigen Blindanteil.
+
+Tatsächlich: Sobald
+
+\[
+(288N+144)R\ge T,
+\]
+
+ist die reine Zähl-/Längeninformation mit einer vollständigen Überdeckung
+eines Annulusintervalls der Länge \(<T\) kompatibel. Ob die **wirklichen**
+Phasenlagen diese Überdeckung erreichen, ist eine zusätzliche geometrische
+Frage.
+
+Daher:
+
+\[
+\boxed{
+M_N\le288N+144
+\text{ ist ein Tiefen-No-Go, kein globaler Blindheitsbeweis.}
+}
+\tag{S0.6}
+\]
+
+---
+
+## 6. Monotoner Majoranten-Trick
+
+Für festes \(\varepsilon\) hängt das FREE-Graphing nicht von \(R\) ab.
+Aus
+
+\[
+0<R_1<R_2<\varepsilon
+\]
+
+folgt
+
+\[
+U_{R_1}\subset U_{R_2}
+\quad\Longrightarrow\quad
+V_{\varepsilon,R_1}
+\subset
+V_{\varepsilon,R_2}.
+\tag{S0.7}
+\]
+
+Definiere deshalb den **maximalen KNF-Samplingmajoranten**
+
+\[
+U_\varepsilon^{\max}
+=
+a+(-\varepsilon,\varepsilon)
+\cup
+b+(-\varepsilon,\varepsilon)
+\cup
+T+(-\varepsilon,\varepsilon)
+\]
+
+und
+
+\[
+V_\varepsilon^{\max}
+=
+\operatorname{Sat}_{\mathcal E_\varepsilon}
+(U_\varepsilon^{\max}).
+\]
+
+Findet man ein messbares
+
+\[
+B_\varepsilon\subset(\varepsilon,T)
+\]
+
+mit positivem Maß, das von **keinem** Hub-Sourcewert aus
+\(V_\varepsilon^{\max}\) getroffen wird, dann ist dasselbe
+\(B_\varepsilon\) für **jedes**
+
+\[
+0<R<\varepsilon,
+\qquad
+0<\sigma<R
+\]
+
+blind.
+
+Dies ist entscheidungsstärker als jede \(1-cR\)-Union-Bound-Schätzung.
+
+---
+
+## 7. Neuer exakter Kandidat aus dem ersten Phase-Diagramm-Scan
+
+Setze
+
+\[
+h
+:=
+d-3\Delta.
+\]
+
+Die Konstantenidentitäten ergeben
+
+\[
+\boxed{
+h
+=
+\frac{T-10\Delta}{4}
+>0.
+}
+\tag{S0.8}
+\]
+
+Der direkte Saturationsscan des tatsächlichen A7-Graphings bei der
+Majorantenwahl \(R=\varepsilon\) zeigt einen auffälligen exakten
+Kandidaten:
+
+\[
+\boxed{
+\varepsilon_c
+:=
+\frac h2
+=
+\frac{T-10\Delta}{8}
+\approx
+0.22123729809\,\Delta.
+}
+\tag{S0.9}
+\]
+
+Für
+
+\[
+0<\varepsilon<\varepsilon_c
+\]
+
+erscheinen vierzehn gleich breite blinde Intervalle mit Breite
+
+\[
+g_\varepsilon
+=
+h-2\varepsilon
+=
+\frac{T-10\Delta-8\varepsilon}{4}.
+\tag{S0.10}
+\]
+
+Die beobachteten linken Grundpositionen sind
+
+\[
+\mathcal C=
+\{
+0,\Delta,2\Delta,3\Delta,
+d,d+\Delta,d+2\Delta,
+a,a+\Delta,a+2\Delta,a+3\Delta,
+b,b+\Delta,b+2\Delta
+\}.
+\tag{S0.11}
+\]
+
+Der natürliche Kandidat ist daher
+
+\[
+B_\varepsilon^{\rm cand}
+=
+\bigcup_{c\in\mathcal C}
+(c+\varepsilon,\ c+h-\varepsilon).
+\tag{S0.12}
+\]
+
+Falls die FREE-Sättigungs-/Hub-Exklusion für S0.12 exakt bewiesen wird, folgt
+
+\[
+|B_\varepsilon^{\rm cand}|
+=
+14(h-2\varepsilon)
+=
+\boxed{
+\frac72
+(T-10\Delta-8\varepsilon)
+}
+>0,
+\tag{S0.13}
+\]
+
+**unabhängig von \(R\)**.
+
+Das wäre ein wesentlich stärkerer No-Go-Wedge als der bisherige
+Small-\(R\)-Union-Bound.
+
+### Status dieser Beobachtung
+
+S0.8–S0.11 sind exakt identifizierte Konstanten-/Musterkandidaten.
+
+Die entscheidende Inklusion
+
+\[
+B_\varepsilon^{\rm cand}
+\cap
+W^{\rm vis}(V_\varepsilon^{\max})
+=
+\varnothing
+\tag{S0.14}
+\]
+
+ist **noch nicht bewiesen**.
+
+Daher keine Promotion und noch keine Buchung als negativer Satz.
+
+---
+
+## 8. Nächste Gates
+
+### SALVAGE-A1 — exact maximal-saturation cells
+
+Für
+
+\[
+0<\varepsilon<\varepsilon_c
+\]
+
+die Sättigung von \(U_\varepsilon^{\max}\) unter allen neun A7-Maps
+symbolisch als endliche Intervallzellen klassifizieren.
+
+### SALVAGE-A2 — 14-gap exclusion
+
+Für jede der sechs Hub-Source-Maps beweisen, dass ihre Bilder der
+SALVAGE-A1-Sättigung S0.12 nicht treffen.
+
+Erst dann darf gebucht werden:
+
+\[
+\beta(\varepsilon,R,\sigma)
+\ge
+\frac72(T-10\Delta-8\varepsilon)
+\]
+
+für den gesamten entsprechenden Wedge.
+
+### SALVAGE-A3 — true coverage threshold
+
+Nur außerhalb dieses Wedges die tatsächliche Nullstelle
+
+\[
+\beta(\varepsilon,R,\sigma)=0
+\]
+
+kartieren.
+
+### SALVAGE-A4 — transversality
+
+Nur auf \(\beta=0\) eine Coercivity-/Injektivitätsanalyse starten.
+
+---
+
+## 9. Firewall
+
+- Die alte Schwelle \(T/28080\) ist nur ein grober hinreichender
+  Blindheitsbound.
+- \(M_N\le288N+144\) beweist keine uniforme Blindheit bei adaptivem \(N\).
+- \(\beta=0\) beweist keine Injektivität.
+- S0.9–S0.14 sind aktuell **Kandidaten**, keine Promotion.
+- Keine separate Aussage über \(\ker\Gamma_I\), Objekt X oder RH.
diff --git a/audits/P11_R32_SW1_M1_ND_SALVAGE_A1_A2_ANALYTIC_HANDOFF_CANDIDATE.md b/audits/P11_R32_SW1_M1_ND_SALVAGE_A1_A2_ANALYTIC_HANDOFF_CANDIDATE.md
new file mode 100644
index 00000000..97bde342
--- /dev/null
+++ b/audits/P11_R32_SW1_M1_ND_SALVAGE_A1_A2_ANALYTIC_HANDOFF_CANDIDATE.md
@@ -0,0 +1,311 @@
+# P11/R32 — SALVAGE-A1/A2 Analytic Handoff Candidate
+
+> **Stand:** 1. September 2026  
+> **Status:** internal analytic handoff candidate; no independent promotion.  
+> **Purpose:** verify that the new uniform blind wedge uses only
+> parameter-uniform IMG0/IMG2/IMG3/IMG4 identities and does not import the old
+> \(\varepsilon_0=\Delta/4\) Mass-Transport argument.
+
+---
+
+## 1. Scope
+
+Fix
+
+\[
+0<\varepsilon<\varepsilon_c
+:=
+\frac{T-10\Delta}{8}.
+\]
+
+The exact certificate proves
+
+\[
+\varepsilon_c<\frac{\Delta}{2}.
+\]
+
+Hence the entire new wedge lies in the lower A7 chamber. Let
+
+\[
+0<R<\varepsilon,\qquad 0<\sigma<R.
+\]
+
+Then \(R+\varepsilon<2\varepsilon<\Delta\), so the SW1 chamber inequalities
+hold.
+
+---
+
+## 2. FREE graph
+
+A7 is formulated for the full lower chamber
+
+\[
+0<\varepsilon<\Delta/2.
+\]
+
+Its complete nonidentity physical FREE map list is
+
+\[
+\tau_{\pm a},\quad
+\tau_{\pm T},\quad
+r_a,r_T,r_{3a},r_{4a},r_{2b}.
+\tag{HOF.1}
+\]
+
+The SALVAGE-A1 certificate proves \(K_\varepsilon\) invariant under exactly
+this graphing.
+
+For every \(R<\varepsilon\),
+
+\[
+U_R\subset U_\varepsilon^{\max}\subset K_\varepsilon.
+\]
+
+Therefore, up to the finite gap/domain boundary set,
+
+\[
+\boxed{
+V_{\varepsilon,R}
+:=
+\operatorname{Sat}_{\mathcal E_\varepsilon}(U_R)
+\subset K_\varepsilon
+\quad\text{a.e.}
+}
+\tag{HOF.2}
+\]
+
+This saturation is measurable: the A7 relation is generated by finitely many
+partial Borel isometries, hence
+\[
+V_{\varepsilon,R}
+=
+\bigcup_{w}
+w\bigl(U_R\cap\operatorname{dom}w\bigr)
+\]
+over the countable set of finite graphing words.  The finite endpoint set and
+its word-saturation are null because every word is measure preserving on its
+domain.  Thus the boundary convention does not affect the \(L^2\) projection
+or the reducing identity.
+
+No component bound and no Mass-Transport estimate is used.
+
+---
+
+## 3. Horizon operator
+
+IMG3 gives on the full IMG0 Horizon basislift space
+
+\[
+\boxed{
+\mathscr T_B=V^*(I+A)V.
+}
+\tag{HOF.3}
+\]
+
+Since \(A\ge0\),
+
+\[
+\boxed{
+\mathscr T_B\ge I,
+}
+\tag{HOF.4}
+\]
+
+so \(\mathscr T_B^{-1}\) is bounded.
+
+For the physical multiplication projection
+
+\[
+M_{V_{\varepsilon,R}}h
+=
+1_{V_{\varepsilon,R}}h
+\]
+
+and the basislift projection
+
+\[
+\Pi_{\varepsilon,R}
+=
+V^*M_{V_{\varepsilon,R}}V,
+\]
+
+A7-saturation gives, on every active FREE edge,
+
+\[
+1_{V_{\varepsilon,R}}(x)
+=
+1_{V_{\varepsilon,R}}(\phi(x))
+\]
+
+a.e. Hence \(M_{V_{\varepsilon,R}}\) commutes termwise with the physical
+FREE operator \(I+A\). Therefore
+
+\[
+\boxed{
+\Pi_{\varepsilon,R}\mathscr T_B
+=
+\mathscr T_B\Pi_{\varepsilon,R}
+}
+\tag{HOF.5}
+\]
+
+and
+
+\[
+\boxed{
+\Pi_{\varepsilon,R}\mathscr T_B^{-1}
+=
+\mathscr T_B^{-1}\Pi_{\varepsilon,R}.
+}
+\tag{HOF.6}
+\]
+
+This argument does not use \(\varepsilon=\Delta/4\), Mass Transport or a
+component-cardinality bound.
+
+---
+
+## 4. Annulus and Hub
+
+IMG0 identifies
+
+\[
+\mathscr B_W
+=
+\bigoplus_{k=0}^2 n_kL^2(\mathbb T_L)
+\]
+
+with arbitrary positive Annulus \(L^2\)-data through the unitary odd transport
+
+\[
+W:\mathscr B_W\to\mathscr H_-^{\rm ann}.
+\]
+
+The effective Hub block is
+
+\[
+\boxed{
+\mathcal H_R=V^*HW,
+\qquad
+H=HE_{\mathcal A}.
+}
+\tag{HOF.7}
+\]
+
+The six positive physical source locations are
+
+\[
+|x-a|,\ x+a,\ |x-b|,\ x+b,\ |x-T|,\ x+T.
+\tag{HOF.8}
+\]
+
+SALVAGE-A2 proves that none of these locations lies in \(B_\varepsilon\) for
+any \(x\in K_\varepsilon\), hence in particular for
+\(x\in V_{\varepsilon,R}\).
+
+---
+
+## 5. Kernel handoff
+
+Because
+
+\[
+B_\varepsilon\subset(\varepsilon,T)\subset(R,S),
+\qquad S=T+\sigma,
+\]
+
+choose
+
+\[
+0\ne w_+\in L^2(B_\varepsilon).
+\]
+
+IMG0 gives a unique nonzero \(g\in\mathscr B_W\) with that positive Annulus
+reconstruction. By HOF.7–HOF.8 and the blind support,
+
+\[
+\boxed{
+\Pi_{\varepsilon,R}\mathcal H_Rg=0.
+}
+\tag{HOF.9}
+\]
+
+Set
+
+\[
+f=-\mathscr T_B^{-1}\mathcal H_Rg.
+\]
+
+Using HOF.6,
+
+\[
+\Pi_{\varepsilon,R}f=0.
+\]
+
+Thus the physical Horizon reconstruction of \(f\) vanishes on
+\(V_{\varepsilon,R}\), hence on \(U_R\).
+
+IMG2/KNF characterizes \(\mathscr B_K\) by
+
+\[
+p[f(a-u)-f(a+u)]
++r[f(b-u)-f(b+u)]
++q[f(T-u)-f(T+u)]
+=0
+\]
+
+for a.e. \(0<u<R\). Since all six sample values vanish,
+
+\[
+\boxed{f\in\mathscr B_K.}
+\tag{HOF.10}
+\]
+
+Finally
+
+\[
+\mathscr N_R(f,g)
+=
+\mathscr T_Bf+\mathcal H_Rg
+=
+0.
+\]
+
+Since \(g\ne0\),
+
+\[
+\boxed{\ker\mathscr N_R\ne\{0\}.}
+\tag{HOF.11}
+\]
+
+---
+
+## 6. Not imported from the old explicit IMG4 witness
+
+The new proof does **not** use:
+
+- the a.e.-780 component bound;
+- the \(\pm14\) separator cover;
+- Mass Transport;
+- the \(28080R\) visibility estimate;
+- \(R_0=T/100000\);
+- the special value \(\varepsilon_0=\Delta/4\).
+
+---
+
+## 7. Internal verdict
+
+Subject to the exact SALVAGE-A1/A2 geometry, the analytic kernel handoff is
+parameter-uniform on
+
+\[
+0<\varepsilon<\varepsilon_c,\qquad
+0<R<\varepsilon,\qquad
+0<\sigma<R.
+\]
+
+\[
+\boxed{\text{Gate D: internal GREEN candidate.}}
+\]
+
+No promotion is created by this document alone.
diff --git a/audits/P11_R32_SW1_M1_ND_SALVAGE_A1_A2_REVIEW_PACKET.md b/audits/P11_R32_SW1_M1_ND_SALVAGE_A1_A2_REVIEW_PACKET.md
new file mode 100644
index 00000000..ed23eedf
--- /dev/null
+++ b/audits/P11_R32_SW1_M1_ND_SALVAGE_A1_A2_REVIEW_PACKET.md
@@ -0,0 +1,182 @@
+# P11/R32 — SALVAGE-A1/A2 Uniform Blind Wedge Review Packet
+
+**Date:** 1 September 2026  
+**Branch:** \`research/sw1-m1-nd-salvage-phase-diagram\`  
+**Status:** candidate only; no promotion.
+
+## Claim
+
+Let
+
+\[
+\varepsilon_c=\frac{T-10\Delta}{8}.
+\]
+
+Review whether
+
+\[
+0<\varepsilon<\varepsilon_c,\qquad
+0<R<\varepsilon,\qquad
+0<\sigma<R
+\]
+
+implies
+
+\[
+\ker\mathscr N_R\ne\{0\}.
+\]
+
+Primary proof:
+\`audits/P11_R32_SW1_M1_ND_SALVAGE_A1_A2_UNIFORM_BLIND_WEDGE_CANDIDATE.md\`
+
+Exact certificate:
+\`scripts/certify_sw1_m1_nd_salvage_a1_a2_uniform_blind_wedge.py\`
+
+---
+
+## Gate A — uniform sign and chamber control
+
+Verify independently:
+
+\[
+h=\frac{T-10\Delta}{4}=d-3\Delta>0,
+\qquad
+\varepsilon_c=\frac h2,
+\]
+
+and
+
+\[
+\boxed{\varepsilon_c<\Delta/2.}
+\]
+
+The certificate reduces these signs to exact integer comparisons
+\(2^m\) versus \(3^n\).
+
+For every affine-in-\(\varepsilon\) comparison, check that endpoint signs at
+\(\varepsilon=0\) and \(\varepsilon=\varepsilon_c\) suffice to determine the
+sign on the open interval and that endpoint zeros are handled correctly.
+
+**Verdict:** GREEN / PARTIAL / FAIL
+
+---
+
+## Gate B — graph-invariant Horizon complement
+
+The 24 forbidden gaps are
+
+\[
+F_{s,k,j}
+=
+(s+k\Delta+jh+\varepsilon,\,
+s+k\Delta+(j+1)h-\varepsilon)
+\]
+
+for \(s\in\{0,a\}\), \(k=0,\ldots,5\), \(j=0,1\).
+
+Check:
+
+1. all 24 gaps are nonempty, ordered, disjoint and lie in \((0,T)\);
+2. \(U_\varepsilon^{\max}\) avoids them;
+3. the loop over all 24 gaps and every A7 domain component is exhaustive;
+4. each nonempty image is covered by \(F_\varepsilon\);
+5. the reported count 70 is only a checksum, not the reason for exhaustivity;
+6. the verified inverse graphing relations imply
+   \(K_\varepsilon=F_\varepsilon^c\) is invariant a.e.;
+7. boundary points form only a finite null set;
+8. the saturation is measurable as a countable union of partial-Borel word
+   images, and the word-saturation of the boundary null set remains null.
+
+Relevant upstream:
+- \`audits/P11_R32_SW1_A7_FINITE_STATE_COCYCLE_CANDIDATE.md\`
+- \`scripts/certify_sw1_m1_nd_img4_gateB_pmp_graphing.py\`
+
+**Verdict:** GREEN / PARTIAL / FAIL
+
+---
+
+## Gate C — 14-gap Hub exclusion
+
+Check the 14 intervals
+
+\[
+B_{\varepsilon,c}=(c+\varepsilon,c+h-\varepsilon)
+\]
+
+for
+
+\[
+\mathcal C=
+\{
+0,\Delta,2\Delta,3\Delta,
+d,d+\Delta,d+2\Delta,
+a,a+\Delta,a+2\Delta,a+3\Delta,
+b,b+\Delta,b+2\Delta
+\}.
+\]
+
+Verify:
+
+1. they are nonempty, ordered, disjoint and lie in \((\varepsilon,T)\);
+2. the complement \(K_\varepsilon\) has exactly 25 cells;
+3. for every cell and each \(\tau\in\{a,b,T\}\), the code includes:
+   - the left piece of \(|x-\tau|\),
+   - the right piece of \(|x-\tau|\),
+   - the full \(x+\tau\) piece;
+4. these are exactly the six physical positive Hub source maps;
+5. all 153 nonempty pieces avoid all 14 blind intervals;
+6. 153 is again only a checksum after exhaustive looping.
+
+Verify also
+
+\[
+|B_\varepsilon|
+=
+14(h-2\varepsilon)
+=
+\frac72(T-10\Delta-8\varepsilon)>0.
+\]
+
+**Verdict:** GREEN / PARTIAL / FAIL
+
+---
+
+## Gate D — parameter-uniform analytic handoff
+
+Use
+
+\`audits/P11_R32_SW1_M1_ND_SALVAGE_A1_A2_ANALYTIC_HANDOFF_CANDIDATE.md\`.
+
+Check that the proof uses only parameter-uniform statements:
+
+\[
+\mathscr T_B=V^*(I+A)V,\qquad
+\mathscr T_B\ge I,
+\]
+
+the reducing projection for any A7-saturated measurable set,
+
+\[
+\mathcal H_R=V^*HW,
+\]
+
+and the IMG2/KNF characterization of \(\mathscr B_K\).
+
+Confirm explicitly that no 780 bound, Mass Transport, \(\pm14\) separator
+cover or special \(\varepsilon=\Delta/4\) value is imported.
+
+**Verdict:** GREEN / PARTIAL / FAIL
+
+---
+
+## Promotion criterion
+
+Only if A–D are GREEN may the wedge be considered for
+
+\[
+\checkmark[M]_{\rm neg}.
+\]
+
+No claim that \(\varepsilon_c\) is the exact global phase transition.  
+No injectivity claim for \(\varepsilon\ge\varepsilon_c\).  
+No Object-X or RH conclusion.
diff --git a/audits/P11_R32_SW1_M1_ND_SALVAGE_A1_A2_UNIFORM_BLIND_WEDGE_CANDIDATE.md b/audits/P11_R32_SW1_M1_ND_SALVAGE_A1_A2_UNIFORM_BLIND_WEDGE_CANDIDATE.md
new file mode 100644
index 00000000..707a6a2a
--- /dev/null
+++ b/audits/P11_R32_SW1_M1_ND_SALVAGE_A1_A2_UNIFORM_BLIND_WEDGE_CANDIDATE.md
@@ -0,0 +1,432 @@
+# P11/R32 — SW1 M1-ND SALVAGE-A1/A2 Uniform Blind Wedge Candidate
+
+> **Stand:** 1. September 2026  
+> **Branch:** \`research/sw1-m1-nd-salvage-phase-diagram\`  
+> **Status:** AI-GREEN candidate + exact finite/algebraic certificate for the new geometry; **no promotion yet**.  
+> **Certificate:** \`scripts/certify_sw1_m1_nd_salvage_a1_a2_uniform_blind_wedge.py\`.
+
+---
+
+## 1. Statement and scope
+
+Set
+
+\[
+h:=d-3\Delta.
+\]
+
+Using the physical constants,
+
+\[
+\boxed{
+h=\frac{T-10\Delta}{4}
+=\frac{8\log2-5\log3}{2}>0
+}
+\tag{A12.1}
+\]
+
+because \(2^8>3^5\).
+
+Define
+
+\[
+\boxed{
+\varepsilon_c:=\frac h2=\frac{T-10\Delta}{8}.
+}
+\tag{A12.2}
+\]
+
+Moreover
+
+\[
+\boxed{
+\varepsilon_c<\frac{\Delta}{2}
+}
+\tag{A12.3}
+\]
+
+because this is equivalent to \(11\log2<7\log3\), hence to
+\(2^{11}<3^7\).
+
+Candidate theorem:
+
+> For every
+> \[
+> 0<\varepsilon<\varepsilon_c,\qquad
+> 0<R<\varepsilon,\qquad
+> 0<\sigma<R,
+> \]
+> the current effective SW1 operator satisfies
+> \[
+> \boxed{\ker\mathscr N_R\ne\{0\}.}
+> \tag{A12.4}
+> \]
+
+Since \(\varepsilon<\Delta/2\) and \(R<\varepsilon\), one has
+\(R+\varepsilon<2\varepsilon<\Delta\), so the whole wedge lies in the
+lower SW1 chamber where A7 applies.
+
+---
+
+## 2. The 24-gap Horizon barrier
+
+For
+
+\[
+s\in\{0,a\},\qquad k=0,\ldots,5,\qquad j\in\{0,1\},
+\]
+
+define
+
+\[
+F_{s,k,j}
+=
+\left(
+s+k\Delta+jh+\varepsilon,\,
+s+k\Delta+(j+1)h-\varepsilon
+\right).
+\tag{A12.5}
+\]
+
+Because \(0<\varepsilon<h/2\), every gap has width
+
+\[
+h-2\varepsilon>0.
+\]
+
+Let
+
+\[
+\boxed{
+F_\varepsilon=\bigcup_{s,k,j}F_{s,k,j}.
+}
+\tag{A12.6}
+\]
+
+The exact certificate proves uniformly on the full open
+\(0<\varepsilon<\varepsilon_c\) interval:
+
+- all 24 gaps are nonempty;
+- they are strictly ordered and pairwise disjoint;
+- they lie in \((0,T)\).
+
+Set
+
+\[
+K_\varepsilon:=(0,T+\varepsilon)\setminus F_\varepsilon
+\]
+
+up to the finite boundary set.
+
+---
+
+## 3. Maximal KNF sampling lies in \(K_\varepsilon\)
+
+Define the boundary-majorant sampling set
+
+\[
+U_\varepsilon^{\max}
+=
+(a-\varepsilon,a+\varepsilon)
+\cup
+(b-\varepsilon,b+\varepsilon)
+\cup
+(T-\varepsilon,T+\varepsilon).
+\tag{A12.7}
+\]
+
+For every actual \(0<R<\varepsilon\),
+
+\[
+U_R\subset U_\varepsilon^{\max}.
+\tag{A12.8}
+\]
+
+The certificate proves
+
+\[
+\boxed{
+U_\varepsilon^{\max}\cap F_\varepsilon=\varnothing.
+}
+\tag{A12.9}
+\]
+
+Hence \(U_R\subset K_\varepsilon\).
+
+---
+
+## 4. FREE invariance
+
+Use exactly the nine lower-chamber A7 maps
+
+\[
+\tau_{\pm a},\quad
+\tau_{\pm T},\quad
+r_a,\ r_T,\ r_{3a},\ r_{4a},\ r_{2b}
+\tag{A12.10}
+\]
+
+with the exact A7.1–A7.9 domains.
+
+For every forbidden gap and every nonempty map/domain intersection, the
+certificate checks that its image is covered by \(F_\varepsilon\).
+
+There are exactly
+
+\[
+\boxed{70}
+\]
+
+such nonempty pieces.
+
+The script also checks the inverse graphing structure:
+
+- \(+a\leftrightarrow-a\);
+- \(+T\leftrightarrow-T\);
+- \(r_T,r_{3a},r_{4a},r_{2b}\) are involutions on invariant domains;
+- \(r_a\) swaps its two domain components.
+
+Thus \(F_\varepsilon\) is invariant in both graph directions. Therefore,
+away from the finite boundary set,
+
+\[
+\boxed{
+K_\varepsilon
+\text{ is invariant under the full A7 equivalence relation.}
+}
+\tag{A12.11}
+\]
+
+Consequently
+
+\[
+\boxed{
+V_{\varepsilon,R}
+=
+\operatorname{Sat}_{\mathcal E_\varepsilon}(U_R)
+\subset K_\varepsilon.
+}
+\tag{A12.12}
+\]
+
+No component-cardinality or Mass-Transport estimate is used.
+
+---
+
+## 5. Fourteen uniform Annulus gaps
+
+Let
+
+\[
+\mathcal C=
+\{
+0,\Delta,2\Delta,3\Delta,
+d,d+\Delta,d+2\Delta,
+a,a+\Delta,a+2\Delta,a+3\Delta,
+b,b+\Delta,b+2\Delta
+\}.
+\tag{A12.13}
+\]
+
+For \(c\in\mathcal C\), define
+
+\[
+B_{\varepsilon,c}
+=
+(c+\varepsilon,\ c+h-\varepsilon)
+\tag{A12.14}
+\]
+
+and
+
+\[
+\boxed{
+B_\varepsilon
+=
+\bigcup_{c\in\mathcal C}B_{\varepsilon,c}.
+}
+\tag{A12.15}
+\]
+
+The certificate proves uniformly:
+
+1. all 14 intervals are nonempty;
+2. they are strictly ordered and pairwise disjoint;
+3. they lie in \((\varepsilon,T)\).
+
+The complement \(K_\varepsilon\) consists of exactly 25 interval cells.
+
+For each cell, the certificate evaluates the complete physical positive Hub
+source list
+
+\[
+|x-a|,\ x+a,\ |x-b|,\ x+b,\ |x-T|,\ x+T.
+\tag{A12.16}
+\]
+
+The absolute-value maps are split at \(a,b,T\). This yields exactly
+
+\[
+\boxed{153}
+\]
+
+nonempty image pieces, and every one is proved disjoint from every component
+of \(B_\varepsilon\). Hence
+
+\[
+\boxed{
+H(K_\varepsilon)\cap B_\varepsilon=\varnothing.
+}
+\tag{A12.17}
+\]
+
+By A12.12,
+
+\[
+H(V_{\varepsilon,R})\cap B_\varepsilon=\varnothing.
+\tag{A12.18}
+\]
+
+Because \(R<\varepsilon\) and \(S=T+\sigma>T\),
+
+\[
+B_\varepsilon\subset(\varepsilon,T)\subset(R,S).
+\tag{A12.19}
+\]
+
+So \(B_\varepsilon\) is a genuine positive Annulus blind set for every
+admissible \(R,\sigma\) in the wedge.
+
+---
+
+## 6. Uniform blind measure
+
+Each blind interval has width \(h-2\varepsilon\), hence
+
+\[
+\begin{aligned}
+|B_\varepsilon|
+&=14(h-2\varepsilon)\\
+&=
+\boxed{
+\frac72(T-10\Delta-8\varepsilon)
+}.
+\end{aligned}
+\tag{A12.20}
+\]
+
+For \(0<\varepsilon<\varepsilon_c\), this is strictly positive.
+
+Crucially,
+
+\[
+\boxed{
+|B_\varepsilon|
+\text{ has no }R\text{-decay.}
+}
+\tag{A12.21}
+\]
+
+---
+
+## 7. Kernel handoff
+
+Choose
+
+\[
+0\ne w_+\in L^2(B_\varepsilon)
+\]
+
+and let \(0\ne g\in\mathscr B_W\) be its IMG0 basislift reconstruction.
+
+The parameter-uniform analytic handoff is recorded separately in
+
+\`audits/P11_R32_SW1_M1_ND_SALVAGE_A1_A2_ANALYTIC_HANDOFF_CANDIDATE.md\`.
+
+It gives
+
+\[
+\Pi_{V_{\varepsilon,R}}\mathcal H_Rg=0,
+\]
+
+and for
+
+\[
+f=-\mathscr T_B^{-1}\mathcal H_Rg
+\]
+
+one obtains
+
+\[
+\Pi_{V_{\varepsilon,R}}f=0.
+\]
+
+Since \(U_R\subset V_{\varepsilon,R}\), all six KNF sample values vanish, so
+
+\[
+f\in\mathscr B_K.
+\]
+
+Therefore
+
+\[
+\mathscr N_R(f,g)=0
+\]
+
+with \(g\ne0\). Hence the candidate conclusion is A12.4.
+
+---
+
+## 8. Interpretation
+
+If A12.4 survives adversarial review, the current finite-level geometry is
+degenerate on the open wedge
+
+\[
+\boxed{
+0<\varepsilon<
+\frac{T-10\Delta}{8},
+\quad
+0<R<\varepsilon,
+\quad
+0<\sigma<R.
+}
+\tag{A12.22}
+\]
+
+This is qualitatively stronger than the previously promoted single witness:
+
+- old proof: \(O(R)\) visibility upper bound plus Mass Transport;
+- new proof: explicit graph-invariant Horizon barrier plus an
+  \(R\)-independent positive Annulus blind set.
+
+---
+
+## 9. Scope firewall
+
+Not claimed yet:
+
+- degeneracy for \(\varepsilon\ge\varepsilon_c\);
+- that \(\varepsilon_c\) is the exact global phase boundary;
+- injectivity anywhere on the visible side;
+- any upper-chamber statement;
+- a separate promotion of \(\ker\Gamma_I\ne0\);
+- Object-X failure;
+- any RH conclusion.
+
+The numerical phase-diagram probe is discovery evidence only.
+
+---
+
+## 10. Promotion gate
+
+Before any \(\checkmark[M]_{\rm neg}\) booking for A12.22:
+
+1. verify the exact sign engine and \(\varepsilon_c<\Delta/2\);
+2. verify that the 70 FREE pieces exhaust all A7 gap/domain intersections;
+3. verify that forward+inverse \(F_\varepsilon\)-invariance implies
+   \(K_\varepsilon\)-invariance a.e.;
+4. verify that the 153 Hub pieces exhaust the physical six-map list;
+5. verify that the imported reducing/Hub/KNF handoff is parameter-uniform.
+
+Until then: **candidate only**.
diff --git a/scripts/certify_sw1_m1_nd_salvage_a0_counting_firewall.py b/scripts/certify_sw1_m1_nd_salvage_a0_counting_firewall.py
new file mode 100644
index 00000000..bcde6c4e
--- /dev/null
+++ b/scripts/certify_sw1_m1_nd_salvage_a0_counting_firewall.py
@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+"""SW1 M1-ND SALVAGE-A0 counting firewall certificate.
+
+Purpose:
+- certify the exact linear phase-count formula M_N=288N+144 already used by IMG3;
+- certify that this count alone cannot imply an R-independent blind fraction
+  once N is allowed to depend on R.
+
+The script does NOT assert that the real phase locations cover the annulus.
+It proves only that the cardinality/length estimate is compatible with full
+coverage when N grows like 1/R, so actual phase geometry must be analyzed.
+"""
+
+import sympy as sp
+
+print("SW1 M1-ND SALVAGE-A0 COUNTING FIREWALL")
+
+N=sp.symbols("N", integer=True, nonnegative=True)
+M=72*(4*N+2)
+assert sp.expand(M)==288*N+144
+
+# Abstract positive constants.
+T,R,sigma=sp.symbols("T R sigma", positive=True)
+
+# Restricted-tail condition sigma<R implies annulus length A=S-R<T.
+S=T+sigma
+A=sp.expand(S-R)
+assert sp.simplify(T-A)==R-sigma
+
+# If M*R >= T, then the raw count/length upper bound is already >= A.
+# This makes the union bound non-informative: it cannot force beta>0.
+margin=sp.expand(M*R-T)
+
+# Explicit adaptive choice R_N=T/M. Then M*R_N=T exactly.
+RN=sp.simplify(T/M)
+assert sp.simplify(M*RN-T)==0
+
+# Choosing sigma_N=R_N/2 gives an annulus shorter than T.
+sigmaN=RN/2
+AN=sp.simplify(T+sigmaN-RN)
+assert sp.simplify(T-AN)==RN/2
+assert (sp.simplify(T-AN)).is_positive is True
+
+# For any fixed lower-chamber epsilon>0, RN<epsilon once
+# M>T/epsilon.  The exact integer ceiling is an elementary Archimedean step
+# and is intentionally kept outside the finite CAS certificate.
+eps=sp.symbols("eps", positive=True)
+
+print("M_N = 288*N + 144: PASS")
+print("restricted tail sigma<R gives S-R<T: PASS")
+print("adaptive R_N=T/M_N gives M_N*R_N=T exactly: PASS")
+print("with sigma_N=R_N/2, annulus length is T-R_N/2<T: PASS")
+print("CONCLUSION: count/length data alone are compatible with full coverage")
+print("NECESSARY DEPTH ONLY: N=Omega(1/R)")
+print("FIREWALL: actual A7/A8 phase locations and overlaps remain decisive")
+print("SW1 M1-ND SALVAGE-A0 COUNTING FIREWALL: PASS")
diff --git a/scripts/certify_sw1_m1_nd_salvage_a1_a2_uniform_blind_wedge.py b/scripts/certify_sw1_m1_nd_salvage_a1_a2_uniform_blind_wedge.py
new file mode 100644
index 00000000..4c0805b2
--- /dev/null
+++ b/scripts/certify_sw1_m1_nd_salvage_a1_a2_uniform_blind_wedge.py
@@ -0,0 +1,312 @@
+#!/usr/bin/env python3
+"""Exact SALVAGE-A1/A2 certificate: an R-independent blind wedge.
+
+Claimed geometric scope:
+    0 < epsilon < epsilon_c := (T-10*Delta)/8,
+    0 < R < epsilon,
+    0 < sigma < R.
+
+Define
+    h = (T-10*Delta)/4 = d-3*Delta > 0.
+
+Construct 24 open forbidden Horizon gaps F_epsilon.  Their complement
+K_epsilon contains the maximal KNF sampling set U_epsilon^max.
+The script proves, uniformly for the whole open epsilon interval:
+
+1. the 24 gaps are positive, ordered, disjoint and lie in (0,T);
+2. U_epsilon^max is disjoint from F_epsilon;
+3. every one of the nine A7 graphing maps sends F_epsilon∩domain into
+   F_epsilon; since inverse generators are present, K_epsilon is invariant;
+4. the six physical Hub source maps from K_epsilon avoid 14 explicit
+   positive-Annulus intervals B_epsilon;
+5. the 14 intervals are disjoint, lie in (epsilon,T), and have total measure
+       14(h-2 epsilon)
+       = 7/2 (T-10 Delta-8 epsilon) > 0.
+
+This script proves the new finite geometric premises.  The functional-analytic
+kernel conclusion uses the already promoted IMG4 reducing/Hub/KNF mechanism
+and is recorded separately in the candidate audit.
+"""
+
+import sympy as sp
+
+print("SW1 M1-ND SALVAGE-A1/A2 UNIFORM BLIND WEDGE CERTIFICATE")
+
+L2,L3=sp.log(2),sp.log(3)
+a=L2/2
+b=L3/2
+T=L2
+d=b-a
+Delta=sp.expand(L3-sp.Rational(3,2)*L2)
+h=sp.expand((T-10*Delta)/4)
+eps_c=sp.expand(h/2)
+eps=sp.symbols("eps", real=True)
+T0=T+eps
+
+# ---------- exact sign engine for affine-in-epsilon log forms ----------
+
+def linlog_coeff(expr):
+    z=sp.expand(expr)
+    A=sp.simplify(z.coeff(L2))
+    B=sp.simplify(z.coeff(L3))
+    rest=sp.simplify(z-A*L2-B*L3)
+    assert rest==0,(expr,A,B,rest)
+    assert A.is_Rational and B.is_Rational,(expr,A,B)
+    return sp.Rational(A),sp.Rational(B)
+
+def sign_log(expr):
+    A,B=linlog_coeff(sp.expand(expr))
+    if A==0 and B==0:
+        return 0
+    if A>=0 and B>=0:
+        return 1
+    if A<=0 and B<=0:
+        return -1
+    den=sp.ilcm(int(A.q),int(B.q))
+    ai=int(A*den)
+    bi=int(B*den)
+    if ai>0 and bi<0:
+        lhs=2**ai
+        rhs=3**(-bi)
+        return (lhs>rhs)-(lhs<rhs)
+    if ai<0 and bi>0:
+        lhs=3**bi
+        rhs=2**(-ai)
+        return (lhs>rhs)-(lhs<rhs)
+    raise AssertionError((expr,A,B))
+
+def sign_uniform(expr):
+    """Sign on the open interval 0<eps<eps_c for affine expr."""
+    z=sp.expand(expr)
+    c=sp.simplify(z.coeff(eps))
+    rest=sp.expand(z-c*eps)
+    assert sp.expand(z-rest-c*eps)==0
+    assert c.is_Rational,(expr,c)
+    s0=sign_log(rest)
+    s1=sign_log(sp.expand(rest+c*eps_c))
+    if s0==0:
+        if c>0:
+            return 1
+        if c<0:
+            return -1
+        return 0
+    if s1==0:
+        return s0
+    assert s0==s1,("epsilon crossing inside salvage wedge",expr,s0,s1)
+    return s0
+
+def cmpu(x,y):
+    return sign_uniform(sp.expand(x-y))
+
+def maxu(x,y):
+    return x if cmpu(x,y)>=0 else y
+
+def minu(x,y):
+    return x if cmpu(x,y)<=0 else y
+
+def inter(I,J):
+    lo=maxu(I[0],J[0])
+    hi=minu(I[1],J[1])
+    s=cmpu(hi,lo)
+    return (sp.expand(lo),sp.expand(hi)) if s==1 else None
+
+def image(I,s,c):
+    lo,hi=I
+    if s==1:
+        return (sp.expand(lo+c),sp.expand(hi+c))
+    assert s==-1
+    return (sp.expand(c-hi),sp.expand(c-lo))
+
+# ---------- structural constants ----------
+
+assert sp.simplify(h-(d-3*Delta))==0
+assert sp.simplify(h-(a-(d+2*Delta)))==0
+assert sp.simplify(h-(b-(a+3*Delta)))==0
+assert sp.simplify(h-(T-(b+2*Delta)))==0
+assert sp.simplify(h-(sp.simplify((a-Delta)/2)-2*Delta))==0
+
+# h>0 is exactly 8 log2 > 5 log3, i.e. 2^8 > 3^5.
+assert 2**8 > 3**5
+assert sign_log(h)==1
+assert sign_log(eps_c)==1
+
+# The entire new wedge must remain inside the lower A7 chamber.
+# eps_c < Delta/2 is equivalent to 11*log(2) < 7*log(3),
+# hence to the exact integer inequality 2^11 < 3^7.
+assert 2**11 < 3**7
+assert sign_log(sp.expand(Delta/2-eps_c))==1
+
+assert sign_uniform(eps)==1
+assert sign_uniform(eps_c-eps)==1
+assert sign_uniform(h-2*eps)==1
+assert sign_uniform(Delta-2*eps)==1
+
+# Maximal KNF centers remain inside the positive Horizon.
+assert sign_uniform(a-eps)==1
+assert sign_uniform(b-eps)==1
+
+# ---------- 24 forbidden Horizon gaps ----------
+
+F=[]
+for shift in (sp.Integer(0),a):
+    for k in range(6):
+        base=sp.expand(shift+k*Delta)
+        for j in (0,1):
+            lo=sp.expand(base+j*h+eps)
+            hi=sp.expand(base+(j+1)*h-eps)
+            F.append((lo,hi,(shift,k,j)))
+
+# Sort by one exact interior representative; all pairwise ordering checks below
+# prove that the ordering is uniform on the full open epsilon wedge.
+rep=sp.expand(eps_c/2)
+F.sort(key=lambda z: float(sp.N(z[0].subs(eps,rep),50)))
+assert len(F)==24
+
+for i,(lo,hi,tag) in enumerate(F):
+    assert sign_uniform(hi-lo)==1,("gap width",tag)
+    assert sign_uniform(lo)==1,("gap lower",tag)
+    assert sign_uniform(T-hi)==1,("gap upper",tag)
+    if i+1<len(F):
+        assert sign_uniform(F[i+1][0]-hi)==1,("gap order",tag,F[i+1][2])
+
+Fints=[(lo,hi) for lo,hi,_ in F]
+
+# Maximal KNF sampling set corresponding to the boundary majorant R=epsilon.
+Umax=[
+    (a-eps,a+eps),
+    (b-eps,b+eps),
+    (T-eps,T+eps),
+]
+for U in Umax:
+    for G in Fints:
+        assert inter(U,G) is None
+
+# ---------- A7 graphing and F-invariance ----------
+
+domains={
+    "+a": ( 1, a, [(sp.Integer(0),a+eps)]),
+    "-a": ( 1,-a, [(a,T0)]),
+    "+T": ( 1, T, [(sp.Integer(0),eps)]),
+    "-T": ( 1,-T, [(T,T0)]),
+    "r_a":(-1, a, [(sp.Integer(0),eps),(a-eps,a)]),
+    "r_T":(-1, T, [(sp.Integer(0),T)]),
+    "r_3a":(-1,3*a,[(a-eps,T0)]),
+    "r_4a":(-1,4*a,[(T-eps,T0)]),
+    "r_2b":(-1,2*b,[(2*d-eps,T0)]),
+}
+
+def covered_by_F(I):
+    pieces=[]
+    for G in Fints:
+        K=inter(I,G)
+        if K is not None:
+            pieces.append(K)
+    assert pieces,("no F cover",I)
+    pieces.sort(key=lambda z: float(sp.N(z[0].subs(eps,rep),50)))
+    assert cmpu(pieces[0][0],I[0])<=0
+    cur=pieces[0][1]
+    for lo,hi in pieces[1:]:
+        assert cmpu(lo,cur)<=0,("F cover gap",I,cur,(lo,hi))
+        if cmpu(hi,cur)>0:
+            cur=hi
+    assert cmpu(cur,I[1])>=0
+    return True
+
+mapped_F_pieces=0
+for name,(s,c,doms) in domains.items():
+    for lo,hi,tag in F:
+        for D in doms:
+            K=inter((lo,hi),D)
+            if K is None:
+                continue
+            covered_by_F(image(K,s,c))
+            mapped_F_pieces += 1
+
+assert mapped_F_pieces==70
+
+# Inverse-domain facts needed to pass from F-invariance to K=F^c invariance.
+def eq_int(I,J):
+    return sp.simplify(I[0]-J[0])==0 and sp.simplify(I[1]-J[1])==0
+
+def image_full(s,c,I):
+    return image(I,s,c)
+
+assert eq_int(image_full(1,a,domains["+a"][2][0]),domains["-a"][2][0])
+assert eq_int(image_full(1,-a,domains["-a"][2][0]),domains["+a"][2][0])
+assert eq_int(image_full(1,T,domains["+T"][2][0]),domains["-T"][2][0])
+assert eq_int(image_full(1,-T,domains["-T"][2][0]),domains["+T"][2][0])
+for name in ("r_T","r_3a","r_4a","r_2b"):
+    s,c,Ds=domains[name]
+    assert eq_int(image_full(s,c,Ds[0]),Ds[0])
+ra0,ra1=domains["r_a"][2]
+assert eq_int(image_full(-1,a,ra0),ra1)
+assert eq_int(image_full(-1,a,ra1),ra0)
+
+# ---------- complement K and 14 blind Annulus gaps ----------
+
+K=[]
+cur=sp.Integer(0)
+for lo,hi,_ in F:
+    if sign_uniform(lo-cur)==1:
+        K.append((sp.expand(cur),sp.expand(lo)))
+    cur=hi
+if sign_uniform(T0-cur)==1:
+    K.append((sp.expand(cur),sp.expand(T0)))
+assert len(K)==25
+
+C=[
+    sp.Integer(0),Delta,2*Delta,3*Delta,
+    d,d+Delta,d+2*Delta,
+    a,a+Delta,a+2*Delta,a+3*Delta,
+    b,b+Delta,b+2*Delta,
+]
+assert len(C)==14
+
+B=[(sp.expand(c+eps),sp.expand(c+h-eps)) for c in C]
+for i,(lo,hi) in enumerate(B):
+    assert sign_uniform(hi-lo)==1
+    assert cmpu(lo,eps)>=0
+    assert cmpu(T,hi)>=0
+    if i+1<len(B):
+        assert sign_uniform(B[i+1][0]-hi)==1
+
+def avoids_B(I):
+    for J in B:
+        assert inter(I,J) is None
+
+hub_pieces=0
+for tau in (a,b,T):
+    for I in K:
+        left=inter(I,(sp.Integer(0),tau))
+        if left is not None:
+            avoids_B((sp.expand(tau-left[1]),sp.expand(tau-left[0])))
+            hub_pieces += 1
+        right=inter(I,(tau,T0))
+        if right is not None:
+            avoids_B((sp.expand(right[0]-tau),sp.expand(right[1]-tau)))
+            hub_pieces += 1
+        avoids_B((sp.expand(I[0]+tau),sp.expand(I[1]+tau)))
+        hub_pieces += 1
+
+assert hub_pieces==153
+
+# Total blind measure.
+blind_measure=sp.expand(sum(hi-lo for lo,hi in B))
+expected=sp.expand(14*(h-2*eps))
+assert sp.simplify(blind_measure-expected)==0
+assert sp.simplify(expected-sp.Rational(7,2)*(T-10*Delta-8*eps))==0
+assert sign_uniform(expected)==1
+
+print("h=(T-10 Delta)/4=d-3 Delta > 0: PASS")
+print("epsilon_c=(T-10 Delta)/8 and epsilon_c<Delta/2: PASS")
+print("24 forbidden Horizon gaps: ordered/disjoint/uniform PASS")
+print("maximal KNF sampling set U_epsilon^max avoids F_epsilon: PASS")
+print("70 active forbidden-gap FREE images remain in F_epsilon: PASS")
+print("all nine A7 inverse-domain/involution relations: PASS")
+print("therefore K_epsilon=F_epsilon^c is graph-invariant: ANALYTIC CONSEQUENCE")
+print("25 K_epsilon cells assembled: PASS")
+print("14 candidate Annulus blind gaps: ordered/disjoint/in (epsilon,T): PASS")
+print("153 Hub image pieces from K_epsilon avoid all 14 blind gaps: PASS")
+print("blind measure = 14(h-2 epsilon) = 7/2(T-10Delta-8epsilon) > 0: PASS")
+print("FIREWALL: kernel conclusion imports promoted IMG4 reducing/Hub/KNF mechanism")
+print("SW1 M1-ND SALVAGE-A1/A2 UNIFORM BLIND WEDGE CERTIFICATE: PASS")
diff --git a/scripts/certify_sw1_m1_nd_salvage_direct_complement_crosscheck.py b/scripts/certify_sw1_m1_nd_salvage_direct_complement_crosscheck.py
new file mode 100644
index 00000000..80ca06fa
--- /dev/null
+++ b/scripts/certify_sw1_m1_nd_salvage_direct_complement_crosscheck.py
@@ -0,0 +1,176 @@
+#!/usr/bin/env python3
+"""Direct-complement adversarial cross-check for SALVAGE-A1/A2.
+
+Unlike the primary certificate, this script does NOT infer K-invariance from
+F-invariance plus inverse generators.  It constructs the 25 complement cells
+K_epsilon directly and checks every active K-cell/domain image under all nine
+A7 maps is again covered by K_epsilon, uniformly for
+    0 < epsilon < epsilon_c.
+
+It also independently re-enumerates the physical Hub pieces from K_epsilon
+and checks direct avoidance of all 14 candidate blind intervals.
+
+This is a cross-check of Gates B/C only.  No functional-analytic kernel claim.
+"""
+
+import sympy as sp
+
+print("SW1 M1-ND SALVAGE DIRECT-COMPLEMENT CROSSCHECK")
+
+L2,L3=sp.log(2),sp.log(3)
+a=L2/2
+b=L3/2
+T=L2
+d=b-a
+Delta=sp.expand(L3-sp.Rational(3,2)*L2)
+h=sp.expand((T-10*Delta)/4)
+eps_c=sp.expand(h/2)
+eps=sp.symbols("eps", real=True)
+T0=T+eps
+
+def linlog_coeff(expr):
+    z=sp.expand(expr)
+    A=sp.simplify(z.coeff(L2))
+    B=sp.simplify(z.coeff(L3))
+    rest=sp.simplify(z-A*L2-B*L3)
+    assert rest==0,(expr,A,B,rest)
+    assert A.is_Rational and B.is_Rational
+    return sp.Rational(A),sp.Rational(B)
+
+def sign_log(expr):
+    A,B=linlog_coeff(expr)
+    if A==0 and B==0: return 0
+    if A>=0 and B>=0: return 1
+    if A<=0 and B<=0: return -1
+    den=sp.ilcm(int(A.q),int(B.q))
+    ai=int(A*den); bi=int(B*den)
+    if ai>0 and bi<0:
+        return (2**ai>3**(-bi))-(2**ai<3**(-bi))
+    if ai<0 and bi>0:
+        return (3**bi>2**(-ai))-(3**bi<2**(-ai))
+    raise AssertionError((expr,A,B))
+
+def sign_uniform(expr):
+    z=sp.expand(expr)
+    ce=sp.simplify(z.coeff(eps))
+    rest=sp.expand(z-ce*eps)
+    assert ce.is_Rational
+    s0=sign_log(rest)
+    s1=sign_log(sp.expand(rest+ce*eps_c))
+    if s0==0:
+        return 1 if ce>0 else (-1 if ce<0 else 0)
+    if s1==0:
+        return s0
+    assert s0==s1,("crossing",expr,s0,s1)
+    return s0
+
+def cmpu(x,y): return sign_uniform(sp.expand(x-y))
+def maxu(x,y): return x if cmpu(x,y)>=0 else y
+def minu(x,y): return x if cmpu(x,y)<=0 else y
+
+def inter(I,J):
+    lo=maxu(I[0],J[0]); hi=minu(I[1],J[1])
+    return (sp.expand(lo),sp.expand(hi)) if cmpu(hi,lo)>0 else None
+
+def image(I,s,c):
+    lo,hi=I
+    return (sp.expand(lo+c),sp.expand(hi+c)) if s==1 else (sp.expand(c-hi),sp.expand(c-lo))
+
+rep=sp.expand(eps_c/2)
+
+# Construct F only to determine the complement endpoints.
+F=[]
+for shift in (sp.Integer(0),a):
+    for k in range(6):
+        for j in (0,1):
+            base=sp.expand(shift+k*Delta+j*h)
+            F.append((sp.expand(base+eps),sp.expand(base+h-eps)))
+F.sort(key=lambda z:float(sp.N(z[0].subs(eps,rep),50)))
+
+K=[]
+cur=sp.Integer(0)
+for lo,hi in F:
+    if cmpu(lo,cur)>0:
+        K.append((sp.expand(cur),sp.expand(lo)))
+    cur=hi
+if cmpu(T0,cur)>0:
+    K.append((sp.expand(cur),sp.expand(T0)))
+assert len(K)==25
+
+def covered_by_K(I):
+    pieces=[J for G in K if (J:=inter(I,G)) is not None]
+    assert pieces,("no K cover",I)
+    pieces.sort(key=lambda z:float(sp.N(z[0].subs(eps,rep),50)))
+    assert cmpu(pieces[0][0],I[0])<=0
+    cur=pieces[0][1]
+    for lo,hi in pieces[1:]:
+        assert cmpu(lo,cur)<=0,("K cover gap",I,cur,(lo,hi))
+        if cmpu(hi,cur)>0: cur=hi
+    assert cmpu(cur,I[1])>=0
+
+domains={
+    "+a": ( 1, a, [(sp.Integer(0),a+eps)]),
+    "-a": ( 1,-a, [(a,T0)]),
+    "+T": ( 1, T, [(sp.Integer(0),eps)]),
+    "-T": ( 1,-T, [(T,T0)]),
+    "r_a":(-1, a, [(sp.Integer(0),eps),(a-eps,a)]),
+    "r_T":(-1, T, [(sp.Integer(0),T)]),
+    "r_3a":(-1,3*a,[(a-eps,T0)]),
+    "r_4a":(-1,4*a,[(T-eps,T0)]),
+    "r_2b":(-1,2*b,[(2*d-eps,T0)]),
+}
+
+counts={}
+total=0
+for name,(s,c,Ds) in domains.items():
+    n=0
+    for I in K:
+        for D in Ds:
+            J=inter(I,D)
+            if J is None: continue
+            covered_by_K(image(J,s,c))
+            n+=1; total+=1
+    counts[name]=n
+
+# The count is a checksum after exhaustive loops, not an assumption.
+assert set(counts)==set(domains)
+
+C=[
+    sp.Integer(0),Delta,2*Delta,3*Delta,
+    d,d+Delta,d+2*Delta,
+    a,a+Delta,a+2*Delta,a+3*Delta,
+    b,b+Delta,b+2*Delta,
+]
+B=[(sp.expand(c+eps),sp.expand(c+h-eps)) for c in C]
+
+def avoids_B(I):
+    assert all(inter(I,J) is None for J in B)
+
+hub_counts={}
+hub_total=0
+for tau_name,tau in (("a",a),("b",b),("T",T)):
+    n=0
+    for I in K:
+        left=inter(I,(sp.Integer(0),tau))
+        if left is not None:
+            avoids_B((sp.expand(tau-left[1]),sp.expand(tau-left[0])))
+            n+=1; hub_total+=1
+        right=inter(I,(tau,T0))
+        if right is not None:
+            avoids_B((sp.expand(right[0]-tau),sp.expand(right[1]-tau)))
+            n+=1; hub_total+=1
+        avoids_B((sp.expand(I[0]+tau),sp.expand(I[1]+tau)))
+        n+=1; hub_total+=1
+    hub_counts[tau_name]=n
+
+assert hub_total==153
+
+print("25 complement cells reconstructed: PASS")
+print("direct K-invariance under all nine A7 maps: PASS")
+print("active K/domain image counts:",counts)
+print("total active K/domain pieces:",total)
+print("Hub piece counts by center:",hub_counts)
+print("Hub total pieces:",hub_total)
+print("all Hub pieces avoid all 14 blind intervals: PASS")
+print("FIREWALL: Gate B/C direct cross-check only; no kernel promotion")
+print("SW1 M1-ND SALVAGE DIRECT-COMPLEMENT CROSSCHECK: PASS")
diff --git a/scripts/certify_sw1_m1_nd_salvage_uniform_raw_word_graph.py b/scripts/certify_sw1_m1_nd_salvage_uniform_raw_word_graph.py
new file mode 100644
index 00000000..5056bab0
--- /dev/null
+++ b/scripts/certify_sw1_m1_nd_salvage_uniform_raw_word_graph.py
@@ -0,0 +1,237 @@
+#!/usr/bin/env python3
+"""Uniform raw-word cross-check for the SALVAGE lower-epsilon wedge.
+
+This closes the upstream question left by the older A1 representative-point
+certificate.  It works symbolically for the full open interval
+
+    0 < epsilon < epsilon_c = (T-10*Delta)/8
+
+and derives the A7 graph directly from the eleven raw four-echo A1 words.
+
+Certified:
+1. all positive internal gate/source-horizon walls are exactly
+      epsilon, a-epsilon, a+epsilon, 2d-epsilon, T-epsilon;
+2. all positive internal source-folding zeros are exactly a,T;
+3. therefore the eight open lower-chamber row cells are exhaustive;
+4. direct raw-word evaluation on those cells produces exactly the nine A7
+   nonidentity maps, no tenth map;
+5. the mapwise unions equal A7.1--A7.9 uniformly in epsilon.
+
+No reducing-subspace or kernel claim.
+"""
+
+import sympy as sp
+import certify_sw1_a1_raw_archetypes as a1
+
+print("SW1 M1-ND SALVAGE UNIFORM RAW-WORD GRAPH CROSSCHECK")
+
+X=a1.X
+L2,L3=sp.log(2),sp.log(3)
+a,b,T,d,Delta=a1.a,a1.b,a1.T,a1.d,a1.Delta
+eps=sp.symbols("eps", real=True)
+eps_c=sp.expand((T-10*Delta)/8)
+T0=T+eps
+
+# ---------- exact signs on 0<eps<eps_c ----------
+
+def linlog_coeff(expr):
+    z=sp.expand(expr)
+    A=sp.simplify(z.coeff(L2))
+    B=sp.simplify(z.coeff(L3))
+    rest=sp.simplify(z-A*L2-B*L3)
+    assert rest==0,(expr,A,B,rest)
+    assert A.is_Rational and B.is_Rational
+    return sp.Rational(A),sp.Rational(B)
+
+def sign_log(expr):
+    A,B=linlog_coeff(expr)
+    if A==0 and B==0: return 0
+    if A>=0 and B>=0: return 1
+    if A<=0 and B<=0: return -1
+    den=sp.ilcm(int(A.q),int(B.q))
+    ai=int(A*den); bi=int(B*den)
+    if ai>0 and bi<0:
+        return (2**ai>3**(-bi))-(2**ai<3**(-bi))
+    if ai<0 and bi>0:
+        return (3**bi>2**(-ai))-(3**bi<2**(-ai))
+    raise AssertionError((expr,A,B))
+
+def sign_uniform(expr):
+    z=sp.expand(expr)
+    ce=sp.simplify(z.coeff(eps))
+    rest=sp.expand(z-ce*eps)
+    assert ce.is_Rational,(expr,ce)
+    s0=sign_log(rest)
+    s1=sign_log(sp.expand(rest+ce*eps_c))
+    if s0==0:
+        return 1 if ce>0 else (-1 if ce<0 else 0)
+    if s1==0:
+        return s0
+    assert s0==s1,("epsilon crossing",expr,s0,s1)
+    return s0
+
+assert sign_log(sp.expand(Delta/2-eps_c))>0
+assert sign_uniform(eps)>0
+assert sign_uniform(eps_c-eps)>0
+
+# ---------- exhaustive wall reconstruction ----------
+
+walls=set()
+foldzeros=set()
+
+for delta,eta,lam in a1.WORDS:
+    # Horizon gate equations |x +/- delta| = T0-lambda.
+    B=sp.expand(T0-lam)
+    for shift in (-delta,delta):
+        for s in (-1,1):
+            x=sp.expand(s*B-shift)
+            if sign_uniform(x)>0 and sign_uniform(T0-x)>0:
+                walls.add(sp.simplify(x))
+
+    # Source horizon equations |x+shift|=T0 and folding zeros x+shift=0.
+    shifts=(-delta-eta,-delta+eta,delta-eta,delta+eta)
+    for shift in shifts:
+        for s in (-1,1):
+            x=sp.expand(s*T0-shift)
+            if sign_uniform(x)>0 and sign_uniform(T0-x)>0:
+                walls.add(sp.simplify(x))
+        x0=sp.expand(-shift)
+        if sign_uniform(x0)>0 and sign_uniform(T0-x0)>0:
+            foldzeros.add(sp.simplify(x0))
+
+expected_walls={
+    sp.simplify(eps),
+    sp.simplify(a-eps),
+    sp.simplify(a+eps),
+    sp.simplify(2*d-eps),
+    sp.simplify(T-eps),
+}
+assert walls==expected_walls,(walls,expected_walls)
+assert foldzeros=={sp.simplify(a),sp.simplify(T)},foldzeros
+
+# ---------- direct raw-word evaluation on exhaustive open cells ----------
+
+def inside_abs_uniform(q,bound):
+    return sign_uniform(sp.expand(bound-q))>=0 and sign_uniform(sp.expand(bound+q))>=0
+
+def folded(src_sym,src_mid):
+    s=sign_uniform(src_mid)
+    assert s!=0,("fold zero at row midpoint",src_mid)
+    return sp.expand(src_sym if s>0 else -src_sym)
+
+def aggregate_direct(mid):
+    out={}
+    for j,(delta,eta,lam) in enumerate(a1.WORDS):
+        shifts=(-delta-eta,-delta+eta,delta-eta,delta+eta)
+        gates=(X-delta,X-delta,X+delta,X+delta)
+        for k,(gexpr,sh) in enumerate(zip(gates,shifts)):
+            gmid=sp.expand(gexpr.subs(X,mid))
+            if not inside_abs_uniform(gmid,T0-lam):
+                continue
+            src=X+sh
+            smid=sp.expand(src.subs(X,mid))
+            if not inside_abs_uniform(smid,T0):
+                continue
+            prof=folded(src,smid)
+            out[prof]=sp.simplify(out.get(prof,0)+a1.SIGNS[k]*a1.weights[j])
+    return {sp.expand(k):sp.simplify(v) for k,v in out.items() if sp.simplify(v)!=0}
+
+regions=[
+    ("R0",sp.Integer(0),eps),
+    ("R1",eps,a-eps),
+    ("R2",a-eps,a),
+    ("R3",a,a+eps),
+    ("R4I",a+eps,2*d-eps),
+    ("R5",2*d-eps,T-eps),
+    ("R6",T-eps,T),
+    ("R7",T,T+eps),
+]
+for row,lo,hi in regions:
+    assert sign_uniform(hi-lo)>0,(row,lo,hi)
+
+map_exprs={
+    "+a":X+a,
+    "-a":X-a,
+    "+T":X+T,
+    "-T":X-T,
+    "r_a":a-X,
+    "r_T":T-X,
+    "r_3a":3*a-X,
+    "r_4a":4*a-X,
+    "r_2b":2*b-X,
+}
+
+def classify(expr):
+    if sp.simplify(expr-X)==0:
+        return "I"
+    for name,ref in map_exprs.items():
+        if sp.simplify(expr-ref)==0:
+            return name
+    raise AssertionError(("unexpected map",expr))
+
+by_map={}
+row_maps={}
+for row,lo,hi in regions:
+    mid=sp.expand((lo+hi)/2)
+    got=aggregate_direct(mid)
+    names=[]
+    for expr,coeff in got.items():
+        name=classify(expr)
+        if name=="I":
+            continue
+        names.append(name)
+        by_map.setdefault(name,[]).append((lo,hi))
+    row_maps[row]=names
+
+assert set(by_map)==set(map_exprs),(set(by_map),set(map_exprs))
+assert set(row_maps["R6"])=={"r_T","r_3a","r_4a","-a","r_2b"}
+assert set(row_maps["R7"])=={"-T","r_3a","r_4a","-a","r_2b"}
+
+# ---------- symbolic interval-union reconstruction ----------
+
+rep=sp.expand(eps_c/2)
+
+def merge(intervals):
+    xs=sorted(intervals,key=lambda I:float(sp.N(I[0].subs(eps,rep),50)))
+    out=[]
+    for lo,hi in xs:
+        if not out:
+            out.append([lo,hi]); continue
+        gap=sign_uniform(sp.expand(lo-out[-1][1]))
+        if gap<=0:
+            if sign_uniform(sp.expand(hi-out[-1][1]))>0:
+                out[-1][1]=hi
+        else:
+            out.append([lo,hi])
+    return [(sp.expand(lo),sp.expand(hi)) for lo,hi in out]
+
+got_domains={name:merge(iv) for name,iv in by_map.items()}
+expected={
+    "+a":[(sp.Integer(0),a+eps)],
+    "-a":[(a,T0)],
+    "+T":[(sp.Integer(0),eps)],
+    "-T":[(T,T0)],
+    "r_a":[(sp.Integer(0),eps),(a-eps,a)],
+    "r_T":[(sp.Integer(0),T)],
+    "r_3a":[(a-eps,T0)],
+    "r_4a":[(T-eps,T0)],
+    "r_2b":[(2*d-eps,T0)],
+}
+
+assert set(got_domains)==set(expected)
+for name in expected:
+    assert len(got_domains[name])==len(expected[name]),(name,got_domains[name],expected[name])
+    for (glo,ghi),(elo,ehi) in zip(got_domains[name],expected[name]):
+        assert sp.simplify(glo-elo)==0,(name,"lo",glo,elo)
+        assert sp.simplify(ghi-ehi)==0,(name,"hi",ghi,ehi)
+
+print("eleven raw A1 words evaluated symbolically: PASS")
+print("all positive internal horizon walls =",sorted(map(str,walls)))
+print("all positive source-folding zeros =",sorted(map(str,foldzeros)))
+print("eight lower-wedge row cells exhaustive: PASS")
+print("derived nonidentity alphabet =",sorted(by_map))
+print("no tenth nonidentity map: PASS")
+print("derived domains == A7.1--A7.9 uniformly in epsilon: PASS")
+print("R6/R7 five-arm support uniform in epsilon: PASS")
+print("FIREWALL: raw graph support only; no reducing/kernel verdict")
+print("SW1 M1-ND SALVAGE UNIFORM RAW-WORD GRAPH CROSSCHECK: PASS")
diff --git a/scripts/probe_sw1_m1_nd_salvage_phase_diagram.py b/scripts/probe_sw1_m1_nd_salvage_phase_diagram.py
new file mode 100644
index 00000000..1086ea6f
--- /dev/null
+++ b/scripts/probe_sw1_m1_nd_salvage_phase_diagram.py
@@ -0,0 +1,199 @@
+#!/usr/bin/env python3
+"""Exploratory full-FREE saturation probe for the M1-ND salvage phase diagram.
+
+This is deliberately NOT a certificate.  It numerically saturates the maximal
+KNF sampling set R=epsilon under all nine lower-chamber A7 maps, then computes
+the exact physical six-branch Hub visibility on the positive annulus.
+
+The probe tests the candidate
+    h = (T-10 Delta)/4 = d-3 Delta,
+    epsilon_c = h/2,
+and the 14 candidate blind gaps
+    (c+epsilon, c+h-epsilon)
+for c in
+    0,D,2D,3D,
+    d,d+D,d+2D,
+    a,a+D,a+2D,a+3D,
+    b,b+D,b+2D.
+
+Numerical agreement is discovery evidence only.  SALVAGE-A1/A2 must replace
+this probe by symbolic interval-cell and Hub-exclusion proofs before promotion.
+"""
+
+from mpmath import mp
+
+mp.dps=80
+
+L2=mp.log(2)
+L3=mp.log(3)
+a=L2/2
+b=L3/2
+T=L2
+d=b-a
+Delta=L3-mp.mpf(3)/2*L2
+h=(T-10*Delta)/4
+epscrit=h/2
+
+TOL=mp.mpf("1e-60")
+
+def merge(intervals):
+    xs=sorted((l,r) for l,r in intervals if r-l>TOL)
+    out=[]
+    for l,r in xs:
+        if not out or l>out[-1][1]+TOL:
+            out.append([l,r])
+        elif r>out[-1][1]:
+            out[-1][1]=r
+    return [(l,r) for l,r in out]
+
+def inter(I,J):
+    l=max(I[0],J[0])
+    r=min(I[1],J[1])
+    return (l,r) if r-l>TOL else None
+
+def image(I,s,c):
+    l,r=I
+    return (l+c,r+c) if s==1 else (c-r,c-l)
+
+def saturation(eps,maxit=4000):
+    T0=T+eps
+    domains=[
+        ( 1, a, [(0,a+eps)]),
+        ( 1,-a, [(a,T0)]),
+        ( 1, T, [(0,eps)]),
+        ( 1,-T, [(T,T0)]),
+        (-1, a, [(0,eps),(a-eps,a)]),
+        (-1, T, [(0,T)]),
+        (-1,3*a, [(a-eps,T0)]),
+        (-1,4*a, [(T-eps,T0)]),
+        (-1,2*b, [(2*d-eps,T0)]),
+    ]
+    V=merge([
+        (a-eps,a+eps),
+        (b-eps,b+eps),
+        (T-eps,T+eps),
+    ])
+    for it in range(1,maxit+1):
+        new=list(V)
+        for I in V:
+            for s,c,doms in domains:
+                for D in doms:
+                    K=inter(I,D)
+                    if K is None:
+                        continue
+                    J=inter(image(K,s,c),(mp.mpf("0"),T0))
+                    if J is not None:
+                        new.append(J)
+        V2=merge(new)
+        if len(V2)==len(V) and all(
+            abs(x-u)<TOL and abs(y-v)<TOL
+            for (x,y),(u,v) in zip(V2,V)
+        ):
+            return V2,it
+        V=V2
+    raise RuntimeError("saturation did not stabilize")
+
+def hub_visibility(V,eps):
+    # Boundary-majorant geometry R=eps; choose sigma=eps/2.
+    R=eps
+    S=T+eps/2
+    ann=(R,S)
+    images=[]
+    for l,r in V:
+        for tau in (a,b,T):
+            # |x-tau|, split at tau.
+            if l<tau:
+                K=(l,min(r,tau))
+                if K[1]-K[0]>TOL:
+                    Q=inter((tau-K[1],tau-K[0]),ann)
+                    if Q is not None:
+                        images.append(Q)
+            if r>tau:
+                K=(max(l,tau),r)
+                if K[1]-K[0]>TOL:
+                    Q=inter((K[0]-tau,K[1]-tau),ann)
+                    if Q is not None:
+                        images.append(Q)
+            # x+tau.
+            Q=inter((l+tau,r+tau),ann)
+            if Q is not None:
+                images.append(Q)
+    return merge(images),ann
+
+def blind_measure(W,ann):
+    cur=ann[0]
+    total=mp.mpf("0")
+    gaps=[]
+    for l,r in W:
+        if l>cur+TOL:
+            gaps.append((cur,l))
+            total += l-cur
+        cur=max(cur,r)
+    if cur<ann[1]-TOL:
+        gaps.append((cur,ann[1]))
+        total += ann[1]-cur
+    return total,gaps
+
+C=[
+    0,Delta,2*Delta,3*Delta,
+    d,d+Delta,d+2*Delta,
+    a,a+Delta,a+2*Delta,a+3*Delta,
+    b,b+Delta,b+2*Delta,
+]
+assert len(C)==14
+
+# Exact constant identities, checked numerically at 80 digits.
+assert abs(h-(d-3*Delta)) < TOL
+assert abs(h-(a-(d+2*Delta))) < TOL
+assert abs(h-(b-(a+3*Delta))) < TOL
+assert abs(h-(T-(b+2*Delta))) < TOL
+
+print("SW1 M1-ND SALVAGE PHASE-DIAGRAM PROBE")
+print("Delta =",mp.nstr(Delta,30))
+print("h =",mp.nstr(h,30))
+print("epsilon_c/Delta =",mp.nstr(epscrit/Delta,30))
+
+for frac in ("0.05","0.10","0.15","0.18","0.20","0.22"):
+    eps=mp.mpf(frac)*Delta
+    assert eps<epscrit
+    V,it=saturation(eps)
+    W,ann=hub_visibility(V,eps)
+    beta,gaps=blind_measure(W,ann)
+
+    g=h-2*eps
+    assert g>0
+    cand=[(c+eps,c+h-eps) for c in C]
+
+    # Candidate gaps must lie in (eps,T) and be pairwise separated.
+    for l,r in cand:
+        assert l>=eps-TOL and r<=T+TOL and r-l>0
+
+    # Numerical disjointness from actual visible union.
+    for B in cand:
+        for J in W:
+            assert inter(B,J) is None
+
+    lower=14*g
+    assert beta+mp.mpf("1e-50") >= lower
+
+    print(
+        "eps/Delta=",frac,
+        "iters=",it,
+        "Vcells=",len(V),
+        "Wcells=",len(W),
+        "beta=",mp.nstr(beta,18),
+        "14g=",mp.nstr(lower,18),
+    )
+
+# Just above the candidate threshold the majorant scan reaches full support.
+eps=mp.mpf("0.23")*Delta
+assert eps>epscrit
+V,it=saturation(eps)
+W,ann=hub_visibility(V,eps)
+beta,_=blind_measure(W,ann)
+print("eps/Delta=0.23 exploratory beta =",mp.nstr(beta,18))
+assert abs(beta) < mp.mpf("1e-50")
+
+print("DISCOVERY: 14-gap candidate survives every tested epsilon<epsilon_c")
+print("DISCOVERY: boundary-majorant visibility is full at epsilon=0.23 Delta")
+print("FIREWALL: numerical probe only; no SALVAGE-A1/A2 theorem")