From 0d720354a47457212b160492824f5116f9dde267 Mon Sep 17 00:00:00 2001
From: Ali Romman <226877337+aliromman@users.noreply.github.com>
Date: Sat, 24 Oct 2026 15:13:41 -0500
Subject: [PATCH] Add source-bound feedback for original helper query bank

---
 .../COMPLETION-INVOICE.json                   |  23 +
 .../PORTABILITY.json                          |  23 +
 .../original-helper-query-feedback/PROOF.md   | 146 ++++++
 .../original-helper-query-feedback/README.md  | 106 +++++
 .../RESULT.json                               | 189 ++++++++
 .../SOURCE-INVOICE.json                       |  23 +
 .../SOURCES.json                              |  72 +++
 .../original-helper-query-feedback/TASK.json  | 102 +++++
 .../VALIDATION.md                             |  61 +++
 .../VERIFY.json                               |  40 ++
 .../original-helper-query-feedback/verify.py  | 424 ++++++++++++++++++
 11 files changed, 1209 insertions(+)
 create mode 100644 research/original-helper-query-feedback/COMPLETION-INVOICE.json
 create mode 100644 research/original-helper-query-feedback/PORTABILITY.json
 create mode 100644 research/original-helper-query-feedback/PROOF.md
 create mode 100644 research/original-helper-query-feedback/README.md
 create mode 100644 research/original-helper-query-feedback/RESULT.json
 create mode 100644 research/original-helper-query-feedback/SOURCE-INVOICE.json
 create mode 100644 research/original-helper-query-feedback/SOURCES.json
 create mode 100644 research/original-helper-query-feedback/TASK.json
 create mode 100644 research/original-helper-query-feedback/VALIDATION.md
 create mode 100644 research/original-helper-query-feedback/VERIFY.json
 create mode 100644 research/original-helper-query-feedback/verify.py

