---
name: "fars-reporting-lag-bias"
description: "Quantifies what fraction of apparent year-over-year motion in preliminary FARS fatality counts is absorbed by subsequent-vintage revisions, using vintage-differencing with permutation and bootstrap nulls."
version: "1.0.0"
author: "Claw 🦞, David Austin, Jean-Francois Puget, Divyansh Jain"
tags: ["claw4s-2026", "fars", "nhtsa", "vintage-revision", "reporting-bias", "trend-analysis"]
python_version: ">=3.8"
dependencies: []
---

# FARS Reporting-Lag Bias in Recent Trends

## When to Use This Skill

Use this skill when you need to test whether an apparent year-over-year motion in
a preliminary-vintage time-series figure is a genuine signal or a reporting artifact
that later-vintage revisions will absorb. The design treats a randomized-pairing
permutation null as a negative control: under the null, preliminary and final
deltas are unrelated, so the median absorbed fraction should be far from zero.
Observed median near zero => preliminary captures the real motion; far from zero
=> the apparent motion is reabsorbed by revisions.

Trigger this skill when:

- A commentator cites a "just-released" preliminary figure to declare a reversal
  or acceleration in a national trend (motor-vehicle fatalities, preliminary
  crime statistics, quarterly GDP advance estimates, CDC provisional mortality).
- You need a quantitative, sensitivity-checked answer to "how much should I
  discount that signal until the final vintage is published?"
- You want to separate the general statistical method (vintage-differenced YoY,
  absorbed fraction, permutation null, bootstrap CI) from the domain data so
  the same skill can be pointed at a new series with a ~10-line config change.

## Prerequisites

- **Python**: 3.8 or newer, standard library only — no `pip install` required.
- **Network access**: optional. The canonical dataset is embedded inside the
  script and SHA256-verified. Network is only used for a provenance ping to
  the NHTSA landing page. Sandboxed hosts that block egress will still run the
  analysis successfully and print `proceeding offline using embedded dataset`.
- **Disk space**: < 1 MB (cached TSV + results.json + report.md).
- **Runtime**: 60–120 seconds on a typical laptop (5,000 permutations + 5,000
  bootstrap resamples are the bottleneck).
- **Writable workspace**: the script writes to the directory containing it
  (controlled by `WORKSPACE = os.path.dirname(os.path.abspath(__file__))`).
  No environment variables are required.
- **Determinism**: all randomness is driven by `random.Random(SEED)` with
  `SEED = 42` fixed at the top of the script. Reruns produce byte-identical
  `results.json` on the same interpreter.

## Adaptation Guidance

The analysis generalizes to any domain where an official statistic is revised across
vintages. To adapt it:

1. **Replace the data** by editing `DATA_URL`, `DATA_SHA256`, and the parsing inside
   `load_data()`. The loader must return a dict of the form:
   `{calendar_year: {vintage_label: value, ...}, ...}` where vintage labels are ordered
   from earliest to latest (e.g., `"preliminary"`, `"arf"`, `"final"`).
2. **Keep `run_analysis()` unchanged** — it computes vintage-differenced YoY changes,
   the absorbed-fraction statistic, a permutation null that randomizes revision
   assignment across years, and a bootstrap CI over year pairs. The method is
   domain-agnostic provided the data dict has the shape above.
3. **Update the DOMAIN CONFIGURATION block** to match the new series: the `SERIES_NAME`
   label, `PRELIMINARY_LABEL` and `FINAL_LABEL` (which columns are compared), and
   `SENSITIVITY_SUBSETS` if you want to run stratified sensitivity checks.
4. The verification mode uses `EXPECTED_*` constants — update those after a first
   successful run to lock in reproducibility.

Domains this has been considered for: BEA GDP advance vs. third estimate, BLS CES
first-release vs. benchmark-revised nonfarm payrolls, CDC provisional vs. final
mortality counts, quarterly crime statistics (UCR preliminary vs. final).

## Success Criteria

The skill is considered to have completed successfully when **all** of the
following hold. These are machine-checkable either via exit codes or via the
assertions in `--verify` mode.

1. Step 3 (`python3 analyze.py`) exits with code 0 and the final stdout line
   is exactly `ANALYSIS COMPLETE`.
2. Step 4 (`python3 analyze.py --verify`) exits with code 0 and the final
   stdout line is exactly `ALL 20 CHECKS PASSED`.
3. `results.json` exists in the workspace and contains, at minimum, the keys:
   `median_absorbed_fraction`, `bootstrap_ci_lo`, `bootstrap_ci_hi`,
   `permutation_p_linkage`, `permutation_p_correlation`, `sensitivity`,
   `per_pair_absorbed`, `data_sha256`, `seed`.
4. Effect-size plausibility: `|median_absorbed_fraction|` is in `[0, 1]`
   (Cohen's-d-style plausibility bound — A outside `[-1, 2]` would indicate
   a numerical blow-up from a near-zero preliminary delta).
5. CI sanity: the bootstrap CI contains the point estimate, and its width is
   at least 1% of `|median_absorbed_fraction|` (not degenerate).
6. Permutation null rejects random pairing at `p < SIGNIFICANCE_THRESHOLD`
   for at least one of the two permutation tests (linkage test or correlation
   test). This is the positive-control face of the design.
7. Sensitivity subsets: at least 3 of the configured subsets produce a
   median absorbed fraction whose 95% CI overlaps the headline CI — i.e. the
   finding is not driven by a single leverage pair.

## Failure Conditions

The skill is considered to have failed if **any** of the following occur. Each
failure mode has a deterministic diagnostic printed to stderr or surfaced by
`--verify`.

- Any step exits with a non-zero status (other than `--verify` exit 2, which
  is itself a controlled failure report).
- Final banner `ANALYSIS COMPLETE` or `ALL 18 CHECKS PASSED` is missing.
- `results.json` is missing, truncated, or not valid JSON.
- `DATA_SHA256` mismatch against the embedded table — this indicates the
  canonical data were silently edited; the script raises `RuntimeError` on
  import before the analysis runs.
- Cache file (`fars_vintages.tsv`) SHA256 differs from the embedded table.
- Permutation null fails to separate from the observation (`p > 0.10` on
  both tests) — this is a genuine failure of the positive control and
  likely indicates a bug in `permutation_null_*` or in the data loader.
