diff --git a/.github/workflows/third-order-coefficient.yml b/.github/workflows/third-order-coefficient.yml
new file mode 100644
index 000000000..4ff262b43
--- /dev/null
+++ b/.github/workflows/third-order-coefficient.yml
@@ -0,0 +1,109 @@
+name: Third-order coefficient controls
+
+'on':
+  pull_request:
+    paths:
+      - 'frontiers/third_order_coefficient_20261001/**'
+      - '.github/workflows/third-order-coefficient.yml'
+      # merged sources cited in SOURCES.json (cited_only, v1.4.1): a change to any of them re-runs the identity check
+      - 'frontiers/three_fronts_20260924/LIFETIME_REMAINDER.md'
+      - 'reviews/side24_v1_coefficient_claude_20260929/RESULTS.json'
+      - 'coefficients/side24_v1/ENCLOSURE.json'
+      - 'frontiers/cusp_second_order_20261001/PROOF.md'
+      - 'frontiers/remainder_vanishing_20260930/PROOF.md'
+      - 'frontiers/candidate_third_order_20261001/PROOF.md'
+      - 'frontiers/elder_third_order_20261001/PROOF.md'
+      - 'frontiers/third_order_rate_20261001/PROOF.md'
+      - 'frontiers/c2_exact_20261001/NOTE.md'
+      - 'frontiers/c2_finite_jet_transfer_20261001/PROOF.md'
+      - 'frontiers/cusp_coefficient_certified_20261001/NOTE.md'
+      - 'frontiers/far_elder_rate_20260930/PROOF.md'
+      - 'frontiers/elder_cusp_parity_20261002/PROOF.md'
+      - 'frontiers/d1_third_order_law_20261001/PROOF.md'
+      - 'frontiers/candidate_parity_rate_20261001/PROOF.md'
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  exact-controls:
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    steps:
+      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262
+        with:
+          persist-credentials: false
+      - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065
+        with:
+          python-version: '3.11.16'
+      - name: Verify sources, replay both modes, reject mutants
+        env:
+          PYTHONDONTWRITEBYTECODE: '1'
+          GH_TOKEN: ${{ github.token }}
+          GH_REPOSITORY: ${{ github.repository }}
+        run: |
+          set -euo pipefail
+          python -B -S - <<'PY'
+          import base64, hashlib, json, os, pathlib, subprocess, sys, urllib.parse, urllib.request
+          root = pathlib.Path('frontiers/third_order_coefficient_20261001').resolve()
+          manifest = json.loads((root / 'SOURCES.json').read_text())
+          present = sorted(p.name for p in root.iterdir())
+          expected_names = sorted([e['path'] for e in manifest['files']] + ['SOURCES.json'])
+          if present != expected_names:
+              raise ValueError('packet tree differs from manifest: ' + repr(present))
+          for entry in manifest['files']:
+              path = root / entry['path']
+              if path.is_symlink():
+                  raise ValueError('symlink: ' + entry['path'])
+              data = path.read_bytes()
+              if len(data) != entry['bytes'] or hashlib.sha256(data).hexdigest() != entry['sha256']:
+                  raise ValueError('packet file identity mismatch: ' + entry['path'])
+          for entry in manifest['consumed'] + manifest['cited_only']:
+              data = pathlib.Path(entry['path']).read_bytes()
+              framed = b'blob ' + str(len(data)).encode() + b'\0' + data
+              if len(data) != entry['bytes'] or hashlib.sha256(data).hexdigest() != entry['sha256'] or hashlib.sha1(framed).hexdigest() != entry['git_blob']:
+                  raise ValueError('merged source drifted: ' + entry['path'])
+          if manifest.get('consumed_unmerged'):
+              raise ValueError('this packet declares no unmerged dependency')
+          # cited unmerged sources (comparison only) are bound to their recorded commit, path and blob through the
+          # repository API (v1.2, Codex P2 on v1.1): the recorded head must resolve, the recorded path in that head's tree
+          # must be a file with the recorded blob id and size, and the blob's bytes must have the recorded sha256
+          api = 'https://api.github.com/repos/' + os.environ['GH_REPOSITORY']
+          def get_json(url):
+              req = urllib.request.Request(url, headers={'Authorization': 'Bearer ' + os.environ['GH_TOKEN'],
+                                                         'Accept': 'application/vnd.github+json'})
+              with urllib.request.urlopen(req, timeout=60) as resp:
+                  return json.load(resp)
+          for entry in manifest.get('cited_unmerged', []):
+              commit = get_json(api + '/commits/' + entry['head'])
+              if commit.get('sha') != entry['head']:
+                  raise ValueError('recorded head does not resolve: ' + entry['head'])
+              node = get_json(api + '/contents/' + urllib.parse.quote(entry['path']) + '?ref=' + entry['head'])
+              if (node.get('type') != 'file' or node.get('path') != entry['path'] or node.get('sha') != entry['git_blob']
+                      or node.get('size') != entry['bytes']):
+                  raise ValueError('recorded head/path does not map to the recorded blob: ' + entry['path'])
+              blob = get_json(api + '/git/blobs/' + entry['git_blob'])
+              if blob.get('encoding') != 'base64':
+                  raise ValueError('unexpected blob encoding for ' + entry['path'])
+              data = base64.b64decode(blob['content'])
+              framed = b'blob ' + str(len(data)).encode() + b'\0' + data
+              if len(data) != entry['bytes'] or hashlib.sha256(data).hexdigest() != entry['sha256'] or hashlib.sha1(framed).hexdigest() != entry['git_blob']:
+                  raise ValueError('cited unmerged source differs from its pinned blob: ' + entry['path'])
+              print(json.dumps({'cited_unmerged_bound': entry['path'], 'git_blob': entry['git_blob'], 'head': entry['head']}))
+          script = str(root / 'c2_check.py')
+          expected = (root / 'RESULTS.json').read_bytes()
+          for flags in (['-B', '-S'], ['-B', '-O', '-S']):
+              out = subprocess.run([sys.executable, *flags, script], check=True, capture_output=True, timeout=900).stdout
+              if out != expected:
+                  raise RuntimeError('output differs from RESULTS.json under ' + ' '.join(flags))
+              for m in manifest['mutants']:
+                  rc = subprocess.run([sys.executable, *flags, script, '--mutant', m], capture_output=True, timeout=900).returncode
+                  if rc != 1:
+                      raise RuntimeError('mutant ' + m + ' not rejected')
+              rc = subprocess.run([sys.executable, *flags, script, '--mutant', 'M9'], capture_output=True, timeout=900).returncode
+              if rc != 2:
+                  raise RuntimeError('unknown mutant label not rejected with exit 2')
+          print(json.dumps({'scientific_effect': 'NONE', 'mathematical_acceptance': False}))
+          PY
+          git diff --exit-code
diff --git a/frontiers/third_order_coefficient_20261001/NOTE.md b/frontiers/third_order_coefficient_20261001/NOTE.md
new file mode 100644
index 000000000..fa4489340
--- /dev/null
+++ b/frontiers/third_order_coefficient_20261001/NOTE.md
@@ -0,0 +1,649 @@
+# The third-order coefficient of the short-lifetime law: the fold-scale finite part, `d = 1, 2, 3`
+
+Object: CL-THIRD-ORDER-COEFF-20261001-v1.4.1.
+Author: Anthropic Claude (claude.ai session `session_01NMeKEismAyeqgdB4sy2NJU`), 1 October 2026 (v1.3: 2 October; v1.4
+and v1.4.1: 4 October 2026).
+**v1.4.1 (answers the two readbacks of v1.4; no number changes).** C129 (OpenAI/Codex, review 5404127976,
+AMEND_SCOPED) and Grok Bot agent 1's confirming readback (5976332101, AMEND, scoped) found no blocker. They found no
+error in the coefficients or the checker.
+- *C129-A1.* In §2.2, the transverse covariance `2/0/1` is the contact limit. At finite `r` it is `2 + σ_r²`, `σ_r²`
+  and `1`, with `σ_r² = Var(f(0) | U_r) = r⁸/6144 + O(r¹⁰)`. No number changes.
+- *C129-A2 (= N6-1).* The dependency sentence separates numerical inputs (none consumed) from the analytic
+  identifications: #214 Lemma 1.3, #218 (F.2), and #218 Lemma O with #220 Lemma O′.
+- *C129-R1.* The window intervals are labelled as nominal binomial counting intervals. Their coverage under
+  within-field dependence is not assessed.
+- *C129-N1 and N6-2.* `1.9%` becomes `1.8%` (355/19215). §7 and the README say "the `d = 1` comparison with #214".
+- *Merged since v1.4.* #214 (as `e4ca2b3`) and #237 (as `cb73b11`), with the pinned blobs unchanged. Both are now bound
+  from the tree, and the text calls them merged author-side proof candidates.
+
+**v1.4 (answers the four nonauthor reviews at `7e97018`; no coefficient or Monte Carlo ratio changes).** The reviews are
+Grok Bot agent 1 on Slices A and C and the status text (5401553740; signature corrected in 5974176267), xAI/Grok on
+Slice D (5401550768), and xAI/Grok agent 3 on Slice B (5401560065, 5401592048). No finding is a blocker.
+- S1 and S2 are P1. The others are P2 items, two issues "to fix or answer" (D-1, D-2), minor issues and optional
+  amendments.
+- All are applied except U-1 (the Monte Carlo cannot be replayed from the repository), which is acknowledged.
+- `SOURCES.json` (`nonauthor_reviews`) records each disposition.
+
+The changes, by group:
+- *Status wording (S1–S5).* The discharge and "certified" wording of v1.3 is replaced by each packet's own status.
+  - #218, #220, #229, #232 and #187 are author-side proof candidates. #223 and #219 certify enclosures of explicit
+    expressions; #223's is the Gaussian-kernel surrogate, with no torus transfer.
+  - The candidate law ((T.1) of #218, (T⁺.1) of #229) is not (0.2). The adjacent-pair density is formal.
+  - `d = 1` rests on #214, which was open at v1.4 (merged since; v1.4.1). #187 is now bound.
+- *Checker (C1, C2).* T1, T3 and T4 compare every computed `c₂` with #223's closed forms; the observed errors are at most
+  `2.6·10⁻⁹`. The mutants now fail on computed checks only. §0 and §2.4 quote the errors, not the spreads.
+- *Monte Carlo (D-1 to D-6, C3).*
+  - The `ℓ^{1/2}` reading of the residual is withdrawn: other powers fit comparably (#240 §7 item 4; #237 Remark 4).
+  - The adjacent-pair comparisons are labelled formal.
+  - The `d = 3` saddle reference is corrected to `436.25`, and error bars are added.
+  - The weak power of the completeness checks for close pairs is stated, and the window rows give their counts.
+  - The cancellation fraction is stated per `ℓ`, and §4 explains its last-digit rounding.
+- *§§0–2 (A1–A3, XA-216-B-01 to B-06).*
+  - (0.1) and the interface cancellation are cited to #218 (F.2) and Lemma O and to #220 Lemma O′.
+  - §2.2 states its domain, its proof (#218 Lemma F), its non-uniformity in small `k` and its kernel scope.
+  - §2.1 states the truncation error per dimension. §2.3 states the coordinate map to #214 and what it consumes.
+
+**v1.3 (status update; no number changes).** The packets cited as unmerged in v1.2 had landed. §0 "Status since v1.2"
+records what they supply; v1.4 rewords it (S1–S3). xAI's P2 and P3 on v1.2 (5378684363) were answered.
+- P2: §4 separates the coefficients from the three-term truncation, whose error at a given `ℓ` is not quantified.
+- P3: this note consumes nothing, so it imposes no landing order.
+- Labels: #214's theorem is Theorem 1D, with displays (1D.1)–(1D.2); the label note is 5942064561. #214 is rebound to
+  v1.3 (`54666d2`), whose `B₂` is unchanged.
+
+**v1.2 (after the Codex review of v1.1, head `605af74`, and one author-side correction).**
+- *Requirements for a proof (author-side correction).* v1.1 said that a rate `O(r)` in #207's CU.4 would suffice for a
+  proof in `d ≥ 2`. That understated it. §0 "What is not claimed" now lists three requirements:
+  - a rate in CU.4;
+  - a quantitative fold-scale expansion;
+  - for the elder density, a bound `o(ℓ^{1/3})` at intermediate separations. On file, #198's Lemma B gives only
+    `O(ℓ^{1/3}ρ^{−1})` there.
+
+  The candidate density needs only the first two, and Math- #218 (Theorem T) now proves its expansion with this `c₂`,
+  at candidate status.
+- *Digits.* T4 now runs at a refined grid and compares it with the former production grid and with the second `r`-set.
+  v1.1's coarse comparison grid used 32 nodes in `b`, which under-resolves the height integral and moved `c₂` by
+  `4.5·10⁻⁸`. The converged value is unchanged. All stated digits are stable to `≤ 7·10⁻¹⁰` (§2.4). (v1.4, C2: these
+  are spreads, not errors.)
+- *Sources.* The workflow binds each cited unmerged source to its recorded commit and path, not only to its blob id.
+- *Monte Carlo.* §3 gives the final counts and a direct test of the elder window.
+
+The coefficients are unchanged.
+
+**v1.1 (after the Codex review of v1 on Math- #216, head `205550f`).**
+- *Replay.* The replay is now interpreter-independent: every float sum uses `math.fsum`, and the `r`-fit uses `r/max r`.
+  The output is byte-identical on CPython 3.10–3.14.
+- *Precision.* `c₂` is quoted to 8 significant digits. Summation order moves the 10th digit.
+- *Workflow.* The workflow verifies the cited unmerged sources by blob id.
+- *Provenance.* The owner's post-stop instructions are recorded exactly (`SOURCES.json`, `delivered_under`).
+The coefficients are unchanged.
+
+Disposition: FORMAL COEFFICIENT WITH NUMERICAL EVIDENCE. In `d = 1` the law is Theorem 1D of Math- #214, a merged
+author-side proof candidate. In `d ≥ 2` the expansion (0.2) is not proved here. For the elder density, the merged
+author-side proof candidates #220 and #229 prove it with remainder `O(ℓ^{3/7})`, using the merged #187 for the far
+part. For the candidate density, #218 ((T.1)) and #229 ((T⁺.1)) prove the analogous candidate law, which has `B_{d,L}` and `I^{cand}`
+(§0, "Status since v1.2"). Nonauthor review required. Scientific effect: NONE — no register, graph, STATUS,
+PROOF_INDEX, prize or Boolean change. Same GitHub account as every lane; zero organizational independence.
+**Dependencies (v1.4.1, C129-A2).** No numerical input is consumed: the checker implements the merged kernel of [R]
+(`frontiers/three_fronts_20260924/LIFETIME_REMAINDER.md`, blob `247b3ecf`) directly. The analytic identifications
+use, at their own status:
+- #214 Lemma 1.3 (the `d = 1` fold identification, §2.3);
+- #218 Lemma F, (F.2) ((0.1));
+- #218 Lemma O with #220 Lemma O′ (the interface cancellation, §1).
+
+All three are merged author-side proof candidates. The following are cited for comparison:
+- Math- #214 (`d = 1`, Theorem 1D; merged as `e4ca2b3`);
+- Math- #207 (Theorem CU: `c₁` and the cusp loss; merged);
+- Math- #191 (the even contact expansion; merged);
+- the merged values of `c_{2,∞}` and `c_{3,∞}`;
+- since v1.3, the merged #218 (Theorem T), #220 (Theorem E3), #229 (Theorems T⁺ and E3⁺), #223 (`c₂` in closed form),
+  #232 (`c₂` on the torus) and #219 (`c₁` certified);
+- since v1.4, the merged #187 (Theorem F, the far part of #220 and #229) and #240 (§7 item 4), and #237 (Remark 4;
+  merged as `cb73b11`).
+
+## 0. Statement
+
+**Setting.** We use the notation of [R] §§2–4 and #207 §0:
+- the [P] field on `X = R^d/(LZ^d)`, with pins `M = −ru/2` and `S = ru/2`;
+- the symmetric pin vector `U_r`, with target `v_r = (b − kr³/2, −kr², 0, 12k, 0, …, 0)`;
+- its density `π_r`;
+- the two-point kernel
+
+      A_r(b, k, u) = 12 π_r(v_r) E[ |det H_M| |det H_S| 1{typed} | U_r = v_r ] / r²,
+
+  so that the near part of the elder lifetime density is `∫dσ(u)∫db∫dr r^{−2}A_r^{eld}(b, ℓ/r³, u)` (#207 (0.1)).
+
+In `d ≥ 2`, at fixed `(b, k, u)` with `k > 0`, `A_r = A₀ + r²A₂ + O(r³(1 + k^{−1}))` (#218 Lemma F, (F.1)); `d = 1`
+rests on #214 (merged; an author-side proof candidate; §2.2–§2.3). There is no `r¹` term (#191's even contact
+expansion; #218 (2.2); checker T5). Here `A₀ = 12π₀(v₀)·36k²E[Δ²1{A<0} | v₀]` is the contact kernel, and
+
+    A₂(b, 0, u) = −12 π₀(u; v₀(b, 0)) E₀[ Y² 1{A < 0} | b ]                                              (0.1)
+
+is the small-`s` limit of #207's cusp loss `loss(s) → Y²` (`s → 0`), with `Y = (f₄/12)Δ − γᵀadj(A)γ/4`. (0.1) is not
+part of a definition.
+- In `d ≥ 2` it is #218 Lemma F, (F.2) (merged; candidate status), which also gives `A₂(b, ·, u) ∈ C¹[0, ∞)`. #218 does
+  not cover `d = 1`.
+- This packet checks it numerically in `d = 2` only (T6). In `d = 1` a development check, not replayed, agrees to
+  `2·10⁻¹²`. There is no `d = 3` check.
+
+Define
+
+    c₂ := (1/3) ∫_{S^{d−1}} ∫_R ∫_0^∞ [A₂(b, k, u) − A₂(b, 0, u)] k^{−4/3} dk db dσ(u),
+
+the Hadamard finite part of `(1/3)∫A₂k^{−4/3}dk`. The integral converges: `A₂(b, k) − A₂(b, 0) = O(k)` as `k → 0`.
+
+**Claim (formal in `d ≥ 2`).**
+
+    ν_eld(ℓ) = c ℓ^{−1/3} + c₁ ℓ^{1/4} + c₂ ℓ^{1/3} + O(ℓ^{1/2})        (ℓ ↓ 0),                         (0.2)
+
+with `c₁` the coefficient of #207 (CU.2). The same `c₂` appears in the near candidate density, with `c₁` replaced by
+`I^{cand} = (3^{1/4}/2)c₁` (#207 (CU′.1)). The candidate law ((T.1) of #218, (T⁺.1) of #229) also has the constant
+`B_{d,L}`. Formally, the density of adjacent (max, saddle) pairs has the same three coefficients and no `B_{d,L}`.
+Nothing on file proves that expansion (#218 Remark 3; #220 and #229 list it as not claimed). The reason for the common
+`c₂` is that it is a fold-scale quantity: the elder rule enters only through the cusp window.
+
+**What is established here.**
+1. **`d = 1`.** The formula gives #214's `2B₂` (§2.3).
+   - The cusp component is an algebraic identity for every covariance satisfying #214's (H).
+   - The fold component is an identification not derived here: it consumes #214's Lemma 1.3.
+   - The total is checked numerically to `10⁻⁹` for two kernels (checkers T1, T2). For the Gaussian kernel the merged
+     #223 gives `c₂ = 2B₂` as an identity of exact numbers.
+
+   In `d = 1`, (0.2) is #214's Theorem 1D. #214 is a merged author-side proof candidate, so the `d = 1` law holds at
+   that status.
+2. **Values for the Gaussian kernel `e^{−|z|²/2}`** (the SIDE24 covariance up to factors `1 + O(e^{−L²/8})`):
+
+   | `d` | `c` (recomputed; equals the merged value) | `c₂` | `c₂/c` | `c₁/c` (#207, #214) |
+   |---|---|---|---|---|
+   | 1 | `0.110110378959` (`C₀`) | `0.23004458` (`= 2B₂`) | `2.089218` | `−2.0671` |
+   | 2 | `0.073406919306` (`c_{2,∞}`) | `0.22152441` | `3.017759` | `−3.6699` |
+   | 3 | `0.041775931841` (`c_{3,∞}`) | `0.16123405` | `3.859496` | `−5.0711` |
+
+   Merged #223 gives these `c₂` in closed form, with certified enclosures: for example,
+   `c₂ = (13/18)·12^{1/6}Γ(5/6)/π^{3/2}` in `d = 2` and `(5/48)(33 − 7√6)·12^{1/6}Γ(5/6)/π^{5/2}` in `d = 3`. Every
+   digit in the table is a correct rounding: of #223's closed forms for `c`, `c₂` and `c₂/c`, and of #219's enclosures
+   for `c₁/c` (in `d = 1`, of #219's `c₁` over #223's `c`).
+   - *Accuracy (v1.4, C2).* Changing the `r`-set, refining the grids, or replacing exactly rounded summation by plain
+     left-to-right summation moves `c₂` by at most `7·10⁻¹⁰` (§2.4). These variations share the bias of the `r`-fit, so
+     their spreads do not bound the error. v1.2 and v1.3 inferred the digits from the spreads, which was not justified.
+   - Against #223's closed forms (checkers T1, T3, T4) the observed errors are:
+     - `5.7·10⁻¹⁰` in `d = 1`;
+     - `1.9·10⁻⁹` and `2.6·10⁻⁹` in `d = 2` (the two `r`-sets);
+     - `1.0–1.4·10⁻⁹` in `d = 3` (three runs).
+   - The exact values lie at least `4.1·10⁻⁹` from a rounding boundary of the printed digits. The floating values alone
+     would not have settled the eighth digit in `d = 2`.
+
+3. **Full-field Monte Carlo in `d = 2` and `d = 3` (§3; exploration, outside the repository).** The *parameter-free*
+   three-term law (0.2) matches the actual elder-rule persistence of the periodized Gaussian field on `[10⁻⁴, 10⁻²]`,
+   at about the 1% level. Both the leading term alone and the two-term law `cℓ^{−1/3} + c₁ℓ^{1/4}` are rejected. On
+   `[10⁻⁴, 3·10⁻²]` the data exceed (0.2); the form of the excess is open (§3).
+
+**Consequence for SIDE24 (`d = 3`).** The relative correction is
+`ν/(cℓ^{−1/3}) − 1 = −5.071ℓ^{7/12} + 3.859ℓ^{2/3} + …`. The `ℓ^{1/3}` term cancels the fraction `0.761ℓ^{1/12}` of the
+`ℓ^{1/4}` term:
+
+| `ℓ` | `10⁻⁵` | `10⁻⁴` | `10⁻³` | `10⁻²` |
+|---|---|---|---|---|
+| fraction cancelled | 29% | 35% | 43% | 52% |
+
+So the fraction is 40–50% only for `ℓ ∈ [4.4·10⁻⁴, 6.5·10⁻³]`. The combined correction is `1%` at `ℓ ≈ 4.6·10⁻⁵` and
+`10%` at `ℓ ≈ 3.6·10⁻³`. For the `ℓ^{1/4}` term alone (#207 §8, V3 edit E15) the corresponding values are `2.3·10⁻⁵`
+and `1.2·10⁻³`. §4 gives the table and the status of these numbers.
+
+**Status since v1.2 (v1.3; reworded in v1.4, S1–S3).** All the packets below are merged. #218, #220, #229, #232 and
+#187 are author-side proof candidates; #223 and #219 certify enclosures of explicit expressions. Each item holds at its
+packet's stated conditional scope.
+- **Candidate density.** #218 (Theorem T) proves the candidate law: (0.2) with the constant `B_{d,L}` added and `c₁`
+  replaced by `I^{cand}`, with this `c₂` and remainder `O(ℓ^{4/11})`. #229 (Theorem T⁺, (T⁺.1)) improves the remainder
+  to `O(ℓ^{3/7})`.
+- **Elder density.** #220 (Theorem E3) supplies the three requirements below:
+  1. the elder cusp rate, through its Lemmas Q and CE;
+  2. the fold expansion, through #218 Lemma F;
+  3. the intermediate separations, `O(ℓ^{2/5})`, through its Lemmas H and S′.
+
+  With #187's Theorem F for the far part, #220 proves (0.2) with remainder `O(ℓ^{4/11})` (E3.3). #229 (Theorem E3⁺,
+  (E3⁺.1)) improves the remainder to `O(ℓ^{3/7})`. Without #187, #220 gives (E3.0)–(E3.2) only.
+- **What remains formal here.**
+  - The remainder `O(ℓ^{1/2})` of (0.2) in `d ≥ 2`. #229 Remark 1 explains why its method stops at `3/7`.
+  - The adjacent-pair density. No packet proves its expansion (#218 Remark 3; #220 and #229 list it as not claimed).
+  - Any reading of the Monte Carlo residual of §3 as a term of order `ℓ^{1/2}` (v1.4, D-1).
+- **The coefficients.**
+  - **`c₂`** is certified for the Gaussian kernel by #223: closed forms with certified enclosures of the fixed-cone
+    surrogate expression of §2.2.
+    - Its identification with the typed kernel's `A₂` rests on #218 Lemma F, which #223 consumes.
+    - #223 makes no torus transfer. The transfer to the periodized covariance for every `L ≥ 24`, with error `< 10⁻⁶⁰`,
+      is the author-side candidate #232.
+  - **`c₁`** is certified by #219, with `c₁/c_{3,24} ∈ [−5.07106215, −5.07106213]`.
+
+**What is not claimed.** (Items 1–3 below are v1.2's record of what a proof needed. The merged candidates above now
+supply them.)
+- No proof of (0.2) for the elder density in `d ≥ 2` *here*. A proof needs three ingredients. For the candidate density
+  the first two are supplied, at candidate status, by **Math- #218** (Theorem T; see below).
+  1. **A rate in CU.4.** #207's kernel limit CU.4 must hold with a rate:
+     `|r^{−2}(A_r − A₀)(b, κr, u) − (𝒜 − 𝒜^{con})(b, κ, u)| ≤ C r^θ (1 + κ)^N (1 + |b|)^N e^{−cb²}`.
+     - In #218's ledger, `θ > max(2/5, (N + 1)/4)` suffices. `θ > 1/3` alone does not suffice there; this corrects an
+       earlier draft of this item, found by #218's referee.
+     - #218's Lemma C proves `θ = 1`, `N = 2` for the *candidate* kernel.
+     - For the elder kernel this needs a quantitative form of Proposition CU.3. The decision's height margin is
+       `κ·min(1, 12||φ| − 1/3|)`: linear in the distance from the window's edge.
+  2. **A quantitative fold-scale expansion.** `A_r = A₀ + r²A₂ + O(r³(1 + k^{−1}))`, uniformly down to `k ≈ r^{1−}`.
+     The `r³/k` term is the boundary layer of the typed region near `det A = 0`. #218's Lemma F proves it, together with
+     the identification `A₂(b, 0, u) = −12π₀E₀[Y²1{A<0} | b]` of (0.1).
+  3. **For the elder density only: the intermediate separations.** The contribution of `Sℓ^{1/4} ≤ r ≤ r₁`, for one
+     fixed `r₁ > 0`, must be `o(ℓ^{1/3})`.
+     - At v1.2 the tools on file did not give this. #198's Lemma B bounds this range by `O(ℓ^{1/3}ρ^{−1})`, which is
+       never `o(ℓ^{1/3})`, and #207's Lemma CU.5 route gives only `o(ℓ^{1/4})`. Since v1.3, #220's Lemmas H and S′
+       give `O(ℓ^{2/5})`, and #229 gives `O(ℓ^{4/9}log(1/ℓ))`.
+     - Formally the range is `O(ℓ^{1/2})`. The cusp-scale elder weight is `O(κ³)`, with relative corrections
+       `O(r/κ)`.
+     - Beyond `r₁`, the far bounds `O(ℓ^{2/3})` of #187 (merged) and `O(ℓ^N)` of #188 (open) suffice. #198's Lemma F′
+       (`O(ℓ^{1/3})`) does not.
+
+  The **candidate** density needs only 1 and 2. Its intermediate separations are bounded by
+  `O(ℓ^{1/4}S^{−7} + ℓ^{1/2}S^{−2})` (#207 Lemma L), which is `o(ℓ^{1/3})` for `S = ℓ^{−a}`, `a > 1/84`. Its far part
+  is `O(ℓ)` (#207 (7.2)). **Math- #218 (Theorem T)** proves, at candidate status,
+  `ν_cand = cℓ^{−1/3} + B_{d,L} + I^{cand}ℓ^{1/4} + c₂ℓ^{1/3} + O(ℓ^{4/11})` with this `c₂`.
+
+  v1.1 said only that "a rate `O(r)` in CU.4" was needed. That understated 2 and missed 3.
+- No certified enclosure of `c₂` here. The values are floating point. Checkers T1, T3 and T4 compare them with #223's
+  closed forms (v1.4), and #223 encloses those with certified intervals.
+- No statement about the terms after `c₂`.
+- Nothing about `L ≠ ∞`, beyond the `O(e^{−L²/8})` periodization factors. #232 (an author-side candidate) transfers
+  `c₂` to the torus for `L ≥ 24`.
+
+## 1. Why the finite part (formal derivation)
+
+Put `s := rℓ^{−1/4}`, so that `κ = ℓ/r⁴ = s^{−4}` and `k = ℓ/r³ = ℓ^{1/4}s^{−3}`. The near integrand `r^{−2}A_r^{eld}(b, ℓ/r³, u)`
+has two regimes.
+
+- **Fold regime (`s ≪ 1`, `κ ≫ 1`).** Every typed pair is an elder pair: the non-elder part is `O(r³/k)`, [C7-K] (K2).
+  At fixed `k`,
+
+      r^{−2}A_r = r^{−2}A₀(b, k) + A₂(b, k) + O(r).
+
+- **Cusp regime (`s ≍ 1`).** By #207 CU.4,
+
+      r^{−2}A_r^{eld} = r^{−2}A₀ + (𝒜^{eld} − 𝒜^{con})(b, κ) + o(1),
+
+  and `(𝒜^{eld} − 𝒜^{con})(b, κ) = −12π₀E₀[loss(s) | b] → A₂(b, 0)` as `κ → ∞`, by (0.1).
+
+The composite approximation
+
+    r^{−2}A₀(b, k) + A₂(b, k) + [(𝒜^{eld} − 𝒜^{con})(b, κ) − A₂(b, 0)]
+
+reproduces both regimes:
+- for `s ≪ 1` the bracket vanishes;
+- for `s ≍ 1` we have `k → 0` and `A₂(b, k) → A₂(b, 0)`.
+
+Integrating over `r` gives three pieces, each converging separately:
+
+    ∫ r^{−2}A₀ dr = cℓ^{−1/3},
+    ∫ [A₂(b, ℓ/r³) − A₂(b, 0)] dr = (ℓ^{1/3}/3) ∫ [A₂(b, k) − A₂(b, 0)] k^{−4/3} dk,
+    ∫ (𝒜^{eld} − 𝒜^{con})(b, ℓ/r⁴) dr = ℓ^{1/4} ∫ (𝒜^{eld} − 𝒜^{con})(b, s^{−4}) ds.
+
+The third piece is #207's `c₁` integrand. The neglected pieces are formally `O(ℓ^{1/2})`:
+- the fold remainder. With requirement 2 of §0 it is `O(ρ_f² + ρ_f⁵/ℓ)` below `r = ρ_f`, which is `o(ℓ^{1/3})` for
+  `ρ_f = ℓ^{1/4+a'}`, `a' > 1/60`;
+- the cusp remainder. With requirement 1 it is `o(ℓ^{1/3})`;
+- the mixed term `A₂(b, k) − A₂(b, 0) = O(k)` at `s ≍ 1`, which integrates to `O(ℓ^{1/2}σ^{−2})` above `s = σ`;
+- the intermediate separations `ℓ^{1/4} ≪ r ≤ r₁` and the far part. For the elder density these need requirement 3, and
+  #187 or #188.
+
+Given requirements 1–3, these estimates close the argument. The interface terms `±A₂(b, 0)ρ_f` cancel, because
+`(𝒜^{eld} − 𝒜^{con})(s) = A₂(b, 0) + O(s⁴)` as `s → 0`, that is `O(κ^{−1})` with `κ = s^{−4}`. For the candidate kernel
+this is #218 Lemma O (O.1). For the elder kernel it is #220 Lemma O′ (O′.1), combined with Lemma O. This is a sketch; it
+is not written here as a proof. #218 §4 and #220's proof of Theorem E3 carry it out. v1.1 listed only the first three
+pieces.
+
+In `d = 1` this is exactly the structure of #214's Proposition 2.2:
+- the fold part (c) gives `B₂^{(1)}`;
+- the cusp part (d), split as `p₃(α) = p₃(0) + (p₃(α) − p₃(0))`, gives the Mellin term `(I_θ/2)h^{1/4}` and the finite
+  part `B₂^{(2)}`.
+
+There it is proved, in #214 (merged; an author-side proof candidate).
+
+## 2. The computation
+
+**2.1 Pinned Gaussian structure.**
+- *Jets.* The jets `J = (∂^αf(0))_{|α|≤N}` at the midpoint have covariance `(−1)^{|β|}∂^{α+β}ρ(0)`. We take `N = 12, 10, 8`
+  for `d = 1, 2, 3`.
+- *Pin rows and Hessians.* Both are linear forms in `J`, by Taylor along `u = e₁`.
+- *Truncation.* The error is of order `r^{N−2}` times a Gaussian moment; no constant is stated. The measured sizes
+  (v1.4, XA-216-B-04) are:
+  - `≤ 7·10⁻¹⁵` relative (float resolution) in `d = 1, 2`, against an untruncated kernel (nonauthor Slice B read
+    5401592048, B-10);
+  - in `d = 3`, against `N = 10`: up to `2.3·10⁻¹³` relative at `r = 0.011` and `2.2·10⁻¹⁴` at `r = 0.007` (measured
+    by the reviewer and reproduced here);
+  - the `d = 3` `c₂` moves by `1.2·10⁻¹¹` between `N = 8` and `N = 10`. v1.3's "below `10⁻¹⁵` at `r ≤ 0.011`" was
+    wrong for `d = 3`.
+- *Conditioning.* We condition on `U_r = v_r` in Decimal arithmetic (50 digits), then pass to floats. The small conditional
+  variances, `O(r⁴)`, come from `O(1)` cancellations and need the extra digits.
+
+**2.2 The typed indicator.** *Domain (v1.4, XA-216-B-01):* fixed `(b, k, u)` with `k > 0`, and
+`0 < r ≤ min(r_0^*, 1/2)`.
+- **`d = 1`.** At fixed `k > 0` the typed event has probability `1 − O(e^{−ck²/r²})`, so `E[(−h_M)h_S]` is used. By
+  Cauchy–Schwarz the kernel error is `O(e^{−ck²/(2r²)})`. This is a fixed-`k` sketch. It is not covered by #218 Lemma F,
+  which is stated for `d ≥ 2`.
+- **`d = 2`.** `1{typed} = 1{f_yy(0) < 0}` up to shifts of the boundary of size `O(rT(1 + T/k))`, where `T` is #218's
+  dominating variable and this size is its `υ`.
+  - On the layer between the two boundaries both scaled determinants are `O(r)`, so the product is `O(r²)` there. The
+    layer has probability `O(υ)`.
+  - So the error in `A_r` is `O(r³(1 + k^{−1}))`. This is #218 Lemma F, Step F2 and (2.3), with the surrogate paragraph
+    after its proof.
+  - Combining (2.3) with #218 (2.1) (`Φ` against the exact product, `O(r⁴)`), the nonauthor Slice B read (5401560065,
+    B-2) obtains `|A_r − Ã_r| ≤ Cr³(1 + k^{−1})P^Ne^{−c(b² + k²)}`. Here `P = 1 + |b| + k` as in #218, and `Ã_r` is
+    the fixed-cone surrogate, in #223's notation.
+  - The expectation of the quartic product given `f_yy(0)` follows from Isserlis' formula; the half-line integral uses
+    truncated Gaussian moments.
+- **`d = 3`.** `1{typed} = 1{A < 0}`, with `A = D_y²f(0)` (`2 × 2`), again up to `O(r³(1 + k^{−1}))` (Lemma F with
+  `m = 2`).
+  - The conditional law of `A` is invariant under transverse rotations.
+  - Its covariance is `Var a₁₁ = Var a₂₂ = 2`, `Cov(a₁₁, a₂₂) = 0` and `Var a₁₂ = 1` in the contact limit.
+  - At finite `r` (reference kernel; v1.4.1, C129-A1), `A + f(0)I` is independent of the pins with this GOE covariance.
+    So `Var a₁₁ = Var a₂₂ = 2 + σ_r²`, `Cov(a₁₁, a₂₂) = σ_r²` and `Var a₁₂ = 1`, where
+    `σ_r² := Var(f(0) | U_r) = r⁸/6144 + O(r¹⁰)` (checked at 60 digits: `1.6276·10⁻¹²` at `r = 0.1`).
+  - Rotation invariance and the eigenvalue reduction are unaffected. The checker uses the full conditional covariance
+    of its truncated-jet model, so no number changes.
+  - So `E[det H_M det H_S | A]` depends only on the eigenvalues. It is a polynomial of degree `≤ 6` in
+    `(b_eff, k, λ₁, λ₂)`, obtained from Isserlis' formula over the 76 partial matchings of each of the 36 permutation
+    products.
+  - It is integrated over `λ₂ < λ₁ < 0` with the eigenvalue Jacobian `π(λ₁ − λ₂)`.
+  - Here `b_eff := b − kr³/2`, the target's height coordinate. The transverse block's conditional mean does not depend on
+    `k`, by parity; the checker asserts this.
+- **Not uniform in small `k` (v1.4, XA-216-B-02).** The constant grows like `k^{−1}`. For `k ≲ r`, the cusp scale, the
+  typed and fixed-cone kernels differ at order `r²`. The difference is the cusp correction
+  `r²·12π₀E₀[(Y² − 36κ²Δ²)₊1{A<0} | b] = r²[(𝒜^{cand} − 𝒜^{con})(κ) − A₂(b, 0)]`, with `κ = k/r`, and it decays like
+  `κ^{−1}` (#218 Lemma O).
+  - So the `O(r³)` of this section must not be used uniformly in small `k`. Integrals down to `k → 0` need Lemma F's
+    `k^{−1}` together with the cusp analysis (#207 CU.4; #218 Lemmas C and O).
+  - The definition of `c₂` needs only the fixed-`k` statement. Pointwise in `k > 0` it gives `A₂ = Ã₂` for the
+    `r²`-coefficients of `A_r` and `Ã_r`. Both are `C¹` on `[0, ∞)` ((F.2) and #218's surrogate paragraph), so they
+    agree at `k = 0` too.
+- **Kernel scope (v1.4, XA-216-B-03).**
+  - For `d ≥ 2` the replacement holds for any [P] covariance, including the torus covariance `K_L` at fixed `L` (Lemma F;
+    its constants are not uniform in `L`).
+  - The `d = 3` rotation invariance and the covariance above (`2/0/1` in the contact limit) are facts about the
+    reference kernel `φ`. For `φ`, pins on `e₁` make the transverse law isotropic; `K_L` has only cubic symmetry.
+  - The `d = 1` statement is the fixed-`k` sketch above.
+
+**2.3 The finite part in `d = 1`.** This section uses #214 (merged; an author-side proof candidate). (#214's `c₂` in
+its Lemma 1.3 is a jet coefficient, unrelated to this note's `c₂`.) `∫A₂(b, k)db` has two components.
+- *The cusp component (v1.4, XA-216-B-05).* With `Y = f₄/12` and `∫π₀E₀[f₄²]db = p₁₂p₃·σ₄²`, the expression of (0.1)
+  evaluated at `v₀(b, k)` instead of `v₀(b, 0)` has `b`-integral `−(σ₄²/12)p₁₂p₃(12k)`. At `k = 0` this is the
+  `b`-integral of (0.1) itself, `−(σ₄²/12)p₁₂p₃(0)`.
+- So the cusp component contributes `(2/3)(−σ₄²p₁₂/12)12^{1/3}∫₀^∞(p₃(α) − p₃(0))α^{−4/3}dα` to the finite part, with
+  `α = 12k`. This is `2B₂^{(2)}` of #214 §2(d), which defines it (§2(e) gives its closed form). The factor 2 accounts
+  for the two orientations.
+- *The fold component (v1.4, XA-216-B-06)* is the rest of `∫A₂(b, k)db`. It is #214's `τ²`-coefficient of
+  `(12/t⁴)p_tm²` (§2(c)), which integrates to `2B₂^{(1)}`.
+  - The coordinates correspond as `t = r`, `τ = r/2`, `α = 12h/t³ = 12k` and `h = ℓ`. The relative order `r²` of
+    `∫db r^{−2}A_r` is the relative order `τ²` of `(12/t⁴)p_tm²`, plus the cusp component.
+  - This identification is not derived here. It consumes #214's Lemma 1.3.
+  - It is checked numerically by T1–T2 for the totals. The nonauthor Slice B read (5401592048, B-14) checked it pointwise
+    in `k`, for both kernels, to `≤ 2·10⁻¹⁶` relative (exploration outside the repository).
+- T1 and T2 check the total against the closed form `2B₂` (#214 (1D.2)):
+  - Gaussian kernel: `0.2300445808` against `0.2300445803`, which is also #223's closed form (v1.4);
+  - mixture `(e^{−x²/2} + e^{−2x²})/2`: `0.5760427428` against `0.5760427425`.
+
+**2.4 Numerics.**
+- *Expansion coefficients.* `A₀` and `A₂` come from least squares on `(1, r², r³, r⁴)` over five separations:
+  `r = 0.001…0.005` in `d = 1`, `r = 0.003…0.011` in `d = 2, 3`.
+- *Quadrature.* Gauss–Legendre in `b ∈ [−8, 8]` and in `t = k^{1/3} ∈ [0, K^{1/3}]`, with `K = 8`, and `K = 27` for the
+  mixture.
+- *Tail.* The term `|S^{d−1}|K^{−1/3}∫db(−A₂(b, 0))` beyond `K` is added analytically.
+- *`d = 3` cone.* A Gauss–Legendre rule in `(s, t)`, with `λ₁ = −s` and `λ₂ = −s − t`.
+- *Convergence (v1.2).* All changes below are absolute changes of `c₂`.
+
+  | `d` | `c` relative error | `r`-set | grid refinement | plain summation |
+  |---|---|---|---|---|
+  | 1 | `2·10⁻¹⁴` | against `2B₂`: `6·10⁻¹⁰` (Gaussian), `4·10⁻¹⁰` (mixture) | `k`: `80 → 120`, `5·10⁻¹²` | — |
+  | 2 | `8·10⁻¹⁴` | `7·10⁻¹⁰` | `(48, 80) → (64, 120)`: `< 10⁻¹²` | `3·10⁻¹⁰` |
+  | 3 | `7·10⁻¹³` (grid `(56, 120, 48²)`) | `3·10⁻¹⁰` | `(40, 80, 32²) → (56, 120, 48²)`: `6·10⁻¹¹`; `(64, 160, 64²)`: `2·10⁻¹¹` more | `2·10⁻¹⁰` |
+
+  - The `r`-fit bias dominates. Every variation is below `10⁻⁹`, but the variations share that bias, so they do not
+    bound the error (v1.4, C2).
+  - Against #223's closed forms the errors are `5.7·10⁻¹⁰` (`d = 1`), `1.9·10⁻⁹` and `2.6·10⁻⁹` (`d = 2`), and
+    `1.1·10⁻⁹`, `1.0·10⁻⁹` and `1.4·10⁻⁹` (`d = 3`: production grid, comparison grid, second `r`-set). That is up to
+    about four times the largest spread. T1, T3 and T4 now report them.
+  - v1.1's comparison grid `(32, 48, 24²)` moved `c₂` by `4.5·10⁻⁸` (Codex P2). The cause is the height quadrature:
+    32 nodes on `b ∈ [−8, 8]` under-resolve the `d = 3` integrand, while `(32, 80, 32²)` and `(40, 48, 32²)` isolate it.
+  - v1.1's summation sensitivity `2·10⁻⁸` predates the scaled `r`-fit; the measured value is `≤ 3·10⁻¹⁰`.
+
+## 3. Full-field Monte Carlo (exploration; outside the repository)
+
+**Method** (C and numpy; archived with the project record, not part of this packet, per the standard-library rule).
+- **Synthesis.** Exact spectral synthesis of the periodized kernel, with `ρ̂(k) = (2π)^{d/2}L^{−d}e^{−|k|²/2}`:
+  - `d = 2`: `L = 64`, on a `2048²` grid;
+  - `d = 3`: `L = 16`, on a `256³` grid.
+- **Critical points.** All critical points are found and refined:
+  - candidates from the fine-grid gradient;
+  - Newton on degree-10 (`d = 2`) or degree-8 (`d = 3`) Taylor expansions, from spectrally exact coarse-grid derivatives;
+  - a partner search along soft Hessian directions, for close fold pairs inside one cell.
+- **Merges.** Ascending lines from every `(d−1)`-saddle, by RK2 with a backtracking line search, give the merges.
+- **Persistence.** The superlevel `H₀` persistence follows by union–find with the elder rule. It is exact for the computed
+  critical values.
+- **Integrity.**
+  - Critical-point counts match Kac–Rice. The errors are standard errors of the per-sample mean (D-3). v1.4 computed them
+    from the raw sample records. These are pinned by sha256 in `SOURCES.json` but kept only in the session workspace, not
+    in the project archive, because of their size.
+    - `d = 2`: `376.42 ± 0.16` maxima and `752.70 ± 0.25` saddles per sample, against `376.37` and `752.75`.
+    - `d = 3`: `142.99 ± 0.24` maxima and `142.52 ± 0.24` minima per sample, against `142.80`. The saddles number
+      `436.20 ± 0.49` (index 1) and `436.67 ± 0.50` (index 2), against `436.25`. The saddle reference is the BBKS value,
+      with saddle-to-extremum ratio `(29 + 6√6)/(29 − 6√6)`; v1.2 printed it as `436.4`.
+  - The Euler characteristic is 0 in every retained sample.
+  - Every maximum but one dies.
+  - A dense-seed Newton search found no missed critical point in six `20 × 20` subregions (`d = 2`) and two `5³` subregions
+    (`d = 3`).
+  - *Power for close pairs (v1.4, D-4).*
+    - These regions are small. By (0.2) they are expected to contain about 11.5 elder pairs with `ℓ < 10⁻²` (2.6 with
+      `ℓ < 10⁻³`) in `d = 2`, and 0.66 (0.15) in `d = 3`. So the search tests completeness for close pairs only weakly
+      in `d = 2`, and not at all in `d = 3`.
+    - In `d = 3`, completeness for close pairs rests on the partner search. The Kac–Rice match bounds their loss only
+      coarsely. There are about 10.8 elder pairs with `ℓ < 10⁻²` per sample, against `142.8` maxima. The maxima count
+      (`142.99 ± 0.24`) excludes a loss of more than about 0.3 maxima per sample (2σ), that is about 3% of those pairs.
+    - Missing close pairs would bias the elder ratios low, and the observed ratios are above 1.
+  - Taylor evaluation matches exact trigonometric evaluation to `10⁻¹⁴` (`d = 2`) and `3·10⁻¹⁰` (`d = 3`).
+  - In `d = 3`, 4 of 1000 samples are flagged and excluded: 3 have a failed ascent and 1 has Euler characteristic 1. In
+    `d = 2`, none of 4000 is flagged.
+
+**Results (final, v1.2: `d = 2`, 4000 samples, volume `1.64·10⁷`; `d = 3`, 996 samples, volume `4.08·10⁶`).** Counts
+are binned in 24 logarithmic bins on `[10⁻⁵, 0.3]` and compared with the bin integrals of (0.2). There are no free
+parameters. A range selects the bins whose geometric centres lie in it (v1.4, stated at the Slice D read's request).
+- `[10⁻⁴, 10⁻²]` is 11 bins, spanning `[8.57·10⁻⁵, 9.65·10⁻³]`.
+- `[10⁻⁴, 3·10⁻²]` is 14 bins, spanning `[8.57·10⁻⁵, 3.50·10⁻²]`.
+
+| `d` | range of `ℓ` | elder pairs: data/(0.2) | `χ²/bins` | adjacent pairs: data/(formal law, `I^{cand}` for `c₁`) | `χ²/bins` |
+|---|---|---|---|---|---|
+| 2 | `[10⁻⁴, 10⁻²]` | `1.006 ± 0.004` | `7.0/11` | `1.004 ± 0.004` | `6.9/11` |
+| 2 | `[10⁻⁴, 3·10⁻²]` | `1.013 ± 0.002` | `44.9/14` | `1.004 ± 0.002` | `12.8/14` |
+| 3 | `[10⁻⁴, 10⁻²]` | `1.008 ± 0.010` | `5.0/11` | `0.999 ± 0.010` | `5.8/11` |
+| 3 | `[10⁻⁴, 3·10⁻²]` | `1.026 ± 0.007` | `26.9/14` | `1.001 ± 0.006` | `6.5/14` |
+
+*The adjacent-pair columns compare with a formal law (v1.4, D-2).* Adjacent pairs have no `B_{d,L}` term, and nothing on
+file proves their expansion (#218 Remark 3; #237 Remark 4). These columns, and the rejected-adjacent coefficient below,
+check consistency with the formal coefficients only.
+
+**Shorter laws.** On `[10⁻⁴, 10⁻²]` both are rejected:
+
+| `d` | leading term alone: ratio | `χ²` | two-term law: ratio | `χ²` |
+|---|---|---|---|---|
+| 2 | `0.941` | `335/11` | `1.089` | `714/11` |
+| 3 | `0.911` | `116/11` | `1.122` | `175/11` |
+
+The interim runs (1150 and 240 samples) gave consistent ratios.
+
+**Beyond the three-term law (reworded in v1.4, D-1).**
+- On `[10⁻⁴, 3·10⁻²]` the elder data exceed (0.2). A fit `eℓ^{1/2}` gives `e = 0.029 ± 0.005` in `d = 2` and
+  `0.031 ± 0.007` in `d = 3`. On `[10⁻⁴, 10⁻²]` the same fit is not significant: `0.03 ± 0.02` and `0.01 ± 0.03`.
+- Other powers fit comparably.
+  - On `[10⁻⁴, 0.3]`, fits with `ℓ^{1/2} + ℓ^{3/4}` and with `ℓ^{2/3} + ℓ^{3/4}` differ by `|Δχ²| ≤ 2.6` (#240 §7 item 4).
+  - A single extra power fits best at `p ≈ 0.14–0.33` in six of eight elder and rejected fits (#237 Remark 4).
+  - So the data do not single out `ℓ^{1/2}`. Whether the residual comes from decision effects or from Monte Carlo
+    systematics is open.
+- v1.3 read it as "about `0.03ℓ^{1/2}`" and as consistent with the formal `O(ℓ^{1/2})` remainder. Nothing contradicts
+  that remainder, but the data do not support the reading.
+- So the Monte Carlo supports the three-term law at about the 1% level on `[10⁻⁴, 10⁻²]` only.
+- The adjacent-pair residual is consistent with zero. It is so on this note's two ranges (the `χ²` above), and in #237
+  Remark 4's joint fits on `[10⁻⁴, 0.3]` and `[10⁻⁴, 0.1]`.
+
+**Rejected adjacent pairs.** These are adjacent pairs (the saddle ascends to the maximum) that are not elder pairs. They
+test the cusp window directly, because the fold terms cancel. A fit `aℓ^{1/4} + bℓ^{1/2} + eℓ^{3/4}` on `[10⁻⁴, 0.3]`
+gives:
+- `d = 2`: `a = 0.0922 ± 0.0039`, against `I^{cand} − c₁ = 0.0921`;
+- `d = 3`: `a = 0.069 ± 0.006`, against `0.0724`.
+
+On `[10⁻³, 0.3]` the fit gives `0.091 ± 0.004` and `0.072 ± 0.007`. A fit without the `ℓ^{1/2}` term gives
+`0.0821 ± 0.0006` and `0.0593 ± 0.0011`, which is biased. In `d ≥ 2` the rejected data carry a further correction whose
+power the data do not fix (#240 §7 item 4; #237 Remark 4), so `a` depends on the nuisance terms (v1.4, D-1). In `d = 1`
+there was no such correction (#214 §6.2).
+
+**The elder window, tested directly (v1.2).** Theorem CU.2 says that, at the cusp scale, an adjacent pair is an elder
+pair iff `|φ| < 1/3`. Here `φ = (f₄ − 3γᵀA^{−1}γ)/(72κ)` is computed from the jets at the midpoint, with `κ = ℓ/r⁴`.
+For each `ℓ`-range the simulation tabulates the elder fraction against `|φ|`. The `|φ|` at which it crosses `1/2`, and
+the rate at which the rule `1{|φ| < 1/3}` disagrees with the computed elder mark, are:
+
+| `ℓ` range | `d = 2`: 50% crossing | `d = 2`: disagreement (count) | `d = 3`: 50% crossing | `d = 3`: disagreement (count) |
+|---|---|---|---|---|
+| `[10⁻⁶, 10⁻⁴)` | (too few near `1/3`) | `0.16%` (6/3795) | (too few) | `0.4%` (2/503) |
+| `[10⁻⁴, 3·10⁻⁴)` | `0.329` | `0.40%` (17/4244) | `0.334` | `0.0%` (0/568) |
+| `[3·10⁻⁴, 10⁻³)` | `0.347` | `0.91%` (90/9876) | `0.395` (few) | `1.7%` (23/1392) |
+| `[10⁻³, 3·10⁻³)` | `0.337` | `1.8%` (355/19215) | `0.357` | `2.4%` (66/2704) |
+| `[3·10⁻³, 10⁻²)` | `0.343` | `4.3%` (1936/45256) | `0.329` | `6.0%` (374/6252) |
+| `[10⁻², 3·10⁻²)` | `0.335` | `8.2%` (6932/84812) | `0.339` | `11.7%` (1353/11560) |
+
+*Reading the table (v1.4, D-5).*
+- In `d = 2` the crossing sits at `1/3` within the binning in every range with enough pairs near the boundary. The
+  disagreement falls steadily as `ℓ ↓ 0`, roughly like `ℓ^{2/3}`: a log–log fit of the five rows above `10⁻⁴` gives
+  slope `0.66`.
+- In `d = 3` the crossings lie between `0.329` and `0.395`. The lowest range has no crossing.
+- The two lowest `d = 3` rows rest on few events. Their nominal 95% binomial counting intervals (Clopper–Pearson,
+  treating the pairs as independent) are `0.05–1.4%` for 2/503 and `0–0.65%` for 0/568. Their coverage under
+  within-field dependence has not been assessed (v1.4.1, C129-R1). So below `10⁻³` the `d = 3` disagreement is small
+  but not resolved as monotone.
+
+The archived figure `results/mc_final.png` shows three panels for each of `d = 2, 3`:
+- the elder density divided by `cℓ^{−1/3}`, with the leading, two-term and three-term laws;
+- the rejected adjacent density divided by `ℓ^{1/4}`;
+- the window test.
+
+## 4. The SIDE24 correction sizes (`d = 3`, Gaussian kernel)
+
+| `ℓ` | `−5.071ℓ^{7/12}` | `+3.859ℓ^{2/3}` | sum (three-term relative correction) |
+|---|---|---|---|
+| `10⁻⁵` | `−0.0061` | `+0.0018` | `−0.0044` |
+| `10⁻⁴` | `−0.0235` | `+0.0083` | `−0.0152` |
+| `10⁻³` | `−0.0902` | `+0.0386` | `−0.0516` |
+| `10⁻²` | `−0.3455` | `+0.1791` | `−0.1663` |
+
+Each entry is rounded separately from the unrounded coefficients `−5.07106214` (#219) and `3.85949617` (#223) (v1.4,
+C3). So at `10⁻⁵` and `10⁻²` the sum differs by one unit in its last digit from the sum of the displayed columns. The
+unrounded sums are `−0.00435`, `−0.01522`, `−0.05158` and `−0.16635`.
+
+The combined correction is `1%` at `ℓ ≈ 4.6·10⁻⁵` and `10%` at `ℓ ≈ 3.6·10⁻³`. V3 edit E15's sizes describe the
+`ℓ^{1/4}` term only (#214 caution); with this note the manuscript can quote both.
+
+*Status of these numbers (v1.3, xAI P2 in 5378684363; reworded in v1.4, S1).*
+- **The coefficients.**
+  - `c₁/c_{3,24}` is certified by #219.
+  - `c₂/c` is certified for the Gaussian kernel by #223's closed form. Its transfer to the torus `L ≥ 24` is the
+    author-side candidate #232.
+  - `c_{3,24} = c_{3,∞}(1 + O(e^{−288}))`. The ratios `−5.071` and `3.859` are roundings of these values.
+- **The table is the three-term truncation, not a certified prediction of `ν`.**
+  - The three-term law holds at candidate status with remainder `O(ℓ^{3/7})` (#229, using #187), with an unspecified
+    constant. So the size of the omitted terms at a given `ℓ` is not quantified.
+  - In §3's Monte Carlo the elder data exceed the three-term law by about 1–3% on `[10⁻⁴, 3·10⁻²]` (ratios `1.013` and
+    `1.026`). The form of the excess is open (exploration).
+
+## 5. Sources (exact identities in `SOURCES.json`)
+
+Merged:
+- [R] `frontiers/three_fronts_20260924/LIFETIME_REMAINDER.md` (`247b3ecf`): the kernel, the pin vector and its target;
+- `reviews/side24_v1_coefficient_claude_20260929/RESULTS.json`: `c_{2,∞}`;
+- `coefficients/side24_v1/ENCLOSURE.json`: `c_{3,24} = c_{3,∞}(1 + O(e^{−288}))`.
+
+Cited, merged since v1.2 (verified from the tree):
+- #207 `frontiers/cusp_second_order_20261001/PROOF.md` (`f6df5a73`): `c₁`, the cusp loss, Theorem CU′;
+- #191 `frontiers/remainder_vanishing_20260930/PROOF.md` (`441152df`): the even contact expansion;
+- #218 `frontiers/candidate_third_order_20261001/PROOF.md` (`70ca57ef`): Theorem T, (0.1), Lemmas C and F;
+- #220 `frontiers/elder_third_order_20261001/PROOF.md` (`c8767dde`): Theorem E3, Lemmas Q, CE, H, S′;
+- #229 `frontiers/third_order_rate_20261001/PROOF.md` (`110ed33a`): Theorems T⁺, E3⁺, Remark 1;
+- #223 `frontiers/c2_exact_20261001/NOTE.md` (`a2798b87`): `c₂` in closed form, certified enclosures;
+- #232 `frontiers/c2_finite_jet_transfer_20261001/PROOF.md` (`54cc4a1a`): `c₂` on the torus, `L ≥ 24`;
+- #219 `frontiers/cusp_coefficient_certified_20261001/NOTE.md` (`b2866871`): `c₁` certified, `c₁/c_{3,24}`.
+
+Cited, merged, bound since v1.4:
+- #187 `frontiers/far_elder_rate_20260930/PROOF.md` (`07260114`): Theorem F, the far part of (E3.3) and (E3⁺.1);
+- #240 `frontiers/elder_cusp_parity_20261002/PROOF.md` (`16a1db06`): §7 item 4, fits of the Monte Carlo residual.
+
+Cited, merged since v1.4 (verified from the tree; the pinned blobs are unchanged; v1.4.1):
+- #214 `frontiers/d1_third_order_law_20261001/PROOF.md` (`1591ecee`; merged as `e4ca2b3`): `B₂` and its proof in
+  `d = 1` (Theorem 1D);
+- #237 `frontiers/candidate_parity_rate_20261001/PROOF.md` (`a97bf528`; merged as `cb73b11`): Remark 4, the Monte
+  Carlo residuals.
+
+## 6. Controls
+
+`c2_check.py` uses the standard library only. Its output is `RESULTS.json`, byte-identical under `-O`. Mutants M1–M4 exit 1,
+and an unknown label exits 2. The run takes about 30 seconds.
+- **T1–T2** `d = 1`: `c = C₀` to `10⁻¹⁰` and `c₂ = 2B₂` to `10⁻⁸`, against #214's closed forms, for the Gaussian kernel and
+  the mixture. For the Gaussian kernel `c₂` is also within `10⁻⁸` of #223's closed form (observed `5.7·10⁻¹⁰`; v1.4).
+- **T3** `d = 2`: `c = c_{2,∞}` to `10⁻¹⁰`; `c₂` from two `r`-sets, each within `10⁻⁸` of #223's closed form (observed
+  `1.9·10⁻⁹` and `2.6·10⁻⁹`; v1.4).
+- **T4** `d = 3`: `c = c_{3,∞}` to `10⁻¹⁰`; `c₂` at the grid `(56, 120, 48²)`, at the grid `(40, 80, 32²)` and from the
+  second `r`-set, each within `10⁻⁸` of #223's closed form (observed `1.1·10⁻⁹`, `1.0·10⁻⁹` and `1.4·10⁻⁹`; v1.4).
+- *Closed forms.* The checker evaluates #223's closed forms with `math.gamma`. It first checks that each lies in #223's
+  certified interval, as a transcription control.
+- **T5** no `r¹` term: the ratio to `A₀` is below `10⁻⁶` at six test points, while the `r²` ratio is `O(1)`.
+- **T6** the overlap term (0.1) in `d = 2`: at four heights, `A₂(b, 0)` from the `r`-fit equals `−12π₀E₀[Y²1{A<0} | b]`
+  to `10⁻⁶`. The latter is computed directly from the jets, with `Y = f_xxxx a/12 − γ²/4`. In `d = 1` the same identity
+  holds to `2·10⁻¹²` (development check).
+- **Mutants,** with the checks that reject them (both modes):
+  - M1 drops the finite-part subtraction: T1–T4;
+  - M2 takes the `r³` coefficient for `A₂`: T1–T4;
+  - M3 uses a wrong sphere measure in `d = 2`: T3;
+  - M4 drops the analytic tail: T1–T4.
+
+  Every rejection is computed (v1.4, C1). v1.3 forced the M1 failure of T6 and the M2 failure of T5 by hand, and M2 and
+  M4 passed T3 and T4.
+
+What the controls do not test: the formal derivation of §1 in `d ≥ 2`, and the Monte Carlo of §3, which is exploration.
+
+## 7. Review slices
+
+- **A** §0 and §1: the definition of `c₂`, and whether the composite-expansion argument is right. In particular, that the
+  overlap term is exactly (0.1).
+- **B** §2.1–§2.3: the pinned structure, the `O(r³)` indicator replacement, and the `d = 1` comparison with #214.
+- **C** §2.4 and `c2_check.py`: the numerics and their convergence.
+- **D** §3–§4: the Monte Carlo method and its interpretation (exploration).
+
+**Changed bytes in v1.4** (against v1.3 at `7e97018`; each change is tagged with its finding ID):
+- *Header:* the object label, the v1.4 block, the shortened v1.3 block, the Disposition sentence and the dependency
+  list.
+- *§0:*
+  - the fold expansion and (0.1) with their sources (A1);
+  - the adjacent-pair sentence (S3);
+  - item 1 (S5, B-06), item 2's accuracy paragraph (C2) and item 3 (D-1);
+  - the SIDE24 fraction table (D-6, C3);
+  - "Status since v1.2" (S1–S3) and "What is not claimed" (A3).
+- *§1:* the interface cancellation (A2), and "#214 (an open PR)".
+- *§2.1:* truncation (B-04). *§2.2:* domain, layer size, non-uniformity and kernel scope (B-01 to B-03). *§2.3:* cusp and
+  fold components (B-05, B-06). *§2.4:* the errors against #223 (C2).
+- *§3:*
+  - the Kac–Rice counts with error bars (D-3) and the power of the completeness checks (D-4);
+  - the bin spans (Slice D request) and the adjacent-pair label (D-2);
+  - "Beyond the three-term law", and the nuisance-term note on the rejected-adjacent fit (D-1);
+  - the window counts (D-5).
+- *§4:* the rounding note (C3) and the status paragraph (S1).
+- *§5:* #187, #240 and #237. *§6:* T1, T3, T4 and the mutants (C1). *§7:* this list.
+
+**Changed bytes in v1.4.1** (against v1.4 at `1bfdf28`):
+- *Header:* the object label and the v1.4.1 block.
+- *Disposition and dependencies:* #214 and #237 are merged, and the dependency sentence is reworded (C129-A2).
+- *§0:* "rests on #214 (merged; …)" and item 1's status sentence.
+- *§1:* "in #214 (merged; …)". *§2.2:* the finite-`r` covariance (C129-A1) and the kernel-scope wording.
+- *§2.3:* its first sentence. *§3:* `1.8%` (C129-N1), the interval label (C129-R1) and "(#237 Remark 4)".
+- *§5:* #214 and #237 move to the merged list. *§7:* "comparison" (N6-2) and this list.
+
+`c2_check.py` and `RESULTS.json` are unchanged in v1.4.1. In v1.4, `c2_check.py` adds the #223 comparisons and drops
+the two hand-forced mutant failures, and `RESULTS.json` changes only by the new fields and the object label. No
+coefficient value, control value or Monte Carlo ratio changes in either version. v1.3 changed only status text (against
+v1.2 at `04c08e1`).
diff --git a/frontiers/third_order_coefficient_20261001/README.md b/frontiers/third_order_coefficient_20261001/README.md
new file mode 100644
index 000000000..ccd40968c
--- /dev/null
+++ b/frontiers/third_order_coefficient_20261001/README.md
@@ -0,0 +1,179 @@
+# The third-order coefficient of the short-lifetime law (CL-THIRD-ORDER-COEFF-20261001-v1.4.1)
+
+Formal coefficient with numerical evidence. Anthropic Claude, 1 October 2026 (v1.4 and v1.4.1: 4 October). Scientific
+effect NONE. Nonauthor review required.
+
+**v1.4.1 (no number changes)** answers the two readbacks of v1.4: C129 (5404127976) and Grok Bot agent 1
+(5976332101), both AMEND (scoped) with no blocker.
+- The finite-`r` transverse covariance is stated; `2/0/1` is its contact limit (C129-A1).
+- Numerical inputs (none consumed) are separated from the analytic identifications (C129-A2).
+- The window intervals are labelled as nominal binomial intervals (C129-R1).
+- Two display fixes (N1, N6-2).
+- #214 and #237 are recorded as merged.
+
+**v1.4 (answers the four nonauthor reviews at `7e97018`; no coefficient or Monte Carlo ratio changes).** The reviews
+are 5401553740 (Slices A and C and the status text, Grok Bot agent 1), 5401550768 (Slice D, xAI/Grok), and 5401560065
+and 5401592048 (Slice B, xAI/Grok agent 3). None found a blocker. Every finding is applied except U-1 (the Monte Carlo
+cannot be replayed from the repository), which is acknowledged (NOTE header and §7; `SOURCES.json`).
+- **Status wording.** Each packet is described by its own status.
+  - #218, #220, #229, #232 and #187 are author-side proof candidates. #223 and #219 certify enclosures of explicit
+    expressions.
+  - The candidate law ((T.1) of #218, (T⁺.1) of #229) is not (0.2). The adjacent-pair density is formal.
+    `d = 1` rests on #214, which was open at v1.4 and is merged since (v1.4.1).
+- **Checker.** T1, T3 and T4 compare every computed `c₂` with #223's closed forms (observed errors `≤ 2.6·10⁻⁹`). The
+  mutants fail on computed checks only.
+- **Monte Carlo.**
+  - The `ℓ^{1/2}` reading of the residual is withdrawn (#240 §7 item 4; #237 Remark 4).
+  - The `d = 3` Kac–Rice saddle reference is corrected to `436.25`, with error bars.
+  - The weak power of the completeness checks for close pairs is stated, and the window rows give their counts.
+
+**v1.3 (status update)** recorded the merged #191, #207, #218, #220, #229, #223, #232 and #219, and answered xAI's P2 and
+P3 on v1.2 (5378684363). v1.4 rewords its status sentences.
+
+**v1.2** applied the two Codex findings on v1.1 (`605af74`) and one author-side correction:
+- T4 now runs at a refined grid and compares it with the old grid and with a second `r`-set. Every grid, `r`-set and
+  summation-order variation moves `c₂` by `≤ 7·10⁻¹⁰` absolute. (v1.4, C2: these spreads share the `r`-fit bias and do
+  not bound the error. The errors against #223's closed forms are up to `2.6·10⁻⁹`, and the eight digits are correct
+  roundings of the closed forms.)
+- CI binds each cited unmerged source to its recorded commit, path and blob.
+- **Correction.** v1.1 said that a rate in #207's CU.4 would suffice for a proof in `d ≥ 2`. That understated it; see
+  "Status by dimension".
+- The Monte Carlo counts are final, and the elder window is tested directly.
+
+**v1.1** applied the three Codex findings on v1 (`205550f`):
+- byte-identical replay on CPython 3.10–3.14;
+- blob-id verification of the cited unmerged sources;
+- exact owner provenance.
+
+The coefficients are unchanged and are quoted to 8 digits.
+
+**Dependencies (v1.4.1).** No numerical input is consumed: the checker implements the merged two-point kernel of [R]
+(`frontiers/three_fronts_20260924/LIFETIME_REMAINDER.md`, `247b3ecf`) directly. The analytic identifications use, at
+their own status:
+- #214 Lemma 1.3 (the `d = 1` fold identification);
+- #218 Lemma F, (F.2) ((0.1));
+- #218 Lemma O with #220 Lemma O′ (the interface cancellation).
+
+All are merged author-side proof candidates. Cited for comparison: #207, #214 and #191; since v1.3 also #218, #220,
+#229, #223, #232 and #219; since v1.4 #187, #240 and #237. All are merged.
+
+**What it is.** The elder lifetime density has a third term:
+
+    ν_eld(ℓ) = c ℓ^{−1/3} + c₁ ℓ^{1/4} + c₂ ℓ^{1/3} + O(ℓ^{1/2}).
+
+- `c` is the leading constant, and `c₁ < 0` is #207's cusp coefficient.
+- `c₂` is the Hadamard finite part of `(1/3)∫A₂ k^{−4/3}dk`. Here `A₂(b, k, u)` is the `r²`-coefficient of [R]'s kernel at
+  fixed `(b, k, u)`.
+- The subtracted term `A₂(b, 0, u) = −12π₀E₀[Y²1{A<0} | b]` is the small-`s` limit of #207's cusp loss.
+
+The same `c₂` appears in the near candidate density, with `c₁` replaced by `I^{cand} = (3^{1/4}/2)c₁`; the candidate
+law also has a constant `B_{d,L}`. Formally the adjacent-pair density has the same three coefficients, but nothing on
+file proves its expansion (#218 Remark 3). The reason for the common `c₂` is that it is a fold-scale quantity; the
+elder rule enters only through the cusp window.
+
+**Status by dimension.**
+- **`d = 1`.** The formula gives #214's `2B₂`. #214 (Theorem 1D) is a merged author-side proof candidate, so the
+  `d = 1` law holds at that status.
+  - The cusp part of the finite part is an algebraic identity.
+  - The fold part rests on an identification not derived here, which consumes #214's Lemma 1.3.
+  - The total matches to `10⁻⁹` for two kernels. For the Gaussian kernel the merged #223 gives `c₂ = 2B₂` exactly.
+- **`d ≥ 2`, since v1.3.**
+  - *Elder density.* The merged author-side proof candidates #220 and #229 prove (0.2) with remainder `O(ℓ^{3/7})`,
+    using the merged #187 for the far part.
+  - *Candidate density.* #218 ((T.1)) and #229 ((T⁺.1)) prove the candidate law, with `B_{d,L}` and `I^{cand}`.
+  - The remainder `O(ℓ^{1/2})` and the adjacent-pair density stay formal. The list below is v1.2's record of what a
+    proof needed, now supplied by #220 (NOTE §0).
+- **`d ≥ 2`, v1.2.** For the elder density the expansion was formal (matched asymptotics, NOTE §1). A proof needs three
+  things (NOTE §0):
+  1. a rate in #207's kernel limit CU.4. In #218's ledger, an error `r^θ(1 + κ)^N` with `θ > max(2/5, (N+1)/4)`
+     suffices. For the elder kernel this is a quantitative Proposition CU.3;
+  2. a quantitative fold-scale expansion `A_r = A₀ + r²A₂ + O(r³(1 + k^{−1}))`;
+  3. for the elder density, a bound `o(ℓ^{1/3})` at intermediate separations `ℓ^{1/4} ≪ r ≤ r₁`. #198's Lemma B gives
+     only `O(ℓ^{1/3}ρ^{−1})` there.
+- **The candidate density.** It needs only 1 and 2, and **Math- #218 (Theorem T) supplies both**, at candidate status:
+  `ν_cand = cℓ^{−1/3} + B_{d,L} + I^{cand}ℓ^{1/4} + c₂ℓ^{1/3} + O(ℓ^{4/11})` in every `d ≥ 2`, with this `c₂`.
+
+**Values** for the Gaussian kernel, which is the SIDE24 covariance up to `1 + O(e^{−L²/8})`. #223 (merged) gives `c₂` in
+closed form with certified enclosures, and every digit below is a correct rounding:
+
+| `d` | `c` | `c₁` | `c₂` | `c₂/c` |
+|---|---|---|---|---|
+| 1 | `0.110110379` | `−0.227606` | `0.23004458` | `2.0892` |
+| 2 | `0.073406919` | `−0.269399` | `0.22152441` | `3.0178` |
+| 3 | `0.041775932` | `−0.211848` | `0.16123405` | `3.8595` |
+
+**For SIDE24 (`d = 3`).** The relative correction is `ν/(cℓ^{−1/3}) − 1 = −5.071ℓ^{7/12} + 3.859ℓ^{2/3}`:
+
+| `ℓ` | `10⁻⁵` | `10⁻⁴` | `10⁻³` | `10⁻²` |
+|---|---|---|---|---|
+| relative correction | `−0.4%` | `−1.5%` | `−5.2%` | `−16.6%` |
+
+The `ℓ^{1/3}` term cancels a fraction `0.761ℓ^{1/12}` of the `ℓ^{1/4}` term: 29%, 35%, 43% and 52% at `ℓ = 10⁻⁵`,
+`10⁻⁴`, `10⁻³` and `10⁻²`. The combined correction reaches `1%` at `4.6·10⁻⁵` and `10%` at `3.6·10⁻³`. Taking the
+`ℓ^{1/4}` term alone, as V3 edit E15 does, gives `2.3·10⁻⁵` and `1.2·10⁻³`.
+
+These are the three-term truncation (xAI P2). The coefficients:
+- `c₁/c` is certified by #219;
+- `c₂/c` is certified for the Gaussian kernel by #223, and its torus transfer for `L ≥ 24` is the author-side candidate
+  #232.
+
+The law holds at candidate status with remainder `O(ℓ^{3/7})` (#229, using #187), with an unspecified constant, so the
+omitted terms are not quantified at a given `ℓ` (NOTE §4).
+
+**Numerical evidence (exploration, outside the repository; NOTE §3).** A full-field Monte Carlo computes the actual
+elder-rule persistence of the periodized Gaussian field:
+- all critical points;
+- ascending lines from every `(d−1)`-saddle;
+- union–find.
+
+The runs are `d = 2` with `L = 64` and `d = 3` with `L = 16`. Integrity checks: Kac–Rice counts with error bars,
+Euler characteristic 0, dense-seed completeness. The dense-seed regions are too small to test close pairs in `d = 3`
+(NOTE §3).
+
+Final counts are 4000 samples (volume `1.64·10⁷`) in `d = 2` and 996 samples (`4.08·10⁶`) in `d = 3`. On
+`[10⁻⁴, 10⁻²]`:
+
+| `d` | three-term law: data/law | `χ²` | two-term law: ratio | `χ²` |
+|---|---|---|---|---|
+| 2 | `1.006 ± 0.004` | `7.0/11` | `1.089` | `714/11` |
+| 3 | `1.008 ± 0.010` | `5.0/11` | `1.122` | `175/11` |
+
+- The three-term law is parameter-free; the two-term law is rejected. The Monte Carlo supports the three-term law at
+  about the 1% level on `[10⁻⁴, 10⁻²]`.
+- The adjacent-pair density fits the formal law with `I^{cand}` in place of `c₁`. That law is not proved, so this checks
+  the formal coefficients only.
+- The rejected-adjacent coefficient is `0.0922 ± 0.0039` (`d = 2`), against `I^{cand} − c₁ = 0.0921` (also formal).
+- On `[10⁻⁴, 3·10⁻²]` the elder data exceed (0.2). An `ℓ^{1/2}` fit gives about `0.03`, but other powers fit
+  comparably (#240 §7 item 4; #237 Remark 4). The origin of the residual is open.
+- **The elder window, tested directly.** The elder fraction of adjacent pairs, plotted against `|φ|` from the midpoint
+  jets, crosses `1/2` at `|φ| ≈ 1/3` in every `d = 2` range with enough pairs near the boundary. In `d = 3` the crossings
+  lie between `0.329` and `0.395`.
+- The rule `1{|φ| < 1/3}` disagrees with the computed elder mark in `8.2%` of pairs (6932/84812) at
+  `ℓ ∈ [10⁻², 3·10⁻²)` and in `0.16%` (6/3795) below `10⁻⁴` (`d = 2`). The `d = 3` rows below `10⁻³` rest on few events
+  (NOTE §3).
+
+**Files.**
+- `NOTE.md`: the definition and its formal derivation (§1); the computation (§2, including the `d = 1` comparison with #214);
+  the Monte Carlo (§3); the SIDE24 correction sizes (§4).
+- `c2_check.py`: standard library. Its output is `RESULTS.json`, byte-identical under `-O` and on CPython 3.10–3.14. Mutants M1–M4 exit 1
+  on computed checks, and an unknown label exits 2. The run takes about 30 s. Its controls:
+  - **T1–T2** `d = 1` against #214's closed forms `C₀`, `2B₂`, for the Gaussian kernel and the mixture
+    `(e^{−x²/2} + e^{−2x²})/2`; for the Gaussian kernel also against #223's closed form;
+  - **T3** `d = 2`: `c = c_{2,∞}`, and `c₂` from two `r`-sets, each against #223's closed form;
+  - **T4** `d = 3`: `c = c_{3,∞}`; `c₂` on a refined grid, the old grid and a second `r`-set, each against #223's closed
+    form;
+  - **T5** the expansion has no `r¹` term;
+  - **T6** the subtracted term is the cusp-loss limit (0.1), checked in `d = 2`.
+- `SOURCES.json`: exact identities of the sources. It also gives the sha256 of the archived exploration code.
+
+**Review slices** (NOTE §7):
+- **A** the definition and the matched-asymptotics argument;
+- **B** the pinned structure and the `d = 1` identity;
+- **C** the numerics;
+- **D** the Monte Carlo (exploration).
+
+**Not claimed here:**
+- a proof in `d ≥ 2`. The merged author-side candidates #220 and #229, with #187, prove (0.2) for the elder density
+  with remainder `O(ℓ^{3/7})`. #218 ((T.1)) and #229 ((T⁺.1)) prove the candidate law;
+- certified values. #223 certifies `c₂` for the Gaussian kernel, and #219 certifies `c₁`;
+- the terms after `c₂`, and any reading of the Monte Carlo residual as an `ℓ^{1/2}` term.
diff --git a/frontiers/third_order_coefficient_20261001/RESULTS.json b/frontiers/third_order_coefficient_20261001/RESULTS.json
new file mode 100644
index 000000000..8a22bd730
--- /dev/null
+++ b/frontiers/third_order_coefficient_20261001/RESULTS.json
@@ -0,0 +1,99 @@
+{
+ "checks": {
+  "T1_d1_gauss": {
+   "2B2_closed": "0.2300445803",
+   "C0_closed": "0.110110378959",
+   "c": "0.110110378959",
+   "c2": "0.2300445808",
+   "c2_closed_223": "0.2300445803",
+   "c2_minus_closed_223": "5.7e-10",
+   "passed": true
+  },
+  "T2_d1_mixture": {
+   "2B2_closed": "0.5760427425",
+   "C0_closed": "0.269510028583",
+   "c": "0.269510028583",
+   "c2": "0.5760427428",
+   "passed": true
+  },
+  "T3_d2_gauss": {
+   "c": "0.073406919306",
+   "c2": "0.2215244125",
+   "c2_closed_223": "0.2215244106",
+   "c2_minus_closed_223": "1.9e-09",
+   "c2_over_c": "3.01775929",
+   "c2_second_rset": "0.2215244132",
+   "c2_second_rset_minus_closed_223": "2.6e-09",
+   "c_2inf": "0.073406919306",
+   "passed": true
+  },
+  "T4_d3_gauss": {
+   "c": "0.0417759318406",
+   "c2": "0.1612340502",
+   "c2_closed_223": "0.1612340491",
+   "c2_grid_40_80_32": "0.1612340502",
+   "c2_grid_40_80_32_minus_closed_223": "1.0e-09",
+   "c2_minus_closed_223": "1.1e-09",
+   "c2_over_c": "3.85949620",
+   "c2_second_rset": "0.1612340505",
+   "c2_second_rset_minus_closed_223": "1.4e-09",
+   "c_3inf": "0.0417759318406",
+   "grids": "b 56, k 120, cone 48x48; comparisons b 40, k 80, cone 32x32 (both r-sets)",
+   "passed": true
+  },
+  "T5_no_r1_term": {
+   "d2_b-1_k0.2": {
+    "abs_r1_over_A0_below_1e-6": true,
+    "r2_over_A0": "-1.1117"
+   },
+   "d2_b0.3_k0.7": {
+    "abs_r1_over_A0_below_1e-6": true,
+    "r2_over_A0": "1.4342"
+   },
+   "d2_b1.5_k1.3": {
+    "abs_r1_over_A0_below_1e-6": true,
+    "r2_over_A0": "5.1331"
+   },
+   "d3_b-1_k0.2": {
+    "abs_r1_over_A0_below_1e-6": true,
+    "r2_over_A0": "-3.2392"
+   },
+   "d3_b0.3_k0.7": {
+    "abs_r1_over_A0_below_1e-6": true,
+    "r2_over_A0": "0.9682"
+   },
+   "d3_b1.5_k1.3": {
+    "abs_r1_over_A0_below_1e-6": true,
+    "r2_over_A0": "5.0519"
+   },
+   "passed": true
+  },
+  "T6_overlap_term_d2": {
+   "b-1.2": {
+    "A2_b0": "-1.18081920e-03",
+    "agree_1e-6": true,
+    "loss_limit": "-1.18081920e-03"
+   },
+   "b0": {
+    "A2_b0": "-7.56455053e-03",
+    "agree_1e-6": true,
+    "loss_limit": "-7.56455054e-03"
+   },
+   "b0.7": {
+    "A2_b0": "-7.28360713e-03",
+    "agree_1e-6": true,
+    "loss_limit": "-7.28360714e-03"
+   },
+   "b2": {
+    "A2_b0": "-1.48947166e-03",
+    "agree_1e-6": true,
+    "loss_limit": "-1.48947166e-03"
+   },
+   "passed": true
+  }
+ },
+ "mutant": null,
+ "object": "CL-THIRD-ORDER-COEFF-20261001-v1.4 controls",
+ "passed": true,
+ "scientific_effect": "NONE"
+}
diff --git a/frontiers/third_order_coefficient_20261001/SOURCES.json b/frontiers/third_order_coefficient_20261001/SOURCES.json
new file mode 100644
index 000000000..0fcf08902
--- /dev/null
+++ b/frontiers/third_order_coefficient_20261001/SOURCES.json
@@ -0,0 +1,737 @@
+{
+ "schema": 1,
+ "scientific_effect": "NONE",
+ "object": "CL-THIRD-ORDER-COEFF-20261001-v1.4.1",
+ "kind": "formal coefficient with numerical evidence: the ell^(1/3) coefficient c2 of the short-lifetime law as the fold-scale Hadamard finite part of the r^2 coefficient of [R]'s two-point kernel; equals 2 B2 of Math- #214 in d = 1 (Theorem 1D of the open #214); values for d = 2, 3; full-field Monte Carlo with a direct test of the elder window (exploration outside the repository). Not a proof for the elder density in d >= 2; the candidate-density expansion with this c2 is Theorem T of Math- #218 (candidate); v1.3 (status update, no number changes): the expansion is proved at candidate status with remainder O(l^(3/7)) by the merged #218/#220/#229, c2 is certified by the merged #223 and transferred to the torus by #232, c1 by #219; xAI P2/P3 (5378684363) answered; #214 relabelled Theorem 1D and rebound to v1.3; v1.4 (answers the four nonauthor reviews at 7e97018; no coefficient, control-value or Monte Carlo ratio changes): status wording follows each packet's own status (S1-S5: #218/#220/#229/#232/#187 are author-side proof candidates, #223/#219 certify enclosures; the candidate law is (T+.1); d = 1 rests on the open #214); controls T1/T3/T4 compare c2 with the closed forms of #223 and the mutants fail on computed checks only (C1, C2); the l^(1/2) reading of the Monte Carlo residual is withdrawn and the adjacent-pair comparison is labelled formal (D-1, D-2); Kac-Rice references and error bars, completeness power and window counts (D-3 to D-5); sections 0-2 domain, sources and scope (A1-A3, XA-216-B-01 to B-06); v1.4.1 (answers the readbacks C129 5404127976 and 5976332101, no number changes): the finite-r transverse covariance with its contact limit 2/0/1 (C129-A1); numerical inputs separated from the analytic identifications (C129-A2); nominal binomial window intervals (C129-R1); #214 and #237 merged and bound from the tree",
+ "author": "Anthropic Claude",
+ "session": "https://claude.ai/code/session_01NMeKEismAyeqgdB4sy2NJU",
+ "read_at": {
+  "branch_base": "3e0a91b69892b9717564c592e7a966492a81566a",
+  "main_merged_in_v1_3": "2d8616ef1b45c4d5bb0970dcc20453bb4126114d",
+  "main_read_v1_4": "42f19d7dc4109c2359520b7cbde24b6bb1fca110",
+  "main_merged_in_v1_4_1": "cb73b11717d9389055b91e564bec7dcf71e58688"
+ },
+ "consumed": [],
+ "consumed_unmerged": [],
+ "cited_only": [
+  {
+   "path": "frontiers/three_fronts_20260924/LIFETIME_REMAINDER.md",
+   "bytes": 17734,
+   "sha256": "380b7d0abdb0fe2de5a6564565af9560d3f1b1ce22fd5538927db0c52f4f3a4a",
+   "git_blob": "247b3ecf80bfbe896948d5d489b2d5842a81c481",
+   "tag": "R",
+   "use": "the two-point kernel A_r = 12 pi_r(v_r) Z_r / r^2, the symmetric pin vector U_r and its target v_r (sections 2 and 4); the computation implements these definitions"
+  },
+  {
+   "path": "reviews/side24_v1_coefficient_claude_20260929/RESULTS.json",
+   "bytes": 1567,
+   "sha256": "8af1f8f0bea0a1739bfc41dd43fcdd11c219946c16c2ad169ff0581bf6da0b03",
+   "git_blob": "66e0462aa1245f66053d38d8f12a07f2f4f232d7",
+   "tag": "c2inf",
+   "use": "reference value c_{2,inf} = 0.073406919306034271030 (control T3)"
+  },
+  {
+   "path": "coefficients/side24_v1/ENCLOSURE.json",
+   "bytes": 1090,
+   "sha256": "72b6cd92d31394cdaf5da8919a5d548e902228af1f095cc184158a71d8287811",
+   "git_blob": "57af39a05e14ed0ba8ebc00a9b4aca4dffb067c7",
+   "tag": "c3inf",
+   "use": "reference value c_{3,24} = c_{3,inf}(1 + O(e^-288)) = 0.04177593184059834334... (control T4)"
+  },
+  {
+   "path": "frontiers/cusp_second_order_20261001/PROOF.md",
+   "bytes": 52605,
+   "sha256": "cffc1b83ac364da58bd650c3c301ea1babd38e19af54f74010bdc120edce38a8",
+   "git_blob": "f6df5a7356a54771b0052e42a864a140709903ad",
+   "tag": "207",
+   "use": "comparison: c1 (CU.2), the cusp loss and its small-s limit Y^2, CU.4, Theorem CU-prime (merged; the same blob as pinned in v1.2)"
+  },
+  {
+   "path": "frontiers/remainder_vanishing_20260930/PROOF.md",
+   "bytes": 25353,
+   "sha256": "0cb5b949261476f10e539677e2744e3288752474393af25ba787e67b1350f32a",
+   "git_blob": "441152dfc1d8d00cb268cebdb0394212a5bfacdb",
+   "tag": "191",
+   "use": "comparison: the even contact expansion (no r^1 term), checked independently by T5 (merged; the same blob as pinned in v1.2)"
+  },
+  {
+   "path": "frontiers/candidate_third_order_20261001/PROOF.md",
+   "bytes": 37220,
+   "sha256": "6c1279164499d4fe2fbeee244b40dafa2159758d20f04826cd67d7602ea97fe4",
+   "git_blob": "70ca57ef05199e75417d7d57928c1e1c93bf944e",
+   "tag": "218",
+   "use": "Theorem T: the candidate density to third order with this c2; Lemma F (F.1), (F.2): the fold expansion and the identification (0.1), cited at NOTE section 0 (v1.4, A1); Step F2, (2.3) and the surrogate paragraph: the typed-indicator replacement of section 2.2 (v1.4, XA-216-B-01); Lemma O (O.1): the overlap (v1.4, A2); Remark 3: the adjacent-pair expansion is not proved (v1.4, D-2) (merged; the same blob as pinned in v1.2)"
+  },
+  {
+   "path": "frontiers/elder_third_order_20261001/PROOF.md",
+   "bytes": 70544,
+   "sha256": "74b5f031ba5be6f50b5e543636136df1d9b5fad0fcd2c8210320cfef02f80e37",
+   "git_blob": "c8767ddecf1041d234f685e95af582073a7be393",
+   "tag": "220",
+   "use": "status (v1.3): Theorem E3, the elder density to third order with this c2, Lemmas Q, CE, H, S-prime; (E3.3) with #187; Lemma O-prime (O-prime.1): the elder overlap (v1.4, A2); no statement about the adjacent-pair density (v1.4, S3)"
+  },
+  {
+   "path": "frontiers/third_order_rate_20261001/PROOF.md",
+   "bytes": 37626,
+   "sha256": "5de5a6c7b942a71675c812000ade30c16766f02ee388e8dc3e1c51dde5297f7d",
+   "git_blob": "110ed33a57902bef11873807e722fde3888b59fb",
+   "tag": "229",
+   "use": "status (v1.3): Theorems T+ and E3+, remainder O(l^(3/7)) ((T+.1), (E3+.1)); Remark 1 (why the method stops at 3/7); author-side proof candidate, no numerical constant certified (v1.4, S2); no statement about the adjacent-pair density"
+  },
+  {
+   "path": "frontiers/c2_exact_20261001/NOTE.md",
+   "bytes": 14480,
+   "sha256": "598fc86a7c6b21bad438ef087e5aa7521f0fae08e25fa4f40f9b2ba635846dbb",
+   "git_blob": "a2798b87674ed5fc0d2144697e77ccb9b185b4ab",
+   "tag": "223",
+   "use": "c2 for the Gaussian kernel in closed form with certified enclosures (section 0), for the fixed-cone surrogate expression, with no torus transfer (section 8); since v1.4 controls T1, T3 and T4 compare the computed c2 with these closed forms, each first checked to lie in the certified interval (C1, C2)"
+  },
+  {
+   "path": "frontiers/c2_finite_jet_transfer_20261001/PROOF.md",
+   "bytes": 25581,
+   "sha256": "971101de946fd711207454c2cd4bbc36729ca9b7c07262e122ff1d54bf5dfa16",
+   "git_blob": "54cc4a1ae274842bc2c01f9c207549e7b07de7bc",
+   "tag": "232",
+   "use": "status (v1.3): c2 on the periodized torus covariance, d = 1, 2, 3, every L >= 24, error < 1e-60; an author-side proof candidate (v1.4, S1)"
+  },
+  {
+   "path": "frontiers/cusp_coefficient_certified_20261001/NOTE.md",
+   "bytes": 27264,
+   "sha256": "9c74117f6b7ff2054fcfb5ddcfb4c8ad4a3a1278c201faafc5e98e7612abfc0c",
+   "git_blob": "b2866871c10cd0a0def41e10bdaf5ecbef18241c",
+   "tag": "219",
+   "use": "status (v1.3): c1 certified; c1/c_(3,24) in [-5.07106215, -5.07106213]"
+  },
+  {
+   "path": "frontiers/far_elder_rate_20260930/PROOF.md",
+   "bytes": 16493,
+   "sha256": "ed908ed97348ed708c6fd06e5c09f6290ab0e8c47e6384b7bdded321452f523b",
+   "git_blob": "072601145601a1021037a2e91bf8826c1c971ecc",
+   "tag": "187",
+   "use": "status (v1.4, S4): Theorem F, the far elder density O(l^(2/3)) at a fixed separation, which #220 (E3.3) and #229 (E3+.1) use for the far part; an author-side proof candidate"
+  },
+  {
+   "path": "frontiers/elder_cusp_parity_20261002/PROOF.md",
+   "bytes": 51848,
+   "sha256": "35b9c5943cf35919f2046ba194945ba759be654edf5d5ad77ba17b1f5c5377fd",
+   "git_blob": "16a1db0658918057ff741df888c13702763d9919",
+   "tag": "240",
+   "use": "Monte Carlo interpretation (v1.4, D-1): section 7 item 4, the residual fits l^(1/2) + l^(3/4) and l^(2/3) + l^(3/4) are comparable (|delta chi2| <= 2.6), so the data do not single out l^(1/2)"
+  },
+  {
+   "path": "frontiers/d1_third_order_law_20261001/PROOF.md",
+   "bytes": 46313,
+   "sha256": "a1b5e6ecc97341ad72d74973c69c0f94304b22c559ab0187310ef2bd73455804",
+   "git_blob": "1591ecee3c82c8b42cb3220189ea0a4ce4bf195f",
+   "tag": "214",
+   "use": "comparison: B2 (closed form (1D.2), proof in d = 1, Theorem 1D; v1.3 of #214, rebound from f4a58df / 873532b9, whose B2 is unchanged); controls T1, T2 compare c2 with 2 B2; v1.4 (S5, XA-216-B-05/06): the d = 1 law is #214 Theorem 1D, an open PR; NOTE section 2.3 cites section 2(c) (fold part), 2(d) (definition of B2^(2)) and Lemma 1.3 (consumed by the fold identification); merged as e4ca2b3 with this blob, bound from the tree since v1.4.1 (previously cited_unmerged at head 54666d2)",
+   "pr": "Math- #214",
+   "merge_commit": "e4ca2b3f8e0b76e000d5a85fe09b8ddd52328191"
+  },
+  {
+   "path": "frontiers/candidate_parity_rate_20261001/PROOF.md",
+   "bytes": 53499,
+   "sha256": "9d58a29bf725d0756c8d11b5a9aa538782e83bee62242bcb1a869d2b95ccce94",
+   "git_blob": "a97bf528b4e073c6e12fd2d4616be77e8bbae16b",
+   "tag": "237",
+   "use": "Monte Carlo interpretation (v1.4, D-1, D-2): Remark 4, the elder and rejected residuals (a single extra power fits best at p ~ 0.14-0.33 in six of eight fits; joint l^(1/2) + l^(3/4) coefficients); the adjacent-pair comparison concerns the common formal coefficients only; merged as cb73b11 with this blob, bound from the tree since v1.4.1 (previously cited_unmerged at head 0add03b)",
+   "pr": "Math- #237",
+   "merge_commit": "cb73b11717d9389055b91e564bec7dcf71e58688"
+  }
+ ],
+ "cited_unmerged": [],
+ "cited_external": [
+  {
+   "tag": "Isserlis",
+   "reference": "L. Isserlis (1918), moments of products of Gaussian variables (Wick)",
+   "use": "conditional expectations of determinant products"
+  },
+  {
+   "tag": "Hadamard",
+   "reference": "Hadamard finite part",
+   "use": "definition of c2"
+  }
+ ],
+ "mutants": [
+  "M1",
+  "M2",
+  "M3",
+  "M4"
+ ],
+ "replayed": [
+  "c2_check.py"
+ ],
+ "not_replayed": [
+  "the Monte Carlo of NOTE section 3 (C + numpy; exploration archived with the project record)"
+ ],
+ "exploration_outside_repository": [
+  {
+   "path": "project archive V2_2/numerics_lifetime_mc_20261001/README.md",
+   "bytes": 4770,
+   "sha256": "592552635479e8f5a7a50ecb67b65a4b98fd84138cf48735c28c6d3225ad120e"
+  },
+  {
+   "path": "project archive V2_2/numerics_lifetime_mc_20261001/analysis/law_compare.py",
+   "bytes": 2364,
+   "sha256": "d20cf129c47e0ba9b49ae55958d27e93a79c64bb7e93894e285e49d5a75b230b"
+  },
+  {
+   "path": "project archive V2_2/numerics_lifetime_mc_20261001/analysis/plots_final.py",
+   "bytes": 3491,
+   "sha256": "0ff6cf9ad8d9af49940bd072a9d13840b3c7fb8403aa67cb70c7482eb24e3329"
+  },
+  {
+   "path": "project archive V2_2/numerics_lifetime_mc_20261001/analysis/window_test.py",
+   "bytes": 3009,
+   "sha256": "2bcd5370e060f6e5100332ac8e0fc62b38d3422126bfafcbb8479a093f7e950b"
+  },
+  {
+   "path": "project archive V2_2/numerics_lifetime_mc_20261001/c2_mpmath/c2_d3.py",
+   "bytes": 8393,
+   "sha256": "92e5f22efa8ae7d188c183e04d3eb66b06d37d3cda8cf9eea4388ccf4cd682c3"
+  },
+  {
+   "path": "project archive V2_2/numerics_lifetime_mc_20261001/c2_mpmath/c2_d3_int.py",
+   "bytes": 1946,
+   "sha256": "e9b247e073014d57845c6d2825cb66c54f0e3ad84c4f1677ab930c5899aea956"
+  },
+  {
+   "path": "project archive V2_2/numerics_lifetime_mc_20261001/c2_mpmath/c2_fold.py",
+   "bytes": 8436,
+   "sha256": "e4f5cbe79fa106f7d227f0c522e91a22a668aafc2e037e93c3f7fead5e4f9ec9"
+  },
+  {
+   "path": "project archive V2_2/numerics_lifetime_mc_20261001/c2_mpmath/c2_int.py",
+   "bytes": 2470,
+   "sha256": "f0e30b74853ed812a0c8b204efea80fdb287fe54992934f30d376d680e0b01be"
+  },
+  {
+   "path": "project archive V2_2/numerics_lifetime_mc_20261001/results/law2_final.json",
+   "bytes": 1355,
+   "sha256": "fbacb05213c3c7d7fd724d9c72d162404f83e2bd95555ddd165598c752f612e0"
+  },
+  {
+   "path": "project archive V2_2/numerics_lifetime_mc_20261001/results/law3_final.json",
+   "bytes": 1355,
+   "sha256": "b87acf045b7657c253ac474883a6b65de70095e0f2e80a88f2dea95823d1e377"
+  },
+  {
+   "path": "project archive V2_2/numerics_lifetime_mc_20261001/results/mc2_final.json",
+   "bytes": 6465,
+   "sha256": "168104cdc15e5de40586816bb451d6944f88ecd0a557ff1ee9c471d56188a86f"
+  },
+  {
+   "path": "project archive V2_2/numerics_lifetime_mc_20261001/results/mc2_interim.json",
+   "bytes": 6437,
+   "sha256": "66f28d5191d8f7a0011f4e363276dc67c52b83cd4911342140296d7b4b420b0d"
+  },
+  {
+   "path": "project archive V2_2/numerics_lifetime_mc_20261001/results/mc3_final.json",
+   "bytes": 6401,
+   "sha256": "f1105e1e6471b2a95caf664e3342b69a9145b69899b37837c3c6d40849c77843"
+  },
+  {
+   "path": "project archive V2_2/numerics_lifetime_mc_20261001/results/mc3_interim.json",
+   "bytes": 6367,
+   "sha256": "6676b9f45ca0340e1ed2f1dddc6649322d883507c53f8a65b2dd7ebe4d63bb84"
+  },
+  {
+   "path": "project archive V2_2/numerics_lifetime_mc_20261001/results/mc_final.png",
+   "bytes": 190186,
+   "sha256": "606c8092ea61b3a9d8c79f2fe835b2e92d2c7a288aed16896ec08676ed00260b"
+  },
+  {
+   "path": "project archive V2_2/numerics_lifetime_mc_20261001/results/validate2d.out",
+   "bytes": 350,
+   "sha256": "a946644417ce7b1dec789b7df61f2705c95f9316193a892c5480bcea8a756b88"
+  },
+  {
+   "path": "project archive V2_2/numerics_lifetime_mc_20261001/results/validate3d.out",
+   "bytes": 314,
+   "sha256": "d29eec6e670044a76920045f2cb0e329a0de92fa47f3d3054a65a804e421b1d4"
+  },
+  {
+   "path": "project archive V2_2/numerics_lifetime_mc_20261001/results/window2_final.json",
+   "bytes": 3211,
+   "sha256": "3ae8c05cf0c202e3575d61ae8ef1a69275e09ea15e866c29efd0d8a4da11cedf"
+  },
+  {
+   "path": "project archive V2_2/numerics_lifetime_mc_20261001/results/window3_final.json",
+   "bytes": 2958,
+   "sha256": "c7bfb554df29f906466fc14072e777f7834ee320595075978fae2a4c36a97905"
+  },
+  {
+   "path": "project archive V2_2/numerics_lifetime_mc_20261001/sim2d/analyze.py",
+   "bytes": 6633,
+   "sha256": "3c02c8601c17ff1df1e416800f12747f3d159ccf637dc3d75ad7bbdf1cd6187a"
+  },
+  {
+   "path": "project archive V2_2/numerics_lifetime_mc_20261001/sim2d/mc_compare.py",
+   "bytes": 4107,
+   "sha256": "98b7253373f6cf7d8bee9f32b287fce29c87603164529ea68139399ad2f83d88"
+  },
+  {
+   "path": "project archive V2_2/numerics_lifetime_mc_20261001/sim2d/plots.py",
+   "bytes": 3180,
+   "sha256": "7c13c4909495667a2b6ba59ab2781288cb36e915e1577c9a9b75bb2e150580c0"
+  },
+  {
+   "path": "project archive V2_2/numerics_lifetime_mc_20261001/sim2d/run_batch_v2.py",
+   "bytes": 1053,
+   "sha256": "d3744083a2f3d4cea2d22132ced8af027ad7a484171538d0d115b1b549019679"
+  },
+  {
+   "path": "project archive V2_2/numerics_lifetime_mc_20261001/sim2d/sim2d.c",
+   "bytes": 12429,
+   "sha256": "456a1d83d037a26a55bd6867d1e932cd11eeeb8a7c0d510149445a2ee31c4b8c"
+  },
+  {
+   "path": "project archive V2_2/numerics_lifetime_mc_20261001/sim2d/sim2d.py",
+   "bytes": 10769,
+   "sha256": "a647a79579ea7af2885d729320b92d807dafe1b3d4a820ee7dbe08edd0072439"
+  },
+  {
+   "path": "project archive V2_2/numerics_lifetime_mc_20261001/sim2d/sim2d_v2.c",
+   "bytes": 12665,
+   "sha256": "649d6fba0ff8f435029973d06d14fef0ae01d55f472362da455e56f584d2bee4"
+  },
+  {
+   "path": "project archive V2_2/numerics_lifetime_mc_20261001/sim2d/sim2d_v2.py",
+   "bytes": 11739,
+   "sha256": "f9358cf91fa30abd31943583df8ac3208c5cb7cc03b56a898c317005a91b8ad7"
+  },
+  {
+   "path": "project archive V2_2/numerics_lifetime_mc_20261001/sim2d/validate4.py",
+   "bytes": 1222,
+   "sha256": "aa363970700494238983ba81d420706b0088cddcf5f4ea72f51dcc08e30eb772"
+  },
+  {
+   "path": "project archive V2_2/numerics_lifetime_mc_20261001/sim3d/run_batch3d_v3.py",
+   "bytes": 1029,
+   "sha256": "9026377acde460bd28ca123b915579547a1f46c7d6236e04fac95e9216779845"
+  },
+  {
+   "path": "project archive V2_2/numerics_lifetime_mc_20261001/sim3d/sim3d.c",
+   "bytes": 12872,
+   "sha256": "28d63e3f3145718d39f7f0b0f3ae0db73f68368e6b5d5da139d445c5883edb95"
+  },
+  {
+   "path": "project archive V2_2/numerics_lifetime_mc_20261001/sim3d/sim3d.py",
+   "bytes": 9448,
+   "sha256": "2997e970bb6d3b43554db0f151a7447e5c68d69069a2d1baa760ae04ff6f06fe"
+  },
+  {
+   "path": "project archive V2_2/numerics_lifetime_mc_20261001/sim3d/sim3d_v3.c",
+   "bytes": 13121,
+   "sha256": "bd05561355c1273babb934d67f097ae1806ee93f7b23d7cf93b5633d1254c542"
+  },
+  {
+   "path": "project archive V2_2/numerics_lifetime_mc_20261001/sim3d/sim3d_v3.py",
+   "bytes": 10221,
+   "sha256": "6e54cad15b8e2ae9a5305fdda7d80e63a85328de802a57bcee524ce60c447d7e"
+  },
+  {
+   "path": "project archive V2_2/numerics_lifetime_mc_20261001/sim3d/validate3d.py",
+   "bytes": 1971,
+   "sha256": "256e42ee13bd9cbca183445a21c0d77e021fa8552ce46debb818ca76cea22ac6"
+  }
+ ],
+ "delivered_under": "explicit owner instructions of Dylan Roy in claude.ai session session_01NMeKEismAyeqgdB4sy2NJU, given after OWNER_STOP (2026-09-27): 2026-09-30 \"Continue to Work on closing as many mathematical items as possible while working with and supporting the other models in the GitHub. Also advance the mathematics in every place that's justified based on what we currently know\", followed by \"Continue\"; standing: \"Any request or permissions are preapproved in advance by me Dylan Roy\", pull requests only, never self-merge, no register/GRAPH/STATUS/lemma_closed/prize/premise edits, OWNER_STOP.md untouched. OWNER_STOP.md addresses Cursor agents and is untouched; nothing is merged by its author.",
+ "automated_nonauthor": [
+  {
+   "reviewer": "chatgpt-codex-connector[bot] (OpenAI Codex, automated PR review)",
+   "reviewed_commit": "205550f85ad4005825162d3cfd3b77a22852230a",
+   "date": "2026-10-01",
+   "findings": [
+    {
+     "id": "P2",
+     "thread": 4152981579,
+     "claim": "byte-exact replay is interpreter-dependent (CPython 3.14 differs at ~1e-9 in c2)",
+     "verdict": "correct",
+     "disposition": "v1.1: every float sum is math.fsum (the built-in sum of floats changed in CPython 3.12) and the r-fit uses r/max(r); RESULTS.json is now byte-identical on CPython 3.10, 3.11, 3.12, 3.13 and 3.14 (checked); NOTE quotes c2 to 8 significant digits, the level at which summation order no longer matters"
+    },
+    {
+     "id": "P1",
+     "thread": 4152981591,
+     "claim": "a pull_request workflow added during the owner stop re-arms automation",
+     "verdict": "governance question; provenance made exact",
+     "disposition": "v1.1 records the owner's explicit post-stop instructions (delivered_under), as on Math- #210; the workflow is the pull_request-scoped replay that every packet in this lane carries (#198, #207, #211, #214), schedules nothing, and runs only when this packet changes; the PR stays unmerged unless the owner merges it"
+    },
+    {
+     "id": "P2",
+     "thread": 4152981598,
+     "claim": "the workflow ignores cited_unmerged entries",
+     "verdict": "correct",
+     "disposition": "v1.1: the workflow verifies every cited_unmerged entry by its pinned blob id through the repository API (size, sha256, git blob), as #198 does for consumed dependencies"
+    }
+   ]
+  },
+  {
+   "reviewer": "chatgpt-codex-connector[bot] (OpenAI Codex, automated PR review)",
+   "reviewed_commit": "605af74ce462ed5a26bb488c65c0b4097d6bd3fa",
+   "date": "2026-10-01",
+   "review": 5376571239,
+   "findings": [
+    {
+     "id": "P2",
+     "thread": 4153154184,
+     "claim": "eight digits of c2 in d = 3 are not supported by T4 (its two grids differ by 4.5e-8)",
+     "verdict": "correct about T4; the converged value is unchanged",
+     "disposition": "v1.2: convergence study (b, k, cone grids, r-set, summation order); the coarse grid under-resolved the height integral (32 nodes); T4 now runs at (56, 120, 48^2) and compares with (40, 80, 32^2) and the second r-set (spreads < 1e-10 and 3e-10); all variations < 1e-9 in every dimension (NOTE section 2.4)"
+    },
+    {
+     "id": "P2",
+     "thread": 4153154193,
+     "claim": "cited_unmerged blobs are not bound to their recorded head and path",
+     "verdict": "correct",
+     "disposition": "v1.2: the workflow resolves each recorded head, checks through the contents API that the recorded path at that head is a file with the recorded blob id and size, then checks the blob bytes (sha256, framed sha1)"
+    }
+   ]
+  }
+ ],
+ "author_corrections": [
+  {
+   "version": "v1.2",
+   "what": "v1.1 said a rate O(r) in #207 CU.4 suffices for a proof in d >= 2; that understated it: a quantitative fold expansion and, for the elder density, an o(l^(1/3)) bound at intermediate separations are also needed (NOTE section 0); the sufficient rate condition is theta > max(2/5, (N+1)/4) for an error r^theta (1 + kappa)^N (found by the referee of Math- #218)"
+  }
+ ],
+ "files": [
+  {
+   "path": "NOTE.md",
+   "bytes": 47631,
+   "sha256": "cbb59eb8df5d492c5183e110219703559307441b0d9fb281434b5193e3ef8078"
+  },
+  {
+   "path": "README.md",
+   "bytes": 11824,
+   "sha256": "fe7dc3f3140320511be9a8cb35a9123042e7de2375d1783f1f1491bcc6c3a890"
+  },
+  {
+   "path": "c2_check.py",
+   "bytes": 27306,
+   "sha256": "28b84f0fd5fa48f255dabef539e1d080482296cc186b2bf979e06822ae0aa126"
+  },
+  {
+   "path": "RESULTS.json",
+   "bytes": 2435,
+   "sha256": "b02c0452f4748aec718c18feb589324346fef02099c39722614b5aba25b62bfd"
+  }
+ ],
+ "supersedes": {
+  "object": "CL-THIRD-ORDER-COEFF-20261001-v1.4",
+  "head": "e475107254fe1f64ff813e503f3d5b7a8058061a",
+  "commit": "1bfdf28b2e9baa3aa3fcc9d00c974bce56045f83",
+  "note_blob": "5b2c5c024db393c6eabceedc293fe4acb5126de1"
+ },
+ "nonauthor_reviews": [
+  {
+   "reviewer": "xAI / Grok lane (Lucas); same GitHub account; organizational independence 0",
+   "review": "pullrequestreview-5378684363",
+   "at": "4f0927f",
+   "verdict": "COMMENT (AUTHOR_SIDE_CANDIDATE / REVIEWED_WITH_FINDINGS)",
+   "findings": [
+    "P2: label the SIDE24 sentence (answered in v1.3, NOTE section 4)",
+    "P3: landing order / does not discharge the elder law (answered in v1.3)"
+   ],
+   "applied_in": "v1.3"
+  },
+  {
+   "reviewer": "xAI / Grok team; same GitHub account; organizational independence 0",
+   "review": "pullrequestreview-5379816488",
+   "at": "04c08e1",
+   "verdict": "NOT READY (scope note: exponents close; the elder expansion was formal; blocked)",
+   "findings": []
+  },
+  {
+   "reviewer": "OpenAI Codex automated review",
+   "comment": "5928841544",
+   "at": "4f0927f",
+   "verdict": "no major issues",
+   "findings": []
+  },
+  {
+   "reviewer": "Grok Bot agent 1, a Cursor-hosted assistant (the post was signed \"xAI / Grok (Cursor)\"; corrected in comment 5974176267); same GitHub account; organizational independence 0",
+   "review": "pullrequestreview-5401553740",
+   "claim": "5970714924",
+   "at": "7e97018",
+   "scope": "Slice A (NOTE sections 0-1), Slice C (section 2.4, c2_check.py, RESULTS.json, workflow) and the v1.3 status text",
+   "verdict": "ACCEPT_WITH_FINDINGS (Slices A and C: P2 only; status text: two P1 wording overclaims)",
+   "findings": [
+    {
+     "id": "A1",
+     "severity": "P2",
+     "disposition": "applied in v1.4: (0.1) is stated as #218 Lemma F (F.2), a theorem; the fold expansion cites (F.1); the checks are stated (T6 in d = 2; a d = 1 development check; none in d = 3)"
+    },
+    {
+     "id": "A2",
+     "severity": "P2",
+     "disposition": "applied in v1.4: the interface cancellation cites #218 Lemma O (O.1) and #220 Lemma O-prime (O-prime.1); still labelled a sketch"
+    },
+    {
+     "id": "A3",
+     "severity": "P2",
+     "disposition": "applied in v1.4: \"not proved here\"; item 3 records the v1.2 state and the later #220 (O(l^(2/5))) and #229 (O(l^(4/9) log)) bounds"
+    },
+    {
+     "id": "C1",
+     "severity": "P2",
+     "disposition": "applied in v1.4: T1, T3 and T4 compare every computed c2 with the closed forms of #223 (each first checked to lie in its certified interval); the hand-forced failures (M1 in T6, M2 in T5) are removed; M1, M2 and M4 now fail T1-T4 and M3 fails T3, computed, under -B -S and -B -O -S"
+    },
+    {
+     "id": "C2",
+     "severity": "P2",
+     "disposition": "applied in v1.4: NOTE section 0 and 2.4 quote the errors against #223 (5.7e-10; 1.9e-9 and 2.6e-9; 1.1e-9, 1.0e-9 and 1.4e-9), not the spreads; RESULTS.json reports them"
+    },
+    {
+     "id": "C3",
+     "severity": "P2 (nit)",
+     "disposition": "applied in v1.4: section 4 states that each entry is rounded from the unrounded coefficients and gives the unrounded sums; the cancellation fraction is tabulated per l; the duplicate workflow paths are removed; the checker docstring and the RESULTS object are v1.4"
+    },
+    {
+     "id": "S1",
+     "severity": "P1",
+     "disposition": "applied in v1.4: the reviewer's wording (c2 certified for the Gaussian kernel by #223; the torus transfer is the author-side candidate #232; c1 certified by #219), in NOTE sections 0 and 4 and README; the PR body is rewritten at the v1.4 push"
+    },
+    {
+     "id": "S2",
+     "severity": "P1",
+     "disposition": "applied in v1.4: no discharge wording; #220 and #229 prove the elder law at candidate status, with #187 (NOTE header, Disposition, section 0; README; the PR body is rewritten at the v1.4 push)"
+    },
+    {
+     "id": "S3",
+     "severity": "P2",
+     "disposition": "applied in v1.4: the candidate law is (T+.1), with B_{d,L} and I^cand; the adjacent-pair density is listed under what remains formal"
+    },
+    {
+     "id": "S4",
+     "severity": "P2",
+     "disposition": "applied in v1.4: #187 is bound in cited_only (blob 07260114); the PR body is rewritten at the v1.4 push"
+    },
+    {
+     "id": "S5",
+     "severity": "P2",
+     "disposition": "applied in v1.4: the d = 1 law is #214 Theorem 1D, an open PR, and is stated as conditional on it"
+    }
+   ],
+   "applied_in": "v1.4"
+  },
+  {
+   "reviewer": "xAI / Grok (Cursor); same GitHub account; organizational independence 0",
+   "review": "pullrequestreview-5401550768",
+   "claim": "5970730805",
+   "at": "7e97018",
+   "scope": "Slice D (NOTE sections 3-4, README Monte Carlo and SIDE24 paragraphs, SOURCES exploration entries)",
+   "verdict": "COMMENT: no blocker; D-1 and D-2 to fix or answer, D-3 to D-6 minor; U-1 fail-closed (the Monte Carlo is not replayable from the repository)",
+   "findings": [
+    {
+     "id": "U-1",
+     "severity": "unverifiable",
+     "disposition": "acknowledged: the Monte Carlo stays exploration outside the repository, pinned by sha256 (exploration_outside_repository); v1.4 also pins the raw records (raw_records_outside_project_archive; kept in the session workspace, not in the project archive)"
+    },
+    {
+     "id": "D-1",
+     "severity": "issue",
+     "disposition": "applied in v1.4: the l^(1/2) reading is withdrawn; other powers fit comparably (#240 section 7 item 4; #237 Remark 4); the origin of the residual is open; the Monte Carlo supports the three-term law at about 1% on [1e-4, 1e-2] only"
+    },
+    {
+     "id": "D-2",
+     "severity": "issue",
+     "disposition": "applied in v1.4: the adjacent-pair columns and the rejected-adjacent coefficient are labelled as checks of formal coefficients (#218 Remark 3; #237 Remark 4)"
+    },
+    {
+     "id": "D-3",
+     "severity": "minor",
+     "disposition": "applied in v1.4: the d = 3 saddle reference is 436.25 (BBKS); error bars from the raw records: maxima 142.99 +- 0.24, minima 142.52 +- 0.24, saddles 436.20 +- 0.49 and 436.67 +- 0.50; d = 2 saddles 752.70 +- 0.25"
+    },
+    {
+     "id": "D-4",
+     "severity": "minor",
+     "disposition": "applied in v1.4: the expected close pairs in the dense-seed regions (11.5 and 0.66 with l < 1e-2) and the reliance on the partner search in d = 3 are stated"
+    },
+    {
+     "id": "D-5",
+     "severity": "minor",
+     "disposition": "applied in v1.4: the window table gives counts; exact 95% intervals for the two lowest d = 3 rows; README wording restricted to d = 2 ranges with enough pairs; v1.4.1 (C129-R1): the intervals are labelled nominal 95% binomial counting intervals (Clopper-Pearson, pairs treated as independent); their coverage under within-field dependence is not assessed"
+    },
+    {
+     "id": "D-6",
+     "severity": "minor",
+     "disposition": "applied in v1.4: the cancellation fraction 0.761 l^(1/12) is given per l (29%, 35%, 43%, 52%); README no longer drops the qualifier, and the PR body is rewritten at the v1.4 push"
+    },
+    {
+     "id": "bins",
+     "severity": "request",
+     "disposition": "applied in v1.4: the bins are selected by geometric centre; the spans are [8.57e-5, 9.65e-3] (11 bins) and [8.57e-5, 3.50e-2] (14 bins)"
+    }
+   ],
+   "applied_in": "v1.4"
+  },
+  {
+   "reviewer": "xAI / Grok agent 3; same GitHub account; organizational independence 0",
+   "review": "pullrequestreview-5401560065",
+   "claim": "5970734766",
+   "at": "7e97018",
+   "scope": "Slice B, NOTE section 2.2 (typed indicator to fixed-cone surrogate)",
+   "verdict": "COMMENT: B-1, B-3 PASS_SCOPED; B-2, B-5 PASS_SCOPED + AMEND; B-4 AMEND (not uniform in small k)",
+   "findings": [
+    {
+     "id": "XA-216-B-01",
+     "severity": "amendment",
+     "disposition": "applied in v1.4: the domain is stated; #218 Lemma F, Step F2, (2.3) and the surrogate paragraph are cited with the bound O(r^3 (1 + 1/k)); the boundary shift is O(rT(1 + T/k)) (#218's upsilon) and the layer wording is corrected"
+    },
+    {
+     "id": "XA-216-B-02",
+     "severity": "amendment",
+     "disposition": "applied in v1.4: the non-uniformity in small k and the order-r^2 cusp correction for k <~ r are stated"
+    },
+    {
+     "id": "XA-216-B-03",
+     "severity": "amendment",
+     "disposition": "applied in v1.4: the kernel scope is stated (any [P] covariance in d >= 2 via Lemma F; the d = 3 isotropy and 2/0/1 covariance are reference-phi facts; d = 1 is a fixed-k sketch)"
+    }
+   ],
+   "applied_in": "v1.4"
+  },
+  {
+   "reviewer": "xAI / Grok agent 3; same GitHub account; organizational independence 0",
+   "review": "pullrequestreview-5401592048",
+   "claim": "5970863484",
+   "at": "7e97018",
+   "scope": "Slice B, NOTE sections 2.1 and 2.3 (completing Slice B)",
+   "verdict": "COMMENT: B-8, B-9, B-11, B-13 PASS; B-10, B-14 PASS_SCOPED + AMEND; B-12 PASS + AMEND",
+   "findings": [
+    {
+     "id": "XA-216-B-04",
+     "severity": "amendment",
+     "disposition": "applied in v1.4: truncation stated per dimension; the d = 3 comparison N = 8 against N = 10 was reproduced (c2 shift -1.16e-11; pointwise 2.3e-13 at r = 0.011, 2.2e-14 at r = 0.007); v1.3's bound is withdrawn for d = 3"
+    },
+    {
+     "id": "XA-216-B-05",
+     "severity": "amendment",
+     "disposition": "applied in v1.4: the b-integral of (0.1) is at k = 0; the k-dependent term is the cusp component; #214 section 2(d) is cited for the definition of B2^(2)"
+    },
+    {
+     "id": "XA-216-B-06",
+     "severity": "amendment",
+     "disposition": "applied in v1.4: the coordinate map is written out; the identification consumes #214 Lemma 1.3 (open) and is checked numerically (T1-T2; the reviewer's pointwise check); the d = 1 law is conditional on #214"
+    }
+   ],
+   "applied_in": "v1.4"
+  },
+  {
+   "reviewer": "OpenAI/Codex /root with /root/next_math_triage, /root/c99_custody_audit, /root/next_ui_triage (C129); same GitHub account; organizational independence 0",
+   "review": "pullrequestreview-5404127976",
+   "claim": "5976154917",
+   "delivery": "5976349213",
+   "at": "e475107",
+   "scope": "successor readback of the v1.4 changed bytes (1bfdf28 over 7e97018)",
+   "verdict": "AMEND_SCOPED: three P2 amendments, one optional display correction; no coefficient or checker defect",
+   "findings": [
+    {
+     "id": "C129-A1",
+     "severity": "P2",
+     "disposition": "applied in v1.4.1: section 2.2 states 2/0/1 as the contact limit and the finite-r covariance 2 + s, s, 1 with s = Var(f(0) | U_r) = r^8/6144 + O(r^10) (checked at 60 digits); rotation invariance and the checker are unaffected"
+    },
+    {
+     "id": "C129-A2",
+     "severity": "P2",
+     "disposition": "applied in v1.4.1: NOTE and README separate numerical inputs (none consumed; the checker implements [R] directly) from the analytic identifications (#214 Lemma 1.3, #218 (F.2), #218 Lemma O with #220 Lemma O-prime); the PR body is rewritten; consumed/consumed_unmerged keep their runtime meaning"
+    },
+    {
+     "id": "C129-R1",
+     "severity": "P2",
+     "disposition": "applied in v1.4.1: the two d = 3 window intervals are labelled nominal binomial counting intervals with coverage under within-field dependence not assessed; the D-5 disposition is synchronized; U-1 stands"
+    },
+    {
+     "id": "C129-N1",
+     "severity": "optional",
+     "disposition": "applied in v1.4.1: 355/19215 is printed as 1.8%"
+    }
+   ],
+   "applied_in": "v1.4.1"
+  },
+  {
+   "reviewer": "Grok Bot agent 1, a Cursor-hosted Grok Bot support agent (non-Claude); original Slice A/C reviewer, so a confirming re-read; same GitHub account; organizational independence 0",
+   "review": "comment 5976332101",
+   "claim": "5976273625",
+   "at": "e475107",
+   "scope": "confirming readback of v1.4, Slices A and C and the status text",
+   "verdict": "AMEND (scoped; no blocker): all eleven findings of 5401553740 RESOLVED; one required change (= C129-A2)",
+   "findings": [
+    {
+     "id": "N6-1",
+     "severity": "P2 (= C129-A2)",
+     "disposition": "applied in v1.4.1: the reviewer's sentence is used, with #214 now recorded as merged"
+    },
+    {
+     "id": "N6-2",
+     "severity": "P3 (optional)",
+     "disposition": "applied in v1.4.1: \"the d = 1 comparison with #214\" in README and NOTE section 7"
+    },
+    {
+     "id": "C129-N1 (concur)",
+     "severity": "P3",
+     "disposition": "applied in v1.4.1"
+    }
+   ],
+   "applied_in": "v1.4.1"
+  }
+ ],
+ "status_updates": [
+  {
+   "version": "v1.3",
+   "files_changed": [
+    "NOTE.md",
+    "README.md",
+    "SOURCES.json",
+    ".github/workflows/third-order-coefficient.yml"
+   ],
+   "unchanged": [
+    "c2_check.py",
+    "RESULTS.json"
+   ],
+   "what": "merged status of #191/#207/#218; the expansion proved at candidate status by #218/#220/#229; c2 certified by #223 and transferred by #232; c1 by #219; xAI P2/P3 answered; Theorem 1D labels; #214 rebound to v1.3"
+  },
+  {
+   "version": "v1.4",
+   "files_changed": [
+    "NOTE.md",
+    "README.md",
+    "SOURCES.json",
+    "c2_check.py",
+    "RESULTS.json",
+    ".github/workflows/third-order-coefficient.yml"
+   ],
+   "unchanged_values": "every coefficient, control value and Monte Carlo ratio; RESULTS.json gains only the #223 comparison fields and the v1.4 object label",
+   "what": "answers the four nonauthor reviews at 7e97018 (5401553740, 5401550768, 5401560065, 5401592048); see nonauthor_reviews"
+  },
+  {
+   "version": "v1.4.1",
+   "files_changed": [
+    "NOTE.md",
+    "README.md",
+    "SOURCES.json",
+    ".github/workflows/third-order-coefficient.yml"
+   ],
+   "unchanged": [
+    "c2_check.py",
+    "RESULTS.json"
+   ],
+   "what": "answers C129 (5404127976) and Grok Bot agent 1 (5976332101); #214 (e4ca2b3) and #237 (cb73b11) merged with their pinned blobs and now bound from the tree"
+  }
+ ],
+ "raw_records_outside_project_archive": [
+  {
+   "path": "session scratchpad sim3d/batch3B.npz (d = 3, 1000 samples; not mirrored to the project archive, size)",
+   "bytes": 3580675,
+   "sha256": "20f53f39aaaf5da6f073f3f6223e45e4177df149a688f1954079043e5bb3461b",
+   "use": "v1.4 (D-3): per-sample critical-point counts by index, for the Kac-Rice error bars of NOTE section 3"
+  },
+  {
+   "path": "session scratchpad sim2d/batchA2.npz (d = 2, 4000 samples; not mirrored to the project archive, size)",
+   "bytes": 26880641,
+   "sha256": "d34030095cbeaf4b6ff2810d89f2828c13c28d617734ae8dfb9f425b7cd4340e",
+   "use": "v1.4 (D-3): per-sample critical-point counts, for the Kac-Rice error bars of NOTE section 3"
+  }
+ ]
+}
diff --git a/frontiers/third_order_coefficient_20261001/c2_check.py b/frontiers/third_order_coefficient_20261001/c2_check.py
new file mode 100644
index 000000000..83ef5527d
--- /dev/null
+++ b/frontiers/third_order_coefficient_20261001/c2_check.py
@@ -0,0 +1,576 @@
+#!/usr/bin/env python3
+"""Controls for CL-THIRD-ORDER-COEFF-20261001-v1.4 (frontiers/third_order_coefficient_20261001/NOTE.md).
+Standard library only. Run: python3 -B -S c2_check.py   (and with -O; output byte-identical). v1.1: every float sum is
+math.fsum (exactly rounded; the built-in sum of floats changed in CPython 3.12) and the r-fit uses the scaled variable
+r/max(r), so the output is the same on CPython 3.10-3.14 (checked). v1.2 (Codex P2 on v1.1): T4 runs at a refined grid
+and compares with the former production grid and with the second r-set (v1.1's coarse comparison grid under-resolved
+the height integral: 32 nodes in b moved c2 by 4.5e-8). v1.4 (nonauthor Slice C finding C1, review 5401553740): T1, T3
+and T4 also compare every computed c2 with the closed form of the merged Math- #223 (frontiers/c2_exact_20261001/NOTE.md
+section 0), to 1e-8 absolute, and report the observed error; each closed form is first checked to lie in #223's
+certified interval. The mutants now fail on computed checks only (v1.3 forced the M1 failure of T6 and the M2 failure
+of T5 by hand).
+Mutants: --mutant M1|M2|M3|M4 must exit 1; an unknown label exits 2.
+
+The two-point kernel of [R] (frontiers/three_fronts_20260924/LIFETIME_REMAINDER.md):
+    A_r(b, k, u) = 12 pi_r(v_r) E[|det H_M| |det H_S| 1{typed} | U_r = v_r] / r^2,
+symmetric pin vector U_r and target v_r = (b - k r^3/2, -k r^2, 0, 12k, 0, ..., 0).  At fixed (b, k):
+A_r = A_0 + r^2 A_2 + O(r^3).  The fold-scale finite part gives
+    c  = (1/3)|S^{d-1}| int db int A_0(b,k) k^{-2/3} dk,
+    c2 = (1/3)|S^{d-1}| f.p. int db int A_2(b,k) k^{-4/3} dk = (1/3)|S^{d-1}| int db int [A_2(b,k) - A_2(b,0)] k^{-4/3} dk.
+
+  T1 d = 1, Gaussian kernel: c = C0 and c2 = 2 B2 of Math- #214 (closed forms); c2 within 1e-8 of #223's closed form
+  T2 d = 1, mixture (exp(-x^2/2) + exp(-2x^2))/2: c = C0 and c2 = 2 B2 (closed forms of #214, general spectral moments)
+  T3 d = 2, Gaussian kernel: c = c_{2,inf} (merged reviews/side24_v1_coefficient_claude_20260929); c2 from two r-sets,
+     each within 1e-8 of #223's closed form
+  T4 d = 3, Gaussian kernel: c = c_{3,inf} = c_{3,24}(1 + O(e^{-288})) (merged coefficients/side24_v1); c2 at the grid
+     (b 56, k 120, cone 48^2), at the grid (40, 80, 32^2) and from the second r-set, each within 1e-8 of #223's closed form
+  T5 the expansion A_r = A_0 + r^2 A_2 + O(r^3) has no r^1 term (d = 2, 3, three test points each)
+  T6 the subtracted term is the small-s limit of the cusp loss: A_2(b, 0) = -12 pi_0 E_0[Y^2 1{A<0} | b] (d = 2)
+
+Numerics: conditioning in Decimal (prec 50), then floats; Gauss-Legendre quadrature; the r^2 coefficient by least squares
+over five separations. Typed indicator: d = 1 none needed (exponentially small at fixed k); d = 2 1{f_yy(0) < 0};
+d = 3 1{D_y^2 f(0) < 0} (2x2), the conditional expectation evaluated at A = diag(l1, l2) and integrated in eigenvalue
+coordinates (transverse rotation invariance). These replacements change A_r by O(r^3) at fixed k.
+"""
+import argparse
+import itertools
+import json
+import math
+import sys
+from decimal import Decimal, getcontext
+
+getcontext().prec = 50
+MUTANT = None
+
+
+# ----------------------------------------------------------------------------------------------- small linear algebra
+def dfact(n):
+    out = 1
+    while n > 1:
+        out *= n
+        n -= 2
+    return out
+
+
+def rho_der(kernel, g):
+    """d^g rho(0) for rho = exp(-|z|^2/2) ('gauss') or (exp(-x^2/2) + exp(-2x^2))/2 ('mix', d = 1)"""
+    if any(x % 2 for x in g):
+        return 0
+    if kernel == 'gauss':
+        out = 1
+        for x in g:
+            out *= (-1) ** (x // 2) * dfact(x - 1)
+        return out
+    (x,) = g
+    m = x // 2
+    return Decimal((-1) ** m * dfact(x - 1) * (1 + 4 ** m)) / 2
+
+
+def gauss_jordan_inv(A):
+    n = len(A)
+    M = [row[:] + [Decimal(int(i == j)) for j in range(n)] for i, row in enumerate(A)]
+    det = Decimal(1)
+    for c in range(n):
+        p = max(range(c, n), key=lambda i: abs(M[i][c]))
+        if p != c:
+            M[c], M[p] = M[p], M[c]
+            det = -det
+        piv = M[c][c]
+        det *= piv
+        M[c] = [x / piv for x in M[c]]
+        for i in range(n):
+            if i != c and M[i][c] != 0:
+                f = M[i][c]
+                M[i] = [a - f * b for a, b in zip(M[i], M[c])]
+    return [row[n:] for row in M], det
+
+
+def gauss_legendre(n):
+    xs, ws = [], []
+    for i in range(1, n + 1):
+        x = math.cos(math.pi * (i - 0.25) / (n + 0.5))
+        for _ in range(100):
+            p0, p1 = 1.0, x
+            for k in range(2, n + 1):
+                p0, p1 = p1, ((2 * k - 1) * x * p1 - (k - 1) * p0) / k
+            dp = n * (x * p1 - p0) / (x * x - 1)
+            dx = p1 / dp
+            x -= dx
+            if abs(dx) < 1e-16:
+                break
+        xs.append(x)
+        ws.append(2 / ((1 - x * x) * dp * dp))
+    return xs, ws
+
+
+# ----------------------------------------------------------------------------------------------- the pinned structure
+_SIG_CACHE = {}
+
+
+class Pinned:
+    """jets at 0 up to total order N, pin rows of [R] section 2 at separation r along e_1, Gaussian conditioning"""
+
+    def __init__(self, d, N, r, kernel, forms):
+        self.d, self.N, self.r = d, N, Decimal(r)
+        self.J = [a for n in range(N + 1) for a in itertools.product(range(n + 1), repeat=d) if sum(a) == n]
+        self.idx = {a: i for i, a in enumerate(self.J)}
+        key = (d, N, kernel)
+        if key not in _SIG_CACHE:
+            S = [[Decimal(0)] * len(self.J) for _ in self.J]
+            for i, a in enumerate(self.J):
+                for j, b in enumerate(self.J):
+                    v = rho_der(kernel, tuple(x + y for x, y in zip(a, b)))
+                    if v:
+                        S[i][j] = Decimal(v) * (-1) ** sum(b)
+            _SIG_CACHE[key] = S
+        self.Sig = _SIG_CACHE[key]
+        rows = self.pin_rows()
+        n = len(self.J)
+        MS = [[sum(row[t] * self.Sig[t][j] for t in range(n) if row[t]) for j in range(n)] for row in rows]
+        S = [[sum(MS[i][t] * rows[j][t] for t in range(n) if rows[j][t]) for j in range(len(rows))] for i in range(len(rows))]
+        Sinv, detS = gauss_jordan_inv(S)
+        self.p = len(rows)
+        self.Sinv = [[float(x) for x in row] for row in Sinv]
+        self.detS = float(detS)
+        G = [[sum(MS[q][i] * Sinv[q][j] for q in range(self.p)) for j in range(self.p)] for i in range(n)]   # Sig M^T S^-1
+        self.cov, self.mcoef = {}, {}
+        names = list(forms)
+        vec = {u: self.deriv_at(*forms[u]) for u in names}
+        Sv = {u: [sum(self.Sig[i][t] * vec[u][t] for t in range(n) if vec[u][t]) for i in range(n)] for u in names}
+        MSv = {u: [sum(MS[q][t] * vec[u][t] for t in range(n) if vec[u][t]) for q in range(self.p)] for u in names}
+        cG = {u: [sum(vec[u][t] * G[t][j] for t in range(n) if vec[u][t]) for j in range(self.p)] for u in names}
+        for i, u in enumerate(names):
+            self.mcoef[u] = [float(x) for x in cG[u]]
+            for w in names[i:]:
+                val = sum(vec[u][t] * Sv[w][t] for t in range(n) if vec[u][t]) - sum(cG[u][q] * MSv[w][q] for q in range(self.p))
+                self.cov[(u, w)] = self.cov[(w, u)] = float(val)
+
+    def deriv_at(self, beta, x):
+        """vector over the jets of d^beta f at x e_1 (Taylor at 0, truncated at total order N)"""
+        x = Decimal(x)
+        c = [Decimal(0)] * len(self.J)
+        j, xp, fac = 0, Decimal(1), 1
+        while True:
+            a = (beta[0] + j,) + tuple(beta[1:])
+            if sum(a) > self.N:
+                break
+            c[self.idx[a]] += xp / fac
+            j += 1
+            xp *= x
+            fac *= j
+        return c
+
+    def pin_rows(self):
+        d, r = self.d, self.r
+        e0, ex = (0,) * d, (1,) + (0,) * (d - 1)
+        a, c = -r / 2, r / 2
+        f_a, f_c, fx_a, fx_c = self.deriv_at(e0, a), self.deriv_at(e0, c), self.deriv_at(ex, a), self.deriv_at(ex, c)
+        n = len(self.J)
+        rows = [[(f_a[t] + f_c[t]) / 2 for t in range(n)], [(f_c[t] - f_a[t]) / r for t in range(n)],
+                [(fx_c[t] - fx_a[t]) / r for t in range(n)],
+                [6 / (r * r) * (fx_a[t] + fx_c[t] - 2 * (f_c[t] - f_a[t]) / r) for t in range(n)]]
+        for s in range(1, d):
+            ey = tuple(1 if i == s else 0 for i in range(d))
+            ya, yc = self.deriv_at(ey, a), self.deriv_at(ey, c)
+            rows += [[(ya[t] + yc[t]) / 2 for t in range(n)], [(yc[t] - ya[t]) / r for t in range(n)]]
+        return rows
+
+    def target(self, b, k):
+        r = float(self.r)
+        return [b - k * r ** 3 / 2, -k * r * r, 0.0, 12 * k] + [0.0] * (2 * (self.d - 1))
+
+    def pi(self, v):
+        q = math.fsum(v[i] * self.Sinv[i][j] * v[j] for i in range(self.p) for j in range(self.p))
+        return (2 * math.pi) ** (-self.p / 2) / math.sqrt(self.detS) * math.exp(-q / 2)
+
+    def mean(self, u, v):
+        return math.fsum(c * x for c, x in zip(self.mcoef[u], v))
+
+
+# ----------------------------------------------------------------------------------------------- polynomials
+def pmul(p, q):
+    out = {}
+    for e1, c1 in p.items():
+        for e2, c2 in q.items():
+            e = tuple(x + y for x, y in zip(e1, e2))
+            out[e] = out.get(e, 0.0) + c1 * c2
+    return out
+
+
+def matchings(lst):
+    if not lst:
+        yield []
+        return
+    first, rest = lst[0], lst[1:]
+    for mm in matchings(rest):
+        yield mm
+    for i, x in enumerate(rest):
+        for mm in matchings(rest[:i] + rest[i + 1:]):
+            yield [(first, x)] + mm
+
+
+def isserlis_poly(factors, aff, cov, nv):
+    """E[prod (m_i + eps_i)] with affine means aff[i] (dict exponent -> coef) and covariance cov(i, j)"""
+    total = {}
+    zero = (0,) * nv
+    n = len(factors)
+    cache = {}
+
+    def prod(us):
+        key = tuple(sorted(us))
+        if key not in cache:
+            res = {zero: 1.0}
+            for u in key:
+                res = pmul(res, aff[u])
+            cache[key] = res
+        return cache[key]
+    for mt in matchings(list(range(n))):
+        c = 1.0
+        used = set()
+        for (a, b) in mt:
+            c *= cov(factors[a], factors[b])
+            used.update((a, b))
+        if c == 0.0:
+            continue
+        for e, v in prod([factors[i] for i in range(n) if i not in used]).items():
+            total[e] = total.get(e, 0.0) + c * v
+    return total
+
+
+# ----------------------------------------------------------------------------------------------- kernels
+def forms_for(d, r):
+    rf = Decimal(r)
+    xM, xS = -rf / 2, rf / 2
+    if d == 1:
+        return {'hM': ((2,), xM), 'hS': ((2,), xS)}
+    if d == 2:
+        f = {}
+        for nm, x in (('M', xM), ('S', xS)):
+            f['xx' + nm], f['xy' + nm], f['yy' + nm] = ((2, 0), x), ((1, 1), x), ((0, 2), x)
+        f['a'] = ((0, 2), Decimal(0))
+        return f
+    f = {}
+    for nm, x in (('M', xM), ('S', xS)):
+        for (i, j) in ((0, 0), (0, 1), (0, 2), (1, 1), (1, 2), (2, 2)):
+            beta = [0, 0, 0]
+            beta[i] += 1
+            beta[j] += 1
+            f[(nm, i, j)] = (tuple(beta), x)
+    f['a11'], f['a12'], f['a22'] = ((0, 2, 0), Decimal(0)), ((0, 1, 1), Decimal(0)), ((0, 0, 2), Decimal(0))
+    return f
+
+
+class Kernel:
+    def __init__(self, d, N, r, kernel):
+        self.d, self.r = d, float(r)
+        self.P = Pinned(d, N, r, kernel, forms_for(d, r))
+        if d == 2:
+            self.setup2()
+        if d == 3:
+            self.setup3()
+
+    # d = 2: E[X Y 1{a<0}], X = det H_M, Y = -det H_S; conditioning on a
+    def setup2(self):
+        P = self.P
+        self.terms = [(+1, ('xxM', 'yyM', 'xxS', 'yyS')), (-1, ('xxM', 'yyM', 'xyS', 'xyS')),
+                      (-1, ('xyM', 'xyM', 'xxS', 'yyS')), (+1, ('xyM', 'xyM', 'xyS', 'xyS'))]
+        sa2 = P.cov[('a', 'a')]
+        self.sa2 = sa2
+        self.beta = {u: P.cov[(u, 'a')] / sa2 for u in P.mcoef if u != 'a'}
+        self.cp = {(u, w): P.cov[(u, w)] - self.beta[u] * self.beta[w] * sa2 for u in self.beta for w in self.beta}
+
+    def Z2(self, v):
+        P = self.P
+        ma = P.mean('a', v)
+        mu = {u: P.mean(u, v) for u in self.beta}
+        s = math.sqrt(self.sa2)
+        cc = -ma
+        phi = math.exp(-cc * cc / (2 * self.sa2)) / (s * math.sqrt(2 * math.pi))
+        T = [0.5 * math.erfc(-cc / (s * math.sqrt(2))), -self.sa2 * phi]
+        for n in range(2, 5):
+            T.append((n - 1) * self.sa2 * T[n - 2] - self.sa2 * cc ** (n - 1) * phi)
+        tot = 0.0
+        for sgn, nm in self.terms:
+            aff = {i: {(0,): mu[u], (1,): self.beta[u]} for i, u in enumerate(nm)}
+            poly = isserlis_poly(list(range(4)), aff, lambda i, j: self.cp[(nm[i], nm[j])], 1)
+            tot += sgn * math.fsum(c * T[e[0]] for e, c in poly.items())
+        return -tot
+
+    # d = 3: polynomial in (b_eff, k, l1, l2) of E[det H_M det H_S | A = diag(l1, l2)]
+    def setup3(self):
+        P = self.P
+        al = ['a11', 'a12', 'a22']
+        C = [[P.cov[(a, b)] for b in al] for a in al]
+        det = (C[0][0] * (C[1][1] * C[2][2] - C[1][2] * C[2][1]) - C[0][1] * (C[1][0] * C[2][2] - C[1][2] * C[2][0])
+               + C[0][2] * (C[1][0] * C[2][1] - C[1][1] * C[2][0]))
+        inv = [[(C[(j + 1) % 3][(i + 1) % 3] * C[(j + 2) % 3][(i + 2) % 3] - C[(j + 1) % 3][(i + 2) % 3] * C[(j + 2) % 3][(i + 1) % 3]) / det
+                for j in range(3)] for i in range(3)]
+        self.Caa_inv, self.Caa_det = inv, det
+        hn = [u for u in P.mcoef if u not in al]
+        B = {u: [math.fsum(P.cov[(u, al[j])] * inv[j][i] for j in range(3)) for i in range(3)] for u in hn}
+        self.cp3 = {(u, w): P.cov[(u, w)] - math.fsum(B[u][i] * P.cov[(al[i], w)] for i in range(3)) for u in hn for w in hn}
+        r = self.r
+
+        def kcoef(u):    # coefficient of k in the conditional mean: v = (b_eff, -k r^2, 0, 12k, 0, ...)
+            mc = P.mcoef[u]
+            return -mc[1] * r * r + 12 * mc[3]
+        self.mu_a = [(P.mcoef[a][0], kcoef(a)) for a in al]
+        if max(abs(m1) for (_, m1) in self.mu_a) > 1e-20:       # parity: the transverse block does not see k
+            raise RuntimeError('k-dependence of the transverse mean')
+        aff = {}
+        for u in hn:
+            cb = P.mcoef[u][0] - math.fsum(B[u][j] * P.mcoef[al[j]][0] for j in range(3))
+            ck = kcoef(u) - math.fsum(B[u][j] * kcoef(al[j]) for j in range(3))
+            aff[u] = {(1, 0, 0, 0): cb, (0, 1, 0, 0): ck, (0, 0, 1, 0): B[u][0], (0, 0, 0, 1): B[u][2]}
+        perms = list(itertools.permutations(range(3)))
+
+        def sgn(p):
+            return 1 if sum(1 for i in range(3) for j in range(i + 1, 3) if p[i] > p[j]) % 2 == 0 else -1
+        poly = {}
+        for p in perms:
+            for q in perms:
+                fac = [('M', min(i, p[i]), max(i, p[i])) for i in range(3)] + [('S', min(i, q[i]), max(i, q[i])) for i in range(3)]
+                part = isserlis_poly(fac, aff, lambda x, y: self.cp3[(x, y)], 4)
+                s = sgn(p) * sgn(q)
+                for e, c in part.items():
+                    poly[e] = poly.get(e, 0.0) + s * c
+        self.poly3 = poly
+
+    def cone_moments(self, beff, k, nq):
+        """M_ij = pi * int_{l2<l1<0} l1^i l2^j p_A(diag(l1, l2)) (l1 - l2) dl, i + j <= 6"""
+        mu = [m0 * beff + m1 * k for (m0, m1) in self.mu_a]
+        inv = self.Caa_inv
+        norm = 1 / ((2 * math.pi) ** 1.5 * math.sqrt(self.Caa_det))
+        Smax = 10 + 1.2 * abs(mu[0])
+        xs, ws = gauss_legendre(nq)
+        M = {}
+        for x1, w1 in zip(xs, ws):
+            s = Smax * (x1 + 1) / 2
+            for x2, w2 in zip(xs, ws):
+                t = Smax * (x2 + 1) / 2
+                l1, l2 = -s, -s - t
+                z = (l1 - mu[0], -mu[1], l2 - mu[2])
+                q = math.fsum(z[i] * inv[i][j] * z[j] for i in range(3) for j in range(3))
+                w = w1 * w2 * (Smax / 2) ** 2 * norm * math.exp(-q / 2) * (l1 - l2) * math.pi
+                for i in range(7):
+                    for j in range(7 - i):
+                        M[(i, j)] = M.get((i, j), 0.0) + w * l1 ** i * l2 ** j
+        return M
+
+    def Z3(self, beff, k, M):
+        tot = 0.0
+        for (eb, ek, e1, e2), c in self.poly3.items():
+            tot += c * beff ** eb * k ** ek * M[(e1, e2)]
+        return -tot
+
+    def A(self, b, k, moments=None):
+        P = self.P
+        if self.d == 3:
+            beff = b
+            v = P.target(beff + k * self.r ** 3 / 2, k)
+            return 12 * P.pi(v) * self.Z3(beff, k, moments) / self.r ** 2
+        v = P.target(b, k)
+        if self.d == 1:
+            Z = -(P.mean('hM', v) * P.mean('hS', v) + P.cov[('hM', 'hS')])
+        else:
+            Z = self.Z2(v)
+        return 12 * P.pi(v) * Z / self.r ** 2
+
+
+def coefficients(d, kernel, N, rs, nb=48, nt=80, nq=28, K=8.0):
+    """c and c2 by the fold-scale finite part"""
+    ks = [Kernel(d, N, r, kernel) for r in rs]
+    rf = [float(r) for r in rs]
+    rmax = max(rf)
+    basis = [[1.0, (r / rmax) ** 2, (r / rmax) ** 3, (r / rmax) ** 4] for r in rf]      # scaled: well conditioned
+    if MUTANT == 'M2':
+        basis = [[1.0, (r / rmax) ** 3, (r / rmax) ** 2, (r / rmax) ** 4] for r in rf]
+    # least-squares rows for the first two coefficients
+    XtX = [[math.fsum(basis[i][a] * basis[i][b] for i in range(len(rf))) for b in range(4)] for a in range(4)]
+    inv, _ = gauss_jordan_inv([[Decimal(x) for x in row] for row in XtX])
+    inv = [[float(x) for x in row] for row in inv]
+    W = [[math.fsum(inv[a][c] * basis[i][c] for c in range(4)) / (1.0 if a == 0 else rmax ** 2) for i in range(len(rf))]
+         for a in range(2)]
+    B, T = 8.0, K ** (1 / 3)
+    xb, wb = gauss_legendre(nb)
+    xt, wt = gauss_legendre(nt)
+    sphere = {1: 2.0, 2: 2 * math.pi, 3: 4 * math.pi}[d]
+    if MUTANT == 'M3' and d == 2:
+        sphere = math.pi
+    c = c2 = tail = 0.0
+    for xi, wi in zip(xb, wb):
+        b = B * xi
+        mom = [kk.cone_moments(b, 0.0, nq) for kk in ks] if d == 3 else [None] * len(ks)
+        vals0 = [kk.A(b, 0.0, m) for kk, m in zip(ks, mom)]
+        A20 = math.fsum(W[1][i] * vals0[i] for i in range(len(rf)))
+        tail += B * wi * (-A20)
+        for xj, wj in zip(xt, wt):
+            t = T * (xj + 1) / 2
+            k = t ** 3
+            vals = [kk.A(b, k, m) for kk, m in zip(ks, mom)]
+            A0 = math.fsum(W[0][i] * vals[i] for i in range(len(rf)))
+            A2 = math.fsum(W[1][i] * vals[i] for i in range(len(rf)))
+            w = B * wi * T * wj / 2
+            c += w * 3 * A0
+            if MUTANT == 'M1':
+                c2 += w * 3 * A2 / t ** 2
+            else:
+                c2 += w * 3 * (A2 - A20) / t ** 2
+    c *= sphere / 3
+    c2 = c2 * sphere / 3 + (0.0 if MUTANT == 'M4' else sphere * T ** -1 * tail)
+    return c, c2
+
+
+# ----------------------------------------------------------------------------------------------- closed forms of #214
+def d1_closed(kernel):
+    if kernel == 'gauss':
+        l2, l4, l6, l8 = 1.0, 3.0, 15.0, 105.0
+    else:
+        l2, l4, l6, l8 = 2.5, 25.5, 487.5, 13492.5
+    D = l2 * l6 - l4 * l4
+    s3 = math.sqrt(D / l2)
+    p12 = 1 / (2 * math.pi * math.sqrt(l2 * l4))
+    C0 = 2 * 72 ** (-1 / 6) * math.gamma(7 / 6) * (2 * math.pi) ** -0.5 * p12 * s3 ** (4 / 3)
+    Q = 4 * l2 ** 2 * l4 * l8 + 26 * l2 * l4 ** 2 * l6 - 5 * l2 ** 2 * l6 ** 2 - 25 * l4 ** 4
+    B2 = 2 ** 0.5 * 3 ** (1 / 3) * math.gamma(5 / 6) * (2 * math.pi) ** -0.5 * p12 * s3 ** (2 / 3) * Q / (120 * l2 * l4 * D)
+    return C0, 2 * B2
+
+
+# ----------------------------------------------------------------------------------------------- closed forms of #223
+# merged Math- #223, frontiers/c2_exact_20261001/NOTE.md section 0 (Gaussian kernel): the closed forms of c2 and their
+# certified enclosures (interval arithmetic, outward to 16 digits)
+C2_223_INTERVAL = {1: ('0.2300445802661503', '0.2300445802661998'), 2: ('0.2215244106266632', '0.2215244106267110'),
+                   3: ('0.1612340491269447', '0.1612340491269810')}
+
+
+def c2_closed_223(d):
+    g = 12 ** (1 / 6) * math.gamma(5 / 6)
+    if d == 1:
+        val = 0.75 * g / math.pi ** 1.5
+    elif d == 2:
+        val = (13 / 18) * g / math.pi ** 1.5
+    else:
+        val = (5 / 48) * (33 - 7 * math.sqrt(6)) * g / math.pi ** 2.5
+    lo, hi = C2_223_INTERVAL[d]
+    if not float(lo) <= val <= float(hi):           # transcription control: the closed form lies in #223's enclosure
+        raise RuntimeError('closed form of #223 outside its certified interval, d = %d' % d)
+    return val
+
+
+C2INF = 0.073406919306034271030   # reviews/side24_v1_coefficient_claude_20260929 (merged)
+C3INF = 0.04177593184059834334    # coefficients/side24_v1 (merged), c_{3,24} = c_{3,inf}(1 + O(e^{-288}))
+RS = ['0.003', '0.005', '0.007', '0.009', '0.011']
+RS_B = ['0.002', '0.004', '0.006', '0.008']
+RS_D1 = ['0.001', '0.002', '0.003', '0.004', '0.005']
+
+
+def main():
+    global MUTANT
+    ap = argparse.ArgumentParser()
+    ap.add_argument('--mutant', default=None)
+    args = ap.parse_args()
+    if args.mutant is not None and args.mutant not in ('M1', 'M2', 'M3', 'M4'):
+        sys.stderr.write('unknown mutant label\n')
+        return 2
+    MUTANT = args.mutant
+    out = {'object': 'CL-THIRD-ORDER-COEFF-20261001-v1.4 controls', 'scientific_effect': 'NONE', 'mutant': MUTANT, 'checks': {}}
+    ok_all = True
+    for name, kern, K, nt in (('T1_d1_gauss', 'gauss', 8.0, 80), ('T2_d1_mixture', 'mix', 27.0, 120)):
+        c, c2 = coefficients(1, kern, 12, RS_D1, nt=nt, K=K)
+        C0, twoB2 = d1_closed(kern)
+        ok = abs(c / C0 - 1) < 1e-10 and abs(c2 / twoB2 - 1) < 1e-8
+        out['checks'][name] = {'c': '%.12f' % c, 'C0_closed': '%.12f' % C0, 'c2': '%.10f' % c2, '2B2_closed': '%.10f' % twoB2}
+        if kern == 'gauss':     # v1.4: also against the merged closed form of #223 (Gaussian kernel only)
+            cl = c2_closed_223(1)
+            ok = ok and abs(c2 - cl) < 1e-8
+            out['checks'][name].update({'c2_closed_223': '%.10f' % cl, 'c2_minus_closed_223': '%.1e' % (c2 - cl)})
+        out['checks'][name]['passed'] = ok
+        ok_all &= ok
+    cl = c2_closed_223(2)
+    c, c2 = coefficients(2, 'gauss', 10, RS)
+    cb, c2b = coefficients(2, 'gauss', 10, RS_B)
+    ok = abs(c / C2INF - 1) < 1e-10 and abs(c2 - cl) < 1e-8 and abs(c2b - cl) < 1e-8
+    out['checks']['T3_d2_gauss'] = {'c': '%.12f' % c, 'c_2inf': '%.12f' % C2INF, 'c2': '%.10f' % c2, 'c2_second_rset': '%.10f' % c2b,
+                                    'c2_closed_223': '%.10f' % cl, 'c2_minus_closed_223': '%.1e' % (c2 - cl),
+                                    'c2_second_rset_minus_closed_223': '%.1e' % (c2b - cl),
+                                    'c2_over_c': '%.8f' % (c2 / c), 'passed': ok}
+    ok_all &= ok
+    cl = c2_closed_223(3)
+    c, c2 = coefficients(3, 'gauss', 8, RS, nb=56, nt=120, nq=48)
+    c_g, c2_g = coefficients(3, 'gauss', 8, RS, nb=40, nt=80, nq=32)
+    c_r, c2_r = coefficients(3, 'gauss', 8, RS_B, nb=40, nt=80, nq=32)
+    ok = abs(c / C3INF - 1) < 1e-10 and abs(c2 - cl) < 1e-8 and abs(c2_g - cl) < 1e-8 and abs(c2_r - cl) < 1e-8
+    out['checks']['T4_d3_gauss'] = {'c': '%.13f' % c, 'c_3inf': '%.13f' % C3INF, 'c2': '%.10f' % c2,
+                                    'c2_grid_40_80_32': '%.10f' % c2_g, 'c2_second_rset': '%.10f' % c2_r,
+                                    'c2_closed_223': '%.10f' % cl, 'c2_minus_closed_223': '%.1e' % (c2 - cl),
+                                    'c2_grid_40_80_32_minus_closed_223': '%.1e' % (c2_g - cl),
+                                    'c2_second_rset_minus_closed_223': '%.1e' % (c2_r - cl),
+                                    'c2_over_c': '%.8f' % (c2 / c),
+                                    'grids': 'b 56, k 120, cone 48x48; comparisons b 40, k 80, cone 32x32 (both r-sets)',
+                                    'passed': ok}
+    ok_all &= ok
+    # T5: the fold-scale expansion is even at first order (#191): interpolating A_r on (1, r, r^2, r^3, r^4) at the five
+    # separations gives a negligible r^1 coefficient
+    t5 = {}
+    rf = [float(r) for r in RS]
+    rmx5 = Decimal(max(RS, key=Decimal))
+    Xb = [[Decimal(1), Decimal(r) / rmx5, (Decimal(r) / rmx5) ** 2, (Decimal(r) / rmx5) ** 3, (Decimal(r) / rmx5) ** 4] for r in RS]
+    inv, _ = gauss_jordan_inv(Xb)
+    ok5 = True
+    for d, N in ((2, 10), (3, 8)):
+        ks = [Kernel(d, N, r, 'gauss') for r in RS]
+        for (b, k) in ((0.3, 0.7), (-1.0, 0.2), (1.5, 1.3)):
+            mom = [kk.cone_moments(b, 0.0, 32) for kk in ks] if d == 3 else [None] * len(ks)
+            vals = [kk.A(b, k, m) for kk, m in zip(ks, mom)]
+            co = [math.fsum(float(inv[a][i]) * vals[i] for i in range(len(rf))) for a in range(5)]
+            rm = float(rmx5)
+            rel1, rel2 = co[1] / rm / co[0], co[2] / rm ** 2 / co[0]
+            t5['d%d_b%g_k%g' % (d, b, k)] = {'abs_r1_over_A0_below_1e-6': abs(rel1) < 1e-6, 'r2_over_A0': '%.4f' % rel2}
+            ok5 &= abs(rel1) < 1e-6 and abs(rel2) > 1e-2
+    t5['passed'] = bool(ok5)
+    out['checks']['T5_no_r1_term'] = t5
+    ok_all &= ok5
+    # T6: the subtracted term is the cusp loss limit (0.1): A_2(b, 0) = -12 pi_0 E_0[Y^2 1{A<0} | b] in d = 2,
+    # Y = f_xxxx a / 12 - gamma^2 / 4, a = f_yy(0), gamma = f_xxy(0)
+    ks = [Kernel(2, 10, r, 'gauss') for r in RS]
+    rmx = max(float(r) for r in RS)
+    basis = [[1.0, (float(r) / rmx) ** 2, (float(r) / rmx) ** 3, (float(r) / rmx) ** 4] for r in RS]
+    XtX = [[math.fsum(basis[i][a] * basis[i][b] for i in range(len(RS))) for b in range(4)] for a in range(4)]
+    inv4, _ = gauss_jordan_inv([[Decimal(x) for x in row] for row in XtX])
+    inv4 = [[float(x) for x in row] for row in inv4]
+    W2 = [math.fsum(inv4[1][c] * basis[i][c] for c in range(4)) / rmx ** 2 for i in range(len(RS))]
+    P0 = Pinned(2, 10, '0.000001', 'gauss', {'f4': ((4, 0), Decimal(0)), 'g': ((2, 1), Decimal(0)), 'a': ((0, 2), Decimal(0))})
+    xg, wg = gauss_legendre(64)
+    t6, ok6 = {}, True
+    for b in (-1.2, 0.0, 0.7, 2.0):
+        A20 = math.fsum(W2[i] * ks[i].A(b, 0.0) for i in range(len(RS)))
+        v = P0.target(b, 0.0)
+        mu = {u: P0.mean(u, v) for u in ('f4', 'g', 'a')}
+        sa2 = P0.cov[('a', 'a')]
+        s = math.sqrt(sa2)
+        bf, bg = P0.cov[('f4', 'a')] / sa2, P0.cov[('g', 'a')] / sa2
+        vf, vg = P0.cov[('f4', 'f4')] - bf * bf * sa2, P0.cov[('g', 'g')] - bg * bg * sa2
+        cfg = P0.cov[('f4', 'g')] - bf * bg * sa2
+        lo, hi = mu['a'] - 14 * s, min(0.0, mu['a'] + 14 * s)
+        tot = 0.0
+        for x, w in zip(xg, wg):
+            a = lo + (hi - lo) * (x + 1) / 2
+            dens = math.exp(-(a - mu['a']) ** 2 / (2 * sa2)) / (s * math.sqrt(2 * math.pi))
+            mf, mg = mu['f4'] + bf * (a - mu['a']), mu['g'] + bg * (a - mu['a'])
+            eg2 = vg + mg * mg
+            ey2 = (a / 12) ** 2 * (vf + mf * mf) - (a / 24) * (mf * eg2 + 2 * cfg * mg) + (3 * vg * vg + 6 * vg * mg * mg + mg ** 4) / 16
+            tot += w * (hi - lo) / 2 * dens * ey2
+        pred = -12 * P0.pi(v) * tot
+        rel = A20 / pred - 1
+        t6['b%g' % b] = {'A2_b0': '%.8e' % A20, 'loss_limit': '%.8e' % pred, 'agree_1e-6': abs(rel) < 1e-6}
+        ok6 &= abs(rel) < 1e-6
+    t6['passed'] = bool(ok6)
+    out['checks']['T6_overlap_term_d2'] = t6
+    ok_all &= ok6
+    out['passed'] = bool(ok_all)
+    sys.stdout.write(json.dumps(out, indent=1, sort_keys=True) + '\n')
+    return 0 if ok_all else 1
+
+
+if __name__ == '__main__':
+    sys.exit(main())