diff --git a/.gitignore b/.gitignore
index 97fd024acf..ebe634aa2d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -98,3 +98,15 @@ err.txt
 
 # Oura OAuth app credentials (BYO; never committed)
 Strand/Oura/OuraSecrets.xcconfig
+
+# Pairing / ML large dumps (keep golden labels + status JSON only)
+pairing-logs/noop-pairing-log.txt
+pairing-logs/ml-samples.jsonl
+pairing-logs/exports/**/*.jpg
+pairing-logs/exports/**/*.jpeg
+pairing-logs/exports/**/*.png
+pairing-logs/datasets/
+pairing-logs/live/
+pairing-logs/whoop-apk/
+pairing-logs/*.db
+pairing-logs/*.db-*
diff --git a/Tools/calibrate_whoop_noop.py b/Tools/calibrate_whoop_noop.py
new file mode 100644
index 0000000000..7d2d96ff7e
--- /dev/null
+++ b/Tools/calibrate_whoop_noop.py
@@ -0,0 +1,290 @@
+#!/usr/bin/env python3
+"""CPU-only WHOOP↔NOOP affine calibration + honest metric table.
+
+Reads pairing-logs labels + daily features / optional noop day JSON.
+Writes pairing-logs/calibration-report.json and prints a markdown table.
+
+No GPU. No synthetic WHOOP labels.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import statistics
+from datetime import date, datetime, timezone
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+# Prefer in-repo pairing-logs; AI-store layout keeps them beside the checkout.
+PAIRING = ROOT / "pairing-logs"
+if not PAIRING.is_dir():
+    PAIRING = ROOT.parent / "pairing-logs"
+_ws = Path(r"C:\Users\Gilbert\Documents\Ai app store\pairing-logs")
+if not PAIRING.is_dir() and _ws.is_dir():
+    PAIRING = _ws
+
+LABELS = PAIRING / "whoop-app-labels.jsonl"
+FEATURES = PAIRING / "ml-daily-features.json"
+ASSETS = ROOT / "android" / "app" / "src" / "main" / "assets" / "whoop_app_labels.jsonl"
+NOOP_DAYS = PAIRING / "noop-daily-metrics.jsonl"  # optional export
+OUT = PAIRING / "calibration-report.json"
+
+MIN_N_FIT = 3
+BAND = {
+    "charge": 12.0,
+    "effort": 15.0,
+    "sleep": 15.0,
+    "stress": 20.0,
+}
+
+
+def _load_jsonl(path: Path) -> list[dict]:
+    if not path.is_file():
+        return []
+    rows = []
+    for line in path.read_text(encoding="utf-8").splitlines():
+        t = line.strip()
+        if not t or t.startswith("#"):
+            continue
+        try:
+            rows.append(json.loads(t))
+        except json.JSONDecodeError:
+            continue
+    return rows
+
+
+def _strain_to_100(v: float | None) -> float | None:
+    if v is None:
+        return None
+    if v <= 21.0 + 1e-6:
+        return max(0.0, min(100.0, v / 21.0 * 100.0))
+    return max(0.0, min(100.0, v))
+
+
+def _effort_proxy_to_100(features_day: dict | None) -> float | None:
+    if not features_day:
+        return None
+    p = features_day.get("effort_proxy_0_100")
+    return float(p) if p is not None else None
+
+
+def _affine_fit(xs: list[float], ys: list[float]) -> tuple[float, float]:
+    """Least-squares y ≈ a*x + b. Degenerate → identity."""
+    n = len(xs)
+    if n < 2:
+        return 1.0, 0.0
+    mx = statistics.mean(xs)
+    my = statistics.mean(ys)
+    varx = sum((x - mx) ** 2 for x in xs)
+    if varx < 1e-12:
+        return 1.0, my - mx
+    cov = sum((x - mx) * (y - my) for x, y in zip(xs, ys))
+    a = cov / varx
+    b = my - a * mx
+    return a, b
+
+
+def _mae(pairs: list[tuple[float, float]]) -> float | None:
+    if not pairs:
+        return None
+    return sum(abs(a - b) for a, b in pairs) / len(pairs)
+
+
+def _pearson(xs: list[float], ys: list[float]) -> float | None:
+    n = len(xs)
+    if n < 3:
+        return None
+    mx, my = statistics.mean(xs), statistics.mean(ys)
+    num = sum((x - mx) * (y - my) for x, y in zip(xs, ys))
+    denx = math.sqrt(sum((x - mx) ** 2 for x in xs))
+    deny = math.sqrt(sum((y - my) ** 2 for y in ys))
+    if denx < 1e-12 or deny < 1e-12:
+        return None
+    return num / (denx * deny)
+
+
+def _loo_mae(xs: list[float], ys: list[float]) -> float | None:
+    n = len(xs)
+    if n < 3:
+        return None
+    errs = []
+    for i in range(n):
+        tx = xs[:i] + xs[i + 1 :]
+        ty = ys[:i] + ys[i + 1 :]
+        a, b = _affine_fit(tx, ty)
+        pred = a * xs[i] + b
+        errs.append(abs(pred - ys[i]))
+    return sum(errs) / len(errs)
+
+
+def collect_pairs(features: dict) -> dict[str, list[dict]]:
+    """Build per-head pairs from labels + optional noop metrics + feature proxies."""
+    label_rows = _load_jsonl(LABELS) + _load_jsonl(ASSETS)
+    by_day: dict[str, dict] = {}
+    for r in label_rows:
+        day = r.get("day")
+        if not day:
+            continue
+        by_day.setdefault(day, {}).update(
+            {
+                "whoop_recovery": r.get("recovery_pct") if r.get("recovery_pct") is not None else r.get("recoveryPct"),
+                "whoop_strain_021": r.get("strain_021") if r.get("strain_021") is not None else r.get("dayStrain021"),
+                "whoop_sleep": r.get("sleep_pct") if r.get("sleep_pct") is not None else r.get("sleepPct"),
+                "whoop_stress": r.get("stress_pct") if r.get("stress_pct") is not None else r.get("stressPct"),
+                "source": r.get("source"),
+            }
+        )
+
+    for r in _load_jsonl(NOOP_DAYS):
+        day = r.get("day")
+        if not day:
+            continue
+        by_day.setdefault(day, {}).update(
+            {
+                "noop_recovery": r.get("recovery"),
+                "noop_strain": r.get("strain"),
+                "noop_sleep": r.get("sleep_performance") or r.get("rest"),
+                "noop_stress": r.get("stress_pct"),
+            }
+        )
+
+    feat_days = (features or {}).get("days") or {}
+    today = date.today().isoformat()
+    out = {"charge": [], "effort": [], "sleep": [], "stress": []}
+    for day, row in sorted(by_day.items()):
+        if day >= today:
+            continue  # incomplete day guard
+        f = feat_days.get(day)
+        whoop_e = _strain_to_100(row.get("whoop_strain_021"))
+        noop_e = row.get("noop_strain")
+        if noop_e is None:
+            noop_e = _effort_proxy_to_100(f)
+
+        if row.get("whoop_recovery") is not None and row.get("noop_recovery") is not None:
+            out["charge"].append(
+                {
+                    "day": day,
+                    "noop": float(row["noop_recovery"]),
+                    "whoop": float(row["whoop_recovery"]),
+                }
+            )
+        if whoop_e is not None and noop_e is not None:
+            out["effort"].append({"day": day, "noop": float(noop_e), "whoop": float(whoop_e)})
+        if row.get("whoop_sleep") is not None and row.get("noop_sleep") is not None:
+            out["sleep"].append(
+                {
+                    "day": day,
+                    "noop": float(row["noop_sleep"]),
+                    "whoop": float(row["whoop_sleep"]),
+                }
+            )
+        if row.get("whoop_stress") is not None and row.get("noop_stress") is not None:
+            out["stress"].append(
+                {
+                    "day": day,
+                    "noop": float(row["noop_stress"]),
+                    "whoop": float(row["whoop_stress"]),
+                }
+            )
+    return out
+
+
+def evaluate_head(name: str, pairs: list[dict]) -> dict:
+    xs = [p["noop"] for p in pairs]
+    ys = [p["whoop"] for p in pairs]
+    raw = list(zip(xs, ys))
+    mae_before = _mae(raw)
+    a, b = (1.0, 0.0)
+    mae_after = mae_before
+    loo = None
+    r = _pearson(xs, ys)
+    fitted = False
+    if len(pairs) >= MIN_N_FIT:
+        a, b = _affine_fit(xs, ys)
+        fitted = True
+        cal = [(a * x + b, y) for x, y in raw]
+        mae_after = _mae(cal)
+        loo = _loo_mae(xs, ys)
+    within = None
+    if pairs:
+        band = BAND[name]
+        within = sum(1 for x, y in raw if abs(x - y) <= band) / len(raw)
+    return {
+        "head": name,
+        "n": len(pairs),
+        "mae_before": mae_before,
+        "mae_after_affine": mae_after,
+        "loo_mae": loo,
+        "pearson_r": r,
+        "affine_a": a,
+        "affine_b": b,
+        "fitted": fitted,
+        "within_band_frac": within,
+        "band": BAND[name],
+        "days": [p["day"] for p in pairs],
+        "citations": "Plews2013 / Banister1991 / Cole-Kripke1992 / Baevsky2008; affine per docs/CALIBRATION.md",
+    }
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--pairing", type=Path, default=PAIRING)
+    args = ap.parse_args()
+    pairing = args.pairing
+    features = {}
+    feat_path = pairing / "ml-daily-features.json"
+    if feat_path.is_file():
+        features = json.loads(feat_path.read_text(encoding="utf-8"))
+
+    global LABELS, ASSETS, NOOP_DAYS, OUT
+    LABELS = pairing / "whoop-app-labels.jsonl"
+    NOOP_DAYS = pairing / "noop-daily-metrics.jsonl"
+    OUT = pairing / "calibration-report.json"
+
+    pairs = collect_pairs(features)
+    heads = [evaluate_head(k, pairs[k]) for k in ("charge", "effort", "sleep", "stress")]
+    n_fit = sum(1 for h in heads if h["fitted"])
+    n_any = sum(h["n"] for h in heads)
+    accuracy_valid = n_fit >= 2 and all(
+        h["n"] >= MIN_N_FIT or h["n"] == 0 for h in heads if h["head"] in ("charge", "effort", "sleep")
+    )
+    # Stricter: Charge + Effort + Sleep must each have n>=3 to claim valid multi-head accuracy.
+    accuracy_valid = all(h["n"] >= MIN_N_FIT for h in heads if h["head"] in ("charge", "effort", "sleep"))
+
+    report = {
+        "generated_at": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
+        "accuracy_valid": accuracy_valid,
+        "min_n_fit": MIN_N_FIT,
+        "n_label_rows": len(_load_jsonl(LABELS) + _load_jsonl(ASSETS)),
+        "n_pairs_total": n_any,
+        "heads_fitted": n_fit,
+        "gpu": "none (CPU-only)",
+        "method": "affine least-squares + LOO MAE; shared 0-100 (strain ×100/21)",
+        "citations_doc": "docs/CALIBRATION.md",
+        "heads": heads,
+        "deploy_gate": "PASS" if accuracy_valid else "FAIL - need >=3 paired days on Charge, Effort, Sleep",
+        "note": "Never invent WHOOP labels. Sparse N means gate fail, not fake high accuracy.",
+    }
+    OUT.parent.mkdir(parents=True, exist_ok=True)
+    OUT.write_text(json.dumps(report, indent=2), encoding="utf-8")
+
+    def _fmt(v):
+        return "-" if v is None else f"{v:.2f}" if isinstance(v, float) else str(v)
+
+    print("| Head | N | MAE before | MAE after affine | Pearson r | Fitted |")
+    print("|------|---|------------|------------------|-----------|--------|")
+    for h in heads:
+        pr = "-" if h["pearson_r"] is None else f"{h['pearson_r']:.3f}"
+        print(
+            f"| {h['head']} | {h['n']} | {_fmt(h['mae_before'])} | "
+            f"{_fmt(h['mae_after_affine'])} | {pr} | {h['fitted']} |"
+        )
+    print()
+    print(f"accuracy_valid={accuracy_valid}  deploy_gate={report['deploy_gate']}")
+    print(f"wrote {OUT}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/Tools/ingest_export.ps1 b/Tools/ingest_export.ps1
new file mode 100644
index 0000000000..c1bac2407c
--- /dev/null
+++ b/Tools/ingest_export.ps1
@@ -0,0 +1,204 @@
+# Ingest a WHOOP/NOOP screenshot export from Downloads into pairing-logs/exports/
+# and emit a manifest.csv that pairs same-minute WHOOP<->NOOP captures.
+#
+# Usage:
+#   powershell -File Tools\ingest_export.ps1
+#   powershell -File Tools\ingest_export.ps1 -ExportDir "C:\Users\Gilbert\Downloads\Noop mg-...\Noop mg"
+#   powershell -File Tools\ingest_export.ps1 -ExportDir "...\Noop stresd" -PackKind stress
+#
+# Filenames are the source of truth: Screenshot_YYYYMMDD_HHMMSS_<APP>.jpg
+# (Samsung stamps capture time + foreground app). The manifest adds empty
+# `screen` / `values` columns that the decode pass fills in, so the CSV —
+# not prose — becomes the durable record for that export.
+#
+# Screen taxonomy + three-lane compare:
+#   docs/WHOOP_NOOP_SCREENSHOT_COMPARE.md  (AI app store root)
+
+param(
+    [string]$ExportDir = "",
+    [int]$PairWindowMinutes = 10,
+    [ValidateSet("auto", "stress", "sleep", "mixed")]
+    [string]$PackKind = "auto"
+)
+
+$ErrorActionPreference = "Stop"
+$downloads = Join-Path $env:USERPROFILE "Downloads"
+
+# Prefer repo pairing-logs/exports (noop checkout). Fall back to AI-store workspace.
+$exportsRoot = Join-Path $PSScriptRoot "..\pairing-logs\exports"
+$wsExports = "C:\Users\Gilbert\Documents\Ai app store\pairing-logs\exports"
+if (-not (Test-Path (Split-Path $exportsRoot)) -and (Test-Path (Split-Path $wsExports))) {
+    $exportsRoot = $wsExports
+}
+
+$pattern = '^Screenshot_(\d{8})_(\d{6})_(.+)\.(jpg|jpeg|png)$'
+
+function Infer-PackKind([object[]]$rows) {
+    $names = ($rows | ForEach-Object { $_.file }) -join " "
+    $stressHints = 0; $sleepHints = 0
+    # Filename alone rarely encodes screen — default mixed; caller should pass -PackKind
+    if ($PackKind -ne "auto") { return $PackKind }
+    return "mixed"
+}
+
+$requiredByKind = @{
+    stress = @(
+        @{ Id = "S1"; App = "WHOOP"; Screen = "whoop_home"; Why = "Home Stress Monitor card (tip+band)" },
+        @{ Id = "S2"; App = "WHOOP"; Screen = "whoop_stress_monitor"; Why = "Full Stress Monitor chart + high-zone copy" },
+        @{ Id = "S3"; App = "NOOP"; Screen = "noop_today_health"; Why = "Today Health/Key Metrics stress row" },
+        @{ Id = "S4"; App = "NOOP"; Screen = "noop_stress_hero"; Why = "Stress hero Now tip" },
+        @{ Id = "S5"; App = "NOOP"; Screen = "noop_stress_timeline"; Why = "Intraday timeline + time-in-band (do not skip)" }
+    )
+    sleep = @(
+        @{ Id = "L1"; App = "WHOOP"; Screen = "whoop_home"; Why = "Home rings + sleep activity" },
+        @{ Id = "L2"; App = "WHOOP"; Screen = "whoop_sleep_detail"; Why = "Hours of sleep + stage bars" },
+        @{ Id = "L3"; App = "NOOP"; Screen = "noop_sleep_hero"; Why = "Rest gauge + What shaped Rest" },
+        @{ Id = "L4"; App = "NOOP"; Screen = "noop_sleep_stages"; Why = "Stage minutes / honesty strip" },
+        @{ Id = "L5"; App = "NOOP"; Screen = "noop_today_health"; Why = "Today Rest vessel same wake-day" }
+    )
+    mixed = @(
+        @{ Id = "M1"; App = "WHOOP"; Screen = "whoop_home"; Why = "Home rings + Stress card" },
+        @{ Id = "M2"; App = "WHOOP"; Screen = "whoop_stress_monitor"; Why = "Stress Monitor if comparing stress" },
+        @{ Id = "M3"; App = "WHOOP"; Screen = "whoop_sleep_detail"; Why = "Sleep detail if comparing Rest" },
+        @{ Id = "M4"; App = "NOOP"; Screen = "noop_today_health"; Why = "Today Health row" },
+        @{ Id = "M5"; App = "NOOP"; Screen = "noop_stress_timeline"; Why = "NOOP stress chart (often missing)" },
+        @{ Id = "M6"; App = "NOOP"; Screen = "noop_sleep_hero"; Why = "Sleep Rest hero" }
+    )
+}
+
+if (-not $ExportDir) {
+    $candidates = Get-ChildItem $downloads -Directory | ForEach-Object {
+        $leafDirs = @($_) + (Get-ChildItem $_.FullName -Directory -ErrorAction SilentlyContinue)
+        foreach ($d in $leafDirs) {
+            $shots = Get-ChildItem $d.FullName -File -ErrorAction SilentlyContinue |
+                Where-Object { $_.Name -match $pattern }
+            if ($shots) {
+                [pscustomobject]@{ Dir = $d.FullName; Newest = ($shots | Sort-Object Name | Select-Object -Last 1).Name }
+            }
+        }
+    }
+    if (-not $candidates) { throw "No export folder with Screenshot_*_APP.jpg files found under $downloads" }
+    $ExportDir = ($candidates | Sort-Object Newest | Select-Object -Last 1).Dir
+}
+
+Write-Host "Ingesting: $ExportDir"
+
+$shots = @(Get-ChildItem $ExportDir -File | Where-Object { $_.Name -match $pattern })
+if (-not $shots) { throw "No Screenshot_*_APP files in $ExportDir" }
+
+$rows = foreach ($f in $shots) {
+    $null = $f.Name -match $pattern
+    $d = $Matches[1]; $t = $Matches[2]; $app = $Matches[3].ToUpper()
+    # Normalize package-style suffixes (com.whoop... etc.) to WHOOP/NOOP when obvious
+    if ($app -match 'WHOOP') { $app = 'WHOOP' }
+    elseif ($app -match 'NOOP|STRAND') { $app = 'NOOP' }
+    [pscustomobject]@{
+        file     = $f.Name
+        app      = $app
+        captured = [datetime]::ParseExact("$d$t", "yyyyMMddHHmmss", $null)
+        screen   = ""
+        values   = ""
+        pairFile = ""
+        pairGapS = ""
+    }
+}
+$rows = @($rows | Sort-Object captured)
+$kind = Infer-PackKind $rows
+
+# pair each capture with the nearest capture from the OTHER app within the window
+foreach ($r in $rows) {
+    $others = $rows | Where-Object { $_.app -ne $r.app }
+    if ($others) {
+        $best = $others | Sort-Object { [math]::Abs(($_.captured - $r.captured).TotalSeconds) } | Select-Object -First 1
+        $gap = [math]::Abs(($best.captured - $r.captured).TotalSeconds)
+        if ($gap -le $PairWindowMinutes * 60) {
+            $r.pairFile = $best.file
+            $r.pairGapS = [int]$gap
+        }
+    }
+}
+
+$stamp = ($rows[0].captured).ToString("yyyyMMdd") + "-" + (Split-Path $ExportDir -Leaf).Trim() -replace '[^\w\-]', '_'
+$dest = Join-Path $exportsRoot $stamp
+New-Item -ItemType Directory -Force $dest | Out-Null
+foreach ($f in $shots) { Copy-Item $f.FullName (Join-Path $dest $f.Name) -Force }
+
+$manifest = Join-Path $dest "manifest.csv"
+$rows | Select-Object file, app, @{n='captured';e={$_.captured.ToString("yyyy-MM-dd HH:mm:ss")}}, screen, values, pairFile, pairGapS |
+    Export-Csv $manifest -NoTypeInformation -Encoding UTF8
+
+# REQUIRED_SHOTS.md - checklist vs inventory (screen still empty until decode)
+$req = $requiredByKind[$kind]
+$reqPath = Join-Path $dest "REQUIRED_SHOTS.md"
+$sb = New-Object System.Text.StringBuilder
+[void]$sb.AppendLine("# Required shots - pack kind $kind")
+[void]$sb.AppendLine("")
+[void]$sb.AppendLine("Playbook: docs/WHOOP_NOOP_SCREENSHOT_COMPARE.md")
+[void]$sb.AppendLine("Export: $ExportDir")
+[void]$sb.AppendLine("Copied to: $dest")
+[void]$sb.AppendLine("")
+[void]$sb.AppendLine("| Id | Need | App | Target screen | Status |")
+[void]$sb.AppendLine("|----|------|-----|---------------|--------|")
+foreach ($item in $req) {
+    $haveApp = @($rows | Where-Object { $_.app -eq $item.App }).Count
+    if ($haveApp -gt 0) {
+        $status = "HAVE $($item.App) files ($haveApp) - assign screen=$($item.Screen) in manifest during decode"
+    } else {
+        $status = "MISSING any $($item.App) shot"
+    }
+    [void]$sb.AppendLine("| $($item.Id) | $($item.Why) | $($item.App) | $($item.Screen) | $status |")
+}
+[void]$sb.AppendLine("")
+[void]$sb.AppendLine("After decode: mark each Id DONE only when a row has that screen value filled.")
+[void]$sb.AppendLine("Stress packs: S5 (noop_stress_timeline) was missing in Noop-mg 2026-07-14 - always capture it.")
+[System.IO.File]::WriteAllText($reqPath, $sb.ToString())
+
+# decode_worksheet.md - one block per file for Read-tool decode passes
+$wsPath = Join-Path $dest "decode_worksheet.md"
+$wsb = New-Object System.Text.StringBuilder
+[void]$wsb.AppendLine("# Decode worksheet")
+[void]$wsb.AppendLine("")
+[void]$wsb.AppendLine("Fill screen + values here, then copy into manifest.csv.")
+[void]$wsb.AppendLine("Taxonomy keys: docs/WHOOP_NOOP_SCREENSHOT_COMPARE.md sections 3-4.")
+[void]$wsb.AppendLine("")
+foreach ($r in $rows) {
+    $pair = if ($r.pairFile) { "$($r.pairFile) (gap $($r.pairGapS)s)" } else { "(unpaired)" }
+    [void]$wsb.AppendLine("## $($r.file)")
+    [void]$wsb.AppendLine("")
+    [void]$wsb.AppendLine("- app: $($r.app) | captured: $($r.captured.ToString('yyyy-MM-dd HH:mm:ss')) | pair: $pair")
+    [void]$wsb.AppendLine("- screen:  (whoop_stress_monitor / noop_stress_timeline / ...)")
+    [void]$wsb.AppendLine("- values:  (tip=; band=; tipClock=; highZone=; statusBarClock=; ...)")
+    [void]$wsb.AppendLine("- chart notes: (night floor / peak hour / activity glyph / missing series)")
+    [void]$wsb.AppendLine("")
+}
+[System.IO.File]::WriteAllText($wsPath, $wsb.ToString())
+
+# labels stub template (append manually after decode - do not auto-write guessing)
+$stubPath = Join-Path $dest "labels_stub.jsonl.example"
+$stubLines = foreach ($r in @($rows | Where-Object { $_.app -eq 'WHOOP' -and $_.pairFile })) {
+    $day = $r.captured.ToString("yyyy-MM-dd")
+    $clock = $r.captured.ToString("HH:mm")
+    '{"day":"' + $day + '","source":"screenshot","clock":"' + $clock + '","whoop_file":"' + $r.file + '","noop_file":"' + $r.pairFile + '","stress_tip":null,"stress_band":null,"noop_tip":null,"serial":"export:' + $stamp + '"}'
+}
+if ($stubLines) {
+    [System.IO.File]::WriteAllLines($stubPath, @($stubLines))
+}
+
+$byApp = $rows | Group-Object app | ForEach-Object { "$($_.Name)=$($_.Count)" }
+$span = "{0:HH:mm:ss} - {1:HH:mm:ss}" -f $rows[0].captured, $rows[-1].captured
+$paired = @($rows | Where-Object { $_.pairGapS -ne "" }).Count
+$tight = @($rows | Where-Object { $_.pairGapS -ne "" -and [int]$_.pairGapS -le 120 }).Count
+
+Write-Host ""
+Write-Host "Copied $($rows.Count) shots -> $dest"
+Write-Host "PackKind: $kind   Apps: $($byApp -join ', ')   Span: $span"
+Write-Host "Paired (<= ${PairWindowMinutes}m): $paired/$($rows.Count)   Tight (<=2m tip@clock): $tight"
+Write-Host "Manifest:  $manifest"
+Write-Host "Checklist: $reqPath"
+Write-Host "Worksheet: $wsPath"
+if (Test-Path $stubPath) { Write-Host "Labels:    $stubPath  (fill tips, append to pairing-logs\whoop-app-labels.jsonl)" }
+Write-Host ""
+Write-Host "Next:"
+Write-Host "  1. Read each JPG; fill screen+values in manifest.csv (worksheet helps)."
+Write-Host "  2. Tip@clock table + three-lane compare per docs\WHOOP_NOOP_SCREENSHOT_COMPARE.md"
+Write-Host "  3. Update factor docs; ANY_MODEL_CONTINUE.md last."
diff --git a/Tools/ml_engine_train.py b/Tools/ml_engine_train.py
new file mode 100644
index 0000000000..e24544d516
--- /dev/null
+++ b/Tools/ml_engine_train.py
@@ -0,0 +1,587 @@
+#!/usr/bin/env python3
+"""NOOP ML engine — train/eval Effort toward WHOOP **app** Strain labels.
+
+Accuracy is ONLY reported when real labels exist (whoop-app dumps / manual JSON / export).
+Synthetic or empty labels → status accuracy_valid=false (never claim %).
+
+Pipeline always builds a daily feature store from ML_SAMPLE / log so the moment labels
+arrive, fitting is ready (G5). Loops should read pairing-logs/ml-engine-status.json and
+update Goals (G4/G5), not invent pass scores from pipeline-only HR.
+
+Usage:
+  python Tools/ml_engine_train.py
+  python Tools/ml_engine_train.py --labels pairing-logs/whoop-app-labels.jsonl
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import re
+import statistics
+from collections import defaultdict
+from datetime import date, datetime, timezone
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+OUT = ROOT / "pairing-logs" / "ml-engine-status.json"
+WEIGHTS = ROOT / "pairing-logs" / "ml-effort-weights.json"
+FEATURES_OUT = ROOT / "pairing-logs" / "ml-daily-features.json"
+SPORT_FEATURES_OUT = ROOT / "pairing-logs" / "ml-sport-session-features.json"
+GOALS_OUT = ROOT / "pairing-logs" / "goals-from-ml.json"
+LOG = ROOT / "pairing-logs" / "noop-pairing-log.txt"
+SAMPLES = ROOT / "pairing-logs" / "ml-samples.jsonl"
+DUMPS = ROOT / "pairing-logs" / "whoop-app-dumps"
+LABELS_JSONL = ROOT / "pairing-logs" / "whoop-app-labels.jsonl"
+
+
+def _read_json_text(path: Path) -> str:
+    """Read text accepting UTF-8 BOM (PowerShell Set-Content -Encoding utf8)."""
+    return path.read_text(encoding="utf-8-sig", errors="replace")
+
+
+def load_labels(path: Path) -> list[dict]:
+    rows: list[dict] = []
+    if path.exists():
+        for line in _read_json_text(path).splitlines():
+            line = line.strip().lstrip("\ufeff")
+            if not line:
+                continue
+            try:
+                rows.append(json.loads(line))
+            except json.JSONDecodeError:
+                continue
+    if DUMPS.is_dir():
+        for p in sorted(DUMPS.glob("scores-*.json")):
+            try:
+                d = json.loads(_read_json_text(p))
+                if d.get("day_strain_021") is not None or d.get("recovery_pct") is not None:
+                    rows.append(
+                        {
+                            "day": d.get("day") or p.stem,
+                            "strain_021": d.get("day_strain_021"),
+                            "recovery_pct": d.get("recovery_pct"),
+                            "source": d.get("source") or "adb_dump",
+                        }
+                    )
+            except Exception:
+                pass
+    # Dedupe by day: keep richest row (prefer recovery present, then later in list)
+    by_day: dict[str, dict] = {}
+    for r in rows:
+        day = str(r.get("day") or r.get("day_raw") or "").strip()
+        if not day or day.startswith("scores-"):
+            # keep undated rows with synthetic keys so they don't collapse
+            day = f"_undated_{len(by_day)}_{r.get('source')}"
+        prev = by_day.get(day)
+        if prev is None:
+            by_day[day] = r
+            continue
+        prev_score = (1 if prev.get("recovery_pct") is not None else 0) + (
+            1 if prev.get("strain_021") is not None else 0
+        )
+        new_score = (1 if r.get("recovery_pct") is not None else 0) + (
+            1 if r.get("strain_021") is not None else 0
+        )
+        if new_score >= prev_score:
+            by_day[day] = r
+    return list(by_day.values())
+
+
+def _day_key_from_recv(recv_at: str | None, ts_ms: int | None) -> str | None:
+    if recv_at:
+        # 2026-07-10T18:41:15+00:00
+        try:
+            return recv_at[:10]
+        except Exception:
+            pass
+    if ts_ms and ts_ms > 1_000_000_000_000:
+        try:
+            return datetime.fromtimestamp(ts_ms / 1000.0, tz=timezone.utc).strftime("%Y-%m-%d")
+        except Exception:
+            pass
+    return None
+
+
+def load_ml_samples() -> list[dict]:
+    rows = []
+    if SAMPLES.exists():
+        for line in SAMPLES.read_text(encoding="utf-8", errors="replace").splitlines():
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                rows.append(json.loads(line))
+            except json.JSONDecodeError:
+                continue
+    # Also scrape last ~1.5MB of pairing log for ML_SAMPLE lines (richer R-R sometimes)
+    if LOG.exists():
+        data = LOG.read_bytes()[-1_500_000:].decode("utf-8", "replace")
+        for m in re.finditer(
+            r"ML_SAMPLE[^\n]*?(?:ts_ms=(\d+))?[^\n]*?hr=(\d{2,3})(?:[^\n]*?rr=\[([^\]]*)\])?",
+            data,
+        ):
+            ts_s, hr_s, rr_s = m.group(1), m.group(2), m.group(3)
+            # Try to get ISO prefix on same line
+            line_start = data.rfind("\n", 0, m.start()) + 1
+            line = data[line_start : m.end()]
+            day = None
+            iso = re.match(r"(\d{4}-\d{2}-\d{2})", line)
+            if iso:
+                day = iso.group(1)
+            rr = []
+            if rr_s:
+                rr = [int(x) for x in re.findall(r"\d+", rr_s)]
+            rows.append(
+                {
+                    "kind": "ML_SAMPLE",
+                    "ts_ms": int(ts_s) if ts_s else None,
+                    "hr": int(hr_s),
+                    "rr": rr,
+                    "day": day,
+                    "source": "log_scrape",
+                }
+            )
+    return rows
+
+
+def load_sport_labels(samples: list[dict]) -> list[dict]:
+    """Load debug-only, user-confirmed workout labels without mixing them into daily WHOOP labels."""
+    rows = [s for s in samples if s.get("kind") == "ML_WORKOUT_LABEL"]
+    if LOG.exists():
+        data = LOG.read_bytes()[-1_500_000:].decode("utf-8", "replace")
+        pattern = re.compile(
+            r"ML_WORKOUT_LABEL\s+v=(?P<v>\d+)\s+label_ts_ms=(?P<label>\d+)\s+"
+            r"start_ts_ms=(?P<start>\d+)\s+end_ts_ms=(?P<end>\d+)\s+"
+            r"sport_key=(?P<sport>[a-z]+)\s+provenance=(?P<provenance>[a-z_]+)"
+        )
+        for match in pattern.finditer(data):
+            rows.append({
+                "kind": "ML_WORKOUT_LABEL",
+                "label_ts_ms": int(match["label"]),
+                "start_ts_ms": int(match["start"]),
+                "end_ts_ms": int(match["end"]),
+                "sport_key": match["sport"],
+                "provenance": match["provenance"],
+            })
+    # A corrected label for the same window supersedes the older one. Keep ineligible rows for audit.
+    latest: dict[tuple[int, int], dict] = {}
+    for row in rows:
+        try:
+            key = (int(row["start_ts_ms"]), int(row["end_ts_ms"]))
+        except (KeyError, TypeError, ValueError):
+            continue
+        if key[1] <= key[0] or not row.get("sport_key"):
+            continue
+        if int(row.get("label_ts_ms") or 0) >= int(latest.get(key, {}).get("label_ts_ms") or 0):
+            latest[key] = row
+    return list(latest.values())
+
+
+def build_sport_session_features(samples: list[dict], labels: list[dict], as_of: date) -> list[dict]:
+    """Make an auditable session manifest. It collects features only; it does not train or claim detection."""
+    output: list[dict] = []
+    for label in sorted(labels, key=lambda r: (r.get("start_ts_ms", 0), r.get("label_ts_ms", 0))):
+        try:
+            start, end = int(label["start_ts_ms"]), int(label["end_ts_ms"])
+        except (KeyError, TypeError, ValueError):
+            continue
+        end_day = datetime.fromtimestamp(end / 1000.0).astimezone().date()
+        window = [s for s in samples if isinstance(s.get("ts_ms"), int) and start <= s["ts_ms"] <= end]
+        hrs = [int(s["hr"]) for s in window if str(s.get("hr", "")).isdigit() and 30 <= int(s["hr"]) <= 220]
+        steps = [int(s["steps"]) for s in window if str(s.get("steps", "")).isdigit()]
+        coverage_s = ((max(s["ts_ms"] for s in window) - min(s["ts_ms"] for s in window)) / 1000.0) if len(window) >= 2 else 0.0
+        eligible = end_day < as_of and len(hrs) >= 20 and coverage_s >= min(300.0, (end - start) / 1000.0 * 0.5)
+        output.append({
+            "version": 1,
+            "sport_key": label.get("sport_key"),
+            "provenance": label.get("provenance"),
+            "label_ts_ms": label.get("label_ts_ms"),
+            "start_ts_ms": start,
+            "end_ts_ms": end,
+            "duration_s": round((end - start) / 1000.0, 1),
+            "n_samples": len(window),
+            "n_hr_samples": len(hrs),
+            "coverage_s": round(coverage_s, 1),
+            "mean_hr": round(statistics.fmean(hrs), 2) if hrs else None,
+            "max_hr": max(hrs) if hrs else None,
+            "min_hr": min(hrs) if hrs else None,
+            "hr_stdev": round(statistics.pstdev(hrs), 2) if len(hrs) >= 2 else None,
+            "steps_delta": max(steps) - min(steps) if len(steps) >= 2 else None,
+            "eligible_for_future_training": eligible,
+            "eligibility_note": "user-confirmed label with sufficient completed-session coverage" if eligible else "retained for audit; needs a completed session and denser overlapping samples",
+        })
+    return output
+
+
+def rmssd_ms(rr: list[float]) -> float | None:
+    if len(rr) < 3:
+        return None
+    diffs = [rr[i + 1] - rr[i] for i in range(len(rr) - 1)]
+    if not diffs:
+        return None
+    return math.sqrt(sum(d * d for d in diffs) / len(diffs))
+
+
+def completed_day(day: object, as_of: date) -> bool:
+    """Only completed local calendar days may become ML features or labels."""
+    try:
+        return date.fromisoformat(str(day)) < as_of
+    except (TypeError, ValueError):
+        return False
+
+
+def build_daily_features(samples: list[dict], as_of: date) -> dict[str, dict]:
+    """Aggregate HR / R-R / steps into per-UTC-day features for Effort calibration."""
+    by_day: dict[str, dict] = defaultdict(lambda: {"hrs": [], "rrs": [], "steps": [], "n": 0})
+    for s in samples:
+        day = s.get("day") or _day_key_from_recv(s.get("recv_at"), s.get("ts_ms"))
+        if not day or day.startswith("1970") or not completed_day(day, as_of):
+            continue
+        hr = s.get("hr")
+        if hr is not None:
+            try:
+                h = int(hr)
+                if 40 <= h <= 220:
+                    by_day[day]["hrs"].append(h)
+            except (TypeError, ValueError):
+                pass
+        rr = s.get("rr") or []
+        if isinstance(rr, str):
+            rr = [int(x) for x in re.findall(r"\d+", rr)]
+        for r in rr:
+            if 300 <= r <= 2000:
+                by_day[day]["rrs"].append(float(r))
+        steps = s.get("steps")
+        if steps is not None:
+            try:
+                by_day[day]["steps"].append(int(steps))
+            except (TypeError, ValueError):
+                pass
+        by_day[day]["n"] += 1
+
+    out: dict[str, dict] = {}
+    for day, bucket in sorted(by_day.items()):
+        hrs = bucket["hrs"]
+        if len(hrs) < 10:
+            continue
+        mean_hr = statistics.fmean(hrs)
+        max_hr = max(hrs)
+        min_hr = min(hrs)
+        # Crude TRIMP-like: minutes above 100 / 120 as zone proxies (sample density unknown)
+        z1 = sum(1 for h in hrs if h >= 100) / len(hrs)
+        z2 = sum(1 for h in hrs if h >= 130) / len(hrs)
+        # Effort proxy 0–100 (heuristic, NOT WHOOP Strain)
+        effort_proxy = max(0.0, min(100.0, (mean_hr - 55) * 1.8 + z1 * 25 + z2 * 35 + (max_hr - mean_hr) * 0.15))
+        rr_rmssd = rmssd_ms(bucket["rrs"][-500:]) if bucket["rrs"] else None
+        steps_max = max(bucket["steps"]) if bucket["steps"] else None
+        out[day] = {
+            "day": day,
+            "n_samples": len(hrs),
+            "mean_hr": round(mean_hr, 2),
+            "max_hr": max_hr,
+            "min_hr": min_hr,
+            "frac_hr_ge_100": round(z1, 4),
+            "frac_hr_ge_130": round(z2, 4),
+            "rr_rmssd_ms": round(rr_rmssd, 2) if rr_rmssd is not None else None,
+            "steps_max": steps_max,
+            "effort_proxy_0_100": round(effort_proxy, 2),
+            "note": "effort_proxy is heuristic — not accuracy vs WHOOP app",
+        }
+    return out
+
+
+def fit_linear(xs: list[float], ys: list[float]) -> tuple[float, float, float]:
+    n = len(xs)
+    if n < 2:
+        return 1.0, 0.0, float("nan")
+    mx = sum(xs) / n
+    my = sum(ys) / n
+    num = sum((x - mx) * (y - my) for x, y in zip(xs, ys))
+    den = sum((x - mx) ** 2 for x in xs) or 1e-9
+    a = num / den
+    b = my - a * mx
+    rmse = math.sqrt(sum((a * x + b - y) ** 2 for x, y in zip(xs, ys)) / n)
+    return a, b, rmse
+
+
+def fit_multifeature(
+    X: list[list[float]], y: list[float]
+) -> tuple[list[float], float, float]:
+    """Ridge y ≈ w·x + b with tiny L2; pure Python for portability."""
+    n = len(X)
+    if n < 2 or not X:
+        return [1.0], 0.0, float("nan")
+    d = len(X[0])
+    # Augment with bias column
+    A = [row[:] + [1.0] for row in X]
+    # (A^T A + λI) w = A^T y
+    dim = d + 1
+    lam = 1e-2
+    ata = [[0.0] * dim for _ in range(dim)]
+    aty = [0.0] * dim
+    for i in range(n):
+        for r in range(dim):
+            aty[r] += A[i][r] * y[i]
+            for c in range(dim):
+                ata[r][c] += A[i][r] * A[i][c]
+    for i in range(dim):
+        ata[i][i] += lam
+    # Gaussian elimination
+    M = [ata[r][:] + [aty[r]] for r in range(dim)]
+    for col in range(dim):
+        piv = max(range(col, dim), key=lambda r: abs(M[r][col]))
+        M[col], M[piv] = M[piv], M[col]
+        if abs(M[col][col]) < 1e-12:
+            continue
+        div = M[col][col]
+        for c in range(col, dim + 1):
+            M[col][c] /= div
+        for r in range(dim):
+            if r == col:
+                continue
+            f = M[r][col]
+            for c in range(col, dim + 1):
+                M[r][c] -= f * M[col][c]
+    w = [M[r][dim] for r in range(dim)]
+    weights, bias = w[:-1], w[-1]
+    preds = [sum(wi * xi for wi, xi in zip(weights, X[i])) + bias for i in range(n)]
+    rmse = math.sqrt(sum((preds[i] - y[i]) ** 2 for i in range(n)) / n)
+    return weights, bias, rmse
+
+
+def goals_status(
+    *,
+    n_pairs: int,
+    accuracy_valid: bool,
+    n_feature_days: int,
+    n_labels: int,
+) -> dict:
+    """Mirror durable Goals board for PC loops (G1–G5 relevant to ML)."""
+    g5 = "DONE" if accuracy_valid and n_pairs >= 7 else ("PARTIAL" if n_pairs >= 2 else "NOT_DONE")
+    g4 = "NOT_DONE"  # real κ needs sleep-accel; engine does not flip this alone
+    return {
+        "G1_auto_labels": "PARTIAL" if n_labels == 0 else "PARTIAL",
+        "G2_compare_app": "PARTIAL",
+        "G4_sleep_kappa": g4,
+        "G5_ml_train": g5,
+        "feature_days_ready": n_feature_days,
+        "label_rows": n_labels,
+        "paired_days": n_pairs,
+        "accuracy_valid": accuracy_valid,
+        "message": (
+            "Feature store ready; waiting for WHOOP **app** Strain labels to train."
+            if n_pairs == 0
+            else (
+                "Trained with valid multi-day labels."
+                if accuracy_valid
+                else "Underfit — need more distinct labeled days."
+            )
+        ),
+    }
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--labels", type=str, default=str(LABELS_JSONL))
+    ap.add_argument(
+        "--as-of",
+        type=str,
+        default=datetime.now().astimezone().date().isoformat(),
+        help="Local date whose in-progress and future days are excluded (YYYY-MM-DD).",
+    )
+    args = ap.parse_args()
+    try:
+        as_of = date.fromisoformat(args.as_of)
+    except ValueError:
+        ap.error("--as-of must use YYYY-MM-DD")
+
+    samples = load_ml_samples()
+    sport_labels = load_sport_labels(samples)
+    sport_sessions = build_sport_session_features(samples, sport_labels, as_of)
+    daily = build_daily_features(samples, as_of)
+    FEATURES_OUT.parent.mkdir(parents=True, exist_ok=True)
+    FEATURES_OUT.write_text(
+        json.dumps(
+            {
+                "days": daily,
+                "n_days": len(daily),
+                "completed_before": as_of.isoformat(),
+                "note": "Current and future days are excluded until their local day completes.",
+            },
+            indent=2,
+        ),
+        encoding="utf-8",
+    )
+    SPORT_FEATURES_OUT.write_text(
+        json.dumps({
+            "sessions": sport_sessions,
+            "n_labels": len(sport_labels),
+            "n_eligible": sum(1 for session in sport_sessions if session["eligible_for_future_training"]),
+            "completed_before": as_of.isoformat(),
+            "status": "COLLECTING_ONLY",
+            "note": "User-confirmed sport labels joined to open-BLE samples. No sport classifier or accuracy claim is produced here.",
+        }, indent=2),
+        encoding="utf-8",
+    )
+
+    labels = load_labels(Path(args.labels))
+    eligible_labels = [lab for lab in labels if completed_day(lab.get("day"), as_of)]
+    xs: list[float] = []
+    ys: list[float] = []
+    X_multi: list[list[float]] = []
+    pairs: list[dict] = []
+
+    for lab in eligible_labels:
+        s = lab.get("strain_021") or lab.get("dayStrain021")
+        if s is None:
+            continue
+        try:
+            s = float(s)
+        except (TypeError, ValueError):
+            continue
+        target = max(0.0, min(100.0, s / 21.0 * 100.0))
+        day = lab.get("day")
+        feat = daily.get(str(day)) if day else None
+        if lab.get("noop_effort") is not None:
+            try:
+                x = float(lab["noop_effort"])
+            except (TypeError, ValueError):
+                x = None
+        elif feat:
+            x = float(feat["effort_proxy_0_100"])
+        else:
+            x = None
+        if x is None or x <= 0:
+            continue
+        xs.append(x)
+        ys.append(target)
+        if feat:
+            X_multi.append(
+                [
+                    feat["mean_hr"] / 100.0,
+                    feat["frac_hr_ge_100"],
+                    feat["frac_hr_ge_130"],
+                    (feat["rr_rmssd_ms"] or 40.0) / 100.0,
+                    x / 100.0,
+                ]
+            )
+        else:
+            X_multi.append([x / 100.0, 0.0, 0.0, 0.4, x / 100.0])
+        pairs.append(
+            {
+                "day": day,
+                "noop_effort": x,
+                "app_strain_021": s,
+                "app_pct": target,
+                "features": feat,
+            }
+        )
+
+    distinct_days = {p.get("day") for p in pairs if p.get("day")}
+    accuracy_valid = len(pairs) >= 3 and len(distinct_days) >= 3
+
+    goals = goals_status(
+        n_pairs=len(pairs),
+        accuracy_valid=accuracy_valid,
+        n_feature_days=len(daily),
+        n_labels=len(labels),
+    )
+    GOALS_OUT.write_text(json.dumps(goals, indent=2), encoding="utf-8")
+
+    base_status = {
+        "accuracy_valid": False,
+        "n_label_rows": len(labels),
+        "n_completed_label_rows": len(eligible_labels),
+        "n_excluded_current_or_future_labels": len(labels) - len(eligible_labels),
+        "n_pairs": len(pairs),
+        "n_feature_days": len(daily),
+        "n_ml_samples_ingested": len(samples),
+        "completed_before": as_of.isoformat(),
+        "future_day_guard": "Current local day and future dates are excluded until their day has completed.",
+        "feature_store": str(FEATURES_OUT),
+        "sport_session_feature_store": str(SPORT_FEATURES_OUT),
+        "n_sport_labels": len(sport_labels),
+        "n_sport_sessions_eligible": sum(1 for session in sport_sessions if session["eligible_for_future_training"]),
+        "goals": goals,
+        "next_actions": [
+            "Enable Accessibility NOOP WHOOP app capture; open WHOOP daily",
+            "Or run Tools/whoop_app_adb_capture.ps1 with wireless adb",
+            "Append JSONL {day, strain_021, recovery_pct, noop_effort?} to pairing-logs/whoop-app-labels.jsonl",
+            "Re-run this script after ≥3 distinct labeled days for accuracy_valid",
+            "For sleep κ: download sleep-accel → Tools/sleep_stage_eval.py (G4)",
+            "Save and correct real workouts in NOOP debug builds to collect user-confirmed sport windows; this pipeline does not classify sports yet.",
+        ],
+        "honest_rule": "Never treat pipeline HR collect or synthetic eval as model accuracy vs WHOOP app.",
+    }
+
+    if len(pairs) < 2:
+        status = {
+            **base_status,
+            "status": "FEATURE_STORE_READY" if daily else "NOT_READY",
+            "message": (
+                f"Built {len(daily)} day(s) of features from BLE samples. "
+                "Need ≥2 days of WHOOP **app** Strain labels to fit Effort→Strain. "
+                "Do NOT treat synthetic/pipeline pass as model accuracy."
+            ),
+        }
+    else:
+        a, b, rmse = fit_linear(xs, ys)
+        w, bias, rmse_m = fit_multifeature(X_multi, ys)
+        mae = sum(abs(a * x + b - y) for x, y in zip(xs, ys)) / len(xs)
+        softs = [max(0.0, 100.0 - (abs(a * x + b - y) / 15.0) * 100.0) for x, y in zip(xs, ys)]
+        pass_score = sum(softs) / len(softs)
+        weights = {
+            "version": "0.2.0-linear+ridge",
+            "linear": {
+                "a": a,
+                "b": b,
+                "formula": "app_strain_pct_hat = a * noop_effort + b",
+            },
+            "ridge": {
+                "feature_names": [
+                    "mean_hr/100",
+                    "frac_hr_ge_100",
+                    "frac_hr_ge_130",
+                    "rr_rmssd/100",
+                    "effort_proxy/100",
+                ],
+                "weights": w,
+                "bias": bias,
+                "rmse": rmse_m,
+            },
+            "n_pairs": len(pairs),
+            "rmse_linear": rmse,
+            "mae": mae,
+            "pass_score": pass_score,
+            "accuracy_valid": accuracy_valid,
+        }
+        WEIGHTS.write_text(json.dumps(weights, indent=2), encoding="utf-8")
+        status = {
+            **base_status,
+            "accuracy_valid": accuracy_valid,
+            "status": "TRAINED" if accuracy_valid else "UNDERFIT_N<3_DAYS",
+            "pass_score": round(pass_score, 2) if accuracy_valid else None,
+            "mae_pct": round(mae, 2),
+            "rmse_pct": round(rmse, 2),
+            "weights_file": str(WEIGHTS),
+            "pairs": pairs[:20],
+            "message": (
+                "Linear+ridge calibration from NOOP features → WHOOP app Strain%."
+                if accuracy_valid
+                else "Fit unstable — need more distinct labeled days before claiming accuracy."
+            ),
+        }
+
+    OUT.write_text(json.dumps(status, indent=2), encoding="utf-8")
+    print(json.dumps(status, indent=2))
+    print(f"Wrote {OUT}")
+    print(f"Wrote {FEATURES_OUT} ({len(daily)} days)")
+    print(f"Wrote {SPORT_FEATURES_OUT} ({len(sport_sessions)} user-confirmed sessions)")
+    print(f"Wrote {GOALS_OUT}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/Tools/sleep_stage_eval.py b/Tools/sleep_stage_eval.py
new file mode 100644
index 0000000000..a09c331a16
--- /dev/null
+++ b/Tools/sleep_stage_eval.py
@@ -0,0 +1,388 @@
+#!/usr/bin/env python3
+"""Sleep-stage evaluation harness for NOOP-class 4-class staging.
+
+Primary open bench: PhysioNet sleep-accel (Walch 2019).
+  https://physionet.org/content/sleep-accel/1.0.0/
+
+Metrics: epoch accuracy + Cohen's kappa + per-class F1 (wake/light/deep/rem).
+Does NOT invent clinical claims. Algorithm lane first; ML lane is optional sklearn.
+
+Usage:
+  python Tools/sleep_stage_eval.py --synthetic
+  python Tools/sleep_stage_eval.py --sleep-accel-dir pairing-logs/datasets/sleep-accel
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import math
+from collections import Counter, defaultdict
+from pathlib import Path
+from typing import Iterable
+
+ROOT = Path(__file__).resolve().parents[1]
+OUT = ROOT / "pairing-logs" / "sleep-stage-eval.json"
+
+# Walch labels: 0 wake, 1 N1, 2 N2, 3 N3, 5 REM → NOOP 4-class
+STAGES = ("wake", "light", "deep", "rem")
+
+
+def walch_to_noop(label: int) -> str:
+    if label == 0:
+        return "wake"
+    if label in (1, 2):
+        return "light"
+    if label == 3:
+        return "deep"
+    if label == 5:
+        return "rem"
+    return "light"  # unknown → light (majority sleep)
+
+
+def cohen_kappa(y_true: list[str], y_pred: list[str], labels: Iterable[str] = STAGES) -> float:
+    labels = list(labels)
+    n = len(y_true)
+    if n == 0:
+        return 0.0
+    # confusion
+    idx = {lab: i for i, lab in enumerate(labels)}
+    mat = [[0] * len(labels) for _ in labels]
+    for t, p in zip(y_true, y_pred):
+        if t not in idx or p not in idx:
+            continue
+        mat[idx[t]][idx[p]] += 1
+    po = sum(mat[i][i] for i in range(len(labels))) / n
+    row = [sum(mat[i]) for i in range(len(labels))]
+    col = [sum(mat[i][j] for i in range(len(labels))) for j in range(len(labels))]
+    pe = sum((row[i] / n) * (col[i] / n) for i in range(len(labels)))
+    if abs(1 - pe) < 1e-12:
+        return 0.0
+    return (po - pe) / (1 - pe)
+
+
+def accuracy(y_true: list[str], y_pred: list[str]) -> float:
+    if not y_true:
+        return 0.0
+    return sum(a == b for a, b in zip(y_true, y_pred)) / len(y_true)
+
+
+def f1_per_class(y_true: list[str], y_pred: list[str]) -> dict[str, float]:
+    out = {}
+    for lab in STAGES:
+        tp = sum(1 for t, p in zip(y_true, y_pred) if t == lab and p == lab)
+        fp = sum(1 for t, p in zip(y_true, y_pred) if t != lab and p == lab)
+        fn = sum(1 for t, p in zip(y_true, y_pred) if t == lab and p != lab)
+        prec = tp / (tp + fp) if (tp + fp) else 0.0
+        rec = tp / (tp + fn) if (tp + fn) else 0.0
+        out[lab] = (2 * prec * rec / (prec + rec)) if (prec + rec) else 0.0
+    return out
+
+
+def baseline_majority(y_true: list[str]) -> list[str]:
+    maj = Counter(y_true).most_common(1)[0][0]
+    return [maj] * len(y_true)
+
+
+def heuristic_hr_motion(
+    hr: list[float],
+    motion: list[float],
+    epoch_s: float = 30.0,
+) -> list[str]:
+    """Tiny transparent heuristic (not V1 port) for smoke-test when full Kotlin isn't available.
+
+    Rules inspired by SleepStager comments: high motion → wake; low HR + low motion → deep;
+    high HR variability proxy → rem; else light.
+    """
+    n = len(hr)
+    if n == 0:
+        return []
+    # z-score HR
+    mean_hr = sum(hr) / n
+    var = sum((h - mean_hr) ** 2 for h in hr) / max(n, 1)
+    sd = math.sqrt(var) or 1.0
+    preds = []
+    for i, h in enumerate(hr):
+        m = motion[i] if i < len(motion) else 0.0
+        z = (h - mean_hr) / sd
+        # motion high
+        if m > 0.05:
+            preds.append("wake")
+        elif m < 0.01 and z < -0.4:
+            preds.append("deep")
+        elif z > 0.3 and m < 0.02:
+            preds.append("rem")
+        else:
+            preds.append("light")
+    return preds
+
+
+def load_sleep_accel_subject(base: Path, sid: str) -> tuple[list[str], list[float], list[float]] | None:
+    """Load one subject into 30s epochs: labels, mean HR, motion energy."""
+    lab_path = base / "labels" / f"{sid}_labeled_sleep.txt"
+    hr_path = base / "heart_rate" / f"{sid}_heartrate.txt"
+    acc_path = base / "motion" / f"{sid}_acceleration.txt"
+    if not lab_path.exists():
+        # alternate layout: flat files
+        lab_path = base / f"{sid}_labeled_sleep.txt"
+        hr_path = base / f"{sid}_heartrate.txt"
+        acc_path = base / f"{sid}_acceleration.txt"
+    if not lab_path.exists() or not hr_path.exists():
+        return None
+
+    labels_raw: list[tuple[float, int]] = []
+    for line in lab_path.read_text(encoding="utf-8", errors="replace").splitlines():
+        parts = line.strip().split()
+        if len(parts) < 2:
+            continue
+        try:
+            labels_raw.append((float(parts[0]), int(float(parts[1]))))
+        except ValueError:
+            continue
+    if not labels_raw:
+        return None
+
+    hr_pts: list[tuple[float, float]] = []
+    for line in hr_path.read_text(encoding="utf-8", errors="replace").splitlines():
+        parts = line.strip().split()
+        if len(parts) < 2:
+            continue
+        try:
+            hr_pts.append((float(parts[0]), float(parts[1])))
+        except ValueError:
+            continue
+
+    acc_pts: list[tuple[float, float]] = []
+    if acc_path.exists():
+        for line in acc_path.read_text(encoding="utf-8", errors="replace").splitlines():
+            parts = line.strip().split()
+            if len(parts) < 4:
+                continue
+            try:
+                t, x, y, z = float(parts[0]), float(parts[1]), float(parts[2]), float(parts[3])
+                # energy of successive samples approximated later; store magnitude
+                acc_pts.append((t, math.sqrt(x * x + y * y + z * z)))
+            except ValueError:
+                continue
+
+    # labels are already ~30s epochs starting at t
+    y_true: list[str] = []
+    hr_e: list[float] = []
+    mot_e: list[float] = []
+    for t0, lab in labels_raw:
+        t1 = t0 + 30.0
+        hrs = [h for t, h in hr_pts if t0 <= t < t1]
+        if not hrs:
+            continue
+        mags = [m for t, m in acc_pts if t0 <= t < t1]
+        # motion energy = std of magnitude as proxy for activity
+        if mags:
+            mm = sum(mags) / len(mags)
+            mv = sum((m - mm) ** 2 for m in mags) / len(mags)
+            motion = math.sqrt(mv)
+        else:
+            motion = 0.0
+        y_true.append(walch_to_noop(lab))
+        hr_e.append(sum(hrs) / len(hrs))
+        mot_e.append(motion)
+    if len(y_true) < 10:
+        return None
+    return y_true, hr_e, mot_e
+
+
+def discover_sleep_accel_ids(base: Path) -> list[str]:
+    labels_dir = base / "labels"
+    if labels_dir.is_dir():
+        return sorted({p.name.split("_")[0] for p in labels_dir.glob("*_labeled_sleep.txt")})
+    return sorted({p.name.split("_")[0] for p in base.glob("*_labeled_sleep.txt")})
+
+
+def eval_pair(y_true: list[str], y_pred: list[str], name: str) -> dict:
+    return {
+        "name": name,
+        "n_epochs": len(y_true),
+        "accuracy": round(accuracy(y_true, y_pred), 4),
+        "cohen_kappa": round(cohen_kappa(y_true, y_pred), 4),
+        "f1": {k: round(v, 4) for k, v in f1_per_class(y_true, y_pred).items()},
+        "label_hist": dict(Counter(y_true)),
+        "pred_hist": dict(Counter(y_pred)),
+    }
+
+
+def mini_ml_predict(
+    hr: list[float],
+    motion: list[float],
+    y_true: list[str] | None = None,
+) -> list[str]:
+    """Tiny feature → class rules with optional train-on-half thresholds.
+
+    Not a real sleep model. Used only to prove the ML-lane plumbing (features → κ).
+    When y_true is provided, thresholds are fit on the first half (leaky demo on synthetic).
+    """
+    n = len(hr)
+    if n == 0:
+        return []
+    mean_hr = sum(hr) / n
+    # Default thresholds
+    wake_m = 0.04
+    deep_z = -0.35
+    rem_z = 0.25
+    if y_true is not None and n >= 40:
+        half = n // 2
+        # Fit motion threshold for wake from first half
+        wake_mots = [motion[i] for i in range(half) if y_true[i] == "wake"]
+        if wake_mots:
+            wake_m = max(0.02, sum(wake_mots) / len(wake_mots) * 0.7)
+    sd = math.sqrt(sum((h - mean_hr) ** 2 for h in hr) / n) or 1.0
+    preds = []
+    for i, h in enumerate(hr):
+        m = motion[i] if i < len(motion) else 0.0
+        z = (h - mean_hr) / sd
+        if m > wake_m:
+            preds.append("wake")
+        elif m < 0.01 and z < deep_z:
+            preds.append("deep")
+        elif z > rem_z and m < 0.02:
+            preds.append("rem")
+        else:
+            preds.append("light")
+    return preds
+
+
+def synthetic_demo() -> dict:
+    """No download required — sanity check metrics plumbing. accuracy_valid=false always."""
+    y_true = (
+        ["wake"] * 20
+        + ["light"] * 80
+        + ["deep"] * 40
+        + ["light"] * 60
+        + ["rem"] * 50
+        + ["light"] * 40
+        + ["wake"] * 10
+    )
+    hr = [70.0] * len(y_true)
+    for i, s in enumerate(y_true):
+        if s == "wake":
+            hr[i] = 78
+        elif s == "deep":
+            hr[i] = 58
+        elif s == "rem":
+            hr[i] = 68
+        else:
+            hr[i] = 62
+    motion = [0.08 if s == "wake" else 0.005 for s in y_true]
+    y_pred = heuristic_hr_motion(hr, motion)
+    y_ml = mini_ml_predict(hr, motion, y_true=y_true)
+    return {
+        "mode": "synthetic",
+        "accuracy_valid": False,
+        "goal_G4": "NOT_DONE",
+        "note": (
+            "No public dataset on disk — metrics plumbing only. "
+            "Do NOT cite these κ/acc as product accuracy. "
+            "Download PhysioNet sleep-accel → re-run for real LOSO κ (G4)."
+        ),
+        "results": [
+            eval_pair(y_true, y_pred, "heuristic_hr_motion"),
+            eval_pair(y_true, y_ml, "mini_ml_lane_synthetic"),
+            eval_pair(y_true, baseline_majority(y_true), "majority_baseline"),
+        ],
+    }
+
+
+def eval_sleep_accel(base: Path, max_subjects: int = 8) -> dict:
+    ids = discover_sleep_accel_ids(base)
+    if not ids:
+        return {
+            "mode": "sleep-accel",
+            "error": f"No subjects found under {base}. Expected labels/*_labeled_sleep.txt",
+        }
+    results = []
+    all_true: list[str] = []
+    all_pred: list[str] = []
+    for sid in ids[:max_subjects]:
+        loaded = load_sleep_accel_subject(base, sid)
+        if not loaded:
+            continue
+        y_true, hr, mot = loaded
+        y_pred = heuristic_hr_motion(hr, mot)
+        results.append(eval_pair(y_true, y_pred, f"subject_{sid}"))
+        all_true.extend(y_true)
+        all_pred.extend(y_pred)
+    if not all_true:
+        return {
+            "mode": "sleep-accel",
+            "accuracy_valid": False,
+            "goal_G4": "NOT_DONE",
+            "error": "Subjects found but none loadable",
+        }
+    # Mini-ML lane on real data: train thresholds on subject 0, eval rest (crude LOSO-ish)
+    ml_true: list[str] = []
+    ml_pred: list[str] = []
+    loaded_all = []
+    for sid in ids[:max_subjects]:
+        loaded = load_sleep_accel_subject(base, sid)
+        if loaded:
+            loaded_all.append((sid, loaded))
+    if loaded_all:
+        _, (train_y, train_hr, train_mot) = loaded_all[0]
+        # Use train subject only to fit (via y_true half-fit inside mini_ml)
+        for sid, (y_true, hr, mot) in loaded_all[1:] or loaded_all[:1]:
+            pred = mini_ml_predict(hr, mot, y_true=train_y)
+            # length mismatch if different nights — re-predict with local stats only
+            if len(pred) != len(y_true):
+                pred = mini_ml_predict(hr, mot, y_true=None)
+            ml_true.extend(y_true)
+            ml_pred.extend(pred[: len(y_true)])
+    pooled_ml = eval_pair(ml_true, ml_pred, "pooled_mini_ml") if ml_true else None
+    kappa = (eval_pair(all_true, all_pred, "pooled_heuristic")).get("cohen_kappa", 0)
+    return {
+        "mode": "sleep-accel",
+        "accuracy_valid": True,
+        "goal_G4": "PARTIAL" if kappa is not None else "NOT_DONE",
+        "path": str(base),
+        "n_subjects_used": len(results),
+        "subjects_available": len(ids),
+        "pooled": eval_pair(all_true, all_pred, "pooled_heuristic"),
+        "pooled_mini_ml": pooled_ml,
+        "pooled_majority": eval_pair(all_true, baseline_majority(all_true), "pooled_majority"),
+        "per_subject": results,
+        "note": (
+            "Real labels from sleep-accel — report cohen_kappa as primary. "
+            "Heuristic/mini_ml are smoke benches, NOT SleepStager V1/V2 port. "
+            "Community ML ~0.75 acc on mini-set; Walch ceiling ~0.65–0.73 wearable."
+        ),
+        "datasets_doc": "docs/SLEEP_ML_DATASETS.md",
+    }
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--synthetic", action="store_true", help="Run without datasets")
+    ap.add_argument(
+        "--sleep-accel-dir",
+        type=str,
+        default="",
+        help="Path to unpacked sleep-accel 1.0.0 root",
+    )
+    ap.add_argument("--max-subjects", type=int, default=8)
+    args = ap.parse_args()
+
+    if args.sleep_accel_dir:
+        payload = eval_sleep_accel(Path(args.sleep_accel_dir), max_subjects=args.max_subjects)
+    else:
+        default = ROOT / "pairing-logs" / "datasets" / "sleep-accel"
+        if default.is_dir() and discover_sleep_accel_ids(default):
+            payload = eval_sleep_accel(default, max_subjects=args.max_subjects)
+        else:
+            payload = synthetic_demo()
+
+    OUT.parent.mkdir(parents=True, exist_ok=True)
+    OUT.write_text(json.dumps(payload, indent=2), encoding="utf-8")
+    print(json.dumps(payload, indent=2)[:4000])
+    print(f"\nWrote {OUT}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/Tools/stress_sleep_train.py b/Tools/stress_sleep_train.py
new file mode 100644
index 0000000000..664cc64f98
--- /dev/null
+++ b/Tools/stress_sleep_train.py
@@ -0,0 +1,329 @@
+#!/usr/bin/env python3
+"""Train / evaluate stress tip calibration + sleep-stage plumbing + effort→strain.
+
+CPU-first (desk RX 7900 / laptop RTX idle is fine; these fits are linear / tiny).
+Never invents clinical vitals. Labels must come from WHOOP app UI / screenshots /
+adb dumps in pairing-logs/whoop-app-labels.jsonl.
+
+Usage (from AI app store root OR noop checkout with pairing-logs/):
+  python Tools/stress_sleep_train.py
+  python Tools/stress_sleep_train.py --pairing pairing-logs --as-of 2026-07-14
+
+Outputs:
+  pairing-logs/stress-sleep-train-status.json
+  pairing-logs/ml-stress-tip-weights.json   (when ≥2 clock-matched tip pairs)
+  pairing-logs/sleep-stage-eval.json       (via sleep_stage_eval)
+  pairing-logs/ml-engine-status.json       (via ml_engine_train)
+  pairing-logs/calibration-report.json     (via calibrate_whoop_noop when present)
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import statistics
+import subprocess
+import sys
+from datetime import date, datetime, timezone
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def resolve_pairing(explicit: Path | None) -> Path:
+    if explicit is not None:
+        return explicit
+    candidates = [
+        ROOT / "pairing-logs",
+        ROOT.parent / "pairing-logs",
+        Path(r"C:\Users\Gilbert\Documents\Ai app store\pairing-logs"),
+    ]
+    for c in candidates:
+        if c.is_dir():
+            return c
+    return candidates[0]
+
+
+def load_jsonl(path: Path) -> list[dict]:
+    if not path.is_file():
+        return []
+    rows = []
+    for line in path.read_text(encoding="utf-8-sig", errors="replace").splitlines():
+        t = line.strip().lstrip("\ufeff")
+        if not t or t.startswith("#"):
+            continue
+        try:
+            rows.append(json.loads(t))
+        except json.JSONDecodeError:
+            continue
+    return rows
+
+
+def affine_fit(xs: list[float], ys: list[float]) -> tuple[float, float]:
+    n = len(xs)
+    if n < 2:
+        return 1.0, 0.0
+    mx, my = statistics.mean(xs), statistics.mean(ys)
+    varx = sum((x - mx) ** 2 for x in xs)
+    if varx < 1e-12:
+        return 1.0, my - mx
+    cov = sum((x - mx) * (y - my) for x, y in zip(xs, ys))
+    a = cov / varx
+    return a, my - a * mx
+
+
+def mae(pairs: list[tuple[float, float]]) -> float | None:
+    if not pairs:
+        return None
+    return sum(abs(a - b) for a, b in pairs) / len(pairs)
+
+
+def stress_tip_pairs(rows: list[dict]) -> list[dict]:
+    """Clock-matched tip pairs: need whoop stress_tip + noop_tip on 0–3 scale."""
+    out = []
+    for r in rows:
+        if r.get("stress_tip") is None or r.get("noop_tip") is None:
+            continue
+        if r.get("tip_clock_matched") is False:
+            continue
+        try:
+            w = float(r["stress_tip"])
+            n = float(r["noop_tip"])
+        except (TypeError, ValueError):
+            continue
+        out.append(
+            {
+                "day": r.get("day"),
+                "clock": r.get("clock"),
+                "whoop_tip": w,
+                "noop_tip": n,
+                "delta": round(n - w, 4),
+                "whoop_band": r.get("stress_band"),
+                "noop_band": r.get("noop_band"),
+                "source": r.get("source"),
+                "serial": r.get("serial"),
+                "whoop_file": r.get("whoop_file"),
+                "noop_file": r.get("noop_file"),
+            }
+        )
+    return out
+
+
+def sleep_rest_pairs(rows: list[dict]) -> list[dict]:
+    """WHOOP sleep_pct (0–100) vs NOOP Rest (noop_rest) when both present."""
+    out = []
+    for r in rows:
+        if r.get("sleep_pct") is None or r.get("noop_rest") is None:
+            continue
+        try:
+            w = float(r["sleep_pct"])
+            n = float(r["noop_rest"])
+        except (TypeError, ValueError):
+            continue
+        out.append(
+            {
+                "day": r.get("day"),
+                "whoop_sleep_pct": w,
+                "noop_rest": n,
+                "delta": round(n - w, 4),
+                "whoop_sws_pct": r.get("whoop_sws_pct"),
+                "whoop_rem_pct": r.get("whoop_rem_pct"),
+                "noop_deep_pct": r.get("noop_deep_pct"),
+                "noop_rem_pct": r.get("noop_rem_pct"),
+                "source": r.get("source"),
+                "serial": r.get("serial"),
+            }
+        )
+    return out
+
+
+def fit_tip_head(pairs: list[dict], scale_note: str) -> dict:
+    xs = [p["noop_tip"] if "noop_tip" in p else p["noop_rest"] for p in pairs]
+    ys = [p["whoop_tip"] if "whoop_tip" in p else p["whoop_sleep_pct"] for p in pairs]
+    raw = list(zip(xs, ys))
+    before = mae(raw)
+    fitted = len(pairs) >= 2
+    a, b = affine_fit(xs, ys) if fitted else (1.0, 0.0)
+    after = mae([(a * x + b, y) for x, y in raw]) if fitted else before
+    # Same qualitative band for stress 0–3: LOW <1, MEDIUM <2, else HIGH
+    same_band = None
+    if pairs and "whoop_tip" in pairs[0]:
+        def band(v: float) -> str:
+            if v < 1.0:
+                return "LOW"
+            if v < 2.0:
+                return "MEDIUM"
+            return "HIGH"
+
+        same_band = sum(1 for p in pairs if band(p["whoop_tip"]) == band(p["noop_tip"])) / len(pairs)
+    accuracy_valid = len(pairs) >= 4 and (same_band is None or same_band >= 0.75)
+    return {
+        "n": len(pairs),
+        "mae_before": before,
+        "mae_after_affine": after,
+        "affine_a": a,
+        "affine_b": b,
+        "fitted": fitted,
+        "accuracy_valid": accuracy_valid,
+        "same_band_frac": same_band,
+        "scale": scale_note,
+        "pairs": pairs,
+        "honest_rule": (
+            "accuracy_valid only with ≥4 tip@clock pairs and ≥75% same band. "
+            "Do not retune DaytimeStress constants from a single δ."
+        ),
+    }
+
+
+def run_script(script: Path, args: list[str], cwd: Path) -> dict:
+    if not script.is_file():
+        return {"ok": False, "missing": str(script)}
+    cmd = [sys.executable, str(script), *args]
+    try:
+        proc = subprocess.run(
+            cmd,
+            cwd=str(cwd),
+            capture_output=True,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            timeout=600,
+        )
+        return {
+            "ok": proc.returncode == 0,
+            "returncode": proc.returncode,
+            "cmd": cmd,
+            "stdout_tail": (proc.stdout or "")[-2000:],
+            "stderr_tail": (proc.stderr or "")[-1000:],
+        }
+    except Exception as e:
+        return {"ok": False, "error": str(e), "cmd": cmd}
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--pairing", type=Path, default=None)
+    ap.add_argument("--as-of", type=str, default=date.today().isoformat())
+    ap.add_argument("--skip-subprocess", action="store_true")
+    args = ap.parse_args()
+    pairing = resolve_pairing(args.pairing)
+    pairing.mkdir(parents=True, exist_ok=True)
+    labels_path = pairing / "whoop-app-labels.jsonl"
+    rows = load_jsonl(labels_path)
+
+    tip = stress_tip_pairs(rows)
+    sleep = sleep_rest_pairs(rows)
+    # Remap sleep pairs field names for fit_tip_head
+    sleep_for_fit = [
+        {
+            "day": p["day"],
+            "noop_rest": p["noop_rest"],
+            "whoop_sleep_pct": p["whoop_sleep_pct"],
+            **{k: v for k, v in p.items() if k not in ("noop_rest", "whoop_sleep_pct")},
+        }
+        for p in sleep
+    ]
+    # fit_tip_head expects noop_tip/whoop_tip OR we specialize:
+    sleep_head = {
+        "n": len(sleep),
+        "mae_before": mae([(p["noop_rest"], p["whoop_sleep_pct"]) for p in sleep]),
+        "pairs": sleep,
+        "note": (
+            "Rest (NOOP) vs Sleep% (WHOOP) are related but not identical scales. "
+            "Use for trend checks; RestScorer tickets live in SLEEP_FACTORS / Fable backlog."
+        ),
+        "accuracy_valid": False,
+    }
+    if len(sleep) >= 2:
+        xs = [p["noop_rest"] for p in sleep]
+        ys = [p["whoop_sleep_pct"] for p in sleep]
+        a, b = affine_fit(xs, ys)
+        sleep_head["affine_a"] = a
+        sleep_head["affine_b"] = b
+        sleep_head["mae_after_affine"] = mae([(a * x + b, y) for x, y in zip(xs, ys)])
+        sleep_head["fitted"] = True
+    else:
+        sleep_head["fitted"] = False
+
+    stress_head = fit_tip_head(tip, "WHOOP/NOOP stress tip 0-3")
+
+    weights = {
+        "version": "0.1.0-stress-tip-affine",
+        "generated_at": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
+        "formula": "whoop_tip_hat = a * noop_tip + b",
+        "a": stress_head["affine_a"],
+        "b": stress_head["affine_b"],
+        "n_pairs": stress_head["n"],
+        "mae_before": stress_head["mae_before"],
+        "mae_after": stress_head["mae_after_affine"],
+        "accuracy_valid": stress_head["accuracy_valid"],
+        "citations": [
+            "docs/STRESS_FACTORS_AND_LITERATURE.md",
+            "docs/WHOOP_NOOP_SCREENSHOT_COMPARE.md",
+            "docs/STRESS_SLEEP_ML_REPRO.md",
+        ],
+    }
+    weights_path = pairing / "ml-stress-tip-weights.json"
+    weights_path.write_text(json.dumps(weights, indent=2), encoding="utf-8")
+
+    sub = {}
+    if not args.skip_subprocess:
+        tools = ROOT / "Tools"
+        # Prefer scripts next to this file; fall back to store Tools if running from noop-v8 copy
+        sleep_py = tools / "sleep_stage_eval.py"
+        if not sleep_py.is_file():
+            sleep_py = Path(r"C:\Users\Gilbert\Documents\Ai app store\Tools\sleep_stage_eval.py")
+        train_py = tools / "ml_engine_train.py"
+        cal_py = tools / "calibrate_whoop_noop.py"
+        sub["sleep_stage_eval"] = run_script(sleep_py, ["--synthetic"], ROOT)
+        sub["ml_engine_train"] = run_script(
+            train_py,
+            ["--labels", str(labels_path), "--as-of", args.as_of],
+            ROOT,
+        )
+        if cal_py.is_file():
+            sub["calibrate_whoop_noop"] = run_script(
+                cal_py, ["--pairing", str(pairing)], ROOT
+            )
+
+    status = {
+        "generated_at": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
+        "host_hint": "Prefer desk Tailscale Host desk (DESKTOP-UEJPJSH); CPU affine is enough",
+        "pairing": str(pairing),
+        "n_label_rows": len(rows),
+        "stress_tip": stress_head,
+        "sleep_rest": sleep_head,
+        "weights_file": str(weights_path),
+        "subprocess": sub,
+        "fold_status": (
+            "Fold plugged-in but powered OFF this session — no live USB ADB, tip@clock, "
+            "bank pull, or live-edit. Device verification deferred until phone is on."
+        ),
+        "factor_docs": [
+            "docs/STRESS_FACTORS_AND_LITERATURE.md",
+            "docs/SLEEP_FACTORS_AND_LITERATURE.md",
+            "docs/SLEEP_ML_DATASETS.md",
+            "docs/WHOOP_NOOP_SCREENSHOT_COMPARE.md",
+            "docs/FABLE5_300_NOT_INTUITIVE.md",
+        ],
+        "tickets": ["STRESS-TIP", "STRESS-SHAPE", "REST-WEIGHT", "SLEEP-SELF-1", "G4_sleep_kappa"],
+        "next": [
+            "Decode more tip@clock pairs (≥4) before touching DaytimeStress constants",
+            "Download PhysioNet sleep-accel → python Tools/sleep_stage_eval.py --sleep-accel-dir …",
+            "When Fold is on: bank pull + FoldStressReplay with screenshot cutoff",
+        ],
+        "honest_rule": "Never invent SpO2/BP/clinical stages. accuracy_valid stays false until N gates pass.",
+    }
+    out = pairing / "stress-sleep-train-status.json"
+    out.write_text(json.dumps(status, indent=2), encoding="utf-8")
+    print(json.dumps({k: status[k] for k in (
+        "generated_at", "n_label_rows", "stress_tip", "sleep_rest", "weights_file", "fold_status"
+    )}, indent=2))
+    print(f"Wrote {out}")
+    print(f"Wrote {weights_path}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/docs/ML_DAY1_TO_NOW.md b/docs/ML_DAY1_TO_NOW.md
new file mode 100644
index 0000000000..76ee0175df
--- /dev/null
+++ b/docs/ML_DAY1_TO_NOW.md
@@ -0,0 +1,18 @@
+# ML day-1 → now vs WHOOP
+
+Living log of real training status. Numbers come only from `Tools/ml_engine_train.py` /
+`Tools/stress_sleep_train.py` / `pairing-logs/*-status.json`.
+
+### Checkpoint 2026-07-14 (stress + sleep reproduce PR)
+- Orchestrator: `python Tools/stress_sleep_train.py --as-of 2026-07-14`
+- Stress tip pairs (clock-matched): 1 (WHOOP 1.4 ↔ NOOP 1.8 @ 22:14 on 2026-07-13) — `accuracy_valid=false` until ≥4
+- Sleep Rest vs WHOOP Sleep%: 1 pair (Rest 73 vs Sleep% 64) — RestScorer ticket REST-WEIGHT, not a fit claim
+- Sleep stages: synthetic plumbing only until PhysioNet sleep-accel lands (`docs/SLEEP_ML_DATASETS.md`)
+- Effort→Strain: still underfit (need ≥3 distinct strain label days)
+- Fold: plugged in but powered OFF — no bank pull this session
+- Repro: `docs/STRESS_SLEEP_ML_REPRO.md`
+
+### Checkpoint 2026-07-12 07:26Z
+- accuracy_valid: False
+- labels: 1 · features: 2 · samples: 2666
+- note: Built 2 day(s) of features from BLE samples. Need ≥2 days of WHOOP **app** Strain labels to fit Effort→Strain. Do NOT treat synthetic/pipeline pass as model accuracy.
diff --git a/docs/SLEEP_FACTORS_AND_LITERATURE.md b/docs/SLEEP_FACTORS_AND_LITERATURE.md
new file mode 100644
index 0000000000..6321b567cc
--- /dev/null
+++ b/docs/SLEEP_FACTORS_AND_LITERATURE.md
@@ -0,0 +1,399 @@
+# Sleep factors and literature
+
+**CONTINUED 2026-07-12 sleep-export.** Code-truth map of what feeds NOOP Sleep (detection, staging, totals, UI), how each input moves the readout, peer-reviewed context, and honesty limits versus WHOOP’s proprietary Sleep Coach. Does **not** invent WHOOP stage math. MAIN builds still hide algo-vs-WHOOP compare.
+
+Export compared: `Downloads/Noop sleep -20260712T215506Z-2-001/Noop sleep/` — **8 JPGs only** (7 WHOOP + 1 NOOP); **no CSV/JSON**.
+
+---
+
+## Export inventory
+
+| File | Surface | Headline numbers |
+|------|---------|------------------|
+| `…175042_WHOOP.jpg` | Last night (Today) | Hours asleep **5:53**; window **6:21–12:57**; Duration (typical) **6:36**; Awake 0:22 / Light 2:23 / SWS 1:53 / REM 1:37; restorative **3:30** |
+| `…175059_WHOOP.jpg` | Today cards | Hours vs needed **61%** (5:53 / 9:41); efficiency **89%**; awake **0:21**; 16 wake events |
+| `…175104`–`175123` | Supporting WHOOP | Consistency / stress / need breakdown (same session family) |
+| `…175137_WHOOP.jpg` | Sat Jul 11 | Hours asleep **6:08**; window **2:14–9:57**; Duration **7:43**; Awake 1:07 / Light 2:45 / SWS 2:29 / REM 0:54 |
+| `…175149_NOOP.jpg` | Sleep tab | Compare NOOP **3h 44m** vs “WHOOP” **6h 36m**; bed **02:33–11:05**; **8h 32m in bed · 56%**; Hours of sleep **4h 45m**; restorative **0m**; Awake **3h 48m** / Light **4h 45m** / Deep **0** / REM **0** |
+
+---
+
+## Why NOOP looked so different (root causes)
+
+| Observation | Cause in code | Fix (this continuation) |
+|-------------|---------------|-------------------------|
+| Compare **3h 44m** vs stage **4h 45m** | Strip used `days.last.totalSleepMin`; chart used session segments | Strip + hero use **navigated night** stage-sum asleep |
+| “WHOOP app **6h 36m**” | HC fallback = **time in bed** when stages missing; labeled as WHOOP hours | Label **HC asleep** vs **HC in bed**; don’t call TIB “WHOOP hours” |
+| Window **02:33–11:05** vs WHOOP Today **6:21–12:57** | Different primary nights / day attribution (WHOOP “Today” vs NOOP last overnight) | Honesty: compare only same wake-day; docs note mismatch |
+| Sat Jul 11 WHOOP **6:08** with real SWS/REM vs NOOP **0 Deep/REM** | On-device V1 stager collapsed night to **wake + light** (EEG-free actigraphy/HR); V2 opt-in + **WHOOP5-only** family gate | **No invented Deep/REM**; wake/light-only banner under iPhone chart |
+| Efficiency **56%** vs WHOOP **89%** | Efficiency = TST/TIB from on-device wake load; inflated WASO when stages are coarse | Keep formula; honesty copy on approx stages |
+| Chart shape (HR line + empty Deep/REM rows) | iPhone 8.7 path correct; minutes could disagree with bars / DailyMetric | Chart minutes from **smoothed timed segments** |
+
+Hard rule: **MAIN never shows algo-vs-WHOOP**. DEBUG may still surface compare tools elsewhere.
+
+---
+
+## Pipeline overview
+
+```
+Gravity + HR + R-R (+ optional resp / band sleep state)
+        │
+        ▼
+SleepStager.detectSleep  ──► windows (onset/wake)
+        │
+        ├── V1 stageSession (default)  → {wake, light, deep, rem} segments
+        └── V2 SleepStagerV2 (opt-in Puffin; WHOOP5/MG only via sleepStagerV2ForFamily)
+        │
+        ▼
+stagesJSON + efficiency + DailyMetric (totalSleepMin, deep/rem/light, efficiency)
+        │
+        ▼
+SleepStageTotals / analyzeDay  ──► Rest composite, debt, need tiles
+        │
+        ▼
+SleepScreen: selectNight → heroDisplay → iPhone StageTimeline (#988 / 8.7) or legacy hypnogram
+```
+
+| Lane | Feeds UI? | Source |
+|------|-----------|--------|
+| **A. Detected sessions** | Bed/wake, hypnogram, asleep | `SleepStager` / `SleepStagerV2` |
+| **B. DailyMetric rollup** | Trends, debt, Rest, compare (was buggy) | `AnalyticsEngine` + `SleepStageTotals` |
+| **C. Health Connect / import** | Dual strip; optional blend `HcNoopAlign` | `health-connect` sessions + WHOOP export |
+| **D. Display smoothing** | Bar coalescing only (≥90s) | `displaySmoothedSegments` — must not invent stages |
+
+---
+
+## Factor → effect table
+
+| Input | Where | Effect on readout | Gate / notes | Literature / rationale | Export link |
+|-------|-------|-------------------|--------------|------------------------|-------------|
+| **Gravity / jerk** | V1 Cole–Kripke + V2 jerk wake gate | Wake vs sleep; sparse gravity → whole night **light** fallback | `gSeg.size < 2` → single light segment | Actigraphy wake detection (Cole–Kripke tradition) | Empty Deep/REM more likely with sparse motion |
+| **HR / HR flatness** | V1 features; V2 11-min HR-flatness deep gate | Deep eligibility; high variability → rem/wake lean | V2 deep gate ≈ lowest 20% flatness | HR slowing / reduced variance in SWS (literature, not EEG) | WHOOP SWS present; NOOP 0 deep |
+| **RMSSD / R-R** | Staging features + session avg HRV | Soft rem/light cues; Rest drivers | Clean R-R after ectopic filter | Task Force HRV; sleep staging from PPG is limited | — |
+| **Resp / RSA regularity** | V2 | Regular → deep; irregular → rem | Optional stream | RSA / breathing regularity in deep sleep | V2 off by default |
+| **Cycle prior** | V2 | Deep early; rem suppressed first ~12% | Soft prior, not hard wipe | Ultrashort sleep-cycle architecture (AASM framing) | — |
+| **Family gate** | `sleepStagerV2ForFamily` | V2 **never** on WHOOP4 even if toggle on | `enabled && family != WHOOP4` | Hardware/signal differences | User may be 4.0 → stuck on V1 |
+| **Experimental V2 toggle** | `PuffinExperiment.experimentalSleepV2` | Default **false** → V1 | Settings / Test Centre | Opt-in experiment | Export night likely V1 |
+| **Efficiency** | `asleep / inBed` | % in subtitle; Rest; H9 badge | Session stages define wake | AASM SE = TST/TIB | 56% vs WHOOP 89% |
+| **totalSleepMin** | DailyMetric | Trends / debt / (was) compare | Should match stage sum | TST | Stale 224 vs stage 285 |
+| **HC stages JSON** | Compare + `HcNoopAlign` | Dual strip; optional blend ≥25 min gap | Prefer staged light+deep+rem | Phone/WHOOP app via HC ≠ open BLE | 6h36 TIB mislabeled |
+| **Display 90s coalesce** | `displaySmoothedSegments` | Visual only | Absorbs brief blips | Presentation, not rescoring | Bars must drive minutes |
+| **Main-night group** | `SleepStageTotals` / `selectNight` | Which window is “last night” | Habitual midsleep; skip pre-onset stubs | Shift-worker / biphasic nights | Window vs WHOOP Today |
+
+### Dominance rules (code)
+
+1. **Hero chart minutes:** smoothed timed segments → `stagesFromSegments` (post sleep-export).
+2. **Hero when segments exist:** `heroDisplay` prefers night segment sums over DailyMetric-derived model stages.
+3. **Tiles / debt / trends:** still `totalSleepMin` over full `days` (iOS parity) — not TIB.
+4. **Never invent Deep/REM** when the stager emitted none.
+5. **MAIN:** no algo-vs-WHOOP compare UI.
+
+---
+
+## Key papers & standards
+
+1. **Iber C et al. / AASM** — *The AASM Manual for the Scoring of Sleep and Associated Events.* Gold-standard **EEG/EOG/EMG** staging; wearable proxies are not clinical PSG.
+2. **Cole RJ, Kripke DF, et al.** (1992). *Automatic sleep/wake identification from wrist activity.* Sleep 15:461–469. **PMID: 1455130**. Actigraphy sleep/wake — ancestor of NOOP V1 motion path.
+3. **Sadeh A** (2011). *The role and validity of actigraphy in sleep medicine.* Sleep Med Rev 15:259–267. **PMID: 21237680**. Actigraphy good for sleep/wake, weak for stage architecture.
+4. **Fonseca P et al.** (2017). *Validation of photoplethysmography-based sleep staging.* Sleep / related PPG work — shows **HRV+motion** can approximate stages but with large deep/REM errors vs PSG.
+5. **Beattie Z et al.** (2017). *Estimation of sleep stages using cardiac and movement data.* — consumer multi-sensor staging limits (Fitbit-era validation literature).
+6. **Task Force ESC/NASPE** (1996). HRV standards — **PMID: 8598068** (RR features used in staging recipes).
+7. **Billman GE** (2013). LF/HF caveats — **PMID: 23431279** (adjacent honesty; Stress doc).
+
+Honesty: NOOP on-device stages are an **engineering hypnogram**, not PSG and **not** WHOOP’s Sleep Coach algorithm.
+
+---
+
+## Code fix checklist (this continuation)
+
+- [x] Compare strip = navigated night asleep (not `days.last.totalSleepMin`)
+- [x] HC TIB not labeled as WHOOP hours asleep
+- [x] `buildSleepModel` / `heroDisplay` prefer session/segment stage sums for awake+asleep
+- [x] iPhone timeline minutes from smoothed segments; wake/light-only honesty note
+- [x] Hero asleep never falls back to time-in-bed
+- [x] Unit test `SleepExportConsistencyTest`
+- [x] Docs + Fable tags + ANY_MODEL_CONTINUE sleep marker
+- [x] Fold honesty-strip audit via uiautomator (2026-07-12) — see Fold visual audit table
+- [ ] Optional: user enable V2 on WHOOP 5/MG and re-stage (still approximate)
+- [x] Re-verify Deep/REM banner mid-scroll without WHOOP stealing focus
+
+---
+
+## Fable audit — pass criteria vs still lacking
+
+Use the export folder side-by-side with Sleep on Fold after install.
+
+| Check | Pass (= STANDARD) | Still lacking (= IMPROVED_STILL_LACKING) |
+|-------|-------------------|------------------------------------------|
+| Compare NOOP figure | Equals stage **Hours of sleep** (±1 min) for the same navigated night | Still shows a different minute total than the chart |
+| Right-hand phone figure | Labeled **HC asleep**, **HC in bed**, or **WHOOP sleep %** correctly | Still says “WHOOP app” for TIB/duration |
+| Deep/REM zeros | Banner: wake/light only; no fake restorative bars | Silent 0% Deep/REM looking like a real drought |
+| iPhone chart path | Four rows + sleeping HR when segments exist (8.7) | Falls back to legacy hypnogram unexpectedly |
+| Window honesty | User can see NOOP bed/wake may ≠ WHOOP “Today” night | UI implies same night when windows differ by hours |
+| Efficiency | Shown with “approx. stages (on-device)” when computed | Reads as WHOOP-grade SE |
+| MAIN build | No algo-vs-WHOOP lab | Lab visible on store APK |
+| Staging richness | (Aspirational) Deep/REM appear when signal supports V1/V2 | Wake/light-only persists — **algo limit**, not a UI bug |
+
+### Update — 2026-07-12 Fold visual audit (8.6.30 → documented on 8.6.31)
+
+**Method:** `uiautomator dump` on Fold cover while Sleep tab open (`com.noop.whoop`); WHOOP app was force-stopped so NOOP stayed foreground. Full stage-chart scroll interrupted by WHOOP reclaiming focus — top-of-Sleep honesty strip verified.
+
+| Check | Fold observation | Tag |
+|-------|------------------|-----|
+| Compare NOOP = Hours of sleep | NOOP asleep **3h 44m**; efficiency 47% × 7h 58m TIB ≈ 3h45 — strip matches construct | `STANDARD` |
+| HC captions | **HC in bed** · **6h 36m** + TIB not-comparable footnote | `STANDARD` |
+| Wake-day + NOOP window | **Wake day · Sun 12 Jul · NOOP 04:56–12:54** | `STANDARD` |
+| Efficiency honesty | **7h 58m in bed · 47% efficiency · on-device stages (approx.)** | `STANDARD` |
+| Source badge | **NOOP** on hero | `STANDARD` |
+| Window vs WHOOP export Today | NOOP **04:56–12:54** vs export WHOOP **6:21–12:57** — closer than old 02:33–11:05; onset still differs | `IMPROVED_STILL_LACKING` |
+| Deep/REM zeros banner | Re-checked below (Jul 11) → `STANDARD` | see next table |
+| Staging richness | Algo limit | `IMPROVED_STILL_LACKING` |
+
+### Update — 2026-07-12 Fold Deep/REM banner re-check (8.6.31 → tagged on 8.6.32)
+
+**Method:** force-stop `com.whoop.android`; Sleep → Previous night (Sat 11 Jul export night); scroll Stage breakdown.
+
+| Check | Fold observation | Tag |
+|-------|------------------|-----|
+| Banner when Deep+REM = 0 | **On-device staging found no Deep or REM — wake/light only. Not WHOOP’s SWS/REM split…** visible under legend | `STANDARD` |
+| Banner when Deep > 0 | Sun 12 Jul Deep **5m** / REM **0m** — banner correctly **absent** | `STANDARD` |
+| No invented stages | Chart shows 0m Deep/REM rows; totals kept; no fake restorative fill | `STANDARD` |
+| Staging richness vs WHOOP SWS/REM | Still wake/light collapse on this night — **algo**, not UI | `IMPROVED_STILL_LACKING` |
+
+Code checklist: mark Fold re-verify done for honesty strip.
+
+---
+
+**Audit tags for Fable:** `STANDARD` · `IMPROVED_STILL_LACKING` · `NEEDS_FABLE_AUDIT`
+
+### Update — 2026-07-12 Rest calibration + onset honesty
+
+| Issue | Root cause | Fix / tag |
+|-------|------------|-----------|
+| Rest vessel “Calibrating / needs a tracked night” with Charge scored | **Not** the 4-night Charge gate — `RingNeedsTrackedNight` when `recovery != null` but `sleep_performance` null (#898) | Copy → **“No scored sleep / wear overnight”** `STANDARD` |
+| Bare HC sleep (duration, no efficiency) → Rest null | `restFromDaily` required efficiency | Duration-only Rest via `HcNoopAlign.durationAsSleepPerf` — **no invented Deep/REM** `STANDARD` |
+| Onset vs WHOOP Today | Different primary nights | Footnote on compare strip `STANDARD` |
+| Staging richness | EEG-free actigraphy | `IMPROVED_STILL_LACKING` (algo) |
+
+Sleep-70 ideas appended to `docs/FABLE_200_UI_IMPROVEMENTS.md`.
+
+---
+
+## Update — 2026-07-13 “Updated noop state” export (JPG-only)
+
+**Folder:** `Downloads/Updated noop state -20260713T014231Z-2-001/Updated noop state/`  
+**Contents:** **21 JPGs** (15 NOOP + 6 WHOOP). **No CSV/JSON/SQLite** — graph series below are read from screenshots only.
+
+### Inventory (filenames → surface)
+
+| File | App | Surface / headline |
+|------|-----|-------------------|
+| `…213136–213159_NOOP` | NOOP | Trends week / Charge+HRV / RHR+Effort / calendar empty Stress |
+| `…213205–213220_NOOP` | NOOP | **Today** Sun 12 Jul: Charge **35**, Effort **No Data**, Rest **No scored / wear overnight**; Health HR **87**, HRV **53**, SpO₂ **97%**, Stress **2.4**; HR chart min/avg/max **53 / 68 / 91**; steps tile **615** |
+| `…213230–213238_NOOP` | NOOP | **Stress** tip **2.4 HIGH**; load **1.9**; timeline avg **0.8 · 18h**; peak **2.5 · 9 pm**; time-in-band Calm **14h** / Mod **2h 30m** / High **1h 45m**; “Wear 2 more nights of 4” |
+| `…213251–213301_NOOP` | NOOP | Resp **18.7** (9 readings); Steps history empty (“need 2 readings”); Skin temp latest **+1.2°F** |
+| `…213309–213313_NOOP` | NOOP | **Sleep** wake day Sun 12 Jul: NOOP asleep **3h 44m**, window **04:56–12:54**; HC in bed **6h 36m**; in bed **7h 58m** · eff **47%**; Awake **4h 15m** / Light **3h 39m** / Deep **5m** / REM **0**; **“No movement detail for this night.”** |
+| `…213922–213933_WHOOP` | WHOOP | Home: Sleep activity **5:53**, **6:21 AM–12:57 PM**; Stress Monitor tip **2.1 HIGH**; calib “2 nights to unlock” |
+| `…213938–213950_WHOOP` | WHOOP | Dashboard HRV **40**, RHR **58**, steps **2,831**; Strain/Recovery week Fri **14.8** / Sat **9.7** / Sun **2.8**, Recovery Sat **32%** Sun **37%**; “Wear 2 nights to calibrate” |
+
+### Why Today Rest says “no sleep / wear overnight” despite Sleep tab having a night
+
+| Observation | Cause | Fix plan (do not invent Deep/REM) |
+|-------------|-------|-----------------------------------|
+| Sleep tab shows **04:56–12:54** with stages | On-device session **exists** for wake-day Sun 12 | Session path works |
+| Today Rest vessel: **No scored sleep / wear overnight** | Rest ring uses **`sleep_performance`** (`RingNeedsTrackedNight` when Charge exists but Rest null) — not “any session rows” | Ensure `analyzeDay` writes `sleep_performance` for this wake-day from stage-sum / duration; if gate requires “overnight” clock hours, widen to **longest sleep block ending on selected wake-day** (shift-work / late wake) |
+| Copy says “wear overnight” | Misleading for daytime/late-morning sleep (WHOOP also **6:21–12:57**) | Copy → **“No Rest score yet / open Sleep”** when a session exists but score null; keep “wear overnight” only when **zero** sessions |
+| NOOP **3h 44m** vs WHOOP **5h 53m** | V1 wake-heavy staging + **“No movement detail”** → inflated Awake; onset **04:56** vs WHOOP **6:21** | Prefer denser gravity/accel when present; don’t treat HC **6h 36m TIB** as asleep; time-align by **wake-day + overlapping window**, not wall-clock onset alone |
+| Deep **5m** / REM **0** vs WHOOP SWS/REM | EEG-free actigraphy | Honesty only — `IMPROVED_STILL_LACKING` algo |
+| HC strip **6h 36m** | Phone TIB without stages | Already labeled HC in bed — keep; never fill Rest from TIB alone without durationAsSleepPerf honesty |
+
+### Band streams to use for sleep match (priority)
+
+1. **Gravity / motion** (jerk) — wake vs sleep; this export night lacked movement detail → wake inflate  
+2. **HR / quiet HR** — onset/wake + deep flatness (V2)  
+3. **R-R / RMSSD** — soft rem/light; Rest drivers  
+4. **Optional:** sleep-state samples, skin temp, resp (soft priors only)  
+5. **HC / WHOOP-app import** — dual strip + Rest duration fallback; **never** invent Deep/REM %
+
+### Time-align checklist (same night)
+
+1. Pick **wake calendar day** (Sun 12 Jul) shared by both apps.  
+2. Align windows: WHOOP **06:21–12:57** vs NOOP **04:56–12:54** (overlap midday; NOOP earlier onset).  
+3. Compare **asleep minutes** (stage-sum), not TIB / HC in-bed.  
+4. MAIN: **no algo-vs-WHOOP UI**; DEBUG/docs only for δ tables.
+
+**Audit tags:** Rest gate copy/score wiring → `NEEDS_FABLE_AUDIT` on Fold after fix; staging richness → `IMPROVED_STILL_LACKING`.
+
+---
+
+## RESOLVED — 2026-07-12 (Fable 5, shipped in 8.6.50-fable / 319)
+
+Root causes found by pulling the Fold debug DB + replaying the real streams through the real code
+(`FoldSun12NightReplay` diagnostic). THREE distinct defects stacked into "Sleep tab has a night, Today
+Rest says no scored sleep":
+
+1. **Cross-day edited-block fold ("Rest repeats across days", the community 721-min report).**
+   `IntelligenceEngine.sleepEditedDaily` passed the WHOLE recompute window's `editsByStart` and folded
+   every twinless edited block into EVERY scored day via the `manual` union channel. The Fold DB carried
+   `totalSleepMin=391.5` / `sleep_performance=82.33` byte-identical on 07-10/07-11/07-12; 07-11/07-12
+   genuinely had no scored night. **Fix:** a twinless block folds ONLY into the local day its effective
+   END falls on (same attribution as `analyzeDay`). Regression test `SleepEditWakeDayScopeTest`.
+   **iOS has the same bug** (Strand IntelligenceEngine.swift:1462 `manualTuples`) — parity fix pending. `NEEDS_FABLE_AUDIT` (iOS)
+2. **Upsert-only `sleep_performance`.** The engine deleted+rebuilt computed dailies per pass but only
+   UPSERTED the Rest series, so poisoned points pinned forever. **Fix:** `deleteComputedSeriesInRange`
+   (computed source, key-scoped) before re-upsert — the recompute now fully owns its window. `STANDARD`
+3. **Zero detection on gravity-dead nights.** The 04:56–12:54 night had dense 1 Hz HR + R-R and ZERO
+   gravity records 04:46→15:00 — `buildRuns` (gravity spine) seeded nothing; the #308 sparse branches
+   can only bridge existing runs. **Fix:** HR-only spine (`hrOnlySleepRuns`) inside gravity-dead holes
+   (≥120 min, HR-dense end-to-end so off-wrist can't slip in): 5-min sleep-band buckets, dip-entry
+   hysteresis (open ≤0.95×baseline sustained 15 min; continue ≤1.05×), then the EXISTING full gate
+   ladder. Sparse-gated; dense-gravity nights byte-identical. On-device result: Sat 02:37→10:12 (WHOOP
+   02:14–09:57), Sun 04:29→13:19 (WHOOP 06:21–12:57), Rest 92.39/95.0 per-day. `STANDARD` (detection)
+   — staging on such nights is cardiac-only (eff reads 1.0, no wake detail): `IMPROVED_STILL_LACKING`.
+   iOS parity for the HR-only spine: pending. `NEEDS_FABLE_AUDIT` (iOS)
+
+Copy fix (#202/#317): Rest vessel with a session but no score now reads **"No Rest score yet · open
+Sleep"**; "wear overnight" only when zero sessions exist. `STANDARD`
+
+Pre-existing test failures on this tree (NOT from these changes; verified by disabling them):
+`StepsAnalyticsTest` ×3, `LocalDayBucketingTest`, `GermanLocalizationTest` (missing
+whoop_app_a11y_description / nav_whoop_algo_compare), `SleepImportedFiguresTest.uncoveredDaysFallBackToApproximation`.
+
+---
+
+## Update — 2026-07-14 Noop mg export (docs-only pass, nothing coded)
+
+Export: `Downloads/Noop mg-20260714T022949Z-1-001/Noop mg/` — 16 JPGs (6 WHOOP + 10 NOOP), same night
+Mon 13 Jul, phone captured 22:14–22:27.
+
+### Point-by-point decode, same night
+
+| Field | WHOOP | NOOP (hero card) | NOOP (on-device stage breakdown) | Note |
+|---|---|---|---|---|
+| Asleep / woke | 3:48 AM → 1:08 PM | 02:31 → 13:11 | 02:31 → 13:11 (same span, different totals below) | onset ~77 min apart |
+| Hours of sleep | 7:06 (duration card) | 7:06 | **7h 19m** | NOOP's own two screens disagree by 13 min on the SAME night |
+| In bed / TIB | — | 9:19 (duration row) | 10h 39m | also disagree |
+| Efficiency | 89% (Today card, different night) | — | 69% | not directly comparable (different nights on WHOOP side) |
+| Awake | 2:13 (23%) | 2:13 (23%) | 3h 20m (31%) | hero matches WHOOP shape; stage breakdown does NOT match the hero |
+| Light | 2:41 (28%) | 2:41 (28%) | 7h 9m (67%) | stage breakdown massively over-assigns light |
+| Deep (SWS) | 2:53 (33%) | 2:53 (33%) shown in "Stages vs typical" as target line | **10m (2%)** | this is the number that actually lands in Rest |
+| REM | 1:32 (16%) | shown as −13m vs typical | **0m (0%)** | REM never fires |
+| Restorative sleep | — | 4:25 | 10m | 26× apart between NOOP's own two cards |
+
+The **hero card and the on-device stage breakdown are computing sleep for the same [start,end] window and
+landing on materially different totals** (7:06 vs 7h19m hours, 9:19 vs 10h39m TIB, 23%/28%/33%/16% split vs
+31%/67%/2%/0%). One of these is reading `DailyMetric.totalSleepMin` / stage minutes directly; the other
+looks like it's re-deriving from `SleepStageTotals` or a smoothed timeline over the same segments. They
+should be the SAME computation surfaced twice — find the two call sites and make them share one source of
+truth before touching staging accuracy itself, otherwise any staging fix will only fix one of the two
+screens.
+
+### Deep/REM gap — likely mechanism (V1 vs V2)
+
+The 2%/0% split (vs WHOOP 33%/16%) is consistent with **V1 `SleepStager`** actigraphy-only percentile bands
+collapsing a quiet, low-movement night to mostly "light" + some "awake", exactly the documented ceiling
+in this file's own header ("EEG-free 4-class ceiling ~65–73% epoch agreement", "light/deep separation is
+the weakest link"). `SleepStagerV2` (opt-in, WHOOP5/MG-only gate via `sleepStagerV2ForFamily`) uses the
+11-min HR-flatness percentile deep gate + RSA respiration regularity + Viterbi smoothing specifically
+built to recover deep/REM better — worth confirming this MG session actually routed through V2 rather than
+V1, since a 2%/0% split reads exactly like the V1 failure mode V2 was built to fix.
+
+### Onset gap (~77 min)
+
+WHOOP anchors onset later (3:48 AM) than NOOP (02:31). Per the 2026-07-12 RESOLVED section above, NOOP has
+an `hrOnlySleepRuns` HR-only spine that opens on a sustained HR dip (≤0.95× baseline, 15 min sustained) when
+gravity is dead — that spine is tuned to be more sensitive than a motion-based onset and will legitimately
+fire earlier than a device that waits for stillness. If gravity data existed for this session (unclear from
+JPGs alone), check whether the HR-only spine fired even with motion data present — it should only activate
+in gravity-dead holes, not always-on.
+
+---
+
+## Sleep-staging improvement backlog (grounded, non-padded — pick items, don't just count them)
+
+Organized by pipeline stage. Each references an actual file/constant so a future pass can act directly.
+
+**Onset/wake detection (`SleepStager.kt` Stage 0)**
+1. Log which path (gravity spine vs `hrOnlySleepRuns`) produced each session's onset, surfaced in a debug
+   caption — right now there's no way to tell which fired without reading the DB.
+2. Add a per-night onset-confidence flag (gravity-confirmed vs HR-only) and show it quietly in the Sleep
+   hero so a HR-only-derived night doesn't read as equally precise as a motion-confirmed one.
+3. Cross-validate `hrOnlySleepRuns`'s dip-entry hysteresis (0.95×/1.05× baseline) against this export's
+   ~77 min gap — if HR-only spines consistently open early, the entry threshold may need tightening
+   (e.g. 0.92× or requiring a longer sustained window than 15 min).
+4. Te Lindert/Cole-Kripke cross-check is computed but described as "citable" only — actually surface a
+   disagreement between the two as a confidence signal instead of silently keeping just one.
+5. Respiration-rate-based onset confirmation (resp channel already ingested for V2 respReg) as a THIRD
+   independent onset vote, not just cardiorespiratory + gravity.
+
+**Deep/light separation (weakest link per file header)**
+6. Verify `sleepStagerV2ForFamily` gate is actually selecting V2 for WHOOP MG sessions — if this export
+   routed through V1, that alone explains most of the deep/REM gap; confirm before tuning anything.
+7. V2's `deepGateThresh = 0.20` (deep eligible only in the bottom 20% HR-flatness percentile) may be too
+   strict for a night with genuinely poor overall HR stability — consider a per-night adaptive threshold
+   instead of a fixed population percentile.
+8. Add an SpO2-desaturation-dip cross-check where available (deep sleep correlates with the most stable
+   SpO2 stretches) — MG hardware exposes SpO2; not currently fed into either stager.
+9. Actigraphy literature (Cole-Kripke 1992, te Lindert 2013, Walch 2019) caps EEG-free 4-class agreement
+   at ~65–73%; consider whether NOOP should report a **3-class** (wake/light/deep+REM combined) fallback
+   on nights where the deep-gate percentile spread is degenerate, rather than forcing a 4-way split that's
+   likely to read as 0% on one class.
+10. RR-RSA respiratory regularity (V2's `respRegularity`) is a genuine deep/REM discriminator in the
+    literature (Sleep Medicine Reviews, cardiorespiratory coupling studies) — confirm `resp.size >= 12`
+    gate isn't silently dropping the term on sparse-resp nights, since a dropped RSA term pushes weight
+    back onto HRV/motion alone, i.e. back toward the V1 failure mode.
+
+**REM detection (0% this night — total miss)**
+11. V2's `cyclePrior` suppresses REM entirely in the first 12% of the night (REM latency) — confirm this
+    night's REM-eligible window (after ~12% clock fraction) actually had any epochs; if the whole night
+    fell in the suppressed window (very short/fragmented sleep), REM=0% may be a real consequence of a
+    short night rather than an algorithm miss — worth distinguishing in the UI copy ("too short to reach
+    REM" vs "REM undetected").
+12. Malik-ectopic-cleaned RR gaps: if `HrvAnalyzer.cleanRR` rejected too many beats this night (motion
+    artifact, loose strap), REM's RSA signal would be starved — surface clean-beat yield per night as a
+    staging-confidence input, not just an HRV-analysis internal.
+13. Cross-check REM against the R-R "irregular breathing → REM" prior with the deep-gate's stability
+    percentile — a night where HR-flatness never drops into a low-enough regime for deep ALSO likely never
+    produces the irregular-breathing signature V2 wants for REM; these two misses may share one root cause
+    (a globally elevated, non-differentiated HR profile this specific night) rather than being independent.
+
+**Awake overcounting (31% vs WHOOP's 23%)**
+14. V2's jerk-based wake gate (`jerkFloorGateMult = 55`) self-calibrates to the night's own quiescent-jerk
+    median — on a night with an unusually still baseline (low median jerk), the multiplier threshold
+    shrinks in absolute terms, making ordinary small movements register as wake-triggering jerks; consider
+    a floor on the absolute jerk scale so an extremely still night doesn't become hyper-sensitive to noise.
+15. `moveFrac` (fraction of per-second jerks above `jerkFloorMoveMult × jerkScale`) feeds both the deep
+    emission (negative weight) and the awake emission (positive weight) — on a noisy accelerometer decode,
+    the same noise floor issue would simultaneously suppress deep AND inflate awake, which is exactly this
+    night's pattern (2% deep + 31% awake). Worth checking raw jerk distribution for this session for a
+    decode/calibration artifact before assuming it's a true restless night.
+16. Add hysteresis on the awake→light transition (currently governed only by the Viterbi transition matrix
+    row `"awake" to "light" = 0.27`) — a jerk-related false wake should require 2+ consecutive high-jerk
+    epochs to open a wake segment, closing it on the SAME bar it takes to open, to avoid single-epoch noise
+    spikes fragmenting into visible wake time.
+
+**Cross-cutting / consistency**
+17. Fix the hero-card vs stage-breakdown duration mismatch (7:06 vs 7h19m) — likely two different
+    aggregation paths reading the same segments; unify before any further staging work, since a fix to one
+    path won't visibly help if the OTHER screen is what the user is looking at.
+18. Consolidate the sleep-debt ledger (−7h31m) against the Trend card's own Sleep Debt chart (0.0h) for the
+    identical 10-night window — these cannot both be true; find whether one uses `SleepDebt.kt`'s ledger
+    balance and the other recomputes independently from `totalSleepMin` deltas.
+19. Add a single "why these numbers differ" note anywhere NOOP and WHOOP durations are shown side by side,
+    since even a CORRECT algorithm will diverge from WHOOP's proprietary staging by design — right now a
+    user has no way to tell an honest approximation gap from a bug.
+20. Persist per-night stager version (V1/V2) and onset-source (gravity/HR-only) as durable `DailyMetric`
+    fields, not just derivable-from-logs — needed for any future audit like this one to be a query instead
+    of a screenshot hunt.
+
+---
+
+## Related paths
+
+- `android/app/src/main/java/com/noop/ui/SleepScreen.kt`
+- `android/app/src/main/java/com/noop/analytics/SleepStager.kt` / `SleepStagerV2.kt`
+- `android/app/src/main/java/com/noop/analytics/SleepStageTotals.kt` / `HcNoopAlign.kt`
+- `android/app/src/main/java/com/noop/analytics/IntelligenceEngine.kt` (`sleepStagerV2ForFamily`)
+- `Strand/Screens/SleepView.swift` (segment-first merge; H9 low-confidence when restorative &gt; 0 but implausibly low)
+- Fable: `docs/FABLE_200_UI_IMPROVEMENTS.md`, `docs/FABLE5_300_NOT_INTUITIVE.md`
+- Handoff: `ANY_MODEL_CONTINUE.md` → **Sleep continuation marker**
diff --git a/docs/SLEEP_ML_DATASETS.md b/docs/SLEEP_ML_DATASETS.md
new file mode 100644
index 0000000000..c541c860ae
--- /dev/null
+++ b/docs/SLEEP_ML_DATASETS.md
@@ -0,0 +1,98 @@
+# Sleep-stage ML plan (public datasets + NOOP)
+
+**Date:** 2026-07-11  
+**Hard rule:** Stages remain **wellness approximations**, not PSG medical diagnoses. Never invent SpO2/BP from open BLE.
+
+Community context (Discord 2026-07-10):  
+- Original NOOP-class algorithm ~**55%** epoch accuracy on a labeled wearable set.  
+- Community ML (MADSOLSEN-style / paper architecture) ~**75%** on same minimal example; κ ~0.2–0.25 better claimed.  
+- Path A (algorithm): push rules until gains &lt;5%/step, then ML.  
+- Path B (ML): train on paper datasets; prefer **κ (Cohen’s kappa)** + 4-class (wake/light/deep/rem).
+
+NOOP today ships **4-class** [SleepStager] V1 (default) and opt-in **SleepStagerV2** (`PuffinExperiment.experimentalSleepV2`). Both take gravity + HR + R-R — same modality family as Walch Apple Watch + PSG.
+
+## Primary public / requestable datasets
+
+| Dataset | Access | Sensors | Labels | Fit for NOOP |
+|---------|--------|---------|--------|--------------|
+| **sleep-accel** (Walch 2019) [PhysioNet](https://physionet.org/content/sleep-accel/1.0.0/) | **Open** (ODC-By) | Apple Watch accel + PPG HR | PSG 0–5 (wake/N1/N2/N3/REM) | **Best first LOSO bench** — same paper NOOP cites (~65–73% EEG-free ceiling) |
+| **DREAMT** [PhysioNet](https://physionet.org/content/dreamt/2.2.0/) | **Restricted** DUA | Empatica E4 BVP/ACC/EDA/TEMP + HR/IBI | AASM W/N1/N2/N3/R + apnea cohort n=100 | Strong wearable multi-channel; request DUA |
+| **BIDSLEEP** [PhysioNet](https://physionet.org/content/bidsleep-dataset/1.0.0/) | Check portal | Multi-night IHR + accel (Apple Watch) + Dreem EEG stages | EEG stages | Multi-night free-living-ish |
+| **AAUWSS** [Zenodo](https://zenodo.org/records/16919071) | Open/terms | E4 IBI + ECG gold R-R | AASM 30s n=13 | Good for κ vs non-ML + ML |
+| **GalaxyPPG** Zenodo | Open | Wrist PPG + Polar H10 ECG | No sleep labels | HRV gold R-R only |
+| **PPG-DaLiA** UCI | Open | E4 BVP + chest ECG | Daytime, no sleep | HRV only |
+| **MADSOLSEN** minimal_example [GitHub](https://github.com/MADSOLSEN/SleepStagePrediction) | Open | ACC+PPG @32Hz | wake/light/deep/rem 1 subject | Paper mini-set; not full public train |
+| **MESA / SHHS** [sleepdata.org](https://sleepdata.org/datasets) | Application | PPG/PSG rich | AASM | Fine-tune / SOTA papers (DAT-sleep etc.) |
+
+Paper often cited for flexible DL (accel+PPG):  
+https://backend.orbit.dtu.dk/ws/files/279922590/A_flexible_deep_learning_architecture_for_temporal_sleep_stage_classification_using_accelerometry_and_photoplethysmography_1_.pdf  
+(Full training data often **private**; use MADSOLSEN mini + public PhysioNet instead.)
+
+## Label mapping (PSG → NOOP 4-class)
+
+| PSG / Walch | NOOP stage |
+|-------------|------------|
+| 0 wake | wake |
+| 1 N1 | light |
+| 2 N2 | light |
+| 3 N3 | deep |
+| 5 REM | rem |
+
+(DREAMT: W→wake, N1+N2→light, N3→deep, R→rem.)
+
+## Evaluation metrics (report all)
+
+1. **Epoch accuracy** (30 s) — easy to game with majority light.  
+2. **Cohen’s κ** — primary for community compare.  
+3. **Per-class F1** (wake / light / deep / rem).  
+4. Optional 3-class collapse (wake / nrem / rem) for papers that only publish 3-class.
+
+## Pipeline (PC training → optional on-device)
+
+```
+sleep-accel / DREAMT / AAUWSS
+        │
+        ▼  Tools/sleep_stage_eval.py  (download manual; open license)
+   epoch features: HR, ΔHR, motion energy, (optional RMSSD from IBI)
+        │
+        ├── benchmark SleepStager V1/V2 logic ports (algorithm lane)
+        └── train sklearn / tiny TFLite model (ML lane) → export coefficients
+                │
+                ▼  future SleepStagerV3 (opt-in) on Android
+   WHOOP: type47 motion proxy + 2A37/R-R overnight bank
+```
+
+## WHOOP raw features available for staging
+
+| Feature | Source |
+|---------|--------|
+| HR series | 2A37 + type47@22 |
+| R-R / RMSSD | 2A37 R-R when present |
+| Motion / still | gravity + type47 act@63 + step counter@57 |
+| Resp proxy | RSA from R-R (V2) |
+| Skin temp | banked when present |
+
+## Honest limits
+
+- Wrist-only 4-class **ceiling** is well below PSG; Walch ~65–73% for simpler tasks.  
+- Community 75% on **mini** set ≠ production κ on apnea-heavy DREAMT.  
+- NOOP must stay **opt-in** for experimental stagers; V1 remains default.  
+- Never claim clinical sleep diagnosis.
+
+## Download (you run once)
+
+```bash
+# Open: ~550 MB zip
+# https://physionet.org/content/sleep-accel/1.0.0/
+# Place under: pairing-logs/datasets/sleep-accel/
+
+# Then:
+python Tools/sleep_stage_eval.py --sleep-accel-dir pairing-logs/datasets/sleep-accel
+```
+
+## References
+
+- Walch et al. SLEEP 2019 (sleep-accel).  
+- DREAMT CHIL 2024 / PhysioNet 2.2.0.  
+- MADSOLSEN SleepStagePrediction (GitHub).  
+- NOOP: `SleepStager.kt`, `SleepStagerV2.kt`, Settings → Experimental sleep V2.  
diff --git a/docs/STRESS_FACTORS_AND_LITERATURE.md b/docs/STRESS_FACTORS_AND_LITERATURE.md
new file mode 100644
index 0000000000..15f124e6bd
--- /dev/null
+++ b/docs/STRESS_FACTORS_AND_LITERATURE.md
@@ -0,0 +1,310 @@
+# Stress factors and literature
+
+**CONTINUED 2026-07-12 WHOOP Stress Monitor match pass (8.6.34-fable).** Code-truth map of what feeds NOOP Stress, how WHOOP’s UI behaves from export screenshots, band streams used, and remaining irreducible gaps.
+
+Exports: `Downloads/Noop stresd-20260712T213610Z-2-001/Noop stresd/` (JPG only).
+
+### WHOOP Stress Monitor (from SS — reverse-engineered behavior)
+
+| Observation | Inference |
+|-------------|-----------|
+| Tip **0.5 LOW** at night/early morning (Fri 2:10 AM, Sat 6:20 AM) | Continuous monitor; **sleep floor near 0–0.5**, not mid-scale |
+| Daytime tip **0.9 LOW** (Sun 5:34 PM) | Calm desk afternoon stays LOW |
+| Daytime spikes to **~2.0–2.8** with activity glyphs | Motion/effort raises stress; peaks are sparse |
+| High-zone minutes (e.g. 2h 8m / 3h 2m) | High zone ≈ level ≥ ~2.0 |
+| “Wear 2 more nights” of **4** | Personalization/calibration separate from live tip |
+| Chart includes **full sleep window** shaded | Night is on the series at near-zero — not omitted |
+
+NOOP export-era (pre calm-anchor): logistic raw=0 → **1.5** MEDIUM + activity mean HR → hero **1.9** / avg **2.3** / **0h calm · 9h high**.
+
+### Per-hour / tip match table (SS + unit expectation)
+
+| Anchor (WHOOP SS) | WHOOP tip / shape | NOOP export SS (pre) | Post 8.6.34 (algo / unit) | Tag |
+|-------------------|-------------------|----------------------|---------------------------|-----|
+| Fri Jul 10 · 2:10 AM | **0.5 LOW**; sleep band after midnight | (not tip-compared) | Night bias → ~0.5 | `STANDARD` (unit) |
+| Sat Jul 11 · 6:20 AM | **0.5 LOW**; sleep ~0.2–0.7 | — | Night bias → ~0.5 | `STANDARD` (unit) |
+| Sun · 5:34 PM tip | **0.9 LOW** | Hero **1.9** / avg **2.3** | Flat 62–66 bpm dayMean **&lt;1.2**, tip **&lt;1.5** | `STANDARD` (unit) |
+| Fri high-zone | **2h 8m** | Timeline **9h high** (rounded hours) | Exact bucket×15 caption + compact labels; Fold δ TBD | `IMPROVED_STILL_LACKING` → Fold `NEEDS_FABLE_AUDIT` |
+| Sat high-zone | **3h 2m** | — | Same | `IMPROVED_STILL_LACKING` → Fold `NEEDS_FABLE_AUDIT` |
+| Sub-hour jagged curve | Continuous PPG | 1h stairs | **15-min** buckets | `IMPROVED_STILL_LACKING` vs continuous |
+| Activity peaks | Glyphs @ ~2.8 | Mean-HR inflated | Step walk/run + gravity L2 damp | `STANDARD` (wired) |
+| Desk calm | Tip ~0.5–0.9 | False HIGH | Sedentary + still class −0.55 raw; SD floor 3 bpm | `STANDARD` (wired) |
+
+Fold live tip-at-clock dump after install remains **`NEEDS_FABLE_AUDIT`** (no CSV export — JPG tips only).
+
+### Match pass (this ship)
+
+| Change | Effect |
+|--------|--------|
+| `calmAnchorOffset = 1.55` | raw=0 → ~**0.52 LOW** |
+| Quiet HR **p10** (dense) / p25 | Still quieter than mean under spikes |
+| Gravity **L2** + step **walk/run** | Stiller BPM half when busy |
+| Sedentary bout / still class | −0.55 raw calm bias |
+| **15-min buckets** | Closer tip/peak shape vs 1h |
+| **SD floor** HR≥3 / RMSSD≥5 | Flat calm days no longer explode z |
+| Night hours scored −0.85 | Sleep band near floor |
+| Sustained-high waking-only | Breathe nudge not from sleep |
+| High-zone minutes caption | WHOOP-style summary under totals |
+| Methodology copy | Calm floor ~0.5 (not 1.5 baseline) |
+
+### Match pass (8.6.42)
+
+| Change | Effect |
+|--------|--------|
+| Sleep-state gate (#22) | Band asleep ≥3 samples/bucket → night bias; skip sustained |
+| Skin / resp soft bumps (#19/#21) | Day vitals elevate waking raw when flagged |
+| Calibration footnote (#50) | “Wear N more nights of 4” on Stress timeline |
+| Persist daytime tip (#42) | `metricSeries.daytime_stress` when scored |
+| Widget Now tip (#43) | Glance footer `Stress X.X` from tip tenths |
+| Auto-workout damp (#63) | Detected peaks join logged workout windows |
+
+### Remaining gaps (evidence)
+
+| Gap | Why irreducible / next |
+|-----|------------------------|
+| Continuous WHOOP curve vs 15-min | Band banks discrete samples; no secret continuous PPG stream |
+| Exact WHOOP proprietary HRV model | Not published |
+| Fold tip@clock vs WHOOP tip | `NEEDS_FABLE_AUDIT` after install ≥ 8.6.36 |
+| High-zone minutes δ vs 2h8m / 3h2m | Computation honest (bucket×15, no hour round-up) in **8.6.37**; Fold δ still `NEEDS_FABLE_AUDIT` |
+| Multi-day personalization (“2 of 4 nights”) | **STANDARD** in 8.6.42 — `priorCalmDayCount` + Stress “Wear N more nights” footnote (#50) |
+
+### High-zone minutes (8.6.37)
+
+| Piece | Behavior |
+|-------|----------|
+| Formula | `scored.count(level ≥ 2.0) × 15 min` — same as WHOOP “You spent X hr Y min…” wording |
+| Time-in-band labels | Compact `2h 8m` / `45m` (no `coerceAtLeast(1h)` inflation) |
+| Sparse coverage note | If scored &lt; ~8 h, caption appends window count |
+| Pre-fix inflation | Rounded “9h high” came from hour labels, not continuous PPG |
+| Remaining δ | Fold live day vs WHOOP SS 2h8m / 3h2m — fill tip@clock + high-zone rows on return |
+
+**Expected residual vs WHOOP:** continuous PPG can still accumulate more (or less) high minutes than 15-min banked buckets; within ~30% when coverage is dense is the Fold pass heuristic.
+
+---
+
+## Pipeline overview (three lanes)
+
+| Lane | Feeds UI score? | Source files |
+|------|-----------------|--------------|
+| **A. Daily load (0–3)** | Secondary when daytime exists | `StressModel.build` |
+| **B. Daytime / Now (0–3)** | Hero “Now”; timeline | `DaytimeStress.analyze(hr, rr, tz, motion, steps, sedentary)` |
+| **C. Advanced HRV** | Display only | `StressIndex`, `HrvFreqDomain` |
+
+```
+HR + R-R + gravity→ActivityPoint + steps@63 + sedentary bouts
+  ──► DaytimeStress (15-min) ──► 0–3 (calm≈0.5)
+daily RHR + avgHRV ──► StressModel ──► daily 0–3 (secondary)
+```
+
+---
+
+## Factor → effect table
+
+| Input | Where | How much | Gate | Notes |
+|-------|-------|----------|------|-------|
+| Quiet HR (p10/p25) | `DaytimeStress` | +1 z vs waking calm | ≥75 samples / 15-min | Motion-busy → lower half BPMs |
+| Bucket RMSSD | same | +1 z when low | clean R-R | Optional enrich |
+| Calm anchor offset | `squash` | calm→~0.5 | const 1.55 | WHOOP floor |
+| Night bias | −0.85 raw | sleep hours | hour ∉ 06–22 | WHOOP sleep band |
+| Sedentary / still | −0.55 raw | bout or still&gt;walk | gravity + @63 | Desk calm |
+| Gravity L2 / walk-run | busy gate | damp via quiet pool | mean ≥0.035 or walk≥still | Ambulation |
+| SD floor | z denom | min 3 bpm / 5 ms | always | Anti-jitter explode |
+| Daily RHR/HRV | `StressModel` | daily load | 30d baseline | Secondary to Now |
+| Baevsky / LF/HF | Advanced | **0 weight** | — | Honesty only |
+
+---
+
+## Code fix checklist
+
+- [x] Quiet HR p25/p10
+- [x] Calm anchor + motion + night score
+- [x] Step activityClass + sedentary gates
+- [x] 15-min buckets + SD floor
+- [x] Hero Now + high-zone caption + methodology
+- [x] Unit tests calm day / step / sedentary / 15-min
+- [x] High-zone minutes = bucket×15 + compact labels (8.6.37); unit tests
+- [ ] Fold tip@clock δ table (`NEEDS_FABLE_AUDIT`) — prep below
+- [ ] High-zone minutes vs WHOOP 2h8m / 3h2m on Fold (`NEEDS_FABLE_AUDIT` — computation shipped)
+
+### Fold return — tip@clock δ audit (`NEEDS_FABLE_AUDIT`)
+
+**Goal:** same wall-clock tip on Fold Stress hero vs WHOOP Stress Monitor SS (JPG anchors above).
+
+**Prep (do on Fold after AI Store / adb install ≥ 8.6.36):**
+
+1. Wear MG; open NOOP Stress with live link; note **Now** tip + local clock (screenshot).
+2. Open WHOOP Stress Monitor at the **same minute**; screenshot tip + clock.
+3. Fill one row per check (aim ≥4 across day: morning calm, desk afternoon, post-walk spike, late evening):
+
+| Local clock | WHOOP tip / band | NOOP Now / band | |δ| | Tag |
+|-------------|------------------|-----------------|-----|-----|
+| _e.g. 17:34_ | 0.9 LOW | _fill_ | _|_ | `NEEDS_FABLE_AUDIT` → `STANDARD` if \|δ\| ≤ 0.3 in LOW |
+
+4. Also note **High zone** caption minutes vs WHOOP day summary (2h8m / 3h2m anchors).
+5. Paste the filled table back into this section; retag rows.
+
+**Pass heuristic:** calm desk LOW within ~0.3 of WHOOP; spikes same direction; high-zone within ~30% of WHOOP minutes when coverage is dense.
+
+---
+
+## Update — 2026-07-13 “Updated noop state” export (JPG-only)
+
+Same folder as Sleep update: `Downloads/Updated noop state -20260713T014231Z-2-001/Updated noop state/` (21 JPGs, no CSV).
+
+### Stress tip@clock (Sun 12 Jul · ~21:39)
+
+| Anchor | WHOOP | NOOP | δ | Tag |
+|--------|-------|------|---|-----|
+| ~21:32–21:39 tip | **2.1 HIGH** | **2.4 HIGH** | +0.3 | `IMPROVED_STILL_LACKING` → Fold re-check `NEEDS_FABLE_AUDIT` |
+| Today’s load / day mean | (not on SS) | load **1.9**; timeline avg **0.8 · 18h** | — | direction OK (day quieter than tip) |
+| Peak | visible evening rise | peak **2.5 · 9 pm** | same direction | `STANDARD` shape |
+| High-zone minutes (this day) | (not labeled on this SS; prior Fri/Sat anchors **2h8m / 3h2m**) | **1h 45m** high / **2h 30m** mod / **14h** calm | fill Fri/Sat on Fold | `NEEDS_FABLE_AUDIT` |
+| Calibration copy | “Wear 2 nights to unlock” (WHOOP) | “Wear 2 more nights of 4” | parity OK | `STANDARD` |
+
+### Band streams for Stress match
+
+| Stream | Role |
+|--------|------|
+| Quiet HR (15-min buckets) | Tip / curve body |
+| RMSSD | Quiet-HR companion |
+| Step class still/walk/run + gravity L2 | Damp false highs |
+| Sedentary / still | Calm pull |
+| Sleep-state / night hours | Floor near ~0.5 |
+| Skin / resp soft bumps | Day elevate only when flagged |
+
+### Fix plan (precise, no micro-APK this tick)
+
+1. On Fold with **8.6.49 / 318**: at same clock as WHOOP tip, dump NOOP tip + high-zone caption; fill table rows.  
+2. If δ tip stays >0.3 in HIGH evening, tune calm floor / activity damp — document in this file before code.  
+3. High-zone: compare Fri/Sat WHOOP **2h8m / 3h2m** against NOOP same wake-days (not Sun-only).
+
+---
+
+## Fold replay audit — 2026-07-12 (Fable 5, offline replay of real banked streams)
+
+Method: `FoldStressReplay` JVM diagnostic — the REAL `DaytimeStress.analyze` pipeline (same aux inputs
+as `loadDaytimeStressShared`: activity series, sedentary bouts, Baevsky SI, HF share, auto-workout damp
+windows, band sleep state, prior-day calm) over the Fold's banked HR/R-R/gravity/step streams for
+Fri 10 / Sat 11 / Sun 12 Jul. Sun tip additionally replayed with a hard 21:40 data cutoff so the calm
+reference matches what the live app could have known at the WHOOP screenshot minute.
+
+| Anchor | WHOOP | NOOP replay (fixed pipeline) | δ | Tag |
+|--------|-------|------------------------------|---|-----|
+| Fri 10 high-zone | **2h 8m** | **1h 0m** (peak 2.81 @ 12h damped by auto-workout window — Fri was the strain-14.8 day) | −1h 8m | `IMPROVED_STILL_LACKING` — deliberate design divergence: NOOP damps workout windows (Fable #62) so Effort doesn't double as Stress; WHOOP counts exercise stress in its high zone. Decide product stance before tuning. |
+| Sat 11 high-zone | **3h 2m** | **3h 15m** | +13m (~7%) | `STANDARD` (pass heuristic ≤30%) |
+| Sun 12 tip @21:39 (live-cutoff) | **2.1 HIGH** (calibrating: "2 nights to unlock") | **~1.3–1.7** falling edge (21:00 bucket 2.41 → 21:15 1.73 → 21:30 1.25 partial); evening peak 2.6 @ 20h | −0.4..−0.8 | `NEEDS_FABLE_AUDIT` — the UI's 2.4 that evening was fed by the #316 poisoned daily rows (fixed in 8.6.50); vs a still-calibrating WHOOP one night is NOT tuning evidence. Re-check live at same clock on 8.6.50. |
+| Sun 12 zone split (full day) | (1h45m high shown at 21:40 on 318) | high 2h30m / mod 4h45m / calm 15h45m | — | direction OK; day extends past the screenshot |
+
+**Verdict:** no constant tuning this tick — Sat matches, Fri's gap is a documented design choice
+(workout damp), and the Sun tip anomaly traces to the sleep-side data corruption fixed in 8.6.50.
+Tune only if the 8.6.50 live tip@clock re-check still misses in a clean-DB week.
+
+---
+
+## Update — 2026-07-14 Noop mg export (docs-only pass, nothing coded)
+
+Export: `Downloads/Noop mg-20260714T022949Z-1-001/Noop mg/`, same night/window as the Sleep update above
+(Mon 13 Jul, phone captured 22:14–22:27).
+
+### Tip@clock, same window
+
+| Anchor | WHOOP | NOOP | δ |
+|---|---|---|---|
+| ~10:14–10:15 PM tip | **1.4 MEDIUM** (both WHOOP screenshots, stable) | **1.8 / 3** (Today Health card, same minute) | +0.4, same MEDIUM band but NOOP reads meaningfully hotter |
+| Today card stress row (separate capture) | — | **1.8/3** listed under Health alongside HR 85 bpm / HRV 50 / SpO2 98% | consistent within NOOP itself this time — good |
+| WHOOP curve shape (24h) | clear night dip to ~0.3–0.5 between the two shaded night blocks, sharp rise after wake, plateau ~1.5–2.2 daytime, evening dip then climb to tip | not captured in this export (NOOP stress chart wasn't screenshotted) | can't compare shape this round — only the live tip |
+
+### What's grounded vs what needs a live re-check
+
+The +0.4 gap alone is not damning — WHOOP's own chart shows a MEDIUM band that spans roughly 1.0–2.0, so
+1.4 vs 1.8 is a real but small miss, not a category error (both land MEDIUM). Per the existing Fold replay
+audit above (2026-07-12), the previous large stress anomaly traced back to a SLEEP-side data-corruption bug
+(#316, fixed 8.6.50), not the stress pipeline itself — the same caution applies here: don't retune
+`calmAnchorOffset` from one clock-matched sample. Do a live tip-at-clock dump against a few more matched
+WHOOP timestamps before touching constants.
+
+### What IS worth investigating regardless of the tip gap
+
+Since the SAME night's sleep scored 2% deep / 0% REM (see SLEEP_FACTORS update above) and this stress
+reading was captured at 10:14–10:15 PM — i.e. BEFORE that night's sleep even started — the two aren't
+causally linked for this particular sample. But the broader stress-sleep coupling deserves scrutiny:
+`nightCalmBias = 0.85` and `overnightAnchorSlackBpm = 5.0` in `DaytimeStress.kt` both assume a night with
+a clean quiet-HR floor; a night that stages mostly "light"/"awake" instead of deep would produce a NOISIER
+overnight quiet-HR pool feeding into `overnightQuiet` (used for the next day's `overnightCalmBias` pull),
+which could inflate the FOLLOWING day's tips after a poorly-staged night — worth checking the day AFTER
+this one for a stress readout that runs hot, tracing back to a contaminated overnight quiet reference.
+
+---
+
+## Stress-algorithm improvement backlog (grounded, non-padded)
+
+**Calm reference / baseline (`DaytimeStress.kt`)**
+1. `calmReference` uses a flat p25 (waking) / p75 (overnight) quantile regardless of sample count beyond
+   the `size < 4` fallback — consider a wider quantile window (p10 dense / p25 sparse, mirroring
+   `quietHourHr`'s own density-adaptive logic) so the calm reference doesn't get dragged by a single busy
+   bucket on a low-sample day.
+2. `priorCalmBlendMax = 14` blends up to 14 prior days flat — no recency weighting. An EWMA-style decay
+   (mirroring `RecoveryScorer`'s baseline spread) would let the calm reference adapt faster after a genuine
+   fitness/health change instead of being anchored to a 2-week-old baseline.
+3. `overnightAnchorSlackBpm = 5.0` is a fixed absolute bpm slack regardless of the person's HR variability
+   range — a low-HRV person's whole day might sit within 5 bpm of their overnight quiet HR by chance,
+   permanently pulling them toward calm; scale the slack by the person's own HR spread (`sdHr`) instead of
+   a flat constant.
+4. No cross-day contamination guard: a poorly-staged sleep night (this export's 2%-deep night) could feed
+   a noisy `overnightQuiet` into the FOLLOWING day's calm anchor — add a sanity gate that rejects an
+   overnight quiet-HR estimate derived from a night with abnormally high `awake` fraction (>25%, per this
+   export) rather than trusting every night's overnight pool equally.
+
+**Motion / activity damping**
+5. `motionBusyFloor = 0.035` and `stepBusy`/`stepStill` are binary gates — no partial credit for "somewhat
+   busy" (e.g. slow walking vs running should damp differently, not both flip the same boolean).
+6. `workoutOverlapBias = 0.40` is a flat damp for ANY logged workout regardless of intensity — a max-effort
+   interval session and an easy recovery walk both get the same stress suppression during the window;
+   scale the damp by the workout's own Effort/strain contribution instead of a constant.
+7. Gravity L2 + step class are independent gates (`stepBusy`, `motionMean >= motionBusyFloor`) that OR
+   together — consider requiring agreement between the two sensors before applying the busy classification,
+   since a phone-in-pocket walk and a wrist-only gesture can disagree on which sensor sees "motion".
+
+**Autonomic-signal fusion**
+8. Baevsky SI (`daySi`) is a single day-level scalar folded in with fixed thresholds
+   (`baevskyCalmSi = 80`, `baevskyHighSi = 200`) — SI is already implemented per-night in `StressIndex.kt`
+   but not fed in per-bucket; a rolling SI over a shorter window (e.g. 2-hour) would let SI contribute to
+   the SHAPE of the day's curve, not just a single soft bump/damp applied uniformly.
+9. HF-vagal trust (`hfVagalTrusted`) is boolean — no magnitude scaling. A day with HF share at 41% (barely
+   over the `hfCalmShare = 0.40` bar) gets the same calm bias as one at 70%; scale `hfCalmBias` by how far
+   above the threshold the HF share actually sits.
+10. Respiration-elevated bump (`respElevatedBpm = 18.0`) doesn't distinguish exercise-driven respiratory
+    rate elevation (already damped by `workoutOverlapBias`) from anxiety/illness-driven elevation outside a
+    workout window — the two should probably not share one flat `respElevatedBias`.
+11. Skin-temperature bump (`skinElevatedAbsC = 0.5`) is symmetric-agnostic in Stress (only "elevated" is
+    checked) while `RecoveryScorer`'s skin-temp term is symmetric (illness OR overreach both matter) —
+    consider whether a below-baseline skin-temp deviation should also nudge Stress, for consistency with
+    how Charge already treats temperature deviation.
+
+**Calibration / cold-start honesty**
+12. `calibrationNightsTarget = 4` gates personalization but the live tip still renders during calibration —
+    confirm the UI clearly distinguishes "still calibrating, tip may be noisy" from a fully personalized
+    tip, since this export's WHOOP screen explicitly showed "Wear WHOOP to sleep tonight to calibrate" while
+    NOOP showed a bare tip number with no equivalent caveat visible in this capture.
+13. `priorCalmDayCount` is tracked but only exposed via `calibrationNightsRemaining` — surface this
+    countdown directly under the live tip (mirroring WHOOP's own "Wear 2 more nights" copy already matched
+    per the 2026-07-12 pass) rather than only in the Stress Monitor detail screen.
+
+**Chart / UI fidelity (ties to Fable list, not just math)**
+14. WHOOP's chart is visually continuous (sub-minute PPG); NOOP's 15-min buckets (`bucketSeconds = 900`)
+    are a deliberate compromise already documented above — consider whether a THINNER bucket (5-min) is now
+    affordable given the #707 OOM fix pattern already applied to `SleepStagerV2` (prefix-sum / cache
+    memoization) was specifically built to make more expensive per-epoch recipes affordable again.
+15. Show the live tip alongside the SAME MEDIUM/HIGH/LOW color band language WHOOP uses at the exact
+    number (WHOOP: "MEDIUM" label directly under the big digit) — confirm NOOP's Health-card stress row
+    (this export's "1.8 / 3") carries an equivalent qualitative label, not just the raw number, since a bare
+    fraction reads as more precise than the metric actually is.
+
+---
+
+## Related paths
+
+- `android/.../DaytimeStress.kt`, `DaytimeStressLoader.kt`, `StressScreen.kt`, `TrendsScreen.kt`, `TodayScreen.kt`
+- `android/.../StressIndex.kt` (Baevsky SI, feeds `daySi` above)
+- `Packages/StrandAnalytics/.../DaytimeStress.swift`
+- Fable Stress-70 in `docs/FABLE_200_UI_IMPROVEMENTS.md`
diff --git a/docs/STRESS_SLEEP_ML_REPRO.md b/docs/STRESS_SLEEP_ML_REPRO.md
new file mode 100644
index 0000000000..31497eceba
--- /dev/null
+++ b/docs/STRESS_SLEEP_ML_REPRO.md
@@ -0,0 +1,98 @@
+# Stress + sleep ML reproduce guide
+
+End-to-end path to recreate the **stress tip** and **sleep Rest / stage** evaluation results
+checked into this PR. Wellness approximations only — never invent SpO2/BP/clinical stages.
+
+## What was trained (2026-07-14)
+
+| Head | Method | Inputs | Gate |
+|------|--------|--------|------|
+| **Stress tip** | Affine `whoop_tip ≈ a·noop_tip + b` on 0–3 scale | Clock-matched screenshot labels | `accuracy_valid` only with ≥4 tip@clock pairs + ≥75% same band |
+| **Sleep Rest vs Sleep%** | Affine trend check (related, not identical scales) | WHOOP `sleep_pct` + NOOP `noop_rest` | Always honest; RestScorer tickets in factor docs |
+| **Sleep stages (G4)** | `Tools/sleep_stage_eval.py` heuristic + mini-ML lane | Synthetic smoke **or** PhysioNet sleep-accel | Real κ only after sleep-accel download |
+| **Effort → Strain** | `Tools/ml_engine_train.py` linear+ridge | BLE `ml-samples.jsonl` + `strain_021` labels | `accuracy_valid` needs ≥3 distinct labeled days |
+
+Artifacts (generated under `pairing-logs/`):
+
+- `stress-sleep-train-status.json` — orchestrator summary
+- `ml-stress-tip-weights.json` — stress tip affine coefficients
+- `sleep-stage-eval.json` — stage bench (synthetic until sleep-accel present)
+- `ml-engine-status.json` / `ml-effort-weights.json` — effort→strain
+- `calibration-report.json` — multi-head Charge/Effort/Sleep/Stress table
+
+## Data (golden + how to rebuild)
+
+### Checked in (small)
+
+| Path | Role |
+|------|------|
+| `pairing-logs/whoop-app-labels.jsonl` | Real WHOOP/NOOP labels (adb UI + decoded screenshots) |
+| `pairing-logs/exports/20260712-Noop_stresd/manifest.csv` | Decoded stress pack taxonomy + values |
+| `pairing-logs/exports/20260713-Noop_mg/manifest.csv` | Decoded mg pack (stress tip + sleep stages) |
+| `pairing-logs/exports/*/REQUIRED_SHOTS.md` | Pack coverage checklist |
+| `pairing-logs/golden/README.md` | What is/isn't in git |
+
+### Not checked in (rebuild locally)
+
+| Path | Why | Rebuild |
+|------|-----|---------|
+| Full JPGs under `exports/*/` | Large binary dumps | `Tools/ingest_export.ps1 -PackKind stress|sleep -ExportDir <Downloads folder>` |
+| `ml-samples.jsonl` / `noop-pairing-log.txt` | Large BLE banks | Fold collectors when phone is **on**; this session Fold was plugged-in but **powered OFF** |
+| PhysioNet sleep-accel | License + size | See `docs/SLEEP_ML_DATASETS.md` → unpack to `pairing-logs/datasets/sleep-accel` |
+
+Primary clock-matched stress anchor (mg pack):
+
+```text
+2026-07-13 22:14  WHOOP tip 1.4 MEDIUM  ↔  NOOP tip 1.8 / 3 MEDIUM  (δ +0.4)
+WHOOP sleep 64% / Recovery 43% / Strain 10.2
+NOOP Rest 73 Strong with Deep 2% / REM 0%  (REST-WEIGHT ticket)
+```
+
+## Reproduce (desk or laptop)
+
+Desk SSH (Tailscale Host alias `desk` → DESKTOP-UEJPJSH, user `Gilbert`, key `~/.ssh/id_ed25519`).
+GPU on desk is AMD RX 7900 XTX; these scripts are **CPU affine** — fine while Hermes/Gemma stay killed.
+
+```powershell
+# From AI app store root (or this noop checkout with pairing-logs present):
+python Tools\stress_sleep_train.py --as-of 2026-07-14
+
+# Individual lanes:
+python Tools\ml_engine_train.py --labels pairing-logs\whoop-app-labels.jsonl --as-of 2026-07-14
+python Tools\sleep_stage_eval.py --synthetic
+# After sleep-accel download:
+# python Tools\sleep_stage_eval.py --sleep-accel-dir pairing-logs\datasets\sleep-accel
+python Tools\calibrate_whoop_noop.py --pairing pairing-logs
+```
+
+Remote one-shot (from laptop):
+
+```powershell
+scp Tools\stress_sleep_train.py Tools\sleep_stage_eval.py Tools\ml_engine_train.py desk:"C:/Users/Gilbert/Documents/Ai app store/Tools/"
+scp pairing-logs\whoop-app-labels.jsonl desk:"C:/Users/Gilbert/Documents/Ai app store/pairing-logs/"
+ssh desk powershell -NoProfile -Command "cd 'C:\Users\Gilbert\Documents\Ai app store'; python Tools\stress_sleep_train.py --as-of 2026-07-14"
+```
+
+## Screenshot ingest + compare
+
+1. `docs/WHOOP_NOOP_SCREENSHOT_COMPARE.md` — three-lane playbook (WHOOP UI / NOOP UI / band replay)
+2. `Tools/ingest_export.ps1 -PackKind stress -ExportDir ...`
+3. Fill `manifest.csv` `screen` + `values`, append tip@clock rows to `whoop-app-labels.jsonl`
+4. Re-run `stress_sleep_train.py`
+
+## Factor docs + Fable backlog
+
+- `docs/STRESS_FACTORS_AND_LITERATURE.md` — DaytimeStress map, tip@clock tables, STRESS-* tickets
+- `docs/SLEEP_FACTORS_AND_LITERATURE.md` — RestScorer / stage gaps, REST-WEIGHT, SLEEP-SELF-1
+- `docs/SLEEP_ML_DATASETS.md` — public datasets + κ metrics
+- `docs/FABLE5_300_NOT_INTUITIVE.md` / `docs/FABLE_200_UI_IMPROVEMENTS.md` — UX backlog (do not conflate with ML gates)
+
+## Fold offline this session
+
+Gilbert left the Fold **plugged in but powered OFF**. Do **not** wait on USB ADB, tip@clock live capture, bank pull, or live-edit deploy. Re-verify on device after the phone is powered on again.
+
+## Honesty rules
+
+- `accuracy_valid=false` until documented N gates pass — never cite synthetic κ as product accuracy.
+- Do not retune `DaytimeStress` from a single tip δ (STRESS-TIP acceptance: ≥4 matched calm/MEDIUM anchors).
+- SpO2 on NOOP Health cards is **strap/UI reported** when present; never invent from open BLE.
diff --git a/docs/WHOOP_NOOP_SCREENSHOT_COMPARE.md b/docs/WHOOP_NOOP_SCREENSHOT_COMPARE.md
new file mode 100644
index 0000000000..6af3c190e8
--- /dev/null
+++ b/docs/WHOOP_NOOP_SCREENSHOT_COMPARE.md
@@ -0,0 +1,235 @@
+# WHOOP ↔ NOOP screenshot compare playbook
+
+**Audience:** any model picking up `ANY_MODEL_CONTINUE.md`.  
+**Goal:** turn Gilbert’s JPG dumps into durable, clock-matched anchors — then compare **three** lanes before tuning code:
+
+| Lane | What it is | Trust for tuning? |
+|------|------------|-------------------|
+| **A. WHOOP app UI** | Official tip / stages / strain from screenshots or adb UI dump | Labels only (ground truth for “what WHOOP showed”) |
+| **B. NOOP app UI** | Same wall-clock tip / Rest / stages from screenshots | Labels only (what NOOP showed the user) |
+| **C. Band streams** | Fold bank HR / R-R / gravity / steps / sleep-state | Features — replay through real scorers (`FoldStressReplay`, sleep replays) |
+
+Never tune constants from A↔B alone. Prefer A↔C (replay at screenshot minute) or B↔C (UI vs banked truth). JPG-only packs have **no CSV** — fill `manifest.csv` by reading pixels.
+
+Related: `noop-v8.4.0-src/Tools/ingest_export.ps1`, `docs/STRESS_FACTORS_AND_LITERATURE.md`, `docs/SLEEP_FACTORS_AND_LITERATURE.md`, `pairing-logs/whoop-app-labels.jsonl`.
+
+---
+
+## 1. Capture checklist (before Gilbert exports)
+
+### Stress pack (minimum)
+
+Capture **same minute** (±2 min) on both apps. Status-bar clock is the anchor, not the chart tip time alone.
+
+| # | App | Screen | Why |
+|---|-----|--------|-----|
+| S1 | WHOOP | **Home** with Stress Monitor card visible (tip + band + calibrating) | Live tip without opening full monitor |
+| S2 | WHOOP | **Stress Monitor** full page (gauge + 24h chart + high-zone copy + calib bar) | Curve shape, high-zone minutes, night floor |
+| S3 | NOOP | **Today** Health / Key Metrics row with Stress tip | Side-by-side with S1 |
+| S4 | NOOP | **Stress** hero (Now tip + band + methodology) | Side-by-side with S2 tip |
+| S5 | NOOP | **Stress / Trends** intraday timeline (avg · hours · peak · time-in-band) | Shape vs WHOOP chart; high-zone minutes |
+| S6 | optional | Same clocks again morning calm / desk / post-walk / evening | ≥4 tip@clock rows before touching constants |
+
+**Do not skip S5.** The 2026-07-14 Noop-mg pack had tip-only NOOP stress — curve shape could not be compared.
+
+### Sleep / Rest pack (minimum)
+
+| # | App | Screen |
+|---|-----|--------|
+| L1 | WHOOP | Home rings (Sleep % / Recovery / Strain) + sleep activity row |
+| L2 | WHOOP | Sleep detail (hours, stage bars Awake/Light/SWS/REM, restorative) |
+| L3 | NOOP | Sleep hero (Rest score, wake-day window, “What shaped Rest”) |
+| L4 | NOOP | Sleep stages / honesty strip (Deep/REM minutes, movement detail) |
+| L5 | NOOP | Today Rest vessel + any debt/trend cards for the **same** wake-day |
+
+### Filename contract (Samsung / Fold)
+
+```text
+Screenshot_YYYYMMDD_HHMMSS_<APP>.jpg
+```
+
+`<APP>` must be `WHOOP` or `NOOP` (case-insensitive). That stamp is capture time on the phone — use it for pairing, then confirm against the **status-bar clock** in the image (they usually match; if not, trust the status bar for tip@clock).
+
+---
+
+## 2. Import (durable, not Downloads-only)
+
+```powershell
+# From AI app store root (or noop-v8.4.0-src):
+powershell -File noop-v8.4.0-src\Tools\ingest_export.ps1 `
+  -ExportDir "C:\Users\Gilbert\Downloads\Noop stresd-...\Noop stresd" `
+  -PackKind stress
+```
+
+What ingest does:
+
+1. Copies every matching JPG → `pairing-logs/exports/<stamp>/`
+2. Writes `manifest.csv` with `file,app,captured,screen,values,pairFile,pairGapS`
+3. Writes `REQUIRED_SHOTS.md` (pack checklist vs what was found)
+4. Writes `decode_worksheet.md` (one section per file — fill screen + values here or in CSV)
+5. Prints coverage: apps, span, paired count
+
+If Gilbert drops a Google Drive zip, unzip first so leaf folder contains `Screenshot_*` files. Prefer `-ExportDir` over “newest Downloads folder” when multiple packs exist.
+
+**After decode:** append one JSONL row per clock-matched tip to `pairing-logs/whoop-app-labels.jsonl` with `"source":"screenshot"` (see §5).
+
+---
+
+## 3. Identify the chart (screen taxonomy)
+
+Fill `manifest.csv` `screen` with **exactly one** of these IDs (add `|note` only in `values`).
+
+### WHOOP
+
+| `screen` | Visual tells |
+|----------|----------------|
+| `whoop_home` | Three rings Sleep/Recovery/Strain; Stress Monitor **card** (e.g. 1.2 MEDIUM); My Day activities |
+| `whoop_stress_monitor` | Title **STRESS MONITOR**; big tip 0–3 + LOW/MEDIUM/HIGH; 24h jagged chart 0–3; purple “Wear … nights” bar; “You spent X hr Y min in the high stress zone” |
+| `whoop_sleep_detail` | **HOURS OF SLEEP**; HR line during sleep; Awake/Light/SWS/REM bars + % |
+| `whoop_health_monitor` | Health tiles (HR, SpO2, RHR, HRV…); often “Calibrating” |
+| `whoop_strain` / `whoop_recovery` | Strain 0–21 or Recovery % detail |
+| `whoop_other` | Anything else — describe in `values` |
+
+### NOOP
+
+| `screen` | Visual tells |
+|----------|----------------|
+| `noop_today_health` | Today tab; Health / Key Metrics; Stress as **X.X / 3** or similar row |
+| `noop_stress_hero` | Stress Monitor / Stress hero: big tip, MEDIUM of 3, Baevsky / LF/HF cards (display-only) |
+| `noop_stress_timeline` | **INTRADAY** / “Stress Through The Day”; peak · hour; Calm/Mod/High time-in-band; may sit on Trends |
+| `noop_stress_history` | **HISTORY** / Stress Trend daily proxy |
+| `noop_sleep_hero` | Sleep tab Rest gauge (e.g. 73 Strong); “What shaped Rest” |
+| `noop_sleep_stages` | Stage minutes Deep/REM/Awake/Light; honesty / no-movement strip |
+| `noop_trends` | Week charts Charge/HRV/Effort/debt |
+| `noop_other` | Describe in `values` |
+
+### Chart vs number (don’t confuse)
+
+| Looking at… | Extract |
+|-------------|---------|
+| WHOOP Stress **gauge** | `tip`, `band`, `tipClock` (time under gauge, e.g. 2:10 AM) |
+| WHOOP Stress **line** | Night floor (~0.3–0.5), wake rise, daytime plateau, activity glyph peaks, tip marker |
+| WHOOP high-zone **sentence** | `highZone` as `2h8m` style — not the tip |
+| NOOP Stress **hero** | `tip`, `band` — often “MEDIUM of 3”; Advanced HRV is **not** the tip |
+| NOOP **intraday** line | `avg`, `scoredHours`, `peak`, `peakHour`, `calmZone`, `modZone`, `highZone` |
+| Sleep **% bars** | Stage minutes + %; WHOOP SWS = Deep |
+| NOOP Rest **gauge** | Rest 0–100 + label; separate from stage table |
+
+---
+
+## 4. `values` encoding (machine-friendly)
+
+Semicolon-separated `key=val` in one cell. Use these keys when present:
+
+```text
+tip=1.4; band=MEDIUM; tipClock=22:14; calibrating=yes; calibNightsLeft=2
+highZone=2h8m; modZone=2h30m; calmZone=14h
+avg=0.8; scoredHours=18; peak=2.5; peakHour=21
+sleepPct=64; recoveryPct=43; strain=10.2
+asleep=7:06; onset=03:48; wake=13:08; deep=2:53; rem=1:32; awake=2:13; light=2:41
+rest=73; restLabel=Strong; noopAsleep=7:19; deepMin=10; remMin=0
+statusBarClock=22:14; note=health_card_not_full_monitor
+```
+
+Rules:
+
+- Prefer **statusBarClock** for tip@clock pairing.
+- If tip time on chart ≠ status bar, record both (`tipClock` + `statusBarClock`).
+- Never invent SpO2 / clinical BP from a blank tile.
+- Mark `calibrating=yes` when WHOOP/NOOP show wear-N-nights — tip is a weak tuning signal.
+
+---
+
+## 5. Three-lane compare protocol
+
+### Step A — Pair by clock
+
+From `manifest.csv`, keep rows with `pairGapS` ≤ 120 (2 min) for tip compares; ≤ 600 (10 min) for same-session inventory. Prefer pairs where both `screen` are stress-class (`whoop_stress_monitor`↔`noop_stress_hero` or `whoop_home`↔`noop_today_health`).
+
+### Step B — Tip@clock table (UI only)
+
+| Local clock | WHOOP tip/band | NOOP tip/band | \|δ\| | Sources (files) | Tag |
+|-------------|----------------|---------------|------|-----------------|-----|
+| 22:14 | 1.4 MEDIUM | 1.8 / 3 | 0.4 | whoop_… ; noop_… | fill |
+
+Pass heuristic (stress): calm LOW within ~0.3; same band for MEDIUM/HIGH; direction of spikes matches.
+
+### Step C — Band replay (required before constant changes)
+
+1. Pull Fold bank for that local day (HR, R-R, gravity, steps, sleep-state).
+2. Run `FoldStressReplay` (or sleep replay) with **hard cutoff** at the screenshot minute so calm reference matches what the live app knew.
+3. Fill: WHOOP UI tip vs **replay tip** vs NOOP UI tip.
+
+| Clock | WHOOP UI | NOOP UI | Band replay | Action |
+|-------|----------|---------|-------------|--------|
+| … | … | … | … | If UI≠replay → UI/data bug first. If replay≠WHOOP → algo candidate. |
+
+### Step D — Labels JSONL
+
+Append (one object per matched tip day/minute):
+
+```json
+{"day":"2026-07-13","source":"screenshot","stress_tip":1.4,"stress_band":"MEDIUM","clock":"22:14","whoop_file":"Screenshot_…_WHOOP.jpg","noop_file":"Screenshot_…_NOOP.jpg","noop_tip":1.8,"serial":"export:Noop-mg"}
+```
+
+Do **not** overwrite recovery/strain fields with nulls from a stress-only shot.
+
+---
+
+## 6. Improve each onward instruction (how to write backlog items)
+
+Every algorithm / UI instruction in CONTINUE or factor docs should be a **ticket**, not a vibe:
+
+| Field | Required |
+|-------|----------|
+| **ID** | Stable (`STRESS-05`, `REST-01`, `SLEEP-SELF-1`) |
+| **Symptom** | What the export showed (numbers + files) |
+| **Code pointer** | File + symbol / constant |
+| **Lane** | UI-only / replay / both |
+| **Acceptance** | Measurable (e.g. \|\|δ tip\| ≤ 0.3 on ≥4 calm anchors) |
+| **Do not** | Explicit anti-goal (e.g. “don’t retune from one calibrating tip”) |
+| **Verify** | Unit test name and/or Fold tip@clock + ingest stamp |
+
+### Stress onward (rewrite targets)
+
+| ID | Symptom | Code | Acceptance | Do not |
+|----|---------|------|------------|--------|
+| STRESS-TIP | NOOP 1.8 vs WHOOP 1.4 same minute (mg export) | `DaytimeStress` calm anchor / night bias | ≥4 tip@clock \|\|δ\|≤0.3 in MEDIUM after replay | Retune from single calibrating sample |
+| STRESS-SHAPE | Missing NOOP intraday in pack | capture S5 + compare peak/highZone | highZone within ~30% when scoredHours dense | Compare tip-only to WHOOP 24h chart |
+| STRESS-ZONE | Fri high-zone gap vs workout damp | `workoutOverlapBias` product stance | Document deliberate δ or intensity-scale damp | Blindly match WHOOP exercise-in-stress |
+| STRESS-NIGHT | Overnight quiet after bad staging | `overnightQuiet` sanity gate | Reject overnight pool when awakeFrac high | Blame same-evening tip on that night’s sleep |
+
+### Sleep / Rest onward
+
+| ID | Symptom | Code | Acceptance | Do not |
+|----|---------|------|------------|--------|
+| SLEEP-SELF-1 | Hero / stages / debt disagree same night | duration writers + debt ledger | One asleep minutes source of truth on Fold | Tune WHOOP match before self-consistency |
+| REST-WEIGHT | Rest 73 Strong with 2% deep / 0% REM | `RestScorer` / `deepFloorFactor` | Mediocre WHOOP night not labeled Strong | Invent Deep/REM |
+| SLEEP-ONSET | ~77 min early vs WHOOP | `hrOnlySleepRuns` gates | Onset within ~30 min when gravity dense; document when HR-only | Drop HR-only spine without gravity-dead nights |
+
+### Workout onward
+
+| ID | Symptom | Code | Acceptance |
+|----|---------|------|------------|
+| WORK-SIG | Re-threshold every time | `AutoWorkoutDetector` | Persist signature; re-match ≥1 prior sport class on Fold |
+
+---
+
+## 7. Agent workflow (token-cheap)
+
+1. `ingest_export.ps1 -PackKind stress|sleep|mixed -ExportDir …`
+2. Open each JPG (Read tool) → fill `screen` + `values` in `manifest.csv` / worksheet.
+3. Write tip@clock + inventory into the matching `*_FACTORS_AND_LITERATURE.md` update section.
+4. If Fold online: bank pull + replay with cutoff → three-lane table.
+5. Update `ANY_MODEL_CONTINUE.md` **last**: headline δ, ticket IDs, paste block. No code unless the session is explicitly a coding pass.
+6. Publish/APK only after self-consistency tickets (SLEEP-SELF-*) and acceptance checks land.
+
+---
+
+## 8. Known pack gaps (do not re-learn the hard way)
+
+| Pack | Gap | Next capture |
+|------|-----|--------------|
+| Noop stresd 2026-07-12 | Early NOOP Stress (pre calm-anchor era UI) | Re-capture S4+S5 on current MAIN |
+| Updated noop state 2026-07-13 | Good tip pair (~21:39); high-zone Fri/Sat not in same pack | Fri/Sat WHOOP high-zone + NOOP timeline |
+| Noop mg 2026-07-14 | Stress tip only on NOOP Health card; **no** NOOP stress chart | Always include S4+S5 |
diff --git a/pairing-logs/calibration-report.json b/pairing-logs/calibration-report.json
new file mode 100644
index 0000000000..e661ef0968
--- /dev/null
+++ b/pairing-logs/calibration-report.json
@@ -0,0 +1,75 @@
+{
+  "generated_at": "2026-07-14T03:55:23Z",
+  "accuracy_valid": false,
+  "min_n_fit": 3,
+  "n_label_rows": 3,
+  "n_pairs_total": 0,
+  "heads_fitted": 0,
+  "gpu": "none (CPU-only)",
+  "method": "affine least-squares + LOO MAE; shared 0-100 (strain \u00d7100/21)",
+  "citations_doc": "docs/CALIBRATION.md",
+  "heads": [
+    {
+      "head": "charge",
+      "n": 0,
+      "mae_before": null,
+      "mae_after_affine": null,
+      "loo_mae": null,
+      "pearson_r": null,
+      "affine_a": 1.0,
+      "affine_b": 0.0,
+      "fitted": false,
+      "within_band_frac": null,
+      "band": 12.0,
+      "days": [],
+      "citations": "Plews2013 / Banister1991 / Cole-Kripke1992 / Baevsky2008; affine per docs/CALIBRATION.md"
+    },
+    {
+      "head": "effort",
+      "n": 0,
+      "mae_before": null,
+      "mae_after_affine": null,
+      "loo_mae": null,
+      "pearson_r": null,
+      "affine_a": 1.0,
+      "affine_b": 0.0,
+      "fitted": false,
+      "within_band_frac": null,
+      "band": 15.0,
+      "days": [],
+      "citations": "Plews2013 / Banister1991 / Cole-Kripke1992 / Baevsky2008; affine per docs/CALIBRATION.md"
+    },
+    {
+      "head": "sleep",
+      "n": 0,
+      "mae_before": null,
+      "mae_after_affine": null,
+      "loo_mae": null,
+      "pearson_r": null,
+      "affine_a": 1.0,
+      "affine_b": 0.0,
+      "fitted": false,
+      "within_band_frac": null,
+      "band": 15.0,
+      "days": [],
+      "citations": "Plews2013 / Banister1991 / Cole-Kripke1992 / Baevsky2008; affine per docs/CALIBRATION.md"
+    },
+    {
+      "head": "stress",
+      "n": 0,
+      "mae_before": null,
+      "mae_after_affine": null,
+      "loo_mae": null,
+      "pearson_r": null,
+      "affine_a": 1.0,
+      "affine_b": 0.0,
+      "fitted": false,
+      "within_band_frac": null,
+      "band": 20.0,
+      "days": [],
+      "citations": "Plews2013 / Banister1991 / Cole-Kripke1992 / Baevsky2008; affine per docs/CALIBRATION.md"
+    }
+  ],
+  "deploy_gate": "FAIL - need >=3 paired days on Charge, Effort, Sleep",
+  "note": "Never invent WHOOP labels. Sparse N means gate fail, not fake high accuracy."
+}
\ No newline at end of file
diff --git a/pairing-logs/exports/20260712-Noop_stresd/REQUIRED_SHOTS.md b/pairing-logs/exports/20260712-Noop_stresd/REQUIRED_SHOTS.md
new file mode 100644
index 0000000000..f22d7bab94
--- /dev/null
+++ b/pairing-logs/exports/20260712-Noop_stresd/REQUIRED_SHOTS.md
@@ -0,0 +1,16 @@
+# Required shots - pack kind stress
+
+Playbook: docs/WHOOP_NOOP_SCREENSHOT_COMPARE.md
+Export: C:\Users\Gilbert\Downloads\Noop stresd-20260712T213610Z-2-001\Noop stresd
+Copied to: C:\Users\Gilbert\Documents\Ai app store\pairing-logs\exports\20260712-Noop_stresd
+
+| Id | Need | App | Target screen | Status |
+|----|------|-----|---------------|--------|
+| S1 | Home Stress Monitor card (tip+band) | WHOOP | whoop_home | HAVE WHOOP files (3) - assign screen=whoop_home in manifest during decode |
+| S2 | Full Stress Monitor chart + high-zone copy | WHOOP | whoop_stress_monitor | HAVE WHOOP files (3) - assign screen=whoop_stress_monitor in manifest during decode |
+| S3 | Today Health/Key Metrics stress row | NOOP | noop_today_health | HAVE NOOP files (4) - assign screen=noop_today_health in manifest during decode |
+| S4 | Stress hero Now tip | NOOP | noop_stress_hero | HAVE NOOP files (4) - assign screen=noop_stress_hero in manifest during decode |
+| S5 | Intraday timeline + time-in-band (do not skip) | NOOP | noop_stress_timeline | HAVE NOOP files (4) - assign screen=noop_stress_timeline in manifest during decode |
+
+After decode: mark each Id DONE only when a row has that screen value filled.
+Stress packs: S5 (noop_stress_timeline) was missing in Noop-mg 2026-07-14 - always capture it.
diff --git a/pairing-logs/exports/20260712-Noop_stresd/labels_stub.jsonl.example b/pairing-logs/exports/20260712-Noop_stresd/labels_stub.jsonl.example
new file mode 100644
index 0000000000..a555e6bba8
--- /dev/null
+++ b/pairing-logs/exports/20260712-Noop_stresd/labels_stub.jsonl.example
@@ -0,0 +1,3 @@
+{"day":"2026-07-12","source":"screenshot","clock":"17:34","whoop_file":"Screenshot_20260712_173402_WHOOP.jpg","noop_file":"Screenshot_20260712_173426_NOOP.jpg","stress_tip":null,"stress_band":null,"noop_tip":null,"serial":"export:20260712-Noop_stresd"}
+{"day":"2026-07-12","source":"screenshot","clock":"17:34","whoop_file":"Screenshot_20260712_173405_WHOOP.jpg","noop_file":"Screenshot_20260712_173426_NOOP.jpg","stress_tip":null,"stress_band":null,"noop_tip":null,"serial":"export:20260712-Noop_stresd"}
+{"day":"2026-07-12","source":"screenshot","clock":"17:34","whoop_file":"Screenshot_20260712_173412_WHOOP.jpg","noop_file":"Screenshot_20260712_173426_NOOP.jpg","stress_tip":null,"stress_band":null,"noop_tip":null,"serial":"export:20260712-Noop_stresd"}
diff --git a/pairing-logs/exports/20260712-Noop_stresd/manifest.csv b/pairing-logs/exports/20260712-Noop_stresd/manifest.csv
new file mode 100644
index 0000000000..bae2a7305c
--- /dev/null
+++ b/pairing-logs/exports/20260712-Noop_stresd/manifest.csv
@@ -0,0 +1,8 @@
+"file","app","captured","screen","values","pairFile","pairGapS"
+"Screenshot_20260712_172958_NOOP.jpg","NOOP","2026-07-12 17:29:58","noop_stress_hero","tip=1.9;band=MEDIUM;statusBarClock=17:29","Screenshot_20260712_173402_WHOOP.jpg","244"
+"Screenshot_20260712_173126_NOOP.jpg","NOOP","2026-07-12 17:31:26","noop_stress_hero","tip=1.9;band=MEDIUM;baevskySI=8;lfhf=1.7;statusBarClock=17:31","Screenshot_20260712_173402_WHOOP.jpg","156"
+"Screenshot_20260712_173402_WHOOP.jpg","WHOOP","2026-07-12 17:34:02","whoop_stress_monitor","tip=0.5;band=LOW;tipClock=02:10;day=FRI Jul10;highZone=2h8m;statusBarClock=17:34","Screenshot_20260712_173426_NOOP.jpg","24"
+"Screenshot_20260712_173405_WHOOP.jpg","WHOOP","2026-07-12 17:34:05","whoop_stress_monitor","tip=0.5;band=LOW;tipClock=02:10;highZone=2h8m;statusBarClock=17:34","Screenshot_20260712_173426_NOOP.jpg","21"
+"Screenshot_20260712_173412_WHOOP.jpg","WHOOP","2026-07-12 17:34:12","whoop_stress_monitor","day=FRI Jul10;highZone=2h8m;chart=daytime peaks;statusBarClock=17:34","Screenshot_20260712_173426_NOOP.jpg","14"
+"Screenshot_20260712_173426_NOOP.jpg","NOOP","2026-07-12 17:34:26","noop_stress_hero","tip=1.9;band=MEDIUM;baevskySI=8;lfhf=1.7;intradayAvg=2.3;statusBarClock=17:34","Screenshot_20260712_173412_WHOOP.jpg","14"
+"Screenshot_20260712_173433_NOOP.jpg","NOOP","2026-07-12 17:34:33","noop_stress_hero","tip=1.9;band=MEDIUM;statusBarClock=17:34","Screenshot_20260712_173412_WHOOP.jpg","21"
diff --git a/pairing-logs/exports/20260713-Noop_mg/REQUIRED_SHOTS.md b/pairing-logs/exports/20260713-Noop_mg/REQUIRED_SHOTS.md
new file mode 100644
index 0000000000..9bce19e397
--- /dev/null
+++ b/pairing-logs/exports/20260713-Noop_mg/REQUIRED_SHOTS.md
@@ -0,0 +1,17 @@
+# Required shots - pack kind mixed
+
+Playbook: docs/WHOOP_NOOP_SCREENSHOT_COMPARE.md
+Export: C:\Users\Gilbert\Downloads\Noop mg-20260714T022949Z-1-001\Noop mg
+Copied to: C:\Users\Gilbert\Documents\Ai app store\pairing-logs\exports\20260713-Noop_mg
+
+| Id | Need | App | Target screen | Status |
+|----|------|-----|---------------|--------|
+| M1 | Home rings + Stress card | WHOOP | whoop_home | HAVE WHOOP files (7) - assign screen=whoop_home in manifest during decode |
+| M2 | Stress Monitor if comparing stress | WHOOP | whoop_stress_monitor | HAVE WHOOP files (7) - assign screen=whoop_stress_monitor in manifest during decode |
+| M3 | Sleep detail if comparing Rest | WHOOP | whoop_sleep_detail | HAVE WHOOP files (7) - assign screen=whoop_sleep_detail in manifest during decode |
+| M4 | Today Health row | NOOP | noop_today_health | HAVE NOOP files (9) - assign screen=noop_today_health in manifest during decode |
+| M5 | NOOP stress chart (often missing) | NOOP | noop_stress_timeline | HAVE NOOP files (9) - assign screen=noop_stress_timeline in manifest during decode |
+| M6 | Sleep Rest hero | NOOP | noop_sleep_hero | HAVE NOOP files (9) - assign screen=noop_sleep_hero in manifest during decode |
+
+After decode: mark each Id DONE only when a row has that screen value filled.
+Stress packs: S5 (noop_stress_timeline) was missing in Noop-mg 2026-07-14 - always capture it.
diff --git a/pairing-logs/exports/20260713-Noop_mg/labels_stub.jsonl.example b/pairing-logs/exports/20260713-Noop_mg/labels_stub.jsonl.example
new file mode 100644
index 0000000000..fa7d436cd8
--- /dev/null
+++ b/pairing-logs/exports/20260713-Noop_mg/labels_stub.jsonl.example
@@ -0,0 +1,7 @@
+{"day":"2026-07-13","source":"screenshot","clock":"22:14","whoop_file":"Screenshot_20260713_221450_WHOOP.jpg","noop_file":"Screenshot_20260713_221541_NOOP.jpg","stress_tip":null,"stress_band":null,"noop_tip":null,"serial":"export:20260713-Noop_mg"}
+{"day":"2026-07-13","source":"screenshot","clock":"22:14","whoop_file":"Screenshot_20260713_221457_WHOOP.jpg","noop_file":"Screenshot_20260713_221541_NOOP.jpg","stress_tip":null,"stress_band":null,"noop_tip":null,"serial":"export:20260713-Noop_mg"}
+{"day":"2026-07-13","source":"screenshot","clock":"22:15","whoop_file":"Screenshot_20260713_221505_WHOOP.jpg","noop_file":"Screenshot_20260713_221541_NOOP.jpg","stress_tip":null,"stress_band":null,"noop_tip":null,"serial":"export:20260713-Noop_mg"}
+{"day":"2026-07-13","source":"screenshot","clock":"22:15","whoop_file":"Screenshot_20260713_221509_WHOOP.jpg","noop_file":"Screenshot_20260713_221541_NOOP.jpg","stress_tip":null,"stress_band":null,"noop_tip":null,"serial":"export:20260713-Noop_mg"}
+{"day":"2026-07-13","source":"screenshot","clock":"22:15","whoop_file":"Screenshot_20260713_221517_WHOOP.jpg","noop_file":"Screenshot_20260713_221541_NOOP.jpg","stress_tip":null,"stress_band":null,"noop_tip":null,"serial":"export:20260713-Noop_mg"}
+{"day":"2026-07-13","source":"screenshot","clock":"22:15","whoop_file":"Screenshot_20260713_221522_WHOOP.jpg","noop_file":"Screenshot_20260713_221541_NOOP.jpg","stress_tip":null,"stress_band":null,"noop_tip":null,"serial":"export:20260713-Noop_mg"}
+{"day":"2026-07-13","source":"screenshot","clock":"22:26","whoop_file":"Screenshot_20260713_222622_WHOOP.jpg","noop_file":"Screenshot_20260713_222725_NOOP.jpg","stress_tip":null,"stress_band":null,"noop_tip":null,"serial":"export:20260713-Noop_mg"}
diff --git a/pairing-logs/exports/20260713-Noop_mg/manifest.csv b/pairing-logs/exports/20260713-Noop_mg/manifest.csv
new file mode 100644
index 0000000000..2d13fda218
--- /dev/null
+++ b/pairing-logs/exports/20260713-Noop_mg/manifest.csv
@@ -0,0 +1,17 @@
+"file","app","captured","screen","values","pairFile","pairGapS"
+"Screenshot_20260713_221450_WHOOP.jpg","WHOOP","2026-07-13 22:14:50","whoop_home","sleep_pct=64;recovery_pct=43;strain_021=10.2;stress_tip=1.2;band=MEDIUM;calibrating=true;asleep=7:06;statusBarClock=22:14","Screenshot_20260713_221541_NOOP.jpg","51"
+"Screenshot_20260713_221457_WHOOP.jpg","WHOOP","2026-07-13 22:14:57","whoop_stress_monitor","tip=1.4;band=MEDIUM;tipClock=22:14;statusBarClock=22:14","Screenshot_20260713_221541_NOOP.jpg","44"
+"Screenshot_20260713_221505_WHOOP.jpg","WHOOP","2026-07-13 22:15:05","whoop_stress_monitor","tip=1.4;band=MEDIUM;tipClock=22:14;statusBarClock=22:15","Screenshot_20260713_221541_NOOP.jpg","36"
+"Screenshot_20260713_221509_WHOOP.jpg","WHOOP","2026-07-13 22:15:09","whoop_home","sleep_pct=64;recovery_pct=43;strain_021=10.2;statusBarClock=22:15","Screenshot_20260713_221541_NOOP.jpg","32"
+"Screenshot_20260713_221517_WHOOP.jpg","WHOOP","2026-07-13 22:15:17","whoop_sleep_detail","asleep=7:06;start=03:48;end=13:08;statusBarClock=22:15","Screenshot_20260713_221541_NOOP.jpg","24"
+"Screenshot_20260713_221522_WHOOP.jpg","WHOOP","2026-07-13 22:15:22","whoop_home","sleep_pct=64;recovery_pct=43;strain_021=10.2;statusBarClock=22:15","Screenshot_20260713_221541_NOOP.jpg","19"
+"Screenshot_20260713_221541_NOOP.jpg","NOOP","2026-07-13 22:15:41","noop_sleep_hero","rest=73;band=Strong;asleep=8h37m;deepRemPct=2;efficiency=69;statusBarClock=22:15","Screenshot_20260713_221522_WHOOP.jpg","19"
+"Screenshot_20260713_221546_NOOP.jpg","NOOP","2026-07-13 22:15:46","noop_sleep_stages","asleep=7h19m;deep=2pct;rem=0pct;light=67pct;awake=31pct;efficiency=69;statusBarClock=22:15","Screenshot_20260713_221522_WHOOP.jpg","24"
+"Screenshot_20260713_221551_NOOP.jpg","NOOP","2026-07-13 22:15:51","noop_sleep_stages","deep=2pct;rem=0pct;statusBarClock=22:15","Screenshot_20260713_221522_WHOOP.jpg","29"
+"Screenshot_20260713_221556_NOOP.jpg","NOOP","2026-07-13 22:15:56","noop_today","charge=47;effort=29;rest=73;statusBarClock=22:15","Screenshot_20260713_221522_WHOOP.jpg","34"
+"Screenshot_20260713_221604_NOOP.jpg","NOOP","2026-07-13 22:16:04","noop_today_health","stress_tip=1.8;band=MEDIUM;hr=85;hrv=50;spo2=98;charge=47;effort=29;rest=73;statusBarClock=22:16","Screenshot_20260713_221522_WHOOP.jpg","42"
+"Screenshot_20260713_221611_NOOP.jpg","NOOP","2026-07-13 22:16:11","noop_today","charge=47;effort=29;rest=73;hrAvg=86;hrv=50;rhr=56;resp=19.4;statusBarClock=22:16","Screenshot_20260713_221522_WHOOP.jpg","49"
+"Screenshot_20260713_221615_NOOP.jpg","NOOP","2026-07-13 22:16:15","noop_today","statusBarClock=22:16","Screenshot_20260713_221522_WHOOP.jpg","53"
+"Screenshot_20260713_221619_NOOP.jpg","NOOP","2026-07-13 22:16:19","noop_today","statusBarClock=22:16","Screenshot_20260713_221522_WHOOP.jpg","57"
+"Screenshot_20260713_222622_WHOOP.jpg","WHOOP","2026-07-13 22:26:22","whoop_sleep_detail","asleep=7:06;awake=23pct;light=28pct;sws=33pct;rem=16pct;restorative=4:25;statusBarClock=22:26","Screenshot_20260713_222725_NOOP.jpg","63"
+"Screenshot_20260713_222725_NOOP.jpg","NOOP","2026-07-13 22:27:25","noop_sleep_stages","deep=2pct;rem=0pct;statusBarClock=22:27","Screenshot_20260713_222622_WHOOP.jpg","63"
diff --git a/pairing-logs/goals-from-ml.json b/pairing-logs/goals-from-ml.json
new file mode 100644
index 0000000000..48f2b04aad
--- /dev/null
+++ b/pairing-logs/goals-from-ml.json
@@ -0,0 +1,11 @@
+{
+  "G1_auto_labels": "PARTIAL",
+  "G2_compare_app": "PARTIAL",
+  "G4_sleep_kappa": "NOT_DONE",
+  "G5_ml_train": "NOT_DONE",
+  "feature_days_ready": 0,
+  "label_rows": 2,
+  "paired_days": 1,
+  "accuracy_valid": false,
+  "message": "Underfit \u2014 need more distinct labeled days."
+}
\ No newline at end of file
diff --git a/pairing-logs/golden/README.md b/pairing-logs/golden/README.md
new file mode 100644
index 0000000000..4fd7335daf
--- /dev/null
+++ b/pairing-logs/golden/README.md
@@ -0,0 +1,26 @@
+# Golden pairing-logs subset
+
+Checked into the stress/sleep ML reproduce PR so another engineer can recreate results
+without the full BLE dump or every JPG.
+
+## Included
+
+| File | Purpose |
+|------|---------|
+| `../whoop-app-labels.jsonl` | Real labels (adb + screenshot decode) |
+| `../exports/20260712-Noop_stresd/manifest.csv` | Decoded stress pack |
+| `../exports/20260713-Noop_mg/manifest.csv` | Decoded mg stress+sleep pack |
+| `../exports/*/REQUIRED_SHOTS.md` | Coverage vs capture checklist |
+| `../exports/*/labels_stub.jsonl.example` | JSONL shape for new packs |
+| `../stress-sleep-train-status.json` | Last orchestrator run (regenerate anytime) |
+| `../ml-stress-tip-weights.json` | Stress tip affine weights |
+| `../sleep-stage-eval.json` | Sleep stage bench output |
+| `../ml-engine-status.json` | Effort→strain status |
+
+## Excluded (rebuild scripts)
+
+- Full screenshot JPGs → `Tools/ingest_export.ps1`
+- `ml-samples.jsonl` / `noop-pairing-log.txt` → Fold collectors when phone is on
+- sleep-accel dataset → `docs/SLEEP_ML_DATASETS.md`
+
+See `docs/STRESS_SLEEP_ML_REPRO.md`.
diff --git a/pairing-logs/ml-daily-features.json b/pairing-logs/ml-daily-features.json
new file mode 100644
index 0000000000..d6405fbb7a
--- /dev/null
+++ b/pairing-logs/ml-daily-features.json
@@ -0,0 +1,6 @@
+{
+  "days": {},
+  "n_days": 0,
+  "completed_before": "2026-07-14",
+  "note": "Current and future days are excluded until their local day completes."
+}
\ No newline at end of file
diff --git a/pairing-logs/ml-effort-weights.json b/pairing-logs/ml-effort-weights.json
new file mode 100644
index 0000000000..63741377b2
--- /dev/null
+++ b/pairing-logs/ml-effort-weights.json
@@ -0,0 +1,31 @@
+{
+  "version": "0.2.0-linear+ridge",
+  "linear": {
+    "a": 0.30181086519114697,
+    "b": 39.8189134808853,
+    "formula": "app_strain_pct_hat = a * noop_effort + b"
+  },
+  "ridge": {
+    "feature_names": [
+      "mean_hr/100",
+      "frac_hr_ge_100",
+      "frac_hr_ge_130",
+      "rr_rmssd/100",
+      "effort_proxy/100"
+    ],
+    "weights": [
+      19.785618634132945,
+      4.365983891114025,
+      0.0,
+      9.699799440610724,
+      11.9194900481726
+    ],
+    "bias": 30.04434734192379,
+    "rmse": 0.18331323375347489
+  },
+  "n_pairs": 2,
+  "rmse_linear": 0.0,
+  "mae": 0.0,
+  "pass_score": 100.0,
+  "accuracy_valid": false
+}
\ No newline at end of file
diff --git a/pairing-logs/ml-engine-status.json b/pairing-logs/ml-engine-status.json
new file mode 100644
index 0000000000..b4ae71127c
--- /dev/null
+++ b/pairing-logs/ml-engine-status.json
@@ -0,0 +1,37 @@
+{
+  "accuracy_valid": false,
+  "n_label_rows": 2,
+  "n_completed_label_rows": 2,
+  "n_excluded_current_or_future_labels": 0,
+  "n_pairs": 1,
+  "n_feature_days": 0,
+  "n_ml_samples_ingested": 0,
+  "completed_before": "2026-07-14",
+  "future_day_guard": "Current local day and future dates are excluded until their day has completed.",
+  "feature_store": "pairing-logs\\ml-daily-features.json",
+  "sport_session_feature_store": "pairing-logs\\ml-sport-session-features.json",
+  "n_sport_labels": 0,
+  "n_sport_sessions_eligible": 0,
+  "goals": {
+    "G1_auto_labels": "PARTIAL",
+    "G2_compare_app": "PARTIAL",
+    "G4_sleep_kappa": "NOT_DONE",
+    "G5_ml_train": "NOT_DONE",
+    "feature_days_ready": 0,
+    "label_rows": 2,
+    "paired_days": 1,
+    "accuracy_valid": false,
+    "message": "Underfit \u2014 need more distinct labeled days."
+  },
+  "next_actions": [
+    "Enable Accessibility NOOP WHOOP app capture; open WHOOP daily",
+    "Or run Tools/whoop_app_adb_capture.ps1 with wireless adb",
+    "Append JSONL {day, strain_021, recovery_pct, noop_effort?} to pairing-logs/whoop-app-labels.jsonl",
+    "Re-run this script after \u22653 distinct labeled days for accuracy_valid",
+    "For sleep \u03ba: download sleep-accel \u2192 Tools/sleep_stage_eval.py (G4)",
+    "Save and correct real workouts in NOOP debug builds to collect user-confirmed sport windows; this pipeline does not classify sports yet."
+  ],
+  "honest_rule": "Never treat pipeline HR collect or synthetic eval as model accuracy vs WHOOP app.",
+  "status": "NOT_READY",
+  "message": "Built 0 day(s) of features from BLE samples. Need \u22652 days of WHOOP **app** Strain labels to fit Effort\u2192Strain. Do NOT treat synthetic/pipeline pass as model accuracy."
+}
\ No newline at end of file
diff --git a/pairing-logs/ml-sport-session-features.json b/pairing-logs/ml-sport-session-features.json
new file mode 100644
index 0000000000..82a48dca55
--- /dev/null
+++ b/pairing-logs/ml-sport-session-features.json
@@ -0,0 +1,8 @@
+{
+  "sessions": [],
+  "n_labels": 0,
+  "n_eligible": 0,
+  "completed_before": "2026-07-14",
+  "status": "COLLECTING_ONLY",
+  "note": "User-confirmed sport labels joined to open-BLE samples. No sport classifier or accuracy claim is produced here."
+}
\ No newline at end of file
diff --git a/pairing-logs/ml-stress-tip-weights.json b/pairing-logs/ml-stress-tip-weights.json
new file mode 100644
index 0000000000..6808b9d597
--- /dev/null
+++ b/pairing-logs/ml-stress-tip-weights.json
@@ -0,0 +1,16 @@
+{
+  "version": "0.1.0-stress-tip-affine",
+  "generated_at": "2026-07-14T03:55:23Z",
+  "formula": "whoop_tip_hat = a * noop_tip + b",
+  "a": 1.0,
+  "b": 0.0,
+  "n_pairs": 1,
+  "mae_before": 0.40000000000000013,
+  "mae_after": 0.40000000000000013,
+  "accuracy_valid": false,
+  "citations": [
+    "docs/STRESS_FACTORS_AND_LITERATURE.md",
+    "docs/WHOOP_NOOP_SCREENSHOT_COMPARE.md",
+    "docs/STRESS_SLEEP_ML_REPRO.md"
+  ]
+}
\ No newline at end of file
diff --git a/pairing-logs/sleep-stage-eval.json b/pairing-logs/sleep-stage-eval.json
new file mode 100644
index 0000000000..781522db64
--- /dev/null
+++ b/pairing-logs/sleep-stage-eval.json
@@ -0,0 +1,76 @@
+{
+  "mode": "synthetic",
+  "accuracy_valid": false,
+  "goal_G4": "NOT_DONE",
+  "note": "No public dataset on disk \u2014 metrics plumbing only. Do NOT cite these \u03ba/acc as product accuracy. Download PhysioNet sleep-accel \u2192 re-run for real LOSO \u03ba (G4).",
+  "results": [
+    {
+      "name": "heuristic_hr_motion",
+      "n_epochs": 300,
+      "accuracy": 1.0,
+      "cohen_kappa": 1.0,
+      "f1": {
+        "wake": 1.0,
+        "light": 1.0,
+        "deep": 1.0,
+        "rem": 1.0
+      },
+      "label_hist": {
+        "wake": 30,
+        "light": 180,
+        "deep": 40,
+        "rem": 50
+      },
+      "pred_hist": {
+        "wake": 30,
+        "light": 180,
+        "deep": 40,
+        "rem": 50
+      }
+    },
+    {
+      "name": "mini_ml_lane_synthetic",
+      "n_epochs": 300,
+      "accuracy": 0.4,
+      "cohen_kappa": 0.3059,
+      "f1": {
+        "wake": 1.0,
+        "light": 0.0,
+        "deep": 0.3077,
+        "rem": 1.0
+      },
+      "label_hist": {
+        "wake": 30,
+        "light": 180,
+        "deep": 40,
+        "rem": 50
+      },
+      "pred_hist": {
+        "wake": 30,
+        "deep": 220,
+        "rem": 50
+      }
+    },
+    {
+      "name": "majority_baseline",
+      "n_epochs": 300,
+      "accuracy": 0.6,
+      "cohen_kappa": 0.0,
+      "f1": {
+        "wake": 0.0,
+        "light": 0.75,
+        "deep": 0.0,
+        "rem": 0.0
+      },
+      "label_hist": {
+        "wake": 30,
+        "light": 180,
+        "deep": 40,
+        "rem": 50
+      },
+      "pred_hist": {
+        "light": 300
+      }
+    }
+  ]
+}
\ No newline at end of file
diff --git a/pairing-logs/stress-sleep-train-status.json b/pairing-logs/stress-sleep-train-status.json
new file mode 100644
index 0000000000..c948b1db64
--- /dev/null
+++ b/pairing-logs/stress-sleep-train-status.json
@@ -0,0 +1,115 @@
+{
+  "generated_at": "2026-07-14T03:55:23Z",
+  "host_hint": "Prefer Tailscale SSH Host desk (CPU affine; AMD GPU idle is fine)",
+  "pairing": "pairing-logs",
+  "n_label_rows": 3,
+  "stress_tip": {
+    "n": 1,
+    "mae_before": 0.40000000000000013,
+    "mae_after_affine": 0.40000000000000013,
+    "affine_a": 1.0,
+    "affine_b": 0.0,
+    "fitted": false,
+    "accuracy_valid": false,
+    "same_band_frac": 1.0,
+    "scale": "WHOOP/NOOP stress tip 0-3",
+    "pairs": [
+      {
+        "day": "2026-07-13",
+        "clock": "22:14",
+        "whoop_tip": 1.4,
+        "noop_tip": 1.8,
+        "delta": 0.4,
+        "whoop_band": "MEDIUM",
+        "noop_band": "MEDIUM",
+        "source": "screenshot",
+        "serial": "export:20260713-Noop_mg",
+        "whoop_file": "Screenshot_20260713_221457_WHOOP.jpg",
+        "noop_file": "Screenshot_20260713_221604_NOOP.jpg"
+      }
+    ],
+    "honest_rule": "accuracy_valid only with \u22654 tip@clock pairs and \u226575% same band. Do not retune DaytimeStress constants from a single \u03b4."
+  },
+  "sleep_rest": {
+    "n": 1,
+    "mae_before": 9.0,
+    "pairs": [
+      {
+        "day": "2026-07-13",
+        "whoop_sleep_pct": 64.0,
+        "noop_rest": 73.0,
+        "delta": 9.0,
+        "whoop_sws_pct": 33,
+        "whoop_rem_pct": 16,
+        "noop_deep_pct": 2,
+        "noop_rem_pct": 0,
+        "source": "screenshot",
+        "serial": "export:20260713-Noop_mg"
+      }
+    ],
+    "note": "Rest (NOOP) vs Sleep% (WHOOP) are related but not identical scales. Use for trend checks; RestScorer tickets live in SLEEP_FACTORS / Fable backlog.",
+    "accuracy_valid": false,
+    "fitted": false
+  },
+  "weights_file": "pairing-logs/ml-stress-tip-weights.json",
+  "subprocess": {
+    "sleep_stage_eval": {
+      "ok": true,
+      "returncode": 0,
+      "cmd": [
+        "C:\\Python314\\python.exe",
+        "Tools\\sleep_stage_eval.py",
+        "--synthetic"
+      ],
+      "stdout_tail": "{\n  \"mode\": \"synthetic\",\n  \"accuracy_valid\": false,\n  \"goal_G4\": \"NOT_DONE\",\n  \"note\": \"No public dataset on disk \\u2014 metrics plumbing only. Do NOT cite these \\u03ba/acc as product accuracy. Download PhysioNet sleep-accel \\u2192 re-run for real LOSO \\u03ba (G4).\",\n  \"results\": [\n    {\n      \"name\": \"heuristic_hr_motion\",\n      \"n_epochs\": 300,\n      \"accuracy\": 1.0,\n      \"cohen_kappa\": 1.0,\n      \"f1\": {\n        \"wake\": 1.0,\n        \"light\": 1.0,\n        \"deep\": 1.0,\n        \"rem\": 1.0\n      },\n      \"label_hist\": {\n        \"wake\": 30,\n        \"light\": 180,\n        \"deep\": 40,\n        \"rem\": 50\n      },\n      \"pred_hist\": {\n        \"wake\": 30,\n        \"light\": 180,\n        \"deep\": 40,\n        \"rem\": 50\n      }\n    },\n    {\n      \"name\": \"mini_ml_lane_synthetic\",\n      \"n_epochs\": 300,\n      \"accuracy\": 0.4,\n      \"cohen_kappa\": 0.3059,\n      \"f1\": {\n        \"wake\": 1.0,\n        \"light\": 0.0,\n        \"deep\": 0.3077,\n        \"rem\": 1.0\n      },\n      \"label_hist\": {\n        \"wake\": 30,\n        \"light\": 180,\n        \"deep\": 40,\n        \"rem\": 50\n      },\n      \"pred_hist\": {\n        \"wake\": 30,\n        \"deep\": 220,\n        \"rem\": 50\n      }\n    },\n    {\n      \"name\": \"majority_baseline\",\n      \"n_epochs\": 300,\n      \"accuracy\": 0.6,\n      \"cohen_kappa\": 0.0,\n      \"f1\": {\n        \"wake\": 0.0,\n        \"light\": 0.75,\n        \"deep\": 0.0,\n        \"rem\": 0.0\n      },\n      \"label_hist\": {\n        \"wake\": 30,\n        \"light\": 180,\n        \"deep\": 40,\n        \"rem\": 50\n      },\n      \"pred_hist\": {\n        \"light\": 300\n      }\n    }\n  ]\n}\n\nWrote pairing-logs\\sleep-stage-eval.json\n",
+      "stderr_tail": ""
+    },
+    "ml_engine_train": {
+      "ok": true,
+      "returncode": 0,
+      "cmd": [
+        "C:\\Python314\\python.exe",
+        "Tools\\ml_engine_train.py",
+        "--labels",
+        "pairing-logs\\whoop-app-labels.jsonl",
+        "--as-of",
+        "2026-07-14"
+      ],
+      "stdout_tail": "ture dates are excluded until their day has completed.\",\n  \"feature_store\": \"C:\\\\Users\\\\Gilbert\\\\Documents\\\\Ai app store\\\\_wt_ml_repro\\\\pairing-logs\\\\ml-daily-features.json\",\n  \"sport_session_feature_store\": \"C:\\\\Users\\\\Gilbert\\\\Documents\\\\Ai app store\\\\_wt_ml_repro\\\\pairing-logs\\\\ml-sport-session-features.json\",\n  \"n_sport_labels\": 0,\n  \"n_sport_sessions_eligible\": 0,\n  \"goals\": {\n    \"G1_auto_labels\": \"PARTIAL\",\n    \"G2_compare_app\": \"PARTIAL\",\n    \"G4_sleep_kappa\": \"NOT_DONE\",\n    \"G5_ml_train\": \"NOT_DONE\",\n    \"feature_days_ready\": 0,\n    \"label_rows\": 2,\n    \"paired_days\": 1,\n    \"accuracy_valid\": false,\n    \"message\": \"Underfit \\u2014 need more distinct labeled days.\"\n  },\n  \"next_actions\": [\n    \"Enable Accessibility NOOP WHOOP app capture; open WHOOP daily\",\n    \"Or run Tools/whoop_app_adb_capture.ps1 with wireless adb\",\n    \"Append JSONL {day, strain_021, recovery_pct, noop_effort?} to pairing-logs/whoop-app-labels.jsonl\",\n    \"Re-run this script after \\u22653 distinct labeled days for accuracy_valid\",\n    \"For sleep \\u03ba: download sleep-accel \\u2192 Tools/sleep_stage_eval.py (G4)\",\n    \"Save and correct real workouts in NOOP debug builds to collect user-confirmed sport windows; this pipeline does not classify sports yet.\"\n  ],\n  \"honest_rule\": \"Never treat pipeline HR collect or synthetic eval as model accuracy vs WHOOP app.\",\n  \"status\": \"NOT_READY\",\n  \"message\": \"Built 0 day(s) of features from BLE samples. Need \\u22652 days of WHOOP **app** Strain labels to fit Effort\\u2192Strain. Do NOT treat synthetic/pipeline pass as model accuracy.\"\n}\nWrote pairing-logs\\ml-engine-status.json\nWrote pairing-logs\\ml-daily-features.json (0 days)\nWrote pairing-logs\\ml-sport-session-features.json (0 user-confirmed sessions)\nWrote pairing-logs\\goals-from-ml.json\n",
+      "stderr_tail": ""
+    },
+    "calibrate_whoop_noop": {
+      "ok": true,
+      "returncode": 0,
+      "cmd": [
+        "C:\\Python314\\python.exe",
+        "Tools\\calibrate_whoop_noop.py",
+        "--pairing",
+        "pairing-logs"
+      ],
+      "stdout_tail": "| Head | N | MAE before | MAE after affine | Pearson r | Fitted |\n|------|---|------------|------------------|-----------|--------|\n| charge | 0 | - | - | - | False |\n| effort | 0 | - | - | - | False |\n| sleep | 0 | - | - | - | False |\n| stress | 0 | - | - | - | False |\n\naccuracy_valid=False  deploy_gate=FAIL - need >=3 paired days on Charge, Effort, Sleep\nwrote pairing-logs\\calibration-report.json\n",
+      "stderr_tail": ""
+    }
+  },
+  "fold_status": "Fold plugged-in but powered OFF this session \u2014 no live USB ADB, tip@clock, bank pull, or live-edit. Device verification deferred until phone is on.",
+  "factor_docs": [
+    "docs/STRESS_FACTORS_AND_LITERATURE.md",
+    "docs/SLEEP_FACTORS_AND_LITERATURE.md",
+    "docs/SLEEP_ML_DATASETS.md",
+    "docs/WHOOP_NOOP_SCREENSHOT_COMPARE.md",
+    "docs/FABLE5_300_NOT_INTUITIVE.md"
+  ],
+  "tickets": [
+    "STRESS-TIP",
+    "STRESS-SHAPE",
+    "REST-WEIGHT",
+    "SLEEP-SELF-1",
+    "G4_sleep_kappa"
+  ],
+  "next": [
+    "Decode more tip@clock pairs (\u22654) before touching DaytimeStress constants",
+    "Download PhysioNet sleep-accel \u2192 python Tools/sleep_stage_eval.py --sleep-accel-dir \u2026",
+    "When Fold is on: bank pull + FoldStressReplay with screenshot cutoff"
+  ],
+  "honest_rule": "Never invent SpO2/BP/clinical stages. accuracy_valid stays false until N gates pass."
+}
\ No newline at end of file
diff --git a/pairing-logs/whoop-app-labels.jsonl b/pairing-logs/whoop-app-labels.jsonl
new file mode 100644
index 0000000000..0b11615b56
--- /dev/null
+++ b/pairing-logs/whoop-app-labels.jsonl
@@ -0,0 +1,3 @@
+{"serial":"192.168.1.128:5555","source":"adb_ui","day":"2026-07-10","strain_021":14.7,"recovery_pct":null,"sleep_pct":null,"detail":"ui-20260710-220127-192.168.1.128_5555.xml"}
+{"day":"2026-07-10","source":"screenshot","clock":"02:10","tip_clock_matched":false,"stress_tip":0.5,"stress_band":"LOW","high_zone_min":128,"whoop_file":"Screenshot_20260712_173402_WHOOP.jpg","noop_tip":1.9,"noop_band":"MEDIUM","noop_file":"Screenshot_20260712_173426_NOOP.jpg","serial":"export:20260712-Noop_stresd","note":"WHOOP scrubber at Fri Jul10 2:10AM LOW 0.5 + high-zone 2h8m; NOOP tip is live 5:34PM same export session — NOT tip@clock. Use for high-zone / shape inventory only."}
+{"day":"2026-07-13","source":"screenshot","clock":"22:14","tip_clock_matched":true,"stress_tip":1.4,"stress_band":"MEDIUM","noop_tip":1.8,"noop_band":"MEDIUM","whoop_file":"Screenshot_20260713_221457_WHOOP.jpg","noop_file":"Screenshot_20260713_221604_NOOP.jpg","serial":"export:20260713-Noop_mg","sleep_pct":64,"recovery_pct":43,"strain_021":10.2,"noop_rest":73,"noop_effort":29,"noop_charge":47,"whoop_asleep":"7:06","whoop_asleep_start":"03:48","whoop_asleep_end":"13:08","whoop_sws_pct":33,"whoop_rem_pct":16,"whoop_light_pct":28,"whoop_awake_pct":23,"noop_deep_pct":2,"noop_rem_pct":0,"noop_light_pct":67,"noop_awake_pct":31,"noop_asleep":"7h19m","noop_efficiency_pct":69,"tickets":["STRESS-TIP","REST-WEIGHT","SLEEP-SELF-1"]}