diff --git a/research/p104-fiber-tag-seam/README.md b/research/p104-fiber-tag-seam/README.md
new file mode 100644
index 0000000000..1498212016
--- /dev/null
+++ b/research/p104-fiber-tag-seam/README.md
@@ -0,0 +1,144 @@
+# P104 fiber-tag seam on one row/column pair
+
+**Finite obstruction; no new supplier and no κ.** On the 104 published P104
+labels, the phase-uniform row tag `z ⊗ q_j` and column tag `r_i ⊗ z` are never
+the same 81-bit translation. A mixed weight-class pair also disagrees on the
+one-dimensional shared line. The published witness `(386, 405)` is such a pair.
+Selected conditional κ stays `0.001672660197076918`.
+
+## Scope and evidence
+
+Original card: `p104-side-correction`, scope **refined**. The card allows one
+chronological cut or one hosting obstruction. Discussion #1166 comment 19034676
+asks for one actual row/column pair and a reconciliation of the fiber-dependent
+tags `z ⊗ q_j` and `r_i ⊗ z` on shared owners. This package does that comparison
+for every ordered pair of the retained labels, and pins the witness already
+named by PR #3954. It does not build a caller, clear the inherited excess
+44,096, or admit a physical owner.
+
+The labels are `physical_labels` from the `RESULT.json` exported by PR #3966
+at `3e2d70630fde46847c8938564576d78da48d101d`, origin PR #3954 head
+`f1e2839819959cd0534d008be91ed5b79ec55a6a`. That file's SHA-256 is
+`ce05a27ebc98677bec4febaa488fa03f5b6fc60216aa43b34298444d12f7ab6c`. It is not a
+Git object on this base. `labels.json` is the vendored array; `verify.py`
+checks its SHA-256
+`7227a7d6bdb49f36b6e401478034cc542eb887979890c8deda924b8ac0844209`.
+
+### Conventions
+
+`z = 420`, support `{2, 5, 7, 8}`. `O x = x + (x · z) z`. Bit `9α+β` of
+`u ⊗ v` is `u_α v_β`. The row image is `q_j = O p_j` and the column image is
+`r_i = O p_i`. The row tag is `z ⊗ q_j`. The column tag is `r_i ⊗ z`. The
+shared line is `span(r_i ⊗ q_j)`, read by the dot product with that vector.
+The uniform completion tag is `a = z ⊗ 511 + 511 ⊗ z`.
+
+### Proof
+
+`z · z = 0` and `wt(z) = 4`, so `O` is an orthogonal involution and `Oz = z`.
+Hence `z · (O p) = z · p`. The checker tests the involution, the orthogonality
+identity, and `q(Ox) = q(x) + 2(x · z) (mod 4)` on all of `F_2^9`.
+
+Every retained label is odd, 56 of weight class 1 and 48 of class 3. Every
+image has weight class 3, so every image is odd, and none equals `z`. The
+weight law then forces `z · p = 1` exactly on class 1.
+
+**Full address.** Summing a matrix over its second index in `F_2`:
+
+- the row tag contributes `z_α (q · 1) = z_α`, because `q` is odd;
+- the column tag contributes `r_α (z · 1) = 0`, because `z` is even.
+
+`z ≠ 0`, so the tags differ for every odd `q` and every `r`. All 10,816
+ordered pairs therefore have distinct full-address translations. The oddness
+hypothesis is necessary: both tags are zero when `q = r = 0`.
+
+**Shared line.** Both images are odd, so `b = r ⊗ q` satisfies `b · b = 1`.
+The two tags flip that line by `z · r = z · p_i` and `z · q = z · p_j`. The
+flips agree if and only if the labels have the same weight class. That is
+5,440 ordered pairs. The other 5,376 disagree.
+
+**Uniform helper.** Write `a = z ⊗ 511 + 511 ⊗ z`. Its column sum, summing
+the first factor, is `z`. The column sum of a row tag `z ⊗ q` is `0` because
+`z` is even, so `a` is never a row tag. Its row sum, summing the second
+factor, is also `z`. The row sum of a column tag `r ⊗ z` is `0`, so `a` is
+never a column tag either. On the shared line, `a` matches the row tag exactly
+when the column label is class 3.
+
+**Distance.** The minimum Hamming distance between a row tag and a column tag
+is 6, attained only by the ordered pairs of labels `32` and `4` (list indices
+19 and 75, both class 1, images 388 and 416). Even the two diagonal pairs
+differ. No shared-line agreement is a full-address agreement.
+
+### Pinned witness
+
+PR #3954's witness names `p_row = 386` and `p_donor = 405`. In
+`physical_labels` those are indices 0 and 8. The field `donor_port = 2` is not
+an index into that list.
+
+| | row 386 | column 405 |
+|---|---:|---:|
+| weight class mod 4 | 3 | 1 |
+| image under `O` | 386 | 49 |
+| shared-line flip | 0 | 1 |
+| Hamming distance of the tags | 20 | |
+| separating coordinate | bit 11, which is `(α, β) = (1, 2)` | |
+
+`χ` at that bit takes values `+1` and `-1` on the two translations, so they
+differ as operators on arbitrary functions. The uniform tag flips the same
+shared line and the row tag does not, so a helper carrying `a` does not match
+this row owner.
+
+## What this does not establish
+
+Nothing here clears the scaffold excess 44,096 from PR #3966, which already
+grants every gauge and tag for free. Same-class pairs still need a correction
+on at least six address bits before the full translations agree. Native
+routing, owners, dirty return, precision, and a changed favorable bill are
+open. This is not a multiplication theorem.
+
+## Reproduce
+
+From the repository root, CPython 3.12, standard library only:
+
+```sh
+python3.12 -B scripts/research_package.py --package research/p104-fiber-tag-seam --check-only
+python3.12 -B scripts/research_package.py --package research/p104-fiber-tag-seam
+python3.12 -B research/p104-fiber-tag-seam/verify.py
+```
+
+Expected marker:
+
+```text
+PASS_P104_FIBER_TAG_SEAM pairs=10816 full_equal=0 mixed_shared_disagree=5376 same_shared_agree=5440 min_hamming=6 witness=386/405 shared_flips=0/1 ham=20 helper_disagrees_on_witness=true no_new_kappa
+```
+
+The same command under `-O` is registered. A forced claim that the witness tags
+are equal is rejected. The zero-vector pair shows that an even image can agree.
+
+`python3 -B scripts/research_baseline.py` returned
+`PASS_RESEARCH_BASELINE_BINDINGS_ONLY`. That check binds the selected record.
+It is not this certificate.
+
+Not run: the PR #3954 and PR #3966 executables, Lean, Docker, and the selected
+cold replay.
+
+## Open next questions
+
+1. For one same-class pair, such as label 32 against itself, can a paid
+   correction of the six disagreeing bits be hosted without repaying the
+   inherited excess 44,096? The shared line already agrees, so only the
+   complementary address bits are in play. Blocked by a physical owner and a
+   changed bill; the free-tag scaffold is still over capacity.
+2. Does any non-orthogonal address change make the witness pair `(386, 405)`
+   share one translation on both the full address and the helper tag `a`?
+   This orthogonal gauge cannot. A different gauge needs its own defect
+   calculation before it is treated as a caller.
+
+## Credit
+
+Chris R / Clear1nsight for PR #3954 and PR #3966, including the labels, the
+witness, the gauge `z = 420`, and the open fiber-tag question. The orthogonal
+gauge and the uniform tag `a` are theirs. The comparison of `z ⊗ q_j` with
+`r_i ⊗ z` on these labels is new.
+
+Prepared by unpaidmoon with substantial Cursor Grok assistance. No independent
+human or formal-kernel review is claimed. New work is Apache-2.0.
diff --git a/research/p104-fiber-tag-seam/SOURCES.json b/research/p104-fiber-tag-seam/SOURCES.json
new file mode 100644
index 0000000000..a604c6a640
--- /dev/null
+++ b/research/p104-fiber-tag-seam/SOURCES.json
@@ -0,0 +1,18 @@
+{
+  "schema_version": 1,
+  "base_commit": "bb4bccbf42844d2801487450727c2f63e10d1d0f",
+  "files": [
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81",
+      "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+    },
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "67f085acd86acd7d4e03922d9cf4b26bca66fed5",
+      "sha256": "47b42433f5a85809a3aadd29c2c339da2c6ed728e4f7762df6b88bccb7874cf0"
+    }
+  ]
+}
diff --git a/research/p104-fiber-tag-seam/TASK.json b/research/p104-fiber-tag-seam/TASK.json
new file mode 100644
index 0000000000..cfbf4eb552
--- /dev/null
+++ b/research/p104-fiber-tag-seam/TASK.json
@@ -0,0 +1,94 @@
+{
+  "schema_version": 1,
+  "task_id": "p104-side-correction",
+  "priority_revision": 6,
+  "base_commit": "bb4bccbf42844d2801487450727c2f63e10d1d0f",
+  "original_card": {
+    "id": "p104-side-correction",
+    "question": "Can the proposed P104 joint endpoint flags be realized by a chronological correction program with coefficients, dirty restoration and an affordable complete bill?",
+    "starting_points": [
+      "docs/research/research-family-status.md",
+      "research/p104-native-channel/README.md",
+      "research/p104-native-channel/PROOF.md",
+      "docs/research/community-efficient1000-review.md",
+      "research/p104-joint-unit-flags/README.md"
+    ],
+    "methods": [
+      "Construct one side-correction word at an explicit chronological cut with the needed frames still available.",
+      "Derive a lower bound on the side correction and hosting costs that decides whether this channel can beat the selected budget."
+    ],
+    "acceptance_gate": "An exact arbitrary-input identity, source/target frame availability and restoration at the chosen cut, plus the complete channel+correction+idle/hosting bill or an explicit favorable bound. The native channel alone is not a supplier. 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 the revision-6 family record and #2981 static joint flags, alongside the reviewed #1991 channel. #2981 is an author-checked source archive, not an independently validated executable correction or a refutation of program-level lifetime floors.",
+      "scope": "Source-bound orientation only. Read the named package and review before relying on its local evidence; this command is not its replay or supplier admission."
+    },
+    "first_experiment": "After checking live handoffs, pin one named collection from #2981 and attach acquisition/delivery times, source dependencies and coefficient requirements. Test legal access and arbitrary dirty restoration; price any completion against the full channel/endpoint/hosting allowance. Stop with the exact missing implication or a scoped counterexample rather than expanding the static cover census.",
+    "bottleneck_link": "Completing an already realized changed channel tests a concrete construction opportunity, instead of refining the incumbent packing. A positive local result still needs global and all-size admission.",
+    "allowed_variations": [
+      "One correction factorization, one chronological cut, or one explicit hosting obstruction.",
+      "A changed correction schedule with an updated full bill and native frame contract."
+    ],
+    "scope_change_triggers": [
+      "Recompiling the already certified low-rank channel without closing a new obligation.",
+      "Treating a pending ancestor, local histogram or unpriced side correction as an admitted global supplier.",
+      "Repeating a correction or physical conversion already supplied by a pending follow-up without adding independent coverage or a different unresolved obligation.",
+      "Repeating the 208-flag static matching or calling a static nested cover a chronological correction program. Independent audit of that certificate is distinct and remains useful."
+    ],
+    "overlap_terms": [
+      "P104",
+      "I-G/2",
+      "side correction",
+      "native channel",
+      "1972",
+      "1991",
+      "2586",
+      "endpoint transport",
+      "physical dual",
+      "relay composition",
+      "2981",
+      "joint unit flags",
+      "acquisition delivery",
+      "static nesting"
+    ],
+    "existing_checks": [
+      {
+        "scope": "PR #2981 reports static joint endpoint flags and a matching of 208 departure and arrival flags; archival intake is not independent verification.",
+        "evidence": "research/p104-joint-unit-flags/README.md",
+        "remaining": "Independent flag check and a chronological coefficient program with dirty restoration and a complete cost.",
+        "status": "author-checked",
+        "source_commit": "3d24b92d8ba057b57cb2d480170ec407520e6882",
+        "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+      }
+    ]
+  },
+  "scope_status": "refined",
+  "actual_scope": "One chronological row/column pair of the 104 published P104 labels: the fiber tags z\u2297q_j and r_i\u2297z never agree as 81-bit translations, and they disagree on the shared line exactly for mixed weight classes. The published witness is (386, 405).",
+  "scope_change_reason": "Handoff comment 19034676 asks for one row/column pair and a reconciliation of the fiber-dependent tags. The card's chronological correction program is not constructed; this is the tag obstruction at that cut.",
+  "bottleneck_link": "A side-correction caller that reuses one translation on a shared row/column owner cannot use these phase-uniform fiber tags. The inherited scaffold excess 44096 remains, so the obstruction stops this gauge rather than improving kappa.",
+  "budget_minutes": 60,
+  "stop_rule": "Stop after every ordered pair of the 104 labels and the one published witness. Do not search another gauge or price a correction of the six-bit minimum while the free-tag scaffold stays over capacity.",
+  "outcome": "negative-result",
+  "evidence": "README states the marginal-sum proof. verify.py checks O on all 512 vectors and all 10816 pairs, including shared-line flips, Hamming distance, the witness character at bit 11, and the uniform helper tag.",
+  "author": "unpaidmoon",
+  "ai_assistance": "Substantial Cursor Grok assistance in the proof, checker, and write-up. Not independent human or formal-kernel review.",
+  "open_questions": [
+    {
+      "question": "Can a paid correction of the six disagreeing bits on a same-class pair, such as label 32 against itself, be hosted without repaying the inherited excess 44096?",
+      "why_it_matters": "Same-class pairs already agree on the shared line, so only the complementary address bits block one common translation.",
+      "first_step": "Freeze label 32, list the six bits where z\u2297388 differs from 388\u2297z, and price one owner that sees those bits against the unchanged scaffold capacity.",
+      "blocked_by": "No physical owner model is fixed here, and PR #3966 already rejects the scaffold when every tag is free."
+    },
+    {
+      "question": "Does a non-orthogonal address change make the witness pair (386, 405) share one translation on the full address and on the helper tag a?",
+      "why_it_matters": "The orthogonal phase-uniform gauge cannot reconcile this mixed-class pair, but the handoff still allows a different encoding.",
+      "first_step": "Name one address map other than O\u2297O and recompute both fiber tags and a on labels 386 and 405.",
+      "blocked_by": "Any new defect has to be derived before the map is treated as a caller. This package does not supply one."
+    }
+  ]
+}
diff --git a/research/p104-fiber-tag-seam/VERIFY.json b/research/p104-fiber-tag-seam/VERIFY.json
new file mode 100644
index 0000000000..a3ebc9367f
--- /dev/null
+++ b/research/p104-fiber-tag-seam/VERIFY.json
@@ -0,0 +1,19 @@
+{
+  "schema_version": 1,
+  "status": "ready",
+  "python": "3.12",
+  "requirements": [],
+  "inputs": [],
+  "commands": [
+    {
+      "argv": ["{python}", "-B", "{package}/verify.py"],
+      "timeout_seconds": 120,
+      "checks": "All 512 gauge vectors, all 10816 label pairs, the pinned witness 386/405, and the even-image control"
+    },
+    {
+      "argv": ["{python}", "-O", "-B", "{package}/verify.py"],
+      "timeout_seconds": 120,
+      "checks": "Same certificate with assertions removed, so the explicit exceptions still fire"
+    }
+  ]
+}
diff --git a/research/p104-fiber-tag-seam/labels.json b/research/p104-fiber-tag-seam/labels.json
new file mode 100644
index 0000000000..ddb50703fa
--- /dev/null
+++ b/research/p104-fiber-tag-seam/labels.json
@@ -0,0 +1 @@
+[386,391,431,426,127,122,82,87,405,445,440,351,304,290,295,309,346,357,31,32,79,93,88,74,37,26,224,223,176,162,167,181,218,229,261,494,385,406,446,425,454,468,289,310,345,331,358,372,283,94,73,38,52,25,11,100,115,134,148,251,236,196,211,188,174,161,182,217,203,230,244,155,140,121,107,4,19,59,44,67,81,262,276,379,324,339,316,302,475,460,419,433,398,481,502,301,434,397,482,501,487,392,439,296]
diff --git a/research/p104-fiber-tag-seam/verify.py b/research/p104-fiber-tag-seam/verify.py
new file mode 100644
index 0000000000..836a547850
--- /dev/null
+++ b/research/p104-fiber-tag-seam/verify.py
@@ -0,0 +1,225 @@
+#!/usr/bin/env python3
+"""Reconcile one P104 row/column fiber-tag pair.
+
+The 104 labels are the physical_labels array in PR #3966's retained
+RESULT.json (SHA-256 ce05a27ebc98677bec4febaa488fa03f5b6fc60216aa43b34298444d12f7ab6c),
+itself the PR #3954 export at f1e2839819959cd0534d008be91ed5b79ec55a6a.
+That file is not a Git object on this base, so labels.json is the vendored
+array and this checker authenticates its bytes.
+"""
+
+import hashlib
+import json
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent
+LABEL_SHA256 = "7227a7d6bdb49f36b6e401478034cc542eb887979890c8deda924b8ac0844209"
+Z = 420
+J = 511
+ROW_LABEL = 386
+COLUMN_LABEL = 405
+
+
+def fail(message):
+    raise SystemExit("FAIL_P104_FIBER_TAG_SEAM " + message)
+
+
+def require(condition, message):
+    if not condition:
+        fail(message)
+
+
+def dot(left, right):
+    return (left & right).bit_count() & 1
+
+
+def weight_mod4(value):
+    return value.bit_count() % 4
+
+
+def apply_o(value):
+    if dot(value, Z):
+        return value ^ Z
+    return value
+
+
+def tensor(left, right):
+    """Bit 9*alpha+beta of left⊗right is left_alpha * right_beta."""
+    out = 0
+    for alpha in range(9):
+        if (left >> alpha) & 1:
+            out |= right << (9 * alpha)
+    return out
+
+
+def load_labels():
+    raw = (ROOT / "labels.json").read_bytes()
+    require(hashlib.sha256(raw).hexdigest() == LABEL_SHA256, "label bytes drifted")
+    labels = json.loads(raw.decode("utf-8"))
+    require(isinstance(labels, list) and len(labels) == 104, "expected 104 labels")
+    require(all(isinstance(item, int) and 0 <= item < 512 for item in labels), "label out of F2^9")
+    require(len(set(labels)) == 104, "labels are not distinct")
+    return labels
+
+
+def check_gauge():
+    """O is an orthogonal involution on every vector, with the weight law."""
+    for left in range(512):
+        image = apply_o(left)
+        require(apply_o(image) == left, "O is not an involution")
+        require(weight_mod4(image) == (weight_mod4(left) + 2 * dot(left, Z)) % 4,
+                "weight law failed")
+        for right in range(left, 512):
+            require(dot(apply_o(left), apply_o(right)) == dot(left, right), "O is not orthogonal")
+    require(dot(Z, Z) == 0 and Z.bit_count() == 4, "z is not the stated even weight-4 vector")
+    require(apply_o(Z) == Z and apply_o(J) == J, "O does not fix z and the all-ones vector")
+
+
+def tags(row_image, column_image):
+    return tensor(Z, column_image), tensor(row_image, Z)
+
+
+def shared_flips(row_image, column_image):
+    row_tag, column_tag = tags(row_image, column_image)
+    shared = tensor(row_image, column_image)
+    return dot(row_tag, shared), dot(column_tag, shared), row_tag, column_tag, shared
+
+
+def check_labels(labels):
+    images = []
+    class_counts = {1: 0, 3: 0}
+    for label in labels:
+        require(weight_mod4(label) in (1, 3), "label is not an odd published class")
+        image = apply_o(label)
+        require(weight_mod4(image) == 3, "image is not weight 3 mod 4")
+        require(dot(Z, image) == dot(Z, label), "O is not self-adjoint on z")
+        require((dot(Z, label) == 1) == (weight_mod4(label) == 1), "class does not match z·p")
+        class_counts[weight_mod4(label)] += 1
+        images.append(image)
+    require(class_counts == {1: 56, 3: 48}, "class split is not 56/48")
+    require(Z not in images, "some image equals z")
+    return images
+
+
+def marginals(value):
+    """Return (row-sum, column-sum) in F2^9 for an 81-bit tensor."""
+    row_sum = 0
+    column_sum = 0
+    for alpha in range(9):
+        stripe = (value >> (9 * alpha)) & 511
+        column_sum ^= stripe
+        if stripe.bit_count() & 1:
+            row_sum |= 1 << alpha
+    return row_sum, column_sum
+
+
+def check_marginals(images):
+    uniform = tensor(Z, J) ^ tensor(J, Z)
+    require(marginals(uniform) == (Z, Z), "uniform tag marginals are not both z")
+    for image in images:
+        row_tag, column_tag = tags(image, image)
+        # tags(row_image, column_image) = (z⊗column_image, row_image⊗z).
+        # Using the same odd image for both factors checks each shape.
+        require(marginals(tensor(Z, image)) == (Z, 0), "row-tag marginals failed")
+        require(marginals(tensor(image, Z)) == (0, Z), "column-tag marginals failed")
+        require(row_tag != uniform and column_tag != uniform, "marginal witness collided with a")
+
+
+def check_pairs(labels, images):
+    full_equal = 0
+    mixed_disagree = 0
+    same_agree = 0
+    min_hamming = 81
+    min_pairs = []
+    uniform = tensor(Z, J) ^ tensor(J, Z)
+    require(uniform.bit_count() == 40, "uniform completion tag does not have weight 40")
+    helper_row_matches = 0
+    for row_index, row_image in enumerate(images):
+        for column_index, column_image in enumerate(images):
+            row_flip, column_flip, row_tag, column_tag, shared = shared_flips(row_image, column_image)
+            require(dot(shared, shared) == 1, "shared line is degenerate")
+            require(row_flip == dot(Z, labels[row_index]), "row shared flip is not z·p_row")
+            require(column_flip == dot(Z, labels[column_index]), "column shared flip is not z·p_column")
+            same_class = weight_mod4(labels[row_index]) == weight_mod4(labels[column_index])
+            require((row_flip == column_flip) == same_class, "shared-bit rule failed")
+            if same_class:
+                same_agree += 1
+            else:
+                mixed_disagree += 1
+            if row_tag == column_tag:
+                full_equal += 1
+            hamming = (row_tag ^ column_tag).bit_count()
+            if hamming < min_hamming:
+                min_hamming = hamming
+                min_pairs = [(row_index, column_index)]
+            elif hamming == min_hamming:
+                min_pairs.append((row_index, column_index))
+            require(row_tag != uniform and column_tag != uniform, "a fiber tag equals the uniform tag")
+            uniform_flip = dot(uniform, shared)
+            # The uniform tag matches the row tag on the shared line exactly
+            # when the column label is class 3.
+            require((row_flip == uniform_flip) == (dot(Z, labels[column_index]) == 0),
+                    "helper/row shared-bit comparison is inconsistent")
+            if row_flip == uniform_flip:
+                helper_row_matches += 1
+    require(full_equal == 0, "some full-address tags agree")
+    require(mixed_disagree == 5376 and same_agree == 5440, "pair census changed")
+    require(min_hamming == 6, "minimum Hamming distance is not 6")
+    require(sorted(min_pairs) == [(19, 19), (19, 75), (75, 19), (75, 75)],
+            "minimum pairs are not labels 32 and 4")
+    require(helper_row_matches == 104 * 48, "helper match count is not the class-3 columns")
+    return min_hamming
+
+
+def check_witness(labels, images):
+    row_index = labels.index(ROW_LABEL)
+    column_index = labels.index(COLUMN_LABEL)
+    require((row_index, column_index) == (0, 8), "published witness labels moved")
+    require(weight_mod4(labels[row_index]) == 3 and weight_mod4(labels[column_index]) == 1,
+            "witness classes changed")
+    row_flip, column_flip, row_tag, column_tag, shared = shared_flips(
+        images[row_index], images[column_index])
+    require((images[row_index], images[column_index]) == (386, 49), "witness images changed")
+    require((row_flip, column_flip) == (0, 1), "witness shared flips changed")
+    difference = row_tag ^ column_tag
+    require(difference.bit_count() == 20, "witness Hamming distance is not 20")
+    require((difference >> 11) & 1 == 1, "separating bit 11 disappeared")
+    frequency = 1 << 11
+    require(dot(row_tag, frequency) == 0 and dot(column_tag, frequency) == 1,
+            "character e_11 does not separate the witness tags")
+    uniform = tensor(Z, J) ^ tensor(J, Z)
+    require(dot(uniform, shared) == 1 and row_flip == 0,
+            "uniform helper tag agrees with the witness row tag")
+
+
+def check_controls():
+    """The odd-image hypothesis is necessary, and a forced agreement is rejected."""
+    require(tensor(Z, 0) == tensor(0, Z) == 0, "zero tags should agree")
+    row_tag, column_tag = tags(386, 49)
+    require(row_tag != column_tag, "control lost the witness mismatch")
+    try:
+        require(row_tag == column_tag, "forced equality")
+    except SystemExit as exc:
+        require(str(exc).startswith("FAIL_P104_FIBER_TAG_SEAM"), "control raised the wrong failure")
+    else:
+        fail("forced tag equality was accepted")
+
+
+def main():
+    labels = load_labels()
+    check_gauge()
+    images = check_labels(labels)
+    check_marginals(images)
+    min_hamming = check_pairs(labels, images)
+    check_witness(labels, images)
+    check_controls()
+    print(
+        "PASS_P104_FIBER_TAG_SEAM pairs=10816 full_equal=0 "
+        "mixed_shared_disagree=5376 same_shared_agree=5440 "
+        f"min_hamming={min_hamming} witness=386/405 shared_flips=0/1 ham=20 "
+        "helper_disagrees_on_witness=true no_new_kappa"
+    )
+
+
+if __name__ == "__main__":
+    main()