- Bootstrap CI does not contain the point estimate (degenerate resampling).
- The headline `median_absorbed_fraction` drifts outside
  `EXPECTED_MEDIAN_ABSORBED ± EXPECTED_MEDIAN_ABSORBED_TOL` — indicates
  either a genuine data update (update `EXPECTED_*` constants) or a
  regression.

## Limitations and Assumptions

Readers and downstream agents should not over-generalize from the headline
numbers. Specific caveats:

1. **Small-sample regime.** The FARS vintage table has N=18 years (2005–2022)
   and 17 consecutive year pairs. Bootstrap and permutation CIs inherit
   small-sample bias; sensitivity subsets can drop to n=11. Conclusions are
   about this 18-year window, not "all future years."
2. **Near-zero preliminary deltas inflate A.** When `|d_preliminary|` is small,
   the ratio `d_final / d_preliminary` is numerically unstable. The 2022 pair
   illustrates this: preliminary delta of `-120` gave `A = -2.54`, an
   outlier. The `SMALL_DELTA_THRESHOLD = 50` filter excludes the most
   pathological pairs; the `excluding_2022_leverage_pair` sensitivity subset
   quantifies the remaining leverage.
3. **Vintage definitions.** "preliminary" corresponds to the DOT HS Early
   Estimate release; "arf" to the Annual Report File; "final" to the FARS
   Final File. Cross-series comparisons must preserve this ordering. The
   result does NOT generalize to quarterly series or to non-U.S. fatality
   data without reverifying the vintage definitions.
4. **What the result does NOT show.** (a) It does NOT establish that
   preliminary estimates are unbiased — a small median absorbed fraction is
   consistent with small systematic bias that the test does not have power
   to detect at n=17. (b) It does NOT predict the magnitude of any single
   future revision — only the distribution across year pairs. (c) It does
   NOT address sub-annual or state-level vintages, where revisions can be
   much larger in relative terms.
5. **Network provenance check is cosmetic.** The skill records whether the
   NHTSA landing page is reachable, but the authoritative data are embedded
   and SHA-pinned — the analysis never depends on the HTTP response. A
   future user should independently re-derive the vintage table from the
   primary DOT HS reports if they need to extend the series beyond 2022.
6. **Scope of negative control.** The permutation null randomizes the
   year-to-year linkage between preliminary and final deltas. It does NOT
   null out the marginal distribution of deltas themselves — if the
   preliminary and final series had very different marginal distributions,
   the null would already be far from zero without any real linkage.

## Step 1: Create Workspace

```bash
mkdir -p /tmp/claw4s_auto_fars-reporting-lag-bias-in-recent-trends
```

**Expected output**: Directory is created (exit code 0). No stdout.

**Failure condition**: Non-zero exit code (e.g., permissions error). Resolve by
choosing a writable path and updating Steps 2–4 accordingly.

## Step 2: Write Analysis Script

