diff --git a/research/cut9047-caller-witness-domain/PROOF.md b/research/cut9047-caller-witness-domain/PROOF.md
new file mode 100644
index 0000000000..52e2993b4b
--- /dev/null
+++ b/research/cut9047-caller-witness-domain/PROOF.md
@@ -0,0 +1,100 @@
+# Caller-domain admissibility at cut 9047
+
+No new κ. The selected record stays `781451/250000000`. This note does not
+replay the native word. It uses the coframed rows already recorded by
+#5546 and the entrance program already recorded by #5402.
+
+## Entrance
+
+The #5413 caller runs `PROVIDER_5402` before the native word. On this word
+that schedule is: multiply each mode owner by 2, run the 834-instruction
+`input_basis_program`, then execute the word. The same `PROVIDER.json` bytes
+are the capsule input of `research/selected-caller-exact-grid`.
+
+Owners `0..223` are mains. Owners `224..631` are helpers. The basis mixes
+122 helpers, `basis_roles`. The eight mode owners are
+
+```text
+224, 225, 227, 229, 240, 241, 256, 257.
+```
+
+Each mode input is also multiplied by the monomial `Km` before the basis.
+`Km` is a `D`/`P`/`X`/phase word. It is not an empty native warp word, so it
+is not one of the keys in the #5546 row table. The two readings below differ
+only in whether that monomial is collapsed to a rational owner coefficient.
+
+The published coframed rows, with every warp word empty, are
+
+| Row | Terms |
+| --- | --- |
+| L19 | `L19` |
+| L300 | `L19 + (1/2)L293 - L298 + L300 + (1/4)L505` |
+| L301 | `L19 - L226 - (1/2)L288 + (1/2)L293 + (1/2)L296 - L298 + L301 - (1/2)L302 + L303` |
+
+#5546 shows that `(L300=u, L505=-4u)` and `(L301=u, L226=u)`, with every
+other native input fixed, preserve these three rows and move the corresponding
+pure coordinate by `u`.
+
+## Owner-rational reading
+
+Ignore the operator content of `Km` and keep only the scalar 2. The resulting
+map on the 122 basis owners has rank 122, so it is bijective, and it is the
+identity on every other owner. Both published native witnesses are therefore
+entrance states:
+
+- public `(L300=u, L240=-u/2, L505=-4u)`, every other public input 0, arrives
+  as native `(L300=u, L505=-4u)`;
+- public `(L301=u, L226=u)` arrives unchanged.
+
+`L240` is a mode owner. `L226`, `L301` and `L505` are helpers outside the
+basis. In this reading the published separators transfer verbatim, because
+their native images are exactly the witnesses #5546 already checked.
+
+## Empty-warp reading
+
+Hold every mode input at 0, so no `Km` key is present. Public inputs are then
+bare helper atoms. On those atoms the basis sends public `L300` to native
+`L300` with coefficient 1, and it also writes that same atom into other native
+helpers. The coframed row L301 reads four of them:
+
+```text
+L288 = -u/4,  L296 = u/4,  L302 = u/4,  L303 = -u/2.
+```
+
+Their L301 coefficients give
+
+```text
+(-1/2)(-1/4) + (1/2)(1/4) + (-1/2)(1/4) + (1)(-1/2) = -3/8.
+```
+
+So the verbatim public pair `(L300=u, L505=-4u)` still kills rows L19 and
+L300, and still moves native `L300` by `u`, but it moves row L301 by `-3u/8`.
+It is not a separator in this sector. No other bare public atom reaches native
+`L300`, so the leak cannot be removed while keeping native `L300 = u` and
+every mode input at 0, except by cancelling it downstream in the row.
+
+`L226` is outside the basis, and row L301 has coefficient `-1` on it. Public
+
+```text
+(L300=u, L505=-4u, L226=-3u/8),
+```
+
+with every mode input and every other public input 0, adds `+3u/8` to row
+L301 and does not meet rows L19 or L300. All three rows stay fixed, and native
+`L300` still moves by `u`.
+
+`L301` and `L226` are both outside the basis and outside the mode set, so the
+published pair `(L301=u, L226=u)` is already an empty-warp entrance state.
+It fixes the three rows and moves native `L301` by `u`.
+
+Thus both pure coordinates remain separated by legal empty-warp inputs. The
+obstruction transfers. The extra `L226` term is a correction of the witness,
+not a new prefix, basis, or anchor.
+
+## What this does not say
+
+A nonzero `Km` input is a different formal key. This package does not replay
+those keys through events `0..9047`, so it does not claim they stay out of the
+empty-warp sector at the cut. The witnesses above set those inputs to zero.
+Mains, including `L19`, stay fixed. No paid-profile change, new helper
+inventory, or selected-record update is claimed.
diff --git a/research/cut9047-caller-witness-domain/README.md b/research/cut9047-caller-witness-domain/README.md
new file mode 100644
index 0000000000..f403572730
--- /dev/null
+++ b/research/cut9047-caller-witness-domain/README.md
@@ -0,0 +1,67 @@
+# Caller admissibility of the cut-9047 witnesses
+
+**Scoped audit; no new κ.** The #5546 separators at forward cut 9047 still
+work on the #5402 entrance that the #5413 caller runs. The selected record is
+unchanged (`781451/250000000`).
+
+#5546 proved that the native variations `(L300=u, L505=-4u)` and
+`(L301=u, L226=u)` fix the three coframed rows and move the pure helper
+coordinates. It left open whether those variations are legal inputs of the
+caller. This package checks that entrance and does not rerun the word.
+
+The entrance multiplies eight mode owners by 2, applies monomials `Km`, and
+runs the 834-instruction input basis on 122 helpers. [PROOF.md](PROOF.md)
+records two readings.
+
+- If `Km` is collapsed to the scalar 2, the entrance has rank 122. The
+  published L300 witness is the public input `(L300=u, L240=-u/2, L505=-4u)`.
+  The published L301 witness is already public. Both transfer verbatim.
+- If mode inputs are kept out of the empty-warp keys, the verbatim L300 pair
+  moves coframed row L301 by `-3u/8`. The bare public correction
+  `(L300=u, L505=-4u, L226=-3u/8)` fixes every coframed row and still moves
+  native `L300` by `u`. The L301 witness is unchanged.
+
+Either reading supplies a legal variation that preserves the cut rows and
+moves the pure coordinate. No prefix, basis, or anchor change is nominated.
+The checker prints `PASS_CUT9047_CALLER_WITNESS_DOMAIN`.
+
+## Reproduce
+
+From the repository root, Python 3.12, standard library only:
+
+```sh
+python3 -B scripts/research_package.py --package research/cut9047-caller-witness-domain
+python3 -B research/cut9047-caller-witness-domain/verify.py
+```
+
+The registered command has a 60-second timeout. It authenticates the compressed
+word, the provider entrance and the #5546 row table, checks that all three
+bind the same payload, and evaluates the rank, the warp-blind preimage, the
+`-3/8` leak and the corrected separator. Three mutations must fail: a zero
+scale, a dropped `L226` correction, and a wrong `L505` coefficient.
+
+## Scope
+
+The coframed rows are an input from #5546, not a new derivation. `Km` is not
+replayed through the 9,047 native events. Mains stay fixed. This is not a
+paid-profile change, a compiler or precision bill, or a multiplication theorem.
+
+## Open next questions
+
+- After each mode monomial `Km` is carried through forward events `0..9047`,
+  does any `Km`-keyed term meet a coframed row on the empty warp word? The
+  bare witnesses set every mode input to zero, so they do not use that replay.
+  A term that returns to the empty word would need its own separator.
+- If a later caller replaces the #5402 basis, the corrected witness has to be
+  recomputed before any prefix credit. No replacement entrance is proposed here.
+
+## Credit
+
+Cao Yifan supplied the #4610 word. Dillon Amburgey supplied the #5402 provider
+entrance. Chris R (Clear1nsight) supplied the #5546 cut and the #5413 caller
+schedule that runs that entrance. The coded-native-caller and balanced-J
+lineage supplied the main/helper split this audit uses only as classification.
+Retain the source authors credited in those packages.
+
+Prepared by unpaidmoon with substantial Cursor Grok assistance. New material
+is Apache-2.0. The pinned inputs are unchanged.
diff --git a/research/cut9047-caller-witness-domain/SOURCES.json b/research/cut9047-caller-witness-domain/SOURCES.json
new file mode 100644
index 0000000000..9962d50588
--- /dev/null
+++ b/research/cut9047-caller-witness-domain/SOURCES.json
@@ -0,0 +1,36 @@
+{
+  "schema_version": 1,
+  "base_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+  "files": [
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec",
+      "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81"
+    },
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "git_blob": "d59b5035e7b4cbaa9d688a1d32dd0d6eb79c466a",
+      "sha256": "9b8d0eea95b3bf0dfcb7938a732a6439b87a2685dec2a5ab9e525b3b34debbfa"
+    },
+    {
+      "path": "research/kappa-round3-warp-20261022/ACTUAL-WORD.json.gz",
+      "usage": "input",
+      "git_blob": "46d929df83817b85a5387bcdb9745e0627d6366e",
+      "sha256": "7679daa4ec6a40f56fc7f0202379a6f454310e94945aba4f48beaaaafb838d05"
+    },
+    {
+      "path": "research/native-rank8-helper-provider/PROVIDER.json",
+      "usage": "input",
+      "git_blob": "0afd30ed01202eb6ce62462dcf8bc9164f3b0455",
+      "sha256": "676de7551d3364598f4a7e29ae97cae0e4364348786bbe70435b84294ba7dd65"
+    },
+    {
+      "path": "research/shared-crossing-cut9047-20261025/expected/RESULT.json",
+      "usage": "input",
+      "git_blob": "ee8a91838b4deabe9a35147c7c8a960dbe7bf819",
+      "sha256": "70a30ac467a8d9a2b15e54d88b519258ef5bfff98fed11832a208c31c4fd0c81"
+    }
+  ]
+}
diff --git a/research/cut9047-caller-witness-domain/TASK.json b/research/cut9047-caller-witness-domain/TASK.json
new file mode 100644
index 0000000000..db5074f261
--- /dev/null
+++ b/research/cut9047-caller-witness-domain/TASK.json
@@ -0,0 +1,81 @@
+{
+  "schema_version": 1,
+  "task_id": "complex-new-helper-inventory",
+  "priority_revision": 8,
+  "base_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+  "original_card": {
+    "id": "complex-new-helper-inventory",
+    "question": "Can a changed helper inventory earn productive credit that survives completion, compilation and the actual caller?",
+    "starting_points": [
+      "docs/research/current-priorities.md",
+      "docs/research/research-family-status.md",
+      "certificates/selected-result.json",
+      "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md"
+    ],
+    "methods": [
+      "Construct and independently check one source-bound instance of the stated first experiment.",
+      "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change."
+    ],
+    "acceptance_gate": "A source-bound arbitrary-input identity and legal producer/consumer boundary with the complete paid and productive target invoice, including restoration, ownership, native alignment and extra charges. Price under the actual current model; historical ceiling.py assumptions must be established before use. A favorable optimistic relaxation keeps a route open but is not a completed supplier. A scoped local result remains useful; expansion requires the family-level budget gate.",
+    "first_step": {
+      "command": [
+        "python3",
+        "-B",
+        "scripts/research_selected_baseline.py"
+      ],
+      "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY",
+      "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.",
+      "scope": "Source-bound orientation only, not a supplier replay or theorem proof."
+    },
+    "first_experiment": "Specify all arbitrary inputs, owned fields, restored outputs and a physically legal consumer. Compare complete P and T, including target debits and precision/stock costs. #5599 is a positive control for target refinement, not permission to split every helper for free. #5614 is a hypothetical compiler budget, not an emitted 145-split word. Stop at the first unpaid boundary or a failing optimistic full bill.",
+    "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.",
+    "allowed_variations": [
+      "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes."
+    ],
+    "scope_change_triggers": [
+      "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.",
+      "Treating an archived proposal or local numerical pass as complete supplier admission."
+    ],
+    "overlap_terms": [
+      "productive helper",
+      "target refinement",
+      "5599",
+      "5614"
+    ],
+    "existing_checks": [
+      {
+        "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.",
+        "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md",
+        "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.",
+        "status": "reviewed",
+        "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137",
+        "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5"
+      }
+    ]
+  },
+  "scope_status": "refined",
+  "actual_scope": "Audit whether the #5546 cut-9047 separating witnesses are admissible inputs of the #5402 entrance used by the #5413 caller. No new helper inventory, paid profile, or kappa.",
+  "scope_change_reason": "The live handoff asks only for caller-domain admissibility of the already proved cut-9047 witnesses, not for a new productive inventory. The original card's complete-supplier gate is not claimed.",
+  "bottleneck_link": "A shared-helper split earns no caller credit if its separating inputs are illegal, and it still fails if a legal input variation keeps the same cut rows fixed while moving the pure helper coordinates.",
+  "budget_minutes": 60,
+  "stop_rule": "One entrance audit of the two published witnesses, then stop. Do not rerun scalar purification and do not nominate a new prefix, basis, or anchor.",
+  "outcome": "negative-result",
+  "evidence": "PROOF.md; verify.py; pinned PROVIDER.json entrance; pinned #5546 selected rows; pinned ACTUAL-WORD payload hash.",
+  "author": "unpaidmoon",
+  "ai_assistance": "Prepared by unpaidmoon with substantial Cursor Grok assistance. Agent execution is not independent human or formal-theorem admission.",
+  "open_questions": [
+    {
+      "question": "After the eight mode monomials Km are carried through forward events 0..9047, does any Km-keyed term arrive at a coframed row with an empty native warp word?",
+      "why_it_matters": "The empty-warp certificate holds every mode input at zero. A Km term that returns to the empty word could add columns to the coframed rows and would need its own separator.",
+      "first_step": "Replay each pinned Km word as the initial operator of its mode owner through the pinned forward prefix and read the empty-warp coefficients of rows L19, L300 and L301.",
+      "blocked_by": "This package does not replay the native word. The bare witnesses do not depend on that replay because they set every mode input to zero."
+    },
+    {
+      "question": "Does a later change of the #5402 input basis make the corrected bare witness illegal?",
+      "why_it_matters": "The transferred obstruction uses this fixed entrance. A different basis is a different caller domain and is not ruled out by the rank-122 identity proved here.",
+      "first_step": "Name the replacement basis program, rerun this checker, and require a new legal separator or an explicit failure before any prefix credit.",
+      "blocked_by": "No replacement entrance is proposed in this package."
+    }
+  ],
+  "original_card_acceptance_gate_met": false
+}
diff --git a/research/cut9047-caller-witness-domain/VERIFY.json b/research/cut9047-caller-witness-domain/VERIFY.json
new file mode 100644
index 0000000000..691437c1c3
--- /dev/null
+++ b/research/cut9047-caller-witness-domain/VERIFY.json
@@ -0,0 +1,22 @@
+{
+  "schema_version": 1,
+  "status": "ready",
+  "python": "3.12",
+  "requirements": [],
+  "inputs": [
+    "research/kappa-round3-warp-20261022/ACTUAL-WORD.json.gz",
+    "research/native-rank8-helper-provider/PROVIDER.json",
+    "research/shared-crossing-cut9047-20261025/expected/RESULT.json"
+  ],
+  "commands": [
+    {
+      "argv": [
+        "{python}",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 60,
+      "checks": "Hash-pin the word, the #5402 entrance and the #5546 coframed rows. Check basis rank 122, the warp-blind preimage of the published L300 witness, the empty-warp leak R301=-3/8, and the bare correction that restores both separators. Reject a zero scale, a dropped L226 correction and a wrong L505 coefficient."
+    }
+  ]
+}
diff --git a/research/cut9047-caller-witness-domain/verify.py b/research/cut9047-caller-witness-domain/verify.py
new file mode 100644
index 0000000000..2593bfb526
--- /dev/null
+++ b/research/cut9047-caller-witness-domain/verify.py
@@ -0,0 +1,260 @@
+#!/usr/bin/env python3
+"""Caller-domain admissibility of the published cut-9047 witnesses.
+
+Standard library only. Does not replay the native word and does not change kappa.
+The coframed rows are the pinned #5546 table. The entrance is the pinned #5402
+input basis, preceded by scalar 2 on each mode owner.
+"""
+from fractions import Fraction as F
+import gzip
+import hashlib
+import json
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+WORD = ROOT / "research/kappa-round3-warp-20261022/ACTUAL-WORD.json.gz"
+PROVIDER = ROOT / "research/native-rank8-helper-provider/PROVIDER.json"
+ROWS = ROOT / "research/shared-crossing-cut9047-20261025/expected/RESULT.json"
+WORD_SHA = "7679daa4ec6a40f56fc7f0202379a6f454310e94945aba4f48beaaaafb838d05"
+PAYLOAD_SHA = "cfcd36b40326d7a5815e1db5313444379b3fb756b27d5201c561574c085cc0dd"
+PROVIDER_SHA = "676de7551d3364598f4a7e29ae97cae0e4364348786bbe70435b84294ba7dd65"
+ROWS_SHA = "70a30ac467a8d9a2b15e54d88b519258ef5bfff98fed11832a208c31c4fd0c81"
+MODES = (224, 225, 227, 229, 240, 241, 256, 257)
+
+
+def require(ok, message):
+    if not ok:
+        raise SystemExit("FAIL: " + message)
+
+
+def sha256(path):
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+
+def sparse_add(row, key, coefficient):
+    value = row.get(key, F(0)) + coefficient
+    if value:
+        row[key] = value
+    else:
+        row.pop(key, None)
+
+
+def load():
+    require(sha256(WORD) == WORD_SHA, "ACTUAL-WORD compressed hash")
+    payload = gzip.decompress(WORD.read_bytes())
+    require(hashlib.sha256(payload).hexdigest() == PAYLOAD_SHA, "ACTUAL-WORD payload hash")
+    require(sha256(PROVIDER) == PROVIDER_SHA, "PROVIDER.json hash")
+    require(sha256(ROWS) == ROWS_SHA, "#5546 RESULT.json hash")
+    provider = json.loads(PROVIDER.read_text(encoding="utf-8"))
+    result = json.loads(ROWS.read_text(encoding="utf-8"))
+    require(provider["source_payload_sha256"] == PAYLOAD_SHA, "provider binds the same word payload")
+    require(result["source_decompressed_sha256"] == PAYLOAD_SHA, "#5546 rows bind the same word payload")
+    require(result["source_compressed_sha256"] == WORD_SHA, "#5546 rows bind the compressed word")
+    require(tuple(provider["mode_owners"]) == MODES, "eight mode owners")
+    roles = provider["basis_roles"]
+    require(len(roles) == len(set(roles)) == 122, "122 distinct basis owners")
+    require(set(MODES) <= set(roles), "modes lie in the basis")
+    require(all(224 <= owner < 632 for owner in roles), "basis owners are helpers")
+    program = provider["input_basis_program"]
+    require(len(program) == 834, "834 entrance instructions")
+    require(all(ins[0] in ("add", "scale") for ins in program), "basis uses only add and scale")
+    require(all(F(ins[2]) != 0 for ins in program if ins[0] == "scale"), "every scale is nonzero")
+    touched = set()
+    for ins in program:
+        if ins[0] == "add":
+            touched.add(ins[1])
+            touched.add(ins[2])
+        else:
+            touched.add(ins[1])
+    require(touched == set(roles), "basis support equals basis_roles")
+    return provider, result, roles, program
+
+
+def published_rows(result):
+    rows = {}
+    for owner, terms in result["selected_rows"].items():
+        row = {}
+        for term in terms:
+            require(term["warp_word"] == [], "published rows are empty-warp")
+            key = int(term["input"][1:])
+            require(term["input"] == "L" + str(key), "published input name")
+            sparse_add(row, key, F(term["numerator"], term["denominator"]))
+        rows[int(owner)] = row
+    require(set(rows) == {19, 300, 301}, "coframed owners L19, L300, L301")
+    require(rows[19] == {19: F(1)}, "row D")
+    require(rows[300] == {19: F(1), 293: F(1, 2), 298: F(-1), 300: F(1), 505: F(1, 4)}, "row R300")
+    require(rows[301] == {
+        19: F(1), 226: F(-1), 288: F(-1, 2), 293: F(1, 2), 296: F(1, 2),
+        298: F(-1), 301: F(1), 302: F(-1, 2), 303: F(1),
+    }, "row R301")
+    return rows
+
+
+def warp_blind(program, public):
+    """Rational owner map: scale each mode by 2, then run the basis in place."""
+    state = {owner: coefficient for owner, coefficient in public.items() if coefficient}
+    for owner in MODES:
+        if owner in state:
+            state[owner] *= 2
+            if state[owner] == 0:
+                state.pop(owner)
+    for ins in program:
+        if ins[0] == "add":
+            destination, source, coefficient = ins[1], ins[2], F(ins[3])
+            if source in state:
+                sparse_add(state, destination, coefficient * state[source])
+        else:
+            field, coefficient = ins[1], F(ins[2])
+            if field in state:
+                updated = state[field] * coefficient
+                if updated:
+                    state[field] = updated
+                else:
+                    state.pop(field)
+    return state
+
+
+def bare_columns(roles, program):
+    """Empty-warp columns of non-mode public helpers. Mode keys are omitted."""
+    rows = {}
+    for owner in roles:
+        rows[owner] = {(owner, "mode"): F(2)} if owner in MODES else {(owner, "bare"): F(1)}
+    for ins in program:
+        if ins[0] == "add":
+            destination, source, coefficient = ins[1], ins[2], F(ins[3])
+            for key, value in rows[source].items():
+                sparse_add(rows[destination], key, coefficient * value)
+        else:
+            field, coefficient = ins[1], F(ins[2])
+            rows[field] = {
+                key: value * coefficient
+                for key, value in rows[field].items()
+                if value * coefficient
+            }
+    columns = {}
+    for source in roles:
+        if source in MODES:
+            continue
+        column = {}
+        for owner, terms in rows.items():
+            coefficient = terms.get((source, "bare"), F(0))
+            if coefficient:
+                column[owner] = coefficient
+        columns[source] = column
+    return columns
+
+
+def empty_warp_image(columns, public):
+    image = {}
+    for source, coefficient in public.items():
+        if coefficient == 0:
+            continue
+        require(source not in MODES, "empty-warp witness sets every mode input to zero")
+        column = columns.get(source)
+        if column is None:
+            sparse_add(image, source, coefficient)
+        else:
+            for owner, value in column.items():
+                sparse_add(image, owner, coefficient * value)
+    return image
+
+
+def dots(rows, image):
+    return {
+        owner: sum(image.get(native, F(0)) * coefficient for native, coefficient in row.items())
+        for owner, row in rows.items()
+    }
+
+
+def rank(program, roles):
+    columns = [warp_blind(program, {owner: F(1)}) for owner in roles]
+    matrix = [[column.get(owner, F(0)) for column in columns] for owner in roles]
+    width = len(roles)
+    rank_value = 0
+    for column in range(width):
+        pivot = None
+        for row in range(rank_value, width):
+            if matrix[row][column] != 0:
+                pivot = row
+                break
+        if pivot is None:
+            continue
+        matrix[rank_value], matrix[pivot] = matrix[pivot], matrix[rank_value]
+        lead = matrix[rank_value][column]
+        matrix[rank_value] = [value / lead for value in matrix[rank_value]]
+        for row in range(width):
+            if row == rank_value:
+                continue
+            factor = matrix[row][column]
+            if factor == 0:
+                continue
+            matrix[row] = [
+                matrix[row][index] - factor * matrix[rank_value][index]
+                for index in range(width)
+            ]
+        rank_value += 1
+    return rank_value
+
+
+def controls(program, roles, rows, columns):
+    rejected = []
+    broken = [list(ins) for ins in program]
+    scale = next(ins for ins in broken if ins[0] == "scale")
+    scale[2] = "0"
+    require(rank(broken, roles) < 122, "a zero scale must drop the entrance rank")
+    rejected.append("zero_scale_drops_rank")
+
+    leaked = empty_warp_image(columns, {300: F(1), 505: F(-4)})
+    require(dots(rows, leaked) == {19: F(0), 300: F(0), 301: F(-3, 8)}, "uncorrected witness leaves R301=-3/8")
+    require(leaked.get(300) == 1 and leaked.get(505) == -4, "uncorrected image still moves L300 and L505")
+    rejected.append("verbatim_L300_witness_not_an_empty_warp_separator")
+
+    wrong_505 = empty_warp_image(columns, {300: F(1), 505: F(-3), 226: F(-3, 8)})
+    require(dots(rows, wrong_505)[300] != 0, "a wrong L505 coefficient must move R300")
+    rejected.append("wrong_L505_coefficient")
+
+    cleared = empty_warp_image(columns, {505: F(-4), 226: F(-3, 8)})
+    require(cleared.get(300, F(0)) == 0, "without public L300 the pure coordinate stays fixed")
+    rejected.append("missing_public_L300")
+    return rejected
+
+
+def main():
+    provider, result, roles, program = load()
+    rows = published_rows(result)
+    require(rank(program, roles) == 122, "owner-rational entrance rank")
+    blind = warp_blind(program, {300: F(1), 240: F(-1, 2), 505: F(-4)})
+    require(blind == {300: F(1), 505: F(-4)}, "warp-blind preimage of the published L300 witness")
+    blind_301 = warp_blind(program, {301: F(1), 226: F(1)})
+    require(blind_301 == {301: F(1), 226: F(1)}, "warp-blind image of the published L301 witness")
+
+    columns = bare_columns(roles, program)
+    require(300 in roles and 300 not in MODES, "L300 is a bare basis helper")
+    for owner in (226, 293, 301, 505):
+        require(owner not in roles and owner not in MODES and owner >= 224, "free helper " + str(owner))
+    require(19 < 224 and 19 not in roles, "L19 is a main and is not mixed by the basis")
+    require(columns[300].get(300) == 1, "public L300 reaches native L300 with coefficient 1")
+    require(all(source == 300 or columns[source].get(300, F(0)) == 0 for source in columns),
+            "no other bare public reaches native L300")
+
+    corrected = empty_warp_image(columns, {300: F(1), 505: F(-4), 226: F(-3, 8)})
+    require(dots(rows, corrected) == {19: F(0), 300: F(0), 301: F(0)}, "corrected bare witness fixes every coframed row")
+    require(corrected.get(300) == 1 and corrected.get(301, F(0)) == 0, "corrected witness moves only the L300 target")
+    carried = empty_warp_image(columns, {301: F(1), 226: F(1)})
+    require(carried == {301: F(1), 226: F(1)}, "L301 witness is unchanged by the entrance")
+    require(dots(rows, carried) == {19: F(0), 300: F(0), 301: F(0)}, "L301 witness fixes every coframed row")
+    rejected = controls(program, roles, rows, columns)
+    print("PASS_CUT9047_CALLER_WITNESS_DOMAIN")
+    print(json.dumps({
+        "entrance_rank": 122,
+        "warp_blind_L300_public": {"L300": "1", "L240": "-1/2", "L505": "-4"},
+        "empty_warp_L300_public": {"L300": "1", "L505": "-4", "L226": "-3/8"},
+        "empty_warp_L301_public": {"L301": "1", "L226": "1"},
+        "verbatim_empty_warp_R301": "-3/8",
+        "controls": rejected,
+        "new_kappa": False,
+    }, sort_keys=True))
+
+
+if __name__ == "__main__":
+    main()