diff --git a/research/gaussian-gauge-column/README.md b/research/gaussian-gauge-column/README.md
new file mode 100644
index 0000000000..7926f38cfc
--- /dev/null
+++ b/research/gaussian-gauge-column/README.md
@@ -0,0 +1,139 @@
+# A within-cell column budget for the downward gauge
+
+**Claim type:** a written transfer inside one phase cell. **No new κ.**
+This is the within-cell half of the open question in #4437. It does not bound
+entries that cross a cell, and it does not edit the #4100 notes.
+
+## Question
+
+Inside one cell the rounded block is
+
+```text
+A = diag(ahat) Ghat diag(ahat)^{-1},
+```
+
+so a column is multiplied by the weight ratios `ahat_j / ahat_k`. Those ratios
+do not preserve the ideal column sums. Which relative error still leaves a
+column gap of size `1/(16p^2)`?
+
+## Lemma
+
+Inside a cell, `β_{i+h} = β_i + θ h` and `ρ = 1+θ`. The ideal entry factors as
+
+```text
+N_{i,i+h} = (a_i / a_{i+h}) exp(-a ρ h^2),
+```
+
+where `log(a_i/a_j) = a(i-j)(β_i+β_j)` is the gauge audit's identity. Thus the
+bare kernel `G_h = exp(-a ρ h^2)` is symmetric and Toeplitz.
+
+Suppose the rounded data satisfy `Ghat_0 = 1`, `0 ≤ Ghat_h ≤ G_h`, and
+
+```text
+(1-ε) a_i ≤ ahat_i ≤ a_i
+```
+
+with `0 ≤ ε < 1`. Every within-cell column then has off-sum at most the ideal
+column off-sum divided by `1-ε`, and its diagonal entry is 1.
+
+Take the ideal off-sum to be at most `1 - 1/(8p^2)`, which #4402 gives
+eventually inside a constant-phase run. The sufficient budget is
+
+```text
+ε ≤ 1/(16p^2).
+```
+
+The rounded column gap is then at least `1/(16p^2 - 1)`, hence strictly above
+`1/(16p^2)`. The gauge audit's stated allowance `ε ≤ 1/2` does not give this:
+it multiplies the ideal off-sum by 2, and `2(1 - 1/(8p^2)) > 1`.
+
+`GAUSSIAN.md` writes a relative error `< 2^{-C p}` for an unnamed positive
+setup constant `C`. The smallest value that meets `ε ≤ 1/(16p^2)` for every
+integer `p ≥ 2` is `C = 3`. At `p = 2` the powers are equal, and the note's
+inequality is strict. `C = 2` fails at `p = 2`, where `2^{-4} = 1/16` and the
+budget is `1/64`. This does not assert that the note's `C` is at least 3.
+
+## Proof
+
+The cell law `β_{i+h} = β_i + θ h` gives
+
+```text
+(ρ h + β_i)^2 - β_{i+h}^2 = (1+2θ) h^2 + 2 β_i h.
+```
+
+The gauge identity contributes `log(a_i/a_{i+h}) = -a h (2 β_i + θ h)`.
+Subtracting that logarithm from the ideal exponent cancels `β_i` and one
+factor of `θ`, and leaves `-a(1+θ) h^2`. The kernel depends only on `h`.
+
+A rounded entry is
+
+```text
+(ahat_i / ahat_{i+h}) Ghat_h
+    = (r_i / r_{i+h}) (a_i / a_{i+h}) Ghat_h,
+```
+
+with `1-ε ≤ r ≤ 1`. Downward rounding gives `Ghat_h ≤ G_h`, so the entry is
+at most `N_{i,i+h} / (1-ε)`. Summing a column multiplies the ideal off-sum by
+at most `1/(1-ε)`. The diagonal ratio is 1.
+
+If the ideal off-sum is at most `1 - γ` with `γ = 1/(8p^2)` and
+`ε = γ/2 = 1/(16p^2)`, the rounded gap is at least
+
+```text
+(γ - ε) / (1 - ε) = 1/(16p^2 - 1) > 1/(16p^2).
+```
+
+For `ε = 1/2` the comparison becomes `2(1-γ) = 2 - 1/(4p^2) > 1`.
+
+The same budget in exponential form is `2^{C p} ≥ 16 p^2`. Equality holds at
+`C = 3`, `p = 2`. For `p ≥ 2`, `(p+1)/p ≤ 3/2` and `(3/2)^2 = 9/4 < 8 = 2^3`,
+so the inequality persists and is strict after `p = 2`. At `C = 2` and `p = 2`,
+`2^4 = 16 < 64`.
+
+A row-sum bound does not replace this argument. The downstream estimate is a
+row bound, `||H-N|| < p · 2^{16p+7} η + 2^{-46p}`. Charging every one of the
+`2p-1` band entries with a row mass `1/(16p)` produces a column change
+`(2p-1)/(16p)`. That exceeds `1/(8p^2)` for every integer `p ≥ 2`, since
+`p(2p-1) > 2`.
+
+## Not covered
+
+- Entries across a cell. The downstream note uses the downward dyadic
+  approximation of the original entry there, not the ratio
+  `ahat_j Ghat_(j-k)/ahat_k`.
+- The claim that the written setup constant already satisfies `C ≥ 3`.
+- `||A^{-1}||_2`, the exponents in #4406, and any new κ. The selected record
+  remains `23/10000`.
+
+## Reproduce
+
+```sh
+python3.12 -B scripts/research_package.py --package research/gaussian-gauge-column --check-only
+python3.12 -B scripts/research_package.py --package research/gaussian-gauge-column
+```
+
+Base `2a13eb1827784206202db90e5dc8327cf8a250db`, priority revision 7, selection
+refresh κ = `23/10000`.
+
+Overlap on 2026-10-21 found no statement of this relative-error budget. The
+search hit unrelated defect ledgers. #4402 supplies the in-cell ideal column
+gap. #4437 extends that gap across a `g = 2` step and leaves this gauge
+question open. A search miss is not a novelty certificate.
+
+## Open next questions
+
+1. **Do the exponents 12, 26, 28, 28 and 7 apply inside one cell once `ε ≤ 1/(16p^2)`?**
+   Both gaps are then above `1/(16p^2)`, which is the ceiling #4406 used.
+   The first step is the Neumann bound #4402 already wrote, applied to this
+   rounded block. The global reference is still blocked because its
+   across-cell entries are the downward original entries, not this ratio.
+
+## Credit
+
+- The gauge identity and the one-sided weight inequality are the capped-gauge
+  audit's, from PR1673.
+- The in-cell column gap is Ryanson Jonathan's #4402.
+- The row perturbation that does not transfer is the downstream phase-cell note's.
+- #4437 asked for this column after the ideal `g = 2` bound.
+
+Prepared by James Reed with substantial Cursor Grok 4.7 assistance. Apache-2.0.
diff --git a/research/gaussian-gauge-column/SOURCES.json b/research/gaussian-gauge-column/SOURCES.json
new file mode 100644
index 0000000000..6d572e443c
--- /dev/null
+++ b/research/gaussian-gauge-column/SOURCES.json
@@ -0,0 +1,48 @@
+{
+  "schema_version": 1,
+  "base_commit": "2a13eb1827784206202db90e5dc8327cf8a250db",
+  "files": [
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "git_blob": "ed33caef5c5827693e9572d252a66f99cbb73d40",
+      "sha256": "5732707cc1e460b090b53f2463162749ad860de878a18f7408938671d295a9d9"
+    },
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "64bfc5af6709ed9811171e0a2108f05e1219cb65",
+      "sha256": "352a6184713b8843d96fd2c2071eb7aeaa655906b7c51d45ad444912666c8a96"
+    },
+    {
+      "path": "references/semantic-bulk/rad20/reports/downstream-phase-cell-inverse.md",
+      "usage": "input",
+      "git_blob": "d72345a0aa748443c4efcddf87aa10d524664841",
+      "sha256": "3cdf492bcb719db4295658604dc202d6a2c5a008b87de43ec54f0107c64db730"
+    },
+    {
+      "path": "research/capped-phase-fusion/CAPPED-GAUGE-AUDIT.md",
+      "usage": "input",
+      "git_blob": "a2d1c5ae923db7649627dbf419434e36267e57c6",
+      "sha256": "1030a34922709ab8d3434a4c57a4a58934ae268c237fb598cb415697da411c9f"
+    },
+    {
+      "path": "research/capped-phase-fusion/LOG-A-PHASE-SCHUR-AUDIT.md",
+      "usage": "input",
+      "git_blob": "3bcf490a8c164d44aff5b7e2ec2e0f4bf07d7a73",
+      "sha256": "e05d6b8596c80b6e8676569a0ff464a29fa704c3304143f58914f47cdf38b272"
+    },
+    {
+      "path": "research/gaussian-column-gap/README.md",
+      "usage": "input",
+      "git_blob": "7f8b5d9cbad96a1cd46432a6cf47422e2ced7fb4",
+      "sha256": "7e589bec5c03d788ac366c85080af9fe26dad254d289bec93553398380b46dab"
+    },
+    {
+      "path": "research/unconditional-batched-crt/GAUSSIAN.md",
+      "usage": "input",
+      "git_blob": "adfb28c93e6b06178c901caaac39ede41a9e541b",
+      "sha256": "2f63c91c58f2d1cf31294812c75970ea390c61866a8da7ed700d4316a033a242"
+    }
+  ]
+}
diff --git a/research/gaussian-gauge-column/TASK.json b/research/gaussian-gauge-column/TASK.json
new file mode 100644
index 0000000000..1d414eac6a
--- /dev/null
+++ b/research/gaussian-gauge-column/TASK.json
@@ -0,0 +1,74 @@
+{
+  "schema_version": 1,
+  "task_id": "uniform-transfer-audit",
+  "priority_revision": 7,
+  "base_commit": "2a13eb1827784206202db90e5dc8327cf8a250db",
+  "original_card": {
+    "id": "uniform-transfer-audit",
+    "question": "Does one quantified step of the proposed #4100 all-size construction hold at its actual caller?",
+    "starting_points": [
+      "docs/research/research-family-status.md",
+      "certificates/selected-result.json",
+      "research/unconditional-batched-crt/README.md"
+    ],
+    "methods": [
+      "Prove one missing implication with explicit quantified hypotheses.",
+      "Find an exact counterexample at the claimed interface boundary."
+    ],
+    "acceptance_gate": "Identify the proposition and what would change downstream; do not equate a finite replay with a universal proof.",
+    "first_step": {
+      "command": [
+        "python3",
+        "-B",
+        "scripts/research_baseline.py"
+      ],
+      "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY",
+      "inspect": "Read PROOF.md and AUDIT.md in #4100. Select one distinct obligation: CRT total repair, native/free-algebra lifting, precision/conditioning, or complete fixed-tape cost. This is an author-submitted proof, not an accepted unconditional theorem.",
+      "scope": "Source-binding orientation only; no scientific replay, theorem acceptance or supplier admission. Budget any heavy replay separately."
+    },
+    "first_experiment": "Check live handoffs; name one proposition, its caller, quantified domain and dependency closure. Independently prove the implication or exhibit a precise gap/counterexample. Prioritize CRT.md total repair or COMPLEX.md free-algebra lift only if unclaimed. Stop at the chosen obligation; do not substitute finite samples or root arithmetic for an all-size proof, or launch the complete package by default.",
+    "bottleneck_link": "Finite supplier improvements are useful only under the retained transfer obligations.",
+    "allowed_variations": [
+      "One CRT repair, native lift, precision/conditioning or tape-cost proposition, with its exact caller."
+    ],
+    "scope_change_triggers": [
+      "Replacing a quantified obligation with another finite smoke test.",
+      "Treating archive intake, an author PASS receipt or a finite composed fixture as discharge of the universal hypotheses."
+    ],
+    "overlap_terms": [
+      "uniform transfer",
+      "all-size",
+      "precision",
+      "4100",
+      "unconditional-batched-crt"
+    ],
+    "existing_checks": [
+      {
+        "scope": "PR #4100: proposed unconditional construction and finite checks, without independent acceptance.",
+        "evidence": "research/unconditional-batched-crt/README.md",
+        "remaining": "Independent proof audit of one caller-bound all-size implication; all other premises remain explicit.",
+        "status": "author-checked",
+        "source_commit": "337d04939571a637aeab54a0f58f54fde811663a",
+        "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+      }
+    ]
+  },
+  "scope_status": "refined",
+  "actual_scope": "Find the relative weight error that preserves a 1/(16p^2) column gap for the within-cell matrix diag(ahat) Ghat diag(ahat)^{-1}.",
+  "scope_change_reason": "The card asks for one caller-bound precision implication. This package bounds the gauge ratio inside one cell. It does not bound the across-cell entries of the rounded reference.",
+  "bottleneck_link": "The selected frontier is unchanged. A within-cell column gap of size 1/(16p^2) is the hypothesis #4406 needs before its smaller exponents can apply to that block.",
+  "budget_minutes": 60,
+  "stop_rule": "Stop at the sufficient relative error and the smallest integer setup constant that meets it. Do not bound across-cell entries, do not edit the #4100 notes, and do not claim a new kappa.",
+  "outcome": "completed",
+  "evidence": "python3.12 -B scripts/research_package.py --package research/gaussian-gauge-column",
+  "author": "James Reed",
+  "ai_assistance": "Substantial help from Cursor Grok 4.7 on the kernel factorization, the relative-error budget and the package text.",
+  "open_questions": [
+    {
+      "question": "Do the exponents 12, 26, 28, 28 and 7 apply inside one cell once the relative weight error is at most 1/(16p^2)?",
+      "why_it_matters": "Both gaps are then above 1/(16p^2), which is the ceiling those exponents used.",
+      "first_step": "Apply the Neumann bound from the constant-phase column lemma to this rounded block.",
+      "blocked_by": "Nothing in the weight ratio blocks the within-cell step. The global reference remains blocked because its across-cell entries are the downward original entries, not this ratio."
+    }
+  ]
+}
diff --git a/research/gaussian-gauge-column/VERIFY.json b/research/gaussian-gauge-column/VERIFY.json
new file mode 100644
index 0000000000..d5f80aa5cc
--- /dev/null
+++ b/research/gaussian-gauge-column/VERIFY.json
@@ -0,0 +1,25 @@
+{
+  "schema_version": 1,
+  "status": "ready",
+  "python": "3.12",
+  "requirements": [],
+  "inputs": [
+    "certificates/selected-result.json",
+    "references/semantic-bulk/rad20/reports/downstream-phase-cell-inverse.md",
+    "research/capped-phase-fusion/CAPPED-GAUGE-AUDIT.md",
+    "research/capped-phase-fusion/LOG-A-PHASE-SCHUR-AUDIT.md",
+    "research/gaussian-column-gap/README.md",
+    "research/unconditional-batched-crt/GAUSSIAN.md"
+  ],
+  "commands": [
+    {
+      "argv": [
+        "{python}",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 60,
+      "checks": "Kernel factorization, the 1/(16p^2) budget, and the failure of epsilon 1/2 and of C=2."
+    }
+  ]
+}
diff --git a/research/gaussian-gauge-column/verify.py b/research/gaussian-gauge-column/verify.py
new file mode 100644
index 0000000000..7e811ee91e
--- /dev/null
+++ b/research/gaussian-gauge-column/verify.py
@@ -0,0 +1,147 @@
+#!/usr/bin/env python3
+"""Within-cell column transfer for a downward gauge.
+
+Integer identities only. The ideal column gap is a hypothesis, taken from
+the constant-phase lemma. This does not bound across-cell entries.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+PACKAGE = ROOT / "research" / "gaussian-gauge-column"
+
+
+def digest(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+
+def add(left, right):
+    out = dict(left)
+    for key, coeff in right.items():
+        out[key] = out.get(key, 0) + coeff
+        if out[key] == 0:
+            del out[key]
+    return out
+
+
+def scale(poly, factor):
+    return {key: factor * coeff for key, coeff in poly.items() if factor * coeff}
+
+
+def mul(left, right):
+    out = {}
+    for degree, coeff in left.items():
+        for other, factor in right.items():
+            key = degree + other
+            out[key] = out.get(key, 0) + coeff * factor
+    return {key: coeff for key, coeff in out.items() if coeff}
+
+
+def pins_and_phrases() -> None:
+    sources = json.loads((PACKAGE / "SOURCES.json").read_text(encoding="utf-8"))
+    for row in sources["files"]:
+        if row["usage"] == "input":
+            assert digest(ROOT / row["path"]) == row["sha256"], row["path"]
+    log_a = (
+        ROOT / "research/capped-phase-fusion/LOG-A-PHASE-SCHUR-AUDIT.md"
+    ).read_text(encoding="utf-8")
+    gauge = (
+        ROOT / "research/capped-phase-fusion/CAPPED-GAUGE-AUDIT.md"
+    ).read_text(encoding="utf-8")
+    gaussian = (
+        ROOT / "research/unconditional-batched-crt/GAUSSIAN.md"
+    ).read_text(encoding="utf-8")
+    column = (ROOT / "research/gaussian-column-gap/README.md").read_text(
+        encoding="utf-8"
+    )
+    downstream = (
+        ROOT / "references/semantic-bulk/rad20/reports/downstream-phase-cell-inverse.md"
+    ).read_text(encoding="utf-8")
+    selected = json.loads(
+        (ROOT / "certificates/selected-result.json").read_text(encoding="utf-8")
+    )
+    assert "ahat_j Ghat_(j-k)/ahat_k" in log_a
+    assert "Downward rounding only decreases this off-diagonal sum." in log_a
+    assert "(1-epsilon) a_i <= ahat_i <= a_i`, with epsilon<=1/2." in gauge
+    assert "log(a_i/a_j)=a(i-j)(beta_i+beta_j)" in gauge
+    assert "A=diag(ahat) Ghat diag(ahat)^-1" in gauge
+    assert "P_setup=Cp+64p^2ceil(log2 p)" in gaussian
+    assert "relative error<2^-Cp" in gaussian
+    assert "`δ_col` exceeds `1/(8p²)` eventually" in column
+    assert "||H-N|| < p*2^(16p+7)*eta + 2^(-46p)." in downstream
+    assert "Across different cells use the downward\ndyadic approximation" in downstream
+    assert selected["kappa"] == "23/10000"
+
+
+def kernel_factorization() -> None:
+    # (β + θh + h)^2 - (β + θh)^2 = h^2 + 2 θ h^2 + 2 β h.
+    # Keys are (power of β, power of θh, power of h).
+    beta = {(1, 0, 0): 1}
+    shift = {(0, 1, 0): 1}
+    step = {(0, 0, 1): 1}
+
+    def tmul(left, right):
+        out = {}
+        for left_key, left_coeff in left.items():
+            for right_key, right_coeff in right.items():
+                key = tuple(a + b for a, b in zip(left_key, right_key))
+                out[key] = out.get(key, 0) + left_coeff * right_coeff
+        return {key: coeff for key, coeff in out.items() if coeff}
+
+    grown = add(add(beta, shift), step)
+    square = add(tmul(grown, grown), scale(tmul(add(beta, shift), add(beta, shift)), -1))
+    assert square == add(add(tmul(step, step), scale(tmul(shift, step), 2)), scale(tmul(beta, step), 2))
+    # Divide by a: subtract the log-ratio -h(2β + θh) from the row exponent.
+    row = {0: 1, 1: 2, 2: 2}
+    ratio = {1: -1, 2: -2}
+    assert add(scale(row, -1), scale(ratio, -1)) == {0: -1, 1: -1}
+
+
+def column_budget() -> None:
+    # off_H <= off_N/(1-ε). With off_N <= 1-1/(8p^2) and ε=1/(16p^2),
+    # the gap is at least 1/(16p^2-1) > 1/(16p^2).
+    cleared = {2: 16, 0: -1}
+    assert add(cleared, {0: 1}) == {2: 16}
+    # ε=1/2 gives the upper bound 2-1/(4p^2), and 4p^2>1.
+    assert 2 * 4 == 8
+    assert 4 * 2 * 2 > 1
+    # (2p-1)/(16p) > 1/(8p^2) iff p(2p-1)-2 > 0.
+    value = add(mul({1: 2, 0: -1}, {1: 1}), {0: -2})
+    assert value == {2: 2, 1: -1, 0: -2}
+    assert 2 * 4 - 2 - 2 == 4
+    nxt = add(
+        add(mul({0: 2}, mul({1: 1, 0: 1}, {1: 1, 0: 1})), scale({1: 1, 0: 1}, -1)),
+        {0: -2},
+    )
+    assert add(nxt, scale(value, -1)) == {1: 4, 0: 1}
+
+
+def setup_constant() -> None:
+    # Smallest C with 2^{C p} >= 16 p^2 for every integer p>=2 is C=3.
+    assert 2 ** (3 * 2) == 64 == 16 * (2 ** 2)
+    assert 2 ** (2 * 2) == 16
+    assert 16 < 64
+    # ((p+1)/p)^2 <= (3/2)^2 = 9/4 < 8 = 2^3.
+    assert 3 * 2 - 2 * (2 + 1) == 0
+    assert 9 < 32
+    assert uni_gap() == {1: 1, 0: -2}
+
+
+def uni_gap() -> dict:
+    return add({1: 3}, scale({1: 2, 0: 2}, -1))
+
+
+def main() -> None:
+    pins_and_phrases()
+    kernel_factorization()
+    column_budget()
+    setup_constant()
+    print("PASS_GAUSSIAN_GAUGE_COLUMN")
+
+
+if __name__ == "__main__":
+    main()