feat(research): explain the 4H<->1D snapping sign flip (net-vs-path channel, descriptive)

Narrow investigate follow-up: why does the snapping<->cleanliness relationship flip
sign between 4H (deflate) and 1D (inflate)? Same frozen data / locked detection;
DESCRIPTIVE-ONLY -- no verdict, no claim, no lock change, no matched-null, no new
universe, no new bins. Crux stays OPEN.

cleanliness = net/path, so a snap changes cleanliness via a NET channel and a PATH
channel. On the moved-snap domain (snaps that actually changed the span; unmoved snaps
are dclean=0 by construction):
- 4H: path grows faster than net (median rel_path 0.231 > rel_net 0.181; 63%
  path-dominated) -> cleanliness DOWN (matches snapping_deflates).
- 1D: net grows faster than path (median rel_net 0.063 > rel_path 0.025; 60%
  net-dominated) -> cleanliness UP (matches snapping_inflates).
The dominant channel FLIPS between TFs -- mechanically consistent with candle
granularity (fine 4H bars add intermediate retracement = path; coarse 1D bars put the
detector pivot at a more extreme price = net). Spearman(dclean, rel_path) itself flips
-0.18 -> +0.20. The dclean~(rel_net-rel_path) Spearman is 0.99 BY CONSTRUCTION
(arithmetic identity, flagged, not the finding).

Kept apart from any selection-claim: this is the measurement geometry of snapping, NOT
evidence about cleanliness-as-human-signal. Extended the mechanics module (+net/path
decomposition, 2 descriptive ArtifactRow fields snap_a_idx/snap_b_idx, +2 tests).
Checkpoint + handoff updated. Gates green: ruff + format + 588 pytest (cov 74.38%) +
bounds + wiki-lint. No Genesis/1H/ETH/refresh/label-mutation/edge claim.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: JohnCCarter

docs/research_wiki/handoff.md