diff --git a/research/original-helper-query-feedback/COMPLETION-INVOICE.json b/research/original-helper-query-feedback/COMPLETION-INVOICE.json
new file mode 100644
index 0000000000..c67e42f5da
--- /dev/null
+++ b/research/original-helper-query-feedback/COMPLETION-INVOICE.json
@@ -0,0 +1,23 @@
+{
+  "schema": "integer-mult-recursive-invoice/v1",
+  "contract": {
+    "model": "mixed-target-unnormalized-power-v1",
+    "rank_semantics": "H_r costs r^(1-C); every autonomous helper is counted once; common unchanged main outputs cancel",
+    "ambient_rank": 9,
+    "boundary": "One original forward FULL, before feedback: compare original helper returns with complete independent helper return decoding. Main endpoint and source ordinary operations are common."
+  },
+  "paid": {
+    "1": 2207,
+    "2": 412,
+    "3": 510,
+    "4": 127,
+    "5": 66,
+    "8": 8
+  },
+  "targets": {
+    "4": 2,
+    "7": 7,
+    "8": 41,
+    "9": 358
+  }
+}
diff --git a/research/original-helper-query-feedback/PORTABILITY.json b/research/original-helper-query-feedback/PORTABILITY.json
new file mode 100644
index 0000000000..9edbfe9575
--- /dev/null
+++ b/research/original-helper-query-feedback/PORTABILITY.json
@@ -0,0 +1,23 @@
+{
+  "status": "PASS_READ_ONLY_GIT_FREE_EXPORT",
+  "python": "Python 3.12.14",
+  "files": 18,
+  "all_hashes_unchanged": true,
+  "empty_path": true,
+  "checks": [
+    {
+      "optimized": false,
+      "exit_code": 0,
+      "seconds": 5.203,
+      "stdout": "PASS_UNCODED_FORWARD_EARLY_QUERY_FEEDBACK {\"feedback_shears\": 5, \"original_inputs\": 632, \"owned_inputs\": 226, \"rejected_controls\": 7, \"replacement_cuts\": 112}",
+      "stderr": ""
+    },
+    {
+      "optimized": true,
+      "exit_code": 0,
+      "seconds": 5.089,
+      "stdout": "PASS_UNCODED_FORWARD_EARLY_QUERY_FEEDBACK {\"feedback_shears\": 5, \"original_inputs\": 632, \"owned_inputs\": 226, \"rejected_controls\": 7, \"replacement_cuts\": 112}",
+      "stderr": ""
+    }
+  ]
+}
diff --git a/research/original-helper-query-feedback/PROOF.md b/research/original-helper-query-feedback/PROOF.md
new file mode 100644
index 0000000000..064cf65f6d
--- /dev/null
+++ b/research/original-helper-query-feedback/PROOF.md
@@ -0,0 +1,146 @@
+# Original-forward helper-query feedback
+
+## Source and input contract
+
+The source is the original forward native word with 632 arbitrary independent
+persistent inputs: 112 x fields, 112 y fields and 408 helper fields. Its moving-
+frame endpoint is `(x,y+x,h)`. Its eight center calls and owned temporary remain.
+The verifier replays all source endpoint rows and checks that its 358 cold-helper
+first departures equal the complete matrix T from PR5388. All 112 selected
+first events, owners, frames and ranks agree with that bank. This comparison
+uses the original word, not the center-free producer consumed by PR5388.
+
+Let xi be the independent cold-helper coordinates and let w=D_K xi. The
+predecessor's in-place scalar program applies T inverse. Its original first
+query at selected slot j has physical frame E_j and argument K_j xi_j.
+The monomial words K_j and O_j satisfy
+
+```text
+O_j E_j K_j = Q,        K_j R = R K_j,
+Q^2 = X_central,        Q^4 = I.
+```
+
+Every displayed identity is checked with its signed Clifford tableau and exact
+zero-state amplitudes. Q squared is an ordinary Pauli permutation. All scalar
+coefficients remain outside tensor powers. The fixed native lift applies each
+operator identity to the active axes and preserves arbitrary spectator data.
+Thus the identities hold at every allowed positive fiber width under the
+inherited native implementation and cost assumptions.
+
+The 112 adapted H1 children are relocated to an entrance prologue, before
+T inverse. For each selected coordinate, copy w_j into a cleared raw field,
+execute its actual adapted source child, copy that physical result into a
+cleared observation field, and apply O_j to the observation. The source child
+is relocated, not duplicated. The three live values are then
+
+```text
+w_j   = K_j xi_j
+raw_j = E_j K_j xi_j
+obs_j = Q xi_j.
+```
+
+## One exact feedback shear
+
+For h different from k, change `xi_k` to `xi_k+Q xi_h`. Keep the three live
+representations consistent by these changes:
+
+```text
+w_k   += K_k obs_h
+obs_k += Q^2 K_h^-1 w_h
+raw_k += O_k^-1 Q^2 K_h^-1 w_h.
+```
+
+The first is K_k times the required argument increment. The second is Q times
+that increment. For the third, the query identity gives
+
+```text
+O_k^-1 Q^2 = E_k K_k Q.
+```
+
+Hence the raw increment is the actual query E_k applied to the new argument.
+No new Gaussian query is needed: K_k, Q squared, K_h inverse and O_k inverse
+are monomial maps. The verifier checks their Fourier rank, literal compilation,
+signed tableaux and absolute phases. Merely changing w_k would leave the held
+raw result and observation stale.
+
+Use one owned scratch field a for the following literal sequence:
+
+```text
+CLEAR a; COPY a <- obs_h; apply K_k to a; ADD w_k += a;
+CLEAR a; COPY a <- w_h; apply Q^2 K_h^-1 to a; ADD obs_k += a;
+apply O_k^-1 to a; ADD raw_k += a; CLEAR a.
+```
+
+Chart changes on a come from the stated physical monomial maps. They are not
+free nonzero retags. The source field h is unchanged during this shear because
+h differs from k. Therefore the sequence preserves the three displayed
+invariants and is an invertible elementary change on the xi coordinates.
+Induction proves the same fact for any finite ordered sequence. It permits a
+later shear to read or change a coordinate used by an earlier shear.
+
+## Resume the original source and return every field
+
+After all feedback, apply the unchanged T inverse program to w. At each of the
+112 original query cuts, the persistent field is again w_j in chart zero.
+Its stored raw field is E_j w_j. Replace that original child by a whole-field
+swap, including its chart tag, then clear only the owned duplicate. This puts
+the persistent field in exactly the physical state that the source child
+would produce on the updated independent input.
+
+The first-departure rows have no main-input coefficient. Each prefix identity
+holds on every helper column, so it remains true after this operator-valued
+linear substitution. Induction through the replacement cuts proves the entire
+original source endpoint on the changed inputs. Every other source operation,
+including all eight centers and inherited phase/adapter records, is retained.
+The source never reads the separately held observations.
+
+The source leaves each helper in its old physical output chart. Apply the
+predecessor's 26 H5 and six H1 completion recipes to the non-full cold returns.
+All 358 cold fields now have the same full-R chart. Apply the scalar program T
+and the selected K inverses. The source proof gives the final cold outputs
+`R S(Q) xi`, where S(Q) is the ordered feedback shear word. The other 50 helpers
+retain their original jobs. The main source endpoint is unchanged. Clear all
+owned observations after their last use; raw fields and scratch already hold
+zero. No persistent input direction is erased.
+
+S(Q) is invertible, but it depends on Q. This proof does not supply an ordinary
+inverse decoder for S(Q). Consequently it does not permit independent H9 target
+credit on the original xi inputs. A completed caller must consume or remove
+this code and prove its own targets. The copied observations add no independent
+productive input or job.
+
+## Exact accounting and verification
+
+The original paid profile is `{1:2201,2:412,3:510,4:127,5:40,8:8}`. Relocation
+and feedback preserve that profile. Return completion adds six H1 and 26 H5.
+The final paid profile is `{1:2207,2:412,3:510,4:127,5:66,8:8}`. With no feedback,
+the autonomous helper profile changes from `{4:28,7:7,8:47,9:326}` to
+`{4:2,7:7,8:41,9:358}`. Before feedback this is a legitimate source-bound
+completion comparison. Its signed difference is positive at every concave
+hinge below rank nine and zero in rank mass. It is a strict cost increase
+for 0<t<1, not a paid-profile improvement.
+
+The relocated bank uses 224 new owned fields, 224 COPY, 448 CLEAR and 112
+whole-field/chart swaps. The two basis programs use 6,420 ADD and 408 SCALE.
+Input, output, response and completion words use at most 400 monomial field
+maps. Each nonempty feedback sequence adds one reused owned field and, per
+shear, two COPY, three ADD, three monomial maps and three CLEAR. The source's
+original ordinary operations and owned center temporary remain additional.
+All original owned inputs may start arbitrary. Only owned fields are cleared.
+Fixed rational scalar coefficients, field traffic and monomial maps still need
+ordinary and precision funding in any eventual multiplication construction.
+
+The primary replay represents each input by an independent free-word column.
+It checks 632 original columns and 226 arbitrary owned columns for five shears
+`(0,1),(1,0),(1,2),(2,111),(111,0)`, plus the empty sequence. A separate elementary
+update of the independent xi rows supplies the expected feedback endpoint.
+The full source replay checks every replacement cut, all persistent rows,
+all final charts, the paid profile and every owned return. The exact physical
+check covers all 112 query identities and all 32 completions. Seven deliberate
+changes must fail: stale raw data, stale observations, one Q instead of Q
+squared, a swap without chart transport, uncleared initial scratch, live final
+scratch, and an omitted completion. These finite controls support the written
+induction; they are not formal-kernel verification of all callers or widths.
+
+No backward interface, complete caller, full precision/compiler bill, BIT
+transfer, supplier admission or new multiplication exponent follows.
diff --git a/research/original-helper-query-feedback/README.md b/research/original-helper-query-feedback/README.md
new file mode 100644
index 0000000000..f396b2f7f0
--- /dev/null
+++ b/research/original-helper-query-feedback/README.md
@@ -0,0 +1,106 @@
+# Helper feedback after 112 early native queries
+
+This construction permits helper-to-helper feedback after the original complex
+FULL has exposed 112 early common-Q responses. It updates each helper argument,
+its held raw query result, and its normalized observation before the native word
+resumes. All eight original center calls remain. No extra Gaussian call is
+needed for a feedback shear.
+
+This is a forward interface, not a complete caller or a kappa improvement.
+After feedback, helper outputs are Gaussian transforms of changed independent
+coordinates. They are not yet autonomous Gaussian jobs on the original inputs.
+A caller must remove or consume that code and pay for the full construction.
+
+[PROOF.md](PROOF.md) gives the exact contract and the ordered patch.
+[RESULT.json](RESULT.json) records the source-bound replay and seven rejected
+mutations. [SOURCES.json](SOURCES.json) pins every imported source and the
+historical catalogue and selected record. All live source files are already
+on canonical main; no pending Git object or network is required for replay.
+
+## Result and local bill
+
+For distinct selected coordinates h and k, the interface implements
+`xi_k <- xi_k + Q xi_h`. It supports a finite sequence of these shears,
+including reuse of a prior source or destination. The preserved invariant is
+`w_j=K_j xi_j`, `raw_j=E_j K_j xi_j`, `obs_j=Q xi_j`.
+Each shear uses two COPY, three ADD, three monomial field maps and three CLEAR,
+with one reused owned scratch field. These are counted operations, not free
+machine work. The proof applies to every allowed positive fiber width under
+the inherited native and Clifford lifting conventions.
+
+The source and charged helper-return completion have paid profile
+`{1:2207,2:412,3:510,4:127,5:66,8:8}`. The 358 cold outputs are full H9 transforms
+of the feedback coordinates; the 50 other helper jobs retain profile
+`{4:2,7:7,8:41}`. All 408 helper directions remain independent, and none is erased.
+Their original target rank mass and the paid rank mass both rise by 136 during
+completion. The completion alone is a strict concave-moment loss; the saved
+invoice preflight checks this before any feedback and does not claim a caller.
+
+The hoisted bank uses 224 added owned fields, 224 COPY, 448 CLEAR and 112
+whole-field/chart swaps. Its fixed basis work is 6,420 ADD and 408 SCALE, with
+at most 400 monomial field maps including completion wrappers. A nonempty
+feedback sequence adds one owned scratch field and the per-shear work above.
+The native word and its original owned center field remain additional.
+The five-shear receipt checks all 632 original and 226 arbitrary owned inputs.
+
+## Reproduce
+
+Python 3.12 or later and the standard library suffice. From the repository root:
+
+```sh
+python3 -B scripts/research_package.py --package research/original-helper-query-feedback
+python3 -I -O -B research/original-helper-query-feedback/verify.py
+```
+
+Expected token: `PASS_UNCODED_FORWARD_EARLY_QUERY_FEEDBACK`.
+The default verifier is read-only. `--emit` writes `RESULT.json` for authors.
+It authenticates live bytes before importing source, ignores bytecode caches,
+and compiles the inherited scientific modules with assertions active in both
+wrapper modes. The registered runner also gives each command a private cache.
+[VALIDATION.md](VALIDATION.md) records actual execution and omitted checks.
+
+The replay includes the original native word, all eight centers, all 358 first
+departures, all 112 replacements, the empty-sequence control, five overlapping
+feedback shears, all helper returns, all owned clears, 112 physical query
+identities and 32 charged completion identities. It rejects a stale raw result,
+a stale observation, a missing Q factor, wrong chart transport, dirty scratch,
+live scratch at exit, and an omitted completion.
+
+The predecessor physical adapters and all-width native implementation remain
+inherited. No backward interface, flat physical compiler, uniform precision
+bill, full caller, supplier admission or selected cold replay is supplied.
+
+## Open next questions
+
+A useful next step is one complete caller with a terminal decoder for the
+Q-dependent helper code and a complete paid/target invoice. A separate backward
+interface needs its own source chronology and exact phases. Only after caller
+closure can its ordinary work, storage and precision be priced. The exact
+questions, first steps and blockers are in [TASK.json](TASK.json).
+
+## Sources and credit
+
+Dillon / @dillona supplies the scalar first-departure basis, phase-correct
+query wrappers, hoist and charged return completion in
+[PR #5388](https://github.com/CrocSwap/integer-mult-bounds/pull/5388), scientific
+head `568717635d8d11175a80024c9c596e16f54b1ea4`. That interface forbids changes
+to helper arguments without a new integrated proof. This package supplies that
+proof for elementary Q feedback on the original source, with all centers kept.
+It does not claim the query bank, hoist, normalizers or completion as new work.
+
+Cao Yifan / @intqwq supplies the native word in
+[PR #4610](https://github.com/CrocSwap/integer-mult-bounds/pull/4610).
+Dugongue / @mdumitrean supplies the exact replay core in
+[PR #4929](https://github.com/CrocSwap/integer-mult-bounds/pull/4929).
+Dillon supplies the exact Clifford maps and physical conventions in
+[PR #4933](https://github.com/CrocSwap/integer-mult-bounds/pull/4933).
+Keep the full predecessor credit in the unchanged
+[native query-bank attribution](../native-helper-query-bank/ATTRIBUTION.md),
+including Cinna Davis, zxv, Chris R, Jacob Alan Sussman and the native, scalar,
+controller, compiler and analytic contributors.
+
+The scientific experiment began at `1ec1119972c9aefe42525172d07b332fcff81cb4`.
+The publication base is `32890bc5de034ab8fc93ac88ead7279a6a416d04`; priority
+revision 7 is unchanged. The historical selected record at this base is
+conditional kappa 0.003027288235. This package does not change it.
+Prepared for Ali Romman with substantial OpenAI Codex assistance. Apache-2.0.
diff --git a/research/original-helper-query-feedback/RESULT.json b/research/original-helper-query-feedback/RESULT.json
new file mode 100644
index 0000000000..9f98fec9c7
--- /dev/null
+++ b/research/original-helper-query-feedback/RESULT.json
@@ -0,0 +1,189 @@
+{
+  "additional_owned_fields": 225,
+  "all_owned_outputs_zero": true,
+  "arbitrary_owned_inputs": 226,
+  "completed_paid": {
+    "1": 2207,
+    "2": 412,
+    "3": 510,
+    "4": 127,
+    "5": 66,
+    "8": 8
+  },
+  "completion_invoice_preflight": {
+    "assurance": {
+      "contract": "Exact matching user declarations; mathematical applicability is not verified.",
+      "inconclusive": "Mixed hinge signs do not establish a power-moment crossing or failure.",
+      "input_binding": "SHA-256 identifies the exact input bytes read, when loaded by this CLI.",
+      "scope": "Histogram arithmetic only. Histogram correctness, circuit legality, ownership, phases, precision, supplier admission and compiler endpoints are not validated."
+    },
+    "classification": "uniformly_worse",
+    "contract": {
+      "ambient_rank": 9,
+      "boundary": "One original forward FULL, before feedback: compare original helper returns with complete independent helper return decoding. Main endpoint and source ordinary operations are common.",
+      "model": "mixed-target-unnormalized-power-v1",
+      "rank_semantics": "H_r costs r^(1-C); every autonomous helper is counted once; common unchanged main outputs cancel"
+    },
+    "delta_paid": {
+      "1": 6,
+      "5": 26
+    },
+    "delta_targets": {
+      "4": -26,
+      "8": -6,
+      "9": 32
+    },
+    "hinges": [
+      {
+        "rank": 0,
+        "value": 0
+      },
+      {
+        "rank": 1,
+        "value": 32
+      },
+      {
+        "rank": 4,
+        "value": 110
+      },
+      {
+        "rank": 5,
+        "value": 110
+      },
+      {
+        "rank": 8,
+        "value": 32
+      },
+      {
+        "rank": 9,
+        "value": 0
+      }
+    ],
+    "method_credit": "Classical concave order/majorization; mightyOil's t16-moment-order-audit and its retained predecessors. No new theorem claim.",
+    "power_moment": {
+      "exponent": "0 < t < 1",
+      "new_minus_old_sign": "strictly_positive",
+      "tariff": "r^t"
+    },
+    "quantity": "(new paid - new targets) - (old paid - old targets)",
+    "rank_mass": {
+      "delta": {
+        "paid": 136,
+        "paid_minus_targets": 0,
+        "targets": 136
+      },
+      "new": {
+        "paid": 5463,
+        "paid_minus_targets": 1856,
+        "targets": 3607
+      },
+      "old": {
+        "paid": 5327,
+        "paid_minus_targets": 1856,
+        "targets": 3471
+      }
+    },
+    "schema": "integer-mult-recursive-invoice-comparison/v1",
+    "signed_net_delta": {
+      "1": 6,
+      "4": 26,
+      "5": 26,
+      "8": 6,
+      "9": -32
+    },
+    "tariff_class": "increasing concave f on nonnegative ranks, with f(0)=0",
+    "uniform_order": "weak; some concave tariffs can give equality"
+  },
+  "empty_sequence_control": {
+    "owned_clear": 448,
+    "owned_copy": 224,
+    "physical_field_swap": 112
+  },
+  "feedbacks": [
+    [
+      0,
+      1
+    ],
+    [
+      1,
+      0
+    ],
+    [
+      1,
+      2
+    ],
+    [
+      2,
+      111
+    ],
+    [
+      111,
+      0
+    ]
+  ],
+  "first_departure_rows_checked": 358,
+  "fixed_basis_adds": 6420,
+  "fixed_basis_scales": 408,
+  "fixed_monomial_maps_at_most": 400,
+  "helper_output_ranks_on_transformed_coordinates": {
+    "4": 2,
+    "7": 7,
+    "8": 41,
+    "9": 358
+  },
+  "limitation": "Forward interface only. No caller closure, complete precision tariff, or kappa improvement is claimed.",
+  "ordinary": {
+    "monomial_map": 15,
+    "owned_clear": 463,
+    "owned_copy": 234,
+    "physical_field_swap": 112,
+    "scalar_add": 15
+  },
+  "original_inputs": 632,
+  "physical_checks": {
+    "completion_identities": 32,
+    "query_identities": 112
+  },
+  "rejected_controls": [
+    {
+      "mutation": "stale_raw",
+      "reason": "Held raw argument matches current helper coordinate",
+      "result": "REJECT"
+    },
+    {
+      "mutation": "stale_observation",
+      "reason": "Observation matches current helper coordinate",
+      "result": "REJECT"
+    },
+    {
+      "mutation": "one_Q",
+      "reason": "Observation matches current helper coordinate",
+      "result": "REJECT"
+    },
+    {
+      "mutation": "chart_swap",
+      "reason": "Replacement chart transport",
+      "result": "REJECT"
+    },
+    {
+      "mutation": "dirty_scratch",
+      "reason": "Owned COPY needs a cleared target",
+      "result": "REJECT"
+    },
+    {
+      "mutation": "live_scratch",
+      "reason": "Every arbitrary owned input removed and every owned output cleared",
+      "result": "REJECT"
+    },
+    {
+      "mutation": "missing_completion",
+      "reason": "Common return chart before scalar decoding",
+      "result": "REJECT"
+    }
+  ],
+  "replacement_cuts": 112,
+  "source_payload_sha256": "cfcd36b40326d7a5815e1db5313444379b3fb756b27d5201c561574c085cc0dd",
+  "source_scope": "Original forward FULL, all eight centers retained.",
+  "status": "PASS_UNCODED_FORWARD_EARLY_QUERY_FEEDBACK",
+  "target_scope": "Helpers return on the transformed independent coordinates. A closed caller must prove its target."
+}
diff --git a/research/original-helper-query-feedback/SOURCE-INVOICE.json b/research/original-helper-query-feedback/SOURCE-INVOICE.json
new file mode 100644
index 0000000000..6c20eed8a4
--- /dev/null
+++ b/research/original-helper-query-feedback/SOURCE-INVOICE.json
@@ -0,0 +1,23 @@
+{
+  "schema": "integer-mult-recursive-invoice/v1",
+  "contract": {
+    "model": "mixed-target-unnormalized-power-v1",
+    "rank_semantics": "H_r costs r^(1-C); every autonomous helper is counted once; common unchanged main outputs cancel",
+    "ambient_rank": 9,
+    "boundary": "One original forward FULL, before feedback: compare original helper returns with complete independent helper return decoding. Main endpoint and source ordinary operations are common."
+  },
+  "paid": {
+    "1": 2201,
+    "2": 412,
+    "3": 510,
+    "4": 127,
+    "5": 40,
+    "8": 8
+  },
+  "targets": {
+    "4": 28,
+    "7": 7,
+    "8": 47,
+    "9": 326
+  }
+}
diff --git a/research/original-helper-query-feedback/SOURCES.json b/research/original-helper-query-feedback/SOURCES.json
new file mode 100644
index 0000000000..cf7bd5dbaa
--- /dev/null
+++ b/research/original-helper-query-feedback/SOURCES.json
@@ -0,0 +1,72 @@
+{
+  "schema_version": 1,
+  "base_commit": "32890bc5de034ab8fc93ac88ead7279a6a416d04",
+  "files": [
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "git_blob": "fc3d4ba105e1f097d0d7d051a308281e86ab1446",
+      "sha256": "66974efdced4083c00025f97d95d83909a226cdf801edb9301c195c6641f6903"
+    },
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "f126dd2e2dad2b669e75d1d0d0bd05c600725602",
+      "sha256": "f7a48bfa2659b88378282a8eee7d9fe52cdf505594124c4d1686b58510fffd72"
+    },
+    {
+      "path": "research/coded-native-caller/PHYSICAL.md",
+      "usage": "input",
+      "git_blob": "da8837ba67423ef08ef1afb8e8297a8032aafe9f",
+      "sha256": "4321b159ff8d3fe705419adaaa1beef75606e869e34341bda553f17d598a6078"
+    },
+    {
+      "path": "research/coded-native-caller/clifford_exact.py",
+      "usage": "input",
+      "git_blob": "166841a037f069249f6f7f6dedb89248812f59e2",
+      "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962"
+    },
+    {
+      "path": "research/kappa-round3-warp-20261022/ACTUAL-WORD.json.gz",
+      "usage": "input",
+      "git_blob": "46d929df83817b85a5387bcdb9745e0627d6366e",
+      "sha256": "7679daa4ec6a40f56fc7f0202379a6f454310e94945aba4f48beaaaafb838d05"
+    },
+    {
+      "path": "research/native-center-free-code/CODED-PROOF.md",
+      "usage": "input",
+      "git_blob": "1f28d33884ec99b34f8366d022d8f7b9b7653ae2",
+      "sha256": "acd904af677718da8cdaf81d205d29866a6855efd393047e7128320a46753b01"
+    },
+    {
+      "path": "research/native-center-free-code/native_core.py",
+      "usage": "input",
+      "git_blob": "5d8a8f0a6382c66449f76b6f57bdd380c057ddc1",
+      "sha256": "178ff80824a012970fc9435f122152da03c7e6bdc3a7de12136fe03e05cf24fe"
+    },
+    {
+      "path": "research/native-helper-query-bank/ATTRIBUTION.md",
+      "usage": "input",
+      "git_blob": "51041de84105c5617645b57f601b702648c1c0ec",
+      "sha256": "02a3723ab014a20b96fa1383a83bb0e3343e59ca96eff78ca7dfbec928662dc2"
+    },
+    {
+      "path": "research/native-helper-query-bank/BANK.json",
+      "usage": "input",
+      "git_blob": "91a6c7a5f30862ffdbe767fa844d0a372bf077a1",
+      "sha256": "237c6a7b890df5ba4dbf9ade112fe70aa06624774344978fde76a2c4ad172fe5"
+    },
+    {
+      "path": "research/native-helper-query-bank/PROOF.md",
+      "usage": "input",
+      "git_blob": "7ae6b095a2713dbbe4f8e5873f1fc89e7a05fea3",
+      "sha256": "a68aaac3bef72478e219e5e4fa9abc775505b3ffbd6da24ae3beceb9827ef124"
+    },
+    {
+      "path": "scripts/compare_recursive_invoices.py",
+      "usage": "input",
+      "git_blob": "fda2a852e9937e42fe40df0707694465ca7c1b48",
+      "sha256": "3930c22c11da7bc6042cfeb6e459ecb06e4478430037bee3469d034353855fc6"
+    }
+  ]
+}
diff --git a/research/original-helper-query-feedback/TASK.json b/research/original-helper-query-feedback/TASK.json
new file mode 100644
index 0000000000..e62140ca29
--- /dev/null
+++ b/research/original-helper-query-feedback/TASK.json
@@ -0,0 +1,102 @@
+{
+  "schema_version": 1,
+  "task_id": "joint-query-controller",
+  "priority_revision": 7,
+  "base_commit": "32890bc5de034ab8fc93ac88ead7279a6a416d04",
+  "original_card": {
+    "id": "joint-query-controller",
+    "question": "Can the installed QQ16 caller win a complete matched protocol bill, or can a changed demand eliminate actual paid work?",
+    "starting_points": [
+      "docs/research/research-family-status.md",
+      "certificates/selected-result.json",
+      "research/qq16-caller-install/README.md"
+    ],
+    "methods": [
+      "Derive the matched whole-caller physical bill for installed and baseline protocols.",
+      "Change the actual demanded observations and prove a cheaper legal producer/consumer contract."
+    ],
+    "acceptance_gate": "Name the changed premise of the fixed F0/B1 observation obstruction. Show exactly which query is recovered, legal native reads and restoration, and a full favorable budget including cover maps, helpers and endpoints. Local inverse identities alone do not close the global controller. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.",
+    "first_step": {
+      "command": [
+        "python3",
+        "-B",
+        "scripts/research_baseline.py"
+      ],
+      "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY",
+      "inspect": "Read #4166 COST.md and ADMISSION.json. An actual caller connection is now proposed. Its native-component profile loses; parent park/restore versus external-call costs remain unresolved. Retain the producer and recovery lineage rather than rebuild it.",
+      "scope": "Source-binding orientation only; no scientific replay, theorem acceptance or supplier admission. Budget any heavy replay separately."
+    },
+    "first_experiment": "At the actual installed cut, compare matched complete parent park/restore and external input/return protocols at the same bank/packet geometry, including every later root call and service cost. Alternatively pin both bridge observations and derive a genuinely smaller source-compatible demand. Stop if the complete necessary inequality fails or an essential cost is unknown; no larger decoder scan from a local tape-action saving.",
+    "bottleneck_link": "The native local words exist; retained query information and its physical access are the missing link to a composed recursive interface.",
+    "allowed_variations": [
+      "One paid query, one changed first pair, or one precisely specified affine helper state.",
+      "A counterexample or lower bound for that exact proposed repair.",
+      "One unresolved obligation of a newer local decoder, with exact source heads and a distinct claim/domain."
+    ],
+    "scope_change_triggers": [
+      "Retaining the fixed first pair and ordinary schedule while allowing only homogeneous selected-only control, already excluded by the witness.",
+      "Treating cover-map counts as zero-cost physical address operations.",
+      "Recreating the pending complete local decoder or early-record/output-bank coalescing already under investigation without a distinct audit or changed premise.",
+      "Treating a completed-output defect inequality as a producer-interior, dirty-range or physical-cost certificate.",
+      "Recreating completed-output recovery or caller wiring already supplied by #4166 without new independent coverage.",
+      "Dropping retained later root calls or claiming native-profile dominance from the isolated publication saving."
+    ],
+    "overlap_terms": [
+      "QQ16",
+      "joint-query",
+      "changing-chart controller",
+      "selected observation",
+      "1969",
+      "2540",
+      "early record",
+      "output-bank retention",
+      "complete native decoder",
+      "2965",
+      "producer defect",
+      "dirty-helper range",
+      "F17 consumer",
+      "4166",
+      "qq16-caller-install"
+    ],
+    "existing_checks": [
+      {
+        "scope": "PR #4166: author-checked installed producer/service/return/bridge connection; native-component comparison loses.",
+        "evidence": "research/qq16-caller-install/README.md",
+        "remaining": "Complete matched physical protocol bill, or changed source-compatible demand/circuit; no affordable supplier yet.",
+        "status": "author-checked",
+        "source_commit": "0b082d22a0e9a442d264ab0633e35ef26c790630",
+        "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+      }
+    ]
+  },
+  "scope_status": "changed",
+  "actual_scope": "A source-bound forward helper-query feedback interface on the original complex native FULL, retaining all eight centers and updating both the held raw query and the normalized observation.",
+  "scope_change_reason": "The donor authorized publication of useful saved constructions after the broader kappa search. This finishes a local helper-feedback interface; it does not claim the original complete-caller gate.",
+  "bottleneck_link": "A future joint-query caller can change helper arguments after early queries only if it updates every state that depends on them. This package gives that chronological update with its local bill.",
+  "budget_minutes": null,
+  "stop_rule": "Stop at a complete local feedback proof, source-bound replay, explicit costs and mutation controls. Do not claim a closed caller or a kappa gain.",
+  "outcome": "partial",
+  "evidence": "RESULT.json records all 632 original inputs, 226 arbitrary owned inputs, 112 replacement cuts, five overlapping feedback shears, 112 phase identities, 32 completion identities and seven rejected mutations.",
+  "author": "Ali Romman",
+  "ai_assistance": "Substantial OpenAI Codex assistance in construction, exact replay, proof and package review; no independent human or formal-kernel acceptance.",
+  "open_questions": [
+    {
+      "question": "Can a closed caller use these feedback coordinates and return canonical Gaussian jobs on every original input?",
+      "why_it_matters": "The output helper coordinates contain the invertible Q-dependent feedback code. Their ranks alone do not give autonomous recursive targets.",
+      "first_step": "Give one complete caller with an explicit terminal decoder and a paid/target invoice.",
+      "blocked_by": "No such caller or funded terminal decoder is supplied."
+    },
+    {
+      "question": "Can the actual backward source provide an independently checked feedback interface?",
+      "why_it_matters": "Forward relocation does not prove the dual frame, phase and argument chronology.",
+      "first_step": "Derive the backward first-departure basis and physical query identities before replaying any feedback.",
+      "blocked_by": "This package supplies only the forward source."
+    },
+    {
+      "question": "Can a completed caller fund scalar work, monomial movement, storage and rational precision?",
+      "why_it_matters": "The native Gaussian profile omits those ordinary and outer costs.",
+      "first_step": "After caller closure, apply the matched compiler and precision tariff to its literal schedule.",
+      "blocked_by": "No complete caller or recursive precision bill is supplied."
+    }
+  ]
+}
diff --git a/research/original-helper-query-feedback/VALIDATION.md b/research/original-helper-query-feedback/VALIDATION.md
new file mode 100644
index 0000000000..a2bca5eb3c
--- /dev/null
+++ b/research/original-helper-query-feedback/VALIDATION.md
@@ -0,0 +1,61 @@
+# Validation record
+
+The publication base is `32890bc5de034ab8fc93ac88ead7279a6a416d04`.
+The scientific source payload and PR5388 bank bytes match the saved experiment.
+No predecessor input was edited.
+
+## Executed checks
+
+Python 3.12.14 on macOS ran the following commands successfully:
+
+```sh
+python3 -I -B research/original-helper-query-feedback/verify.py --emit
+python3 -B scripts/research_package.py --package research/original-helper-query-feedback --check-only
+python3 -B scripts/research_package.py --package research/original-helper-query-feedback
+```
+
+The registered replay ran both normal and optimized wrappers. Both produced
+`PASS_UNCODED_FORWARD_EARLY_QUERY_FEEDBACK` and matched the complete typed
+`RESULT.json`. The metadata command produced
+`PASS_PACKAGE_METADATA_AND_PINS`; that token is not mathematical acceptance.
+The scientific replay was also run under Python 3.14.7 before final receipt
+and invoice packaging.
+
+A separate temporary export contained the nine scientific package files and
+nine declared live inputs. It had no Git directory, an empty PATH and read-only
+files and directories. The absolute Python 3.12.14 interpreter ran the verifier
+normally and with `-O`. Both passed, and all 18 file hashes stayed unchanged.
+[PORTABILITY.json](PORTABILITY.json) records the two executions. This export
+preceded addition of these validation records; the scientific files are the
+same files used by the registered replay. No network or external executable
+was needed by the direct verifier.
+
+A separate complex-geometry AI worker reviewed the three feedback identities,
+the induction for reused source/destination coordinates, operator-valued source
+substitution and the `R S(Q) xi` return. That was a written/code review, not an
+additional execution or independent human review. It found no issue within
+that scope.
+
+The committed-byte preflight and committed-package export integrity check also
+passed. The strict `--check-source-history` option stopped because this shared
+repository has shallow Git history. It did not report a source-byte mismatch.
+The package commit has the declared base as its immediate Git parent, and all
+live inputs are already present at that base. The standalone export tests above
+do not require Git history. Full-history preflight remains unrun.
+
+## Coverage and omitted checks
+
+The replay checks all 632 original columns, 226 arbitrary owned columns,
+112 replacement cuts, 358 source first departures, five overlapping shears,
+the empty sequence, 112 exact-phase query equations, 32 completion equations
+and seven semantic mutations. The inherited Clifford module is compiled with
+assertions active in both wrapper modes; the new checks use explicit errors.
+The completion invoice is reconstructed from the source ranks and compared
+with the shared signed-invoice checker. It is uniformly worse for every
+strict power tariff in the declared no-feedback comparison.
+
+The native physical adapter implementation, all-width implementation theorem
+and source cost convention remain inherited. The finite replay does not prove
+a backward interface, complete caller, terminal decoder, autonomous target
+credit after feedback, precision/compiler funding, BIT transfer or a new kappa.
+No selected-construction cold replay, hosted CI, Lean proof or Docker build ran.
diff --git a/research/original-helper-query-feedback/VERIFY.json b/research/original-helper-query-feedback/VERIFY.json
new file mode 100644
index 0000000000..f3064de230
--- /dev/null
+++ b/research/original-helper-query-feedback/VERIFY.json
@@ -0,0 +1,40 @@
+{
+  "schema_version": 1,
+  "status": "ready",
+  "python": "3.12",
+  "requirements": [],
+  "inputs": [
+    "research/coded-native-caller/PHYSICAL.md",
+    "research/coded-native-caller/clifford_exact.py",
+    "research/kappa-round3-warp-20261022/ACTUAL-WORD.json.gz",
+    "research/native-center-free-code/CODED-PROOF.md",
+    "research/native-center-free-code/native_core.py",
+    "research/native-helper-query-bank/ATTRIBUTION.md",
+    "research/native-helper-query-bank/BANK.json",
+    "research/native-helper-query-bank/PROOF.md",
+    "scripts/compare_recursive_invoices.py"
+  ],
+  "commands": [
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 120,
+      "checks": "Authenticate all live inputs; replay all original fields, helper feedback, original centers, replacement cuts and owned returns; check exact phases and charged completions; reject seven semantic mutations; compare typed receipts."
+    },
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-O",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 120,
+      "checks": "Repeat all checks with optimization enabled for the wrapper; imported scientific source is explicitly compiled with assertions active."
+    }
+  ]
+}
diff --git a/research/original-helper-query-feedback/verify.py b/research/original-helper-query-feedback/verify.py
new file mode 100644
index 0000000000..01845cdbf6
--- /dev/null
+++ b/research/original-helper-query-feedback/verify.py
@@ -0,0 +1,424 @@
+#!/usr/bin/env python3
+"""Check feedback through the original forward native helper-query bank.
+
+PR5388 supplies the basis, wrappers and return completions. All eight original
+centers remain. Ali Romman, substantial OpenAI Codex assistance; Apache-2.0.
+This is a local interface, not a closed caller or a kappa certificate.
+"""
+from collections import Counter
+from fractions import Fraction as F
+from hashlib import sha256
+from pathlib import Path
+import argparse
+import gzip
+import importlib.util
+import json
+import sys
+
+HERE = Path(__file__).resolve().parent
+ROOT = HERE.parents[1]
+SOURCE = ROOT / 'research/kappa-round3-warp-20261022/ACTUAL-WORD.json.gz'
+PIN = 'cfcd36b40326d7a5815e1db5313444379b3fb756b27d5201c561574c085cc0dd'
+PROFILE = {1:2201, 2:412, 3:510, 4:127, 5:40, 8:8}
+QSYM = 1000000
+KBASE = 10000
+
+
+def need(ok, message):
+    if not ok:
+        raise ValueError(message)
+
+
+def module(name, path):
+    spec = importlib.util.spec_from_file_location(name, path)
+    out = importlib.util.module_from_spec(spec)
+    sys.modules[name] = out
+    exec(compile(path.read_bytes(), str(path), "exec", optimize=0), out.__dict__)
+    return out
+
+
+def authenticate():
+    manifest = json.loads((HERE / 'SOURCES.json').read_text())
+    for record in manifest['files']:
+        if record['usage'] == 'input':
+            path = ROOT / record['path']
+            need(sha256(path.read_bytes()).hexdigest() == record['sha256'],
+                 'Changed live source: ' + record['path'])
+
+
+authenticate()
+ce = module('feedback_clifford', ROOT / 'research/coded-native-caller/clifford_exact.py')
+core = module('feedback_native', ROOT / 'research/native-center-free-code/native_core.py')
+
+
+def literal(word):
+    out = ce.ident(9)
+    for e in word:
+        if e[0] == 'P':
+            part = ce.perm(9, tuple(e[1]))
+        elif e[0] == 'D':
+            part = ce.diag(9, tuple(e[1]), tuple(e[2]))
+        elif e[0] == 'X':
+            part = ce.xgate(9, e[1])
+        elif e[0] == 'phase':
+            part = ce.Op(9, ce.identity(9), [tuple(e)])
+        elif e[0] == 'C':
+            part = ce.cgate(9, e[1], e[2])
+        else:
+            raise ValueError('Unknown physical word')
+        out = out.then(part)
+    return out
+
+
+def equal(a, b):
+    return a.tab == b.tab and a.zero_state() == b.zero_state()
+
+
+def prepend(row, symbol):
+    out = {}
+    for (owner, word), coefficient in row.items():
+        if word and word[0] == -symbol:
+            word = word[1:]
+        else:
+            word = (symbol,) + word
+        if word[:4] == (QSYM,) * 4:
+            word = word[4:]
+        key = (owner, word)
+        out[key] = out.get(key, F()) + coefficient
+    return {key:value for key,value in out.items() if value}
+
+
+def act(row, *symbols):
+    for symbol in reversed(symbols):
+        row = prepend(row, symbol)
+    return row
+
+
+def scalar_program(program, rows, owners):
+    for op in program:
+        dst = owners[op[1]]
+        if op[0] == 'add':
+            core.add(rows[dst], rows[owners[op[2]]], F(op[3]))
+        else:
+            need(op[0] == 'scale' and F(op[2]), 'Nonzero scalar basis SCALE')
+            rows[dst] = {key:F(op[2])*v for key,v in rows[dst].items()}
+
+
+def original_departures(source, bank):
+    c = source['canonical']
+    rows = [core.identity(i) for i in range(633)]
+    first = {}
+    cold = bank['cold_helper_owners']
+    ci = {owner:i for i,owner in enumerate(cold)}
+    for event, e in enumerate(source['programs']['forward']):
+        if e[0] == 'climb' and e[2] in ci and e[2] not in first:
+            owner = e[2]
+            expected = {(cold[j], ()):F(a) for j,a in bank['T_rows'][ci[owner]]}
+            need(e[3] == 0 and rows[owner] == expected, 'Original uncoded first-departure row')
+            first[owner] = event
+        if e[0] == 'scalar':
+            gate = e[1]
+            dst = gate[1][1] + (632 if gate[1][0] == 'C' else 0)
+            if gate[0] == 'clear':
+                need(dst == 632, 'No persistent CLEAR')
+                rows[dst] = {}
+            elif gate[0] == 'copy':
+                src = gate[2][1] + (632 if gate[2][0] == 'C' else 0)
+                need(dst == 632, 'No persistent COPY')
+                rows[dst] = rows[src].copy()
+            elif gate[0] == 'add':
+                src = gate[2][1] + (632 if gate[2][0] == 'C' else 0)
+                core.add(rows[dst], rows[src], F(gate[3], gate[4]))
+            else:
+                need(gate[0] == 'scale', 'Known scalar operation')
+                rows[dst] = {key:F(gate[2],gate[3])*v for key,v in rows[dst].items()}
+        elif e[0] == 'warp':
+            owner = e[1][1] + (632 if e[1][0] == 'C' else 0)
+            rows[owner] = core.warp(rows[owner], e[2], False)
+    need(len(first) == 358, 'Every cold first departure')
+    for owner in range(632):
+        need(rows[owner] == core.expected(owner, False), 'Original FULL endpoint')
+    need(not rows[632], 'Original owned center cleanup')
+    for q in bank['queries']:
+        need(first[q['native_role']] == q['source_event'], 'Selected original event index')
+    return len(first)
+
+
+def check_physics(source, bank):
+    c = source['canonical']
+    Q = ce.cgate(9, 1)
+    Q2 = Q.then(Q)
+    R = ce.fourier(9)
+    need(equal(Q2, ce.xgate(9, 1)), 'Q squared is the exact Pauli X')
+    for q in bank['queries']:
+        K, O = literal(q['input_K']['word']), literal(q['response']['word'])
+        E = ce.canonical_frame(9, c['frames'][q['first_chart']])
+        need(equal(K.then(E).then(O), Q), 'Absolute phase of relocated query')
+        need(equal(K.then(R).then(K.adjoint()), R), 'Full return K commutator')
+        need(equal(Q2.then(O.adjoint()), Q.then(K).then(E)), 'Physical raw feedback identity')
+        for op in (K, O, K.adjoint().then(Q2), O.adjoint()):
+            need(ce.rank([x for x,z,p in op.tab[9:]]) == 0, 'Feedback map has no Gaussian call')
+            compiled, _ = ce.monomial(op)
+            need(equal(compiled, op), 'Feedback monomial absolute phase')
+            need(all(e[0] in ('P','D','X','phase') for e in compiled.circuit), 'Literal monomial operations only')
+    for completion in bank['cold_completions']:
+        role = completion['native_role']
+        need(c['final'][role] == completion['final_chart'], 'Completion source chart')
+        frame = ce.canonical_frame(9, c['frames'][completion['final_chart']])
+        compiled = literal(completion['operator']['word'])
+        need(equal(frame.then(compiled), R), 'Completed return absolute phase')
+        rank = 9 - len(c['frames'][completion['final_chart']])
+        need(rank == completion['charged_child_rank'], 'Completion paid rank')
+        gates = [e for e in compiled.circuit if e[0] == 'C']
+        need(gates == [('C', 1 << i, 1) for i in range(rank)], 'One positive completion child')
+        positions = [i for i, e in enumerate(compiled.circuit) if e[0] == 'C']
+        need(positions == list(range(positions[0], positions[0] + rank)), 'Contiguous completion child')
+    return {'query_identities': len(bank['queries']), 'completion_identities': len(bank['cold_completions'])}
+
+
+def run(source, bank, feedbacks, mutation=None):
+    c, queries = source['canonical'], bank['queries']
+    owners = bank['cold_helper_owners']
+    raw_start, obs_start, scratch = 633, 745, 857
+    owned = 225 + bool(feedbacks)
+    rows = [core.identity(i) for i in range(632 + owned)]
+    charts = c['start'][:] + [None] * owned
+    paid, ordinary = Counter(), Counter()
+    expected_helpers = [core.identity(i) for i in range(632)]
+    for h, k in feedbacks:
+        need(0 <= h < 112 and 0 <= k < 112 and h != k, 'Distinct valid feedback coordinates')
+        core.add(expected_helpers[queries[k]['native_role']],
+                 act(expected_helpers[queries[h]['native_role']], QSYM), F(1))
+
+    def clear(slot, chart):
+        need(slot >= 632, 'No persistent erasure')
+        rows[slot], charts[slot] = {}, chart
+        ordinary['owned_clear'] += 1
+
+    def copy(dst, src):
+        need(dst >= 633 and not rows[dst], 'Owned COPY needs a cleared target')
+        rows[dst], charts[dst] = rows[src].copy(), charts[src]
+        ordinary['owned_copy'] += 1
+
+    for q in queries:
+        j, owner = q['query_index'], q['native_role']
+        rows[owner] = act(rows[owner], KBASE+j)
+        rawslot, obs = raw_start+j, obs_start+j
+        clear(rawslot, 0)
+        copy(rawslot, owner)
+        event = source['programs']['forward'][q['source_event']]
+        need(event[0] == 'climb' and event[2:] == [owner,0,q['first_chart'],1], 'Exact relocated native H1')
+        charts[rawslot] = q['first_chart']
+        paid[1] += 1
+        clear(obs, q['first_chart'])
+        copy(obs, rawslot)
+        rows[obs] = act(core.identity(owner), QSYM)
+        charts[obs] = 0
+
+    def invariant(j):
+        q = queries[j]
+        w, r, o = rows[q['native_role']], rows[raw_start+j], rows[obs_start+j]
+        need(w == r, 'Held raw argument matches current helper coordinate')
+        need(o == act(w, QSYM, -(KBASE+j)), 'Observation matches current helper coordinate')
+        need(charts[raw_start+j] == q['first_chart'], 'Held raw physical chart')
+
+    for index, (h, k) in enumerate(feedbacks):
+        for j in (h,k):
+            invariant(j)
+        wh, wk = queries[h]['native_role'], queries[k]['native_role']
+        if not (mutation == "dirty_scratch" and index == 0):
+            clear(scratch, 0)
+        copy(scratch, obs_start+h)
+        rows[scratch] = act(rows[scratch], KBASE+k)
+        ordinary['monomial_map'] += 1
+        core.add(rows[wk], rows[scratch], F(1))
+        ordinary['scalar_add'] += 1
+        clear(scratch, 0)
+        copy(scratch, wh)
+        symbols = (QSYM, -(KBASE+h)) if mutation == "one_Q" and index == 0 else (QSYM, QSYM, -(KBASE+h))
+        rows[scratch] = act(rows[scratch], *symbols)
+        ordinary['monomial_map'] += 1
+        if not (mutation == "stale_observation" and index == 0):
+            core.add(rows[obs_start+k], rows[scratch], F(1))
+        ordinary['scalar_add'] += 1
+        # The exact physical identity above changes the declared chart here.
+        rows[scratch] = act(rows[wh], KBASE+k, QSYM, -(KBASE+h))
+        charts[scratch] = queries[k]['first_chart']
+        ordinary['monomial_map'] += 1
+        if not (mutation == "stale_raw" and index == 0):
+            core.add(rows[raw_start+k], rows[scratch], F(1))
+        ordinary['scalar_add'] += 1
+        if not (mutation == "live_scratch" and index == len(feedbacks) - 1):
+            clear(scratch, 0)
+        for j in (h,k):
+            invariant(j)
+
+    for q in queries:
+        actual = act(rows[q['native_role']], -(KBASE+q['query_index']))
+        need(actual == expected_helpers[q['native_role']], 'Independent elementary feedback endpoint')
+    desired = [row.copy() for row in rows[:632]]
+    scalar_program(bank['entrance_scalar_program'], rows, owners)
+    entered = [row.copy() for row in rows[:632]]
+    by_event = {q['source_event']:q for q in queries}
+    cuts = 0
+    for event_index, e in enumerate(source['programs']['forward']):
+        if event_index in by_event:
+            q = by_event[event_index]
+            owner, rawslot = q['native_role'], raw_start+q['query_index']
+            need(charts[owner] == 0 and charts[rawslot] == q['first_chart'], 'Replacement charts')
+            need(rows[owner] == rows[rawslot], 'Replacement row on all original and owned inputs')
+            rows[owner], rows[rawslot] = rows[rawslot], rows[owner]
+            if not (mutation == 'chart_swap' and cuts == 0):
+                charts[owner], charts[rawslot] = charts[rawslot], charts[owner]
+            need(charts[owner] == q['first_chart'] and charts[rawslot] == 0, 'Replacement chart transport')
+            ordinary['physical_field_swap'] += 1
+            clear(rawslot, 0)
+            cuts += 1
+            continue
+        kind = e[0]
+        if kind == 'scalar':
+            gate, chart = e[1:]
+            dst = gate[1][1]+(632 if gate[1][0] == 'C' else 0)
+            if gate[0] == 'clear':
+                need(dst == 632, 'Native persistent erasure')
+                rows[dst], charts[dst] = {}, chart
+                continue
+            need(charts[dst] == chart, 'Native scalar destination chart')
+            if gate[0] in ('copy','add'):
+                src = gate[2][1]+(632 if gate[2][0] == 'C' else 0)
+                need(charts[src] == chart, 'Native scalar source chart')
+                if gate[0] == 'copy':
+                    need(dst == 632, 'Native persistent overwrite')
+                    rows[dst] = rows[src].copy()
+                else:
+                    core.add(rows[dst], rows[src], F(gate[3],gate[4]))
+            else:
+                need(gate[0] == 'scale', 'Known native scalar')
+                rows[dst] = {key:F(gate[2],gate[3])*v for key,v in rows[dst].items()}
+        elif kind == 'warp':
+            _, ref, op, before, after = e
+            owner = ref[1]+(632 if ref[0] == 'C' else 0)
+            need(charts[owner] == before, 'Native warp chart')
+            rows[owner], charts[owner] = core.warp(rows[owner], op, False), after
+        elif kind in ('climb','center'):
+            if kind == 'climb':
+                _,_,owner,before,after,rank = e
+                need(rank == len(c['frames'][after])-len(c['frames'][before]), 'Native climb rank')
+            else:
+                _,index,before,after,rank = e
+                owner = 632+index
+                need(rank == abs(len(c['frames'][after])-len(c['frames'][before])), 'Native center rank')
+            need(charts[owner] == before, 'Native paid chart')
+            charts[owner] = after
+            paid[rank] += 1
+        else:
+            need(kind in ('phase','adapter','residual_adapter'), 'Known native marker')
+    for owner in range(632):
+        expected = entered[owner].copy()
+        if 112 <= owner < 224:
+            core.add(expected, entered[owner-112], F(1))
+        need(rows[owner] == expected, 'Complete original FULL endpoint on transformed helper inputs')
+    need(charts[:632] == c['final'], 'Original final charts')
+    need(paid == Counter(PROFILE), 'All original Gaussian children, including eight centers')
+    for index, completion in enumerate(bank['cold_completions']):
+        if mutation == 'missing_completion' and index == 0:
+            continue
+        charts[completion['native_role']] = 1
+        paid[completion['charged_child_rank']] += 1
+    need(all(charts[owner] == 1 for owner in owners), 'Common return chart before scalar decoding')
+    scalar_program(bank['exit_scalar_program'], rows, owners)
+    for q in queries:
+        owner, j = q['native_role'], q['query_index']
+        rows[owner] = act(rows[owner], -(KBASE+j))
+        desired[owner] = act(desired[owner], -(KBASE+j))
+    for owner in owners:
+        need(rows[owner] == desired[owner] == expected_helpers[owner], 'Returned transformed helper after completion and decode')
+    for q in queries:
+        j = q['query_index']
+        need(rows[obs_start+j] == act(desired[q['native_role']], QSYM), 'Retained normalized feedback observation')
+        clear(obs_start+j, 0)
+    need(all(not row for row in rows[632:]), 'Every arbitrary owned input removed and every owned output cleared')
+    n = len(feedbacks)
+    need(ordinary == Counter(owned_clear=448+3*n, owned_copy=224+2*n,
+                            physical_field_swap=112, scalar_add=3*n, monomial_map=3*n), 'Complete added ordinary invoice')
+    return dict(status='PASS_UNCODED_FORWARD_EARLY_QUERY_FEEDBACK',
+                source_payload_sha256=PIN,
+                original_inputs=632, arbitrary_owned_inputs=owned, replacement_cuts=cuts,
+                feedbacks=feedbacks, completed_paid=dict(sorted(paid.items())),
+                helper_output_ranks_on_transformed_coordinates={4:2,7:7,8:41,9:358},
+                ordinary=ordinary, all_owned_outputs_zero=True,
+                source_scope='Original forward FULL, all eight centers retained.',
+                target_scope='Helpers return on the transformed independent coordinates. A closed caller must prove its target.',
+                fixed_basis_adds=6420, fixed_basis_scales=408,
+                fixed_monomial_maps_at_most=400, additional_owned_fields=224 + bool(feedbacks),
+                limitation='Forward interface only. No caller closure, complete precision tariff, or kappa improvement is claimed.')
+
+
+def produce():
+    raw = gzip.decompress(SOURCE.read_bytes())
+    need(sha256(raw).hexdigest() == PIN, 'Pinned native payload')
+    source = json.loads(raw)
+    bank = json.loads((ROOT / 'research/native-helper-query-bank/BANK.json').read_text())
+    first = original_departures(source, bank)
+    physics = check_physics(source, bank)
+    feedbacks = [(0,1), (1,0), (1,2), (2,111), (111,0)]
+    result = run(source, bank, feedbacks)
+    result['first_departure_rows_checked'] = first
+    result['physical_checks'] = physics
+    result['empty_sequence_control'] = run(source, bank, [])['ordinary']
+    controls = []
+    for mutation, expected in [
+        ('stale_raw', 'Held raw argument matches current helper coordinate'),
+        ('stale_observation', 'Observation matches current helper coordinate'),
+        ('one_Q', 'Observation matches current helper coordinate'),
+        ('chart_swap', 'Replacement chart transport'),
+        ('dirty_scratch', 'Owned COPY needs a cleared target'),
+        ('live_scratch', 'Every arbitrary owned input removed and every owned output cleared'),
+        ('missing_completion', 'Common return chart before scalar decoding'),
+    ]:
+        try:
+            run(source, bank, feedbacks, mutation)
+        except ValueError as exc:
+            need(str(exc) == expected, 'Wrong mutation rejection: ' + mutation + ': ' + str(exc))
+            controls.append({'mutation': mutation, 'result': 'REJECT', 'reason': str(exc)})
+        else:
+            raise ValueError('Mutation passed: ' + mutation)
+    result['rejected_controls'] = controls
+    comparator = module('feedback_invoice', ROOT / 'scripts/compare_recursive_invoices.py')
+    old = json.loads((HERE / 'SOURCE-INVOICE.json').read_text())
+    new = json.loads((HERE / 'COMPLETION-INVOICE.json').read_text())
+    old_helpers = Counter(len(source['canonical']['frames'][source['canonical']['final'][j]]) -
+                          len(source['canonical']['frames'][source['canonical']['start'][j]])
+                          for j in range(224, 632))
+    need({int(r): n for r, n in old['paid'].items()} == PROFILE, 'Source invoice paid profile')
+    need({int(r): n for r, n in old['targets'].items()} == old_helpers, 'Source invoice helper profile')
+    need({int(r): n for r, n in new['paid'].items()} == result['completed_paid'], 'Completion invoice paid profile')
+    need({int(r): n for r, n in new['targets'].items()} == result['helper_output_ranks_on_transformed_coordinates'],
+         'Completion invoice helper profile before feedback')
+    comparison = comparator.compare_invoices(old, new)
+    need(comparison['classification'] == 'uniformly_worse', 'Completion is a strict concave-moment loss')
+    need(comparison['rank_mass']['delta']['paid'] == comparison['rank_mass']['delta']['targets'] == 136,
+         'Completion paid and target rank-mass change')
+    result['completion_invoice_preflight'] = comparison
+    return result
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--emit', action='store_true', help='Write the result for package authors.')
+    args = parser.parse_args()
+    result = produce()
+    payload = json.dumps(result, sort_keys=True, indent=2) + '\n'
+    path = HERE / 'RESULT.json'
+    if args.emit:
+        path.write_text(payload)
+    else:
+        expected = json.dumps(json.loads(path.read_text()), sort_keys=True, indent=2) + '\n'
+        need(payload == expected, 'Saved typed mathematical receipt differs')
+    print(result['status'], json.dumps({'original_inputs': result['original_inputs'],
+          'owned_inputs': result['arbitrary_owned_inputs'], 'replacement_cuts': result['replacement_cuts'],
+          'feedback_shears': len(result['feedbacks']), 'rejected_controls': len(result['rejected_controls'])}, sort_keys=True))
+
+
+if __name__ == '__main__':
+    main()