diff --git a/research/qq16-rounded-transcript-capacity/PROOF.md b/research/qq16-rounded-transcript-capacity/PROOF.md
new file mode 100644
index 0000000000..a426a21b0c
--- /dev/null
+++ b/research/qq16-rounded-transcript-capacity/PROOF.md
@@ -0,0 +1,96 @@
+# Capacity and packing proof
+
+## 1. Quantized observations
+
+Let X be a finite input set and T_p:X -> R^m any deterministic map. Neither
+linearity, continuity nor a computational bound is assumed. Each component
+belongs to2^-(p+g) Z and has absolute value at most R*2^-p, for integers p,g>=0
+and R>=0. A separate record h_p(x) has at most D states. The decoder receives
+only(T_p(x),h_p(x)) and input-independent parameters including p.
+
+Each component's integer numerator lies in[-R*2^g,R*2^g], so has at most
+K=2 floor(R*2^g)+1 values. The complete record has at most C=D*K^m states,
+regardless of dependencies. Branch-dependent use of a fixed tuple is allowed
+if the branch is counted in h and absent slots are padded with0. No uncounted
+branch information or extra source observation is free.
+
+If the demanded real quantity a(x) has N distinct values, exact reconstruction
+requires C>=N by pigeonhole. If N inputs have pairwise demands more than
+2 epsilon apart, recovery within epsilon on every input also requires C>=N:
+two equal transcripts produce the same decoder output, which cannot belong
+to both disjoint closed epsilon balls. This applies to arbitrary nonlinear
+decoders under deterministic worst-case correctness. Randomized average-error
+guarantees are not claimed. The same proof permits p-dependent m,R,g,D.
+
+## 2. Actual bounded dyadic line
+
+Use PR2384's exact four-pair QQ16 model, owner action and66-port set. Put
+f_b(d)=bit_0(db), which is0 or1 at every owner. Its ordinary witness has
+h44=-f25, h49=-f145, h58=-f4, h70=f4, with every other component0.
+Let H=B0 h and P_A be the actual selected injection R_A^T/4 including its
+owner routes. Define w by X_U=h,Y_U=0,X_A=-P_A H,Y_A=P_A H, all other fields0.
+The pinned proof establishes H!=0, B_s h=0 for s=1..8, and the complete zero
+observation trace for the fixed19events. Function-dictionary cancellation
+proves identities at every owner without assuming bit-function independence.
+Payload-constant fields remove translation dependence at any fixed depth.
+
+Set v=2w. The verifier derives its original selected X_A components as
+
+    f145-f4, f145-f25, f4-f25, 0,
+    f145-f4, f25-f145, f25-f4, 0.
+
+Y_A is their negative; ordinary nonzero components are twice signed bit
+functions. Hence v is integer-valued and ||v||_infinity<=2. At the identity
+owner the first original X_A component is1. The granted exact observations
+of tv vanish for every real t by linearity of the retained logical schedule.
+Homogeneous selected controllers also receive zero exact fields. The rounded
+claim still requires their whole retained transcript to obey the stated error
+and capacity contract; unbounded internal state is not free.
+
+For p>=1, take t_k=k*2^-p,0<=k<=2^(p-1). All x_k=t_k v are p-grid inputs
+in the unit box. Their demanded coordinate is t_k, giving
+N_exact=2^(p-1)+1 distinct values. For p>=3 restrict k to multiples of4.
+This gives N_ulp=2^(p-3)+1 inputs with demand spacing4*2^-p>2*2^-p.
+One-ulp approximate recovery therefore requires N_ulp transcript states;
+exact recovery requires N_exact.
+
+## 3. The entire declared tuple
+
+Let W be the finite number of owner/payload points at the chosen depth. No
+estimate of W is required because the source identities hold at every point.
+The initial S values are zero: h is supported on four unread ports. They
+contribute4*2*66=528 complex slots per point. After each of19events, all
+4*2*16=128 selected A/T values and all528 S values vanish. After event1(B1)
+through event18, all4*96=384 completed-X ordinary descendants vanish at18cuts.
+At terminal event18 the completed-X side becomes Y, so that side is observed;
+former-Y final X is excluded. All five eight-component forward histories are
+zero, adding40slots. The overgranted tuple thus has
+(528+19*656+18*384+40)W=19944W complex, or m=39888W real components.
+Duplicated slots can only decrease its capacity.
+
+Let T_p be any rounded/nonlinear implementation of this tuple whose components
+are on the(p+g(p))-grid and differ from their ideals by at most R(p)*2^-p.
+Include every other retained scalar/metadata value in these components or a
+record with at most D_p states. The ideal tuple is zero on our line, so
+section1 proves the README inequalities. The conclusion is independent of
+the arithmetic that produces the residues. This is a necessary interface
+condition, not proof of any particular implementation's R,g,D bounds.
+
+## 4. Eventual failure and deliberate escapes
+
+For fixed W, polynomial R(p), g(p)=O(log p) and log2(D_p)=o(p), we have
+log2(C_p)=o(p), while log2(N_ulp)>=p-3. Eventually C_p<N_ulp. More generally
+the sufficient obstruction is exactly
+
+    log2(D_p)+m(p)*log2(2 floor(R(p)*2^g(p))+1) < log2(N_ulp).
+
+There is no inference when this inequality fails. Fixed-depth asymptotics
+alone do not reject a coupled depth=depth(p), and no useful small-p threshold
+is claimed.
+
+Finer quantization is a real escape: F_p(t)=2^-p*t is injective on our line
+and belongs to the2p-grid, although |F_p(t)|<=2^-p/2 relative to ideal0.
+Here g=p supplies enough states. Likewise T_p=0 plus h_p(t_k)=k is injective
+when D_p is large enough. Early original-A observation detects t directly.
+These controls demonstrate why small absolute error or an exact kernel alone
+does not establish this conclusion. No physical cost is claimed for escapes.
diff --git a/research/qq16-rounded-transcript-capacity/README.md b/research/qq16-rounded-transcript-capacity/README.md
new file mode 100644
index 0000000000..0cf470dc69
--- /dev/null
+++ b/research/qq16-rounded-transcript-capacity/README.md
@@ -0,0 +1,111 @@
+# Rounded residues and the hidden QQ16 input
+
+This extends commdata2338's exact 66-port counterexample
+[PR2384](https://github.com/CrocSwap/integer-mult-bounds/pull/2384) to arbitrary
+nonlinear rounded observations and decoders under an explicit finite-capacity
+contract. Subexponential transcript capacity cannot reconstruct its bounded
+dyadic hidden line, even to one input ulp. This does not certify an actual
+rounded controller's error bound or reject a changed observation contract.
+
+For a fixed owner/payload domain of size W, the overgranted tuple below has
+m=39888W real components. Suppose each component lies on the (p+g)-bit
+fractional grid, within R(p)*2^-p of its ideal value, and all other retained
+metadata has at most D_p states. Then its capacity is at most
+
+    C_p = D_p * (2 floor(R(p) 2^g) + 1)^m.
+
+Exact recovery requires C_p >= 2^(p-1)+1. Recovery with worst-case absolute
+error at most2^-p requires C_p >= 2^(p-3)+1 for p>=3. Fixed W, polynomial R,
+g=O(log p), and log2(D_p)=o(p) therefore fail eventually. There is no claimed
+useful small-p threshold: W can be enormous. For growing depth/count use the
+exact capacity inequality in [PROOF.md](PROOF.md), not the fixed-W corollary.
+
+## Complete declared observation boundary
+
+Fix the retained19-event QQ16 logical schedule, A/T/U partition, four X/Y pair
+banks, and PR2384's66ordinary read ports S. At every owner/payload point grant:
+
+| Observations | Complex scalar slots |
+| --- | ---: |
+| Initial X/Y values on S, all four pairs | 528 |
+| All A/T and S values after each of19events | 19*(128+528)=12464 |
+| Completed-X ordinary descendants after events1 through18 | 18*384=6912 |
+| Five eight-component forward query histories | 40 |
+| Total | 19944 |
+
+Indices are zero-based: event0 is F0, event1 is B1. At the terminal rotation,
+completed X is the new Y side. Former-Y final X is not granted. Repeated reads
+of a stored value and deterministic postprocessing add no information. We count
+both real and imaginary components despite the hidden family being real.
+
+This is a complete *defined* contract, not every internal primitive of an
+unspecified native implementation. Any additional retained intermediate value,
+branch identifier, timing information or precision-dependent control record
+must appear among the m components or D_p states. Extra source reads and early
+original-A records change the contract. PR2540/PR2651's early records are an
+explicit escape, not targets of this result.
+
+## Source binding and validation
+
+The predecessor at b9ef408b1cb0fcd34ab1f1bdbe645573d5de188f is retained
+byte-for-byte in vendor/pr2384 with its notice. Its verifier authenticates six
+main inputs and two archive members, proves all-owner routes and the19-event
+zero transcript, and rejects eight controls. We replay its complete receipt
+before deriving the integral hidden line and observation ledger; the wrapper
+only redirects its source root to this checkout.
+
+The line is v=2w for that exact witness. Its nonzero ordinary fields have
+coefficients {-2,-2,-2,+2} on ports{44,49,58,70}. Its original selected fields
+also have integral coefficients and coefficient L1 norm at most2. Original
+A0(identity)=1. Thus x_k=k*2^-p*v, 0<=k<=2^(p-1), is a unit-box p-grid family
+with zero exact observations and distinct demanded coordinate k*2^-p. The
+fields are constant in payload addresses at any fixed finite depth.
+
+New finite checks cover normalization, the complete slot ledger, one-ulp
+packing, a sharp nine-transcript toy boundary, exact grid-interval counts,
+and two deliberate escapes: finer output precision and extra side metadata.
+The written pigeonhole proof establishes the universal result; finite controls
+do not replace that proof or sample away the all-owner source identities.
+
+Run Python3.12+, standard library only:
+
+```sh
+python3 -I -O -B research/qq16-rounded-transcript-capacity/verify.py
+python3 scripts/research_package.py --package research/qq16-rounded-transcript-capacity
+```
+
+Replay is read-only, works in a Git-free dependency export, and compares the
+complete typed receipt. --write creates a new receipt exclusively.
+[VALIDATION.md](VALIDATION.md) records actual commands and outcomes.
+
+## Scope and family decision
+
+This closes only the bounded-precision nonlinear escape under the specified
+error, quantization, observation and metadata hypotheses. Larger error, finer
+outputs, exponentially many metadata states, a growing observation count,
+extra reads or a changed consumer can escape. No native error theorem, physical
+cost floor, supplier admission, new kappa or multiplication impossibility follows.
+
+Revision5 decision: finish this precision audit and stop. The complete boundary
+is the tuple plus metadata above. Proved quantities are information capacity and
+the source line; the scalar count upper-bounds observation storage. Native work,
+hosting, restoration and actual rounded errors remain unknown, not zero costs.
+The consumer must change the boundary or meet its capacity requirement. This
+does not expand the newer early-record construction.
+
+Base1884c509, priority5, picker93caa43d0e7c6f6fdbd0977d213fdccc. The baseline
+binding command passed before this refinement of uniform-transfer-audit.
+SOURCES.json/TASK.json retain exact provenance, overlap coverage and limitations.
+
+Credit commdata2338(PR2384), kyzer1023(PR2354), adamgall(PR2093),
+AliRomman(PR1969), and the retained joint-query/QQ16 authors. Prepared by ywz65
+with substantial OpenAI Codex assistance in proof, code and writing.
+Apache-2.0; retained notices remain intact.
+
+## Open next questions
+
+Can a specific rounded controller prove a uniform observation error and count
+all metadata at its actual coupled depth/precision? Inventory the emitted
+boundary and bound each component error, then evaluate the exact capacity
+criterion. Until then this is a conditional audit, not rejection of that
+controller. No further exact-linear coefficient census is proposed here.
diff --git a/research/qq16-rounded-transcript-capacity/RESULT.json b/research/qq16-rounded-transcript-capacity/RESULT.json
new file mode 100644
index 0000000000..7c3c3ae74b
--- /dev/null
+++ b/research/qq16-rounded-transcript-capacity/RESULT.json
@@ -0,0 +1,147 @@
+{
+  "complex_slots_per_point": 19944,
+  "coordinate_l1_bound": 2,
+  "demand_at_identity": 1,
+  "fine_grid_escape": [
+    {
+      "inputs": 5,
+      "p": 3
+    },
+    {
+      "inputs": 9,
+      "p": 4
+    },
+    {
+      "inputs": 17,
+      "p": 5
+    },
+    {
+      "inputs": 33,
+      "p": 6
+    },
+    {
+      "inputs": 65,
+      "p": 7
+    },
+    {
+      "inputs": 129,
+      "p": 8
+    },
+    {
+      "inputs": 257,
+      "p": 9
+    }
+  ],
+  "integer_selected_line": [
+    {
+      "145": "1",
+      "4": "-1"
+    },
+    {
+      "145": "1",
+      "25": "-1"
+    },
+    {
+      "25": "-1",
+      "4": "1"
+    },
+    {},
+    {
+      "145": "1",
+      "4": "-1"
+    },
+    {
+      "145": "-1",
+      "25": "1"
+    },
+    {
+      "25": "1",
+      "4": "-1"
+    },
+    {}
+  ],
+  "packing": [
+    {
+      "exact_inputs": 5,
+      "one_ulp_packing": 2,
+      "p": 3
+    },
+    {
+      "exact_inputs": 9,
+      "one_ulp_packing": 3,
+      "p": 4
+    },
+    {
+      "exact_inputs": 17,
+      "one_ulp_packing": 5,
+      "p": 5
+    },
+    {
+      "exact_inputs": 33,
+      "one_ulp_packing": 9,
+      "p": 6
+    },
+    {
+      "exact_inputs": 65,
+      "one_ulp_packing": 17,
+      "p": 7
+    },
+    {
+      "exact_inputs": 129,
+      "one_ulp_packing": 33,
+      "p": 8
+    },
+    {
+      "exact_inputs": 257,
+      "one_ulp_packing": 65,
+      "p": 9
+    },
+    {
+      "exact_inputs": 513,
+      "one_ulp_packing": 129,
+      "p": 10
+    },
+    {
+      "exact_inputs": 1025,
+      "one_ulp_packing": 257,
+      "p": 11
+    },
+    {
+      "exact_inputs": 2049,
+      "one_ulp_packing": 513,
+      "p": 12
+    }
+  ],
+  "rational_interval_checks": 180,
+  "real_components_per_point": 39888,
+  "rejected_controls": [
+    "unscaled half-integral line is not p-grid integral",
+    "former-Y endpoint is not a zero observation",
+    "omitted imaginary channels are not the declared real tuple",
+    "two-ulp separation does not give disjoint closed balls",
+    "negative radius",
+    "capacity equality is not an impossibility"
+  ],
+  "retained_controls": [
+    "flip coefficient on port 70",
+    "reuse first axis with no original defect",
+    "reverse initial A cancellation sign",
+    "add a read of witness port 44",
+    "omit owner action at one source",
+    "omit cancelling bridge",
+    "wrong F2 bank binding",
+    "observe former-Y terminal output"
+  ],
+  "schema_version": 1,
+  "scope": "conditional finite transcript capacity; no actual rounded error bound or new kappa",
+  "slot_categories": {
+    "completed": 6912,
+    "history": 40,
+    "initial": 528,
+    "post": 12464
+  },
+  "source_head": "b9ef408b1cb0fcd34ab1f1bdbe645573d5de188f",
+  "status": "PASS_QQ16_ROUNDED_TRANSCRIPT_CAPACITY",
+  "toy_capacity": 9,
+  "toy_over_capacity_inputs": 17
+}
diff --git a/research/qq16-rounded-transcript-capacity/SOURCES.json b/research/qq16-rounded-transcript-capacity/SOURCES.json
new file mode 100644
index 0000000000..0bff8026d1
--- /dev/null
+++ b/research/qq16-rounded-transcript-capacity/SOURCES.json
@@ -0,0 +1,89 @@
+{
+  "schema_version": 1,
+  "base_commit": "1884c509efc004524786e9b7cfcc4aca572316d5",
+  "files": [
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11",
+      "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32"
+    },
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "889b95d936746df124872133ae1e7cc339adcb92",
+      "sha256": "7d185cd8c2af35988d638d969748ad7b670f902606444dbfc748e4402c340df6"
+    },
+    {
+      "path": "research/community-frontier1042-audit/selected-replay.tar.gz",
+      "usage": "input",
+      "git_blob": "6f4dc6fe7631d8aacf8081fcaecf32197181685b",
+      "sha256": "22c3f4dce4b897a1d423d1388801933e288b6a6b1906cb15e1b16a5eb68db754"
+    },
+    {
+      "path": "research/joint-query/certificate.json.gz",
+      "usage": "input",
+      "git_blob": "c6e876d8b48d768214deee265ade428f8983b566",
+      "sha256": "a5ed85fac5ebf3c091482a113ab0d351eb5a7892fe2841a35e16017ec1ff49f7"
+    },
+    {
+      "path": "research/joint-query/evidence/CONSERVED-QQ16.md",
+      "usage": "input",
+      "git_blob": "4639583c1be02c2fb60ed8a8072c9969ef1569ce",
+      "sha256": "60f0de3a7205ba5046b5ae7ffa8bf2b1ea42ea46b498face0a77966b59e7f3fb"
+    },
+    {
+      "path": "research/joint-query/evidence/JOINT-QUERY-TRANSFER.md",
+      "usage": "input",
+      "git_blob": "a6805c58f23132f9420efebf90f5b7e863c2e179",
+      "sha256": "9e13e73ebf3192a6548798c2f1d13bd4d83957e8db0dc34de12b1a5311a52a75"
+    },
+    {
+      "path": "research/joint-query/evidence/QQ16-COVER-ACTION-ADDENDUM.md",
+      "usage": "input",
+      "git_blob": "3dd1a990d7b9d57cfb20cf8e8dd45548f043a944",
+      "sha256": "4bb4a68d8b4811b6d8364150612056bc124d38f1974d6f603dae68a99c4682fb"
+    },
+    {
+      "path": "research/joint-query/evidence/QQ16-SELECTED-WITNESS.json",
+      "usage": "input",
+      "git_blob": "5082d791d0b993492cbc5bf61ac3b69e82c96f3f",
+      "sha256": "e35e5868a1322e406191079c0675975b139692ba50b1e2e5fb8a40b6480519f4"
+    }
+  ],
+  "retained_author": "commdata2338; exact source notice retained",
+  "vendored_files": [
+    {
+      "path": "research/qq16-rounded-transcript-capacity/vendor/pr2384/verify.py",
+      "usage": "input",
+      "sha256": "05199736832e745174704a322d1e42e98dae0efb7f3900ece40e441356e9cdbd",
+      "git_blob": "1b7845908358e6d4550111849fb9c7ebf78a4a39",
+      "source_commit": "b9ef408b1cb0fcd34ab1f1bdbe645573d5de188f",
+      "source_path": "research/qq16-66port-second-axis/verify.py"
+    },
+    {
+      "path": "research/qq16-rounded-transcript-capacity/vendor/pr2384/README.md",
+      "usage": "input",
+      "sha256": "90671aa0a4ce875a97020a5cd2e05175c695216e521b2fe52baf6b24549a4e0b",
+      "git_blob": "e22846ca7b95f1af585f22f2a297165d90fdd479",
+      "source_commit": "b9ef408b1cb0fcd34ab1f1bdbe645573d5de188f",
+      "source_path": "research/qq16-66port-second-axis/README.md"
+    },
+    {
+      "path": "research/qq16-rounded-transcript-capacity/vendor/pr2384/RESULT.json",
+      "usage": "input",
+      "sha256": "8b083be2c2159121e179f697c6bb507f85d0610e14a5440642004dadb74ae6d4",
+      "git_blob": "04406104764f710b870a7c69c4f121ab5b855513",
+      "source_commit": "b9ef408b1cb0fcd34ab1f1bdbe645573d5de188f",
+      "source_path": "research/qq16-66port-second-axis/RESULT.json"
+    },
+    {
+      "path": "research/qq16-rounded-transcript-capacity/vendor/pr2384/SOURCES.json",
+      "usage": "input",
+      "sha256": "071f2afb43ea1afc91ea344e117f9039429b1c3c2e08aa14c8168e1a9cf92658",
+      "git_blob": "18e2b59c34606bb81f92ba457282c4274827245d",
+      "source_commit": "b9ef408b1cb0fcd34ab1f1bdbe645573d5de188f",
+      "source_path": "research/qq16-66port-second-axis/SOURCES.json"
+    }
+  ]
+}
diff --git a/research/qq16-rounded-transcript-capacity/TASK.json b/research/qq16-rounded-transcript-capacity/TASK.json
new file mode 100644
index 0000000000..51e4e52f03
--- /dev/null
+++ b/research/qq16-rounded-transcript-capacity/TASK.json
@@ -0,0 +1,78 @@
+{
+  "schema_version": 1,
+  "task_id": "uniform-transfer-audit",
+  "priority_revision": 5,
+  "base_commit": "1884c509efc004524786e9b7cfcc4aca572316d5",
+  "original_card": {
+    "id": "uniform-transfer-audit",
+    "question": "Can one exact all-size/compiler, precision, hosting or restoration implication be proved or falsified?",
+    "starting_points": [
+      "certificates/selected-result.json",
+      "docs/audit.md"
+    ],
+    "methods": [
+      "Prove one missing implication with explicit quantified hypotheses.",
+      "Find an exact counterexample at the claimed interface boundary."
+    ],
+    "acceptance_gate": "Identify the proposition and what would change downstream; do not equate a finite replay with a universal proof.",
+    "first_step": {
+      "command": [
+        "python3",
+        "-B",
+        "scripts/research_baseline.py"
+      ],
+      "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY",
+      "inspect": "Read the selected review scope and choose one exact all-size or precision implication.",
+      "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay."
+    },
+    "first_experiment": "Write its quantified inputs and conclusion; find a missing hypothesis or construct a minimal exact adversarial instance.",
+    "bottleneck_link": "Finite supplier improvements are useful only under the retained transfer obligations.",
+    "allowed_variations": [
+      "Choose one tape, precision, hosting or restoration lemma."
+    ],
+    "scope_change_triggers": [
+      "Replacing a quantified obligation with another finite smoke test."
+    ],
+    "overlap_terms": [
+      "uniform transfer",
+      "all-size",
+      "precision"
+    ]
+  },
+  "scope_status": "refined",
+  "actual_scope": "Finite-precision capacity and approximate-recovery packing for the actual QQ16 66-port hidden dyadic line",
+  "scope_change_reason": "The exact predecessor excludes nonlinear rounded residues. Change that hypothesis while preserving its complete observation boundary and explicitly bounding metadata.",
+  "bottleneck_link": "An exact kernel alone does not exclude approximate implementations; this supplies the missing finite-grid capacity implication under a quantified uniform-error contract.",
+  "budget_minutes": 60,
+  "stop_rule": "Bind the hidden line and full declared tuple, prove exact/approximate capacity bounds, validate sharpness and escape controls; stop before native construction.",
+  "outcome": "negative-result",
+  "evidence": "PROOF.md universal counting/packing argument; authenticated predecessor replay and new RESULT.json",
+  "author": "ywz65",
+  "ai_assistance": "Substantial OpenAI Codex assistance in proof, implementation, verification and writing.",
+  "open_questions": [
+    {
+      "question": "Can a concrete rounded controller prove its observation error and count all retained metadata at coupled depth/precision?",
+      "why_it_matters": "Only those quantified bounds allow the exact criterion to accept or reject that interface.",
+      "first_step": "Inventory the emitted observations and derive their componentwise error, grid and metadata count.",
+      "blocked_by": "No rounded native implementation or uniform error bound is supplied here."
+    }
+  ],
+  "selection_seed": "93caa43d0e7c6f6fdbd0977d213fdccc",
+  "first_step_result": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY",
+  "claim": "https://github.com/CrocSwap/integer-mult-bounds/pull/2384#issuecomment-6197610619",
+  "declared_milestone": "scoped precision interface obstruction",
+  "family_decision": {
+    "decision": "narrow and stop",
+    "proved": "Integral hidden line; full observation count; necessary exact/one-ulp capacity inequalities",
+    "upper_bounded": "Observation tuple slots at each fixed owner/payload domain",
+    "unknown": "Actual native rounded error, work, hosting, restoration, coupled depth/precision; none charged as zero",
+    "consumer_boundary": "Entire defined tuple plus all side metadata; no free extra records",
+    "changed_decision": "Small residues do not rescue this contract under subexponential transcript capacity."
+  },
+  "overlap": {
+    "open_prs": "833 complete at2026-10-15T16:47:56Z",
+    "discussions": "1239 complete at2026-10-15T15:22:22Z",
+    "targeted_rest": "predecessor exact head and latest30openPRs checked16:53UTC",
+    "limits": "Bounded freshness; no novelty certificate; PR2540/2651 changed early-record contract excluded."
+  }
+}
diff --git a/research/qq16-rounded-transcript-capacity/VALIDATION.md b/research/qq16-rounded-transcript-capacity/VALIDATION.md
new file mode 100644
index 0000000000..32f86391e5
--- /dev/null
+++ b/research/qq16-rounded-transcript-capacity/VALIDATION.md
@@ -0,0 +1,37 @@
+# Recorded validation
+
+Native Windows, 2026-10-15. Python3.12.14 standard library, and a separate
+Python3.14.5 isolated optimized replay. No CI result is claimed.
+
+- `python3.12 -I -O -B research/qq16-rounded-transcript-capacity/verify.py`
+  passes, including the full pinned predecessor receipt/eight controls.
+- `python3.12 -B scripts/research_package.py --package research/qq16-rounded-transcript-capacity`
+  passes its metadata/provenance validation and registered optimized command.
+- A Git-free export containing the package and six external dependencies
+  passes under Python3.14.5 `-I -O -B`; before/after SHA256 inventories agree.
+- In that export, Boolean schema-version and floating-point component-count
+  mutations reject as typed receipt mismatches. Whitespace/key-order variation
+  remains accepted. External archive and vendored verifier corruptions reject
+  before execution. Existing `--write` destination and unknown CLI option reject.
+  Every modified export file is restored, and the final inventory matches.
+
+The new receipt retains180 rational interval counts,10 one-ulp packing sizes,
+seven finer-grid escape fixtures, the nine-state sharp toy boundary, and six
+explicit rejection controls. These finite checks support the implementation;
+PROOF.md supplies the quantified capacity and packing argument. Root-agent
+independent proof/source review found no actionable issue, including the exact
+19944-complex-slot ledger and the actual integer line. This is model-assisted
+review, not independent human or formal-kernel verification.
+
+Canonical start/provenance is1884c509efc004524786e9b7cfcc4aca572316d5.
+Prepublication main advanced to8513ab11936831dc45305170357ce6d33098e4e5 with
+additional efficient1100 integrations. AGENTS/autoresearch/CONTRIBUTING,
+family/priority guidance and selected record were unchanged. The six runtime
+scientific inputs remain pinned to the same bytes. Historical source provenance
+and retained predecessor credit remain unchanged.
+
+The full overlap snapshot covers833 open PRs at16:47UTC and1239 Discussion
+records at15:22UTC; targeted REST checks covered the exact predecessor head
+and newest PRs through2685. Those bounded timestamps are not complete live
+coverage or a novelty certificate. PR2540/2651 early-record and2670 completed-
+child error work change or analyze a different observation contract.
diff --git a/research/qq16-rounded-transcript-capacity/VERIFY.json b/research/qq16-rounded-transcript-capacity/VERIFY.json
new file mode 100644
index 0000000000..42a4baf306
--- /dev/null
+++ b/research/qq16-rounded-transcript-capacity/VERIFY.json
@@ -0,0 +1,27 @@
+{
+  "schema_version": 1,
+  "status": "ready",
+  "python": "3.12",
+  "requirements": [],
+  "inputs": [
+    "research/community-frontier1042-audit/selected-replay.tar.gz",
+    "research/joint-query/certificate.json.gz",
+    "research/joint-query/evidence/CONSERVED-QQ16.md",
+    "research/joint-query/evidence/JOINT-QUERY-TRANSFER.md",
+    "research/joint-query/evidence/QQ16-COVER-ACTION-ADDENDUM.md",
+    "research/joint-query/evidence/QQ16-SELECTED-WITNESS.json"
+  ],
+  "commands": [
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-O",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 120,
+      "checks": "Full pinned all-owner predecessor receipt; integral line; complete observation slot ledger; exact/one-ulp packing; finite sharpness and escape controls."
+    }
+  ]
+}
diff --git a/research/qq16-rounded-transcript-capacity/vendor/pr2384/README.md b/research/qq16-rounded-transcript-capacity/vendor/pr2384/README.md
new file mode 100644
index 0000000000..e22846ca7b
--- /dev/null
+++ b/research/qq16-rounded-transcript-capacity/vendor/pr2384/README.md
@@ -0,0 +1,251 @@
+# The specified QQ16 66-port read set still loses selected inputs
+
+**Scoped obstruction with an exact four-port witness; no new kappa.**
+[PR2354](https://github.com/CrocSwap/integer-mult-bounds/pull/2354) proves that
+one specified set of 66 ordinary port reads eliminates its common-first-axis
+hidden-input family. Its second open question asks whether that same set
+fails on other inputs. **It does:** the second local chart axis gives a
+counterexample supported on unread ports **44, 49, 58 and 70**.
+
+The complete fixed QQ16 schedule has zero selected observations, zero
+completed-X descendants, zero five forward-query histories, and zero
+transcripts from all 66 specified ports, but a nonzero original A input.
+The A-to-T selected shear also leaves this witness unchanged.
+
+This answers that exact follow-up. It does not contradict PR2354's explicitly
+family-only sufficiency statement, establish a minimum tap count, or rule out
+every other set of 66 ports. A dense initial old-chart read detects this
+witness. Parallel PR2368 studies that dense read with a different hidden-input
+family; it is separate from the fixed-coordinate set tested here.
+
+## Contract
+
+Use the actual QQ16 A/T/U partition, fixed first `F0/B_1_2` pair, nine local
+stages, and ordinary 19-event recipe. All definitions and local maps are from
+the retained [conserved QQ16 contract](../joint-query/evidence/CONSERVED-QQ16.md),
+[ordered proof](../joint-query/evidence/JOINT-QUERY-TRANSFER.md), and
+[cover action](../joint-query/evidence/QQ16-COVER-ACTION-ADDENDUM.md).
+
+Let J be the following 30 unread ports, and S=U minus J the 66 read ports:
+
+```text
+J = [44,45,48,49,50,51,52,53,54,55,56,58,59,60,61,62,
+     63,64,65,66,67,68,69,70,71,72,73,74,75,77].
+```
+
+This is precisely PR2354's attaining set: J is the set of ordinary ports
+whose first local chart axis is the binary vector 2. The verifier reconstructs
+that set from the frozen source, rather than assuming a similarly sized set.
+
+After complete F0, allow any homogeneous linear selected-field controls,
+including the paired A-to-T shear, arbitrary owner mixing, and arbitrarily
+many side-effect-free reads of the entire X/Y owner arrays at ports in S.
+These reads may be retained for free. Granting earlier ordinary reads from S
+does not help either. Keep ordinary fields and the ordinary schedule unchanged.
+There is no earlier retained selected-input record, read of an unread port,
+ordinary preprocessing, or additional observation of the final former-Y
+endpoint. Private input-dependent records outside this contract are excluded.
+
+The inherited observation contract starts after B1 for completed-X
+descendants. The nonzero ordinary X output immediately after F0 is **not**
+granted as an additional full ordinary observation. Only its ports in S are
+readable. This distinction is necessary.
+
+## A four-column source identity
+
+Write r_p for column p of the actual rational 8-by-112 matrix R and b_p for
+the **second** local chart axis (array index 1, not index 0). The source gives:
+
+| p | coefficient c_p | b_p | r_p, in query-coordinate order |
+|---|---:|---:|---|
+| 44 | -1 | 25 | (0,0,1,-1,0,0,-1,1) |
+| 49 | -1 | 145 | (1,0,0,1,0,1,1,0) |
+| 58 | -1 | 4 | (0,1,-1,0,1,0,0,-1) |
+| 70 | +1 | 4 | (1,1,0,0,1,1,0,0) |
+
+Thus `-r_44-r_49-r_58+r_70=0`. All other coefficients are zero.
+The actual registered routes satisfy, for every port and s=1,...,8,
+
+```text
+rho_s(p) b_p = e_(10+8(s-1)).
+```
+
+Coordinates here start at zero. The verifier binds all 1,008 port/stage
+matrices to the native registry and checks all 7,168 positive-stage local-axis
+identities, including the 32 used by this witness.
+
+## An identity for every cover owner
+
+For an owner d in the retained regular cover G define
+
+```text
+f_v(d) = bit_0(d v), as the rational number 0 or 1;
+h_p(d) = c_p f_(b_p)(d), constant in every payload coordinate.
+```
+
+The full cover map reads at owner `d rho_s(p)`; payload translations act
+trivially on these payload-constant fields. Consequently, with
+`B_s=R_s iota_U`, the checked route identities give for **every** d:
+
+```text
+B_s h(d) = sum_p r_p c_p bit_0(d rho_s(p) b_p)
+         = (sum_p r_p c_p) bit_0(d e_(10+8(s-1)))
+         = 0,                       s=1,...,8.
+```
+
+This is an identity, not an inference from sampled owners. It requires no
+independence assertion about the functions f_v. In the old chart,
+
+```text
+H(d) = B0 h(d) = -r_44 f_25(d) - r_49 f_145(d)
+                         + (r_70-r_58) f_4(d).
+H(I) = (-1,0,-1,0,0,-1,0,-1) != 0.
+```
+
+Identity belongs to G, so this evaluation suffices to prove H is nonzero.
+Using the first axis instead would give `H=f_2 sum_p r_p c_p=0`: that
+old family has no selected defect on this coefficient vector. This is the
+changed premise, not a repetition of its 66-port family threshold.
+
+## The ordered hidden-input trajectory
+
+Initialize only pair 0, with all other pair fields and helpers zero:
+
+```text
+X_U=h,            Y_U=0,
+X_A=-P_(0,A) H,   Y_A=+P_(0,A) H,
+X_T=0,           Y_T=0.
+```
+
+`P_(0,A)=iota_A R_A^T/4` is a section, since `R_A R_A^T=4I`.
+The original selected A input is therefore nonzero. Its identity-owner
+value, in A order `[0,7,20,27,36,46,57,111]`, is
+
+```text
+(1/2,0,-1/2,0,1/2,0,1/2,0).
+```
+
+Every coefficient in the initialized input is integral or half-integral;
+multiplying the entire witness by two gives an integral witness.
+All selected pair sums vanish. The full F0 query is
+`B0 h + ell_(0,A) X_A = H-H=0`, so the exact forward map gives
+
+```text
+after F0:  X_U=Y_U=h,  all selected fields zero.
+```
+
+Every read at S is zero, since h is supported in J. Any allowed selected
+controller therefore keeps selected fields zero. In particular the shear
+`X_T += C X_A; Y_T -= C X_A` does nothing, for any homogeneous linear C.
+
+At B1 the future logger query is `B2 h=0`, the old T driver is zero, and
+the current query is `B1 h=0`. The exact backward map gives
+
+```text
+after B1:  Y_(0,U)=h,  every other ordinary and selected field zero.
+```
+
+The first positive bridge puts `-h` in Y_(1,U). F2 has zero X input and
+changes nothing. The cancelling negative bridge removes that `-h`.
+All remaining active local pairs are zero; the last three bridges also
+leave Y_(0,U)=h alone. Terminal rotation moves it to final X_(0,U), the
+former-Y native endpoint excluded by the inherited observation contract.
+The [receipt](RESULT.json) records every one of the 19 events.
+
+At every allowed read cut, all S arrays and selected fields are identically
+zero. All completed-X descendants after B1 and all five forward histories
+are zero. Induction therefore covers every permitted homogeneous selected
+controller, even with repeated S reads and arbitrary owner mixing. The
+zero input has exactly the same permitted observations but a different
+original A input. No decoder of those observations can restore both inputs.
+
+## Reproduction and evidence
+
+Python 3.12 standard library only, from the repository root:
+
+```sh
+python3 -I -B scripts/research_package.py --package research/qq16-66port-second-axis
+```
+
+The registered hook runs normal and optimized exact replays plus the focused
+integrity tests. Expected direct-verifier output:
+
+```text
+PASS_QQ16_66PORT_SECOND_AXIS support=4 observed_ports=66 stages=9 controls=8 no_new_kappa
+```
+
+The implementation uses rational sums of bit functions and the full ordered
+logical F/B formulas. It does not import predecessor Python. Equality to
+zero is checked by exact cancellation of identical functions; nonzero
+claims use an explicit owner evaluation. The checker authenticates six
+source files and two archive members, checks the selected sections, binds
+local stage/pair/orientation to the hosted template, and compares the full
+typed receipt. Default replay is read-only; `--emit-result NEW_PATH` creates
+a fresh receipt exclusively.
+
+Eight controls reject a coefficient sign error, reuse of the ineffective
+first axis, a wrong initial cancellation sign, reading port 44, omitted
+owner action, a missing cancelling bridge, a wrong F2 bank, and treating the
+former-Y endpoint as an allowed zero observation. Positive controls show
+that an extra port-44 read and a dense initial B0 query detect this witness.
+The integrity tests check relocation and byte-preserving replay, reject an
+on-disk receipt type change and source corruption, and reject removal of
+proof-relevant receipt fields. Every mathematical check stays active under
+`-O`.
+
+This is an author-checked scoped proof with exact finite source evidence.
+It does not rerun the literal native child kernels, the selected full cold
+replay, or a proof assistant. It inherits the retained local QQ16 contract.
+No full-controller rank, alternative read-set optimum, physical read/retention
+cost, hosting, recursive precision, all-size admission, or complete supplier
+invoice is established. The selected frontier remains unchanged. Granting
+all 66 reads and storage zero cost already fails this information screen,
+so no favorable completed supplier budget is claimed.
+
+## Provenance and credit
+
+Base: `0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2`, priority revision 4.
+Task `joint-query-controller`, refined from scope key `0e34adbc1dd119161c3a`;
+nonce `72c3e793ac4e1a0f869f8e219f301324`, recursive-interfaces track.
+Exact source blobs and hashes are in [SOURCES.json](SOURCES.json); the
+task card and overlap record are in [TASK.json](TASK.json).
+Coordination uses [Discussion #2205](https://github.com/CrocSwap/integer-mult-bounds/discussions/2205).
+
+- **kyzer1023 / PR2354**, inspected head
+  `308ebc7405303bb7ed91b012bb705949c6091a16`: first-axis rank-74/defect-66
+  certificate, the exact attaining read set, and this follow-up question.
+- **Adam Gall / PR2093**, credited head
+  `8b21a900eb520e4f11ea177b310f66316f8e8983`: common-axis owner-function
+  witness and its A cancellation. **commdata2338 / PR2326**, credited head
+  `fb7d64cd4a51c49bc56920305b0aca64011a420c`: coordinate-read contract,
+  selected-shear/single-tap obstruction, and threshold question. Those heads
+  are recorded in PR2354; neither package is a runtime dependency here.
+- **Ali Romman / PR1969**: retained QQ16 local maps, native packet,
+  cover semantics and ordinary schedule. Their existing source notices
+  remain at [joint-query/NOTICE.md](../joint-query/NOTICE.md).
+- **Cinna Davis / PR2216 and PR2268**: selected shear and paired-tap repair.
+  **EdDiboi** and kyzer1023: preceding first-axis threshold investigations.
+  **@starship-s / [PR2368](https://github.com/CrocSwap/integer-mult-bounds/pull/2368)**,
+  head `e5d4d78dcfdd55d323fcbc60df477b9f25c7abff`, reports a separate
+  obstruction for the dense old-chart read. Its scope and next questions
+  were read at the final overlap check; its verifier was not replayed here.
+  The present witness is detected by that dense read, so it does not supply
+  PR2368's result or duplicate its different input family.
+
+Prepared for commdata2338 (@commdata2338), with substantial OpenAI Codex assistance.
+OpenAI Codex (GPT-6 Astra) assisted with derivation, implementation, checking
+and writing. Author-checked only; no independent human review is claimed.
+New work is Apache-2.0. Frozen predecessor files are unchanged.
+
+## Open next questions
+
+1. **Which fixed ordinary read sets eliminate every local-axis family?**
+   This matters because a sharp threshold for one family need not repair
+   the controller. First form the simultaneous exact constraints from all
+   eight local chart axes for one proposed unread set. A surviving defect
+   is a falsifier; absence of one still requires testing other input families.
+   No new cardinality lower bound is asserted here.
+The former dense-B0 follow-up has a separate reported negative answer in
+PR2368 at the head credited above. Further dense-record work should start
+from its changed-record or final-cut questions, not repeat the closed
+old-chart experiment. No independent review of that result is claimed here.
diff --git a/research/qq16-rounded-transcript-capacity/vendor/pr2384/RESULT.json b/research/qq16-rounded-transcript-capacity/vendor/pr2384/RESULT.json
new file mode 100644
index 0000000000..0440610476
--- /dev/null
+++ b/research/qq16-rounded-transcript-capacity/vendor/pr2384/RESULT.json
@@ -0,0 +1,642 @@
+{
+  "archive_members": {
+    "t16/global/base/split-centres/GLOBAL-TEMPLATE.json.gz": "a179dad87651aba340a5a8ddbcd86a8e757cad87b8a1f8bad48106fbecd38518",
+    "t16/global/base/work/complex-nine-native/DATA-PHASES.json": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa"
+  },
+  "coefficient_sum": [
+    "0",
+    "0",
+    "0",
+    "0",
+    "0",
+    "0",
+    "0",
+    "0"
+  ],
+  "common_axis_checks": 7168,
+  "initial_A": [
+    {
+      "145": "1/2",
+      "4": "-1/2"
+    },
+    {
+      "145": "1/2",
+      "25": "-1/2"
+    },
+    {
+      "25": "-1/2",
+      "4": "1/2"
+    },
+    {},
+    {
+      "145": "1/2",
+      "4": "-1/2"
+    },
+    {
+      "145": "-1/2",
+      "25": "1/2"
+    },
+    {
+      "25": "1/2",
+      "4": "-1/2"
+    },
+    {}
+  ],
+  "initial_A_at_identity": [
+    "1/2",
+    "0",
+    "-1/2",
+    "0",
+    "1/2",
+    "0",
+    "1/2",
+    "0"
+  ],
+  "local_axis_zero_based": 1,
+  "observed_port_count": 66,
+  "old_chart_at_identity": [
+    "-1",
+    "0",
+    "-1",
+    "0",
+    "0",
+    "-1",
+    "0",
+    "-1"
+  ],
+  "old_chart_query": [
+    {
+      "145": "-1",
+      "4": "1"
+    },
+    {},
+    {
+      "25": "-1",
+      "4": "1"
+    },
+    {
+      "145": "-1",
+      "25": "1"
+    },
+    {},
+    {
+      "145": "-1",
+      "4": "1"
+    },
+    {
+      "145": "-1",
+      "25": "1"
+    },
+    {
+      "25": "-1",
+      "4": "1"
+    }
+  ],
+  "positive_controls": [
+    "extra port-44 read detects witness",
+    "dense initial B0 query detects witness"
+  ],
+  "read_ports": [
+    1,
+    2,
+    3,
+    4,
+    5,
+    6,
+    8,
+    9,
+    10,
+    11,
+    12,
+    13,
+    14,
+    15,
+    16,
+    17,
+    18,
+    19,
+    22,
+    23,
+    24,
+    25,
+    26,
+    28,
+    29,
+    30,
+    31,
+    32,
+    33,
+    34,
+    35,
+    38,
+    39,
+    40,
+    41,
+    42,
+    43,
+    78,
+    79,
+    80,
+    82,
+    83,
+    84,
+    85,
+    86,
+    88,
+    89,
+    90,
+    91,
+    93,
+    94,
+    95,
+    96,
+    97,
+    98,
+    99,
+    100,
+    101,
+    102,
+    103,
+    104,
+    105,
+    106,
+    107,
+    108,
+    109
+  ],
+  "registered_port_stage_routes": 1008,
+  "rejected_controls": [
+    "flip coefficient on port 70",
+    "reuse first axis with no original defect",
+    "reverse initial A cancellation sign",
+    "add a read of witness port 44",
+    "omit owner action at one source",
+    "omit cancelling bridge",
+    "wrong F2 bank binding",
+    "observe former-Y terminal output"
+  ],
+  "schema": "qq16-66port-second-axis-v1",
+  "scope": "specified read set only; no other 66-port-set or minimum-tap claim; no new kappa",
+  "source_sha256": {
+    "research/community-frontier1042-audit/selected-replay.tar.gz": "22c3f4dce4b897a1d423d1388801933e288b6a6b1906cb15e1b16a5eb68db754",
+    "research/joint-query/certificate.json.gz": "a5ed85fac5ebf3c091482a113ab0d351eb5a7892fe2841a35e16017ec1ff49f7",
+    "research/joint-query/evidence/CONSERVED-QQ16.md": "60f0de3a7205ba5046b5ae7ffa8bf2b1ea42ea46b498face0a77966b59e7f3fb",
+    "research/joint-query/evidence/JOINT-QUERY-TRANSFER.md": "9e13e73ebf3192a6548798c2f1d13bd4d83957e8db0dc34de12b1a5311a52a75",
+    "research/joint-query/evidence/QQ16-COVER-ACTION-ADDENDUM.md": "4bb4a68d8b4811b6d8364150612056bc124d38f1974d6f603dae68a99c4682fb",
+    "research/joint-query/evidence/QQ16-SELECTED-WITNESS.json": "e35e5868a1322e406191079c0675975b139692ba50b1e2e5fb8a40b6480519f4"
+  },
+  "status": "PASS_QQ16_66PORT_SECOND_AXIS",
+  "support": [
+    {
+      "R_column": [
+        "0",
+        "0",
+        "1",
+        "-1",
+        "0",
+        "0",
+        "-1",
+        "1"
+      ],
+      "axis": 25,
+      "coefficient": -1,
+      "port": 44
+    },
+    {
+      "R_column": [
+        "1",
+        "0",
+        "0",
+        "1",
+        "0",
+        "1",
+        "1",
+        "0"
+      ],
+      "axis": 145,
+      "coefficient": -1,
+      "port": 49
+    },
+    {
+      "R_column": [
+        "0",
+        "1",
+        "-1",
+        "0",
+        "1",
+        "0",
+        "0",
+        "-1"
+      ],
+      "axis": 4,
+      "coefficient": -1,
+      "port": 58
+    },
+    {
+      "R_column": [
+        "1",
+        "1",
+        "0",
+        "0",
+        "1",
+        "1",
+        "0",
+        "0"
+      ],
+      "axis": 4,
+      "coefficient": 1,
+      "port": 70
+    }
+  ],
+  "trace": [
+    {
+      "event": {
+        "kind": "local",
+        "pair": 0,
+        "reverse": false,
+        "stage": 0
+      },
+      "ordinary": [
+        1,
+        1,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ]
+    },
+    {
+      "event": {
+        "kind": "local",
+        "pair": 0,
+        "reverse": true,
+        "stage": 1
+      },
+      "ordinary": [
+        0,
+        1,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ]
+    },
+    {
+      "event": {
+        "coefficient": 1,
+        "dst": 0,
+        "kind": "bridge",
+        "src": 1
+      },
+      "ordinary": [
+        0,
+        1,
+        0,
+        -1,
+        0,
+        0,
+        0,
+        0
+      ]
+    },
+    {
+      "event": {
+        "kind": "local",
+        "pair": 0,
+        "reverse": false,
+        "stage": 2
+      },
+      "ordinary": [
+        0,
+        1,
+        0,
+        -1,
+        0,
+        0,
+        0,
+        0
+      ]
+    },
+    {
+      "event": {
+        "coefficient": -1,
+        "dst": 0,
+        "kind": "bridge",
+        "src": 1
+      },
+      "ordinary": [
+        0,
+        1,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ]
+    },
+    {
+      "event": {
+        "kind": "local",
+        "pair": 1,
+        "reverse": true,
+        "stage": 3
+      },
+      "ordinary": [
+        0,
+        1,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ]
+    },
+    {
+      "event": {
+        "coefficient": 1,
+        "dst": 1,
+        "kind": "bridge",
+        "src": 2
+      },
+      "ordinary": [
+        0,
+        1,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ]
+    },
+    {
+      "event": {
+        "kind": "local",
+        "pair": 1,
+        "reverse": false,
+        "stage": 4
+      },
+      "ordinary": [
+        0,
+        1,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ]
+    },
+    {
+      "event": {
+        "coefficient": -1,
+        "dst": 1,
+        "kind": "bridge",
+        "src": 2
+      },
+      "ordinary": [
+        0,
+        1,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ]
+    },
+    {
+      "event": {
+        "kind": "local",
+        "pair": 2,
+        "reverse": true,
+        "stage": 5
+      },
+      "ordinary": [
+        0,
+        1,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ]
+    },
+    {
+      "event": {
+        "coefficient": 1,
+        "dst": 2,
+        "kind": "bridge",
+        "src": 3
+      },
+      "ordinary": [
+        0,
+        1,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ]
+    },
+    {
+      "event": {
+        "kind": "local",
+        "pair": 2,
+        "reverse": false,
+        "stage": 6
+      },
+      "ordinary": [
+        0,
+        1,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ]
+    },
+    {
+      "event": {
+        "coefficient": -1,
+        "dst": 2,
+        "kind": "bridge",
+        "src": 3
+      },
+      "ordinary": [
+        0,
+        1,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ]
+    },
+    {
+      "event": {
+        "kind": "local",
+        "pair": 3,
+        "reverse": true,
+        "stage": 7
+      },
+      "ordinary": [
+        0,
+        1,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ]
+    },
+    {
+      "event": {
+        "kind": "local",
+        "pair": 3,
+        "reverse": false,
+        "stage": 8
+      },
+      "ordinary": [
+        0,
+        1,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ]
+    },
+    {
+      "event": {
+        "coefficient": 1,
+        "dst": 3,
+        "kind": "bridge",
+        "src": 2
+      },
+      "ordinary": [
+        0,
+        1,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ]
+    },
+    {
+      "event": {
+        "coefficient": 1,
+        "dst": 2,
+        "kind": "bridge",
+        "src": 1
+      },
+      "ordinary": [
+        0,
+        1,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ]
+    },
+    {
+      "event": {
+        "coefficient": 1,
+        "dst": 1,
+        "kind": "bridge",
+        "src": 0
+      },
+      "ordinary": [
+        0,
+        1,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ]
+    },
+    {
+      "event": {
+        "kind": "terminal",
+        "pairs": 4
+      },
+      "ordinary": [
+        1,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ]
+    }
+  ],
+  "unread_ports": [
+    44,
+    45,
+    48,
+    49,
+    50,
+    51,
+    52,
+    53,
+    54,
+    55,
+    56,
+    58,
+    59,
+    60,
+    61,
+    62,
+    63,
+    64,
+    65,
+    66,
+    67,
+    68,
+    69,
+    70,
+    71,
+    72,
+    73,
+    74,
+    75,
+    77
+  ],
+  "zero_forward_histories": [
+    0,
+    2,
+    4,
+    6,
+    8
+  ],
+  "zero_later_queries": [
+    1,
+    2,
+    3,
+    4,
+    5,
+    6,
+    7,
+    8
+  ]
+}
diff --git a/research/qq16-rounded-transcript-capacity/vendor/pr2384/SOURCES.json b/research/qq16-rounded-transcript-capacity/vendor/pr2384/SOURCES.json
new file mode 100644
index 0000000000..18e2b59c34
--- /dev/null
+++ b/research/qq16-rounded-transcript-capacity/vendor/pr2384/SOURCES.json
@@ -0,0 +1,54 @@
+{
+  "schema_version": 1,
+  "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2",
+  "files": [
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11",
+      "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32"
+    },
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "e8870e5917057d59b730eb14721a778639eca050",
+      "sha256": "d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7"
+    },
+    {
+      "path": "research/community-frontier1042-audit/selected-replay.tar.gz",
+      "usage": "input",
+      "git_blob": "6f4dc6fe7631d8aacf8081fcaecf32197181685b",
+      "sha256": "22c3f4dce4b897a1d423d1388801933e288b6a6b1906cb15e1b16a5eb68db754"
+    },
+    {
+      "path": "research/joint-query/certificate.json.gz",
+      "usage": "input",
+      "git_blob": "c6e876d8b48d768214deee265ade428f8983b566",
+      "sha256": "a5ed85fac5ebf3c091482a113ab0d351eb5a7892fe2841a35e16017ec1ff49f7"
+    },
+    {
+      "path": "research/joint-query/evidence/CONSERVED-QQ16.md",
+      "usage": "input",
+      "git_blob": "4639583c1be02c2fb60ed8a8072c9969ef1569ce",
+      "sha256": "60f0de3a7205ba5046b5ae7ffa8bf2b1ea42ea46b498face0a77966b59e7f3fb"
+    },
+    {
+      "path": "research/joint-query/evidence/JOINT-QUERY-TRANSFER.md",
+      "usage": "input",
+      "git_blob": "a6805c58f23132f9420efebf90f5b7e863c2e179",
+      "sha256": "9e13e73ebf3192a6548798c2f1d13bd4d83957e8db0dc34de12b1a5311a52a75"
+    },
+    {
+      "path": "research/joint-query/evidence/QQ16-COVER-ACTION-ADDENDUM.md",
+      "usage": "input",
+      "git_blob": "3dd1a990d7b9d57cfb20cf8e8dd45548f043a944",
+      "sha256": "4bb4a68d8b4811b6d8364150612056bc124d38f1974d6f603dae68a99c4682fb"
+    },
+    {
+      "path": "research/joint-query/evidence/QQ16-SELECTED-WITNESS.json",
+      "usage": "input",
+      "git_blob": "5082d791d0b993492cbc5bf61ac3b69e82c96f3f",
+      "sha256": "e35e5868a1322e406191079c0675975b139692ba50b1e2e5fb8a40b6480519f4"
+    }
+  ]
+}
diff --git a/research/qq16-rounded-transcript-capacity/vendor/pr2384/verify.py b/research/qq16-rounded-transcript-capacity/vendor/pr2384/verify.py
new file mode 100644
index 0000000000..1b78459083
--- /dev/null
+++ b/research/qq16-rounded-transcript-capacity/vendor/pr2384/verify.py
@@ -0,0 +1,365 @@
+#!/usr/bin/env python3
+"""QQ16 66-port counterexample; exact sums of f_v(d)=bit_0(d v).
+
+Empty sums prove identities; evaluation proves inequality. Independence of
+the f_v is never assumed. No predecessor Python is imported. Apache-2.0.
+Prepared for commdata2338 with substantial OpenAI Codex assistance.
+"""
+import argparse
+from copy import deepcopy
+from fractions import Fraction as Q
+import gzip
+from hashlib import sha256
+from io import BytesIO
+import json
+from pathlib import Path
+import tarfile
+
+PACKAGE = Path(__file__).resolve().parent
+ROOT = PACKAGE.parents[1]
+ARCHIVE = "research/community-frontier1042-audit/selected-replay.tar.gz"
+PACKET = "research/joint-query/certificate.json.gz"
+PREVIOUS = "research/joint-query/evidence/QQ16-SELECTED-WITNESS.json"
+MEMBERS = {
+    "t16/global/base/work/complex-nine-native/DATA-PHASES.json":
+        "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa",
+    "t16/global/base/split-centres/GLOBAL-TEMPLATE.json.gz":
+        "a179dad87651aba340a5a8ddbcd86a8e757cad87b8a1f8bad48106fbecd38518",
+}
+A = [0, 7, 20, 27, 36, 46, 57, 111]
+T = [21, 37, 47, 76, 81, 87, 92, 110]
+U = [p for p in range(112) if p not in A + T]
+UNREAD = [44, 45, 48, 49, 50, 51, 52, 53, 54, 55, 56, 58, 59, 60,
+          61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 77]
+READ = [p for p in U if p not in UNREAD]
+COEFFICIENTS = {44: -1, 49: -1, 58: -1, 70: 1}
+IDENTITY = tuple(1 << i for i in range(73))
+
+
+def require(ok, message):
+    if not ok:
+        raise ValueError(message)
+
+
+def canonical(value):
+    return json.dumps(value, sort_keys=True, separators=(",", ":"), allow_nan=False)
+
+
+def equal_receipt(actual, expected):
+    require(canonical(actual) == canonical(expected), "complete typed receipt mismatch")
+
+
+def authenticate(raw, pin, label):
+    require(sha256(raw).hexdigest() == pin, "source hash mismatch: " + label)
+    return raw
+
+
+def sources(root=ROOT):
+    manifest = json.loads((PACKAGE / "SOURCES.json").read_text())
+    pins = {f["path"]: f["sha256"] for f in manifest["files"] if f["usage"] == "input"}
+    require(set(pins) == {ARCHIVE, PACKET, PREVIOUS,
+                         "research/joint-query/evidence/CONSERVED-QQ16.md",
+                         "research/joint-query/evidence/JOINT-QUERY-TRANSFER.md",
+                         "research/joint-query/evidence/QQ16-COVER-ACTION-ADDENDUM.md"},
+            "complete declared source set")
+    raw = {name: authenticate((root / name).read_bytes(), pin, name)
+           for name, pin in pins.items()}
+    decoded = []
+    with tarfile.open(fileobj=BytesIO(raw[ARCHIVE]), mode="r:gz") as archive:
+        for name, pin in MEMBERS.items():
+            matches = [m for m in archive.getmembers() if m.name == name]
+            require(len(matches) == 1 and matches[0].isfile(), "unique regular archive member")
+            data = authenticate(archive.extractfile(matches[0]).read(), pin, name)
+            decoded.append(json.loads(gzip.decompress(data) if name.endswith(".gz") else data))
+    return (json.loads(gzip.decompress(raw[PACKET])), *decoded,
+            json.loads(raw[PREVIOUS]), pins)
+
+
+def combination(terms):
+    """Rational linear combination of dictionaries representing f_v functions."""
+    out = {}
+    for scale, function in terms:
+        for v, coefficient in function.items():
+            value = out.get(v, Q(0)) + scale * coefficient
+            if value:
+                out[v] = value
+            else:
+                out.pop(v, None)
+    return out
+
+
+def action(columns, vector):
+    result = 0
+    for i, column in enumerate(columns):
+        if (vector >> i) & 1:
+            result ^= column
+    return result
+
+
+def transport(function, columns):
+    return combination((coefficient, {action(columns, v): Q(1)})
+                       for v, coefficient in function.items())
+
+
+def evaluate(function, owner=IDENTITY):
+    return sum((c * (action(owner, v) & 1) for v, c in function.items()), Q(0))
+
+
+def serialize(function):
+    return {str(v): str(c) for v, c in sorted(function.items())}
+
+
+def zero_bank():
+    return [{} for _ in range(112)]
+
+
+def derive_routes(packet, phases):
+    require(phases["m"] == 73 and len(phases["recipes"]) == 112, "source dimensions")
+    registered = {tuple(m["owner_right_matrix_columns"])
+                  for m in packet["map_registry"].values()}
+    bases, routes = [], {}
+    for p, record in enumerate(phases["recipes"]):
+        basis = record["idle_children"][0]["orthogonal_axes"][:8]
+        local = [record["q"], *basis]
+        require(record["port"] == p and len(local) == 9, "source port binding")
+        require(all(0 < v < 512 for v in local), "local chart support")
+        require(all(((v & w).bit_count() % 2) == int(i == j)
+                    for i, v in enumerate(local) for j, w in enumerate(local)),
+                "orthonormal local chart")
+        bases.append(basis)
+        for s in range(9):
+            columns = list(IDENTITY)
+            if s:
+                for i, b in enumerate(basis):
+                    delta = b ^ (1 << (9 + 8 * (s - 1) + i))
+                    columns = [v ^ delta if (v & delta).bit_count() % 2 else v
+                               for v in columns]
+            columns = tuple(columns)
+            require(columns in registered, "route missing from native map registry")
+            require(all(action(columns, columns[i]) == IDENTITY[i] for i in range(73)),
+                    "route inverse")
+            require(action(columns, record["q"]) == record["q"], "route fixes port line")
+            if s:
+                require(all(action(columns, b) == 1 << (9 + 8 * (s - 1) + i)
+                            for i, b in enumerate(basis)), "all-axis route identity")
+            routes[s, p] = columns
+    require([p for p in U if bases[p][0] == 2] == UNREAD,
+            "PR2354 exact attaining unread set")
+    return bases, routes
+
+
+class Model:
+    """Ordered logical maps from the retained conserved QQ16 contract."""
+    def __init__(self, packet, routes):
+        require((packet["A_ports"], packet["T_ports"], packet["U_ports"]) == (A, T, U),
+                "QQ16 partition")
+        self.R = [[Q(row.get(str(p), "0")) for p in range(112)] for row in packet["R_rows"]]
+        require(len(self.R) == 8, "query width")
+        self.routes = routes
+        for ports, scale in ((A, 4), (T, 4), (U, 48)):
+            require(all(sum(self.R[i][p] * self.R[j][p] for p in ports)
+                        == (scale if i == j else 0) for i in range(8) for j in range(8)),
+                    "actual selected and ordinary Grams")
+
+    def query(self, fields, stage, ports=range(112)):
+        return [combination((row[p], transport(fields[p], self.routes[stage, p]))
+                            for p in ports) for row in self.R]
+
+    def inject(self, query, stage, ports):
+        fields = zero_bank()
+        for p in ports:
+            value = combination((self.R[k][p] / 4, query[k]) for k in range(8))
+            fields[p] = transport(value, self.routes[stage, p])
+        return fields
+
+    def forward(self, x, y, stage):
+        f = self.query(x, stage)
+        k = self.inject(f, stage, U)
+        old_t = self.inject(self.query(x, stage, T), stage, A)
+        new_t = self.inject(f, stage, T)
+        xx, yy = zero_bank(), zero_bank()
+        for p in U:
+            xx[p] = combination([(1, x[p]), (-1, k[p])])
+            yy[p] = combination([(1, y[p]), (1, xx[p])])
+        for p in A + T:
+            xx[p] = old_t[p] if p in A else new_t[p]
+            yy[p] = combination([(1, x[p]), (1, y[p]), (-1, xx[p])])
+        return xx, yy, f
+
+    def backward(self, x, y, stage, future):
+        q = self.query(y, future, U + T)
+        logger = self.inject(q, future, A)
+        u = [combination([(1, yy), (1, ll)]) for yy, ll in zip(y, logger)]
+        a = self.query(x, stage, T)
+        b = self.query(u, stage)
+        ku = self.inject(a, stage, U)
+        correction = self.inject([combination([(1, bb), (11, aa)])
+                                  for aa, bb in zip(a, b)], stage, T)
+        target = self.inject([combination([(1, bb), (12, aa)])
+                              for aa, bb in zip(a, b)], stage, T)
+        xx, yy = zero_bank(), zero_bank()
+        for p in U:
+            xx[p] = combination([(1, x[p]), (-1, y[p])])
+            yy[p] = combination([(1, y[p]), (1, ku[p])])
+        for p in A:
+            xx[p] = combination([(1, x[p]), (1, y[p]), (-1, u[p])])
+            yy[p] = u[p]
+        for p in T:
+            xx[p] = target[p]
+            yy[p] = combination([(1, u[p]), (-1, correction[p])])
+        return xx, yy
+
+
+def bind_schedule(recipe, calls):
+    require(recipe[:2] == [{"kind": "local", "pair": 0, "reverse": False, "stage": 0},
+                           {"kind": "local", "pair": 0, "reverse": True, "stage": 1}],
+            "fixed F0/B1 first pair")
+    scheduled = {(e["stage"], e["pair"], "backward" if e["reverse"] else "forward")
+                 for e in recipe if e["kind"] == "local"}
+    require(scheduled == {(c["stage"], c["pair"], c["orientation"]) for c in calls},
+            "local stage/pair/orientation differs from hosted template")
+
+
+def replay(model, template, h, reads=READ, initial_sign=-1):
+    H = model.query(h, 0)
+    require(any(evaluate(f) for f in H), "old-chart defect is not witnessed at identity")
+    for stage in range(1, 9):
+        require(not any(model.query(h, stage)), "later query does not vanish identically")
+    selected = model.inject(H, 0, A)
+    x, y = deepcopy(h), zero_bank()
+    for p in A:
+        x[p] = combination([(initial_sign, selected[p])])
+        y[p] = combination([(-initial_sign, selected[p])])
+    initial_A = [x[p] for p in A]
+    require(any(evaluate(f) for f in initial_A), "nonzero original selected input")
+    banks = [[x, y]] + [[zero_bank(), zero_bank()] for _ in range(3)]
+    trace, histories = [], []
+    bind_schedule(template["recipe"], template["calls"])
+    for index, event in enumerate(template["recipe"]):
+        kind = event["kind"]
+        if kind == "local":
+            pair, stage = event["pair"], event["stage"]
+            x, y = banks[pair]
+            if event["reverse"]:
+                banks[pair] = list(model.backward(x, y, stage, stage + 1))
+            else:
+                xx, yy, f = model.forward(x, y, stage)
+                require(not any(f), "forward history is nonzero")
+                histories.append(stage)
+                banks[pair] = [xx, yy]
+        elif kind == "bridge":
+            source, target, c = event["src"], event["dst"], event["coefficient"]
+            for p in U:
+                banks[target][0][p] = combination([(1, banks[target][0][p]),
+                                                   (c, banks[source][0][p])])
+                banks[source][1][p] = combination([(1, banks[source][1][p]),
+                                                   (-c, banks[target][1][p])])
+        else:
+            require(kind == "terminal" and index == len(template["recipe"]) - 1,
+                    "unique final terminal")
+            banks = [[y, [combination([(-1, f)]) for f in x]] for x, y in banks]
+        require(not any(fields[p] for pair in banks for fields in pair for p in A + T),
+                "selected output survives")
+        require(not any(fields[p] for pair in banks for fields in pair for p in reads),
+                "ordinary read transcript is nonzero")
+        if index >= 1:
+            completed_side = 1 if kind == "terminal" else 0
+            require(not any(pair[completed_side][p] for pair in banks for p in U),
+                    "completed-X descendant is nonzero")
+        multipliers = []
+        for pair in banks:
+            for fields in pair:
+                candidates = [c for c in (-1, 0, 1)
+                              if all(fields[p] == combination([(c, h[p])]) for p in U)]
+                require(len(candidates) == 1, "ordinary trajectory not a unique h multiple")
+                multipliers.append(candidates[0])
+        trace.append({"event": event, "ordinary": multipliers})
+    require(histories == [0, 2, 4, 6, 8], "all five forward histories")
+    require(trace[-1]["ordinary"] == [1, 0, 0, 0, 0, 0, 0, 0], "former-Y endpoint")
+    return initial_A, H, trace
+
+
+def build_result():
+    packet, phases, template, previous, pins = sources()
+    bases, routes = derive_routes(packet, phases)
+    model = Model(packet, routes)
+    h = zero_bank()
+    for p, c in COEFFICIENTS.items():
+        h[p] = {bases[p][1]: Q(c)}
+    require([bases[p][1] for p in COEFFICIENTS] == [25, 145, 4, 4], "second axes")
+    coefficient_sum = [sum(row[p] * c for p, c in COEFFICIENTS.items()) for row in model.R]
+    require(coefficient_sum == [0] * 8, "four-column rational relation")
+    initial_A, H, trace = replay(model, template, h)
+    require([entry["ordinary"] for entry in trace[2:]] ==
+            [entry["ordinary"] for entry in previous["trajectory_after_B1"]],
+            "retained ordinary-tail receipt")
+    require([evaluate(f) for f in H] == [-1, 0, -1, 0, 0, -1, 0, -1],
+            "explicit nonzero old-chart value")
+    controls = []
+
+    def rejects(name, check):
+        try:
+            check()
+        except ValueError:
+            controls.append(name)
+        else:
+            raise ValueError("mutation was not rejected: " + name)
+
+    bad_h = deepcopy(h)
+    bad_h[70] = {bases[70][1]: Q(-1)}
+    rejects("flip coefficient on port 70", lambda: replay(model, template, bad_h))
+    first_h = zero_bank()
+    for p, c in COEFFICIENTS.items():
+        first_h[p] = {bases[p][0]: Q(c)}
+    rejects("reuse first axis with no original defect", lambda: replay(model, template, first_h))
+    rejects("reverse initial A cancellation sign", lambda: replay(model, template, h, initial_sign=1))
+    rejects("add a read of witness port 44", lambda: replay(model, template, h, reads=READ + [44]))
+    wrong_routes = dict(routes)
+    wrong_routes[1, 44] = IDENTITY
+    rejects("omit owner action at one source", lambda: replay(Model(packet, wrong_routes), template, h))
+    wrong = deepcopy(template)
+    wrong["recipe"] = [e for e in wrong["recipe"] if e !=
+                       {"kind": "bridge", "src": 1, "dst": 0, "coefficient": -1}]
+    rejects("omit cancelling bridge", lambda: replay(model, wrong, h))
+    wrong = deepcopy(template)
+    next(e for e in wrong["recipe"] if e.get("stage") == 2)["pair"] = 1
+    rejects("wrong F2 bank binding", lambda: replay(model, wrong, h))
+    rejects("observe former-Y terminal output", lambda: require(not any(h), "extra final read sees h"))
+    require(evaluate(h[44]) == -1, "additional port-44 read detects this witness")
+    require(any(evaluate(f) for f in H), "dense old-chart positive detection control")
+    return {
+        "schema": "qq16-66port-second-axis-v1", "status": "PASS_QQ16_66PORT_SECOND_AXIS",
+        "source_sha256": pins, "archive_members": MEMBERS,
+        "read_ports": READ, "unread_ports": UNREAD, "observed_port_count": len(READ),
+        "local_axis_zero_based": 1,
+        "support": [{"port": p, "coefficient": c, "axis": bases[p][1],
+                     "R_column": [str(row[p]) for row in model.R]} for p, c in COEFFICIENTS.items()],
+        "coefficient_sum": [str(x) for x in coefficient_sum],
+        "old_chart_query": [serialize(f) for f in H],
+        "old_chart_at_identity": [str(evaluate(f)) for f in H],
+        "initial_A": [serialize(f) for f in initial_A],
+        "initial_A_at_identity": [str(evaluate(f)) for f in initial_A],
+        "registered_port_stage_routes": len(routes), "common_axis_checks": 112 * 8 * 8,
+        "zero_later_queries": list(range(1, 9)), "zero_forward_histories": [0, 2, 4, 6, 8],
+        "trace": trace, "rejected_controls": controls,
+        "positive_controls": ["extra port-44 read detects witness", "dense initial B0 query detects witness"],
+        "scope": "specified read set only; no other 66-port-set or minimum-tap claim; no new kappa",
+    }
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--emit-result", type=Path, help="write a new receipt exclusively")
+    args = parser.parse_args()
+    result = build_result()
+    if args.emit_result:
+        with args.emit_result.open("x", encoding="utf-8") as output:
+            json.dump(result, output, indent=2, sort_keys=True)
+            output.write("\n")
+    else:
+        equal_receipt(result, json.loads((PACKAGE / "RESULT.json").read_text()))
+    print("PASS_QQ16_66PORT_SECOND_AXIS support=4 observed_ports=66 stages=9 controls=8 no_new_kappa")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/research/qq16-rounded-transcript-capacity/verify.py b/research/qq16-rounded-transcript-capacity/verify.py
new file mode 100644
index 0000000000..a7edf2941d
--- /dev/null
+++ b/research/qq16-rounded-transcript-capacity/verify.py
@@ -0,0 +1,195 @@
+#!/usr/bin/env python3
+"""Source-bound hidden line and finite controls for the capacity proof.
+
+ywz65, with substantial OpenAI Codex assistance. Apache-2.0.
+"""
+import argparse
+from collections import Counter
+from fractions import Fraction as Q
+from hashlib import sha256
+import importlib.util
+import itertools
+import json
+from pathlib import Path
+
+PACKAGE = Path(__file__).resolve().parent
+ROOT = PACKAGE.parents[1]
+
+
+def require(ok, message):
+    if not ok:
+        raise ValueError(message)
+
+
+def object_pairs(pairs):
+    result = {}
+    for key, value in pairs:
+        require(key not in result, "duplicate JSON key: " + key)
+        result[key] = value
+    return result
+
+
+def read_json(path):
+    return json.loads(path.read_text(encoding="utf-8"), object_pairs_hook=object_pairs)
+
+
+def same(a, b):
+    if type(a) is not type(b):
+        return False
+    if isinstance(a, dict):
+        return a.keys() == b.keys() and all(same(a[k], b[k]) for k in a)
+    if isinstance(a, list):
+        return len(a) == len(b) and all(same(x, y) for x, y in zip(a, b))
+    return a == b
+
+
+def pinned_model():
+    manifest = read_json(PACKAGE / "SOURCES.json")
+    for row in manifest["files"] + manifest["vendored_files"]:
+        if row["usage"] == "input":
+            raw = (ROOT / row["path"]).read_bytes()
+            require(sha256(raw).hexdigest() == row["sha256"], "source hash: " + row["path"])
+    vendor = PACKAGE / "vendor/pr2384"
+    spec = importlib.util.spec_from_file_location("retained_qq16_2384", vendor / "verify.py")
+    old = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(old)
+    # Preserve all retained source bytes; configure its default checkout root.
+    old.sources.__defaults__ = (ROOT,)
+    retained = old.build_result()
+    old.equal_receipt(retained, read_json(vendor / "RESULT.json"))
+    packet, phases, template, previous, pins = old.sources()
+    bases, routes = old.derive_routes(packet, phases)
+    model = old.Model(packet, routes)
+    h = old.zero_bank()
+    for port, coefficient in old.COEFFICIENTS.items():
+        h[port] = {bases[port][1]: Q(coefficient)}
+    initial, query, trace = old.replay(model, template, h)
+    return old, h, initial, trace, retained
+
+
+def capacity(m, radius, overhead, metadata=1):
+    require(type(m) is int and m >= 0, "component count")
+    require(type(overhead) is int and overhead >= 0, "grid overhead")
+    require(type(metadata) is int and metadata >= 1, "metadata count")
+    require(radius >= 0, "radius")
+    scaled = Q(radius) * (1 << overhead)
+    width = 2 * (scaled.numerator // scaled.denominator) + 1
+    return metadata * width ** m
+
+
+def build_result():
+    old, h, initial, trace, retained = pinned_model()
+    v_h = [old.combination([(2, f)]) for f in h]
+    v_a = [old.combination([(2, f)]) for f in initial]
+    expected_a = [{145: Q(1), 4: Q(-1)}, {145: Q(1), 25: Q(-1)},
+                  {4: Q(1), 25: Q(-1)}, {}, {145: Q(1), 4: Q(-1)},
+                  {25: Q(1), 145: Q(-1)}, {25: Q(1), 4: Q(-1)}, {}]
+    require(v_a == expected_a, "actual integral selected line")
+    require(all(c.denominator == 1 for f in v_h + v_a for c in f.values()), "integer line")
+    bound = max(sum(abs(c) for c in f.values()) for f in v_h + v_a)
+    require(bound == 2 and old.evaluate(v_a[0]) == 1, "normalization and demanded coordinate")
+    require(not any(v_h[p] for p in old.READ), "initial read-port tuple")
+
+    # Enumerate semantic slots, independently of the arithmetic count below.
+    slots = []
+    for pair, side, port in itertools.product(range(4), range(2), old.READ):
+        slots.append(("initial", -1, pair, side, port))
+    for index, entry in enumerate(trace):
+        for pair, side, port in itertools.product(range(4), range(2), old.A + old.T + old.READ):
+            slots.append(("post", index, pair, side, port))
+        if index >= 1:
+            side = 1 if entry["event"]["kind"] == "terminal" else 0
+            for pair, port in itertools.product(range(4), old.U):
+                slots.append(("completed", index, pair, side, port))
+        event = entry["event"]
+        if event["kind"] == "local" and not event["reverse"]:
+            for coordinate in range(8):
+                slots.append(("history", index, event["pair"], 0, coordinate))
+    require(len(slots) == len(set(slots)) == 19944, "complete observed slot count")
+    counts = dict(Counter(s[0] for s in slots))
+    require(counts == {"initial": 528, "post": 12464, "completed": 6912, "history": 40}, "slot categories")
+    require(all(s[3] == 1 for s in slots if s[0] == "completed" and s[1] == 18), "terminal side")
+
+    controls = []
+    def reject(name, check):
+        try:
+            check()
+        except ValueError:
+            controls.append(name)
+        else:
+            raise ValueError("control not rejected: " + name)
+
+    reject("unscaled half-integral line is not p-grid integral",
+           lambda: require(all(c.denominator == 1 for f in initial for c in f.values()), "fractional"))
+    reject("former-Y endpoint is not a zero observation", lambda: require(not any(v_h), "nonzero"))
+    reject("omitted imaginary channels are not the declared real tuple",
+           lambda: require(len(slots) == 39888, "two channels"))
+
+    packing = []
+    for p in range(3, 13):
+        values = [Q(k, 1 << p) for k in range(0, (1 << (p - 1)) + 1, 4)]
+        require(len(values) == (1 << (p - 3)) + 1, "packed family count")
+        require(all(b-a > Q(2, 1 << p) for a, b in zip(values, values[1:])), "disjoint one-ulp balls")
+        require(values[0] == 0 and values[-1] == Q(1, 2), "unit-box line range")
+        packing.append({"p": p, "exact_inputs": (1 << (p-1))+1, "one_ulp_packing": len(values)})
+    reject("two-ulp separation does not give disjoint closed balls",
+           lambda: require(Q(2, 64) > 2*Q(1, 64), "closed balls meet"))
+
+    interval_checks = 0
+    for numerator, denominator, g in itertools.product(range(9), range(1, 6), range(4)):
+        radius = Q(numerator, denominator)
+        enumerated = [n for n in range(-100, 101) if abs(Q(n, 1 << g)) <= radius]
+        require(len(enumerated) == capacity(1, radius, g), "rational grid-interval count")
+        interval_checks += 1
+    reject("negative radius", lambda: capacity(1, Q(-1), 0))
+
+    # Toy sharpness/collision at source-line exact p=4 and p=5 cardinalities.
+    pairs = list(itertools.product((-1, 0, 1), repeat=2))
+    require(len(pairs) == capacity(2, 1, 0) == 9, "nine-state alphabet")
+    require(len({pairs[k] for k in range(9)}) == 9, "sharp injective boundary")
+    encoded = [pairs[k % 9] for k in range(17)]
+    require(encoded[0] == encoded[9] and 0 != 9, "explicit over-capacity collision")
+    reject("capacity equality is not an impossibility",
+           lambda: require(capacity(2, 1, 0) < 9, "strict comparison"))
+    # At p=7 the same collision on the four-ulp packing defeats one-ulp recovery.
+    require(Q(4*9, 128) > Q(2, 128), "approximate collision demand separation")
+
+    fine_grid = []
+    for p in range(3, 10):
+        targets = [Q(k, 1 << p) for k in range((1 << (p-1))+1)]
+        fine = [t / (1 << p) for t in targets]
+        require(len(set(fine)) == len(targets), "fine-grid injection")
+        require(max(fine) <= Q(1, 1 << (p+1)), "small error despite injection")
+        require(all((f * (1 << (2*p))).denominator == 1 for f in fine), "2p-grid")
+        require(capacity(1, Q(1, 2), p) >= len(targets), "correct fine-grid capacity")
+        require(capacity(1, 0, 0, len(targets)) == len(targets), "side metadata escape")
+        fine_grid.append({"p": p, "inputs": len(targets)})
+    return {"schema_version": 1, "status": "PASS_QQ16_ROUNDED_TRANSCRIPT_CAPACITY",
+            "source_head": "b9ef408b1cb0fcd34ab1f1bdbe645573d5de188f",
+            "retained_controls": retained["rejected_controls"],
+            "integer_selected_line": [old.serialize(f) for f in v_a],
+            "coordinate_l1_bound": int(bound), "demand_at_identity": 1,
+            "slot_categories": counts, "complex_slots_per_point": len(slots),
+            "real_components_per_point": 2*len(slots), "packing": packing,
+            "rational_interval_checks": interval_checks,
+            "toy_capacity": 9, "toy_over_capacity_inputs": 17,
+            "fine_grid_escape": fine_grid, "rejected_controls": controls,
+            "scope": "conditional finite transcript capacity; no actual rounded error bound or new kappa"}
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--write", type=Path)
+    args = parser.parse_args()
+    result = build_result()
+    if args.write:
+        with args.write.open("x", encoding="utf-8", newline="\n") as stream:
+            json.dump(result, stream, indent=2, sort_keys=True)
+            stream.write("\n")
+    else:
+        require(same(result, read_json(PACKAGE / "RESULT.json")), "complete typed receipt mismatch")
+    print(result["status"])
+
+
+if __name__ == "__main__":
+    main()