@@ -131,6 +131,14 @@ legs/ranges* (labels = facit; **no edge/behaviour/backtest/PnL/Genesis/auto-fib
   Population guard: M1 ≠ Stage-2 lead (different population). No matched-null/new universe/Genesis/1H/
   ETH/refresh. [Mechanics note](reviews/btc-fib-selection-learning-artifact-mechanics-20260624.md);
   mechanics_summary.json gitignored/regenerable.
+- **2026-06-24 Fib SELECTION-LEARNING snapping FLIP mechanics — BUILT + RUN (descriptive, no verdict).**
+  Narrow follow-up: *why does snapping↔cleanliness flip sign 4H↔1D*. Extended the mechanics module
+  (+net/path decomposition, 2 more `ArtifactRow` fields, +2 tests). On the moved-snap domain it is a
+  **net-vs-path channel reversal** consistent with **candle granularity**: 4H grows **path** > net
+  (rel_path 0.231 > rel_net 0.181, 63% path-dominated → clean down); 1D grows **net** > path (0.063 >
+  0.025, 60% net-dominated → clean up). Explains the **measurement geometry**, kept apart from any
+  selection-claim; **no verdict, no lock change, crux OPEN**. No matched-null/universe/Genesis/1H/ETH/
+  refresh. [Flip note](reviews/btc-fib-selection-learning-artifact-mechanics-flip-20260624.md).
 
 **Next work requires a separate explicit GO. No W/gap, no Stage 1, no new sensitivity, and no Genesis
 may be started automatically.** Parked (test-only, separate GO): lock the facit-discipline refusal

docs/research_wiki/reviews/btc-fib-selection-learning-artifact-mechanics-flip-20260624.md

@@ -0,0 +1,96 @@
+# BTC Fib Selection-Learning — snapping sign-FLIP mechanics (4H↔1D) (2026-06-24)
+
+**Lean Fib Research. Research-only. DESCRIPTIVE-ONLY — NO verdict, NO claim, no edge/behaviour/PnL/
+backtest/Genesis/auto-fib/1H/ETH/label-mutation.** A narrow follow-up to the
+[mechanics note](btc-fib-selection-learning-artifact-mechanics-20260624.md): *why does the relationship
+between snapping and cleanliness flip sign between 4H and 1D* (artifact-probe: 4H snapping **deflates**
+cleanliness, 1D **inflates** it). Same **frozen data / locked detection** (no refresh, no new universe,
+no matched-null, no new bins, no lock change). It explains the **measurement geometry of snapping** and
+says **nothing** about human selection — the crux stays OPEN.
+
+> **STATUS — the flip is a net-vs-path channel reversal driven by candle granularity (descriptive).**
+> `cleanliness = net/path`, so a snap changes cleanliness via two channels: it moves the **net**
+> (endpoint-to-endpoint move) and the **path** (summed intermediate move). Restricting to snaps that
+> **actually moved the span** (the question's support; unmoved snaps have Δclean=0 by construction):
+> on **4H** snapping grows **path faster than net** (median rel_path **0.231** > rel_net **0.181**;
+> 63% path-dominated) → cleanliness **down**; on **1D** it grows **net faster than path** (median
+> rel_net **0.063** > rel_path **0.025**; 60% net-dominated) → cleanliness **up**. The dominant channel
+> **flips** between the two TFs — mechanically consistent with **candle granularity** (fine 4H bars add
+> mostly intermediate retracement = path; coarse 1D bars put the detector pivot at a genuinely more
+> extreme price = net). **No verdict, no claim, crux unchanged.**
+
+## Method (descriptive decomposition; no new universe / bins / lock)
+
+For each reached non-degenerate leg the probe already records the exact human span `[pos_a, pos_b]` and
+the snapped detector-pivot span `[snap_a_idx, snap_b_idx]` (two new descriptive `ArtifactRow` fields,
+used by no contrast/verdict). On the same frozen closes: `net = |close[hi] − close[lo]|`,
+`path = Σ|Δclose|`; `rel_net = Δnet/net_exact`, `rel_path = Δpath/path_exact`. Since
+`cleanliness = net/path`, `Δln(cleanliness) ≈ rel_net − rel_path` — an **arithmetic identity** (the
+`d_clean ~ (rel_net−rel_path)` Spearman is **0.99 by construction**, flagged, **not** the finding). The
+**non-trivial empirical content** is *which channel dominates per TF*. Domain = snaps that **moved the
+span** (unmoved snaps are Δclean=0 — the question's support, not a post-hoc bin); the moved fraction is
+reported.
+
+## Results — channel medians on the moved-snap domain
+
+| TF | moved / total | median `rel_net` | median `rel_path` | dominant channel | frac net-dom | Spearman(Δclean, rel_net) | Spearman(Δclean, rel_path) |
+|----|--------------:|-----------------:|------------------:|------------------|-------------:|--------------------------:|---------------------------:|
+| **4H** | 107 / 314 | 0.181 | **0.231** | **PATH** (clean ↓) | 0.374 | +0.476 | **−0.177** |
+| **1D** | 20 / 60 | **0.063** | 0.025 | **NET** (clean ↑) | 0.600 | +0.864 | +0.201 |
+| 1w (ctx) | 5 / 19 | 0.024 | 0.048 | path | 0.40 | +0.90 | +0.10 |
+| 1M (ctx) | 6 / 9 | 0.244 | 0.253 | ~tie | 0.67 | +0.83 | +0.26 |
+
+(`d_clean ~ (rel_net−rel_path)` identity Spearman = 0.99 on 4H/1D — validation, by construction.)
+
+- **The flip is the channel reversal.** 4H: `rel_path > rel_net`, 63% of moved snaps path-dominated →
+  net deflation of cleanliness (matches the locked `snapping_deflates`). 1D: `rel_net > rel_path`, 60%
+  net-dominated → inflation (matches `snapping_inflates_cleanliness`). The `Spearman(Δclean, rel_path)`
+  even changes sign (4H **−0.18** vs 1D **+0.20**): on 4H the path channel pulls cleanliness down, on 1D
+  it does not.
+- **Magnitude context:** 4H snaps move the span proportionally **more** (rel ~0.18–0.23) than 1D
+  (~0.03–0.06) — but on 4H that movement is disproportionately **path**.
+- **Caveat (honest):** the per-leg `median(rel_net − rel_path)` is ≈0 on 4H (the per-leg difference
+  straddles 0); the sign is carried by the **channel medians + the net-dominated fraction**, not the
+  per-leg median — reported as such, not overstated.
+
+## Mechanical reading (descriptive — kept apart from any selection-claim)
+
+The dominant-channel flip is **mechanically consistent with candle granularity**: on **fine 4H bars**,
+a detector pivot a few bars off the human anchor adds **fine intermediate candles that are mostly
+retracement** → path grows faster than net → cleanliness falls. On **coarse 1D bars**, the detector
+pivot being a different bar means a **genuinely more extreme price reached comparatively directly** →
+net grows faster than path → cleanliness rises. This is a statement about **how the detector's bar
+granularity interacts with the cleanliness measurement when anchors are snapped** — it is **not** a
+statement about human selection, the `cleanliness` lead, or the crux.
+
+## Separation of mechanics from selection-claim (binding)
+
+- This explains the **measurement geometry of snapping** (a net-vs-path channel reversal by TF). It is
+  **not** evidence that the Stage-2 `cleanliness` lead is or is not a genuine human signal.
+- The artifact-probe reading is **unchanged** (4H `snapping_deflates`, 1D `snapping_inflates`,
+  combined `meta:` status); **no lock is touched**; **no new verdict / claim**.
+- **The crux stays OPEN.** Explaining the snapping flip mechanically does not resolve "is `cleanliness`
+  human intuition or artifact" either way.
+
+## Observed / Inferred / Unverified
+
+- **Observed (verified):** the table; 4H moved-snap median rel_path 0.231 > rel_net 0.181 (63%
+  path-dominated); 1D rel_net 0.063 > rel_path 0.025 (60% net-dominated); `Spearman(Δclean, rel_path)`
+  flips −0.18→+0.20; identity Spearman 0.99; deterministic; new tests green.
+- **Inferred (descriptive, scoped):** the 4H↔1D snapping sign flip is a **net-vs-path channel reversal**
+  mechanically consistent with **candle granularity** (fine bars add path, coarse bars add net).
+- **Unverified / scope limits:** no verdict, no claim, no lock change; the granularity reading is a
+  *mechanical interpretation*, not a tested hypothesis (no new universe was built to isolate it); 1M/1w
+  are context (moved n = 6 / 5); the crux is unchanged and OPEN.
+
+## Non-claims (binding)
+
+Descriptive consolidation only. **No verdict, no positive claim, no lock change, no reproduction, no
+edge/behaviour/PnL/backtest/strategy claim.** Explaining the snapping geometry is **not** evidence about
+`cleanliness`-as-human-signal. No matched-null, no new candidate universe, no new model feature, no
+Genesis, no auto-fib-as-truth, no 1H, no ETH, no label/corpus mutation, no `data.fetch --refresh`.
+
+> The snapping sign flip is a **net-vs-path channel reversal**: 4H snaps add **path** (fine-bar
+> retracement) → cleanliness down; 1D snaps add **net** (coarse-bar extreme) → cleanliness up —
+> mechanically a **candle-granularity** effect. Descriptive only — measurement geometry, not human
+> selection; no verdict, no claim, crux unchanged.

docs/research_wiki/reviews/btc-fib-selection-learning-checkpoint-20260624.md

@@ -88,8 +88,11 @@ steeply with span (Spearman −0.69), reached legs are longer (median 5 vs 3 bar
 **vanishes when conditioning on span** (short-span +0.003, long-span −0.017): a composition effect, not
 a detector cleanliness-preference. 4H snapping deflates because detector pivots sit **outside** the
 human anchors (span extends, 33% vs 1.6%); the 1D flip is a **TF-dependent geometry** (1D shrinks more,
-10%, **and** the span↔cleanliness relationship flips sign, −0.19→+0.18) — *why* the local relationship
-reverses by TF stays an **open investigate-target**. None of this resolves the crux either way.
+10%, **and** the span↔cleanliness relationship flips sign, −0.19→+0.18). A follow-up
+[flip note](btc-fib-selection-learning-artifact-mechanics-flip-20260624.md) now **mechanically
+attributes** that reversal (descriptive) to a **net-vs-path channel flip** consistent with **candle
+granularity**: on the moved-snap domain, 4H grows path > net (rel_path 0.231 > rel_net 0.181) →
+cleanliness down; 1D grows net > path (0.063 > 0.025) → up. None of this resolves the crux either way.
 
 **Secondary loose end:** set-level **`exclusivity`** (`k*=3`) was specced in the
 [§12 addendum](btc-fib-selection-learning-addendum-20260618.md) but the Stage-2 live whitelist actually

src/fibengine/research/selection_learning_artifact.py

@@ -120,6 +120,12 @@ class ArtifactRow:
     span_bars: int = 0  # |pos_b - pos_a| (duration proxy)
     magnitude_atr: float | None = None  # |close[b] - close[a]| / causal ATR at anchor_b
     snap_span_delta: int | None = None  # |snapped span| - |exact span| (reached, non-degenerate)
+    snap_a_idx: int | None = (
+        None  # snapped (detector-pivot) bar index at anchor_a (reached non-deg)
+    )
+    snap_b_idx: int | None = (
+        None  # snapped (detector-pivot) bar index at anchor_b (reached non-deg)
+    )
 
 
 def _quarter_of(ts: pd.Timestamp) -> str:
@@ -158,6 +164,7 @@ def build_artifact_rows(
             else None
         )
         reached, snapped, drop, snap_span_delta = False, None, None, None
+        snap_a_idx, snap_b_idx = None, None
         if atr_at_b > 0 and np.isfinite(atr_at_b):  # fail-closed on degenerate ATR
             price_tol = cfg.eps_price_atr * atr_at_b
             pivots = detect_pivots(df_t, pivot_cfg)
@@ -174,6 +181,7 @@ def build_artifact_rows(
                 else:
                     snapped = _cleanliness_idx(closes, piv_a.index, piv_b.index)
                     snap_span_delta = abs(piv_b.index - piv_a.index) - span_bars  # descriptive (P3)
+                    snap_a_idx, snap_b_idx = int(piv_a.index), int(piv_b.index)
         rows.append(
             ArtifactRow(
                 quarter=_quarter_of(leg.anchor_b_ts),
@@ -186,6 +194,8 @@ def build_artifact_rows(
                 span_bars=span_bars,
                 magnitude_atr=magnitude_atr,
                 snap_span_delta=snap_span_delta,
+                snap_a_idx=snap_a_idx,
+                snap_b_idx=snap_b_idx,
             )
         )
     return rows

src/fibengine/research/selection_learning_artifact_mechanics.py

@@ -89,6 +89,61 @@ def _median_iqr(vals: list[float]) -> dict[str, Any] | None:
     }
 
 
+# --- the 4H↔1D snapping FLIP: net-vs-path channel decomposition (DESCRIPTIVE) -----------------
+
+
+def _net_path_idx(closes: np.ndarray, i: int, j: int) -> tuple[float | None, float | None]:
+    """(net, path) over the bar-index span [lo,hi] — the two ingredients of cleanliness=net/path."""
+    lo, hi = sorted((int(i), int(j)))
+    seg = closes[lo : hi + 1]
+    if len(seg) < 2:
+        return None, None
+    return float(abs(seg[-1] - seg[0])), float(np.abs(np.diff(seg)).sum())
+
+
+def _flip_decomposition(rows: list, closes: np.ndarray) -> dict[str, Any]:
+    """Why snapping changes cleanliness, and why the sign flips 4H↔1D. cleanliness=net/path, so
+    d_clean is governed by whether snapping changes NET or PATH more (rel_net − rel_path is an
+    arithmetic identity — flagged). Non-trivial content = WHICH channel dominates per TF (median
+    rel_net vs rel_path). DESCRIPTIVE — no verdict/claim."""
+    rel_net, rel_path, npmp, dclean = [], [], [], []
+    n_total = 0
+    for r in rows:
+        if not (r.reached and r.snap_a_idx is not None and r.snapped_clean is not None):
+            continue
+        n_total += 1
+        # MOVED domain only: legs where snapping actually changed the span. Unmoved snaps have
+        # d_clean=0 by construction (the majority here) and are irrelevant to "why snapping changes
+        # cleanliness" — excluding them is the question's support, NOT a post-hoc bin.
+        if sorted((r.snap_a_idx, r.snap_b_idx)) == sorted((r.pos_a, r.pos_b)):
+            continue
+        en, ep = _net_path_idx(closes, r.pos_a, r.pos_b)
+        sn, sp = _net_path_idx(closes, r.snap_a_idx, r.snap_b_idx)
+        if None in (en, ep, sn, sp) or en <= 0 or ep <= 0:
+            continue
+        rn, rp = (sn - en) / en, (sp - ep) / ep
+        rel_net.append(rn)
+        rel_path.append(rp)
+        npmp.append(rn - rp)
+        dclean.append(r.snapped_clean - r.exact_clean)
+    n = len(dclean)
+    if n == 0:
+        return {"n_total": n_total, "n_moved": 0}
+    return {
+        "n_total": n_total,  # all reached non-degenerate snaps
+        "n_moved": n,  # snaps that actually changed the span (the analysis domain)
+        "median_rel_net": float(np.median(rel_net)),  # relative net change from snapping
+        "median_rel_path": float(np.median(rel_path)),  # relative path change from snapping
+        "median_net_minus_path": float(np.median(npmp)),  # >0 → net-dominated (clean up); <0 → path
+        "frac_net_dominates": float(np.mean(np.asarray(npmp) > 0)),
+        "spearman_dclean_vs_net_minus_path_IDENTITY": _spearman(
+            npmp, dclean
+        ),  # ≈+1 by construction
+        "spearman_dclean_vs_rel_net": _spearman(rel_net, dclean),
+        "spearman_dclean_vs_rel_path": _spearman(rel_path, dclean),
+    }
+
+
 # --- per-cell descriptive mechanics (PLAN P2/P3; NO verdict) -----------------------------------
 
 
@@ -162,6 +217,9 @@ def run_mechanics_cell(timeframe: str, cfg: SelectionConfig, settings: Any) -> d
         _spearman([float(p[0]) for p in pairs], [float(p[1]) for p in pairs]) if pairs else None
     )
 
+    # FLIP — net-vs-path channel decomposition explaining the 4H↔1D snapping sign flip
+    flip = _flip_decomposition(rows, df["close"].to_numpy())
+
     return {
         "timeframe": timeframe,
         "k": cfg.k,
@@ -171,6 +229,7 @@ def run_mechanics_cell(timeframe: str, cfg: SelectionConfig, settings: Any) -> d
         "M1_size_length_confound": m1,
         "M3_snap_span_delta_asymmetry": m3,  # headline descriptive object (PLAN P3)
         "M2_span_vs_cleanliness_spearman_PARTLY_ARITHMETIC": m2_spearman,
+        "FLIP_net_path_decomposition": flip,  # why snapping->cleanliness flips sign 4H<->1D
         "note": "DESCRIPTIVE ONLY — no verdict/claim; artifact-probe reading unchanged (PLAN P4)",
     }
 
@@ -226,6 +285,12 @@ def print_mechanics(report: dict, path: Any) -> None:
         print(
             f"    M2(arithmetic) spearman={r['M2_span_vs_cleanliness_spearman_PARTLY_ARITHMETIC']}"
         )
+        fl = r["FLIP_net_path_decomposition"]
+        print(
+            f"    FLIP moved={fl.get('n_moved')}/{fl.get('n_total')} "
+            f"rel_net={fl.get('median_rel_net')} rel_path={fl.get('median_rel_path')} "
+            f"frac_net_dom={fl.get('frac_net_dominates')}"
+        )
     print(f"DESCRIPTIVE-ONLY (no verdict)  summary={path}")
 
 

tests/research/test_selection_learning_artifact_mechanics.py

@@ -14,7 +14,9 @@
 from fibengine.research import selection_learning_artifact_mechanics as mech
 
 
-def _row(reached, exact, span, mag=None, snap_delta=None, snapped=None, q="2020Q1"):
+def _row(
+    reached, exact, span, mag=None, snap_delta=None, snapped=None, q="2020Q1", sa=None, sb=None
+):
     return art.ArtifactRow(
         quarter=q,
         pos_a=0,
@@ -25,6 +27,8 @@ def _row(reached, exact, span, mag=None, snap_delta=None, snapped=None, q="2020Q
         span_bars=span,
         magnitude_atr=mag,
         snap_span_delta=snap_delta,
+        snap_a_idx=sa,
+        snap_b_idx=sb,
     )
 
 
@@ -50,12 +54,53 @@ def test_median_iqr_and_empty():
     assert mech._median_iqr([None, None]) is None
 
 
+def test_net_path_idx():
+    closes = np.array([100.0, 110.0, 105.0, 115.0])
+    net, path = mech._net_path_idx(closes, 0, 3)
+    assert net == pytest.approx(15.0) and path == pytest.approx(25.0)  # |15|, 10+5+10
+    assert mech._net_path_idx(closes, 2, 2) == (None, None)  # <2 bars
+
+
+def test_flip_decomposition_net_vs_path_channel():
+    # closes laid out in 3 regions so two snaps are PATH-dominated (clean down) and one is
+    # NET-dominated (clean up) — the decomposition must recover that split.
+    closes = np.array([100.0, 110.0, 108.0, 100.0, 130.0, 128.0, 130.0, 100.0, 110.0, 107.0])
+    rows = [
+        # A: extend [0,1]->[0,2] adds path -> clean down (path-dominated)
+        _row(True, 1.0, span=1, snapped=8.0 / 12.0, sa=0, sb=2),
+        # B: shrink [3,6]->[3,4] removes a wiggle -> clean up (net-dominated)
+        _row(True, 30.0 / 34.0, span=3, snapped=1.0, sa=3, sb=4, q="2020Q2"),
+        # C: extend [7,8]->[7,9] adds path -> clean down (path-dominated)
+        _row(True, 1.0, span=1, snapped=7.0 / 13.0, sa=7, sb=9, q="2020Q3"),
+    ]
+    # row B's pos_a/pos_b must point at region B (3,6); _row uses pos_a=0,pos_b=span, so fix span=3
+    rows[1].pos_a, rows[1].pos_b = 3, 6
+    rows[2].pos_a, rows[2].pos_b = 7, 8
+    f = mech._flip_decomposition(rows, closes)
+    assert f["n_moved"] == 3 and f["n_total"] == 3
+    # the d_clean <-> (rel_net - rel_path) link is the arithmetic identity → Spearman ≈ +1
+    assert f["spearman_dclean_vs_net_minus_path_IDENTITY"] == pytest.approx(1.0)
+    # two of three snaps are path-dominated (net_minus_path < 0) → overall path-dominated, frac=1/3
+    assert f["median_net_minus_path"] < 0
+    assert f["frac_net_dominates"] == pytest.approx(1.0 / 3.0)
+    assert f["median_rel_path"] > f["median_rel_net"]
+    assert mech._flip_decomposition([], closes) == {"n_total": 0, "n_moved": 0}
+
+
 # --- per-cell descriptive mechanics (no verdict) ----------------------------------------------
 
 
 class _NonEmpty:
     empty = False
 
+    def __getitem__(self, key):  # df["close"] → object with .to_numpy() (flip needs closes)
+        return _Col()
+
+
+class _Col:
+    def to_numpy(self):
+        return np.zeros(0)
+
 
 def _patch_cell(monkeypatch, rows):
     class _D: