diff --git a/research/gaussian-tensor-nine-fold/README.md b/research/gaussian-tensor-nine-fold/README.md
new file mode 100644
index 0000000000..af78553b99
--- /dev/null
+++ b/research/gaussian-tensor-nine-fold/README.md
@@ -0,0 +1,156 @@
+# The telescoping factor with coefficient 9 is absorbed by the same gate
+
+**Claim type:** an explicit absorption bound for one telescoping monomial.
+**No new κ.** The section ceiling `9 p^2` and the section error
+`p^6 exp(-p^2)` stay hypotheses. The selected record remains `23/10000`.
+
+## Question
+
+#4495 absorbs `g (9 p^2)^g exp(K p - p^2)` under the gate
+`p ≥ max(64, 4K + 2C)` and `16 g ceil(log2 p) ≤ p`. The extra factor in
+
+```text
+g (9 p^2)^{g-1} p^6 exp(K p - p^2)
+```
+
+is `p^4 / 9`. Does that monomial stay below `2^{-C p}` under the same gate?
+
+## Lemma
+
+Let `p ≥ 2`, `g ≥ 1`, `K ≥ 0` and `C ≥ 0` be integers, and let
+`L = ceil(log2 p)`. If
+
+```text
+p ≥ max(64, 4K + 2C)    and    16 g L ≤ p,
+```
+
+then
+
+```text
+g (9 p^2)^{g-1} p^6 exp(K p - p^2) < 2^{-C p}.
+```
+
+The case `K = 0` is the monomial in the question. A global factor `exp(K p)`
+does not change the conclusion. Whenever `g log p = o(p)`, every fixed pair
+`K, C` satisfies the gate for all large `p`.
+
+The identity is
+
+```text
+g (9 p^2)^{g-1} p^6 = g (9 p^2)^g (p^4 / 9).
+```
+
+Placing `p^4 / 9` in the exponent contributes `4 L - 3`, because
+`p^4 ≤ 2^{4 L}` and `9 > 8 = 2^3`. The resulting exponent is at most
+`-C p - 3`.
+
+The gate is not optional for every `g`. At `g = p^2` the telescoping error
+is greater than 1 for every integer `p ≥ 2`.
+
+## Proof
+
+The series `1 + 1 + 1/2 = 5/2 > 2` gives `e > 2`, so `exp(-p^2) < 2^{-p^2}`.
+For `k ≥ 2`, `k! ≥ 2^{k-1}`: the values at 2, 3 and 4 are `2`, `6` and `24`,
+and the step uses `k + 1 ≥ 2`. The tail of `e` is then at most the geometric
+series of ratio `1/2`, so `e < 3 < 4` and `exp(K p) < 4^{K p} = 2^{2 K p}`
+whenever `K p > 0`. At `K = 0` the factor is 1.
+
+Since `9 < 16`, `(9 p^2)^g < 2^{4 g} p^{2 g}`. Also `p ≤ 2^L`, so
+`p^{2 g} ≤ 2^{2 g L}`. The hypothesis `16 g L ≤ p` and `L ≥ 1` force
+`g ≤ p/(16 L) ≤ p/16 < 2^L`. Hence
+
+```text
+g (9 p^2)^g exp(K p - p^2) < 2^{L + 4 g + 2 g L + 2 K p - p^2}.
+```
+
+Call this exponent `E_0`. For every integer `p ≥ 64`, `8 L ≤ p`. The base is
+`8 · 7 = 56 ≤ 64` at `p = 2^6`, and `8 ≤ 64`. If `8(m + 1) ≤ 2^m`, then
+`8(m + 2) ≤ 2^m + 8 ≤ 2^{m+1}`. On each dyadic interval the largest ratio of
+`L` to `p` is at the left endpoint, so `8 L ≤ p`. The gate gives
+`2 g L ≤ p/8` and `4 g ≤ p/4`. The linear factor obeys
+`(2 K + C) p ≤ p^2 / 2` exactly when `p ≥ 4 K + 2 C`, because
+`2(2 K + C) = 4 K + 2 C`. The four pieces sum to at most `p/2 + p^2/2`, and
+the slack against `p^2` is `p(p - 1)/2`. At `p = 2` this slack is 1, and it
+increases by `p` at the next integer. Thus `E_0 ≤ -C p - 1`.
+
+The telescoping identity multiplies by `p^4 / 9`. Since `9 > 8`,
+`1/9 < 1/8`, and `p^4 ≤ 2^{4 L}`, so
+
+```text
+p^4 / 9 < 2^{4 L - 3}.
+```
+
+The product is strictly less than `2^E` for
+
+```text
+E = E_0 + 4 L - 3 = 2 g L + 4 g + 5 L - 3 + 2 K p - p^2.
+```
+
+Clear the eighths of `E + C p`. The four pieces scale as
+`8 · 2 g L = 16 g L ≤ p`, `8 · 4 g = 2 · 16 g ≤ 2 p`,
+`8 · 5 L = 5 · 8 L ≤ 5 p`, and `8 (2 K + C) p ≤ 4 p^2` once
+`p ≥ 4 K + 2 C`, because `8(2 K + C) = 4(4 K + 2 C)`. The constant `-3`
+contributes `-24`. Their sum is at most
+
+```text
+-4(p^2 - 2 p + 6).
+```
+
+The coefficients of `p` are `1 + 2 + 5 = 8`, which cancels the `-8 p` inside
+four times the polynomial, and the `4 p^2` from the linear gate cancels four
+times `p^2`. At `p = 2` the polynomial equals 6, and the step to the next
+integer is `2 p - 1`. It is therefore at least 6, so eight times `E + C p`
+is at most `-24`. The exponent `E` is at most `-C p - 3`, and the monomial
+is strictly less than `2^{-C p}`.
+
+If `g log p = o(p)`, then `g log2 p ≤ p/32` for large `p`. For `p ≥ 3`,
+`L ≤ 2 log2 p`, so `p/(32 log2 p) ≤ p/(16 L)` and the gate holds eventually.
+Every fixed `K` and `C` then satisfy `p ≥ 4 K + 2 C` as well.
+
+At `g = p^2` the monomial equals `g (9 p^2)^g exp(-p^2) · p^4 / 9`. Here
+`(9 p^2)^{p^2} > 4^{p^2} > exp(p^2)` because `9 p^2 ≥ 36 > 4` and `e < 4`,
+while `p^4 / 9 > 1` because `p^4 ≥ 16 > 9`. The product is greater than 1,
+which is not below `2^{-C p}`.
+
+## Not covered
+
+- A proof that each section inverse is at most `9 p^2`, or that each section
+  error is less than `p^6 exp(-p^2)`. This comparison starts from both.
+- Replacing any inverse ceiling by the approximant norm
+  `9 p^2 + p^6 exp(-p^2)`.
+- Editing the #4100 notes. They still say `g p^{10 g} exp(-p^2)`.
+- Any new κ.
+
+## Reproduce
+
+```sh
+python3.12 -B scripts/research_package.py --package research/gaussian-tensor-nine-fold --check-only
+python3.12 -B scripts/research_package.py --package research/gaussian-tensor-nine-fold
+```
+
+Base `2a13eb1827784206202db90e5dc8327cf8a250db`, priority revision 7, selection
+refresh κ = `23/10000`. Upstream was fetched at 2026-10-22T01:52:41Z and was
+still that commit.
+
+Overlap snapshot: open PRs fetched 2026-10-22T01:53:32Z (349 records) and
+discussions fetched 2026-10-22T01:54:16Z (3373 records). A search for
+`p^4 / 9`, `4 L - 3` and `(9 p^2)^{g-1}` returned this draft and the #4495
+handoff, which leaves the telescoping factor open. A search miss is not a
+novelty certificate. #4495 is the predecessor monomial. HALO is the written
+error.
+
+## Open next questions
+
+1. **Does the approximant base `9 p^2 + p^6 exp(-p^2)` stay inside this
+   budget?** The first step is to show `p^6 exp(-p^2) < 1/2` for every
+   integer `p ≥ 64`, and then compare `9 p^2 + 1` with `16 p^2`.
+
+## Credit
+
+- The four-bit exponent `L + 4 g + 2 g L + 2 K p - p^2` is #4495's.
+- The section error `p^6 exp(-p^2)` is the within-cell bound of #4452.
+- The telescoping shape with coefficient 10 is #4485. This package is the
+  coefficient-9 monomial.
+- The written error `g p^{10 g} exp(-p^2)` is #4100's.
+
+Prepared by James Reed with substantial Cursor Grok 4.7 assistance. Apache-2.0.
diff --git a/research/gaussian-tensor-nine-fold/SOURCES.json b/research/gaussian-tensor-nine-fold/SOURCES.json
new file mode 100644
index 0000000000..b6dd82035c
--- /dev/null
+++ b/research/gaussian-tensor-nine-fold/SOURCES.json
@@ -0,0 +1,24 @@
+{
+  "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": "research/unconditional-batched-crt/HALO.md",
+      "usage": "input",
+      "git_blob": "5f601b3c8ac368aa79aa1007effe5933a360237b",
+      "sha256": "a2adcf18614983e9255def6d3f5e59be0018a392e418d65e94323722838289cc"
+    }
+  ]
+}
diff --git a/research/gaussian-tensor-nine-fold/TASK.json b/research/gaussian-tensor-nine-fold/TASK.json
new file mode 100644
index 0000000000..6b96051610
--- /dev/null
+++ b/research/gaussian-tensor-nine-fold/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": "Decide whether the #4495 gate absorbs g (9 p^2)^{g-1} p^6 exp(K p - p^2) after the extra factor p^4 / 9 is placed in the exponent as 4 L - 3.",
+  "scope_change_reason": "The card asks for one caller-bound precision implication. This package only folds that monomial into the four-bit gate. It does not prove a 9 p^2 operator bound and does not claim a new kappa.",
+  "bottleneck_link": "The selected frontier is unchanged. This is the telescoping factor left open by the coefficient-9 absorption.",
+  "budget_minutes": 60,
+  "stop_rule": "Stop once the telescoping factor is compared with the gate. Do not absorb the approximant base, do not prove the ideal gaps, 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-tensor-nine-fold",
+  "author": "James Reed",
+  "ai_assistance": "Substantial help from Cursor Grok 4.7 on the folded exponent and the package text.",
+  "open_questions": [
+    {
+      "question": "Does the approximant base 9 p^2 + p^6 exp(-p^2) stay inside this telescoping budget?",
+      "why_it_matters": "The g-1 inverse ceilings may be approximants rather than exact inverses, and the written section error is p^6 exp(-p^2).",
+      "first_step": "Show p^6 exp(-p^2) < 1/2 for every integer p >= 64, then compare 9 p^2 + 1 with 16 p^2.",
+      "blocked_by": "The section ceiling 9 p^2 and the section error p^6 exp(-p^2) remain hypotheses until the ideal gaps are proved."
+    }
+  ]
+}
diff --git a/research/gaussian-tensor-nine-fold/VERIFY.json b/research/gaussian-tensor-nine-fold/VERIFY.json
new file mode 100644
index 0000000000..f939cb74c0
--- /dev/null
+++ b/research/gaussian-tensor-nine-fold/VERIFY.json
@@ -0,0 +1,21 @@
+{
+  "schema_version": 1,
+  "status": "ready",
+  "python": "3.12",
+  "requirements": [],
+  "inputs": [
+    "certificates/selected-result.json",
+    "research/unconditional-batched-crt/HALO.md"
+  ],
+  "commands": [
+    {
+      "argv": [
+        "{python}",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 60,
+      "checks": "Under p >= max(64, 4K+2C) and 16 g L <= p, the factor p^4 / 9 contributes 4 L - 3, and the folded exponent 2 g L + 4 g + 5 L - 3 + 2 K p - p^2 is at most -C p - 3, so g (9 p^2)^{g-1} p^6 exp(K p - p^2) < 2^{-C p}."
+    }
+  ]
+}
diff --git a/research/gaussian-tensor-nine-fold/verify.py b/research/gaussian-tensor-nine-fold/verify.py
new file mode 100644
index 0000000000..e2784f9e6d
--- /dev/null
+++ b/research/gaussian-tensor-nine-fold/verify.py
@@ -0,0 +1,121 @@
+#!/usr/bin/env python3
+"""The telescoping factor with coefficient 9 is absorbed by the same gate.
+
+Every comparison is an integer identity. The section ceiling and the section
+error are hypotheses.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+PACKAGE = ROOT / "research" / "gaussian-tensor-nine-fold"
+
+
+def digest(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+
+def ceil_log2(value: int) -> int:
+    level = 0
+    power = 1
+    while power < value:
+        power *= 2
+        level += 1
+    return level
+
+
+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"]
+    halo = (ROOT / "research/unconditional-batched-crt/HALO.md").read_text(encoding="utf-8")
+    selected = json.loads(
+        (ROOT / "certificates/selected-result.json").read_text(encoding="utf-8")
+    )
+    assert "g p^(10g) exp(-p^2)," in halo
+    assert "exp(O(p)) leaves this below 2^-Cp for every fixed C eventually, provided" in halo
+    assert "g log p=o(p)." in halo
+    assert selected["kappa"] == "23/10000"
+
+
+def series_bounds() -> None:
+    # e > 1 + 1 + 1/2 = 5/2 > 2, and e < 3 < 4.
+    assert 5 > 4
+    assert 3 < 4
+    assert 2 >= 2
+    assert 6 >= 4
+    assert 24 >= 8
+    assert 3 >= 2
+    # Four bits clear the base 9. The denominator 9 is larger than 8 = 2^3.
+    assert 9 < 16
+    assert 9 > 8
+    assert 2**4 == 16
+    assert 2**3 == 8
+    assert 4 * 1 - 4 == 0
+
+
+def log_induction() -> None:
+    # For m >= 6, 8(m+1) <= 2^m, so 8 ceil(log2 p) <= p for every integer p >= 64.
+    assert 8 * 7 <= 64
+    assert 8 <= 64
+    assert 2**6 + 8 <= 2**7
+    assert ceil_log2(2) == 1
+    assert ceil_log2(64) == 6
+    assert ceil_log2(65) == 7
+    assert ceil_log2(128) == 7
+    assert 8 * ceil_log2(128) <= 128
+    assert (2**7) ** 4 == 2 ** (4 * 7)
+
+
+def budget() -> None:
+    # Eight times the four-bit pieces recovers a half, and p(p-1)/2 is at least 1.
+    assert 1 + 2 + 1 == 4
+    assert 4 - 2 == 2
+    assert (3**2 - 3) - (2**2 - 2) == 2 * 2
+    assert 2 * (2 * 3 + 5) == 4 * 3 + 2 * 5
+    # Eight times the folded pieces: 2 g L, 4 g, 5 L, and the linear term.
+    assert 8 * 2 == 16
+    assert 8 * 4 == 2 * 16
+    assert 8 * 5 == 5 * 8
+    assert 1 + 2 + 5 == 8
+    assert 4 * (4 * 3 + 2 * 5) == 8 * (2 * 3 + 5)
+    # The constant -3 contributes -24, matching 4 times the polynomial constant 6.
+    prime = 7
+    budget_value = prime + 2 * prime + 5 * prime + 4 * prime * prime - 24 - 8 * prime * prime
+    assert budget_value == -4 * (prime * prime - 2 * prime + 6)
+    assert 8 * 3 == 24
+    assert 4 * 6 == 24
+    assert 2**2 - 2 * 2 + 6 == 6
+    assert (3**2 - 2 * 3 + 6) - (2**2 - 2 * 2 + 6) == 2 * 2 - 1
+    # Witness: p=128, L=7, g=1. The folded exponent is the four-bit exponent plus 4 L - 3.
+    width = 128
+    level = ceil_log2(width)
+    groups = 1
+    assert 16 * groups * level <= width
+    four = level + 4 * groups + 2 * groups * level - width * width
+    folded = four + 4 * level - 3
+    assert four <= -1
+    assert folded <= -3
+    assert folded == 2 * groups * level + 4 * groups + 5 * level - 3 - width * width
+    # g = p^2 leaves the telescoping error above 1, since 9 p^2 > 4 and p^4 > 9.
+    assert 9 * 4 > 4
+    assert 9 * 3**2 - 9 * 2**2 == 9 * (2 * 2 + 1)
+    assert 2**4 > 9
+    assert 3**4 > 2**4
+
+
+def main() -> None:
+    pins_and_phrases()
+    series_bounds()
+    log_induction()
+    budget()
+    print("PASS_GAUSSIAN_TENSOR_NINE_FOLD")
+
+
+if __name__ == "__main__":
+    main()