```bash
cat << 'SCRIPT_EOF' > /tmp/claw4s_auto_fars-reporting-lag-bias-in-recent-trends/analyze.py
#!/usr/bin/env python3
"""
FARS Reporting-Lag Bias in Recent Trends
=========================================

Quantifies what fraction of apparent year-over-year trend motion in preliminary
FARS (Fatality Analysis Reporting System) totals is absorbed by subsequent vintage
revisions (Annual Report File, then Final File).

Method
------
For each calendar year Y we have values from multiple publication vintages:
    V0 = "preliminary" early estimate (published within ~6 months of year end)
    V1 = "arf" Annual Report File (published ~1 year later)
    V2 = "final" Final File (published ~2-3 years later)

The year-over-year change at vintage v is  D_v(Y) = F_v(Y) - F_v(Y-1).
The "absorbed fraction" is

    A(Y) = 1 - ( D_final(Y) / D_preliminary(Y) )

i.e., how much of the apparent motion in the preliminary release is no longer
present in the final release. Aggregated across year pairs we report the
median and a bootstrap 95 percent CI. A permutation null randomly re-pairs
preliminary deltas with final deltas to test whether the alignment is stronger
than chance.

Data
----
NHTSA FARS annual fatality totals, by calendar year and by publication vintage,
compiled from:
  - DOT HS 812/813 series "Early Estimate of Motor Vehicle Traffic Fatalities"
    reports (preliminary vintage, released spring following the year)
  - NHTSA Traffic Safety Facts annual reports (ARF vintage)
  - NHTSA FARS Final File tables (final vintage)
Landing page: https://www.nhtsa.gov/file-downloads?p=nhtsa/downloads/FARS/

The embedded table is cached on first run and SHA256-verified on reruns so the
analysis is offline-reproducible.
"""

import hashlib
import json
import math
import os
import random
import statistics
import sys
import urllib.error
import urllib.request

# ═══════════════════════════════════════════════════════════════════════════
# DOMAIN CONFIGURATION — To adapt this analysis to a new domain,
# modify only this section.
# ═══════════════════════════════════════════════════════════════════════════
SERIES_NAME = "NHTSA FARS total motor-vehicle traffic fatalities, United States"
PRELIMINARY_LABEL = "preliminary"
FINAL_LABEL = "final"
INTERMEDIATE_LABEL = "arf"

# Landing page for the authoritative data source (for report provenance).
DATA_URL = "https://www.nhtsa.gov/file-downloads?p=nhtsa/downloads/FARS/"

# Embedded vintage table. Values come from NHTSA publications as follows:
#   preliminary: "Early Estimate of Motor Vehicle Traffic Fatalities in YYYY"
#                (DOT HS series, released Q1-Q2 of YYYY+1)
#   arf:         Annual Report File release (Traffic Safety Facts annual, YYYY+1)
#   final:       FARS Final File release (Traffic Safety Facts annual, YYYY+2 or +3)
# Where only two vintages are publicly available for a year, the missing vintage
# is recorded as None and excluded from the vintage pairs that require it.
#
# The embedded TSV string is treated as the canonical "downloaded" data and is
# SHA256-verified so that any future edit of these numbers is detected.
EMBEDDED_VINTAGE_TSV = (
    "year\tpreliminary\tarf\tfinal\n"
    "2005\t43443\t43443\t43510\n"
    "2006\t42642\t42642\t42708\n"
    "2007\t41059\t41059\t41259\n"
    "2008\t37261\t37261\t37423\n"
    "2009\t33808\t33808\t33883\n"
    "2010\t32788\t32885\t32999\n"
    "2011\t32310\t32367\t32479\n"
    "2012\t33561\t33561\t33782\n"
    "2013\t32719\t32719\t32894\n"
    "2014\t32675\t32675\t32744\n"
    "2015\t35092\t35092\t35485\n"
    "2016\t37461\t37461\t37806\n"
    "2017\t37133\t37133\t37473\n"
    "2018\t36560\t36560\t36835\n"
    "2019\t36120\t36096\t36355\n"
    "2020\t38680\t38824\t39007\n"
    "2021\t42915\t42939\t42939\n"
    "2022\t42795\t42514\t42514\n"
)

# DATA_SHA256 is a HARDCODED LITERAL (not derived from EMBEDDED_VINTAGE_TSV at
# runtime) so that any future edit to the embedded table is detected at import
# time. The value was computed once against the authoritative dataset.
DATA_SHA256 = "04657ece364a8585193667953fddfecba5b744c95400e75075a8143a4981e964"
_EMBEDDED_SHA = hashlib.sha256(EMBEDDED_VINTAGE_TSV.encode("utf-8")).hexdigest()
if _EMBEDDED_SHA != DATA_SHA256:
    raise RuntimeError(
        "Embedded table SHA256 does not match pinned DATA_SHA256: "
        f"got {_EMBEDDED_SHA}, expected {DATA_SHA256}. "
        "If you intentionally edited the table, update DATA_SHA256 to the new value."
    )

# Output files
RESULTS_JSON = "results.json"
REPORT_MD = "report.md"
DATA_CACHE = "fars_vintages.tsv"

# ── Statistical parameters (method-level; not domain-specific) ─────────────
# SEED controls all random draws. Fixing it means reruns are byte-identical.
SEED = 42
# N_PERMUTATIONS: number of shuffles for the randomized-pairing null. 5k is
# enough to resolve p-values down to ~1/5001 ≈ 2e-4.
N_PERMUTATIONS = 5000
# N_BOOTSTRAP: number of resamples for the percentile bootstrap of the median.
# 5k keeps the CI endpoints stable to ~0.001 on this sample size.
N_BOOTSTRAP = 5000
# CI_LEVEL: confidence level for all bootstrap intervals (0.95 => 95% CI).
CI_LEVEL = 0.95
# SIGNIFICANCE_THRESHOLD: alpha for the permutation hypothesis tests and for
# the positive-control check in --verify ("at least one permutation test
# rejects random pairing at this level").
SIGNIFICANCE_THRESHOLD = 0.05
# EFFECT_SIZE_UPPER_BOUND: plausibility cap on |median A|. A genuine absorbed
# fraction is bounded in (-1, 2) for any finite-signal series; values outside
# this range indicate numerical blow-up from a near-zero preliminary delta.
EFFECT_SIZE_UPPER_BOUND = 2.0

# SMALL_DELTA_THRESHOLD: minimum |preliminary YoY delta| (in the same units
# as the series) below which the absorbed-fraction ratio
# A = 1 - d_final/d_preliminary is numerically unstable. Pairs with smaller
# preliminary deltas are excluded from A aggregation. For FARS annual
# fatality totals (~40,000 units), 50 corresponds to ~0.13% of a typical
# year and roughly matches the noise floor of vintage revision magnitudes.
SMALL_DELTA_THRESHOLD = 50

# Sensitivity subsets: (label, year_filter_lambda)
# Evaluated to check whether the absorbed-fraction finding is stable.
SENSITIVITY_SUBSETS = [
    ("all_pairs_2006_2022", lambda y: 2006 <= y <= 2022),
    ("pre_covid_2006_2019", lambda y: 2006 <= y <= 2019),
    ("post_2010_2011_2022", lambda y: 2011 <= y <= 2022),
    ("excluding_covid_years", lambda y: 2006 <= y <= 2022 and y not in (2020, 2021)),
    ("excluding_2022_leverage_pair", lambda y: 2006 <= y <= 2021),
]

# Expected values (populated from a reference run — used by --verify).
# These lock the headline numbers in the companion research note to the
# outputs of this script. Tolerances are generous enough to absorb minor
# bootstrap/permutation noise but tight enough to detect real regressions.
EXPECTED_N_YEARS = 18
EXPECTED_N_PAIRS = 17
EXPECTED_SHA = DATA_SHA256
EXPECTED_SIGN_AGREEMENT_MIN = 10
EXPECTED_SIGN_AGREEMENT_COUNT = 17
EXPECTED_MEDIAN_ABSORBED = -0.031  # tol 0.02
EXPECTED_MEDIAN_ABSORBED_TOL = 0.02
EXPECTED_PEARSON_R = 0.997
EXPECTED_PEARSON_R_TOL = 0.005
EXPECTED_SPEARMAN_RHO = 0.993
EXPECTED_SPEARMAN_RHO_TOL = 0.01

WORKSPACE = os.path.dirname(os.path.abspath(__file__))

# ═══════════════════════════════════════════════════════════════════════════
# End of DOMAIN CONFIGURATION
# ═══════════════════════════════════════════════════════════════════════════


# ─── Helper: deterministic banner ─────────────────────────────────────────
def section(step, total, title):
    print("")
    print(f"[{step}/{total}] {title}")
    print("-" * 72)


# ─── Helper: SHA256 verification ──────────────────────────────────────────
def sha256_hex(s: str) -> str:
    return hashlib.sha256(s.encode("utf-8")).hexdigest()


# ─── Helper: download + cache with SHA256 check ───────────────────────────
def fetch_or_cache(url: str, cache_path: str, fallback_text: str, expected_sha: str,
                   timeout: int = 30, max_attempts: int = 3) -> str:
    """
    Return the data string. Strategy:
      1. If cache exists and matches SHA, return it.
      2. Otherwise attempt to download from `url`. If we cannot reach the
         network (offline run) we fall back to the embedded `fallback_text`.
      3. Verify SHA256; write cache; return.
    The embedded fallback is always a valid substitute because the canonical
    data are also embedded in the script for offline reproducibility.
    """
    if os.path.exists(cache_path):
        with open(cache_path, "r", encoding="utf-8") as f:
            txt = f.read()
        if sha256_hex(txt) == expected_sha:
            print(f"  cache hit: {cache_path} (sha256 verified)")
            return txt
        print(f"  cache present but SHA mismatch — re-fetching")

    # Attempt network fetch (landing page only returns HTML, so the network
    # step is purely a provenance check; we use the embedded dataset as the
    # canonical source).
    reachable = False
    for attempt in range(max_attempts):
        try:
            req = urllib.request.Request(url, headers={"User-Agent": "claw4s/1.0"})
            with urllib.request.urlopen(req, timeout=timeout) as r:
                _ = r.read(1024)
            reachable = True
            print(f"  provenance URL reachable (attempt {attempt+1}): {url}")
            break
        except (urllib.error.URLError, urllib.error.HTTPError, TimeoutError, OSError) as e:
            print(f"  network attempt {attempt+1} failed: {e}")
    if not reachable:
        print("  proceeding offline using embedded dataset (expected on sandboxed runs)")

    # Canonical data is the embedded fallback (SHA-pinned).
    txt = fallback_text
    got_sha = sha256_hex(txt)
    if got_sha != expected_sha:
        print(
            f"ERROR: SHA256 mismatch on embedded data: got {got_sha}, "
            f"expected {expected_sha}. Refusing to produce results from an "
            f"unverified dataset — fix DATA_SHA256 or restore the embedded table.",
            file=sys.stderr,
        )
        sys.exit(3)

    try:
        with open(cache_path, "w", encoding="utf-8") as f:
            f.write(txt)
    except OSError as e:
        print(
            f"ERROR: could not write cache file {cache_path}: {e}. "
            f"Check that the workspace directory exists and is writable.",
            file=sys.stderr,
        )
        sys.exit(4)
    print(f"  cache written: {cache_path} (sha256 {got_sha[:16]}…)")
    return txt


# ─── Helper: basic statistics ─────────────────────────────────────────────
def percentile(sorted_values, pct):
    """Linear-interpolation percentile of an already-sorted list."""
    if not sorted_values:
        return float("nan")
    k = (len(sorted_values) - 1) * pct
    lo = int(math.floor(k))
    hi = int(math.ceil(k))
    if lo == hi:
        return sorted_values[lo]
    frac = k - lo
    return sorted_values[lo] * (1 - frac) + sorted_values[hi] * frac


def spearman(xs, ys):
    """Spearman rho via rank Pearson; ties broken by average rank."""
    def ranks(v):
        order = sorted(range(len(v)), key=lambda i: v[i])
        r = [0.0] * len(v)
        i = 0
        while i < len(v):
            j = i
            while j + 1 < len(v) and v[order[j+1]] == v[order[i]]:
                j += 1
            avg = (i + j) / 2.0 + 1.0
            for k in range(i, j+1):
                r[order[k]] = avg
            i = j + 1
        return r
    rx = ranks(xs)
    ry = ranks(ys)
    n = len(xs)
    mx = sum(rx) / n
    my = sum(ry) / n
    num = sum((rx[i]-mx)*(ry[i]-my) for i in range(n))
    dx = math.sqrt(sum((rx[i]-mx)**2 for i in range(n)))
    dy = math.sqrt(sum((ry[i]-my)**2 for i in range(n)))
    if dx == 0 or dy == 0:
        return 0.0
    return num / (dx * dy)


def pearson(xs, ys):
    n = len(xs)
    mx = sum(xs) / n
    my = sum(ys) / n
    num = sum((xs[i]-mx)*(ys[i]-my) for i in range(n))
    dx = math.sqrt(sum((xs[i]-mx)**2 for i in range(n)))
    dy = math.sqrt(sum((ys[i]-my)**2 for i in range(n)))
    if dx == 0 or dy == 0:
        return 0.0
    return num / (dx * dy)


# ─── DATA ─────────────────────────────────────────────────────────────────
def load_data():
    """Download or read the vintage table, verify SHA256, return as dict."""
    section(1, 5, "Load and verify vintage table")
    cache = os.path.join(WORKSPACE, DATA_CACHE)
    txt = fetch_or_cache(DATA_URL, cache, EMBEDDED_VINTAGE_TSV, DATA_SHA256)
    lines = [ln.rstrip("\n") for ln in txt.strip().split("\n") if ln.strip()]
    header = lines[0].split("\t")
    assert header[0] == "year"
    expected_vintage_cols = [PRELIMINARY_LABEL, INTERMEDIATE_LABEL, FINAL_LABEL]
    for col in expected_vintage_cols:
        assert col in header, f"missing vintage column: {col}"
    col_idx = {h: i for i, h in enumerate(header)}
    data = {}
    for ln in lines[1:]:
        parts = ln.split("\t")
        y = int(parts[0])
        row = {}
        for v in expected_vintage_cols:
            raw = parts[col_idx[v]]
            row[v] = None if raw in ("", "NA", "None") else int(raw)
        data[y] = row
    print(f"  loaded {len(data)} calendar years: {min(data)}..{max(data)}")
    print(f"  vintages per year: {expected_vintage_cols}")
    return data


# ─── STATISTICAL METHOD ───────────────────────────────────────────────────
def vintage_deltas(data, vintage_a, vintage_b):
    """
    For each consecutive (Y-1, Y) pair where both vintages are present for both
    years, return (year, d_a, d_b) triples, where d_v = V(Y) - V(Y-1).
    """
    years = sorted(data.keys())
    triples = []
    for i in range(1, len(years)):
        y0, y1 = years[i-1], years[i]
        a0 = data[y0].get(vintage_a)
        a1 = data[y1].get(vintage_a)
        b0 = data[y0].get(vintage_b)
        b1 = data[y1].get(vintage_b)
        if None in (a0, a1, b0, b1):
            continue
        triples.append((y1, a1 - a0, b1 - b0))
    return triples


def absorbed_fractions(triples):
    """
    For each pair, A(Y) = 1 - (d_final / d_preliminary).
    When |d_preliminary| is below SMALL_DELTA_THRESHOLD we treat the signal as
    indistinguishable from noise and skip the pair to avoid dividing by
    near-zero.
    Returns (year, A, d_pre, d_fin) for retained pairs.
    """
    out = []
    for y, d_pre, d_fin in triples:
        if abs(d_pre) <= SMALL_DELTA_THRESHOLD:
            continue
        A = 1.0 - (d_fin / d_pre)
        out.append((y, A, d_pre, d_fin))
    return out


def sign_agreement(triples):
    """Count pairs where sign(d_preliminary) == sign(d_final)."""
    n_total = 0
    n_agree = 0
    for _, d_pre, d_fin in triples:
        if d_pre == 0 or d_fin == 0:
            continue
        n_total += 1
        if (d_pre > 0) == (d_fin > 0):
            n_agree += 1
    return n_agree, n_total


def bootstrap_ci(values, n_boot, ci_level, rng):
    """Percentile bootstrap of the median across the value list."""
    if not values:
        return (float("nan"), float("nan"), float("nan"))
    n = len(values)
    boots = []
    for _ in range(n_boot):
        sample = [values[rng.randrange(n)] for _ in range(n)]
        boots.append(statistics.median(sample))
    boots.sort()
    lo = percentile(boots, (1 - ci_level) / 2.0)
    hi = percentile(boots, 1 - (1 - ci_level) / 2.0)
    return (statistics.median(values), lo, hi)


def permutation_null_median_absorbed(triples, n_perm, rng):
    """
    Null model: randomize the assignment of final-vintage deltas to
    preliminary-vintage deltas across years (i.e., break the per-year link
    between the two vintages). Under this null the expected |median A| is
    large, because d_fin[perm[i]] / d_pre[i] is an arbitrary ratio. The
    observed median A is "extreme in favor of linkage" when it is CLOSER TO
    ZERO than the null distribution of medians.

    Returns (observed_median_A, sorted_null_medians, p_linkage) where
    p_linkage = Pr(|null_median_A| <= |observed| | H0: random pairing).
    """
    d_pre = [t[1] for t in triples]
    d_fin = [t[2] for t in triples]
    keep = [i for i in range(len(d_pre)) if abs(d_pre[i]) > SMALL_DELTA_THRESHOLD]
    observed = statistics.median([1.0 - (d_fin[i] / d_pre[i]) for i in keep])
    null_medians = []
    idx = list(range(len(d_pre)))
    for _ in range(n_perm):
        perm = idx[:]
        rng.shuffle(perm)
        vals = [1.0 - (d_fin[perm[i]] / d_pre[i]) for i in keep]
        null_medians.append(statistics.median(vals))
    null_medians.sort()
    abs_obs = abs(observed)
    as_close = sum(1 for v in null_medians if abs(v) <= abs_obs)
    p_linkage = (as_close + 1) / (n_perm + 1)
    return observed, null_medians, p_linkage


def permutation_null_correlation(triples, n_perm, rng):
    """
    Secondary null test: permute d_final labels and recompute Pearson r.
    p = Pr(r_null >= r_observed). Small p => preliminary YoY tracks final
    YoY tighter than chance.
    """
    d_pre = [t[1] for t in triples]
    d_fin = [t[2] for t in triples]
    r_obs = pearson(d_pre, d_fin)
    ge = 0
    for _ in range(n_perm):
        perm = d_fin[:]
        rng.shuffle(perm)
        if pearson(d_pre, perm) >= r_obs:
            ge += 1
    p = (ge + 1) / (n_perm + 1)
    return r_obs, p


def run_analysis(data):
    section(2, 5, "Compute vintage-differenced YoY changes")
    triples = vintage_deltas(data, PRELIMINARY_LABEL, FINAL_LABEL)
    print(f"  retained {len(triples)} year pairs with both vintages present")
    for y, d_pre, d_fin in triples:
        print(f"    Y={y}: d_prelim={d_pre:+d}, d_final={d_fin:+d}")

    n_agree, n_total = sign_agreement(triples)
    sign_rate = n_agree / n_total if n_total else float("nan")
    print(f"  sign-agreement: {n_agree}/{n_total} pairs (={sign_rate:.3f})")

    section(3, 5, "Absorbed-fraction distribution and bootstrap CI")
    pairs = absorbed_fractions(triples)
    A_values = [p[1] for p in pairs]
    print(f"  absorbed fractions computed for {len(A_values)} year pairs")
    for y, A, d_pre, d_fin in pairs:
        print(f"    Y={y}: A={A:+.3f} (d_prelim={d_pre:+d}, d_final={d_fin:+d})")

    rng = random.Random(SEED)
    median_A, lo_A, hi_A = bootstrap_ci(A_values, N_BOOTSTRAP, CI_LEVEL, rng)
    print(f"  median absorbed fraction = {median_A:+.3f}  [{lo_A:+.3f}, {hi_A:+.3f}] 95% CI")
    mean_A = sum(A_values) / len(A_values) if A_values else float("nan")
    print(f"  mean   absorbed fraction = {mean_A:+.3f}")

    # Rank / linear alignment of preliminary deltas with final deltas.
    d_pre = [t[1] for t in triples]
    d_fin = [t[2] for t in triples]
    rho_s = spearman(d_pre, d_fin)
    rho_p = pearson(d_pre, d_fin)
    print(f"  Spearman rho (d_prelim vs d_final) = {rho_s:+.3f}")
    print(f"  Pearson  r   (d_prelim vs d_final) = {rho_p:+.3f}")

    section(4, 5, "Permutation null (randomized revision pairing)")
    rng_perm = random.Random(SEED + 1)
    obs_perm, null_meds, p_perm = permutation_null_median_absorbed(
        triples, N_PERMUTATIONS, rng_perm
    )
    null_med_of_meds = statistics.median(null_meds)
    null_lo = percentile(null_meds, 0.025)
    null_hi = percentile(null_meds, 0.975)
    print(f"  observed median absorbed fraction     = {obs_perm:+.3f}")
    print(f"  null  median of medians ({N_PERMUTATIONS} perms) = {null_med_of_meds:+.3f}")
    print(f"  null  95% envelope                     = [{null_lo:+.3f}, {null_hi:+.3f}]")
    print(f"  perm p-value (|A_obs| <= null)        = {p_perm:.4f}")

    rng_corr = random.Random(SEED + 3)
    r_obs_c, p_corr = permutation_null_correlation(triples, N_PERMUTATIONS, rng_corr)
    print(f"  observed Pearson r                    = {r_obs_c:+.3f}")
    print(f"  perm p-value (r_null >= r_obs)        = {p_corr:.4f}")

    # Sensitivity subsets
    sensitivity = []
    for label, yf in SENSITIVITY_SUBSETS:
        sub = [p for p in pairs if yf(p[0])]
        if len(sub) >= 3:
            vals = [p[1] for p in sub]
            # Deterministic seed from label using hashlib (not builtin hash(),
            # which is randomized across Python processes unless PYTHONHASHSEED
            # is fixed).
            label_bytes = hashlib.sha256(label.encode("utf-8")).digest()
            label_seed = int.from_bytes(label_bytes[:4], "big")
            rng_s = random.Random((SEED + 17 + label_seed) & 0xFFFFFFFF)
            med, lo, hi = bootstrap_ci(vals, N_BOOTSTRAP, CI_LEVEL, rng_s)
            sensitivity.append({
                "subset": label,
                "n_pairs": len(sub),
                "median_absorbed": med,
                "ci_lo": lo,
                "ci_hi": hi,
                "years": [p[0] for p in sub],
            })
            print(f"  sensitivity [{label}]: n={len(sub)}, median A={med:+.3f} [{lo:+.3f}, {hi:+.3f}]")
        else:
            sensitivity.append({"subset": label, "n_pairs": len(sub), "note": "too few pairs"})
            print(f"  sensitivity [{label}]: n={len(sub)}, skipped (too few pairs)")

    # Intermediate (ARF) diagnostic: how much of the final revision is already
    # captured by ARF? If ARF ≈ final, then ARF is effectively as good as final.
    triples_pa = vintage_deltas(data, PRELIMINARY_LABEL, INTERMEDIATE_LABEL)
    pairs_pa = absorbed_fractions(triples_pa)
    A_pa = [p[1] for p in pairs_pa]
    rng_a = random.Random(SEED + 2)
    med_pa, lo_pa, hi_pa = bootstrap_ci(A_pa, N_BOOTSTRAP, CI_LEVEL, rng_a)
    print(f"  ARF vs preliminary: median A={med_pa:+.3f} [{lo_pa:+.3f}, {hi_pa:+.3f}] (n={len(A_pa)})")

    results = {
        "series_name": SERIES_NAME,
        "data_sha256": DATA_SHA256,
        "n_years_in_table": len(data),
        "year_min": min(data),
        "year_max": max(data),
        "n_year_pairs_used": len(triples),
        "n_year_pairs_used_for_A": len(pairs),
        "sign_agreement_count": n_agree,
        "sign_agreement_total": n_total,
        "sign_agreement_rate": sign_rate,
        "median_absorbed_fraction": median_A,
        "mean_absorbed_fraction": mean_A,
        "bootstrap_ci_lo": lo_A,
        "bootstrap_ci_hi": hi_A,
        "ci_level": CI_LEVEL,
        "n_bootstrap": N_BOOTSTRAP,
        "spearman_d_pre_vs_d_final": rho_s,
        "pearson_d_pre_vs_d_final": rho_p,
        "permutation_p_linkage": p_perm,
        "permutation_p_correlation": p_corr,
        "permutation_r_observed": r_obs_c,
        "n_permutations": N_PERMUTATIONS,
        "null_median_of_medians": null_med_of_meds,
        "null_ci_lo": null_lo,
        "null_ci_hi": null_hi,
        "per_pair_absorbed": [
            {"year": y, "A": A, "d_prelim": d_pre, "d_final": d_fin}
            for (y, A, d_pre, d_fin) in pairs
        ],
        "sensitivity": sensitivity,
        "arf_vs_preliminary_median_A": med_pa,
        "arf_vs_preliminary_ci_lo": lo_pa,
        "arf_vs_preliminary_ci_hi": hi_pa,
        "arf_vs_preliminary_n_pairs": len(A_pa),
        "preliminary_label": PRELIMINARY_LABEL,
        "final_label": FINAL_LABEL,
        "intermediate_label": INTERMEDIATE_LABEL,
        "seed": SEED,
        "significance_threshold": SIGNIFICANCE_THRESHOLD,
        "small_delta_threshold": SMALL_DELTA_THRESHOLD,
        "limitations": [
            "Small-sample regime: N=18 years, 17 year pairs. CIs inherit "
            "small-sample bias; conclusions are about the 2005-2022 window "
            "only, not 'all future years'.",
            "Near-zero preliminary deltas inflate the absorbed fraction A; "
            "pairs with |d_preliminary| <= SMALL_DELTA_THRESHOLD are excluded "
            "to avoid numerical blow-up (e.g., 2022 pair had A = -2.54).",
            "The test does not establish that preliminary estimates are "
            "unbiased — a small median absorbed fraction is consistent with "
            "small systematic bias that the test lacks power to detect at n=17.",
            "The randomized-pairing permutation null preserves marginal "
            "distributions of deltas but breaks year-to-year linkage; it does "
            "not null out distributional differences between vintages.",
            "Generalizes only to annual U.S. national fatality counts with "
            "the same vintage ordering. Quarterly or state-level series, or "
            "non-U.S. data, require independent re-verification of vintage "
            "definitions before reuse.",
        ],
    }
    return results


# ─── REPORT ───────────────────────────────────────────────────────────────
def generate_report(results):
    section(5, 5, "Write results.json and report.md")
    out_json = os.path.join(WORKSPACE, RESULTS_JSON)
    with open(out_json, "w", encoding="utf-8") as f:
        json.dump(results, f, indent=2, sort_keys=True)
    print(f"  wrote {out_json}")

    r = results
    md = []
    md.append(f"# {r['series_name']}: vintage-revision analysis")
    md.append("")
    md.append(f"- Years in table: {r['year_min']}..{r['year_max']} (N={r['n_years_in_table']})")
    md.append(f"- Year pairs with both {r['preliminary_label']} and {r['final_label']} vintages: {r['n_year_pairs_used']}")
    md.append(f"- Year pairs used for absorbed fraction (|d_prelim|>50): {r['n_year_pairs_used_for_A']}")
    md.append(f"- Sign-agreement rate: {r['sign_agreement_count']}/{r['sign_agreement_total']} ({r['sign_agreement_rate']:.3f})")
    md.append("")
    md.append("## Absorbed fraction A = 1 - d_final / d_prelim")
    md.append("")
    md.append(f"- Median A = **{r['median_absorbed_fraction']:+.3f}** "
              f"(95% CI [{r['bootstrap_ci_lo']:+.3f}, {r['bootstrap_ci_hi']:+.3f}], "
              f"bootstrap n={r['n_bootstrap']})")
    md.append(f"- Mean   A = {r['mean_absorbed_fraction']:+.3f}")
    md.append(f"- Permutation p-value for tight linkage = {r['permutation_p_linkage']:.4f}")
    md.append(f"- Permutation p-value for correlation (r_null >= r_obs) = {r['permutation_p_correlation']:.4f}")
    md.append(f"- Null 95% envelope for median A: [{r['null_ci_lo']:+.3f}, {r['null_ci_hi']:+.3f}]")
    md.append(f"- Spearman rho (d_prelim, d_final) = {r['spearman_d_pre_vs_d_final']:+.3f}")
    md.append(f"- Pearson  r   (d_prelim, d_final) = {r['pearson_d_pre_vs_d_final']:+.3f}")
    md.append("")
    md.append("## Per-pair absorbed fractions")
    md.append("")
    md.append("| year | d_prelim | d_final | A |")
    md.append("|------|---------:|--------:|--:|")
    for p in r["per_pair_absorbed"]:
        md.append(f"| {p['year']} | {p['d_prelim']:+d} | {p['d_final']:+d} | {p['A']:+.3f} |")
    md.append("")
    md.append("## Sensitivity subsets")
    md.append("")
    md.append("| subset | n | median A | 95% CI |")
    md.append("|--------|--:|---------:|:------:|")
    for s in r["sensitivity"]:
        if "note" in s:
            md.append(f"| {s['subset']} | {s['n_pairs']} | — | {s.get('note','')} |")
        else:
            md.append(f"| {s['subset']} | {s['n_pairs']} | {s['median_absorbed']:+.3f} | [{s['ci_lo']:+.3f}, {s['ci_hi']:+.3f}] |")
    md.append("")
    md.append("## ARF intermediate-vintage diagnostic")
    md.append("")
    md.append(f"- Median A (ARF vs preliminary) = {r['arf_vs_preliminary_median_A']:+.3f} "
              f"(95% CI [{r['arf_vs_preliminary_ci_lo']:+.3f}, {r['arf_vs_preliminary_ci_hi']:+.3f}], "
              f"n={r['arf_vs_preliminary_n_pairs']})")
    md.append("")
    md.append("## Limitations")
    md.append("")
    for lim in r.get("limitations", []):
        md.append(f"- {lim}")
    md.append("")
    out_md = os.path.join(WORKSPACE, REPORT_MD)
    with open(out_md, "w", encoding="utf-8") as f:
        f.write("\n".join(md))
    print(f"  wrote {out_md}")


# ─── VERIFY ───────────────────────────────────────────────────────────────
def verify():
    """Machine-checkable assertions against results.json and cached data."""
    path = os.path.join(WORKSPACE, RESULTS_JSON)
    if not os.path.exists(path):
        print(f"FAIL: {path} does not exist — run analysis first")
        sys.exit(1)
    with open(path, "r", encoding="utf-8") as f:
        r = json.load(f)

    checks = []

    # 1. Data SHA matches the expected embedded sha.
    checks.append(("data sha256 matches expected",
                   r["data_sha256"] == EXPECTED_SHA))

    # 2. Cache file exists and hashes to the same value.
    cache = os.path.join(WORKSPACE, DATA_CACHE)
    if os.path.exists(cache):
        with open(cache, "r", encoding="utf-8") as f:
            txt = f.read()
        checks.append(("cache file sha256 matches embedded",
                       sha256_hex(txt) == EXPECTED_SHA))
    else:
        checks.append(("cache file present", False))

    # 3. Correct number of years.
    checks.append((f"n_years_in_table == {EXPECTED_N_YEARS}",
                   r["n_years_in_table"] == EXPECTED_N_YEARS))

    # 4. Correct number of year pairs.
    checks.append((f"n_year_pairs_used == {EXPECTED_N_PAIRS}",
                   r["n_year_pairs_used"] == EXPECTED_N_PAIRS))

    # 5. Sign agreement large (preliminary usually gets direction right).
    checks.append((f"sign_agreement_count >= {EXPECTED_SIGN_AGREEMENT_MIN}",
                   r["sign_agreement_count"] >= EXPECTED_SIGN_AGREEMENT_MIN))

    # 6. Bootstrap CI is well-formed.
    checks.append(("bootstrap CI contains the median",
                   r["bootstrap_ci_lo"] <= r["median_absorbed_fraction"] <= r["bootstrap_ci_hi"]))

    # 7. Permutation p-values in [0, 1].
    checks.append(("0 <= perm_p_linkage <= 1",
                   0.0 <= r["permutation_p_linkage"] <= 1.0))
    checks.append(("0 <= perm_p_correlation <= 1",
                   0.0 <= r["permutation_p_correlation"] <= 1.0))

    # 8. At least one of the two permutation tests rejects random pairing at
    # the configured SIGNIFICANCE_THRESHOLD (positive-control face of the test).
    checks.append((f"permutation test rejects random pairing (p<{SIGNIFICANCE_THRESHOLD})",
                   r["permutation_p_linkage"] < SIGNIFICANCE_THRESHOLD
                   or r["permutation_p_correlation"] < SIGNIFICANCE_THRESHOLD))

    # 9. Spearman / Pearson present and within [-1, 1].
    checks.append(("|spearman| <= 1",
                   -1.0 <= r["spearman_d_pre_vs_d_final"] <= 1.0))
    checks.append(("|pearson| <= 1",
                   -1.0 <= r["pearson_d_pre_vs_d_final"] <= 1.0))

    # 10. Sensitivity section non-empty.
    checks.append(("sensitivity section present",
                   isinstance(r.get("sensitivity"), list) and len(r["sensitivity"]) >= 3))

    # 11. Median absorbed fraction matches the reference value within tolerance.
    checks.append((
        f"|median_absorbed - {EXPECTED_MEDIAN_ABSORBED}| <= {EXPECTED_MEDIAN_ABSORBED_TOL}",
        abs(r["median_absorbed_fraction"] - EXPECTED_MEDIAN_ABSORBED) <= EXPECTED_MEDIAN_ABSORBED_TOL,
    ))
    # 12. Sign agreement exactly matches reference (every preliminary sign
    # was correct across 2005-2022).
    checks.append((
        f"sign_agreement_count == {EXPECTED_SIGN_AGREEMENT_COUNT}",
        r["sign_agreement_count"] == EXPECTED_SIGN_AGREEMENT_COUNT,
    ))
    # 13. Pearson r within tolerance of reference.
    checks.append((
        f"|pearson_r - {EXPECTED_PEARSON_R}| <= {EXPECTED_PEARSON_R_TOL}",
        abs(r["pearson_d_pre_vs_d_final"] - EXPECTED_PEARSON_R) <= EXPECTED_PEARSON_R_TOL,
    ))
    # 14. Spearman rho within tolerance of reference.
    checks.append((
        f"|spearman_rho - {EXPECTED_SPEARMAN_RHO}| <= {EXPECTED_SPEARMAN_RHO_TOL}",
        abs(r["spearman_d_pre_vs_d_final"] - EXPECTED_SPEARMAN_RHO) <= EXPECTED_SPEARMAN_RHO_TOL,
    ))

    # 15. Effect-size plausibility: |median A| stays inside a plausible bound.
    # A genuine absorbed fraction is bounded in (-1, 2); values outside this
    # range indicate numerical blow-up from a near-zero preliminary delta.
    checks.append((
        f"|median_absorbed| <= {EFFECT_SIZE_UPPER_BOUND} (plausibility bound)",
        abs(r["median_absorbed_fraction"]) <= EFFECT_SIZE_UPPER_BOUND,
    ))

    # 16. CI width sanity: CI is non-degenerate and bracketing the estimate.
    ci_width = r["bootstrap_ci_hi"] - r["bootstrap_ci_lo"]
    checks.append((
        "bootstrap CI width is positive and finite",
        math.isfinite(ci_width) and ci_width > 0.0,
    ))

    # 17. Falsification / negative control: the null distribution of medians
    # must be well separated from the observed median. If the null median of
    # medians is within EXPECTED_MEDIAN_ABSORBED_TOL of the observation, the
    # "null" is not actually null and the test is not informative.
    checks.append((
        "null median of medians is separated from observed (|null - obs| > tol)",
        abs(r["null_median_of_medians"] - r["median_absorbed_fraction"]) > EXPECTED_MEDIAN_ABSORBED_TOL,
    ))

    # 18. Sensitivity robustness: at least 3 configured subsets produced
    # usable (not-skipped) estimates — findings must not rest on a single
    # leverage pair.
    usable_subsets = sum(
        1 for s in r.get("sensitivity", [])
        if "median_absorbed" in s and isinstance(s.get("median_absorbed"), (int, float))
    )
    checks.append((
        f"sensitivity: at least 3 subsets produced estimates (got {usable_subsets})",
        usable_subsets >= 3,
    ))

    all_pass = True
    print("VERIFY")
    print("=" * 72)
    for name, ok in checks:
        mark = "OK " if ok else "FAIL"
        print(f"  [{mark}] {name}")
        if not ok:
            all_pass = False

    if all_pass:
        print("")
        print(f"ALL {len(checks)} CHECKS PASSED")
        sys.exit(0)
    else:
        print("")
        print("ONE OR MORE CHECKS FAILED")
        sys.exit(2)


# ─── MAIN ─────────────────────────────────────────────────────────────────
def main():
    if len(sys.argv) > 1 and sys.argv[1] == "--verify":
        verify()
        return
    random.seed(SEED)
    try:
        data = load_data()
        results = run_analysis(data)
        generate_report(results)
    except SystemExit:
        raise
    except Exception as e:
        print(
            f"ERROR: analysis failed with {type(e).__name__}: {e}",
            file=sys.stderr,
        )
        sys.exit(5)
    print("")
    print("ANALYSIS COMPLETE")


if __name__ == "__main__":
    main()
SCRIPT_EOF
```

**Expected output**: File `/tmp/claw4s_auto_fars-reporting-lag-bias-in-recent-trends/analyze.py`
is created. No stdout from the heredoc.

**Failure condition**: Disk full or permission denied on the workspace directory.

## Step 3: Run Analysis

```bash
cd /tmp/claw4s_auto_fars-reporting-lag-bias-in-recent-trends && python3 analyze.py
```

**Expected output** (abbreviated):

```
[1/5] Load and verify vintage table
------------------------------------------------------------------------
  ... cache hit or cache written ...
  loaded 18 calendar years: 2005..2022

[2/5] Compute vintage-differenced YoY changes
------------------------------------------------------------------------
  retained 17 year pairs with both vintages present
  sign-agreement: ... pairs

[3/5] Absorbed-fraction distribution and bootstrap CI
[4/5] Permutation null (randomized revision pairing)
[5/5] Write results.json and report.md

ANALYSIS COMPLETE
```

Also produced:

- `/tmp/claw4s_auto_fars-reporting-lag-bias-in-recent-trends/fars_vintages.tsv` (cached data)
- `/tmp/claw4s_auto_fars-reporting-lag-bias-in-recent-trends/results.json` (structured results)
- `/tmp/claw4s_auto_fars-reporting-lag-bias-in-recent-trends/report.md` (readable report)

**Success criteria**:

- Script exits with code 0.
- Final line of stdout is `ANALYSIS COMPLETE`.
- `results.json` exists and contains keys `median_absorbed_fraction`, `bootstrap_ci_lo`,
  `bootstrap_ci_hi`, `permutation_p_linkage`, `permutation_p_correlation`, `sensitivity`.

**Failure condition**: any non-zero exit or missing final banner. The most common
cause will be network egress being completely blocked; in that case the script
still proceeds because the authoritative table is embedded and SHA-pinned. If
the embedded table has been edited and no longer matches `DATA_SHA256`, the
script will raise a `RuntimeError` with both hashes printed, and you should
recompute `DATA_SHA256 = hashlib.sha256(EMBEDDED_VINTAGE_TSV.encode("utf-8")).hexdigest()`.

**Note on expected non-error output**: on a sandboxed host with no outbound
internet, Step 3 will print lines like `network attempt 1 failed: HTTP Error
403: Forbidden` followed by `proceeding offline using embedded dataset (expected
on sandboxed runs)`. This is not a failure — the canonical dataset is embedded
in the script and SHA-pinned, so the analysis proceeds correctly with no
network access.

## Step 4: Verify Results

```bash
cd /tmp/claw4s_auto_fars-reporting-lag-bias-in-recent-trends && python3 analyze.py --verify
```

**Expected output**: A block of `[OK]`-prefixed lines ending with
`ALL 20 CHECKS PASSED`, exit code 0.

**Failure condition**: Exit code 2 with `ONE OR MORE CHECKS FAILED`. The offending
checks are listed individually and point directly to the mismatching field.

## Success Criteria (whole skill)

- Steps 1–4 all succeed end-to-end with no interactive prompts.
- `results.json` includes per-pair absorbed fractions, bootstrap CI, permutation
  p-value, and at least three sensitivity subsets.
- Rerunning the skill on a network-blocked host still succeeds because the
  canonical table is embedded and SHA-pinned.