diff --git "a/orbitlight.py" "b/orbitlight.py"
--- "a/orbitlight.py"
+++ "b/orbitlight.py"
@@ -307,6 +307,32 @@ def archive_simbad_companions(names):
     return {n: sorted(by.get(oids.get(n), [])) for n in names}
 
 
+archive_SIMBAD_BINARIES = ("EB*", "EB?", "SB*", "SB?", "El*", "El?", "RS*", "RS?")
+
+
+def archive_simbad_binaries():
+    """SIMBAD's eclipsing, spectroscopic, ellipsoidal and RS CVn binaries and their candidates (archive_SIMBAD_BINARIES): right ascension,
+    declination (deg) and the type's place in that list, sorted by declination, kept in DATA/simbad_index/binaries.npy once built."""
+    if "binaries" not in archive_SIMBAD_CACHE:
+        path = archive_data("simbad_index", "binaries.npy")
+        if not os.path.exists(path):
+            import pyarrow as pa
+            import pyarrow.compute as pc
+            t = archive_simbad_table("basic", ("ra", "dec", "otype"))
+            t = t.filter(pc.is_in(t["otype"], value_set=pa.array(archive_SIMBAD_BINARIES)))
+            kind = np.array([archive_SIMBAD_BINARIES.index(k) for k in t["otype"].to_pylist()], float)
+            x = np.column_stack([t["ra"].to_numpy(zero_copy_only=False).astype(float), t["dec"].to_numpy(zero_copy_only=False).astype(float), kind])
+            x = x[np.isfinite(x).all(axis=1)]
+            archive_SIMBAD_CACHE.pop(("basic", ("ra", "dec", "otype")), None)
+            os.makedirs(os.path.dirname(path), exist_ok=True)
+            tmp = archive_tmp(path)
+            with open(tmp, "wb") as fh:
+                np.save(fh, x[np.argsort(x[:, 1])])
+            archive_place(tmp, path)
+        archive_SIMBAD_CACHE["binaries"] = np.load(path)
+    return archive_SIMBAD_CACHE["binaries"]
+
+
 def archive_simbad_basic(names, columns=("main_id", "otype")):
     """COLUMNS of SIMBAD's basic table for each identifier of NAMES: a dict of name to a dict of column to value."""
     import pyarrow as pa
@@ -458,9 +484,11 @@ def archive_exoplanets(query):
 
 def archive_eso_listing(ra, dec, inst, min_snr=10.0, radius_deg=0.01):
     """The public ESO Phase 3 spectra of a position from one instrument above MIN_SNR, in time order: dp_id, t_min and snr each."""
-    q = ("SELECT dp_id, instrument_name, t_min, snr FROM ivoa.ObsCore WHERE dataproduct_type = 'spectrum' AND "
+    q = ("SELECT dp_id, instrument_name, t_min, snr, obs_release_date FROM ivoa.ObsCore WHERE dataproduct_type = 'spectrum' AND "
          "CONTAINS(POINT('ICRS', s_ra, s_dec), CIRCLE('ICRS', %.5f, %.5f, %g)) = 1" % (ra, dec, radius_deg))
-    return sorted((r for r in archive_tap("eso", q) if r["instrument_name"] == inst and (archive_num(r["snr"]) or 0) > min_snr), key=lambda r: float(r["t_min"]))
+    today = time.strftime("%Y-%m-%d")
+    return sorted((r for r in archive_tap("eso", q) if r["instrument_name"] == inst and (archive_num(r["snr"]) or 0) > min_snr and (r.get("obs_release_date") or "")[:10] <= today),
+                  key=lambda r: float(r["t_min"]))
 
 
 archive_ESO_INDEX = {}
@@ -496,10 +524,10 @@ def archive_eso_fetch(rows, folder, streams=4, most=None, best=False):
 
 
 def archive_gaia_star(ra, dec, vmag=None, radius_arcsec=30.0, physical=True):
-    """A star's Gaia DR3 source, the brightest within RADIUS_ARCSEC of a J2000 position and 2.5 mag of VMAG, with its astrometry, RUWE and velocity
-    summary, and with PHYSICAL its FLAME mass and radius; or None."""
-    q = ("SELECT source_id, ra, dec, parallax, pmra, pmdec, ruwe, phot_g_mean_mag, non_single_star, ipd_frac_multi_peak, radial_velocity, "
-         "radial_velocity_error, rv_amplitude_robust, rv_chisq_pvalue FROM gaiadr3.gaia_source WHERE CONTAINS(POINT('ICRS', ra, dec), "
+    """A star's Gaia DR3 source, the brightest within RADIUS_ARCSEC of a J2000 position and 2.5 mag of VMAG, with its astrometry, RUWE, excess noise
+    and velocity summary, and with PHYSICAL its FLAME mass and radius; or None."""
+    q = ("SELECT source_id, ra, dec, parallax, pmra, pmdec, ruwe, astrometric_excess_noise, astrometric_excess_noise_sig, phot_g_mean_mag, "
+         "non_single_star, ipd_frac_multi_peak, radial_velocity, radial_velocity_error, rv_amplitude_robust, rv_chisq_pvalue FROM gaiadr3.gaia_source WHERE CONTAINS(POINT('ICRS', ra, dec), "
          "CIRCLE('ICRS', %.6f, %.6f, %.6f)) = 1" % (ra, dec, radius_arcsec / 3600.0))
     rows = [r for r in archive_tap("gaia", q) if vmag is None or not math.isfinite(vmag) or abs((archive_num(r["phot_g_mean_mag"]) or 99.0) - vmag) < 2.5]
     if not rows:
@@ -533,13 +561,34 @@ archive_VIZIER = "phanerozoic/VizieR"
 archive_VIZIER_CACHE = {}
 
 
-def archive_vizier(catalogue, table):
-    """A table of the VizieR mirror, cached."""
-    if (catalogue, table) not in archive_VIZIER_CACHE:
+def archive_vizier(catalogue, table, columns=None):
+    """A table of the VizieR mirror, its COLUMNS alone where given, cached."""
+    key = (catalogue, table, tuple(columns) if columns else None)
+    if key not in archive_VIZIER_CACHE:
         import pyarrow.parquet as pq
         from huggingface_hub import hf_hub_download
-        archive_VIZIER_CACHE[(catalogue, table)] = pq.read_table(hf_hub_download(archive_VIZIER, "%s/%s.parquet" % (catalogue, table), repo_type="dataset"))
-    return archive_VIZIER_CACHE[(catalogue, table)]
+        archive_VIZIER_CACHE[key] = pq.read_table(hf_hub_download(archive_VIZIER, "%s/%s.parquet" % (catalogue, table), repo_type="dataset"),
+                                                  columns=list(columns) if columns else None)
+    return archive_VIZIER_CACHE[key]
+
+
+def archive_earth(mjd):
+    """The Earth's barycentric place (AU, equatorial axes of J2000) at the epochs MJD: the opposite of the Sun's geocentric place from its
+    low-precision ecliptic longitude and distance (the Astronomical Almanac's, good to about a hundredth of a degree)."""
+    n = np.asarray(mjd, float) - 51544.5
+    g = np.radians(357.528 + 0.9856003 * n)
+    lam = np.radians(280.460 + 0.9856474 * n + 1.915 * np.sin(g) + 0.020 * np.sin(2.0 * g))
+    r = 1.00014 - 0.01671 * np.cos(g) - 0.00014 * np.cos(2.0 * g)
+    eps = math.radians(23.439)
+    return np.stack([-r * np.cos(lam), -r * np.sin(lam) * math.cos(eps), -r * np.sin(lam) * math.sin(eps)], -1)
+
+
+def archive_parallax_factors(ra, dec, mjd):
+    """The parallax factors of a star at RA, DEC (degrees, or of many as columns of one) at the epochs MJD: its displacement along right ascension (times
+    cos dec) and along declination for a parallax of one, seen from the Earth's barycentric place (archive_earth)."""
+    x, y, z = archive_earth(mjd).T
+    a, d = np.radians(ra), np.radians(dec)
+    return x * np.sin(a) - y * np.cos(a), (x * np.cos(a) + y * np.sin(a)) * np.sin(d) - z * np.cos(d)
 
 
 # Kervella et al.'s (2022) columns, from the authors' release in the mirror, under VizieR's names for them: the Hipparcos-Gaia long-term proper motion
@@ -1394,7 +1443,7 @@ def gpu_ensemble(logp, p0, steps, thin=10, seed=11, graph=False):
             k = (j + torch.randint(1, nb, (na,), device=gpu_DEVICE)) % nb
             xb = x[b]
             gamma = torch.where(torch.rand(1, dtype=gpu_F64, device=gpu_DEVICE) < 0.1, one, g0)
-            prop = x[a] + gamma * (xb[j] - xb[k]) + 1e-5 * torch.randn((na, 1), dtype=gpu_F64, device=gpu_DEVICE)
+            prop = x[a] + gamma * (1.0 + 1e-5 * torch.randn((na, 1), dtype=gpu_F64, device=gpu_DEVICE)) * (xb[j] - xb[k])
             lq = logp(prop)
             take = torch.log(torch.rand(na, dtype=gpu_F64, device=gpu_DEVICE)) < lq - lp[a]
             x[a] = torch.where(take[:, None], prop, x[a])
@@ -1939,7 +1988,7 @@ TESS light curves, and its orbit is sampled.
     merge     the shares joined, each unflagged signal's period tested in the stars' S index
     transitsearch the census stars' TESS light curves searched blind for transits
     eccentric the census's residuals searched by a Keplerian periodogram, eccentric orbits included
-    calibrate the census run blind on the archive's planets and scored on them
+    calibrate the census run blind on the archive's planets and scored on them; with --wobble, the weighing's wobble rule set on Gaia DR3's published solutions
     benchmark the census run on stars whose answers are known: Proxima, alpha Cen A and B, and the Sun from the solar mode
     lbl       a star's line-by-line velocities from its HARPS spectra
     followup  every signal decided, known, new or rejected: the census's, the varying stars' companions and TESS's candidates; signals.csv and
@@ -2045,6 +2094,11 @@ def planets_bank():
 planets_KNOWN = "SELECT hostname, hd_name, hip_name, ra, dec, sy_pmra, sy_pmdec, pl_name, pl_orbper, pl_bmassj, pl_orbeccen, pl_rvamp FROM pscomppars"
 planets_SOLUTIONS = "SELECT pl_name, hostname, hd_name, hip_name, tic_id, ra, dec, sy_pmra, sy_pmdec, pl_orbper FROM ps"
 planets_CATALOGUED = []
+# the Extrasolar Planets Encyclopaedia's catalogue, each of its statuses asked for by its query, and the columns kept of it
+planets_EU = "https://exoplanet.eu/catalog/csv/"
+planets_EU_STATUSES = ("confirmed", "candidate", "controversial", "retracted", "unconfirmed")
+planets_EU_KEYS = ("name", "planet_status", "orbital_period", "ra", "dec", "star_name", "star_alternate_names", "alternate_names", "discovered")
+planets_ENCYCLOPAEDIA = []
 
 
 def planets_archive(days=1.0):
@@ -2067,28 +2121,24 @@ def planets_archive(days=1.0):
     return planets_read(planets_path("solutions.csv"))
 
 
-def planets_catalogued(days=1.0):
-    """A finder match(ra, dec, tic, names, P, radius) of the archive's planets of a star in any published solution, by TIC, name or position, those
-    within 5 per cent of P where given."""
-    if not planets_CATALOGUED:
-        rows = planets_archive(days)
-        col = lambda k: np.array([planets_num(r.get(k)) for r in rows])
-        ra, dec, per = col("ra"), col("dec"), col("pl_orbper")
-        pmra, pmdec = np.nan_to_num(col("sy_pmra")), np.nan_to_num(col("sy_pmdec"))
-        by_tic, by_name = {}, {}
-        for i, r in enumerate(rows):
-            tic = re.sub(r"\D", "", r.get("tic_id") or "")
-            if tic:
-                by_tic.setdefault(int(tic), []).append(i)
-            for c in ("hostname", "hd_name", "hip_name"):
-                if (r.get(c) or "").strip():
-                    by_name.setdefault(archive_simbad_key(r[c]), []).append(i)
-        order = np.argsort(np.nan_to_num(dec, nan=99.0))
-        planets_CATALOGUED.append((np.array([r["pl_name"] for r in rows]), ra, dec, pmra, pmdec, per, by_tic, by_name, order, np.nan_to_num(dec, nan=99.0)[order],
-                                   {r["pl_name"]: r["hostname"] for r in rows}))
-    names_, ra0, dec0, pmra, pmdec, per, by_tic, by_name, order, dsorted, hosts = planets_CATALOGUED[0]
-
-    def match(ra, dec, tic=None, names=(), P=None, radius=60.0):
+def planets_finder(rows):
+    """A finder match(ra, dec, tic, names, P, radius, tolerance) of the planets ROWS, each under the archive's column names with its star's other names in aliases where it has them, of
+    a star by TIC, name or position, those within TOLERANCE of P in period where given; match.host and match.period give each planet's star and period."""
+    col = lambda k: np.array([planets_num(r.get(k)) for r in rows])
+    ra0, dec0, per = col("ra"), col("dec"), col("pl_orbper")
+    pmra, pmdec = np.nan_to_num(col("sy_pmra")), np.nan_to_num(col("sy_pmdec"))
+    by_tic, by_name = {}, {}
+    for i, r in enumerate(rows):
+        tic = re.sub(r"\D", "", r.get("tic_id") or "")
+        if tic:
+            by_tic.setdefault(int(tic), []).append(i)
+        for n in [r.get(c) for c in ("hostname", "hd_name", "hip_name")] + list(r.get("aliases", ())):
+            if (n or "").strip():
+                by_name.setdefault(archive_simbad_key(n), []).append(i)
+    order = np.argsort(np.nan_to_num(dec0, nan=99.0))
+    names_, dsorted = np.array([r["pl_name"] for r in rows]), np.nan_to_num(dec0, nan=99.0)[order]
+
+    def match(ra, dec, tic=None, names=(), P=None, radius=60.0, tolerance=0.05):
         idx = set(by_tic.get(int(tic), ())) if tic not in (None, "") else set()
         for n in names:
             if n:
@@ -2100,11 +2150,87 @@ def planets_catalogued(days=1.0):
             sep = lambda a, d: np.hypot(((a - ra + 180.0) % 360.0 - 180.0) * cosd, d - dec) * 3600.0
             near = np.minimum(sep(ra0[j], dec0[j]), sep(ra0[j] - 16.0 * pmra[j] / 3.6e6 / cosd, dec0[j] - 16.0 * pmdec[j] / 3.6e6)) < radius
             idx.update(j[near].tolist())
-        return sorted({str(names_[i]) for i in idx if P is None or abs(P / per[i] - 1.0) < 0.05})
-    match.host = hosts
+        return sorted({str(names_[i]) for i in idx if P is None or abs(P / per[i] - 1.0) < tolerance})
+    match.host = {r["pl_name"]: r["hostname"] for r in rows}
+    match.period = {r["pl_name"]: planets_num(r.get("pl_orbper")) for r in rows}
     return match
 
 
+def planets_catalogued(days=1.0):
+    """A finder (planets_finder) of the archive's planets of a star in any published solution."""
+    if not planets_CATALOGUED:
+        planets_CATALOGUED.append(planets_finder(planets_archive(days)))
+    return planets_CATALOGUED[0]
+
+
+def planets_encyclopaedia(days=1.0):
+    """A finder (planets_finder) of the planets of the Extrasolar Planets Encyclopaedia (exoplanet.eu), every status of its catalogue (planets_EU_STATUSES), kept as ROOT/exoplanet_eu.csv
+    in order of name and fetched again once DAYS old, the file's time moved first so that one process of those side by side asks, the old copy kept where the site does not answer whole;
+    match.status gives each planet's status and match.cite how a row names it."""
+    if not planets_ENCYCLOPAEDIA:
+        path = planets_path("exoplanet_eu.csv")
+        held = os.path.exists(path)
+        if not held or time.time() - os.path.getmtime(path) >= days * 86400.0:
+            if held:
+                os.utime(path)
+            try:
+                rows = {}
+                for status in planets_EU_STATUSES:
+                    raw = archive_get(planets_EU + "?" + urllib.parse.urlencode({"query_f": '"%s" in planet_status' % status}), timeout=300, retries=2)
+                    got = list(csv.DictReader(io.StringIO(raw.decode("utf-8-sig", "replace"))))
+                    # the query matches the status's words, so that "confirmed" also brings the unconfirmed
+                    if any(status not in r["planet_status"].lower() for r in got) or status == "confirmed" and len(got) < 1000:
+                        raise IOError("%s: %d rows, not all of that status" % (status, len(got)))
+                    rows.update({(r["name"], r["planet_status"]): r for r in got})
+                tmp = archive_tmp(path)
+                planets_write(tmp, [rows[k] for k in sorted(rows)], planets_EU_KEYS)
+                archive_place(tmp, path)
+            except Exception as exc:
+                if not held:
+                    raise
+                print("exoplanet.eu did not answer whole (%s); exoplanet_eu.csv kept" % str(exc)[:120], flush=True)
+        kept = planets_read(path)
+        tic = lambda r: re.search(r"TIC[\s-]*(\d+)", "%s, %s" % (r.get("star_alternate_names"), r.get("alternate_names")))
+        found = planets_finder([dict(pl_name=r["name"], hostname=r["star_name"], ra=r["ra"], dec=r["dec"], pl_orbper=r["orbital_period"], tic_id=tic(r).group(1) if tic(r) else "",
+                                     aliases=(r.get("star_alternate_names") or "").split(",")) for r in kept])
+        found.status = {r["name"]: r["planet_status"].strip().lower() for r in kept}
+        found.cite = {r["name"]: "exoplanet.eu %s, %s%s" % (r["name"], r["planet_status"].strip().lower(), " (%s)" % r["discovered"] if r["discovered"] else "") for r in kept}
+        planets_ENCYCLOPAEDIA.append(found)
+    return planets_ENCYCLOPAEDIA[0]
+
+
+def planets_place(r, stars, exo):
+    """Where a decided row R's star lies and what it is called, as a finder (planets_finder) takes them: a TESS candidate's from its row of ExoFOP's tables EXO, a census star's from STARS,
+    and a star the TESS stage searched from its record's details."""
+    x = exo.get(r["label"]) if r["kind"] in ("validated", "toi") else None
+    if x:
+        return planets_radec(x) + (x.get("TIC ID"), ())
+    s = stars.get(r["name"], {})
+    if not s and r.get("ra") is not None:
+        return planets_num(r["ra"]), planets_num(r["dec"]), r.get("tic"), (r["name"],)
+    return planets_num(s.get("RAJ2000")), planets_num(s.get("DEJ2000")), None, (r["name"], s.get("SimbadName"))
+
+
+def planets_encyclopaedia_decide(sig, stars):
+    """The rows of SIG the decisions make new or leave candidates set against the Encyclopaedia (planets_encyclopaedia) at their stars, within 5 per cent in period or 25 per cent for a
+    companion, whose long orbit the data bound less closely, each entry named in the row's catalogued. A body it lists as retracted alone is rejected. A TESS candidate is known where it
+    lists it as confirmed, an independent validation where validated, since the catalogue's candidates include the TOIs themselves. Any other body it lists is known."""
+    found = planets_encyclopaedia()
+    exo = {x["label"]: x for source in ("toi", "ctoi") if os.path.exists(planets_path(source + ".csv")) for x in planets_candidates(source)}
+    for r in sig:
+        if r["status"] not in ("new", "candidate"):
+            continue
+        hits = found(*planets_place(r, stars, exo), planets_num(r.get("orbit_P") or r["P"]), tolerance=0.25 if r["kind"] == "companion" else 0.05)
+        if not hits:
+            continue
+        said = {found.status[n] for n in hits}
+        r["catalogued"] = "; ".join([x for x in (r.get("catalogued"),) if x] + [found.cite[n] for n in hits])
+        if said == {"retracted"}:
+            r.update(status="rejected", reason="retracted")
+        elif r["kind"] not in ("validated", "toi") or "confirmed" in said:
+            r.update(status="known", reason="catalogued", contribution="independent validation" if r["kind"] == "validated" else "")
+
+
 def planets_radec(x):
     """A TESS candidate's J2000 position (deg) from its ExoFOP row, sexagesimal or decimal; NaN where unreadable."""
     def angle(text, scale):
@@ -3358,6 +3484,62 @@ def planets_calibrate():
     print("  %d found signals match no catalogued planet or alias, %d of them without flags" % (len(extra), res["extra_unflagged"]), flush=True)
 
 
+def planets_wobble_calibration():
+    """The weighing's rule on the wobble (planets_weigh_holds) set on what Gaia DR3 publishes, to RESULTS/wobble_calibration.json: its two-body solutions that hold an
+    astrometric orbit and its accelerations, of stars brighter than G 13, read from ESA's archive in 48 parts of source_id with each star's excess noise. Each solution's
+    photocentre over Gaia's window, its Thiele-Innes elements' orbit or its acceleration's polynomial, leaves about a five-parameter solution of the star the wobble
+    planets_weigh reads, the root mean square along one axis; that wobble over the excess noise, or over 0.3 mas where that is not significant, gives by steps of wobble the
+    percentiles of each kind of solution, the 99th being the table the rule holds (planets_WOBBLE_P99), and the share of each kind the rule turns down."""
+    top, parts = 6917528997577384320, 48
+    tg, tref = np.linspace(56863.0, 57901.0, 40), 57388.5
+    dt = (tg - tref) / 365.25
+
+    def read(select, table, where):
+        rows = []
+        for k in range(parts):
+            lo, hi = top // parts * k, top // parts * (k + 1) if k < parts - 1 else top + 1
+            rows += archive_tap("gaia", "SELECT %s, g.ra, g.dec, g.astrometric_excess_noise, g.astrometric_excess_noise_sig FROM gaiadr3.%s AS o JOIN gaiadr3.gaia_source AS g "
+                                        "ON o.source_id = g.source_id WHERE o.source_id >= %d AND o.source_id < %d AND g.phot_g_mean_mag < 13 AND %s" % (select, table, lo, hi, where))
+        return {key: np.array([planets_num(r[key]) for r in rows]) for key in rows[0]}
+
+    def wobble(x, da, dd):
+        # the root mean square along one axis of the offsets DA, DD (solutions, epochs; mas) about each star's position, proper motion and parallax fitted to them
+        out = []
+        for i in range(0, len(da), 8192):
+            fa, fd = archive_parallax_factors(x["ra"][i:i + 8192, None], x["dec"][i:i + 8192, None], tg)
+            one, zero, t = np.ones(fa.shape), np.zeros(fa.shape), np.tile(dt, (len(fa), 1))
+            A = gpu_dev(np.stack([np.concatenate(c, 1) for c in ((one, zero), (zero, one), (t, zero), (zero, t), (fa, fd))], 2))
+            y = gpu_dev(np.concatenate([da[i:i + 8192], dd[i:i + 8192]], 1))
+            c = gpu_solve_spd(A.transpose(1, 2) @ A, (A.transpose(1, 2) @ y[:, :, None])[:, :, 0])
+            out.append(gpu_host(torch.sqrt(((y - (A @ c[:, :, None])[:, :, 0]) ** 2).mean(1))))
+        return np.concatenate(out)
+    o = read("o.period, o.eccentricity, o.t_periastron, o.a_thiele_innes, o.b_thiele_innes, o.f_thiele_innes, o.g_thiele_innes", "nss_two_body_orbit", "o.a_thiele_innes IS NOT NULL")
+    e = np.nan_to_num(o["eccentricity"])[:, None]
+    E = gpu_host(gpu_anomaly(tg[None, :], o["period"][:, None], tref + np.nan_to_num(o["t_periastron"])[:, None], e))
+    X, Y = np.cos(E) - e, np.sqrt(1.0 - e * e) * np.sin(E)
+    a = read("o.accel_ra, o.accel_dec, o.deriv_accel_ra, o.deriv_accel_dec", "nss_acceleration_astro", "o.accel_ra IS NOT NULL")
+    bend = lambda g, j: 0.5 * g[:, None] * dt ** 2 + np.nan_to_num(j)[:, None] * dt ** 3 / 6.0
+    kinds = (("orbit", o, wobble(o, o["b_thiele_innes"][:, None] * X + o["g_thiele_innes"][:, None] * Y, o["a_thiele_innes"][:, None] * X + o["f_thiele_innes"][:, None] * Y)),
+             ("acceleration", a, wobble(a, bend(a["accel_ra"], a["deriv_accel_ra"]), bend(a["accel_dec"], a["deriv_accel_dec"]))))
+    edges = (0.3,) + planets_WOBBLE_STEPS + (float("inf"),)
+    out = {}
+    for kind, x, w in kinds:
+        keep = np.isfinite(w) & np.isfinite(x["astrometric_excess_noise"])
+        w, ratio = w[keep], w[keep] / np.maximum(np.where(x["astrometric_excess_noise_sig"][keep] > 2.0, x["astrometric_excess_noise"][keep], 0.0), 0.3)
+        limit = np.array(planets_WOBBLE_P99[kind])[np.searchsorted(planets_WOBBLE_STEPS, w, side="right")]
+        steps = []
+        for lo, hi in zip(edges, edges[1:]):
+            m = (w >= lo) & (w < hi)
+            q = np.percentile(ratio[m], [50, 84, 95, 99])
+            steps.append(dict(wobble_from=lo, wobble_to=hi if math.isfinite(hi) else None, solutions=int(m.sum()), p50=round(float(q[0]), 2), p84=round(float(q[1]), 2), p95=round(float(q[2]), 2),
+                              p99=round(float(q[3]), 2)))
+        out[kind] = dict(solutions=len(w), turned_down=round(float(np.mean(ratio > limit)), 4), steps=steps)
+        print("%s: %d solutions, the rule turns down %.2f per cent" % (kind, len(w), 100.0 * out[kind]["turned_down"]), flush=True)
+        for s in steps:
+            print("  wobble from %5.2f mas: %6d solutions, ratio at 50 per cent %.2f, 84 %.2f, 95 %.2f, 99 %.2f" % (s["wobble_from"], s["solutions"], s["p50"], s["p84"], s["p95"], s["p99"]), flush=True)
+    archive_save(os.path.join(planets_RESULTS, "wobble_calibration.json"), json.dumps(out, separators=(",", ":")).encode())
+
+
 def planets_cal_age(path, mjd):
     """The days between a HARPS spectrum at MJD and the ThAr exposure its wavelengths come from, read from the DRS's CAL TH FILE keyword, or NaN."""
     from astropy.io import fits
@@ -3761,7 +3943,8 @@ def planets_rotation(bv, s):
 def planets_decide(res, P, system, tess, prot=None):
     """Whether a followed signal at P is a planet, and if not why: it must hold in two independent reductions with no indicator at P, raise the joint
     model's BIC by more than 10 when removed, have no preferred alias, show no TESS brightness variation at P, P/2 or 2P (the strongest period, or power
-    0.1 or more), lie more than 10 per cent from the star's rotation period PROT and half of it, and leave its system stable on circular orbits."""
+    0.1 or more, in PDCSAP flux, QLP's detrended flux having had a star's slow variation taken out), lie more than 10 per cent from the star's rotation period PROT and half of it, and leave its
+    system stable on circular orbits."""
     held, _, ind, _ = planets_verdict(res, P)
     if ind:
         return False, "activity indicator"
@@ -3776,6 +3959,7 @@ def planets_decide(res, P, system, tess, prot=None):
         if a["observed_ratio"] < 1.0 and a["truth"].get("%.4f d" % P, {}).get("reaching_observed", 1.0) < 0.01:
             return False, "alias"
     c = (tess or {}).get("combined")
+    c = None if c and c.get("flux") == "detrended" else c
     if c and float(c["fap"]) < 0.01 and any(abs(c["peak_d"] / q - 1.0) < 0.05 for q in (P, P / 2.0, 2.0 * P)):
         return False, "starspots"
     for label, power in (c or {}).get("near", {}).items():
@@ -3952,7 +4136,7 @@ def planets_companion(name, perms=50, most=40, seed=17):
             planets_weigh(name, pmin=0.75 * P0, pmax=1.25 * P0) if span >= 2.0 * P0 else planets_weigh(name)
             w = json.load(open(os.path.join(planets_RESULTS, "weigh", archive_tag(name) + ".json")))
             rec["weigh"] = {k: w[k] for k in ("P_d", "e", "K1_ms", "m2_mjup", "incl_deg", "a_au", "acceleration", "velocity_trend", "p_below_13mjup",
-                                              "p_below_80mjup", "period_allowed")}
+                                              "p_below_80mjup", "period_allowed", "wobble_mas", "excess_noise_mas", "excess_noise_sig") if k in w}
         except BaseException as exc:
             rec["weigh_error"] = str(exc)[:200]
     gs = archive_gaia_star(float(star["RAJ2000"]), float(star["DEJ2000"]), archive_num(star.get("Vmag")), physical=False)
@@ -3996,8 +4180,41 @@ def planets_companion(name, perms=50, most=40, seed=17):
     print(json.dumps(rec), flush=True)
 
 
+# The 99th percentile of the wobble over Gaia's excess noise, or over 0.3 mas where that is not significant, among the orbits and the accelerations Gaia DR3 publishes, in steps
+# of wobble ending at planets_WOBBLE_STEPS (mas) and a last step above them (planets_wobble_calibration)
+planets_WOBBLE_STEPS = (0.4, 0.5, 0.65, 0.8, 1.0, 1.25, 1.6, 2.0, 2.5)
+planets_WOBBLE_P99 = dict(orbit=(1.30, 1.58, 1.87, 2.06, 2.12, 2.39, 2.44, 2.42, 2.49, 3.06), acceleration=(1.32, 1.65, 2.10, 2.56, 3.09, 3.63, 4.26, 5.07, 5.76, 8.83))
+
+
+def planets_weigh_noise(w):
+    """The wobble a weighing (planets_weigh) sets against Gaia's astrometric excess noise, the posterior's median in mas, and that noise, 0.3 mas where it is not significant."""
+    eps, sig = w.get("excess_noise_mas"), w.get("excess_noise_sig")
+    return w["wobble_mas"][0], max(eps if eps is not None and sig is not None and sig > 2.0 else 0.0, 0.3)
+
+
+def planets_weigh_holds(w):
+    """Whether a weighing's orbit (planets_weigh) stands against Gaia's astrometric excess noise: the wobble its photocentre leaves about Gaia's five-parameter solution within what
+    99 per cent of Gaia DR3's published solutions of that wobble leave against their own noise (planets_WOBBLE_P99), its accelerations where the star has one and its orbits
+    otherwise. A weighing made before the wobble was read holds."""
+    if not w.get("wobble_mas"):
+        return True
+    wobble, noise = planets_weigh_noise(w)
+    return wobble <= planets_WOBBLE_P99["acceleration" if w.get("acceleration") else "orbit"][int(np.searchsorted(planets_WOBBLE_STEPS, wobble, side="right"))] * noise
+
+
+def planets_weigh_agrees(w):
+    """Whether a weighing's orbit (planets_weigh) agrees with Gaia's astrometric excess noise closely enough for its mass to stand: its wobble at most 1.65 times that noise, twice
+    the quarter in log the weighing allows above it, which 95 per cent of Gaia DR3's published orbits near a milliarcsecond's wobble keep within. A weighing made before the wobble
+    was read agrees."""
+    if not w.get("wobble_mas"):
+        return True
+    wobble, noise = planets_weigh_noise(w)
+    return wobble <= math.exp(0.5) * noise
+
+
 def planets_decide_companion(rec):
-    """A companion analysis's verdict and reason: 10+ nights, FAP < 1e-3, period fixed by a margin of 10 or by astrometry, second reduction at r >= 0.9."""
+    """A companion analysis's verdict and reason: 10+ nights, FAP < 1e-3, period fixed by a margin of 10 or by astrometry whose orbit stands against Gaia's
+    excess noise (planets_weigh_holds), second reduction at r >= 0.9."""
     if rec["nights"] < 10:
         return False, "few nights"
     if rec["cycles"] < 2.0:
@@ -4007,6 +4224,8 @@ def planets_decide_companion(rec):
             return False, "under two cycles"
         if not ((rec.get("pma_snr") or 0.0) >= 5.0 or w.get("acceleration") or w.get("velocity_trend")):
             return False, "not significant"
+        if not planets_weigh_holds(w):
+            return False, "astrometry inconsistent"
         # the periods the profile allows (planets_weigh), or for a weighing without one the sampled 16th to 84th percentiles
         a, b = (w["period_allowed"][0][0], w["period_allowed"][-1][1]) if w.get("period_allowed") else (w["P_d"][1], w["P_d"][2])
         lo, hi = max(0.5 * rec["span_d"], 50.0), 36525.0
@@ -4040,7 +4259,8 @@ def planets_companion_row(name, star, rec, cat):
         P, K, e = rec["P"], rec["K"], rec["e"]
     msini = planets_msini(P, K, e, m1)
     row.update(P=round(P, 4), K=round(K, 2), e=round(e, 3), msini_mjup=round(msini, 4), msini_mearth=round(msini * 317.83, 1))
-    if w:
+    # the true mass where the weighing's orbit agrees with Gaia's excess noise; the minimum mass stands where it does not
+    if w and planets_weigh_agrees(w):
         row.update(mass_mjup=round(w["m2_mjup"][0], 3), mass_mjup_lo=round(w["m2_mjup"][1], 3), mass_mjup_hi=round(w["m2_mjup"][2], 3))
     held, why = planets_decide_companion(rec)
     row.update(status=("known" if cat else "new") if held else "rejected", reason=("catalogued" if cat else "") if held else why,
@@ -4206,11 +4426,18 @@ def planets_validation_decision(v, x, rv, events):
     sec, sig = v.get("depth_secondary_ppm"), v.get("secondary_sigma")
     most = planets_occultation_max(x, v.get("depth_ppm", 0.0), P)
     excess = (sec - most) / (sec / sig) if sec and sig and sig > 0 else 0.0
-    own = "not vetted" if "odd_even_sigma" not in v else "odd-even depths" if (v["odd_even_sigma"] or 0.0) >= 3.0 else "secondary eclipse" if excess >= 3.0 else ""
+    checks = planets_check_cols(v, P, x)
+    # a transit its star leaves no room for, as 1 of 1,373 confirmed planets' and 83 of 1,111 false positives' on ExoFOP's stars and durations are
+    phys = planets_transit_physical(dict(P=P, depth_ppm=planets_num(x.get("Depth (ppm)")), duration_h=planets_num(x.get("Duration (hours)"))), x.get("Stellar Radius (R_Sun)"), x.get("Stellar Mass (M_Sun)"))
+    own = "not vetted" if "odd_even_sigma" not in v else "odd-even depths" if (v["odd_even_sigma"] or 0.0) >= 3.0 else "secondary eclipse" if excess >= 3.0 else \
+        "variability" if planets_transit_smooth(v) else "a neighbour's variability" if v.get("variable_neighbours") else \
+        "astrometric binary" if (checks.get("ruwe") or 0.0) >= planets_RUWE_MAX else "source off the star" if planets_centroid_off(v) else \
+        "the star's rotation" if (checks.get("gaia_vbroad") or 0.0) >= planets_SPIN_FAST and planets_SPIN_LOW <= (checks.get("spin_ratio") or 0.0) <= planets_SPIN_HIGH else \
+        "inside the star" if phys.startswith("orbit") else "duration" if phys else ""
     near = [e for e in events.get(str(v["tic"]), []) if abs(e["tce_period"] / P - 1.0) < 0.01]
     cols, why = planets_dv(max(near, key=lambda e: e["tce_num_transits"] if math.isfinite(e["tce_num_transits"]) else -1.0)) if near else ({}, "")
     cols.update(odd_even_sigma=v.get("odd_even_sigma", ""), secondary_sigma=v.get("secondary_sigma", ""), occultation_max_ppm=round(most, 1),
-                secondary_excess_sigma=round(excess, 2))
+                secondary_excess_sigma=round(excess, 2), **checks)
     return ("rejected" if own or why else "new"), own or why, cols
 
 
@@ -4218,7 +4445,9 @@ def planets_validated_rows(tois):
     """The TESS candidates validated statistically (RESULTS/validate/, planets_validate) as decided signals.csv rows. A candidate is new where its
     false-positive probability lies below 0.015 and its nearby-false-positive probability below 0.001 (Giacalone et al. 2021), each the mean of ten
     runs, ExoFOP's radius is below two Jupiter radii, the light curves it was weighed from show its odd and even transits' depths within 3 sigma of
-    each other and no dip of 3 sigma half an orbit on, and SPOC's data validation of its threshold-crossing event, its TIC star's event within 1 per
+    each other, no dip of 3 sigma half an orbit on, a transit's box rather than the star's own variation at the period (planets_transit_smooth), Gaia's RUWE
+    below planets_RUWE_MAX, a dip's source not placed off the star (planets_centroid_off), no star spinning at planets_SPIN_FAST or more with the period at its spin's limit (planets_check_cols),
+    an orbit and a transit's length its star allows (planets_transit_physical), and SPOC's data validation of its threshold-crossing event, its TIC star's event within 1 per
     cent of its period with the most transits, finds nothing against it where SPOC raised one (planets_dv), unless velocities weighed at its transits
     (TOIS, planets_toi_rows) put a star or brown dwarf there or a phase other than the transit's, and not decided again where those velocities already
     made it new; a pass from fewer runs waits for the rest, a pass weighed without those checks is not vetted, and the rest are rejected with why. A
@@ -4315,16 +4544,16 @@ def planets_list(rows, stars):
                 return None, None
             stellar[key] = [archive_num(row["Jmag"]), archive_num(row["Kmag"])]
         return tuple(stellar[key])
-    match, discoverer = planets_catalogued(), planets_discoverers()
+    match, discoverer, eu = planets_catalogued(), planets_discoverers(), planets_encyclopaedia()
+    hosts = dict(eu.host, **match.host)
 
     def archived(r):
-        x = exo.get(r["label"]) if r["kind"] in ("validated", "toi") else None
-        if x:
-            return match(*planets_radec(x), x.get("TIC ID"), (), None, 10.0)
-        s = stars.get(r["name"], {})
-        if not s and r.get("ra") is not None:
-            return match(planets_num(r["ra"]), planets_num(r["dec"]), r.get("tic"), (r["name"],), None, 10.0)
-        return match(planets_num(s.get("RAJ2000")), planets_num(s.get("DEJ2000")), None, (r["name"], s.get("SimbadName")), None, 10.0)
+        # the archive's planets of the star and those the Encyclopaedia holds of it beside them, for a TESS candidate its confirmed ones, its candidates including the TOIs themselves
+        where = planets_place(r, stars, exo)
+        listed = match(*where, None, 10.0)
+        said = ("confirmed",) if r["kind"] in ("validated", "toi") else ("confirmed", "candidate", "controversial", "unconfirmed")
+        same = lambda n, m: match.period[m] > 0 and abs(eu.period[n] / match.period[m] - 1.0) < 0.05
+        return listed + [n for n in eu(*where, None, 10.0) if eu.status[n] in said and n not in listed and not any(same(n, m) for m in listed)]
     out = []
     for r in sorted(new, key=lambda x: (x["name"], float(x["P"]))):
         host = host_of(r["name"])
@@ -4336,7 +4565,7 @@ def planets_list(rows, stars):
                                  [n.split()[-1] for n in listed if re.fullmatch(r"[a-z]", n.split()[-1])])) + 1)
             taken[r["name"]] = letter
         stem = r["label"].split(".")[0] if r["kind"] == "toi" else stems.get(r["name"], r["name"]) if r["kind"] == "validated" else host
-        stem = match.host[listed[0]] if listed else stem
+        stem = hosts[listed[0]] if listed else stem
         pick = lambda col, fallback: r.get(col) if r.get(col) not in (None, "") else fallback
         teff, rs, ms, rp = star_of(r)
         P = planets_num(pick("orbit_P", r["P"]))
@@ -4344,7 +4573,7 @@ def planets_list(rows, stars):
         # the mass: weighed with the astrometry, or from the velocities, a transiting candidate's at the inclination of its transit and the others' least
         msini = archive_num(pick("orbit_msini_mearth", r["msini_mearth"]))
         mass, basis = (archive_num(r.get("mass_mjup")) * 317.83, "measured") if archive_num(r.get("mass_mjup")) else \
-            (msini, "measured" if r["kind"] == "toi" else "minimum") if msini and r["kind"] != "validated" else (None, "")
+            (msini, "measured" if r["kind"] in ("toi", "transit") else "minimum") if msini and r["kind"] != "validated" else (None, "")
         character = planets_character(r["object"], P, teff, rs, ms, rp, mass, basis, *mags_of(r), teq)
         out.append(dict(planet="%s %s" % (stem, letter), host=host, kind=r["object"], found_by={"found": "census", "eccentric": "eccentric search", "companion": "companions",
                                                                                                  "toi": "TESS", "validated": "validation",
@@ -4353,9 +4582,12 @@ def planets_list(rows, stars):
                         P_d=pick("orbit_P", r["P"]), P_lo=r.get("orbit_P_lo", ""), P_hi=r.get("orbit_P_hi", ""), K_ms=pick("orbit_K", r["K"]),
                         K_lo=r.get("orbit_K_lo", ""), K_hi=r.get("orbit_K_hi", ""), e=pick("orbit_e", r["e"]),
                         e_lo=r.get("orbit_e_lo", ""), e_hi=r.get("orbit_e_hi", ""), msini_mearth=pick("orbit_msini_mearth", r["msini_mearth"]),
-                        msini_mearth_lo=r.get("orbit_msini_mearth_lo", ""), msini_mearth_hi=r.get("orbit_msini_mearth_hi", ""), msini_mjup=r["msini_mjup"],
+                        msini_mearth_lo=r.get("orbit_msini_mearth_lo", ""), msini_mearth_hi=r.get("orbit_msini_mearth_hi", ""),
+                        msini_mjup=round(msini / 317.83, 4) if msini else r["msini_mjup"],
                         mass_mjup=r.get("mass_mjup", ""), mass_mjup_lo=r.get("mass_mjup_lo", ""), mass_mjup_hi=r.get("mass_mjup_hi", ""), nights=r["nights"],
-                        span_d=r["span_d"], prediction=r.get("prediction", ""), fpp=r.get("fpp", ""), nfpp=r.get("nfpp", ""),
+                        span_d=r["span_d"], prediction=r.get("prediction", ""), second_instrument=r.get("second_instrument", ""), second_nights=r.get("second_nights", ""),
+                        second_scale=r.get("second_scale", ""), second_scale_err=r.get("second_scale_err", ""), second_phase_sigma=r.get("second_phase_sigma", ""), second_test=r.get("second_test", ""),
+                        fpp=r.get("fpp", ""), nfpp=r.get("nfpp", ""),
                         sunlight=round(sunlight, 3) if sunlight else "", teq_k=round(teq) if teq else "", habitable_zone=zone or "", **character,
                         bank_name=r["name"]))
     json.dump(stellar, open(kept, "w"), separators=(",", ":"))
@@ -4483,7 +4715,8 @@ planets_DECISION_KEYS = ["status", "reason", "contribution", "discovered_by", "o
                          "orbit_K", "orbit_K_lo", "orbit_K_hi", "mass_mjup", "mass_mjup_lo", "mass_mjup_hi", "fap_serval", "fap_drs", "fap_lbl", "fap_lbl_quiet",
                          "dbic", "aliases_excluded", "tess_power", "tess_radius_limit_rearth", "rotation_d", "ruwe", "pma_snr", "catalogued", "fpp", "nfpp",
                          "radius_rearth", "odd_even_sigma", "secondary_sigma", "occultation_max_ppm", "secondary_excess_sigma", "dv_odd_even", "dv_secondary_mes", "dv_centroid_sigma", "dv_core", "dv_halo",
-                         "t0_btjd", "depth_ppm", "duration_h", "transit_snr", "transits", "single_event_share"]
+                         "t0_btjd", "depth_ppm", "duration_h", "transit_snr", "transits", "single_event_share", "centroid_arcsec", "centroid_err", "centroid_sigma", "gaia_vbroad", "spin_ratio",
+                         "second_instrument", "second_nights", "second_scale", "second_scale_err", "second_phase_sigma", "second_test"]
 
 
 def planets_followup(workers=6, report=False):
@@ -4605,12 +4838,15 @@ def planets_followup(workers=6, report=False):
     cats = planets_catalogue(sorted(recs), stars, {n: period(rec) for n, rec in recs.items()})
     rows += [planets_companion_row(n, stars[n], rec, cats[n]) for n, rec in sorted(recs.items())]
     tois = planets_toi_rows()
-    transit = planets_transit_rows(stars)
-    # a root of the TESS stage keeps the transit signals that pass the search's vetting alone, its rejections counted in its records
+    # a root of the TESS stage keeps the transit signals that pass the search's vetting alone, its rejections counted in its records, each star decided once
     if os.path.exists(planets_path("tess.json")):
-        transit = [r for r in transit if r["status"] != "rejected"]
+        transit = [r for r in planets_transit_kept(stars) if r["status"] != "rejected"]
+    else:
+        transit = planets_transit_rows(stars, full=True)
     rows += tois + planets_validated_rows(tois) + transit
     sig += rows
+    planets_encyclopaedia_decide(sig, stars)
+    planets_second_decide(sig)
     # Apply the verdicts of planets ledger: a new body whose predicted orbit failed against later observations is rejected.
     lpath, kinds = os.path.join(planets_RESULTS, "ledger.csv"), {"census": "found", "eccentric search": "eccentric", "companions": "companion", "TESS": "toi",
                                                                  "validation": "validated", "transit search": "transit"}
@@ -4653,17 +4889,17 @@ def planets_orbits(name, periods, steps=30000, mstar=None, ebound=0.9, others=Tr
     a jitter, and every DACE instrument family outside HARPS with 5 nights or more (all but the bank's left out where OTHERS is false), each era with its
     offset and each family with its jitter.
     Nights more than six scaled median absolute deviations and five median errors from the circular fit are set aside, at most one in twenty, as the
-    census sets them aside. One Keplerian per starting period, each with its period (within 20 per cent of the start), time of periastron, sqrt(e) cos omega, sqrt(e) sin omega (e
+    census sets them aside. One Keplerian per starting period, each with its period (within 20 per cent of the start), time of inferior conjunction, which a nearly circular orbit fixes where it leaves periastron free, sqrt(e) cos omega, sqrt(e) sin omega (e
     below EBOUND) and semi-amplitude, started from a circular least-squares fit carried to the likelihood's maximum by Levenberg-Marquardt and sampled for
     STEPS steps by differential-evolution moves on the device (gpu_ensemble), the second half of the chain kept; with CIRCULAR every eccentricity is held at
     zero and the rest sampled about the circular fit. The medians and 16th to 84th percentiles of each period, K, e, minimum mass for a star of MSTAR solar
-    masses (the spectral type's by default) and time of inferior conjunction, the best fit's scatter, the chain's autocorrelation time (emcee's estimate),
+    masses (by default Gaia's FLAME mass as ROOT/stellar.json keeps it, else the spectral type's) and time of inferior conjunction, the best fit's scatter, the chain's autocorrelation time (emcee's estimate),
     and its log-likelihood beside that of the same orbits held circular; with CIRCULAR to <name>.circular.json, with LABEL to <name>.<label>.json. 256
     posterior draws of each planet's (P, tp, e, omega, K) go to the .draws.npz file beside the JSON, as one array (planet, draw, parameter) named draws.
     EXTRA is an .npz file of additional nightly velocities (mjd, rv, rv_err in m/s), fitted as a separate series with its own offset and jitter."""
     import emcee
     star = next(r for r in planets_read(planets_path("bank_stars.csv")) if r["Name"] == name)
-    mstar = mstar or planets_mass(star.get("SpType"))
+    mstar = mstar or ((planets_load_json(planets_path("stellar.json")) or {}).get(name) or [None] * 3)[2] or planets_mass(star.get("SpType"))
     groups, jgroups, T, Vv, Ee = [], [], [], [], []
     x = np.array(planets_bank_series({name}).get(name, []))
     for g, sel in enumerate((x[:, 0] < planets_UPGRADE, x[:, 0] >= planets_UPGRADE)):
@@ -4706,9 +4942,13 @@ def planets_orbits(name, periods, steps=30000, mstar=None, ebound=0.9, others=Tr
         """Velocities for parameter rows Q (b, d), a tensor, each eccentricity held below CAP where given."""
         m = q[:, :ng][:, Gt]
         for i in range(n):
-            P, tp, sc, ss, K = (q[:, ng + nj + 5 * i + j:ng + nj + 5 * i + j + 1] for j in range(5))
+            P, tc, sc, ss, K = (q[:, ng + nj + 5 * i + j:ng + nj + 5 * i + j + 1] for j in range(5))
             ecc = sc * sc + ss * ss
-            m = m + K * gpu_keplerian(Tt[None, :], P, tp, ecc if cap is None else torch.clamp(ecc, max=cap), torch.atan2(ss, sc))
+            ecc = ecc if cap is None else torch.clamp(ecc, max=cap)
+            w = torch.atan2(ss, sc)
+            # the time of periastron from the conjunction, where the true anomaly is pi/2 - omega
+            E = 2 * torch.atan2(torch.sqrt(1 - ecc) * torch.sin(math.pi / 4 - w / 2), torch.sqrt(1 + ecc) * torch.cos(math.pi / 4 - w / 2))
+            m = m + K * gpu_keplerian(Tt[None, :], P, tc - P * (E - ecc * torch.sin(E)) / (2 * math.pi), ecc, w)
         return m
 
     def logp(q):
@@ -4716,8 +4956,8 @@ def planets_orbits(name, periods, steps=30000, mstar=None, ebound=0.9, others=Tr
         jit = q[:, ng:ng + nj]
         ok = ((jit >= 0) & (jit < 50)).all(1)
         for i in range(n):
-            P, tp, sc, ss, K = (q[:, ng + nj + 5 * i + j] for j in range(5))
-            ok = ok & (0.8 * periods[i] < P) & (P < 1.2 * periods[i]) & (K > 0) & (sc * sc + ss * ss < ebound) & ((tp - t0).abs() < P)
+            P, tc, sc, ss, K = (q[:, ng + nj + 5 * i + j] for j in range(5))
+            ok = ok & (0.8 * periods[i] < P) & (P < 1.2 * periods[i]) & (K > 0) & (sc * sc + ss * ss < ebound) & ((tc - t0).abs() < P)
         s2 = E2t[None, :] + jit[:, Jt] ** 2
         r = Vt[None, :] - model(q, ebound)
         lp = -0.5 * (r * r / s2 + torch.log(2 * math.pi * s2)).sum(1)
@@ -4735,8 +4975,8 @@ def planets_orbits(name, periods, steps=30000, mstar=None, ebound=0.9, others=Tr
     p = list(c[:ng]) + [1.0] * nj
     for i, P in enumerate(periods):
         A, B = c[ng + 2 * i], c[ng + 2 * i + 1]
-        # the eccentricity starts at 0.01, or inside EBOUND where that is tighter
-        p += [P, t0 + P * math.atan2(B, A) / (2 * np.pi), min(0.1, 0.5 * math.sqrt(ebound)), 0.0, max(math.hypot(A, B), 0.3)]
+        # the conjunction a quarter of an orbit after the velocity's peak; the eccentricity starts at 0.01, or inside EBOUND where that is tighter
+        p += [P, t0 + P * (math.atan2(B, A) / (2 * np.pi) + 0.25), min(0.1, 0.5 * math.sqrt(ebound)), 0.0, max(math.hypot(A, B), 0.3)]
     ecc_idx = [ng + nj + 5 * i + j for i in range(n) for j in (2, 3)]
     free_idx = [i for i in range(len(p)) if i not in ecc_idx]
 
@@ -4798,13 +5038,20 @@ def planets_orbits(name, periods, steps=30000, mstar=None, ebound=0.9, others=Tr
     ndim = len(sampled)
     nw = max(4 * ndim, 48)
     rng = np.random.default_rng(seed)
-    # the walkers spread by 0.1 m/s in offsets and jitters and, per orbit, 1e-4 P in P, 0.01 P in tp, 0.02 in each sqrt(e) term and 0.05 K in K
+    # the walkers spread by half the likelihood's own width in each parameter at the fit, the others held, and at most by 0.1 m/s in offsets and jitters and, per orbit,
+    # 1e-4 P in P, 0.01 P in the conjunction, 0.02 in each sqrt(e) term and 0.05 K in K
     scale = np.full(len(best), 0.1)
     for i in range(n):
         j = ng + nj + 5 * i
         se = min(0.02, 0.3 * math.sqrt(ebound))
         scale[j:j + 5] = (1e-4 * centre[j], 0.01 * centre[j], se, se, max(0.05 * centre[j + 4], 0.05))
     scale, c0 = scale[sampled], centre[sampled]
+    step_ = 0.01 * scale
+    bump = np.diag(step_)
+    lp0, up_, dn_ = lnprob_s(c0)[0], lnprob_s(c0 + bump), lnprob_s(c0 - bump)
+    with np.errstate(all="ignore"):
+        wide = 0.5 / np.sqrt(np.maximum(-(up_ + dn_ - 2.0 * lp0) / step_ ** 2, 0.0))
+    scale = np.where(np.isfinite(wide) & (wide > 0), np.minimum(wide, scale), scale)
     p0 = c0 + scale * rng.standard_normal((nw, ndim))
     bad = ~np.isfinite(lnprob_s(p0))
     while bad.any():
@@ -4820,31 +5067,21 @@ def planets_orbits(name, periods, steps=30000, mstar=None, ebound=0.9, others=Tr
     res = dict(name=name, mstar=mstar, series=labels, nights=len(t), set_aside=int(len(aside)), span=round(float(t.max() - t.min())),
                first_mjd=round(float(t.min()), 3), last_mjd=round(float(t.max()), 3), lnl_free=round(lnl_free, 2), lnl_circular=round(lnl_circ, 2),
                circular=bool(circular), rms_best=round(float(np.std(v - gpu_host(model(gpu_dev(centre[None, :])))[0])), 2), jitter={jl: pct(ch[:, ng + j]) for j, jl in enumerate(jlabels)},
-               acceptance=round(float(np.mean(accept)), 3), steps=steps, walkers=nw,
+               acceptance=round(float(np.mean(accept)), 3), steps=steps, walkers=nw, phase="conjunction",
                autocorrelation_steps=round(10.0 * float(np.max(emcee.autocorr.integrated_time(kept, quiet=True))), 1), planets=[])
-    def conjunction(q):
-        """The times of inferior conjunction, where a transit would fall, of parameter rows Q for each planet, the one nearest the series' median time."""
-        out_ = []
-        for i in range(n):
-            P, tp, sc, ss = (q[:, ng + nj + 5 * i + j] for j in range(4))
-            ecc = sc * sc + ss * ss
-            nu = np.pi / 2 - np.arctan2(ss, sc)
-            E = 2 * np.arctan2(np.sqrt(1 - ecc) * np.sin(nu / 2), np.sqrt(1 + ecc) * np.cos(nu / 2))
-            tc = tp + P * (E - ecc * np.sin(E)) / (2 * np.pi)
-            out_.append(tc + P * np.round((t0 - tc) / P))
-        return out_
-    tc0 = conjunction(centre[None, :])
-    tcs = conjunction(ch)
     draws = []
     for i in range(n):
         P, K = ch[:, ng + nj + 5 * i], ch[:, ng + nj + 5 * i + 4]
         ecc = ch[:, ng + nj + 5 * i + 2] ** 2 + ch[:, ng + nj + 5 * i + 3] ** 2
         msini = planets_msini(P, K, ecc, mstar) * 317.83
-        tc = tcs[i] + P * np.round((tc0[i][0] - tcs[i]) / P)
+        # the time of inferior conjunction, where a transit would fall, the one nearest the series' median time
+        tc = ch[:, ng + nj + 5 * i + 1]
+        tc = tc + P * np.round((centre[ng + nj + 5 * i + 1] - tc) / P)
         j = np.linspace(0, len(ch) - 1, min(256, len(ch))).astype(int)
         om = np.arctan2(ch[j, ng + nj + 5 * i + 3], ch[j, ng + nj + 5 * i + 2])
+        E = 2 * np.arctan2(np.sqrt(1 - ecc[j]) * np.sin(np.pi / 4 - om / 2), np.sqrt(1 + ecc[j]) * np.cos(np.pi / 4 - om / 2))
         res["planets"].append(dict(P=pct(P), K=pct(K), e=pct(ecc), e_95=round(float(np.percentile(ecc, 95)), 4), msini_mearth=pct(msini), tc_mjd=pct(tc)))
-        draws.append(np.round(np.column_stack([P[j], ch[j, ng + nj + 5 * i + 1], ecc[j], om, K[j]]), 6))
+        draws.append(np.round(np.column_stack([P[j], tc[j] - P[j] * (E - ecc[j] * np.sin(E)) / (2 * np.pi), ecc[j], om, K[j]]), 6))
     os.makedirs(os.path.join(planets_RESULTS, "orbits"), exist_ok=True)
     path = os.path.join(planets_RESULTS, "orbits", archive_tag(name) + ("." + label if label else "") + (".circular" if circular else "") + ".json")
     planets_draws_save(path, res, draws=np.array(draws))
@@ -4856,9 +5093,9 @@ def planets_orbits(name, periods, steps=30000, mstar=None, ebound=0.9, others=Tr
 
 
 def planets_transit_flux(path):
-    """A star's TESS light curves (eclipses_fetch's file PATH) as the transit search reads them: each sector binned to ten minutes and divided by its
-    running median over a day, the points 5 robust standard deviations above the median set aside: the times, fluxes, the robust standard deviation
-    and the number of sectors, or None where there is no light curve."""
+    """A star's TESS light curves (eclipses_fetch's file PATH) as the transit search reads them: each sector binned to ten minutes, or left at its
+    cadence where that is longer, and divided by its running median over a day, the points 5 robust standard deviations above the median set aside: the
+    times, fluxes, the robust standard deviation and the number of sectors, or None where there is no light curve."""
     T, F = [], []
     d = np.load(path) if path else None
     for sec in (np.unique(d["sector"]) if d is not None else []):
@@ -4870,7 +5107,9 @@ def planets_transit_flux(path):
         n = np.bincount(inv)
         tb, fb = np.bincount(inv, t) / n, np.bincount(inv, fl) / n
         if len(tb) > 150:
-            T.append(tb), F.append(fb / gpu_host(gpu_running_median(fb, 145)))
+            # a day's bins, whatever the cadence
+            width = max(3, int(round(1.0 / float(np.median(np.diff(tb))))) | 1)
+            T.append(tb), F.append(fb / gpu_host(gpu_running_median(fb, width)))
     if not T:
         return None
     t, f = np.concatenate(T), np.concatenate(F)
@@ -4911,22 +5150,26 @@ def planets_transit_periods(span, pmin, pmax):
 def planets_transit_backfill(part=None):
     """The stored transit searches, of the share K/N where PART is given, that lack their signals' red-noise signal-to-noise (planets_transit_red_snr)
     or the highest signal-to-noise of the same search of the light curve turned upside down given them, from the light curves each search read, the
-    signals' transits masked in turn as the search masked them."""
+    signals' transits masked in turn as the search masked them, ending between searches where a long search would end between stars
+    (planets_search_ends)."""
     done = 0
     paths = sorted(glob.glob(os.path.join(planets_RESULTS, "transitsearch", "*.json")))
     if part:
         k, n = (int(x) for x in part.split("/"))
         paths = paths[k::n]
     for path in paths:
-        rec = json.load(open(path))
-        if not rec.get("signals") or (all("red_snr" in g for g in rec["signals"]) and "inverted_snr" in rec):
+        if planets_search_ends():
+            return
+        rec = planets_load_json(path)
+        if not rec or not rec.get("signals") or (all("red_snr" in g for g in rec["signals"]) and "inverted_snr" in rec):
             continue
         got = planets_transit_flux(os.path.join(eclipses_ROOT, "lightcurves", rec["name"] + ".npz"))
         if got is None:
             continue
         t, f, sd, _ = got
         live = planets_transit_unmasked(t, [(P, t0, D / 24.0) for P, t0, D in rec.get("masked", [])])
-        periods = planets_transit_periods(float(t.max() - t.min()), rec["pmin"], rec["pmax"])
+        span = float(t.max() - t.min())
+        periods = planets_transit_periods(span, rec["pmin"], min(rec["pmax"], 0.5 * span) if "peaks" in rec else rec["pmax"])
         rec["inverted_snr"] = round(float(np.max(gpu_bls(t[live], 2.0 - f[live], np.full(int(live.sum()), sd), periods, planets_TRANSIT_DURATIONS)[0])), 2)
         for g in rec["signals"]:
             P, t0, D = g["P"], g["t0_btjd"], g["duration_h"] / 24.0
@@ -4972,32 +5215,108 @@ def planets_transit_known(tic=None, ra=float("nan"), dec=float("nan")):
 
 
 planets_TRANSIT_KNOWN = []
+# this file's time of writing when the process started, a long search ending between stars once the file is replaced (planets_code_changed)
+planets_CODE = os.stat(os.path.abspath(__file__)).st_mtime_ns
+
+
+def planets_code_changed():
+    """Whether this file has been replaced since the process started."""
+    try:
+        return os.stat(os.path.abspath(__file__)).st_mtime_ns != planets_CODE
+    except OSError:
+        return False
+
+
+# the free bytes on the results' disk under which a long search ends between stars, before a full disk cuts its records short
+planets_DISK_LOW = 2e9
+
+
+# the seconds a long search may spend on one star, and while a pause is asked for, before its process ends: an archive's job that never ends holds
+# the process for good, its calls answered but never finished
+planets_STAR_LIMIT, planets_PAUSE_LIMIT = 3 * 3600, 15 * 60
+planets_STAR_CLOCK = []
+
+
+def planets_star_watch():
+    """Ends the process with exit status 3 once planets_STAR_LIMIT seconds, or planets_PAUSE_LIMIT while a pause is asked for, pass with no call of
+    planets_search_ends, which a long search makes between stars; printed. The process's claim is taken over in its time."""
+    while True:
+        time.sleep(30)
+        idle, pause = time.time() - planets_STAR_CLOCK[0], os.environ.get("ORBITLIGHT_PAUSE")
+        if idle > planets_STAR_LIMIT or (idle > planets_PAUSE_LIMIT and pause and os.path.exists(pause)):
+            print("%.0f s on one star: the process ends" % idle, flush=True)
+            os._exit(3)
+
+
+def planets_search_ends():
+    """Whether a long search ends between stars: once this file has been replaced (planets_code_changed), once the file the environment variable
+    ORBITLIGHT_PAUSE names exists, or once the disk that holds the results has less than planets_DISK_LOW bytes free; the last two are printed. Its
+    first call starts the watch on the time between calls (planets_star_watch)."""
+    if not planets_STAR_CLOCK:
+        planets_STAR_CLOCK.append(time.time())
+        threading.Thread(target=planets_star_watch, daemon=True).start()
+    planets_STAR_CLOCK[0] = time.time()
+    if planets_code_changed():
+        return True
+    pause = os.environ.get("ORBITLIGHT_PAUSE")
+    if pause and os.path.exists(pause):
+        print("%s exists: the search pauses" % pause, flush=True)
+        return True
+    free = shutil.disk_usage(planets_RESULTS).free
+    if free < planets_DISK_LOW:
+        print("%.1f GB free on the disk of %s: the search ends" % (free / 1e9, planets_RESULTS), flush=True)
+        return True
+    return False
+
+
+def planets_transit_current(path):
+    """Whether the stored transit search at PATH is the current search's: a census star's that read each sector's detrended flux (eclipses_fetch), or a star the TESS stage searched, whose
+    light curves are PDCSAP's, without light curves or with its peaks without three transits set aside (planets_transit_search)."""
+    if not os.path.exists(path):
+        return False
+    rec = planets_load_json(path)
+    if not rec:
+        return False
+    return bool(rec.get("note")) or "peaks" in rec if rec.get("tic") else bool(rec.get("detrended"))
+
+
+# the transit search's shortest period
+planets_TRANSIT_PMIN = 0.5
 
 
-def planets_transit_search(name, ra, dec, pmin=0.5, pmax=20.0, snr_min=9.0, most=3, path=None, mask=(), extra=None):
+def planets_transit_search(name, ra, dec, pmin=planets_TRANSIT_PMIN, pmax=20.0, snr_min=9.0, most=3, peaks=8, path=None, mask=(), extra=None):
     """A star's TESS light curves (eclipses_fetch's file, or PATH where given) searched blind for transits by box least squares on the device, to
-    RESULTS/transitsearch/<name>.json: the transits of MASK, (period, epoch in BTJD, duration in days) each, those already registered for the star, set
-    aside first; then up to MOST signals above SNR_MIN, each with its transits, odd and even depths, secondary and red-noise signal-to-noise
-    (planets_transit_red_snr), its transits masked before the next; and the highest signal-to-noise of the same search of the light curve turned
-    upside down. EXTRA, the star's own details, is kept in the record."""
+    RESULTS/transitsearch/<name>.json, at periods from PMIN days to PMAX or half the light curves' span, whichever is shorter: the transits of MASK,
+    (period, epoch in BTJD, duration in days) each, those already registered for the star, set aside first; then the highest peaks above SNR_MIN, PEAKS
+    of them at most, each with its transits, odd and even depths, secondary and red-noise signal-to-noise (planets_transit_red_snr) and its transits
+    masked before the next, until MOST have three transits or more with none dominating, the others kept apart as set_aside, or until the masks leave
+    under a quarter of the light curve; and the highest
+    signal-to-noise of the same search of the light curve turned upside down. EXTRA, the star's own details, is kept in the record, and an earlier
+    search's validations of the star are removed."""
     if path is None:
         path = os.path.join(eclipses_ROOT, "lightcurves", name + ".npz")
         if not os.path.exists(path):
             path = eclipses_fetch(name, ra, dec)
-    out = dict(name=name, pmin=pmin, pmax=pmax, snr_min=snr_min, signals=[], **(extra or {}))
+    out = dict(name=name, pmin=pmin, pmax=pmax, peaks=peaks, snr_min=snr_min, detrended=True, signals=[], set_aside=[], **(extra or {}))
     got = planets_transit_flux(path)
+    if got is not None and float(got[0].max() - got[0].min()) < 4.0 * pmin:
+        got = None
     if got is None:
         out["note"] = "no TESS light curve"
     else:
         t, f, sd, nsec = got
         span = float(t.max() - t.min())
-        periods = planets_transit_periods(span, pmin, pmax)
+        periods = planets_transit_periods(span, pmin, min(pmax, 0.5 * span))
         live = planets_transit_unmasked(t, mask)
         # the same search of the light curve turned upside down, whose highest peak is the star's own noise ceiling
         out.update(sectors=nsec, points=int(len(t)), span_d=round(span, 1), noise_ppm=round(1e6 * sd, 1), periods=len(periods),
                    masked=[[round(P, 6), round(t0, 5), round(24.0 * D, 2)] for P, t0, D in mask],
                    inverted_snr=round(float(np.max(gpu_bls(t[live], 2.0 - f[live], np.full(int(live.sum()), sd), periods, planets_TRANSIT_DURATIONS)[0])), 2))
-        for _ in range(most):
+        found = 0
+        for _ in range(peaks):
+            # the search ends where the transits already masked leave under a quarter of the light curve
+            if live.sum() < 0.25 * len(t):
+                break
             snr, depth, dur, mid = gpu_bls(t[live], f[live], np.full(int(live.sum()), sd), periods, planets_TRANSIT_DURATIONS)
             k = int(np.argmax(snr))
             if not snr[k] >= snr_min:
@@ -5020,56 +5339,84 @@ def planets_transit_search(name, ra, dec, pmin=0.5, pmax=20.0, snr_min=9.0, most
                 w = 1.0 / err ** 2
                 return float((w * dep).sum() / w.sum()), float(1.0 / math.sqrt(w.sum()))
             (do, eo), (de, ee) = mean_depth([e for e in events if e["epoch"] % 2]), mean_depth([e for e in events if not e["epoch"] % 2])
+            # the light half an orbit on against that one to three durations about it, the transit itself left out where a short period brings it near
             sec_in = live & (np.abs(np.abs(dt) - 0.5 * P) < 0.5 * D)
-            sec_out = live & (np.abs(np.abs(dt) - 0.5 * P) > D) & (np.abs(np.abs(dt) - 0.5 * P) < 3.0 * D)
+            sec_out = live & (np.abs(np.abs(dt) - 0.5 * P) > D) & (np.abs(np.abs(dt) - 0.5 * P) < 3.0 * D) & (np.abs(dt) > D)
             sec = (float(np.mean(f[sec_out]) - np.mean(f[sec_in])) / (sd * math.sqrt(1.0 / sec_in.sum() + 1.0 / sec_out.sum()))) if sec_in.sum() >= 3 and sec_out.sum() >= 10 else None
             power = [max(e["snr"], 0.0) ** 2 for e in events]
-            out["signals"].append(dict(P=round(P, 6), t0_btjd=round(t0, 5), duration_h=round(24.0 * D, 2), depth_ppm=round(1e6 * float(depth[k]), 1),
-                                       snr=round(float(snr[k]), 2), red_snr=planets_transit_red_snr(t, f, live, P, t0, D, float(depth[k]), len(events)),
-                                       transits=len(events),
-                                       odd_even_sigma=round(abs(do - de) / math.hypot(eo, ee), 2) if events and math.isfinite(do) and math.isfinite(de) else None,
-                                       secondary_sigma=round(sec, 2) if sec is not None else None,
-                                       single_event_share=round(max(power) / sum(power), 3) if sum(power) > 0 else None, events=events))
+            share = round(max(power) / sum(power), 3) if sum(power) > 0 else None
+            # a peak of fewer than three transits, or of one dominating them, is set aside and counts against PEAKS alone
+            if len(events) >= 3 and (share or 0.0) < 0.5:
+                out["signals"].append(dict(P=round(P, 6), t0_btjd=round(t0, 5), duration_h=round(24.0 * D, 2), depth_ppm=round(1e6 * float(depth[k]), 1),
+                                           snr=round(float(snr[k]), 2), red_snr=planets_transit_red_snr(t, f, live, P, t0, D, float(depth[k]), len(events)),
+                                           transits=len(events),
+                                           odd_even_sigma=round(abs(do - de) / math.hypot(eo, ee), 2) if events and math.isfinite(do) and math.isfinite(de) else None,
+                                           secondary_sigma=round(sec, 2) if sec is not None else None, single_event_share=share, events=events))
+                found += 1
+            else:
+                out["set_aside"].append(dict(P=round(P, 6), t0_btjd=round(t0, 5), duration_h=round(24.0 * D, 2), depth_ppm=round(1e6 * float(depth[k]), 1),
+                                             snr=round(float(snr[k]), 2), transits=len(events), single_event_share=share))
             live &= ~(np.abs(dt) < D)
+            if found >= most:
+                break
     os.makedirs(os.path.join(planets_RESULTS, "transitsearch"), exist_ok=True)
-    archive_save(os.path.join(planets_RESULTS, "transitsearch", archive_tag(name) + ".json"), json.dumps(out, separators=(",", ":")).encode())
+    stored = os.path.join(planets_RESULTS, "transitsearch", archive_tag(name) + ".json")
+    if os.path.exists(stored):
+        # an earlier search's validations name its signals by their order, which this search's need not keep
+        for p in glob.glob(os.path.join(planets_RESULTS, "validate_transits", archive_tag(name) + "_*.json")):
+            if re.fullmatch(re.escape(archive_tag(name)) + r"_\d+\.json", os.path.basename(p)):
+                os.remove(p)
+    archive_save(stored, json.dumps(out, separators=(",", ":")).encode())
     print("%s: %s" % (name, out.get("note") or "%d sectors, %d signals%s" % (out["sectors"], len(out["signals"]), "".join(
         "; P %.4f d S/N %.1f %d transits" % (s["P"], s["snr"], s["transits"]) for s in out["signals"]))), flush=True)
     return out
 
 
+def planets_lightcurve_drop(name):
+    """A star's kept light curve (eclipses_fetch) removed, where it is held and no other process is reading it."""
+    try:
+        os.remove(os.path.join(eclipses_ROOT, "lightcurves", name + ".npz"))
+    except OSError:
+        pass
+
+
 def planets_transit_search_all(part=None):
-    """Every census star of the share PART searched for transits (planets_transit_search), the transits of the TOIs and community TOIs within an
-    arcminute of it set aside (planets_transit_known), those already searched passed over, and each star's candidates validated as soon as it is
-    searched (planets_validate_transits)."""
+    """Every census star of the share PART searched for transits (planets_transit_search) from light curves fetched for it and removed after it, the transits of the TOIs and community TOIs
+    within an arcminute of it set aside (planets_transit_known), those the current search has searched passed over (planets_transit_current), and each star's
+    candidates validated as soon as it is searched (planets_validate_transits); the share ends between stars once this file is replaced or the
+    results' disk runs low, or a pause is asked for (planets_search_ends)."""
     names, stars, _, _ = planets_share(part)
     for name in names:
-        if os.path.exists(os.path.join(planets_RESULTS, "transitsearch", archive_tag(name) + ".json")):
+        if planets_search_ends():
+            sys.exit(3)
+        if planets_transit_current(os.path.join(planets_RESULTS, "transitsearch", archive_tag(name) + ".json")):
             continue
         s = stars[name]
         try:
             ra, dec = float(s["RAJ2000"]), float(s["DEJ2000"])
+            planets_lightcurve_drop(name)
             planets_transit_search(name, ra, dec, mask=planets_transit_known(ra=ra, dec=dec))
             planets_validate_transits(names=[name])
         except Exception as exc:
             print("%s: %s: %s" % (name, type(exc).__name__, str(exc)[:200]), flush=True)
+        planets_lightcurve_drop(name)
         # the device memory each star cached handed back, so that the shares running side by side stay within the card
         if gpu_DEVICE.type == "cuda":
             torch.cuda.empty_cache()
 
 
-def planets_tess_lightcurves(tic, folder):
-    """A TIC star's SPOC two-minute light curves read from MAST's bucket (planets_tess_index) without keeping them, each sector's PDCSAP flux of
-    quality zero divided by its median, written to FOLDER/<tic>.npz as eclipses_fetch writes a star's: the file's path, or None where there is none,
-    and the star's position, TESS magnitude, temperature, gravity, radius and mass from the first light curve's header, the mass from the gravity and
-    radius."""
+def planets_tess_lightcurves(tic, folder, kind=0):
+    """A TIC star's light curves of KIND, SPOC's at two minutes (0) or TESS-SPOC's from the full-frame images (1), read from MAST's bucket
+    (planets_tess_index) without keeping them, each sector's PDCSAP flux of quality zero divided by its median, written to FOLDER/<tic>.npz as
+    eclipses_fetch writes a star's with each sector's cadence: the file's path, or None where there is none, and the star's position, TESS
+    magnitude, temperature, gravity, radius and mass from the first light curve's header, the mass from the gravity and radius."""
     from astropy.io import fits
     tics, secs, kinds, sectors = planets_tess_index()
     a, b = int(np.searchsorted(tics, tic)), int(np.searchsorted(tics, tic, side="right"))
-    keep = sorted(s for s, k in zip(secs[a:b].tolist(), kinds[a:b].tolist()) if k == 0 and s in sectors)
-    T, F, E, S, head = [], [], [], [], {}
+    keep = sorted(s for s, k in zip(secs[a:b].tolist(), kinds[a:b].tolist()) if k == kind and s in sectors)
+    T, F, E, S, C, head = [], [], [], [], [], {}
     for s in keep:
-        raw = archive_get(planets_TESS_BUCKET + planets_tess_key(tic, s, 0, sectors), timeout=300, soft=True)
+        raw = archive_get(planets_TESS_BUCKET + planets_tess_key(tic, s, kind, sectors), timeout=300, soft=True)
         if not raw:
             continue
         with fits.open(io.BytesIO(raw)) as h:
@@ -5082,36 +5429,48 @@ def planets_tess_lightcurves(tic, folder):
         if ok.sum() < 100:
             continue
         med = np.median(f[ok])
-        T.append(t[ok]), F.append(f[ok] / med), E.append(e[ok] / med), S.append(np.full(int(ok.sum()), s))
+        # the cadence in minutes: two for SPOC, and TESS-SPOC's thirty, ten and 200 seconds through sectors 26, 55 and after
+        cadence = 2.0 if kind == 0 else 30.0 if s <= 26 else 10.0 if s <= 55 else 200.0 / 60.0
+        T.append(t[ok]), F.append(f[ok] / med), E.append(e[ok] / med), S.append(np.full(int(ok.sum()), s)), C.append(np.full(int(ok.sum()), cadence))
     if head.get("logg") and head.get("rstar"):
         head["mstar"] = round(10.0 ** (head["logg"] - 4.438) * head["rstar"] ** 2, 3)
     if not T:
         return None, head
     os.makedirs(folder, exist_ok=True)
     path = os.path.join(folder, "%d.npz" % tic)
-    np.savez(path, time=np.concatenate(T), flux=np.concatenate(F), err=np.concatenate(E), sector=np.concatenate(S), cadence=np.full(sum(map(len, T)), 2.0))
+    np.savez(path, time=np.concatenate(T), flux=np.concatenate(F), err=np.concatenate(E), sector=np.concatenate(S), cadence=np.concatenate(C))
     return path, head
 
 
-def planets_tess_search(part=None):
-    """TESS's stars with SPOC two-minute light curves searched blind for transits one at a time: those observed in thirteen sectors or fewer first,
-    the most observed of them first, then those observed in more, of the share K/N where PART is given. Each star is claimed by a folder of its name
-    under RESULTS/transitsearch_claims, so that any number of processes can take stars side by side, a claim an hour old being taken over; its light
-    curves are read from MAST's bucket (planets_tess_lightcurves), the transits of its TOIs and community TOIs set aside (planets_transit_known), the
-    star searched (planets_transit_search) as TIC <number> with its header's details, its candidates validated (planets_validate_transits) and its
-    light curves deleted. A star already searched is passed over."""
+# the faintest TESS magnitude the stage searches among the stars only TESS-SPOC's full-frame light curves hold
+planets_FFI_FAINTEST = 14.0
+
+
+def planets_tess_search(part=None, ffi=False, skip=0):
+    """TESS's stars with SPOC two-minute light curves, or with FFI those TESS-SPOC's full-frame light curves hold and SPOC's do not, searched blind for
+    transits one at a time: those observed in thirteen sectors or fewer first, the most observed of them first, then those observed in more, of the
+    share K/N where PART is given, the first SKIP passed over, so that a second machine works far from the first. Each star is claimed by a folder of its name under RESULTS/transitsearch_claims, so that any number of processes
+    can take stars side by side, a claim an hour old being taken over; its light curves are read from MAST's bucket (planets_tess_lightcurves) into
+    its claim, the transits of its TOIs and community TOIs set aside (planets_transit_known), the star searched (planets_transit_search) as TIC
+    <number> with its header's details, its light curves deleted and its candidates validated (planets_validate_transits); a full-frame star fainter
+    than planets_FFI_FAINTEST is noted and not searched. A star the current search has searched is passed over (planets_transit_current), and the
+    process ends between stars once this file is replaced, the results' disk runs low, or a pause is asked for (planets_search_ends)."""
     tics, secs, kinds, sectors = planets_tess_index()
-    ids, counts = np.unique(tics[kinds == 0], return_counts=True)
+    ids, counts = np.unique(tics[kinds == (1 if ffi else 0)], return_counts=True)
+    if ffi:
+        keep = ~np.isin(ids, tics[kinds == 0])
+        ids, counts = ids[keep], counts[keep]
     order = ids[np.lexsort((ids, -counts, counts > 13))]
     if part:
         k, n = (int(x) for x in part.split("/"))
         order = order[k::n]
-    folder = planets_path("tess", "work%d" % os.getpid())
     claims = os.path.join(planets_RESULTS, "transitsearch_claims")
     os.makedirs(claims, exist_ok=True)
-    for tic in order.tolist():
+    for tic in order[skip:].tolist():
         name = "TIC %d" % tic
-        if os.path.exists(os.path.join(planets_RESULTS, "transitsearch", archive_tag(name) + ".json")):
+        if planets_search_ends():
+            sys.exit(3)
+        if planets_transit_current(os.path.join(planets_RESULTS, "transitsearch", archive_tag(name) + ".json")):
             continue
         claim = os.path.join(claims, archive_tag(name))
         try:
@@ -5120,12 +5479,15 @@ def planets_tess_search(part=None):
             if time.time() - os.path.getmtime(claim) < 3600:
                 continue
         try:
-            path, head = planets_tess_lightcurves(tic, folder)
-            extra = dict(head, tic=tic)
-            if path is None:
+            path, head = planets_tess_lightcurves(tic, claim, 1 if ffi else 0)
+            extra = dict(head, tic=tic, light_curves="TESS-SPOC" if ffi else "SPOC")
+            # a star of the full-frame light curves alone fainter than planets_FFI_FAINTEST is noted and left
+            faint = ffi and (head.get("tmag") or 99.0) > planets_FFI_FAINTEST
+            if path is None or faint:
                 os.makedirs(os.path.join(planets_RESULTS, "transitsearch"), exist_ok=True)
+                note = "fainter than T %g" % planets_FFI_FAINTEST if faint else "no %s light curve" % extra["light_curves"]
                 archive_save(os.path.join(planets_RESULTS, "transitsearch", archive_tag(name) + ".json"),
-                             json.dumps(dict(name=name, signals=[], note="no SPOC light curve", **extra), separators=(",", ":")).encode())
+                             json.dumps(dict(name=name, signals=[], note=note, **extra), separators=(",", ":")).encode())
                 continue
             planets_transit_search(name, extra.get("ra"), extra.get("dec"), path=path, mask=planets_transit_known(tic=tic), extra=extra)
             os.remove(path)
@@ -5136,7 +5498,6 @@ def planets_tess_search(part=None):
             shutil.rmtree(claim, ignore_errors=True)
         if gpu_DEVICE.type == "cuda":
             torch.cuda.empty_cache()
-    shutil.rmtree(folder, ignore_errors=True)
 
 
 def planets_tess_root(source):
@@ -5162,23 +5523,371 @@ def planets_tess_root(source):
     print("TESS root ready", flush=True)
 
 
-def planets_transit_rows(stars, names=None):
+def planets_transit_scatter(g, split=False):
+    """A blind-search signal G's signal-to-noise against the scatter of its transits' depths: its signal-to-noise divided by the root of the
+    chi-square per degree of freedom of the depths about their weighted mean, the odd and the even transits' each where SPLIT is set, where that
+    chi-square lies beyond its 1e-3 false-alarm level, each transit's error the light curve's noise over the root of its points, scaled from the
+    transits measured at a signal-to-noise of one or more; its signal-to-noise as it stands otherwise."""
+    from scipy.stats import chi2
+    ev = g["events"]
+    scale = sorted(abs(e["depth_ppm"] / e["snr"]) * math.sqrt(e["points"]) for e in ev if abs(e["snr"]) >= 1.0)
+    groups = [[e for e in ev if e["epoch"] % 2 == k] for k in (0, 1)] if split else [ev]
+    dof = len(ev) - len([x for x in groups if x])
+    if len(ev) < 3 or not scale or dof < 1:
+        return g["snr"]
+    c2 = 0.0
+    for x in groups:
+        if x:
+            w = np.array([e["points"] for e in x], float) / scale[len(scale) // 2] ** 2
+            d = np.array([e["depth_ppm"] for e in x], float)
+            c2 += float((w * (d - (w * d).sum() / w.sum()) ** 2).sum())
+    return g["snr"] if chi2.sf(c2, dof) >= 1e-3 else g["snr"] / math.sqrt(c2 / dof)
+
+
+def planets_vsx():
+    """VSX's variables, from the VizieR mirror's B/vsx, sorted by declination: names, right ascensions and declinations (deg), periods (days, NaN where
+    none) and whether any of each one's types, uncertain or not, is an eclipsing, ellipsoidal, reflection, heartbeat or RS CVn binary."""
+    if not planets_VSX:
+        import pyarrow.compute as pc
+        t = archive_vizier("B/vsx", "vsx", ("Name", "RAdeg", "DEdeg", "Type", "Period"))
+        dec = np.nan_to_num(t["DEdeg"].to_numpy(zero_copy_only=False).astype(float), nan=99.0)
+        order = np.argsort(dec)
+        binary = pc.fill_null(pc.match_substring_regex(t["Type"], r"(^|[|+/])(E|EA|EB|EW|EC|ELL|R|HB|RS):?($|[|+/])"), False)
+        planets_VSX.append((t["Name"].take(order), t["RAdeg"].to_numpy(zero_copy_only=False).astype(float)[order], dec[order],
+                            t["Period"].to_numpy(zero_copy_only=False).astype(float)[order], binary.to_numpy(zero_copy_only=False)[order]))
+        archive_VIZIER_CACHE.pop(("B/vsx", "vsx", ("Name", "RAdeg", "DEdeg", "Type", "Period")), None)
+    return planets_VSX[0]
+
+
+planets_VSX = []
+
+# The eclipsing binaries VizieR holds beyond VSX and SIMBAD, each table by its J2000 positions: TESS's from its two-minute light curves (Prsa et al.
+# 2022) and from its full-frame images, new and known (Kostov et al. 2025), those of its OBA and OBAF stars (IJspeert et al. 2021, 2024), its EA-type
+# ones (Shi et al. 2022), those with LAMOST spectra (Shi et al. 2025), and Kepler's (Kirk et al. 2016)
+planets_EB_TABLES = ("J/ApJS/258/16/tess-ebs", "J/ApJS/279/50/table3", "J/ApJS/279/50/table4", "J/A+A/652/A120/eb-cat", "J/A+A/691/A242/obaf-eb1",
+                     "J/ApJS/259/50/table1", "J/ApJS/280/26/table1", "J/AJ/151/68/catalog")
+# VizieR's sites, two of its mirrors first
+planets_VIZIER_SITES = ("https://vizier.idia.ac.za", "http://vizier.china-vo.org", "https://vizier.cds.unistra.fr")
+
+
+# the stars the TESS Ten Thousand catalogue's network found eclipse-like, unvetted (Kostov et al. 2025)
+planets_EB_CANDIDATES = ("J/ApJS/279/50/table2",)
+
+# the variable-star catalogues the known check reads live about a star at VizieR's sites, each as (label, source, its name columns, its type column,
+# its period columns, and which of its rows are binaries: every one, none, or those whose type matches a pattern): VSX, whose mirrored copy lags
+# the live one; ASAS-SN's (Jayasinghe et al. 2019, 2021); ATLAS's (Heinze et al. 2018); ZTF's periodic variables (Chen et al. 2020); and Gaia DR3's
+# classified variables and eclipsing binaries (Rimoldini et al. 2023, Mowlavi et al. 2023)
+planets_VARIABLES = (("VSX", "B/vsx/vsx", ("Name",), "Type", ("Period",), r"(^|[|+/])(E|EA|EB|EW|EC|ELL|R|HB|RS):?($|[|+/])"),
+                     ("ASAS-SN", "II/366", ("ASASSN-V", "Name", "ID"), "Type", ("Per",), r"^(E|EA|EB|EW|ELL|RS)"),
+                     ("ATLAS", "J/AJ/156/241", ("ATOID",), "Class", ("fp-period", "ls-Pday"), r"^(CBF|CBH|DBF|DBH)$"),
+                     ("ZTF", "J/ApJS/249/18", ("ID",), None, ("Per-g", "Per-r"), False),
+                     ("Gaia DR3", "I/358/vclassre", ("Source",), "Class", (), r"^(ECL|RS)$"),
+                     ("Gaia DR3 eclipsing", "I/358/veb", ("Source",), None, (), True),
+                     ("Gaia DR3 RR Lyrae", "I/358/vrrlyr", ("Source",), None, ("PF", "P1O"), False))
+
+
+planets_VARIABLES_DOWN = []
+
+
+def planets_variables_near(ra, dec, radius, placed=False):
+    """The variable stars the catalogues of planets_VARIABLES hold within RADIUS arcsec of a J2000 position RA, DEC, each read live from the first of
+    VizieR's sites to answer (planets_VIZIER_SITES), all kept in ROOT/variables/: rows of (catalogue, name, periods in days, whether a binary, separation
+    in arcsec or None, the catalogue's type); an IOError where no site answers for a catalogue. A kept cone whose rows stop at whether a binary serves
+    unless PLACED is set, when it is read again."""
+    path = planets_path("variables", "%.5f_%+.5f_%g.json" % (ra, dec, radius))
+    got = planets_load_json(path)
+    if got is not None and (not placed or all(len(x) > 4 for x in got)):
+        return got
+    # sites that failed once in this process are not waited for again
+    if planets_VARIABLES_DOWN:
+        raise IOError("no VizieR site answered for %s" % planets_VARIABLES_DOWN[0])
+    rows = []
+    for label, source, names, tcol, pcols, rule in planets_VARIABLES:
+        q = urllib.parse.urlencode({"-source": source, "-c": "%.6f %+.6f" % (ra, dec), "-c.rs": "%g" % radius, "-out.max": "50", "-out.all": "", "-out.add": "_RAJ,_DEJ",
+                                    "-oc.form": "d"})
+        text = None
+        for site in planets_VIZIER_SITES:
+            raw = archive_get("%s/viz-bin/asu-tsv?%s" % (site, q), timeout=120, retries=2, soft=True)
+            if raw and b"VizieR" in raw[:4000]:
+                text = raw.decode("utf-8", "replace")
+                break
+        if text is None:
+            planets_VARIABLES_DOWN.append(source)
+            raise IOError("no VizieR site answered for %s" % source)
+        # each table a line of column names, a line of units and a line of dashes, then its rows to a blank line
+        head, skip = None, 0
+        for line in text.splitlines():
+            if line.startswith("#") or not line.strip():
+                head, skip = None, 0
+                continue
+            cells = [c.strip() for c in line.split("\t")]
+            if head is None:
+                head, skip = cells, 2
+                continue
+            if skip:
+                skip -= 1
+                continue
+            r = dict(zip(head, cells))
+            name = next((r[n] for n in names if r.get(n)), "%s %.5f %+.5f" % (label, ra, dec))
+            kind = r.get(tcol, "") if tcol else ""
+            binary = rule if isinstance(rule, bool) else re.search(rule, kind) is not None
+            periods = [p for p in (planets_num(r.get(c)) for c in pcols) if math.isfinite(p) and p > 0]
+            sep = math.hypot(((planets_num(r.get("_RAJ2000")) - ra + 180.0) % 360.0 - 180.0) * math.cos(math.radians(dec)), planets_num(r.get("_DEJ2000")) - dec) * 3600.0
+            rows.append([label, name, periods, binary, round(sep, 1) if math.isfinite(sep) else None, kind])
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    archive_save(path, json.dumps(rows).encode())
+    return rows
+
+
+def planets_eclipsing_binaries(tables=planets_EB_TABLES, name="eclipsing_binaries"):
+    """The stars of the VizieR TABLES, by default the eclipsing binaries of planets_EB_TABLES, as rows of right ascension and declination (J2000, deg)
+    and the table's place in TABLES, sorted by declination: each table read from the first of VizieR's sites to answer (planets_VIZIER_SITES), all
+    kept in ROOT/<name>.npy; an error where a table cannot be had."""
+    if name not in planets_EB:
+        path = planets_path(name + ".npy")
+        if not os.path.exists(path):
+            rows = []
+            for k, table in enumerate(tables):
+                text = None
+                for site in planets_VIZIER_SITES:
+                    raw = archive_get("%s/viz-bin/asu-tsv?-source=%s&-out=_RAJ,_DEJ&-out.max=unlimited&-oc.form=d" % (site, table), timeout=300, retries=2,
+                                      soft=True)
+                    if raw and b"_RAJ2000" in raw:
+                        text = raw.decode("utf-8", "replace")
+                        break
+                if text is None:
+                    raise IOError("no VizieR site answered for %s" % table)
+                for line in text.splitlines():
+                    parts = line.split("\t")
+                    if len(parts) == 2 and not line.startswith("#"):
+                        a, d = planets_num(parts[0]), planets_num(parts[1])
+                        if math.isfinite(a) and math.isfinite(d):
+                            rows.append((a, d, k))
+            x = np.array(rows, float).reshape(-1, 3)
+            os.makedirs(os.path.dirname(path), exist_ok=True)
+            tmp = archive_tmp(path)
+            with open(tmp, "wb") as fh:
+                np.save(fh, x[np.argsort(x[:, 1])])
+            archive_place(tmp, path)
+        planets_EB[name] = np.load(path)
+    return planets_EB[name]
+
+
+planets_EB = {}
+
+
+# the words of a paper's title that make the star it is linked to in SIMBAD a known binary
+planets_BINARY_WORDS = ("eclips", "binar", "triple", "quadruple", "multiple system", "EBLM")
+
+
+def planets_binary_known(ra, dec, P, exo=(), radius=60.0, simbad=archive_SIMBAD_BINARIES, candidates=True, names=(), literature=False):
+    """What already knows of a binary found eclipsing at a J2000 position RA, DEC every P days, each named, within RADIUS arcsec: VSX's variables that
+    are binaries or vary at P, half it or twice it within 1 per cent (planets_vsx), and the same of the variable-star catalogues read live about the
+    star (planets_variables_near); SIMBAD's binaries of the types SIMBAD (archive_simbad_binaries);
+    VizieR's eclipsing binaries (planets_eclipsing_binaries) and, where CANDIDATES is set, the TESS Ten Thousand catalogue's unvetted eclipse-like stars
+    (planets_EB_CANDIDATES); of EXO, the TOIs and community TOIs as (label, ra, dec, period), those at P, half it or twice it within 1 per cent; and
+    where LITERATURE is set, the papers SIMBAD links to the star by any of its NAMES whose titles hold one of planets_BINARY_WORDS."""
+    if literature and any(names):
+        papers = archive_simbad_papers([n for n in names if n], words=planets_BINARY_WORDS)
+        found = sorted({b for rows in papers.values() for b, _, _ in rows})
+        if found:
+            return ["SIMBAD papers %s" % "; ".join(found[:5])]
+    if not (math.isfinite(ra) and math.isfinite(dec)):
+        return []
+    cosd, w = math.cos(math.radians(dec)), radius / 3600.0
+    near = lambda a, d: np.hypot(((a - ra + 180.0) % 360.0 - 180.0) * cosd, d - dec) * 3600.0 < radius
+    band = lambda d: np.arange(np.searchsorted(d, dec - w), np.searchsorted(d, dec + w))
+    with np.errstate(divide="ignore", invalid="ignore"):
+        at = lambda q: np.any([np.abs(m * P / q - 1.0) < 0.01 for m in (0.5, 1.0, 2.0)], axis=0)
+        names, a, d, per, binary = planets_vsx()
+        j = band(d)
+        out = ["VSX %s" % n for n in names.take(j[near(a[j], d[j]) & (binary[j] | at(per[j]))]).to_pylist()]
+        out += sorted({"%s %s" % (cat, n) for cat, n, periods, is_binary, *_ in planets_variables_near(ra, dec, radius)
+                       if is_binary or any(at(np.array([p]))[0] for p in periods)} - set(out))
+        x = archive_simbad_binaries()
+        k = band(x[:, 1])
+        out += sorted({"SIMBAD %s" % archive_SIMBAD_BINARIES[int(c)] for c in x[k[near(x[k, 0], x[k, 1])], 2]} &
+                      {"SIMBAD %s" % s for s in simbad})
+        for tables, name in ((planets_EB_TABLES, "eclipsing_binaries"),) + (((planets_EB_CANDIDATES, "eclipsing_candidates"),) if candidates else ()):
+            x = planets_eclipsing_binaries(tables, name)
+            k = band(x[:, 1])
+            out += sorted({"VizieR %s" % tables[int(c)] for c in x[k[near(x[k, 0], x[k, 1])], 2]})
+        out += [label for label, a_, d_, q in exo if near(np.array([a_]), np.array([d_]))[0] and at(np.array([q]))[0]]
+    return out
+
+
+# the arcseconds within which a variable star's light reaches a TESS star's aperture or the pixels its sky is read from
+planets_NEIGHBOUR_RADIUS = 360.0
+# the arcseconds within which a catalogued variable is the star itself, as the rule on a star's own catalogued binary takes it (planets_transit_rows)
+planets_OWN_RADIUS = 10.0
+# VSX's type for a star whose variation is its planet's transits
+planets_VSX_TRANSIT = r"(^|[|+/])EP:?($|[|+/])"
+
+
+def planets_variable_neighbours(ra, dec, P):
+    """The catalogued variable stars (planets_variables_near) within planets_NEIGHBOUR_RADIUS of a J2000 position RA, DEC whose period lies within 0.2 per
+    cent of P, its half or its double, named: a star whose light, inside the aperture or among the pixels its sky is read from, puts its own period
+    into the light curve, or the star itself where it is catalogued as a binary. A star VSX types as a planet's transits, and any other entry within
+    planets_OWN_RADIUS, is the candidate's own signal and is left out, as is an entry ATLAS itself classes as dubious. An IOError where the catalogues
+    cannot be read."""
+    if not (math.isfinite(ra) and math.isfinite(dec) and P > 0):
+        return []
+    at = lambda x: any(abs(m * P / p - 1.0) < 0.002 for p in x[2] for m in (0.5, 1.0, 2.0))
+    rows = planets_variables_near(ra, dec, planets_NEIGHBOUR_RADIUS)
+    if any(at(x) and len(x) < 5 for x in rows):
+        rows = planets_variables_near(ra, dec, planets_NEIGHBOUR_RADIUS, placed=True)
+    return sorted({"%s %s" % (x[0], x[1]) for x in rows if at(x) and not re.search(planets_VSX_TRANSIT, x[5]) and x[5].lower() != "dubious"
+                   and (x[3] or x[4] is None or x[4] >= planets_OWN_RADIUS)})
+
+
+def planets_transit_sets(g):
+    """The mean depth (ppm) and its error of a blind-search signal G's even transits and of its odd ones, each transit weighted by its points and
+    each transit's error the light curve's noise over the root of its points, scaled from the transits measured at a signal-to-noise of one or more."""
+    ev = g["events"]
+    scale = sorted(abs(e["depth_ppm"] / e["snr"]) * math.sqrt(e["points"]) for e in ev if abs(e["snr"]) >= 1.0)
+    out = []
+    for k in (0, 1):
+        x = [e for e in ev if e["epoch"] % 2 == k]
+        n = sum(e["points"] for e in x)
+        out.append((sum(e["depth_ppm"] * e["points"] for e in x) / n, scale[len(scale) // 2] / math.sqrt(n)) if n and scale else (float("nan"),) * 2)
+    return out
+
+
+def planets_binary_signal(g, split):
+    """A blind-search signal G as its binary's eclipses: where SPLIT, odd and even eclipses of different depths, its period doubled and its epoch and
+    depth those of the deeper set (planets_transit_sets); G as it stands otherwise."""
+    if not split:
+        return g
+    (d0, _), (d1, _) = planets_transit_sets(g)
+    k = int(d1 > d0)
+    return dict(g, P=2.0 * g["P"], t0_btjd=round(g["t0_btjd"] + k * g["P"], 5), depth_ppm=round(max(d0, d1), 1))
+
+
+def planets_binary_decision(v, x, twin=None):
+    """An eclipsing binary's decision from its validation record V and its row X as a TESS candidate (planets_transit_candidate, the star's mass,
+    radius and temperature with it): (status, reason). Rejected with the record's note where it holds no probabilities; where neither the dip half an
+    orbit on, nor the search's second set of eclipses at the same period TWIN where there is one, lies 3 sigma or more beyond the deepest occultation
+    a planet could give (planets_occultation_max), nor is the eclipsing body larger than two Jupiter radii; where the folded light is the star's own
+    smooth variation rather than eclipses (planets_transit_smooth), or skewed dips that repeat at half the period (planets_transit_sawtooth); or where TRICERATOPS puts 0.1 per cent of the probability or more on the eclipses
+    arising on a nearby or an unresolved background star. New otherwise."""
+    if "fpp" not in v:
+        return planets_validation_decision(v, x, None, {})[:2]
+    if planets_transit_smooth(v) or planets_transit_sawtooth(v):
+        return "rejected", "variability"
+    most = planets_occultation_max(x, v.get("depth_ppm", 0.0), v.get("period", planets_num(x.get("Period (days)"))))
+    sec, sig = v.get("depth_secondary_ppm"), v.get("secondary_sigma")
+    excess = (sec - most) / (sec / sig) if sec and sig and sig > 0 else 0.0
+    if twin and twin["depth_ppm"] > 0 and twin["snr"] > 0:
+        excess = max(excess, (twin["depth_ppm"] - most) / (twin["depth_ppm"] / twin["snr"]))
+    if not (excess >= 3.0 or planets_num(x.get("Planet Radius (R_Earth)")) >= 22.4):
+        return "rejected", "no binary's eclipse"
+    off = v["nfpp"] + sum(v.get("scenarios", {}).get(s, 0.0) for s in ("BTP", "BEB", "BEBx2P"))
+    return ("new", "") if off < 0.001 and not planets_centroid_off(v) else ("rejected", "another star")
+
+
+def planets_transit_velocities(name, sptype, g, mstar):
+    """A blind-search signal G of the census star NAME weighed with the star's velocities in ROOT, chosen and cleaned as the census's are
+    (planets_series) and averaged per night and series (planets_nightly), at the signal's own ephemeris (planets_transit_rv_fit) about a star of MSTAR
+    solar masses: the fit, its series, and the share of a period by which the ephemeris may be off at the velocities' mean epoch, the epoch's error
+    taken as the duration over twice the signal-to-noise and the period's as the root of two times that over the cycles its transits span; None where
+    the star has fewer than six nights."""
+    rows, labels = planets_series(name, planets_dace_series({name}), planets_bank_series({name}), sptype)
+    if not rows:
+        return None
+    x = planets_nightly(rows)
+    if len(x) < 6:
+        return None
+    # the transit's epoch from BTJD to MJD
+    P, Tc = g["P"], g["t0_btjd"] + 56999.5
+    times = [ev["time"] for ev in g["events"]]
+    eTc = g["duration_h"] / 24.0 / (2.0 * max(g["snr"], 1.0))
+    eP = math.sqrt(2.0) * eTc / max((max(times) - min(times)) / P, 1.0) if times else eTc
+    fit = planets_transit_rv_fit(x[:, 0], x[:, 1], x[:, 2], x[:, 3], P, Tc, mstar)
+    return dict(fit, series="; ".join(labels), phase_err=round(math.hypot(eTc, abs(float(x[:, 0].mean()) - Tc) / P * eP) / P, 4))
+
+
+# TESS's orbit and its multiples to 60 days, and half of it, periods at which its systematics recur
+planets_TESS_ORBITS = (6.85,) + tuple(13.7 * n for n in range(1, 5))
+
+
+def planets_transit_alias(g):
+    """A blind-search signal G whose transits fall on every second or every third of its epochs alone, as the signal at that multiple of its period
+    with those transits, renumbered: the multiple and residue whose transits, three or more, are detected at the highest signal-to-noise and at 3
+    sigma or more while the other epochs' lie within 3 sigma of no dip, each transit weighted by its points and its error the light curve's noise
+    over the root of its points (planets_transit_sets); its signal-to-noise that of those transits together, its red-noise signal-to-noise scaled by
+    their depth and number, its odd-even significance theirs, and alias the multiple; None where no multiple fits."""
+    ev = g["events"]
+    scale = sorted(abs(e["depth_ppm"] / e["snr"]) * math.sqrt(e["points"]) for e in ev if abs(e["snr"]) >= 1.0)
+    if not scale or g["depth_ppm"] <= 0:
+        return None
+    s0 = scale[len(scale) // 2]
+    mean = lambda x: (sum(e["depth_ppm"] * e["points"] for e in x) / sum(e["points"] for e in x), s0 / math.sqrt(sum(e["points"] for e in x)))
+    best = None
+    for m in (2, 3):
+        for r in range(m):
+            on, off = [e for e in ev if e["epoch"] % m == r], [e for e in ev if e["epoch"] % m != r]
+            if len(on) < 3 or not off:
+                continue
+            (d, e), (d_off, e_off) = mean(on), mean(off)
+            if d >= 3.0 * e and abs(d_off) < 3.0 * e_off and (best is None or d / e > best[0]):
+                best = (d / e, m, r, on, d)
+    if best is None:
+        return None
+    snr, m, r, on, d = best
+    events = [dict(e, epoch=(e["epoch"] - r) // m) for e in on]
+    sets = [[e for e in events if e["epoch"] % 2 == k] for k in (0, 1)]
+    if all(sets):
+        (d0, e0), (d1, e1) = mean(sets[0]), mean(sets[1])
+        odd_even = round(abs(d0 - d1) / math.hypot(e0, e1), 2)
+    else:
+        odd_even = None
+    power = [max(e["snr"], 0.0) ** 2 for e in events]
+    return dict(g, P=round(m * g["P"], 6), t0_btjd=round(g["t0_btjd"] + r * g["P"], 5), depth_ppm=round(d, 1), snr=round(snr, 2),
+                red_snr=round(g["red_snr"] * d / g["depth_ppm"] * math.sqrt(len(on) / g["transits"]), 2) if g.get("red_snr") else None,
+                transits=len(on), events=events, odd_even_sigma=odd_even, secondary_sigma=None,
+                single_event_share=round(max(power) / sum(power), 3) if sum(power) > 0 else None, alias=m)
+# the validation's outcomes that leave a transit past every other test a candidate: not validated, or not weighed
+planets_TRANSIT_OPEN = ("not validated", "no light curve", "no stellar parameters", "analysis failed")
+# the reason of a candidate whose star's variable-star catalogues no VizieR site would give
+planets_UNREAD = "variable catalogues unread"
+
+
+def planets_transit_rows(stars, names=None, full=False, old=False, shared=True):
     """The transit search's signals as signals.csv rows, of the stars NAMES alone where given: rejected on under three transits, one dominant
-    transit, odd-even depths, a secondary, TESS's orbit period, a period within 1 per cent of an earlier signal's of the star, its half or its
-    double, a red-noise signal-to-noise (planets_transit_red_snr) below 7.1, or a signal-to-noise below one and a half times the highest of the same
-    search of the light curve turned upside down, either unmeasured counting as below; of the rest, known where catalogued or a TOI within an
-    arcminute and 1 per cent in period, candidates otherwise."""
+    transit, odd-even depths, a secondary eclipse, half an orbit on or a second set of transits the search found at the same period and another phase,
+    transits whose depths scatter too far for the signal-to-noise against that scatter to reach 7.1 (planets_transit_scatter), a period within 1 per
+    cent of TESS's orbit, its half or a multiple (planets_TESS_ORBITS), or of an earlier signal's of the star, its half or its double, a red-noise
+    signal-to-noise (planets_transit_red_snr) below 7.1, or a signal-to-noise below one and a half times the highest of the same search of the light
+    curve turned upside down, either unmeasured counting as below; of the rest, known where catalogued or a TOI within an arcminute and 1 per cent
+    in period, rejected where more than half its transits lie within a duration of those a TOI or community TOI of the star predicts
+    (planets_transit_known), or where the star is itself a known eclipsing binary within 10 arcsec or varies at the period (planets_binary_known), candidates
+    otherwise, decided on their validation, a candidate the validation does not validate or cannot weigh staying one (planets_TRANSIT_OPEN). A signal
+    whose transits fall on every second or every third of its epochs alone is weighed at that multiple of its period (planets_transit_alias). A signal on a star with no TOI within an arcminute, whose odd and even transits differ with each set detected at 3 sigma
+    or which shows a secondary eclipse, is weighed instead as a binary's eclipses, a star's row, its period doubled where its odd and even eclipses
+    differ (planets_binary_signal), and on the same tests, the odd and even eclipses' depths each held to their own mean: known where a catalogue
+    already knows the binary, or with FULL set a paper SIMBAD links to the star (planets_binary_known), a candidate otherwise, decided on its
+    validation (planets_binary_decision); so is a candidate on such a star whose validation finds it larger than two Jupiter radii. With FULL set, a
+    census star's planet, candidate or validated, is also weighed with the star's velocities at its transit (planets_transit_velocities): new where its
+    ephemeris carries to the velocities within a tenth of a period, its semi-amplitude at the transit's phase is positive at 5 sigma and its free phase
+    agrees within 3 sigma, as a TESS candidate with velocities is, and rejected where that semi-amplitude gives 13 Jupiter masses or more. A body the
+    decision would make new is rejected where the validation's own fold does not show its box at 7.1 sigma (planets_transit_shape). A binary's two equal dips at a period under twice the search's shortest are a planet's transits at half the period where its weighing there
+    (planets_validate_checks) makes it new. With OLD set, a
+    validation weighed before the folded light's shape was read is decided on as it stands and no neighbour's variability is read (planets_validate_first).
+    SHARED sets a signal two stars show against each other (planets_transit_shared), which a caller deciding the rows in parts does across them all."""
     match = planets_catalogued()
     exo = [x for source in ("toi", "ctoi") if os.path.exists(planets_path(source + ".csv")) for x in planets_candidates(source)]
     xra, xdec = (np.array(v) for v in zip(*[planets_radec(x) for x in exo])) if exo else (np.zeros(0), np.zeros(0))
     xper = np.array([planets_num(x.get("Period (days)")) for x in exo])
+    labelled = list(zip([x["label"] for x in exo], xra.tolist(), xdec.tolist(), xper.tolist()))
     out = []
     paths = [os.path.join(planets_RESULTS, "transitsearch", archive_tag(n) + ".json") for n in names] if names else \
         sorted(glob.glob(os.path.join(planets_RESULTS, "transitsearch", "*.json")))
     for path in paths:
         if not os.path.exists(path):
             continue
-        rec = json.load(open(path))
+        rec = planets_load_json(path)
+        if not rec:
+            continue
         # a star the TESS stage searched is placed by its record's header details
         s = stars.get(rec["name"]) or dict(RAJ2000=rec.get("ra"), DEJ2000=rec.get("dec"), SpType="", Vmag=rec.get("tmag", ""))
         ra, dec = planets_num(s.get("RAJ2000")), planets_num(s.get("DEJ2000"))
@@ -5189,70 +5898,556 @@ def planets_transit_rows(stars, names=None):
                        K="", e="", msini_mjup="", msini_mearth="", fap="", flags="", object="planet", depth_ppm=g["depth_ppm"], duration_h=g["duration_h"],
                        t0_btjd=g["t0_btjd"], transit_snr=g["snr"], transits=g["transits"], odd_even_sigma=g["odd_even_sigma"],
                        secondary_sigma=g["secondary_sigma"], single_event_share=g["single_event_share"])
-            near = []
-            if len(exo) and math.isfinite(ra) and math.isfinite(dec):
-                sep = np.hypot(((xra - ra + 180.0) % 360.0 - 180.0) * math.cos(math.radians(dec)), xdec - dec) * 3600.0
+            sep = np.hypot(((xra - ra + 180.0) % 360.0 - 180.0) * math.cos(math.radians(dec)), xdec - dec) * 3600.0 \
+                if len(exo) and math.isfinite(ra) and math.isfinite(dec) else np.full(len(exo), np.inf)
+            hosts = [exo[j]["label"] for j in np.where(sep < 60.0)[0]]
+
+            def cat_at(p):
+                # the archive's planets of the star within 5 per cent of P, and the TOIs within an arcminute and 1 per cent of it
                 with np.errstate(divide="ignore", invalid="ignore"):
-                    near = [exo[j]["label"] for j in np.where((sep < 60.0) & (np.abs(P / xper - 1.0) < 0.01))[0]]
-            cat = ["archive %s" % n for n in match(ra, dec, rec.get("tic"), (rec["name"], s.get("SimbadName")), P)] + near
-            why = "fewer than three transits" if g["transits"] < 3 else "one transit" if (g["single_event_share"] or 0.0) >= 0.5 else \
-                "odd-even depths" if (g["odd_even_sigma"] or 0.0) >= 3.0 else "secondary eclipse" if (g["secondary_sigma"] or 0.0) >= 3.0 else \
-                "TESS orbit" if any(abs(P / q - 1.0) < 0.01 for q in (6.85, 13.7, 27.4)) else \
-                "harmonic" if any(abs(P / (q["P"] * m) - 1.0) < 0.01 for q in rec["signals"][:i] for m in (0.5, 1.0, 2.0)) else \
-                "red noise" if not (g.get("red_snr") or 0.0) >= 7.1 else \
-                "noise" if not g["snr"] >= 1.5 * (rec.get("inverted_snr") or float("inf")) else ""
-            row.update(catalogued="; ".join(cat), status="rejected" if why else "known" if cat else "candidate", reason=why or ("catalogued" if cat else ""))
+                    near = [exo[j]["label"] for j in np.where((sep < 60.0) & (np.abs(p / xper - 1.0) < 0.01))[0]]
+                return ["archive %s" % n for n in match(ra, dec, rec.get("tic"), (rec["name"], s.get("SimbadName")), p)] + near
+            cat = cat_at(P)
+            few = "fewer than three transits" if g["transits"] < 3 else "one transit" if (g["single_event_share"] or 0.0) >= 0.5 else ""
+            real = lambda q: q["transits"] >= 3 and (q.get("red_snr") or 0.0) >= 7.1 and q["snr"] >= 1.5 * (rec.get("inverted_snr") or float("inf"))
+            # a second set of eclipses at the same period and another phase, as an eccentric binary's secondary, where the search found one
+            twin = next((q for j, q in enumerate(rec["signals"]) if j != i and abs(q["P"] / P - 1.0) < 1e-3 and real(q)
+                         and 0.05 < ((q["t0_btjd"] - g["t0_btjd"]) / P) % 1.0 < 0.95), None)
+            split, eclipse = (g["odd_even_sigma"] or 0.0) >= 3.0, (g["secondary_sigma"] or 0.0) >= 3.0 or twin is not None
+            # a binary's eclipses, on a star with no TOI, whose transits a search might fold at a wrong period where its mask misses them: odd and even
+            # eclipses of different depths, each set detected at 3 sigma, the binary's period then twice the search's, or a secondary eclipse
+            host = bool(hosts)
+            binary = not few and not cat and not host and (split and all(d >= 3.0 * e for d, e in planets_transit_sets(g)) or not split and eclipse)
+            b = planets_binary_signal(g, split and binary)
+            # transits on every second or every third epoch alone, a planet's beyond the search's longest period: weighed at that period
+            alias = planets_transit_alias(g) if not few and not cat and not binary and (split or planets_transit_scatter(g) < 7.1) else None
+            h = alias or g
+            if alias:
+                cat = cat_at(h["P"])
+                few = "fewer than three transits" if h["transits"] < 3 else "one transit" if (h["single_event_share"] or 0.0) >= 0.5 else ""
+                split, eclipse = (h["odd_even_sigma"] or 0.0) >= 3.0, twin is not None
+                row.update(P=h["P"], depth_ppm=h["depth_ppm"], t0_btjd=h["t0_btjd"], transit_snr=h["snr"], transits=h["transits"],
+                           odd_even_sigma=h["odd_even_sigma"], secondary_sigma="", single_event_share=h["single_event_share"], alias=alias["alias"])
+            rest = "inconsistent depths" if planets_transit_scatter(h, split and binary) < 7.1 else \
+                "TESS orbit" if any(abs(p / q - 1.0) < 0.01 for p in {h["P"], b["P"]} for q in planets_TESS_ORBITS) else \
+                "harmonic" if any(abs(h["P"] / (q["P"] * m) - 1.0) < 0.01 for q in rec["signals"][:i] for m in (0.5, 1.0, 2.0)) else \
+                "red noise" if not (h.get("red_snr") or 0.0) >= 7.1 else \
+                "noise" if not h["snr"] >= 1.5 * (rec.get("inverted_snr") or float("inf")) else ""
             v = planets_load_json(os.path.join(planets_RESULTS, "validate_transits", archive_tag(rec["name"], i + 1) + ".json"))
-            if row["status"] == "candidate" and v:
-                cand = planets_transit_candidate(rec["name"], i + 1, g, v.get("tic"), v.get("star_radius"))
-                status, reason, cols = planets_validation_decision(v, cand, None, {})
+            # a validation weighed at another period than the one the signal is now weighed at, or before the folded light's shape was read
+            # (planets_transit_shape), stands for nothing (planets_validate_again)
+            if v and (abs(v.get("period", b["P"] if binary else h["P"]) / (b["P"] if binary else h["P"]) - 1.0) > 0.01 or not old and "fpp" in v and "shape_sectors" not in v):
+                v = None
+            # a signal whose catalogues could not be read stays a candidate until the next decision reads them
+            unread = False
+            two_dips = binary and not split and g["P"] < 2.0 * planets_TRANSIT_PMIN
+            if binary:
+                known = []
+                if not rest:
+                    try:
+                        known = planets_binary_known(ra, dec, b["P"], labelled, names=(rec["name"], s.get("SimbadName")), literature=full)
+                    except IOError:
+                        known, unread = [], True
+                row.update(object="star", orbit_P=b["P"], depth_ppm=b["depth_ppm"], t0_btjd=b["t0_btjd"], catalogued="; ".join(known),
+                           status="rejected" if rest else "known" if known else "candidate",
+                           reason=rest or ("catalogued" if known else planets_UNREAD if unread else ""))
+            else:
+                why = few or ("odd-even depths" if split else "secondary eclipse" if eclipse else "") or rest
+                veto = []
+                if not why and not cat:
+                    # a candidate whose transits are mostly those a registered TOI or community TOI predicts, within a duration, as a mask that missed
+                    # them leaves them
+                    eph = planets_transit_known(tic=rec["tic"]) if rec.get("tic") else planets_transit_known(ra=ra, dec=dec)
+                    times = [e["time"] for e in h["events"]]
+                    if times and any(sum(abs(((x - t0) / Pk + 0.5) % 1.0 - 0.5) * Pk < Dk for x in times) > 0.5 * len(times) for Pk, t0, Dk in eph):
+                        why = "a TOI's transits"
+                if not why and not cat:
+                    # a candidate whose star is itself a known eclipsing binary, within 10 arcsec, or varies at its period
+                    try:
+                        veto = planets_binary_known(ra, dec, h["P"], radius=10.0, simbad=("EB*", "EB?", "El*", "El?"), candidates=False)
+                    except IOError:
+                        veto, unread = [], True
+                    why = "known binary or variable" if veto else ""
+                row.update(catalogued="; ".join(cat or veto), status="rejected" if why else "known" if cat else "candidate",
+                           reason=why or ("catalogued" if cat else planets_UNREAD if unread else ""))
+            # equal dips half an orbit apart at a period the search's shortest doubled: a planet's transits at half the period, where its weighing there makes it new
+            if two_dips and row["status"] == "candidate" and not unread:
+                hv = planets_load_json(os.path.join(planets_RESULTS, "validate_transits", archive_tag(rec["name"], i + 1) + "_half.json"))
+                half = planets_transit_half(g)
+                if hv and "fpp" in hv and not planets_transit_physical(half, hv.get("star_radius"), hv.get("star_mass")) and \
+                        planets_validation_decision(hv, planets_transit_candidate(rec["name"], i + 1, half, hv.get("tic"), hv.get("star_radius")), None, {})[0] == "new":
+                    binary, v, h, twin = False, hv, half, None
+                    row.update(object="planet", orbit_P="", P=h["P"], depth_ppm=h["depth_ppm"], t0_btjd=h["t0_btjd"], transit_snr=h["snr"], secondary_sigma="", odd_even_sigma="", half=1)
+            if row["status"] == "candidate" and v and not unread:
+                # a binary is weighed with its star's mass and temperature, the deepest occultation a planet could give then known
+                as_star = lambda x: planets_transit_candidate(rec["name"], i + 1, x, v.get("tic"), v.get("star_radius"), v.get("star_mass"), v.get("star_teff"))
+                cand = as_star(b) if binary else planets_transit_candidate(rec["name"], i + 1, h, v.get("tic"), v.get("star_radius"))
+                status, reason, cols = (planets_binary_decision(v, cand, twin) + ({},)) if binary else planets_validation_decision(v, cand, None, {})
+                # a candidate the validation could not weigh is still too large for a planet where its depth on the TIC's star gives over two Jupiter radii
+                if not binary and status == "rejected" and reason in planets_TRANSIT_OPEN and planets_num(cand.get("Planet Radius (R_Earth)")) >= 22.4:
+                    reason = "radius"
+                if not binary and not host and (status, reason) == ("rejected", "radius"):
+                    # a body larger than two Jupiter radii is a star's: weighed as a binary's eclipses
+                    try:
+                        known = planets_binary_known(ra, dec, h["P"], labelled, names=(rec["name"], s.get("SimbadName")), literature=full)
+                    except IOError:
+                        known, unread = [], True
+                    row.update(object="star", orbit_P=h["P"], catalogued="; ".join(known))
+                    status, reason = ("candidate", planets_UNREAD) if unread else ("known", "catalogued") if known else planets_binary_decision(v, as_star(h))
+                # a planet whose star, with the radius and the mass its validation took, leaves no room for its orbit or its transit's length
+                phys = planets_transit_physical(h, v.get("star_radius"), v.get("star_mass")) if row["object"] == "planet" else ""
+                if phys:
+                    status, reason = "rejected", "inside the star" if phys.startswith("orbit") else "duration"
+                # a body the rest would make new, where the validation's own fold does not show its dip at 7.1 sigma, is not there
+                if status == "new" and not old and (v.get("shape_box_chi2") or 0.0) < 7.1 ** 2:
+                    status, reason = "rejected", "no dip in its fold"
+                # a body the rest would make new, where a variable star near it varies at its period, is that star's
+                if status == "new" and not old:
+                    try:
+                        neighbours = planets_variable_neighbours(ra, dec, planets_num(row.get("orbit_P") or h["P"]))
+                    except IOError:
+                        neighbours, status, reason = [], "candidate", planets_UNREAD
+                    if neighbours:
+                        status, reason = "rejected", "a neighbour's variability"
+                        row["catalogued"] = "; ".join(neighbours)
+                # a signal past every test but the validation, or one the validation could not weigh, stays a candidate
+                if status == "rejected" and reason in planets_TRANSIT_OPEN:
+                    status = "candidate"
                 if status is not None:
                     row.update(cols, fpp=max(v["fpp"], 0.0) if "fpp" in v else "", nfpp=max(v["nfpp"], 0.0) if "nfpp" in v else "", status=status, reason=reason,
-                               radius_rearth=cand["Planet Radius (R_Earth)"])
+                               radius_rearth=cand["Planet Radius (R_Earth)"], **planets_check_cols(v, v.get("period", h["P"]), cand))
+            if full and row["object"] == "planet" and row["status"] in ("candidate", "new") and not rec.get("tic") and not unread:
+                # a census star's velocities weighed at the transit: new as a TESS candidate with velocities is, a star's or brown dwarf's mass rejected
+                mstar = (v or {}).get("star_mass") or planets_mass(s.get("SpType")) or 1.0
+                rv = planets_transit_velocities(rec["name"], s.get("SpType", ""), h, mstar)
+                if rv:
+                    row.update(K=rv["K"], msini_mearth=rv["msini_mearth"], nights=rv["nights"], span_d=rv["span_d"])
+                    if rv["snr"] and rv["snr"] >= 5.0 and rv["phase_err"] < 0.1 and abs(rv["phase_offset_deg"]) <= 3.0 * rv["ephase_deg"]:
+                        row.update(status="rejected", reason="velocities") if rv["msini_mearth"] >= 13.0 * 317.83 else row.update(status="new", reason="")
             out.append(row)
+    if shared:
+        planets_transit_shared(out)
     return out
 
 
+def planets_transit_shared(out):
+    """A signal two stars within two arcminutes both show, at one period within one part in ten thousand (or its half or double) and one phase within a duration,
+    is the brighter star's: the fainter's row of OUT is rejected as another star's. Each row is set only against those within two arcminutes in declination."""
+    import bisect
+    live = [r for r in out if r["status"] in ("candidate", "new") and math.isfinite(planets_num(r["ra"])) and math.isfinite(planets_num(r["dec"]))
+            and math.isfinite(planets_num(r["vmag"]))]
+    by_dec = sorted((planets_num(r["dec"]), k) for k, r in enumerate(live))
+    decs = [d for d, _ in by_dec]
+    for x in live:
+        px = planets_num(x.get("orbit_P") or x["P"])
+        dx = planets_num(x["dec"])
+        near = sorted(k for _, k in by_dec[bisect.bisect_left(decs, dx - 120.0 / 3600.0):bisect.bisect_right(decs, dx + 120.0 / 3600.0)])
+        for y in (live[k] for k in near):
+            py = planets_num(y.get("orbit_P") or y["P"])
+            if x["name"] == y["name"] or not planets_num(x["vmag"]) > planets_num(y["vmag"]) or not any(abs(px / (m * py) - 1.0) < 1e-4 for m in (0.5, 1.0, 2.0)):
+                continue
+            cosd = math.cos(math.radians(planets_num(y["dec"])))
+            sep = math.hypot(((planets_num(x["ra"]) - planets_num(y["ra"]) + 180.0) % 360.0 - 180.0) * cosd, planets_num(x["dec"]) - planets_num(y["dec"])) * 3600.0
+            q = min(px, py)
+            phase = abs(((planets_num(x["t0_btjd"]) - planets_num(y["t0_btjd"])) / q + 0.5) % 1.0 - 0.5) * q
+            if sep < 120.0 and phase * 24.0 < max(planets_num(x["duration_h"]), planets_num(y["duration_h"])):
+                x.update(status="rejected", reason="another star's signal", catalogued=y["name"])
+                break
+
+
+def planets_transit_hopeless(rec, i, g):
+    """Whether the search's own vetting rejects the signal G, the Ith of the record REC, whatever the catalogues and its validation say (planets_transit_rows):
+    under three transits or one dominating them; or, with no transits on every second or third epoch to be weighed at that multiple, depths that scatter too far on
+    either reading of its odd and even transits, a period at TESS's orbit or an earlier signal's, or too low a red-noise or inverted-search signal-to-noise."""
+    if g["transits"] < 3 or (g["single_event_share"] or 0.0) >= 0.5:
+        return True
+    split, scatter = (g["odd_even_sigma"] or 0.0) >= 3.0, planets_transit_scatter(g)
+    if (split or scatter < 7.1) and planets_transit_alias(g):
+        return False
+    return (scatter < 7.1 and (not split or planets_transit_scatter(g, True) < 7.1)) or any(abs(g["P"] / q - 1.0) < 0.01 for q in planets_TESS_ORBITS) or \
+        any(abs(g["P"] / (q["P"] * m) - 1.0) < 0.01 for q in rec["signals"][:i] for m in (0.5, 1.0, 2.0)) or not (g.get("red_snr") or 0.0) >= 7.1 or \
+        not g["snr"] >= 1.5 * (rec.get("inverted_snr") or float("inf"))
+
+
+def planets_rules_hash(functions, values=()):
+    """A digest of the source of the named FUNCTIONS of this file and of VALUES, which changes when a rule they hold does."""
+    import hashlib
+    import inspect
+    h = hashlib.sha256()
+    for name in functions:
+        h.update(inspect.getsource(globals()[name]).encode())
+    h.update(repr(values).encode())
+    return h.hexdigest()[:16]
+
+
+def planets_transit_kept(stars, read_only=False):
+    """The TESS root's transit rows that are not rejected, each star decided once and again only when it must be, kept in RESULTS/decided.sqlite, so that a decision
+    costs what changed and not the whole root: a star whose search record or validations have changed since it was decided, by their times and sizes, is read again;
+    one whose signals the search's own vetting rejects outright (planets_transit_hopeless) is done, and any other is decided (planets_transit_rows). Every star that
+    has a signal past that vetting is decided again when the rules that decide it or ExoFOP's or the archive's tables change, and when a catalogue could not be read;
+    every star is read again when that vetting itself changes, each change found from the rules' source (planets_rules_hash). With READ_ONLY the rows as last decided
+    are returned, or None where nothing has been. The fainter of two stars showing one signal is rejected across all the rows (planets_transit_shared)."""
+    import hashlib
+    import sqlite3
+    path = os.path.join(planets_RESULTS, "decided.sqlite")
+    if read_only and not os.path.exists(path):
+        return None
+    db = sqlite3.connect(path, timeout=600)
+    db.execute("PRAGMA journal_mode=WAL")
+    db.execute("CREATE TABLE IF NOT EXISTS stars (tag TEXT PRIMARY KEY, sig TEXT, live INTEGER, rows TEXT)")
+    db.execute("CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT)")
+    if not read_only:
+        search, weighed = os.path.join(planets_RESULTS, "transitsearch"), os.path.join(planets_RESULTS, "validate_transits")
+        extra = {}
+        if os.path.isdir(weighed):
+            with os.scandir(weighed) as it:
+                for e in it:
+                    m = re.fullmatch(r"(.+?)_\d+(?:_half)?\.json", e.name)
+                    if m:
+                        st = e.stat()
+                        extra.setdefault(m.group(1), []).append("%s:%d:%d" % (e.name, st.st_mtime_ns, st.st_size))
+        current = {}
+        with os.scandir(search) as it:
+            for e in it:
+                if e.name.endswith(".json"):
+                    st = e.stat()
+                    current[e.name[:-5]] = "%d:%d|%s" % (st.st_mtime_ns, st.st_size, "|".join(sorted(extra.get(e.name[:-5], ()))))
+        tables = []
+        for name in ("toi.csv", "ctoi.csv", "known.csv", "eclipsing_binaries.npy", "eclipsing_candidates.npy"):
+            p = planets_path(name)
+            tables.append(os.path.getsize(p) if name.endswith(".npy") and os.path.exists(p) else hashlib.sha256(open(p, "rb").read()).hexdigest() if os.path.exists(p) else "")
+        vetting = planets_rules_hash(("planets_transit_hopeless", "planets_transit_scatter", "planets_transit_alias", "planets_transit_sets"), (planets_TESS_ORBITS,))
+        deciding = planets_rules_hash(("planets_transit_rows", "planets_validation_decision", "planets_binary_decision", "planets_transit_smooth", "planets_transit_sawtooth",
+                                       "planets_transit_half", "planets_transit_physical", "planets_binary_known", "planets_variable_neighbours", "planets_variables_near",
+                                       "planets_check_cols", "planets_centroid_off", "planets_transit_candidate", "planets_occultation_max", "planets_transit_known",
+                                       "planets_binary_signal"),
+                                      (planets_RUWE_MAX, planets_SPIN_FAST, planets_SPIN_LOW, planets_SPIN_HIGH, planets_OWN_RADIUS, planets_NEIGHBOUR_RADIUS, planets_VSX_TRANSIT,
+                                       planets_UNREAD, planets_TRANSIT_OPEN, planets_TRANSIT_PMIN, tables))
+        meta = dict(db.execute("SELECT key, value FROM meta").fetchall())
+        known = dict(db.execute("SELECT tag, sig FROM stars").fetchall()) if meta.get("vetting") == vetting else {}
+        redo = {t for t, in db.execute("SELECT tag FROM stars WHERE live = 1")} if meta.get("deciding") != deciding else set()
+        redo |= {t for t, in db.execute("SELECT tag FROM stars WHERE rows LIKE ?", ('%"reason": "' + planets_UNREAD + '"%',))}
+        done, read = [], 0
+        for tag, sig in current.items():
+            if known.get(tag) == sig:
+                continue
+            rec = planets_load_json(os.path.join(search, tag + ".json"))
+            if not rec:
+                continue
+            read += 1
+            if any(not planets_transit_hopeless(rec, i, g) for i, g in enumerate(rec.get("signals", []))):
+                redo.add(tag)
+            else:
+                done.append((tag, sig, 0, None))
+            if len(done) >= 5000:
+                db.executemany("INSERT OR REPLACE INTO stars VALUES (?, ?, ?, ?)", done)
+                db.commit()
+                done = []
+        db.executemany("INSERT OR REPLACE INTO stars VALUES (?, ?, ?, ?)", done)
+        db.executemany("DELETE FROM stars WHERE tag = ?", [(t,) for t in set(known) - set(current)])
+        db.commit()
+        todo = sorted(redo & set(current))
+        for c in range(0, len(todo), 500):
+            part = todo[c:c + 500]
+            got = {}
+            for r in planets_transit_rows(stars, part, full=True, shared=False):
+                if r["status"] != "rejected":
+                    got.setdefault(archive_tag(r["name"]), []).append(r)
+            db.executemany("INSERT OR REPLACE INTO stars VALUES (?, ?, ?, ?)", [(t, current[t], 1, json.dumps(got[t], default=float) if t in got else None) for t in part])
+            db.commit()
+        db.executemany("INSERT OR REPLACE INTO meta VALUES (?, ?)", [("vetting", vetting), ("deciding", deciding)])
+        db.commit()
+        print("%d stars, %d read again, %d decided" % (len(current), read, len(todo)), flush=True)
+    rows = []
+    for text, in db.execute("SELECT rows FROM stars WHERE rows IS NOT NULL ORDER BY tag"):
+        rows += json.loads(text)
+    db.close()
+    planets_transit_shared(rows)
+    return rows
+
+
+def planets_transit_centroids(tic, P, t0, D, most=8, nulls=60):
+    """Where a transit's dimming comes from, read in its star's light curves from MAST's bucket, SPOC's where any covers a transit, else TESS-SPOC's,
+    MOST sectors at most (planets_tess_index, planets_tess_key), for the ephemeris P (days), T0 (BTJD) and duration D (days). In each sector the points
+    of quality zero within half a duration of a transit's middle are set against those between one and three durations of it: the PDCSAP and the
+    simple-aperture depths, the background's change and the shift of the flux-weighted centroid (MOM_CENTR1, MOM_CENTR2), each with its error from the
+    scatter out of transit. The centroid's shift over the simple-aperture depth places the dimming's source from the centroid out of transit (for a
+    small depth the centroid moves away from the source by the depth times their separation), and the aperture's WCS turns that place into a position
+    on the sky, set against the star's. Each measure's error is the scatter of the same measure taken at the same windows moved, all of a sector's
+    transits together, to NULLS other times of the sector clear of the transits by two durations, so that the light curve's correlated noise is in
+    it; with fewer than eight such times, twice the error from the scatter out of transit. The source is placed both from the star and from the
+    centroid out of transit, which an aperture cut short of the star's light or the frame's conventions move from the star by up to a pixel or so
+    while a dimming of the star itself, where it gives most of the aperture's light (CROWDSAP near one), leaves the source on that centroid. Returns
+    each sector's measures with its crowding, the sectors' median offsets of the source from the star and from the centroid (arcsec, east and north),
+    each with an error, the larger of the sectors' median error and their scatter about the median, over the root of the sectors' number, and its
+    significance, and the TIC stars within two arcminutes with the eclipse depth each would need to give the PDCSAP depth; None where no light curve
+    covers a transit."""
+    from astropy.io import fits
+    from astropy.wcs import WCS
+    warnings.filterwarnings("ignore")
+    tics, secs, kinds, sectors = planets_tess_index()
+    a, b = int(np.searchsorted(tics, tic)), int(np.searchsorted(tics, tic, side="right"))
+    held = {k: sorted(s for s, kk in zip(secs[a:b].tolist(), kinds[a:b].tolist()) if kk == k and "t0" in sectors.get(s, {})) for k in (0, 1)}
+    t0m = t0 + 56999.5
+    covers = lambda s: math.ceil((sectors[s]["t0"] - t0m) / P) * P + t0m <= sectors[s]["t1"]
+    kind = 0 if any(covers(s) for s in held[0]) else 1
+    keep = [s for s in held[kind] if covers(s)]
+    keep = [keep[int(j)] for j in np.unique(np.linspace(0, len(keep) - 1, most).round())] if len(keep) > most else keep
+    if not keep:
+        return None
+    out, head = [], {}
+    for s in keep:
+        raw = archive_get(planets_TESS_BUCKET + planets_tess_key(tic, s, kind, sectors), timeout=300, soft=True)
+        if not raw:
+            continue
+        with fits.open(io.BytesIO(raw)) as h:
+            H, d, ap = h[0].header, h["LIGHTCURVE"].data, h["APERTURE"].header
+            col = lambda k: np.asarray(d[k], float) if k in d.columns.names else np.full(len(d), np.nan)
+            t, pdc, sap, bkg, cx, cy, q = (col(k) for k in ("TIME", "PDCSAP_FLUX", "SAP_FLUX", "SAP_BKG", "MOM_CENTR1", "MOM_CENTR2", "QUALITY"))
+            w = WCS(ap)
+            ra, dec = archive_num(H.get("RA_OBJ")), archive_num(H.get("DEC_OBJ"))
+            crowd = archive_num(h["LIGHTCURVE"].header.get("CROWDSAP"))
+            head = head or dict(ra=ra, dec=dec, tmag=archive_num(H.get("TESSMAG")))
+            ox, oy = float(ap.get("CRVAL1P", 0.0)), float(ap.get("CRVAL2P", 0.0))
+        ok = np.isfinite(t) & np.isfinite(pdc) & np.isfinite(sap) & np.isfinite(cx) & np.isfinite(cy) & np.isfinite(bkg) & (q == 0)
+        t, pdc, sap, bkg, cx, cy = (x[ok] for x in (t, pdc, sap, bkg, cx, cy))
+        if len(t) < 100:
+            continue
+        mids = t0 + P * np.arange(math.ceil((t.min() - D - t0) / P), math.floor((t.max() + D - t0) / P) + 1)
+        series = (pdc / np.median(pdc), sap / np.median(sap), bkg, -cx, -cy)
+
+        def measure(centres):
+            # the windows' out-of-transit means less their in-transit means, for every series at once
+            dist = np.min(np.abs(t[:, None] - centres[None, :]), axis=1)
+            inn, ring = dist < 0.5 * D, (dist > D) & (dist < 3.0 * D)
+            if inn.sum() < 5 or ring.sum() < 20:
+                return None, inn, ring
+            return np.array([float(np.mean(x[ring]) - np.mean(x[inn])) for x in series]), inn, ring
+        true, inn, ring = measure(mids)
+        if true is None:
+            continue
+        # the same windows moved to other times of the sector, clear of every transit by two durations
+        clear = lambda c: np.min(np.abs(c[:, None] - mids[None, :]), axis=1).min() > 2.0 * D
+        null = [m for m in (measure(mids + shift)[0] for shift in np.linspace(-0.5 * (t.max() - t.min()), 0.5 * (t.max() - t.min()), 4 * nulls)
+                            if clear(mids + shift)) if m is not None]
+        if len(null) >= 8:
+            null = np.array(null)
+            err = 1.4826 * np.median(np.abs(null - np.median(null, axis=0)), axis=0)
+        else:
+            err = 2.0 * np.array([1.4826 * float(np.median(np.abs(x[ring] - np.median(x[ring])))) * math.sqrt(1.0 / inn.sum() + 1.0 / ring.sum()) for x in series])
+        (dp, ds, db, sx, sy), (ep, es, eb, esx, esy) = true, err
+        # the centroid's shift into transit, and the source's place on the detector from it
+        row = dict(sector=s, transits=int(len(np.unique(np.round((t[inn] - t0) / P)))), depth_ppm=round(1e6 * dp, 1), depth_err_ppm=round(1e6 * ep, 1),
+                   depth_sap_ppm=round(1e6 * ds, 1), crowding=crowd, background_change=round(db, 3) if math.isfinite(db) else None,
+                   background_sigma=round(db / eb, 2) if math.isfinite(db) and eb > 0 else None,
+                   shift_px=[round(sx, 6), round(sy, 6)], shift_err_px=[round(esx, 6), round(esy, 6)])
+        if ds > 3.0 * es:
+            cxo, cyo = float(np.mean(cx[ring])), float(np.mean(cy[ring]))
+            sky = lambda x, y: w.all_pix2world([[x - ox, y - oy]], 0)[0]
+            arcsec = lambda p, q_: [round((p[0] - q_[0]) * math.cos(math.radians(dec)) * 3600.0, 2), round((p[1] - q_[1]) * 3600.0, 2)]
+            src, cen = sky(cxo - sx / ds, cyo - sy / ds), sky(cxo, cyo)
+            # the error of the source's place: the shift's error over the depth, one pixel being 21 arcsec
+            err = 21.0 * math.hypot(esx, esy) / ds / math.sqrt(2.0)
+            row.update(offset_arcsec=arcsec(src, (ra, dec)), from_centroid_arcsec=arcsec(src, cen), centroid_arcsec=arcsec(cen, (ra, dec)),
+                       offset_err_arcsec=round(err, 2))
+        out.append(row)
+    if not out:
+        return None
+    placed = [r for r in out if "offset_arcsec" in r]
+    res = dict(tic=tic, light_curves="SPOC" if kind == 0 else "TESS-SPOC", sectors=out)
+    if placed:
+        # the sectors' median place of the source, from the star and from the centroid out of transit, so that no one sector's systematics carry
+        # it, against the larger of the sectors' median error and their own scatter about it, each over the root of their number
+        n = len(placed)
+        for key in ("offset_arcsec", "from_centroid_arcsec"):
+            x = np.array([r[key] for r in placed])
+            off = np.median(x, axis=0)
+            scatter = (1.4826 * np.median(np.abs(x - off), axis=0) if n >= 3 else np.abs(x[0] - x[-1]) / math.sqrt(2.0)) if n > 1 else np.zeros(2)
+            err = max(float(np.median([r["offset_err_arcsec"] for r in placed])), float(scatter.max())) / math.sqrt(n)
+            res[key] = [round(float(v), 2) for v in off]
+            res[key.replace("arcsec", "err_arcsec")] = round(err, 2)
+            res[key.replace("arcsec", "sigma")] = round(float(np.hypot(*off)) / err, 2) if err > 0 else None
+    try:
+        cone = planets_tic_cone(tic)
+        me = [s_ for s_ in cone if str(s_["ID"]) == str(tic)]
+        tm = float(me[0]["Tmag"]) if me else head.get("tmag", float("nan"))
+        depth = max((r["depth_ppm"] for r in out), default=0.0) / 1e6
+        near = []
+        for s_ in cone:
+            if str(s_["ID"]) != str(tic) and np.isfinite(float(s_["Tmag"])):
+                sep = math.hypot((float(s_["ra"]) - head["ra"]) * math.cos(math.radians(head["dec"])), float(s_["dec"]) - head["dec"]) * 3600.0
+                if sep < 120.0:
+                    near.append(dict(tic=int(s_["ID"]), sep_arcsec=round(sep, 1), dtmag=round(float(s_["Tmag"]) - tm, 2),
+                                     eclipse_needed=round(depth * 10 ** (0.4 * (float(s_["Tmag"]) - tm)), 4)))
+        res["neighbours"] = sorted(near, key=lambda x: x["eclipse_needed"])[:10]
+    except Exception as exc:
+        res["neighbours_error"] = "%s: %s" % (type(exc).__name__, str(exc)[:160])
+    return res
+
+
+def planets_transit_dossier(name):
+    """Everything the root holds on the blind search's signals of the star NAME, printed: the stored search with each signal's transits, each signal as
+    it is weighed (at a multiple of its period where its transits fall on every second or third epoch, planets_transit_alias), its decision
+    (planets_transit_rows with the decision's own checks) and validation record, its weighing with the star's velocities (planets_transit_velocities),
+    where it is not rejected the place of its dimming's source from the light curves' centroids with the neighbours that could host it
+    (planets_transit_centroids), and SIMBAD's identifiers, type and papers on binaries, planets and companions for the star."""
+    # titles and names outside the console's code page printed with a stand-in rather than stopping the dossier
+    sys.stdout.reconfigure(errors="replace")
+    stars = {r["Name"]: r for r in planets_read(planets_path("bank_stars.csv"))}
+    path = os.path.join(planets_RESULTS, "transitsearch", archive_tag(name) + ".json")
+    if not os.path.exists(path):
+        print("%s: no stored search in %s" % (name, planets_RESULTS))
+        return
+    rec, s = json.load(open(path)), stars.get(name, {})
+    print("%s: %s sectors, %s points over %s d, noise %s ppm, inverted S/N %s, masked %s%s" % (
+        name, rec.get("sectors"), rec.get("points"), rec.get("span_d"), rec.get("noise_ppm"), rec.get("inverted_snr"), rec.get("masked"),
+        "; " + rec["note"] if rec.get("note") else ""))
+    for k, x in enumerate(rec.get("set_aside", []), 1):
+        print("  set aside %d: P %.5f d, %s transits, single share %s" % (k, x["P"], x["transits"], x["single_event_share"]))
+    rows = {r["label"]: r for r in planets_transit_rows(stars, [name], full=True)}
+    for i, g in enumerate(rec.get("signals", []), 1):
+        h = planets_transit_alias(g) or g
+        r = rows.get("transit %d" % i, {})
+        print("signal %d: P %.6f d, t0 %.5f BTJD, %.0f ppm, %.2f h, S/N %.1f (%.2f of the inverted search's), red S/N %s, %d transits, odd-even %s, "
+              "secondary %s, single share %s" % (i, g["P"], g["t0_btjd"], g["depth_ppm"], g["duration_h"], g["snr"], g["snr"] / (rec.get("inverted_snr") or float("nan")),
+                                                g.get("red_snr"), g["transits"], g["odd_even_sigma"], g["secondary_sigma"], g["single_event_share"]))
+        for e in g["events"]:
+            print("    epoch %4d at %.4f: %3d points, %7.0f ppm, S/N %6.1f" % (e["epoch"], e["time"], e["points"], e["depth_ppm"], e["snr"]))
+        if h is not g:
+            print("  weighed at %d times the period, %.6f d: %.0f ppm, S/N %.1f, %d transits, odd-even %s" % (h["alias"], h["P"], h["depth_ppm"], h["snr"],
+                                                                                                         h["transits"], h["odd_even_sigma"]))
+        print("  decision: %s %s (%s) %s; FPP %s NFPP %s" % (r.get("object", ""), r.get("status", ""), r.get("reason", ""), r.get("catalogued", ""), r.get("fpp", ""),
+                                                           r.get("nfpp", "")))
+        v = planets_load_json(os.path.join(planets_RESULTS, "validate_transits", archive_tag(name, i) + ".json"))
+        if v:
+            print("  validation: %s" % {k: v.get(k) for k in ("period", "depth_ppm", "fpp", "nfpp", "runs", "odd_even_sigma", "secondary_sigma", "shape_box_chi2",
+                                                               "shape_sine_chi2", "shape_box_sigma", "shape_sector_chi2", "shape_sector_scatter", "shape_sectors",
+                                                               "note", "star_radius", "star_mass", "star_teff",
+                                                               "sectors", "light_curves")})
+        if not rec.get("tic"):
+            print("  velocities at %.6f d: %s" % (h["P"], planets_transit_velocities(name, s.get("SpType", ""), h, (v or {}).get("star_mass") or
+                                                                                      planets_mass(s.get("SpType")))))
+        tic = rec.get("tic") or (v or {}).get("tic")
+        if tic and r.get("status") != "rejected":
+            c = planets_transit_centroids(int(tic), h["P"], h["t0_btjd"], h["duration_h"] / 24.0)
+            for x in (c or {}).get("sectors", []):
+                print("  sector %3d: %d transits, depth %s +- %s ppm (aperture %s, crowding %s), background change %s (%s sigma), centroid shift %s +- %s "
+                      "px, source %s from the star and %s from the centroid +- %s arcsec" % (
+                          x["sector"], x["transits"], x["depth_ppm"], x["depth_err_ppm"], x["depth_sap_ppm"], x["crowding"], x["background_change"],
+                          x["background_sigma"], x["shift_px"], x["shift_err_px"], x.get("offset_arcsec"), x.get("from_centroid_arcsec"), x.get("offset_err_arcsec")))
+            if c and "offset_arcsec" in c:
+                print("  centroids (%s), the sectors' median: the source %s +- %s arcsec from the star (%s sigma) and %s +- %s from the centroid (%s sigma)" % (
+                    c["light_curves"], c["offset_arcsec"], c["offset_err_arcsec"], c["offset_sigma"], c["from_centroid_arcsec"], c["from_centroid_err_arcsec"],
+                    c["from_centroid_sigma"]))
+            for x in (c or {}).get("neighbours", [])[:6]:
+                print("  neighbour TIC %d at %s arcsec, %+.2f mag: an eclipse of %.2f%% would give the depth" % (x["tic"], x["sep_arcsec"], x["dtmag"],
+                                                                                                              100.0 * x["eclipse_needed"]))
+    ids = [n for n in (s.get("SimbadName"), name) if n]
+    print("SIMBAD: %s" % archive_simbad_basic(ids, ("main_id", "otype")))
+    for n, papers in archive_simbad_papers(ids, words=planets_BINARY_WORDS + ("planet", "companion")).items():
+        for b, y, title in papers[:12]:
+            print("  %s %s %s" % (b, y, title[:150]))
+
+
 def planets_load_json(path):
-    """A JSON file's record, or None where there is none."""
-    return json.load(open(path)) if os.path.exists(path) else None
+    """A JSON file's record, or None where there is none or it cannot be read, as a write a full disk cut short leaves it."""
+    try:
+        return json.load(open(path)) if os.path.exists(path) else None
+    except ValueError:
+        return None
 
 
-def planets_transit_candidate(name, k, g, tic, rstar):
+def planets_transit_candidate(name, k, g, tic, rstar, mstar=None, teff=None):
     """A blind-search signal G, the Kth of the star NAME, as a row of ExoFOP's TOI table for the validation: its TIC number, ephemeris, duration and
-    depth, and the radius its depth gives on a star of RSTAR solar radii."""
+    depth, the radius its depth gives on a star of RSTAR solar radii, and the star's radius, mass MSTAR (solar) and temperature TEFF (K) where given."""
     radius = 109.08 * rstar * math.sqrt(g["depth_ppm"] / 1e6) if rstar and g["depth_ppm"] > 0 else None
+    star = {c: repr(float(x)) for c, x in (("Stellar Radius (R_Sun)", rstar), ("Stellar Mass (M_Sun)", mstar), ("Stellar Eff Temp (K)", teff))
+            if x not in (None, "") and math.isfinite(planets_num(x))}
     return {"label": "OL-%s.%d" % (archive_tag(name), k), "TOI": "%s.%d" % (archive_tag(name), k), "TIC ID": str(tic), "Period (days)": repr(g["P"]),
             "Epoch (BJD)": repr(g["t0_btjd"] + 2457000.0), "Duration (hours)": repr(g["duration_h"]), "Depth (ppm)": repr(g["depth_ppm"]),
-            "Planet Radius (R_Earth)": repr(radius) if radius else ""}
+            "Planet Radius (R_Earth)": repr(radius) if radius else "", **star}
+
+
+# the mass a star of unknown mass is given when a transit's orbit is placed against it, more than a star of its kind holds, so that an orbit inside it
+# at that mass is inside it at any
+planets_MASS_CEILING = 2.5
 
 
 def planets_transit_physical(g, rstar, mstar):
     """Why a blind-search signal G cannot be a planet's transit of a star of RSTAR solar radii and MSTAR solar masses, or nothing: its orbit within
-    1.5 stellar radii, or its box more than twice the longest transit its orbit allows, a central transit of a body of the depth's radius ratio on a
-    circular orbit; nothing where the star's radius or mass is unknown."""
-    if not (rstar and mstar and rstar > 0 and mstar > 0):
+    1.5 stellar radii, or its box more than one and a half times, the widest step of the search's durations, the longest transit its orbit allows, a
+    central transit of a body of the depth's radius ratio on a circular orbit. Where the star's mass is unknown, its orbit is placed for planets_MASS_CEILING solar masses, the widest it could be, and the
+    duration is not judged; nothing where the radius is unknown."""
+    rstar, mstar = planets_num(rstar), planets_num(mstar)
+    if not rstar > 0:
         return ""
-    a = 215.032 * (mstar * (g["P"] / 365.25) ** 2) ** (1.0 / 3.0)
+    known = mstar > 0
+    a = 215.032 * ((mstar if known else planets_MASS_CEILING) * (g["P"] / 365.25) ** 2) ** (1.0 / 3.0)
     if a < 1.5 * rstar:
         return "orbit inside the star"
+    if not known:
+        return ""
     longest = 24.0 * g["P"] / math.pi * math.asin(min(1.0, rstar * (1.0 + math.sqrt(max(g["depth_ppm"], 0.0) / 1e6)) / a))
-    return "duration %.1f h against at most %.1f h" % (g["duration_h"], longest) if g["duration_h"] > 2.0 * longest else ""
+    return "duration %.1f h against at most %.1f h" % (g["duration_h"], longest) if g["duration_h"] > 1.5 * longest else ""
+
+
+def planets_validate_again(path, P=None):
+    """Whether the blind transit search's candidate whose validation record is PATH is to be weighed: it has no record, its record was weighed at
+    another period than P by more than 1 per cent or before the folded light's shape was read (planets_transit_shape), or its analysis raised an
+    error, fewer than three times."""
+    if not os.path.exists(path):
+        return True
+    v = planets_load_json(path)
+    if not v:
+        return True
+    if P and "period" in v and abs(v["period"] / P - 1.0) > 0.01 or "fpp" in v and "shape_sectors" not in v:
+        return True
+    # a record made without a light curve before QLP's were asked for is weighed once more
+    if v.get("note") == "no light curve or aperture" and not v.get("qlp"):
+        return True
+    return "fpp" not in v and re.match(r"\w+: ", v.get("note", "")) is not None and v.get("tries", 1) < 3
+
+
+def planets_validate_first():
+    """The stars whose transit-search validation, weighed before the folded light's shape was read (planets_transit_shape), would make a body new as it
+    stands (planets_transit_rows): those weighed ahead of the rest."""
+    tags = set()
+    for path in glob.glob(os.path.join(planets_RESULTS, "validate_transits", "*.json")):
+        v = planets_load_json(path)
+        if v and "fpp" in v and "shape_sectors" not in v:
+            tags.add(re.sub(r"_\d+\.json$", "", os.path.basename(path)))
+    if not tags:
+        return []
+    stars = {r["Name"]: r for r in planets_read(planets_path("bank_stars.csv"))}
+    return sorted({row["name"] for row in planets_transit_rows(stars, sorted(tags), old=True) if row["status"] == "new"})
 
 
 def planets_validate_transits(draws=100000, runs=10, part=None, names=None):
     """The blind transit search's candidates (planets_transit_rows), of the stars NAMES alone where given, validated statistically as TESS's candidates
     are (planets_validate_one), each star's TIC number the brightest TIC star within 20 arcsec of its J2000 position, each to
-    RESULTS/validate_transits/<star>_<k>.json with that number and the TIC's radius and mass of the star; a candidate the star's radius and mass rule
-    out (planets_transit_physical) is written with why, unweighed. PART takes the share K/N of the candidates without a record."""
+    RESULTS/validate_transits/<star>_<k>.json with that number and the TIC's radius, mass and temperature of the star; a planet the star's radius and
+    mass rule out (planets_transit_physical) is written with why, unweighed, a binary's eclipses are weighed at the binary's period with its deeper
+    eclipses (planets_binary_signal), and a candidate whose analysis raises is written with the error and weighed again, three times at most
+    (planets_validate_again). A candidate is claimed by a folder of its name under RESULTS/validate_transits_claims while it is weighed, so that
+    processes side by side weigh it once, a claim two hours old being taken over, and the weighing ends between candidates where a long search would
+    end between stars (planets_search_ends). PART takes the share K/N of the candidates to weigh."""
     from astroquery.mast import Catalogs
     from astropy.coordinates import SkyCoord
     import astropy.units as u
+    import socket
+    # every network call gives up after five minutes without an answer
+    socket.setdefaulttimeout(300)
     stars = {r["Name"]: r for r in planets_read(planets_path("bank_stars.csv"))}
     folder = os.path.join(planets_RESULTS, "validate_transits")
+    claims = os.path.join(planets_RESULTS, "validate_transits_claims")
     os.makedirs(folder, exist_ok=True)
+    os.makedirs(claims, exist_ok=True)
     path_of = lambda row: os.path.join(folder, archive_tag(row["name"], int(row["label"].split()[-1])) + ".json")
-    rows = [row for row in planets_transit_rows(stars, names) if row["status"] == "candidate" and not os.path.exists(path_of(row))]
+    weighed_at = lambda row: row.get("orbit_P") or row["P"]
+    # a whole root's candidates as last decided where a TESS root keeps them, the rows of the stars asked for otherwise
+    listed = (planets_transit_kept(stars, read_only=True) if not names and os.path.exists(planets_path("tess.json")) else None)
+    listed = listed if listed is not None else planets_transit_rows(stars, names)
+    rows = [row for row in listed if row["status"] == "candidate" and not row.get("half") and planets_validate_again(path_of(row), weighed_at(row))]
     if part:
         kk, nn = (int(x) for x in part.split("/"))
         rows = rows[kk::nn]
@@ -5263,44 +6458,67 @@ def planets_validate_transits(draws=100000, runs=10, part=None, names=None):
         planets_validate_gpu()
         planets_VALIDATE_GPU.append(True)
     for row in rows:
+        # the weighing ends between candidates as a long search does between stars
+        if planets_search_ends():
+            return
         k, path = int(row["label"].split()[-1]), path_of(row)
-        found = json.load(open(os.path.join(planets_RESULTS, "transitsearch", archive_tag(row["name"]) + ".json")))
-        g = found["signals"][k - 1]
-        if found.get("tic"):
-            # a star the TESS stage searched carries its TIC number and its header's radius and mass
-            tic, rstar, mstar = int(found["tic"]), archive_num(found.get("rstar")), archive_num(found.get("mstar"))
-        else:
-            s = stars[row["name"]]
-            t = Catalogs.query_region(SkyCoord(float(s["RAJ2000"]), float(s["DEJ2000"]), unit="deg"), radius=20 * u.arcsec, catalog="TIC")
-            if not len(t):
+        claim = os.path.join(claims, os.path.basename(path)[:-5])
+        try:
+            os.mkdir(claim)
+        except FileExistsError:
+            if time.time() - os.path.getmtime(claim) < 7200:
                 continue
-            t.sort("Tmag")
-            tic, rstar, mstar = int(t["ID"][0]), archive_num(t["rad"][0]), archive_num(t["mass"][0])
-        r = planets_transit_candidate(row["name"], k, g, tic, rstar)
-        why = planets_transit_physical(g, rstar, mstar)
-        if why:
-            rec = dict(note=why)
-        else:
-            cache = planets_path("validate_cache", archive_tag(r["label"]))
-            try:
-                rec = planets_validate_one(r, draws, runs, cache=cache) or dict(note="no light curve or aperture")
-            except Exception as exc:
-                rec = dict(note="%s: %s" % (type(exc).__name__, str(exc)[:200]))
-            shutil.rmtree(cache, ignore_errors=True)
-        rec.update(label=r["label"], tic=tic, star_radius=rstar, star_mass=mstar)
-        archive_save(path, json.dumps(rec, separators=(",", ":")).encode())
-        print("%s: %s" % (r["label"], "FPP %.4f NFPP %.5f" % (rec["fpp"], rec["nfpp"]) if "fpp" in rec else rec["note"]), flush=True)
-        # the Gaia background TRICERATOPS kept for this candidate removed once it is weighed
-        for p in glob.glob(planets_path("validate_backgrounds", "%d_%d_*.csv" % (tic, os.getpid()))):
-            os.remove(p)
+        try:
+            if not planets_validate_again(path, weighed_at(row)):
+                continue
+            tries = (planets_load_json(path) or {}).get("tries", 1) if os.path.exists(path) else 0
+            found = planets_load_json(os.path.join(planets_RESULTS, "transitsearch", archive_tag(row["name"]) + ".json"))
+            if not found:
+                continue
+            g = found["signals"][k - 1]
+            binary = row["object"] == "star"
+            if binary:
+                g = planets_binary_signal(g, (g["odd_even_sigma"] or 0.0) >= 3.0)
+            elif row.get("alias"):
+                g = planets_transit_alias(g)
+            if found.get("tic"):
+                # a star the TESS stage searched carries its TIC number and its header's radius, mass and temperature
+                tic, rstar, mstar, teff = int(found["tic"]), archive_num(found.get("rstar")), archive_num(found.get("mstar")), archive_num(found.get("teff"))
+            else:
+                s = stars[row["name"]]
+                t = Catalogs.query_region(SkyCoord(float(s["RAJ2000"]), float(s["DEJ2000"]), unit="deg"), radius=20 * u.arcsec, catalog="TIC")
+                if not len(t):
+                    continue
+                t.sort("Tmag")
+                tic, rstar, mstar, teff = int(t["ID"][0]), archive_num(t["rad"][0]), archive_num(t["mass"][0]), archive_num(t["Teff"][0])
+            r = planets_transit_candidate(row["name"], k, g, tic, rstar, *((mstar, teff) if binary else ()))
+            why = "" if binary else planets_transit_physical(g, rstar, mstar)
+            if why:
+                rec = dict(note=why)
+            else:
+                cache = planets_path("validate_cache", archive_tag(r["label"]))
+                try:
+                    rec = planets_validate_one(r, draws, runs, cache=cache) or dict(note="no light curve or aperture", qlp=True)
+                except Exception as exc:
+                    rec = dict(note="%s: %s" % (type(exc).__name__, str(exc)[:200]), tries=tries + 1)
+                shutil.rmtree(cache, ignore_errors=True)
+            rec.update(label=r["label"], tic=tic, star_radius=rstar, star_mass=mstar, star_teff=teff)
+            archive_save(path, json.dumps(rec, separators=(",", ":")).encode())
+            print("%s: %s" % (r["label"], "FPP %.4f NFPP %.5f" % (rec["fpp"], rec["nfpp"]) if "fpp" in rec else rec["note"]), flush=True)
+            # the Gaia background TRICERATOPS kept for this candidate removed once it is weighed
+            for p in glob.glob(planets_path("validate_backgrounds", "%d_%d_*.csv" % (tic, os.getpid()))):
+                os.remove(p)
+        finally:
+            shutil.rmtree(claim, ignore_errors=True)
         if gpu_DEVICE.type == "cuda":
             torch.cuda.empty_cache()
 
 
 def planets_tess(name, periods):
     """A star's TESS light curves (eclipses_fetch) read at PERIODS, to RESULTS/tess/<name>.json. Each sector binned to 30 minutes, divided by its median
-    and clipped at 5 sigma; a Lomb-Scargle periodogram per sector from 0.2 to 13 d and over every sector together from 0.2 to 30 d, each with its highest
-    peak, that peak's semi-amplitude and false-alarm level, and the highest power within 5 per cent of each period, half of it and twice it. Each sector is
+    and clipped at 5 sigma; a Lomb-Scargle periodogram per sector from 0.2 to 13 d and over its sectors together from 0.2 to 30 d, each with its highest
+    peak, that peak's semi-amplitude and false-alarm level, and the highest power within 5 per cent of each period, half of it and twice it, the sectors together being those of PDCSAP flux, which keeps
+    a star's own slow variation, where it has any, QLP's detrended flux having had it taken out and marked flux detrended otherwise. Each sector is
     then flattened by a running median of one day and searched by box least squares within 2 per cent of each period for durations of 1 to 6 hours, the
     trial periods spaced so that an hour-long transit drifts by half its length over the baseline, and the best box's events are measured one by one, each
     against the points within two durations of it, so that a transit shows the same depth at every event and a systematic shows one deep event. Where the
@@ -5315,7 +6533,7 @@ def planets_tess(name, periods):
     if path is None:
         return
     d = np.load(path)
-    T, F, S = [], [], []
+    T, F, S, kept = [], [], [], []
     for sec in np.unique(d["sector"]):
         m = (d["sector"] == sec) & np.isfinite(d["flux"])
         t, f = d["time"][m], d["flux"][m]
@@ -5325,6 +6543,7 @@ def planets_tess(name, periods):
         fb = fb / np.median(fb)
         ok = np.abs(fb - 1) < 5 * 1.4826 * np.median(np.abs(fb - 1))
         T.append(tb[ok]), F.append(fb[ok]), S.append(np.full(ok.sum(), sec))
+        kept.append(bool(d["pdcsap"][m].all()) if "pdcsap" in d.files else True)
 
     def scan(t, f, pmax):
         freq = np.linspace(1.0 / pmax, 1.0 / 0.2, 20000)
@@ -5342,9 +6561,10 @@ def planets_tess(name, periods):
                     semi_amplitude_ppm=round(1e6 * float(np.hypot(*gpu_gls_fit(t, f, None, freq[k])[1:])), 1), fap="%.1e" % float(gpu_baluev(pw[k], fmax, t)), near=near,
                     near_fap=near_fap)
 
-    res = dict(name=name, periods=periods, sectors=[dict(sector=int(s[0]), n=len(t), **scan(t, f, 13.0)) for t, f, s in zip(T, F, S) if len(t) > 200])
+    res = dict(name=name, periods=periods, detrended=True, sectors=[dict(sector=int(s[0]), n=len(t), **scan(t, f, 13.0)) for t, f, s in zip(T, F, S) if len(t) > 200])
     t = np.concatenate(T)
-    res["combined"] = scan(t, np.concatenate(F), 30.0)
+    pdc = [k for k, x in enumerate(kept) if x]
+    res["combined"] = dict(scan(np.concatenate([T[k] for k in pdc]), np.concatenate([F[k] for k in pdc]), 30.0), flux="PDCSAP") if pdc else dict(scan(t, np.concatenate(F), 30.0), flux="detrended")
     flat = [f / gpu_host(gpu_running_median(f, 48)) for f in F]
     fl = np.concatenate(flat)
     dy = np.concatenate([np.full(len(x), 1.4826 * np.median(np.abs(x - 1.0))) for x in flat])
@@ -5442,6 +6662,184 @@ def planets_tess(name, periods):
                                                                                            x["limit_ppm"], x["radius_limit_rearth"]), flush=True)
 
 
+def planets_tess_refresh(part=None):
+    """Each star's TESS reading under RESULTS/tess (planets_tess) that did not read each sector's detrended flux (eclipses_fetch) read again at its periods from light curves fetched for it and
+    removed after it. PART takes the share K/N; the pass ends between stars where a long search would end between them, with exit status 3, and a star an archive does not answer for
+    comes round again at the next pass."""
+    paths = sorted(glob.glob(os.path.join(planets_RESULTS, "tess", "*.json")))
+    if part:
+        k, n = (int(x) for x in part.split("/"))
+        paths = paths[k::n]
+    for path in paths:
+        if planets_search_ends():
+            sys.exit(3)
+        rec = planets_load_json(path)
+        if not rec or rec.get("detrended"):
+            continue
+        try:
+            planets_lightcurve_drop(rec["name"])
+            planets_tess(rec["name"], rec["periods"])
+        except Exception as exc:
+            print("%s: %s: %s" % (rec["name"], type(exc).__name__, str(exc)[:200]), flush=True)
+        planets_lightcurve_drop(rec["name"])
+        if gpu_DEVICE.type == "cuda":
+            torch.cuda.empty_cache()
+    print("share done", flush=True)
+
+
+def planets_orbits_refresh(part=None):
+    """Each star's sampled orbits under RESULTS/orbits that were not sampled by their conjunctions (planets_orbits) sampled again from their medians, a companion's orbit carried into its
+    analysis, the stars of new planets first and their orbits' own runs before the circular and the companion's. PART takes the share K/N; the pass ends between stars where a long search would end
+    between them, with exit status 3."""
+    table = os.path.join(planets_RESULTS, "signals.csv")
+    new = {archive_tag(r["name"]) for r in planets_read(table) if r["status"] == "new"} if os.path.exists(table) else set()
+    paths = sorted(glob.glob(os.path.join(planets_RESULTS, "orbits", "*.json")), key=lambda p: (os.path.basename(p).split(".")[0] not in new, os.path.basename(p).count(".") > 1, p))
+    if part:
+        k, n = (int(x) for x in part.split("/"))
+        paths = paths[k::n]
+    for path in paths:
+        if planets_search_ends():
+            sys.exit(3)
+        rec = planets_load_json(path)
+        if not rec or not rec.get("planets") or rec.get("phase") == "conjunction":
+            continue
+        label = "companion" if ".companion" in os.path.basename(path) else None
+        extra = planets_path("ledger", "%s.orbits.newer.npz" % archive_tag(rec["name"]))
+        try:
+            planets_orbits(rec["name"], [p["P"][0] for p in rec["planets"]], steps=rec.get("steps", 30000), circular=bool(rec.get("circular")), label=label,
+                           extra=extra if "newer" in rec.get("series", []) and os.path.exists(extra) else None)
+            kept = os.path.join(planets_RESULTS, "companion", archive_tag(rec["name"]) + ".json")
+            c = planets_load_json(kept) if label else None
+            if c and c.get("orbit"):
+                o = planets_load_json(path)["planets"][0]
+                c["orbit"] = {x: o[x] for x in ("P", "K", "e", "msini_mearth")}
+                archive_save(kept, json.dumps(c, separators=(",", ":")).encode())
+        except Exception as exc:
+            print("%s: %s: %s" % (rec["name"], type(exc).__name__, str(exc)[:200]), flush=True)
+        if gpu_DEVICE.type == "cuda":
+            torch.cuda.empty_cache()
+    print("share done", flush=True)
+
+
+# the spectrographs whose archived spectra test an orbit another's velocities gave, measured line by line, and the dates (MJD) on which their zero points moved
+planets_SECOND = {"ESPRESSO": (58661.5,), "HARPS": (planets_UPGRADE,)}
+
+
+def planets_second_test(t, v, e, groups, orbits):
+    """Velocities V at times T with errors E, an offset for each of GROUPS, held against the orbits ORBITS, each its posterior draws (P, tp, e, omega, K): a sinusoid at each orbit's median period
+    with its amplitude and phase free, all fitted together with a jitter, and the same sinusoids fitted to each draw's curve at those times, which gives the amplitude and phase the first velocities
+    predict and how far the draws spread them. Each orbit's amplitude over the prediction's median (scale), its error, the phase's distance from the prediction in sigma, the draws' spread and the
+    fit's error together, and its verdict: failed where the scale falls short of one by more than the larger of 3 sigma and 30 per cent, or stands at 3 sigma at a phase 3 sigma off the prediction;
+    held where it stands at 3 sigma otherwise, an amplitude above the prediction refuting nothing; open otherwise. Returns those, the jitter and the scatter the fit leaves."""
+    Z = [(groups == g).astype(float) for g in np.unique(groups)]
+    periods = [float(np.median(d[:, 0])) for d in orbits]
+    X = np.column_stack(Z + [f(2.0 * np.pi * t / Q) for Q in periods for f in (np.cos, np.sin)])
+    jit = 0.0
+    for _ in range(8):
+        s = np.sqrt(e ** 2 + jit ** 2)
+        A = X / s[:, None]
+        c = np.linalg.lstsq(A, v / s, rcond=None)[0]
+        r = v - X @ c
+        jit = math.sqrt(max(np.sum(r ** 2) / max(len(t) - X.shape[1], 1) - np.mean(e ** 2), 0.0))
+    s = np.sqrt(e ** 2 + jit ** 2)
+    A = X / s[:, None]
+    c, cov, solve = np.linalg.lstsq(A, v / s, rcond=None)[0], np.linalg.pinv(A.T @ A), np.linalg.pinv(A)
+    out = []
+    wrap = lambda x: (x + np.pi) % (2.0 * np.pi) - np.pi
+    for i, d in enumerate(orbits):
+        k = len(Z) + 2 * i
+        pred = (solve @ (planets_kepler_draws(t, d) / s[None, :]).T)[k:k + 2].T
+        centre = math.atan2(float(np.mean(pred[:, 1] / np.hypot(*pred.T))), float(np.mean(pred[:, 0] / np.hypot(*pred.T))))
+        spread = math.sqrt(float(np.mean(wrap(np.arctan2(pred[:, 1], pred[:, 0]) - centre) ** 2)))
+        size, at = math.hypot(c[k], c[k + 1]), math.atan2(c[k + 1], c[k])
+        radial, tangent = np.array([math.cos(at), math.sin(at)]), np.array([-math.sin(at), math.cos(at)])
+        block = cov[k:k + 2, k:k + 2]
+        want = float(np.median(np.hypot(*pred.T)))
+        scale, err = size / want, math.sqrt(float(radial @ block @ radial)) / want
+        off = abs(float(wrap(at - centre))) / math.hypot(spread, math.sqrt(float(tangent @ block @ tangent)) / size)
+        seen = scale >= 3.0 * err
+        out.append(dict(scale=round(scale, 3), scale_err=round(err, 3), phase_sigma=round(off, 2),
+                        verdict="failed" if scale < 1.0 - max(3.0 * err, 0.3) or seen and off > 3.0 else "held" if seen else "open"))
+    return out, round(jit, 2), round(float(np.std(v - X @ c)), 2)
+
+
+def planets_second(part=None, least=6):
+    """Each new planet's star's orbits (planets_orbits) tested in the archived spectra of a spectrograph its root's velocities did not come from (planets_SECOND), to RESULTS/second/<star>.json:
+    the star's public spectra above a signal-to-noise ratio of 20 on LEAST nights or more, more than the orbits and the zero points leave no room below, measured line by line (planets_lbl),
+    one a night, the nights another series of that instrument gave the orbits left out, and every orbit of the star held against them (planets_second_test). A star's test is made again once its
+    orbits are sampled again, and a month on for spectra released since. PART takes the share K/N; the pass ends between stars where a long search would end between them, with exit status 3."""
+    path = os.path.join(planets_RESULTS, "signals.csv")
+    if not os.path.exists(path):
+        return
+    stars = {r["Name"]: r for r in planets_read(planets_path("bank_stars.csv"))}
+    names = sorted({r["name"] for r in planets_read(path) if r["status"] == "new" and r["kind"] in ("found", "eccentric") and r["name"] in stars})
+    if part:
+        k, n = (int(x) for x in part.split("/"))
+        names = names[k::n]
+    own = json.load(open(planets_path("measure.json")))["inst"] if os.path.exists(planets_path("measure.json")) else "HARPS"
+    folder = os.path.join(planets_RESULTS, "second")
+    os.makedirs(folder, exist_ok=True)
+    for name in names:
+        if planets_search_ends():
+            sys.exit(3)
+        tag, kept = archive_tag(name), os.path.join(folder, archive_tag(name) + ".json")
+        orbit_path = os.path.join(planets_RESULTS, "orbits", tag + ".json")
+        o = planets_load_json(orbit_path)
+        if not o or o.get("phase") != "conjunction" or "draws" not in o:
+            continue
+        rec = planets_load_json(kept)
+        sampled = os.path.getmtime(orbit_path)
+        if rec and rec.get("orbits_sampled") == sampled and time.time() - os.path.getmtime(kept) < 30 * 86400.0:
+            continue
+        s = stars[name]
+        draws = planets_draws_load(orbit_path, o)["draws"]
+        tests = []
+        try:
+            for inst, eras in planets_SECOND.items():
+                if inst == own:
+                    continue
+                listing = archive_eso_listing(float(s["RAJ2000"]), float(s["DEJ2000"]), inst, 20.0)
+                # the nights another series of the instrument gave the orbits
+                used = {math.floor(x[0] + 0.3) for k_, xs in planets_dace_series({name}).get(name, {}).items() if planets_family(k_[0]) == inst and any(inst in lab for lab in o["series"]) for x in xs}
+                listing = [x for x in listing if math.floor(float(x["t_min"]) + 0.3) not in used]
+                nights = len({math.floor(float(x["t_min"]) + 0.3) for x in listing})
+                line = dict(inst=inst, nights=nights)
+                if nights >= max(least, 2 * len(draws) + len(eras) + 4):
+                    second = "%s_%s" % (tag, inst)
+                    lp = planets_path("lbl", second + ".lbl.npz")
+                    if not os.path.exists(lp) or float(np.load(lp)["mjd"].max()) < max(float(x["t_min"]) for x in listing) - 0.5:
+                        planets_lbl(second, streams=4, ra=float(s["RAJ2000"]), dec=float(s["DEJ2000"]), least=least, listing=listing, inst=inst)
+                    d = np.load(lp)
+                    m = np.isfinite(d["rv"]) & np.isfinite(d["rv_err"]) & ~(d["cal_age"] > 30.0) & ~np.isin(np.floor(d["mjd"] + 0.3), sorted(used))
+                    t, v, e = planets_by_night(d["mjd"][m], d["rv"][m], d["rv_err"][m])
+                    if len(t) >= 2 * len(draws) + len(eras) + 4:
+                        got, jit, rms = planets_second_test(t, v, e, np.searchsorted(eras, t), list(draws))
+                        line.update(nights=len(t), first=round(float(t.min()), 1), last=round(float(t.max()), 1), jitter=jit, rms=rms, planets=[dict(g, P=p["P"][0]) for g, p in zip(got, o["planets"])])
+                tests.append(line)
+                print("%s %s: %s" % (name, inst, "; ".join("P %.4g scale %.2f +- %.2f, phase off by %.1f sigma, %s" % (x["P"], x["scale"], x["scale_err"], x["phase_sigma"], x["verdict"]) for x in line.get("planets", []))
+                                     or "%d nights" % nights), flush=True)
+            archive_save(kept, json.dumps(dict(name=name, orbits_sampled=sampled, tests=tests), separators=(",", ":")).encode())
+        except (SystemExit, Exception) as exc:
+            print("%s: %s: %s" % (name, type(exc).__name__, str(exc)[:200]), flush=True)
+    print("share done", flush=True)
+
+
+def planets_second_decide(sig):
+    """The new planets of SIG given what their stars' tests in another spectrograph's spectra (planets_second) hold of them, within 5 per cent in period, their columns second_instrument,
+    second_nights, second_scale, second_scale_err, second_phase_sigma and second_test, the instrument's that measures it best where two do; a planet that fails is rejected."""
+    for r in sig:
+        if r["status"] != "new" or r["kind"] not in ("found", "eccentric"):
+            continue
+        rec = planets_load_json(os.path.join(planets_RESULTS, "second", archive_tag(r["name"]) + ".json")) or {}
+        P = planets_num(r.get("orbit_P") or r["P"])
+        hits = [dict(p, inst=t["inst"], nights=t["nights"]) for t in rec.get("tests", []) for p in t.get("planets", []) if abs(p["P"] / P - 1.0) < 0.05]
+        if hits:
+            x = next((h for h in hits if h["verdict"] == "failed"), min(hits, key=lambda h: h["scale_err"]))
+            r.update(second_instrument=x["inst"], second_nights=x["nights"], second_scale=x["scale"], second_scale_err=x["scale_err"], second_phase_sigma=x["phase_sigma"], second_test=x["verdict"])
+            if x["verdict"] == "failed":
+                r.update(status="rejected", reason="second instrument")
+
+
 def planets_call(f, timeout, *args, **kw):
     """F's value, or None when it raises or runs past TIMEOUT seconds (it is then left running in a daemon thread)."""
     out = {}
@@ -5457,6 +6855,33 @@ def planets_call(f, timeout, *args, **kw):
     return out.get("v")
 
 
+def planets_transit_rv_fit(t, v, e, g, P, Tc, mstar):
+    """Nightly velocities T (MJD), V and E (m/s) of the series G fitted with an offset per series, a linear trend over 300 days of span or more, a jitter
+    and a circular orbit at the period P: once with the transit's phase held at Tc (MJD), the star's velocity -K sin 2 pi (t - Tc) / P with K free and
+    signed, and once with the phase free. Returns the nights and span, the held fit's K, its error and signal-to-noise, the free fit's K and its phase
+    from the transit's with their errors, the jitter, and the minimum mass (Earth's) the held K gives about a star of MSTAR solar masses."""
+    span = float(t.max() - t.min())
+    tt = (t - t.mean()) / 365.25
+    base = [(g == gi).astype(float) for gi in np.unique(g)] + ([tt] if span >= 300 else [])
+    held = -np.sin(2 * np.pi * (t - Tc) / P)
+    jit = 0.0
+    for _ in range(4):
+        s = np.hypot(e, jit)
+        X = np.column_stack(base + [held])
+        r_ = v - X @ np.linalg.lstsq(X / s[:, None], v / s, rcond=None)[0]
+        jit = math.sqrt(max(np.mean(r_ ** 2) - np.mean(e ** 2), 0.0))
+    s = np.hypot(e, jit)
+    A = np.column_stack(base + [held]) / s[:, None]
+    c = np.linalg.lstsq(A, v / s, rcond=None)[0]
+    K, eK = float(c[-1]), float(math.sqrt(np.linalg.pinv(A.T @ A)[-1, -1]))
+    Af = np.column_stack(base + [held, np.cos(2 * np.pi * (t - Tc) / P)]) / s[:, None]
+    cf_ = np.linalg.lstsq(Af, v / s, rcond=None)[0]
+    Kf, eKf, ph, eph = planets_amplitude(cf_, np.linalg.pinv(Af.T @ Af))
+    return dict(nights=len(t), span_d=round(span), K=round(K, 2), eK=round(eK, 2), snr=round(K / eK, 1) if eK > 0 else "", K_free=round(Kf, 2),
+                eK_free=round(eKf, 2), phase_offset_deg=round((ph + 180.0) % 360.0 - 180.0, 0), ephase_deg=round(eph, 1), jitter=round(jit, 2),
+                msini_mearth=round(planets_msini(P, abs(K), 0.0, mstar) * 317.83, 1))
+
+
 def planets_tois(tmag=12.0, threads=3, timeout=60.0, fit_only=False, source="dace", streams=4):
     """TESS's planet candidates weighed with archived velocities, to ROOT/tois.csv. ExoFOP's TOI table is read, and every TOI the TFOPWG lists as a planet
     candidate (PC or APC) brighter than TMAG in the TESS band is looked up in DACE within 10 arcsec, each call given TIMEOUT seconds; the public velocities
@@ -5589,35 +7014,18 @@ def planets_tois(tmag=12.0, threads=3, timeout=60.0, fit_only=False, source="dac
         if not T or sum(len(z) for z in T) < 6 or not (P > 0 and math.isfinite(Tc)):
             continue
         t, v, e, g = (np.concatenate(z) for z in (T, V, E, G))
-        span = float(t.max() - t.min())
-        tt = (t - t.mean()) / 365.25
-        base = [(g == gi).astype(float) for gi in np.unique(g)] + ([tt] if span >= 300 else [])
-        held = -np.sin(2 * np.pi * (t - Tc) / P)
-        jit = 0.0
-        for _ in range(4):
-            s = np.hypot(e, jit)
-            X = np.column_stack(base + [held])
-            r_ = v - X @ np.linalg.lstsq(X / s[:, None], v / s, rcond=None)[0]
-            jit = math.sqrt(max(np.mean(r_ ** 2) - np.mean(e ** 2), 0.0))
-        s = np.hypot(e, jit)
-        A = np.column_stack(base + [held]) / s[:, None]
-        c = np.linalg.lstsq(A, v / s, rcond=None)[0]
-        K, eK = float(c[-1]), float(math.sqrt(np.linalg.pinv(A.T @ A)[-1, -1]))
-        Af = np.column_stack(base + [held, np.cos(2 * np.pi * (t - Tc) / P)]) / s[:, None]
-        cf_ = np.linalg.lstsq(Af, v / s, rcond=None)[0]
-        Kf, eKf, ph, eph = planets_amplitude(cf_, np.linalg.pinv(Af.T @ Af))
         eP, eTc = planets_num(r["Period (days) err"]), planets_num(r["Epoch (BJD) err"])
         n_cyc = abs(t.mean() - Tc) / P
         phase_err = math.hypot(eTc if math.isfinite(eTc) else 0.0, n_cyc * (eP if math.isfinite(eP) else 0.0)) / P
         mstar = planets_num(r["Stellar Mass (M_Sun)"])
         mstar = mstar if mstar > 0 else 1.0
+        fit = planets_transit_rv_fit(t, v, e, g, P, Tc, mstar)
         host = host_of("TOI-" + toi_id.split(".")[0], xs[0]["dace_name"], float("nan"), float("nan")) if host_of else None
         res.append(dict(toi=toi_id, tic=r["TIC ID"], dace_name=xs[0]["dace_name"], ra=round(Angle(r["RA"], unit="hourangle").deg, 6),
                         dec=round(Angle(r["Dec"], unit="deg").deg, 6), disposition=r["TFOPWG Disposition"], tmag=r["TESS Mag"], period=P,
-                        radius_rearth=r["Planet Radius (R_Earth)"], k_predicted=r["Predicted RV Semi-amplitude (m/s)"], nights=len(t), span_d=round(span),
-                        series="; ".join(" ".join(z for z in k if z) for k in keep), phase_err=round(phase_err, 3), K=round(K, 2), eK=round(eK, 2),
-                        snr=round(K / eK, 1) if eK > 0 else "", K_free=round(Kf, 2), eK_free=round(eKf, 2), phase_offset_deg=round((ph + 180.0) % 360.0 - 180.0, 0),
-                        ephase_deg=round(eph, 1), jitter=round(jit, 2), msini_mearth=round(planets_msini(P, abs(K), 0.0, mstar) * 317.83, 1), mstar=mstar,
+                        radius_rearth=r["Planet Radius (R_Earth)"], k_predicted=r["Predicted RV Semi-amplitude (m/s)"], nights=fit["nights"], span_d=fit["span_d"],
+                        series="; ".join(" ".join(z for z in k if z) for k in keep), phase_err=round(phase_err, 3),
+                        **{k: fit[k] for k in ("K", "eK", "snr", "K_free", "eK_free", "phase_offset_deg", "ephase_deg", "jitter", "msini_mearth")}, mstar=mstar,
                         archive_host=host or ""))
     res.sort(key=lambda x: -(x["snr"] or 0))
     planets_write(planets_path(dict(dace="tois.csv", eso="tois_eso.csv", rvcat="tois_rvcat.csv")[source]), res, list(res[0].keys()) if res else ["toi"])
@@ -6015,10 +7423,14 @@ def planets_weigh(name, steps=8000, pmin=None, pmax=36525.0, m1=None, extra=None
     anomaly (planets_anomaly); and one Keplerian orbit of the star about the barycentre, the companion
     dark, fitted to everything at once. The bank's velocities, averaged per night, are read with a zero point on each side of the fibre upgrade and a
     jitter. With an acceleration solution, the proper motion and acceleration at 2016.0 are those of a quadratic fitted to the photocentre over Gaia's
-    window; without one, Gaia's proper motion is the photocentre's mean motion over that window. Either is set against the long-term motion, the
+    window; without one, Gaia's proper motion is the photocentre's mean motion over that window; each window's solution, Hipparcos's as Gaia's, fits
+    the parallax at the same time, its factors at the star's place (archive_parallax_factors), so that an orbit near a year, which the parallax partly
+    takes up, moves the proper motion only by what the parallax leaves. Either is set against the long-term motion, the
     photocentre's displacement from its Hipparcos position (a line fitted over Hipparcos's window) to its Gaia position over 24.75 years, as the observed
-    anomaly is set against the long-term proper motion. A velocity-trend solution adds the derivatives of a quadratic fitted to the model's velocities across
-    Gaia's window. Where Gaia's spectrometer saw the velocity vary (a chi-square p-value below 0.01), the range of its epoch velocities after outliers,
+    anomaly is set against the long-term proper motion. The wobble the photocentre's orbit leaves about Gaia's five-parameter solution over its window,
+    the root mean square along one axis, is held against Gaia's astrometric excess noise, or 0.3 mas where that is not significant: within a quarter in
+    log above it, more than which the orbit cannot leave, and within 0.7 below it, to which other causes may add. A velocity-trend solution adds the
+    derivatives of a quadratic fitted to the model's velocities across Gaia's window. Where Gaia's spectrometer saw the velocity vary (a chi-square p-value below 0.01), the range of its epoch velocities after outliers,
     less 2.5 km/s for their noise, bounds the model's range of velocity over Gaia's window from below, the shortfall counted at 1 km/s. The parameters
     are log period (PMIN to PMAX days, by default half the series' span to 100 years), the time of periastron, sqrt(e) cos
     omega, sqrt(e) sin omega, the log of the companion's mass as a fraction of the primary's (from 0.3 Jupiter masses up to the primary's own mass, which a
@@ -6047,6 +7459,10 @@ def planets_weigh(name, steps=8000, pmin=None, pmax=36525.0, m1=None, extra=None
     # 2.5 km/s for their noise, is a lower bound on the orbit's range of velocity over Gaia's window.
     rv_amp, rv_pval = archive_num(gs.get("rv_amplitude_robust")), archive_num(gs.get("rv_chisq_pvalue"))
     rv_floor = rv_amp - 2.5 if rv_amp is not None and rv_pval is not None and rv_pval < 0.01 and rv_amp > 2.5 else None
+    # Gaia DR3's astrometric excess noise, the wobble its five-parameter solution left about the photocentre; where it is not significant, the
+    # 0.3 mas that calibration leaves the brightest stars stands for it
+    eps, eps_sig = archive_num(gs.get("astrometric_excess_noise")), archive_num(gs.get("astrometric_excess_noise_sig"))
+    eps_obs = max(eps if eps is not None and eps_sig is not None and eps_sig > 2.0 else 0.0, 0.3)
     sol = archive_gaia_solutions([sid])[str(sid)]
     acc, trend = sol["acceleration"], sol["trend"]
     hip = archive_hipparcos_of(sid) or planets_hip_near(gs)
@@ -6072,9 +7488,16 @@ def planets_weigh(name, steps=8000, pmin=None, pmax=36525.0, m1=None, extra=None
     tg = np.linspace(56863.0, 57901.0, 40)
     th = np.linspace(47837.2, 49064.45, 40)
     dt_hg = (tref - hip_epoch) / 365.25
-    Pg = np.linalg.pinv(np.column_stack([np.ones_like(tg), (tg - tref) / 365.25, 0.5 * ((tg - tref) / 365.25) ** 2]))
-    Pg1 = np.linalg.pinv(np.column_stack([np.ones_like(tg), (tg - tref) / 365.25]))
-    Ph = np.linalg.pinv(np.column_stack([np.ones_like(th), (th - hip_epoch) / 365.25]))
+    ra_s, dec_s = num(gs["ra"]), num(gs["dec"])
+
+    def design(tt, t0, quad):
+        # an astrometric solution over the epochs TT about T0, the right ascensions' rows above the declinations': the place, the proper motion, with
+        # QUAD the acceleration, and the parallax, fitted at once, so that the part of an orbit near a year that the parallax takes up is not motion
+        dt, (fa, fd) = (tt - t0) / 365.25, archive_parallax_factors(ra_s, dec_s, tt)
+        o, z = np.ones_like(tt), np.zeros_like(tt)
+        cols = [(o, z), (z, o), (dt, z), (z, dt)] + ([(0.5 * dt ** 2, z), (z, 0.5 * dt ** 2)] if quad else []) + [(fa, fd)]
+        return np.column_stack([np.concatenate(c) for c in cols])
+    Pg, Pg1, Ph = (np.linalg.pinv(design(tt, t0, quad)) for tt, t0, quad in ((tg, tref, True), (tg, tref, False), (th, hip_epoch, False)))
     pm_hg = np.array([num(k["pmRAH2EG3b"]), num(k["pmDEH2EG3b"])])
     if acc and acc[0].get("accel_ra"):
         A = acc[0]
@@ -6106,6 +7529,7 @@ def planets_weigh(name, steps=8000, pmin=None, pmax=36525.0, m1=None, extra=None
     Tn, TG, TH, TR = gpu_dev(t), gpu_dev(tg), gpu_dev(th), gpu_dev(tr_t)
     TS = gpu_dev(np.linspace(56863.0, 57901.0, 400))
     PG, PG1, PH, PR = gpu_dev(Pg), gpu_dev(Pg1), gpu_dev(Ph), gpu_dev(Pr)
+    AG1 = gpu_dev(design(tg, tref, False))
     Vn, E2, GR = gpu_dev(v), gpu_dev(err ** 2), torch.as_tensor(grp, dtype=torch.long, device=gpu_DEVICE)
     OH = torch.nn.functional.one_hot(GR, ngr).to(gpu_F64)
     OD, ED, LOt, HIt = gpu_dev(obs_dmu), gpu_dev(err_dmu), gpu_dev(LO), gpu_dev(HI)
@@ -6144,16 +7568,24 @@ def planets_weigh(name, steps=8000, pmin=None, pmax=36525.0, m1=None, extra=None
             return Ac * X + F * Y, B * X + G * Y
         dg, ag = sky(TG)
         dh, ah = sky(TH)
-        ch_d, ch_a = dh @ PH.T, ah @ PH.T
-        cg_d, cg_a = (dg @ PG.T, ag @ PG.T) if OA is not None else (dg @ PG1.T, ag @ PG1.T)
-        dmu = torch.stack([cg_a[:, 1] - (cg_a[:, 0] - ch_a[:, 0]) / dt_hg, cg_d[:, 1] - (cg_d[:, 0] - ch_d[:, 0]) / dt_hg], 1)
+        # each window's solution: the places (0, 1), the proper motions (2, 3) and, at Gaia's with an acceleration solution, the accelerations (4, 5)
+        yg = torch.cat([ag, dg], 1)
+        ch = torch.cat([ah, dh], 1) @ PH.T
+        cg = yg @ (PG if OA is not None else PG1).T
+        dmu = torch.stack([cg[:, 2] - (cg[:, 0] - ch[:, 0]) / dt_hg, cg[:, 3] - (cg[:, 1] - ch[:, 1]) / dt_hg], 1)
+        # the wobble Gaia's five-parameter solution leaves, the root mean square along one axis of the photocentre about it over Gaia's window
+        wob = torch.sqrt(((yg - (yg @ PG1.T) @ AG1.T) ** 2).mean(1) + 1e-12)
         s2 = E2[None, :] + torch.exp(2 * lj)[:, None]
         r = Vn[None, :] - rv(Tn)
         if zero:
             gam = torch.minimum(torch.maximum(((r / s2) @ OH) / ((1.0 / s2) @ OH), LOt[7:7 + ngr]), HIt[7:7 + ngr])
         lp = -0.5 * (((r - gam[:, GR]) ** 2 / s2 + torch.log(s2)).sum(1)) - 0.5 * (((dmu - OD) / ED) ** 2).sum(1)
+        # the wobble against Gaia's excess noise, in log: within a quarter above it, more than which the orbit cannot leave, and within 0.7 below it,
+        # to which other causes may add
+        dl = torch.log(wob / eps_obs)
+        lp = lp - 0.5 * (dl / torch.where(dl > 0, torch.full_like(dl, 0.25), torch.full_like(dl, 0.7))) ** 2
         if OA is not None:
-            lp = lp - 0.5 * (((torch.stack([cg_a[:, 2], cg_d[:, 2]], 1) - OA) / EA) ** 2).sum(1)
+            lp = lp - 0.5 * (((cg[:, 4:6] - OA) / EA) ** 2).sum(1)
         if TV is not None:
             d = (rv(TR) @ PR.T)[:, 1:1 + tr[2]] - TV
             lp = lp - 0.5 * torch.einsum("bi,ij,bj->b", d, TW, d)
@@ -6165,7 +7597,7 @@ def planets_weigh(name, steps=8000, pmin=None, pmax=36525.0, m1=None, extra=None
         if not host:
             return lp
         der = dict(P=P[:, 0], e=ecc[:, 0], m2=m2[:, 0], m1=mm1[:, 0], K1=K1[:, 0], incl=torch.rad2deg(torch.acos(torch.clamp(ci[:, 0], -1.0, 1.0))),
-                   a_au=(mt ** (1.0 / 3.0) * Pyr ** (2.0 / 3.0))[:, 0], zero=gam)
+                   a_au=(mt ** (1.0 / 3.0) * Pyr ** (2.0 / 3.0))[:, 0], wobble=wob, zero=gam)
         return gpu_host(lp), {key: gpu_host(x) for key, x in der.items()}
 
     logp = lambda pn: model(pn)[0]
@@ -6220,18 +7652,19 @@ def planets_weigh(name, steps=8000, pmin=None, pmax=36525.0, m1=None, extra=None
     res = dict(name=name, nights=int(len(t)), span_d=round(span), first_mjd=round(float(t.min()), 3), last_mjd=round(float(t.max()), 3), source_id=sid, hip=hip, anomaly_source=k.get("source", "Kervella et al. (2022)"),
                pma_snr=num(k.get("snrPMaH2EG3b")), ruwe=num(gs.get("ruwe")), acceleration=acc[0]["nss_solution_type"] if acc else None,
                velocity_trend=trend[0]["nss_solution_type"] if trend else None, gaia_rv_amplitude_kms=rv_amp, gaia_rv_floor_kms=rv_floor,
-               m1_prior=[m1, m1_err], m1_source=m1_source, log_posterior=round(-float(best.fun), 2), period_allowed=allowed,
-               acceptance=float(np.mean(accept)), P_d=q("P"), e=q("e"), K1_ms=q("K1", 1000.0), m2_mjup=q("m2", 1047.57), incl_deg=q("incl"),
-               a_au=q("a_au"), p_below_13mjup=float(np.mean(m2s < 13.0)), p_below_80mjup=float(np.mean(m2s < 80.0)))
+               excess_noise_mas=eps, excess_noise_sig=eps_sig, m1_prior=[m1, m1_err], m1_source=m1_source, log_posterior=round(-float(best.fun), 2),
+               period_allowed=allowed, acceptance=float(np.mean(accept)), P_d=q("P"), e=q("e"), K1_ms=q("K1", 1000.0), m2_mjup=q("m2", 1047.57),
+               incl_deg=q("incl"), a_au=q("a_au"), wobble_mas=q("wobble"), p_below_13mjup=float(np.mean(m2s < 13.0)), p_below_80mjup=float(np.mean(m2s < 80.0)))
     os.makedirs(os.path.join(planets_RESULTS, "weigh"), exist_ok=True)
     path = os.path.join(planets_RESULTS, "weigh", archive_tag(name) + ".json")
     planets_draws_save(path, res, draws=draws, profile=np.column_stack([np.exp(edges[:-1]), np.exp(edges[1:]), np.exp(xs[:, 0]), prof]))
     json.dump(res, open(path, "w"), separators=(",", ":"))
-    print("%s: %d nights over %d d, anomaly %.1f sigma (%s)%s%s | P %.0f (%.0f-%.0f) d, e %.2f, i %.0f deg, m2 %.1f (%.1f-%.1f) MJup, a %.1f au; "
-          "P(m2 < 13 MJup) %.2f, P(m2 < 80) %.2f" % (name, len(t), span, res["pma_snr"], res["anomaly_source"], ", " + res["acceleration"] if res["acceleration"] else "",
-                                                     ", " + res["velocity_trend"] if res["velocity_trend"] else "", res["P_d"][0], res["P_d"][1], res["P_d"][2], res["e"][0],
-                                                     res["incl_deg"][0], res["m2_mjup"][0], res["m2_mjup"][1], res["m2_mjup"][2], res["a_au"][0], res["p_below_13mjup"],
-                                                     res["p_below_80mjup"]), flush=True)
+    print("%s: %d nights over %d d, anomaly %.1f sigma (%s)%s%s | P %.0f (%.0f-%.0f) d, e %.2f, i %.0f deg, m2 %.1f (%.1f-%.1f) MJup, a %.1f au, wobble "
+          "%.2f mas against Gaia's %s; P(m2 < 13 MJup) %.2f, P(m2 < 80) %.2f" % (
+              name, len(t), span, res["pma_snr"], res["anomaly_source"], ", " + res["acceleration"] if res["acceleration"] else "",
+              ", " + res["velocity_trend"] if res["velocity_trend"] else "", res["P_d"][0], res["P_d"][1], res["P_d"][2], res["e"][0], res["incl_deg"][0],
+              res["m2_mjup"][0], res["m2_mjup"][1], res["m2_mjup"][2], res["a_au"][0], res["wobble_mas"][0], eps, res["p_below_13mjup"], res["p_below_80mjup"]),
+          flush=True)
     print("  periods the data allow: %s" % ", ".join("%.0f-%.0f d" % tuple(a) for a in allowed), flush=True)
 
 
@@ -6851,9 +8284,11 @@ def planets_tic_cone(tic, radius=None, catalogs=None):
 
 
 def planets_tess_key(tic, sector, kind, sectors):
-    """A light curve's place in the bucket: SPOC's (KIND 0) from its sector's file-name stem, TESS-SPOC's (KIND 1) from its TIC number and sector
-    alone."""
+    """A light curve's place in the bucket: SPOC's (KIND 0) from its sector's file-name stem, TESS-SPOC's (KIND 1) and QLP's (KIND 2) from its TIC
+    number and sector alone."""
     t = "%016d" % tic
+    if kind == 2:
+        return "mast/hlsp/qlp/s%04d/%s/%s/%s/%s/hlsp_qlp_tess_ffi_s%04d-%s_tess_v01_llc.fits" % (sector, t[0:4], t[4:8], t[8:12], t[12:16], sector, t)
     if kind == 1:
         return "mast/hlsp/tess-spoc/s%04d/target/%s/%s/%s/%s/hlsp_tess-spoc_tess_phot_%s-s%04d_tess_v1_lc.fits" % (sector, t[0:4], t[4:8], t[8:12], t[12:16], t,
                                                                                                             sector)
@@ -6861,13 +8296,38 @@ def planets_tess_key(tic, sector, kind, sectors):
     return "tess/public/tid/s%04d/%s/%s/%s/%s/tess%s-s%04d-%s-%s-s_lc.fits" % (sector, t[0:4], t[4:8], t[8:12], t[12:16], date, sector, t, scid)
 
 
+def planets_qlp_sectors(tic):
+    """The sectors of which MAST's bucket holds a QLP light curve of the TIC star TIC (planets_tess_key, kind 2): every sector of the index asked once
+    with a HEAD request, the answer kept in ROOT/tess/qlp/<tic>.json; an error, and nothing kept, where the bucket answers otherwise than with the file
+    or its absence."""
+    path = planets_path("tess", "qlp", "%d.json" % tic)
+    if os.path.exists(path):
+        return json.load(open(path))
+    sectors = planets_tess_index()[3]
+
+    def held(s):
+        try:
+            urllib.request.urlopen(urllib.request.Request(planets_TESS_BUCKET + planets_tess_key(tic, s, 2, sectors), method="HEAD", headers=dict(archive_UA)),
+                                   timeout=60)
+            return s
+        except urllib.error.HTTPError as exc:
+            if exc.code in (403, 404):
+                return None
+            raise
+    got = sorted(s for s in archive_pmap(held, sorted(sectors), 8) if s)
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    archive_save(path, json.dumps(got).encode())
+    return got
+
+
 def planets_validate_fetch(r, cache, stars=False, most=8):
     """A TESS candidate's light curves, one a sector, from the sectors in which a transit falls on ExoFOP's ephemeris, MOST sectors at most spread evenly
     over them, fetched from MAST's bucket on AWS by the index of every light curve (planets_tess_index) into the folder CACHE: SPOC's at two minutes
     where a transit falls in one of them, else TESS-SPOC's from the full-frame images at the cadence most of their transit sectors share (the shorter on
     a tie), and SPOC's of every sector where no transit falls in either. Their files by sector, or None where there are none or the candidate lacks a
     period, depth or duration; with STARS, a pair of the files and TRICERATOPS's target for those sectors, its stars from the TIC and its background
-    from Gaia DR3."""
+    from Gaia DR3. Where neither SPOC's nor TESS-SPOC's light curves cover a transit, QLP's are taken from the sectors in which one falls
+    (planets_qlp_sectors)."""
     from astropy.io import fits
     warnings.filterwarnings("ignore")
     tic = int(r["TIC ID"])
@@ -6883,7 +8343,14 @@ def planets_validate_fetch(r, cache, stars=False, most=8):
         lo, hi = np.array([sectors[s]["t0"] for s in ss]), np.array([sectors[s]["t1"] for s in ss])
         return [s for s, k in zip(ss, np.ceil((lo - half - t0) / P) * P + t0 <= hi + half) if k]
     spoc, ffi = transits(0), transits(1)
-    if spoc or not ffi:
+    if not spoc and not ffi:
+        held[2] = planets_qlp_sectors(tic)
+        qlp = transits(2)
+    else:
+        qlp = []
+    if qlp:
+        kind, keep = 2, qlp
+    elif spoc or not ffi:
         kind, keep = 0, spoc or held[0]
     else:
         cads = [1800 if s <= 26 else 600 if s <= 55 else 200 for s in ffi]
@@ -7015,22 +8482,344 @@ def planets_contrast_curves(tic, folder):
     return out
 
 
+def planets_lightcurve_flux(d):
+    """A SPOC, TESS-SPOC or QLP light curve's table D read: the times (BTJD) and the flux of quality zero, PDCSAP_FLUX or QLP's detrended DET_FLUX,
+    in its first releases KSPSAP_FLUX, divided by its median; None where fewer than 100 points remain."""
+    col = next((c for c in ("DET_FLUX", "KSPSAP_FLUX") if c in d.columns.names), "PDCSAP_FLUX")
+    t, f, q = np.asarray(d["TIME"], float), np.asarray(d[col], float), np.asarray(d["QUALITY"])
+    ok = np.isfinite(t) & np.isfinite(f) & (q == 0)
+    if ok.sum() < 100:
+        return None
+    return t[ok], f[ok] / np.median(f[ok])
+
+
+def planets_transit_shape(sectors, P, t0, dur):
+    """Whether a signal's folded light is a transit's box or the star's own smooth variation at its period. SECTORS, each sector's times (BTJD) and
+    flux divided by its median (planets_lightcurve_flux), are each divided by their running median over three periods, which leaves the light at the
+    period and its harmonics, clipped at 5 sigma and folded at P days from T0, moved by up to half the duration to where a box of the duration DUR days
+    is deepest; that box, two sinusoids at the period and half of it, and both together are fitted by least squares, the noise the scatter about the
+    last. Returns the chi-square below a constant the box explains
+    (shape_box_chi2) and the sinusoids explain (shape_sine_chi2), the box's depth over its error beside the sinusoids (shape_box_sigma), the box's
+    depth in each sector, against the light between 0.75 and 2 durations of it, set against its mean, the reduced chi-square with each sector's error the scatter of the same box a third to two thirds of an
+    orbit on (shape_sector_chi2), the depths' scatter over their mean (shape_sector_scatter) and the sectors' number (shape_sectors), and the fold's first
+    six harmonics (shape_harmonics), each None where the fold covers no transit. A transit's box puts into the two sinusoids only the share of its variance its first two harmonics hold, and
+    keeps the rest of its significance beside them (planets_box_kept); the star's own variation at the period puts as much or more into them as into
+    the box and leaves the box short of that (planets_transit_smooth)."""
+    none = dict(shape_box_chi2=None, shape_sine_chi2=None, shape_box_sigma=None, shape_sector_chi2=None, shape_sector_scatter=None, shape_sectors=0, shape_harmonics=None)
+    T, F, S = [], [], []
+    for k, (t, f) in enumerate(sectors):
+        size = int(round(3.0 * P / max(float(np.median(np.diff(t))), 1e-4))) | 1
+        if size < len(t):
+            # the running median read on every STEP-th point, about a hundred to its window
+            step = max(1, size // 101)
+            f = f / np.interp(t, t[::step], gpu_host(gpu_running_median(f[None, ::step], (size // step) | 1))[0])
+        T.append(t), F.append(f - 1.0), S.append(np.full(len(t), k))
+    if not T:
+        return none
+    t, f, sec = np.concatenate(T), np.concatenate(F), np.concatenate(S)
+    # clipped at 5 sigma, within a duration of a transit above alone, so that a deep transit keeps its own points
+    mid = float(np.median(f))
+    limit = 5.0 * 1.4826 * float(np.median(np.abs(f - mid)))
+    keep = (f - mid < limit) & ((mid - f < limit) | (np.abs(((t - t0) / P + 0.5) % 1.0 - 0.5) * P < dur))
+    t, f, sec = t[keep], f[keep], sec[keep]
+
+    def deepest(shift):
+        inn = np.abs((((t - t0 - shift) / P + 0.5) % 1.0 - 0.5) * P) < 0.5 * dur
+        return float(np.mean(f[~inn]) - np.mean(f[inn])) if 3 <= inn.sum() < len(f) else -np.inf
+    shifts = np.linspace(-0.5 * dur, 0.5 * dur, 21)
+    t0 = t0 + float(shifts[int(np.argmax([deepest(s) for s in shifts]))])
+    x = ((t - t0) / P + 0.5) % 1.0 - 0.5
+    box = (np.abs(x) * P < 0.5 * dur).astype(float)
+    if box.sum() < 3 or (1.0 - box).sum() < 10:
+        return none
+    sines = [g(2.0 * math.pi * k * x) for k in (1, 2) for g in (np.cos, np.sin)]
+    one = np.ones_like(f)
+
+    def fit(cols):
+        A = np.column_stack(cols + [one])
+        c, *_ = np.linalg.lstsq(A, f, rcond=None)
+        return A, c, f - A @ c
+    A, c, res = fit(sines + [box])
+    sd = 1.4826 * float(np.median(np.abs(res - np.median(res))))
+    if not sd > 0:
+        return none
+    base = float(np.sum((f - f.mean()) ** 2))
+    gain = lambda cols: round((base - float(np.sum(fit(cols)[2] ** 2))) / sd ** 2, 1)
+    err = sd * math.sqrt(float(np.linalg.inv(A.T @ A)[4, 4]))
+    # each sector's depth against the light between 0.75 and 2 durations of it, and against the same box a third to two thirds of an orbit on, whose scatter holds the sector's own
+    # correlated noise
+    deps, errs, q = [], [], dur / P
+    for k in np.unique(sec):
+        xs, fs = x[sec == k], f[sec == k]
+
+        def depth_at(p):
+            y = np.abs((xs - p + 0.5) % 1.0 - 0.5)
+            inn, ring = y < 0.5 * q, (y > 0.75 * q) & (y < 2.0 * q)
+            return float(np.mean(fs[ring]) - np.mean(fs[inn])) if inn.sum() >= 3 and ring.sum() >= 3 else float("nan")
+        far = np.array([depth_at(p) for p in np.linspace(0.35, 0.65, 9)])
+        if math.isfinite(depth_at(0.0)) and np.isfinite(far).sum() >= 5 and np.nanstd(far) > 0:
+            deps.append(depth_at(0.0)), errs.append(float(np.nanstd(far)))
+    chi, scatter = None, None
+    if len(deps) >= 2:
+        d_, e_ = np.array(deps), np.array(errs)
+        mean = float(np.sum(d_ / e_ ** 2) / np.sum(1.0 / e_ ** 2))
+        chi = round(float(np.sum((d_ - mean) ** 2 / e_ ** 2)) / (len(d_) - 1), 2)
+        scatter = round(float(np.std(d_)) / abs(mean), 3) if mean else None
+    # the fold's first six harmonics about the moved epoch, in ppm, with their error
+    harm = dict(cos=[round(2e6 * float(np.mean(f * np.cos(2.0 * math.pi * k * x))), 1) for k in range(1, 7)],
+                sin=[round(2e6 * float(np.mean(f * np.sin(2.0 * math.pi * k * x))), 1) for k in range(1, 7)], err=round(1e6 * sd * math.sqrt(2.0 / len(f)), 2))
+    return dict(shape_box_chi2=gain([box]), shape_sine_chi2=gain(sines), shape_box_sigma=round(-float(c[4]) / err, 2), shape_sector_chi2=chi,
+                shape_sector_scatter=scatter, shape_sectors=len(deps), shape_harmonics=harm)
+
+
+def planets_box_kept(q):
+    """The share of a box's significance that stays beside two sinusoids at its period and half of it, for a box of duty cycle Q: the root of the
+    share of its variance outside its first two harmonics."""
+    q = min(max(q, 1e-6), 0.5)
+    inside = sum(2.0 * math.sin(n * math.pi * q) ** 2 / (n * math.pi) ** 2 for n in (1, 2)) / (q * (1.0 - q))
+    return math.sqrt(max(1.0 - inside, 0.0))
+
+
+def planets_transit_smooth(v):
+    """Whether a validation record V's folded light is the star's own smooth variation at the period rather than a transit or an eclipse
+    (planets_transit_shape): the fold detecting the box at 7.1 sigma or more, the sinusoids at the period and half of it explaining at least as much
+    as the box, and the box beside them under 3 sigma, or under three tenths of the significance a transit's box of its duration keeps there
+    (planets_box_kept), and 3 sigma or more short of that. A fold too noisy to detect the box judges nothing."""
+    s, b, z = v.get("shape_sine_chi2"), v.get("shape_box_chi2"), v.get("shape_box_sigma")
+    if None in (s, b, z) or not v.get("period") or not v.get("duration_h"):
+        return False
+    kept = planets_box_kept(v["duration_h"] / 24.0 / v["period"]) * math.sqrt(max(b, 0.0))
+    return b >= 7.1 ** 2 and s >= b and z < max(3.0, 0.3 * kept) and kept - z >= 3.0
+
+
+def planets_transit_depths_vary(v):
+    """Whether a validation record V's transit changes its depth from sector to sector (planets_transit_shape): in three sectors or more, a reduced
+    chi-square of 5 or more against the sectors' own noise, with a scatter of a quarter of the mean depth or more. No decision reads it."""
+    chi, scatter = v.get("shape_sector_chi2"), v.get("shape_sector_scatter")
+    return (v.get("shape_sectors") or 0) >= 3 and chi is not None and scatter is not None and chi >= 5.0 and scatter >= 0.25
+
+
+def planets_transit_sawtooth(v):
+    """Whether a validation record V's fold repeats at half its period, its odd harmonics under a twentieth of its even (planets_transit_shape), with dips skewed
+    about their deepest, the sines of its second and fourth harmonics at three tenths of their cosines or more, as a star's pulsation is and an eclipse is not."""
+    h = v.get("shape_harmonics")
+    if not h:
+        return False
+    c, s, e = h["cos"], h["sin"], h["err"]
+    even, odd = math.sqrt(c[1] ** 2 + s[1] ** 2 + c[3] ** 2 + s[3] ** 2), math.sqrt(c[0] ** 2 + s[0] ** 2 + c[2] ** 2 + s[2] ** 2)
+    return even >= 10.0 * e and odd <= 0.05 * even and abs(s[1]) + abs(s[3]) >= 0.3 * (abs(c[1]) + abs(c[3]))
+
+
+def planets_transit_equal_dips(v):
+    """Whether a validation record V's fold shows two dips half an orbit apart that the light cannot tell apart: its even harmonics detected at 5 sigma and its
+    odd ones within their errors, a chi-square on the first and third harmonics' four terms under 16 (planets_transit_shape)."""
+    h = v.get("shape_harmonics")
+    if not h or not h["err"] > 0:
+        return False
+    c, s, e = h["cos"], h["sin"], h["err"]
+    return math.sqrt(c[1] ** 2 + s[1] ** 2 + c[3] ** 2 + s[3] ** 2) >= 5.0 * e and (c[0] ** 2 + s[0] ** 2 + c[2] ** 2 + s[2] ** 2) / e ** 2 < 16.0
+
+
+def planets_transit_half(g):
+    """A blind-search signal G as the signal at half its period, its transits' epochs doubled and its signal-to-noise raised for the transits between them."""
+    return dict(g, P=round(0.5 * g["P"], 6), snr=round(g["snr"] * math.sqrt(2.0), 2), red_snr=round(g["red_snr"] * math.sqrt(2.0), 2) if g.get("red_snr") else None,
+                odd_even_sigma=None, secondary_sigma=None, events=[dict(e, epoch=2 * e["epoch"]) for e in g["events"]])
+
+
+def planets_centroid_check(tic, P, t0, dur):
+    """What a validation record keeps of where a dip's light comes from (planets_transit_centroids): the source's distance from the star (centroid_arcsec), its error
+    (centroid_err) and significance (centroid_sigma), and its significance from the light-weighted centre out of transit (centroid_cen_sigma); empty where the
+    light curves place no source."""
+    try:
+        c = planets_transit_centroids(int(tic), P, t0, dur)
+    except Exception:
+        return {}
+    if not c or "offset_arcsec" not in c:
+        return {}
+    return dict(centroid_arcsec=round(math.hypot(*c["offset_arcsec"]), 2), centroid_err=c.get("offset_err_arcsec"), centroid_sigma=c.get("offset_sigma"), centroid_cen_sigma=c.get("from_centroid_sigma"))
+
+
+def planets_centroid_off(v):
+    """Whether a validation record V places a dip's source off the star: 5 sigma or more from the star and from the light-weighted centre out of transit
+    (planets_centroid_check), as 4 per cent of confirmed planets are and 14 per cent of the candidates SPOC's data validation finds off target. Lower levels do not
+    separate the two, so they are reported and decide nothing."""
+    return (v.get("centroid_sigma") or 0.0) >= 5.0 and (v.get("centroid_cen_sigma") or 0.0) >= 5.0
+
+
+def planets_gaia_near(ra, dec):
+    """Gaia DR3's RUWE and rotation speed for the star at a J2000 position, the brightest within 3 arcsec or else the nearest within 10, read from the first of
+    VizieR's sites to answer and kept in ROOT/gaia_near/: (gaia_ruwe, gaia_vbroad), each None where Gaia gives none; an IOError where no site answers."""
+    path = planets_path("gaia_near", "%.5f_%+.5f.json" % (ra, dec))
+    got = planets_load_json(path)
+    if got is not None:
+        return got
+    q = urllib.parse.urlencode({"-source": "I/355/gaiadr3", "-c": "%.6f %+.6f" % (ra, dec), "-c.rs": "10", "-out.max": "20", "-out.add": "_r", "-out": "Gmag,RUWE,Vbroad"})
+    text = None
+    for site in planets_VIZIER_SITES:
+        raw = archive_get("%s/viz-bin/asu-tsv?%s" % (site, q), timeout=120, retries=2, soft=True)
+        if raw and b"VizieR" in raw[:4000]:
+            text = raw.decode("utf-8", "replace")
+            break
+    if text is None:
+        raise IOError("no VizieR site answered for Gaia DR3")
+    rows, head, skip = [], None, 0
+    for line in text.splitlines():
+        if line.startswith("#") or not line.strip():
+            head, skip = None, 0
+            continue
+        cells = [c.strip() for c in line.split("\t")]
+        if head is None:
+            head, skip = cells, 2
+        elif skip:
+            skip -= 1
+        else:
+            rows.append(dict(zip(head, cells)))
+    close = [x for x in rows if planets_num(x.get("_r")) < 3.0]
+    best = min(close, key=lambda x: planets_num(x.get("Gmag"))) if close else min(rows, key=lambda x: planets_num(x.get("_r")), default={})
+    out = {k: (planets_num(best.get(c)) if math.isfinite(planets_num(best.get(c))) else None) for k, c in (("gaia_ruwe", "RUWE"), ("gaia_vbroad", "Vbroad"))}
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    archive_save(path, json.dumps(out).encode())
+    return out
+
+
+# Gaia's RUWE from which a star's astrometry is no longer a single star's (Lindegren et al. 2018), reached by 4 per cent of confirmed planets; the rotation speed
+# (km/s) and the period's share of the longest rotation period that speed allows within which a planet's dip may be the star's rotation, reached by none of the
+# confirmed planets with a speed
+planets_RUWE_MAX, planets_SPIN_FAST, planets_SPIN_LOW, planets_SPIN_HIGH = 1.4, 50.0, 0.7, 1.3
+
+
+def planets_check_cols(v, P, x):
+    """The checks a validation record V holds as signals.csv columns for a signal of period P days and row X: Gaia's RUWE and rotation speed, the period's share of
+    the longest rotation period that speed allows on the star's radius (spin_ratio), and where the dip's light comes from (planets_centroid_check)."""
+    cols = {}
+    if v.get("gaia_ruwe") is not None:
+        cols["ruwe"] = v["gaia_ruwe"]
+    vb, rstar = v.get("gaia_vbroad"), v.get("star_radius") or planets_num(x.get("Stellar Radius (R_Sun)"))
+    if vb:
+        cols["gaia_vbroad"] = vb
+        if rstar and math.isfinite(rstar) and rstar > 0 and P and P > 0:
+            cols["spin_ratio"] = round(P / (2.0 * math.pi * rstar * 6.957e5 / vb / 86400.0), 3)
+    if v.get("centroid_arcsec") is not None:
+        cols.update(centroid_arcsec=v["centroid_arcsec"], centroid_err=v.get("centroid_err"), centroid_sigma=v.get("centroid_sigma"))
+    return cols
+
+
+# the chi-square by which a measured ephemeris must beat the listed one to replace it, five sigma, and the share of its duration a transit must move
+planets_EPHEMERIS_GAIN, planets_EPHEMERIS_MOVE = 25.0, 0.25
+
+
+def planets_ephemeris(sectors, P, t0, dur, span=0.002):
+    """The ephemeris a transit's own light curves give. SECTORS, each sector's times (BTJD) and flux divided by its median (planets_lightcurve_flux), are
+    each divided by their running median over three durations or 0.75 days, whichever is longer, clipped at 5 sigma above alone so that no transit is cut,
+    and binned to a sixth of the duration DUR days. A box of that duration is tried at periods within the share SPAN of P days, spaced so that it drifts by
+    a quarter of its length over the light curves, and at phases within two durations of the epoch T0. Returns the best period P and epoch t0 with the
+    chi-square below a constant that the box explains (chi2), the best at P itself within half a duration of T0 as a fold on the listed ephemeris finds
+    it (chi2_listed), and how far the two ephemerides lie apart within the light curves in days (moved), of the ephemerides within planets_EPHEMERIS_GAIN
+    of the best, which the light curves cannot tell apart, the one nearest the listed; with the depth its box gives in ppm (depth_ppm), the transits it
+    covers (transits) and the largest share of its chi-square one transit holds (share). None where the light curves show no transit's worth of points."""
+    T, F = [], []
+    for t, f in sectors:
+        if len(t) < 10:
+            continue
+        size = int(round(max(0.75, 3.0 * dur) / max(float(np.median(np.diff(t))), 1e-4))) | 1
+        if size < len(t):
+            step = max(1, size // 101)
+            f = f / np.interp(t, t[::step], gpu_host(gpu_running_median(f[None, ::step], (size // step) | 1))[0])
+        T.append(t), F.append(f - 1.0)
+    if not T:
+        return None
+    t, f = np.concatenate(T), np.concatenate(F)
+    order = np.argsort(t)
+    t, f = t[order], f[order]
+    mid = float(np.median(f))
+    keep = f - mid < 5.0 * 1.4826 * float(np.median(np.abs(f - mid)))
+    t, f = t[keep], f[keep]
+    if len(t) < 30:
+        return None
+    width = max(dur / 6.0, float(np.median(np.diff(t))))
+    _, inv, n = np.unique(((t - t[0]) / width).astype(np.int64), return_inverse=True, return_counts=True)
+    w = n.astype(float)
+    tb, yb = np.bincount(inv, t) / w, np.bincount(inv, f) / w
+    yb = yb - float(np.sum(w * yb) / np.sum(w))
+    # the noise per point from the bins' median, which a transit does not move
+    var = float(np.median(w * yb ** 2)) / 0.4549
+    if not var > 0:
+        return None
+    W = float(np.sum(w))
+    reach = float(np.max(np.abs(tb - t0)))
+    step = max(0.25 * dur * P / max(reach, P), 2.0 * span * P / 4000.0)
+    trials = P + np.arange(-int(span * P / step), int(span * P / step) + 1) * step
+    nb, L = max(16, int(math.ceil(P / (0.25 * dur)))), 4
+
+    def scan(periods, reachable):
+        # the best chi-square of each period over the box's places within REACHABLE of the epoch, and the place
+        Wb = np.bincount((np.arange(len(periods))[:, None] * nb + np.minimum((((tb[None, :] - t0) / periods[:, None] + 0.5) % 1.0 * nb).astype(np.int64), nb - 1)).ravel(),
+                         np.tile(w, len(periods)), minlength=len(periods) * nb).reshape(len(periods), nb)
+        Yb = np.bincount((np.arange(len(periods))[:, None] * nb + np.minimum((((tb[None, :] - t0) / periods[:, None] + 0.5) % 1.0 * nb).astype(np.int64), nb - 1)).ravel(),
+                         np.tile(w * yb, len(periods)), minlength=len(periods) * nb).reshape(len(periods), nb)
+        Wc = np.concatenate([np.zeros((len(periods), 1)), np.cumsum(np.concatenate([Wb, Wb[:, :L]], 1), 1)], 1)
+        Yc = np.concatenate([np.zeros((len(periods), 1)), np.cumsum(np.concatenate([Yb, Yb[:, :L]], 1), 1)], 1)
+        s = np.arange(nb)
+        place = ((s + 0.5 * L) / nb - 0.5)[None, :] * periods[:, None]
+        Win, Yin = Wc[:, s + L] - Wc[:, s], Yc[:, s + L] - Yc[:, s]
+        with np.errstate(divide="ignore", invalid="ignore"):
+            chi = np.where((Win > 0) & (Win < W) & (Yin < 0) & (np.abs(place) <= reachable), Yin ** 2 * W / (Win * (W - Win)) / var, 0.0)
+        at = np.argmax(chi, 1)
+        return chi[np.arange(len(periods)), at], place[np.arange(len(periods)), at]
+    got = [scan(trials[c:c + 128], 2.0 * dur) for c in range(0, len(trials), 128)]
+    chi, shift = np.concatenate([g[0] for g in got]), np.concatenate([g[1] for g in got])
+    if not chi.max() > 0:
+        return None
+    away = lambda k: float(np.max(np.abs((tb - t0) / P * (trials[k] - P) + shift[k])))
+    k = min(np.where(chi >= chi.max() - planets_EPHEMERIS_GAIN)[0].tolist(), key=away)
+    best_P, best_shift = float(trials[k]), float(shift[k])
+    listed = float(scan(np.array([P]), 0.5 * dur)[0][0])
+    # the transits the box covers, one by one
+    inn = np.abs(((tb - t0 - best_shift) / best_P + 0.5) % 1.0 - 0.5) * best_P < 0.5 * dur
+    _, where = np.unique(np.round((tb[inn] - t0 - best_shift) / best_P).astype(np.int64), return_inverse=True)
+    Wi, Si = np.bincount(where, w[inn]), np.bincount(where, (w * yb)[inn])
+    each = np.where(Si < 0, Si ** 2 / Wi / var, 0.0)
+    return dict(P=best_P, t0=t0 + best_shift, chi2=round(float(chi[k]), 1), chi2_listed=round(listed, 1), moved=round(away(k), 4), depth_ppm=round(-1e6 * float(Si.sum() / Wi.sum()), 1),
+                transits=int(len(Wi)), share=round(float(each.max() / each.sum()), 3) if each.sum() > 0 else 1.0)
+
+
+def planets_ephemeris_moves(e, dur, depth):
+    """Whether a measured ephemeris E (planets_ephemeris) replaces the listed one of a transit of duration DUR days and listed depth DEPTH ppm: it beats the
+    listed by planets_EPHEMERIS_GAIN in chi-square, moves the transit by planets_EPHEMERIS_MOVE of its duration and by under half a period, past which
+    the light curves cannot tell the cycle, gives no one transit more than half of its chi-square, and gives a depth within a factor of two of the listed,
+    which another planet's transits falling in the box do not."""
+    return bool(e) and e["chi2"] - e["chi2_listed"] >= planets_EPHEMERIS_GAIN and planets_EPHEMERIS_MOVE * dur <= e["moved"] < 0.5 * e["P"] and e["share"] <= 0.5 and depth > 0 \
+        and 0.5 <= e["depth_ppm"] / depth <= 2.0
+
+
+def planets_ephemeris_kept(raw, r, P, t0, dur):
+    """The ephemeris a candidate's light curves RAW give (planets_ephemeris) within 0.2 per cent of its period P or five times the period's listed error in its row R, 1 per cent at
+    most, with the period and epoch to read it at: the measure's where it replaces the listed P and T0 (planets_ephemeris_moves), those otherwise."""
+    err = next((planets_num(r[k]) for k in r if "Period" in k and "err" in k.lower()), float("nan"))
+    e = planets_ephemeris(raw, P, t0, dur, min(0.01, max(0.002, 5.0 * err / P)) if err > 0 else 0.002) if raw and P > 0 and dur > 0 else None
+    return (e, e["P"], e["t0"]) if planets_ephemeris_moves(e, dur, planets_num(r["Depth (ppm)"])) else (e, P, t0)
+
+
 def planets_validate_one(r, draws=100000, runs=10, window=2.0, bins=150, cache=None, parallel=True, files=None, nsamples=5, target=None, fpp_max=0.015,
                          nfpp_max=0.001):
     """One TESS candidate, a row of planets_candidates, validated statistically with TRICERATOPS (Giacalone and Dressing 2020): the stars of the TIC
-    within 10 pixels with a Gaia DR3 background population, and the target's SPOC or TESS-SPOC light curves (planets_validate_fetch). Each
-    light-curve file gives its sector's optimal aperture and, through its aperture's WCS and pixel origin, every star's position on the detector, in
-    place of TRICERATOPS's own TESScut cutouts. The PDCSAP flux of quality zero, each sector divided by its running median over 0.75 days with the
+    within 10 pixels with a Gaia DR3 background population, and the target's SPOC, TESS-SPOC or QLP light curves (planets_validate_fetch). Each SPOC
+    or TESS-SPOC light-curve file gives its sector's optimal aperture and, through its aperture's WCS and pixel origin, every star's position on the
+    detector, in place of TRICERATOPS's own TESScut cutouts; a QLP file gives its circular best aperture about the star's place, the other stars being
+    placed about it by their offsets on the sky, its detrended flux taken for the PDCSAP flux. The PDCSAP flux of quality zero, each sector divided by its running median over 0.75 days with the
     transits bridged, is folded on ExoFOP's ephemeris, its epoch moved by up to half the duration to where a box of the duration is deepest, and binned
     into BINS bins within WINDOW transit durations of mid-transit, each bin's model averaged
     over NSAMPLES times across its width, or for full-frame light curves across their cadence, one time every two minutes; the transit depth is ExoFOP's,
     and the target's mass, radius, temperature and parallax are the TIC's, or ExoFOP's where the TIC gives none; the companions the contrast curves of
     the star's high-resolution imaging on ExoFOP rule out are ruled out (planets_contrast_curves). The same flux, unbinned, gives the
     depths of the odd and the even transits and the depth half an orbit on, each the mean within a quarter of the duration of its centre (within half
-    the duration half an orbit on) against the mean between 0.75 and 2 durations of it, with errors from the scatter there. Returns the record: the
+    the duration half an orbit on) against the mean between 0.75 and 2 durations of it, with errors from the scatter there; the flux of each sector
+    divided by its median alone, folded on the moved epoch, tells a transit's box from the star's own variation at the period (planets_transit_shape).
+    Returns the record: the
     false-positive and nearby-false-positive probabilities, their means over RUNS runs of DRAWS draws each (Giacalone et al. 2021), or over three where
     those three already put the means at FPP_MAX or NFPP_MAX or above, with each run's; every scenario's mean probability; the epoch's shift; the
-    odd-even and secondary depths and their significances; and the light curves' kind, cadence, sectors and points; a note where the light curves cover
+    odd-even and secondary depths and their significances; the shape's chi-squares and the box's significance beside the sinusoids; and the light
+    curves' kind, cadence, sectors and points; a note where the light curves cover
     no transit, the target has no stellar parameters or TRICERATOPS weighs no scenario; or None where no light curve covers the candidate."""
     from astropy.io import fits
     from astropy.wcs import WCS
@@ -7045,20 +8834,34 @@ def planets_validate_one(r, draws=100000, runs=10, window=2.0, bins=150, cache=N
     if target is None:
         with planets_VALIDATE_LOCK:
             target = planets_validate_setup().target(ID=tic, sectors=np.array(good), lightkurve_cache_dir=cache)
-    T, F, aps, coords, cads = [], [], [], [], []
+    T, F, aps, coords, cads, raw = [], [], [], [], [], []
     for s in good:
         with fits.open(files[s]) as h:
-            d, a = h["LIGHTCURVE"].data, h["APERTURE"]
-            cads.append(float(h["LIGHTCURVE"].header.get("TIMEDEL") or 0.0))
-            rows_, cols_ = np.nonzero(np.asarray(a.data).astype(int) & 2)
-            aps.append(np.column_stack([cols_ + a.header["CRVAL1P"], rows_ + a.header["CRVAL2P"]]))
-            x_, y_ = WCS(a.header).all_world2pix(target.stars["ra"].values, target.stars["dec"].values, 0)
-            coords.append(np.column_stack([x_ + a.header["CRVAL1P"], y_ + a.header["CRVAL2P"]]))
-            t, f, q = np.asarray(d["TIME"], float), np.asarray(d["PDCSAP_FLUX"], float), np.asarray(d["QUALITY"])
-        ok = np.isfinite(t) & np.isfinite(f) & (q == 0)
-        if ok.sum() < 100:
+            d, lh = h["LIGHTCURVE"].data, h["LIGHTCURVE"].header
+            cads.append(float(lh.get("TIMEDEL") or 0.0))
+            qlp = next((c for c in ("DET_FLUX", "KSPSAP_FLUX") if c in d.columns.names), None)
+            if qlp:
+                # QLP's light curve, its detrended flux DET_FLUX or in its first releases KSPSAP_FLUX: its circular best aperture (BESTAP, the small,
+                # large and best radii in pixels) about the star's place on the detector, and the TIC's stars placed about it by their offsets on the
+                # sky at 21 arcsec a pixel, a circular aperture being alike under the detector's turn
+                x0, y0 = float(np.nanmedian(d["SAP_X"])), float(np.nanmedian(d["SAP_Y"]))
+                rad = float(str(lh.get("BESTAP") or "3.0").split(":")[-1])
+                gx, gy = np.meshgrid(np.arange(math.floor(x0 - rad), math.ceil(x0 + rad) + 1), np.arange(math.floor(y0 - rad), math.ceil(y0 + rad) + 1))
+                inside = (gx - x0) ** 2 + (gy - y0) ** 2 <= rad ** 2
+                aps.append(np.column_stack([gx[inside], gy[inside]]))
+                ra_, dec_ = target.stars["ra"].values, target.stars["dec"].values
+                coords.append(np.column_stack([x0 + (ra_ - ra_[0]) * math.cos(math.radians(dec_[0])) * 3600.0 / 21.0, y0 + (dec_ - dec_[0]) * 3600.0 / 21.0]))
+            else:
+                a = h["APERTURE"]
+                rows_, cols_ = np.nonzero(np.asarray(a.data).astype(int) & 2)
+                aps.append(np.column_stack([cols_ + a.header["CRVAL1P"], rows_ + a.header["CRVAL2P"]]))
+                x_, y_ = WCS(a.header).all_world2pix(target.stars["ra"].values, target.stars["dec"].values, 0)
+                coords.append(np.column_stack([x_ + a.header["CRVAL1P"], y_ + a.header["CRVAL2P"]]))
+            got = planets_lightcurve_flux(d)
+        if got is None:
             continue
-        t, f = t[ok], f[ok] / np.median(f[ok])
+        t, f = got
+        raw.append(got)
         intransit = np.abs(((t - t0) / P + 0.5) % 1.0 - 0.5) * P < dur
         if intransit.all():
             continue
@@ -7093,7 +8896,12 @@ def planets_validate_one(r, draws=100000, runs=10, window=2.0, bins=150, cache=N
     e_oe = math.hypot(e_odd, e_even)
     fin = lambda v, digits: round(v, digits) if math.isfinite(v) else None
     checks = dict(depth_odd_ppm=fin(1e6 * d_odd, 1), depth_even_ppm=fin(1e6 * d_even, 1), depth_secondary_ppm=fin(1e6 * d_sec, 1),
-                  odd_even_sigma=fin(abs(d_odd - d_even) / e_oe, 2) if e_oe > 0 else None, secondary_sigma=fin(d_sec / e_sec, 2) if e_sec > 0 else None)
+                  odd_even_sigma=fin(abs(d_odd - d_even) / e_oe, 2) if e_oe > 0 else None, secondary_sigma=fin(d_sec / e_sec, 2) if e_sec > 0 else None,
+                  **planets_transit_shape(raw, P, t0, dur), **planets_centroid_check(tic, P, t0, dur))
+    try:
+        checks.update(planets_gaia_near(float(target.stars["ra"].values[0]), float(target.stars["dec"].values[0])))
+    except (IOError, ValueError):
+        del planets_VARIABLES_DOWN[:]
     near = np.abs(x) < window * dur
     edges = np.linspace(-window * dur, window * dur, bins + 1)
     k = np.digitize(x[near], edges) - 1
@@ -7135,7 +8943,7 @@ def planets_validate_one(r, draws=100000, runs=10, window=2.0, bins=150, cache=N
             scen[s_] = scen.get(s_, 0.0) + float(p_)
         if k == 2 and (sum(fpps) >= runs * fpp_max or sum(nfpps) >= runs * nfpp_max):
             break
-    kinds = sorted({"TESS-SPOC" if "tess-spoc" in os.path.basename(files[s]) else "SPOC" for s in good})
+    kinds = sorted({"QLP" if "hlsp_qlp" in os.path.basename(files[s]) else "TESS-SPOC" if "tess-spoc" in os.path.basename(files[s]) else "SPOC" for s in good})
     return dict(head, draws=draws, runs=len(fpps), nsamples=ns, period=P, epoch_shift_min=round(1440.0 * shift, 1), depth_ppm=depth * 1e6,
                 duration_h=dur * 24.0, light_curves="+".join(kinds), cadence_s=round(cadence * 86400.0), sectors=good, points=int(near.sum()),
                 bins=int(ok.sum()), flux_err=err, fpp=float(np.mean(fpps)), nfpp=float(np.mean(nfpps)), fpp_runs=[float("%.4g" % v) for v in fpps],
@@ -7281,6 +9089,328 @@ def planets_validation_benchmark():
     return out
 
 
+def planets_validate_refine(part=None, draws=100000, runs=10):
+    """The TESS candidates whose validation under RESULTS/validate holds probabilities that do not pass or reads the star's own variation, weighed again
+    where their own light curves move them off ExoFOP's ephemeris, since a fold on a period that has drifted smears a transit. Passed over are those the
+    TFOPWG has settled or whose radius rules them out, as no weighing changes their decision. Each one's light curves are fetched as its validation
+    fetched them (planets_validate_fetch) and its ephemeris measured (planets_ephemeris) within 0.2 per cent of its period or five times the period's
+    listed error, 1 per cent at most, the measure kept in RESULTS/validate_ephemeris/<label>.json with the probabilities the candidate held. Where the
+    measure replaces the listed ephemeris (planets_ephemeris_moves), the candidate is weighed at it (planets_validate_one), the new record taking the old
+    one's place where it holds probabilities, with the listed ephemeris beside it
+    and, where it passes, the variable stars near it (planets_variable_neighbours). The candidates nearest to passing come first; PART takes the share K/N;
+    the weighing ends between candidates where a long search would end between stars (planets_search_ends), and exits with status 3 so that it is started
+    again."""
+    from astropy.io import fits
+    import socket
+    warnings.filterwarnings("ignore")
+    socket.setdefaulttimeout(300)
+    folder, kept = os.path.join(planets_RESULTS, "validate"), os.path.join(planets_RESULTS, "validate_ephemeris")
+    os.makedirs(kept, exist_ok=True)
+    exo = {x["label"]: x for source in ("toi", "ctoi") if os.path.exists(planets_path(source + ".csv")) for x in planets_candidates(source)}
+    todo = []
+    for path in glob.glob(os.path.join(folder, "*.json")):
+        v = planets_load_json(path)
+        if not v or "fpp" not in v or os.path.exists(os.path.join(kept, os.path.basename(path))):
+            continue
+        r = exo.get(v.get("label") or "TOI-" + str(v.get("toi")))
+        if not r or r.get("TFOPWG Disposition") in ("KP", "CP", "FP", "FA") or planets_num(r.get("Planet Radius (R_Earth)")) >= 22.4:
+            continue
+        if not (v["fpp"] < 0.015 and v["nfpp"] < 0.001) or planets_transit_smooth(v):
+            todo.append((max(v["fpp"], 0.0) + max(v["nfpp"], 0.0), path, r))
+    todo.sort(key=lambda x: (x[0], x[1]))
+    if part:
+        k, n = (int(x) for x in part.split("/"))
+        todo = todo[k::n]
+    print("%d candidates in this share" % len(todo), flush=True)
+    if not todo:
+        return
+    planets_validate_setup()
+    if gpu_DEVICE.type == "cuda" and not planets_VALIDATE_GPU:
+        planets_validate_gpu()
+        planets_VALIDATE_GPU.append(True)
+    moved_n = 0
+    for i, (_, path, r) in enumerate(todo):
+        if planets_search_ends():
+            sys.exit(3)
+        v = planets_load_json(path)
+        P, t0, dur = planets_num(r["Period (days)"]), planets_num(r["Epoch (BJD)"]) - 2457000.0, planets_num(r["Duration (hours)"]) / 24.0
+        cache = planets_path("validate_cache", archive_tag(r["label"]) + "_ephemeris")
+        try:
+            files = planets_validate_fetch(r, cache) or {}
+            raw = []
+            for s in sorted(files):
+                with fits.open(files[s]) as h:
+                    got = planets_lightcurve_flux(h["LIGHTCURVE"].data)
+                if got is not None:
+                    raw.append(got)
+            e, read_P, read_t0 = planets_ephemeris_kept(raw, r, P, t0, dur)
+            line = dict(e or {}, P_listed=P, t0_listed=t0, fpp_before=v["fpp"], nfpp_before=v["nfpp"], period_before=v.get("period"))
+            if (read_P, read_t0) != (P, t0):
+                moved_n += 1
+                r2 = dict(r, **{"Period (days)": repr(e["P"]), "Epoch (BJD)": repr(e["t0"] + 2457000.0)})
+                start = time.time()
+                rec = planets_validate_one(r2, draws, runs, cache=cache, files=files)
+                if rec and "fpp" in rec:
+                    if rec["fpp"] < 0.015 and rec["nfpp"] < 0.001:
+                        rec["variable_neighbours"] = planets_variable_neighbours(*planets_radec(r), e["P"])
+                    rec.update(seconds=round(time.time() - start), likelihoods="gpu" if gpu_DEVICE.type == "cuda" else "pytransit",
+                               ephemeris_listed=dict(P=P, t0=t0, chi2=e["chi2_listed"]), ephemeris_chi2=e["chi2"])
+                    archive_save(path, json.dumps(rec, separators=(",", ":")).encode())
+                    line.update(fpp=rec["fpp"], nfpp=rec["nfpp"])
+                else:
+                    line.update(note=(rec or {}).get("note", "not weighed"))
+            archive_save(os.path.join(kept, os.path.basename(path)), json.dumps(line, separators=(",", ":")).encode())
+            print("%4d/%d %-18s %s%s" % (i + 1, len(todo), r["label"], "P %.6f to %.6f, chi2 %s from %s, moved %.2f h" % (P, e["P"], e["chi2"], e["chi2_listed"], e["moved"] * 24.0) if e else "no measure",
+                                         ": FPP %.4f NFPP %.5f, was %.4f %.5f" % (line["fpp"], line["nfpp"], v["fpp"], v["nfpp"]) if "fpp" in line else ""), flush=True)
+        except IOError as exc:
+            # a catalogue or an archive that did not answer: the candidate comes round again at the next start
+            print("%s: %s: %s" % (r["label"], type(exc).__name__, str(exc)[:200]), flush=True)
+            del planets_VARIABLES_DOWN[:]
+        except Exception as exc:
+            print("%s: %s: %s" % (r["label"], type(exc).__name__, str(exc)[:200]), flush=True)
+            archive_save(os.path.join(kept, os.path.basename(path)), json.dumps(dict(note=str(exc)[:200]), separators=(",", ":")).encode())
+        finally:
+            shutil.rmtree(cache, ignore_errors=True)
+            for p in glob.glob(planets_path("validate_backgrounds", "%s_%d_*.csv" % (r["TIC ID"], os.getpid()))):
+                os.remove(p)
+        if gpu_DEVICE.type == "cuda":
+            torch.cuda.empty_cache()
+    print("share done: %d moved of %d" % (moved_n, len(todo)), flush=True)
+
+
+def planets_validate_checks(part=None, draws=100000, runs=10):
+    """The checks read after a validation was weighed added to each record under RESULTS/validate and RESULTS/validate_transits whose probabilities pass as a
+    planet's or a binary's: the folded light's shape with its harmonics (planets_transit_shape), where its light comes from (planets_centroid_check) and Gaia's
+    RUWE and rotation speed (planets_gaia_near), its light curves fetched as its validation fetched them, at the ephemeris it was weighed at or the one they give
+    where that replaces it, since a transit that has drifted reads as depths that change (planets_ephemeris_kept). A search signal under
+    twice the search's shortest period whose two dips are equal (planets_transit_equal_dips) is also weighed at half its period, unless the star leaves its orbit no
+    room, to <star>_<k>_half.json. A TESS candidate's record also takes the variable stars near it (planets_variable_neighbours). A record keeps a digest of the code
+    that measured it, so that a check changed or added reaches every record by itself. PART takes the share K/N; the pass ends between records where a long search
+    would end between stars, with exit status 3."""
+    from astropy.io import fits
+    import socket
+    warnings.filterwarnings("ignore")
+    socket.setdefaulttimeout(300)
+    exo = {x["label"]: x for source in ("toi", "ctoi") if os.path.exists(planets_path(source + ".csv")) for x in planets_candidates(source)}
+    version = planets_rules_hash(("planets_validate_checks", "planets_transit_shape", "planets_centroid_check", "planets_transit_centroids", "planets_gaia_near", "planets_variable_neighbours",
+                                  "planets_ephemeris", "planets_ephemeris_moves", "planets_ephemeris_kept"))
+    todo = []
+    for folder in ("validate", "validate_transits"):
+        for path in glob.glob(os.path.join(planets_RESULTS, folder, "*.json")):
+            if path.endswith("_half.json"):
+                continue
+            v = planets_load_json(path)
+            if not v or "fpp" not in v or v.get("checks_read") == version:
+                continue
+            off = v["nfpp"] + sum(v.get("scenarios", {}).get(s, 0.0) for s in ("BTP", "BEB", "BEBx2P"))
+            if (v["fpp"] < 0.015 and v["nfpp"] < 0.001) or (folder == "validate_transits" and off < 0.001):
+                todo.append((folder, path))
+    todo.sort()
+    if part:
+        k, n = (int(x) for x in part.split("/"))
+        todo = todo[k::n]
+    print("%d records in this share" % len(todo), flush=True)
+    for i, (folder, path) in enumerate(todo):
+        if planets_search_ends():
+            sys.exit(3)
+        v = planets_load_json(path)
+        cache = planets_path("validate_cache", os.path.basename(path)[:-5] + "_checks")
+        g = None
+        try:
+            if folder == "validate":
+                r = exo.get(v.get("label") or "TOI-" + str(v.get("toi")))
+                if not r:
+                    continue
+                P = v.get("period") or planets_num(r["Period (days)"])
+                t0 = planets_num(r["Epoch (BJD)"]) - 2457000.0 + (v.get("epoch_shift_min") or 0.0) / 1440.0
+                if v.get("ephemeris_listed"):
+                    e = planets_load_json(os.path.join(planets_RESULTS, "validate_ephemeris", os.path.basename(path))) or {}
+                    t0 = e.get("t0", t0)
+                dur = planets_num(r["Duration (hours)"]) / 24.0
+            else:
+                m = re.fullmatch(r"(.+)_(\d+)\.json", os.path.basename(path))
+                found = planets_load_json(os.path.join(planets_RESULTS, "transitsearch", m.group(1) + ".json"))
+                if not found or int(m.group(2)) > len(found["signals"]):
+                    continue
+                g = found["signals"][int(m.group(2)) - 1]
+                P = v.get("period") or g["P"]
+                s = planets_binary_signal(g, True) if abs(P / g["P"] - 2.0) < 0.01 else g
+                t0, dur = s["t0_btjd"], s["duration_h"] / 24.0
+                r = planets_transit_candidate(found["name"], int(m.group(2)), dict(s, P=P), v.get("tic"), v.get("star_radius"), v.get("star_mass"), v.get("star_teff"))
+            files = planets_validate_fetch(r, cache) or {}
+            raw = []
+            for s_ in sorted(files):
+                with fits.open(files[s_]) as h:
+                    got = planets_lightcurve_flux(h["LIGHTCURVE"].data)
+                    if "ra" not in v and h[0].header.get("RA_OBJ") is not None:
+                        ra, dec = h[0].header["RA_OBJ"], h[0].header["DEC_OBJ"]
+                if got is not None:
+                    raw.append(got)
+            if not raw:
+                continue
+            _, read_P, read_t0 = planets_ephemeris_kept(raw, r, P, t0, dur)
+            v.update(planets_transit_shape(raw, read_P, read_t0, dur), **planets_centroid_check(r["TIC ID"], read_P, read_t0, dur))
+            v.update(planets_gaia_near(ra, dec))
+            if folder == "validate":
+                v["variable_neighbours"] = planets_variable_neighbours(*planets_radec(r), P)
+            v["checks_read"] = version
+            archive_save(path, json.dumps(v, separators=(",", ":")).encode())
+            line = "%s: RUWE %s, %s km/s, source %s +- %s arcsec" % (os.path.basename(path)[:-5], v.get("gaia_ruwe"), v.get("gaia_vbroad"), v.get("centroid_arcsec"), v.get("centroid_err"))
+            half_path = path[:-5] + "_half.json"
+            if g and g["P"] < 2.0 * planets_TRANSIT_PMIN and abs(P / g["P"] - 1.0) < 0.01 and planets_transit_equal_dips(v) and not os.path.exists(half_path):
+                half = planets_transit_half(g)
+                why = planets_transit_physical(half, v.get("star_radius"), v.get("star_mass"))
+                if why:
+                    rec = dict(note=why)
+                else:
+                    planets_validate_setup()
+                    if gpu_DEVICE.type == "cuda" and not planets_VALIDATE_GPU:
+                        planets_validate_gpu()
+                        planets_VALIDATE_GPU.append(True)
+                    rh = planets_transit_candidate(found["name"], int(m.group(2)), half, v.get("tic"), v.get("star_radius"), v.get("star_mass"), v.get("star_teff"))
+                    rec = planets_validate_one(rh, draws, runs, cache=cache + "_half") or dict(note="no light curve or aperture")
+                    shutil.rmtree(cache + "_half", ignore_errors=True)
+                rec.update(tic=v.get("tic"), star_radius=v.get("star_radius"), star_mass=v.get("star_mass"), star_teff=v.get("star_teff"))
+                archive_save(half_path, json.dumps(rec, separators=(",", ":")).encode())
+                line += "; at half the period %s" % ("FPP %.4f NFPP %.5f" % (rec["fpp"], rec["nfpp"]) if "fpp" in rec else rec.get("note"))
+            print("%4d/%d %s" % (i + 1, len(todo), line), flush=True)
+        except IOError as exc:
+            # a catalogue or an archive that did not answer: the record comes round again at the next start
+            print("%s: %s: %s" % (os.path.basename(path), type(exc).__name__, str(exc)[:200]), flush=True)
+            del planets_VARIABLES_DOWN[:]
+        except Exception as exc:
+            print("%s: %s: %s" % (os.path.basename(path), type(exc).__name__, str(exc)[:200]), flush=True)
+            v["checks_read"] = version
+            archive_save(path, json.dumps(v, separators=(",", ":")).encode())
+        finally:
+            shutil.rmtree(cache, ignore_errors=True)
+        if gpu_DEVICE.type == "cuda":
+            torch.cuda.empty_cache()
+    print("share done", flush=True)
+
+
+def planets_control(n=200, seed=1):
+    """The decision rules tried on TOIs whose fate TESS's follow-up has settled, so that a rule that rejects real planets, or rejects false positives no more often than planets,
+    shows itself: N planets (TFOPWG CP or KP) and N false positives or alarms (FP or FA) drawn at random, each measured as a validation is, at the ephemeris its own light curves
+    give where that replaces the listed one (planets_ephemeris_kept), and its record, its probabilities set to pass, decided by planets_validation_decision, with every rule that trips
+    on it, the depths that vary from sector to sector among them, which no decision reads (planets_transit_depths_vary). RESULTS/control.json holds the rules' digest and for each group
+    how many were judged, those rejected by reason and those each rule trips on; a run with the same digest does nothing. Ends between stars where a long search would, with exit status
+    3, keeping what it has in RESULTS/control_parts.jsonl."""
+    from astropy.io import fits
+    warnings.filterwarnings("ignore")
+    digest = planets_rules_hash(("planets_control", "planets_validation_decision", "planets_transit_physical", "planets_transit_smooth", "planets_check_cols", "planets_centroid_off", "planets_variable_neighbours", "planets_transit_shape",
+                                 "planets_ephemeris", "planets_ephemeris_moves", "planets_ephemeris_kept", "planets_transit_depths_vary"), (planets_RUWE_MAX, planets_SPIN_FAST, planets_SPIN_LOW, planets_SPIN_HIGH))
+    path, parts = os.path.join(planets_RESULTS, "control.json"), os.path.join(planets_RESULTS, "control_parts.jsonl")
+    if (planets_load_json(path) or {}).get("digest") == digest:
+        return
+    held = {}
+    if os.path.exists(parts):
+        for line in open(parts, encoding="utf-8"):
+            x = json.loads(line)
+            if x["digest"] == digest:
+                held[x["label"]] = x
+    rows, groups = [], (("planets", ("CP", "KP")), ("false_positives", ("FP", "FA")))
+    for k, (group, fates) in enumerate(groups):
+        got = [r for r in planets_candidates("toi") if r["TFOPWG Disposition"].strip() in fates and planets_num(r["Period (days)"]) > 0 and planets_num(r["Duration (hours)"]) > 0]
+        random.Random(seed + k).shuffle(got)
+        rows += [dict(r, group=group) for r in got[:n]]
+    with open(parts, "a", encoding="utf-8") as out:
+        for r in rows:
+            if r["label"] in held:
+                continue
+            if planets_search_ends():
+                sys.exit(3)
+            P, t0, dur = planets_num(r["Period (days)"]), planets_num(r["Epoch (BJD)"]) - 2457000.0, planets_num(r["Duration (hours)"]) / 24.0
+            cache = planets_path("validate_cache", archive_tag(r["label"]) + "_control")
+            line = dict(label=r["label"], digest=digest, group=r["group"], status="", reason="", rules=[])
+            try:
+                files = planets_validate_fetch(r, cache) or {}
+                raw = []
+                for s in sorted(files):
+                    with fits.open(files[s]) as h:
+                        got = planets_lightcurve_flux(h["LIGHTCURVE"].data)
+                    if got is not None:
+                        raw.append(got)
+                if raw:
+                    _, P, t0 = planets_ephemeris_kept(raw, r, P, t0, dur)
+                    v = dict(planets_transit_shape(raw, P, t0, dur), **planets_centroid_check(r["TIC ID"], P, t0, dur))
+                    ra, dec = planets_radec(r)
+                    v.update(planets_gaia_near(ra, dec), period=P, duration_h=dur * 24.0, fpp=0.0, nfpp=0.0, runs=10, tic=int(r["TIC ID"]), odd_even_sigma=0.0, secondary_sigma=0.0,
+                             variable_neighbours=planets_variable_neighbours(ra, dec, P))
+                    line["status"], line["reason"] = planets_validation_decision(v, r, None, {})[:2]
+                    cols = planets_check_cols(v, P, r)
+                    spun = (cols.get("gaia_vbroad") or 0.0) >= planets_SPIN_FAST and planets_SPIN_LOW <= (cols.get("spin_ratio") or 0.0) <= planets_SPIN_HIGH
+                    line["rules"] = [name for name, hit in (("variability", planets_transit_smooth(v)), ("a neighbour's variability", v["variable_neighbours"]),
+                                                            ("astrometric binary", (v.get("gaia_ruwe") or 0.0) >= planets_RUWE_MAX), ("source off the star", planets_centroid_off(v)),
+                                                            ("the star's rotation", spun), ("the star's size", planets_transit_physical(dict(P=P, depth_ppm=planets_num(r.get("Depth (ppm)")), duration_h=dur * 24.0),
+                                                                                                                        r.get("Stellar Radius (R_Sun)"), r.get("Stellar Mass (M_Sun)"))),
+                                                            ("depths vary", planets_transit_depths_vary(v))) if hit]
+            except Exception as exc:
+                line["reason"] = "unread: %s" % type(exc).__name__
+                del planets_VARIABLES_DOWN[:]
+            finally:
+                shutil.rmtree(cache, ignore_errors=True)
+            held[r["label"]] = line
+            out.write(json.dumps(line) + "\n")
+            out.flush()
+    summary = dict(digest=digest, finished=time.strftime("%Y-%m-%d %H:%M:%S"))
+    for group, _ in groups:
+        judged = [x for x in held.values() if x["status"] and x["group"] == group]
+        by, rules = {}, {}
+        for x in judged:
+            if x["status"] == "rejected":
+                by.setdefault(x["reason"], []).append(x["label"])
+            for rule in x["rules"]:
+                rules.setdefault(rule, []).append(x["label"])
+        summary[group] = dict(judged=len(judged), rejected=sum(len(v) for v in by.values()), by_reason=by, trips=rules)
+        print("the rules reject %d of %d %s: %s; each rule trips on %s" % (summary[group]["rejected"], len(judged), group.replace("_", " "), {k: len(v) for k, v in by.items()},
+                                                                           {k: len(v) for k, v in rules.items()}), flush=True)
+    archive_save(path, json.dumps(summary).encode())
+
+
+def planets_validate_shapes(part=None):
+    """The folded light's shape (planets_transit_shape) and the variable stars near it at its period (planets_variable_neighbours) added to each TESS
+    candidate's validation record under RESULTS/validate whose probabilities pass and that was weighed before the shape's sectors were read, without
+    TRICERATOPS: its light curves fetched again as its validation fetched them (planets_validate_fetch) and folded on ExoFOP's ephemeris as it now
+    stands. PART takes the share K/N of the records."""
+    from astropy.io import fits
+    warnings.filterwarnings("ignore")
+    exo = {x["label"]: x for source in ("toi", "ctoi") if os.path.exists(planets_path(source + ".csv")) for x in planets_candidates(source)}
+    paths = sorted(glob.glob(os.path.join(planets_RESULTS, "validate", "*.json")))
+    if part:
+        k, n = (int(x) for x in part.split("/"))
+        paths = paths[k::n]
+    for path in paths:
+        if planets_search_ends():
+            return
+        v = planets_load_json(path)
+        if not v or "shape_sectors" in v or not (v.get("fpp", 1.0) < 0.015 and v.get("nfpp", 1.0) < 0.001):
+            continue
+        r = exo.get(v.get("label") or "TOI-" + str(v.get("toi")))
+        if not r:
+            continue
+        cache = planets_path("validate_cache", archive_tag(r["label"]) + "_shape")
+        try:
+            raw = []
+            for s, f in sorted((planets_validate_fetch(r, cache) or {}).items()):
+                with fits.open(f) as h:
+                    got = planets_lightcurve_flux(h["LIGHTCURVE"].data)
+                if got is not None:
+                    raw.append(got)
+            shape = planets_transit_shape(raw, planets_num(r["Period (days)"]), planets_num(r["Epoch (BJD)"]) - 2457000.0,
+                                          planets_num(r["Duration (hours)"]) / 24.0)
+            shape["variable_neighbours"] = planets_variable_neighbours(*planets_radec(r), planets_num(r["Period (days)"]))
+        except Exception as exc:
+            print("%s: %s: %s" % (r["label"], type(exc).__name__, str(exc)[:200]), flush=True)
+            continue
+        finally:
+            shutil.rmtree(cache, ignore_errors=True)
+        v.update(shape)
+        archive_save(path, json.dumps(v, separators=(",", ":")).encode())
+        print("%s: box %s, sinusoids %s, box beside them %s sigma%s" % (r["label"], shape["shape_box_chi2"], shape["shape_sine_chi2"], shape["shape_box_sigma"],
+                                                                          ", the star's variation" if planets_transit_smooth(v) else ""), flush=True)
+
+
 def planets_validate(part=None, draws=100000, runs=10, sources=("toi", "ctoi"), dispositions=("PC", "APC"), min_snr=7.1, max_snr=None, redo=False,
                      workers=None, candidates=None, benchmark=0):
     """TESS's planet candidates validated statistically, each to RESULTS/validate/<label>.json (planets_validate_one, RUNS runs of DRAWS draws each), from
@@ -7368,6 +9498,9 @@ def planets_validate(part=None, draws=100000, runs=10, sources=("toi", "ctoi"),
         v = json.load(open(path_of(r)))
         if "fpp" in v and v.get("period") and abs(planets_num(r["Period (days)"]) / v["period"] - 1.0) > 0.01:
             return True
+        # a record made without a light curve before QLP's were asked for is weighed once more
+        if v.get("note") == "no light curve or aperture" and not v.get("qlp"):
+            return True
         if int(r["TIC ID"]) not in imaged or "fpp" not in v or "contrast_curves" in v:
             return False
         try:
@@ -7407,7 +9540,7 @@ def planets_validate(part=None, draws=100000, runs=10, sources=("toi", "ctoi"),
             if due(r):
                 try:
                     rec = (planets_validate_one(r, draws, runs, cache=cache_of(r), files=files, target=target) if files else None) or \
-                        dict(label=r["label"], toi=r["TOI"], tic=int(r["TIC ID"]), note=why or "no light curve or aperture")
+                        dict(label=r["label"], toi=r["TOI"], tic=int(r["TIC ID"]), note=why or "no light curve or aperture", qlp=True)
                 except Exception as exc:
                     rec = dict(label=r["label"], toi=r["TOI"], tic=int(r["TIC ID"]), note="%s: %s" % (type(exc).__name__, str(exc)[:200]))
                 rec.update(seconds=round(time.time() - t_start), likelihoods=likelihoods)
@@ -7466,15 +9599,20 @@ def planets_cli():
     s = sub.add_parser("transitsearch", help="the census stars' TESS light curves searched blind for transits; a share with --part")
     s.add_argument("--part", help="K/N: the census's share, or with --validate the candidates'")
     s.add_argument("--validate", action="store_true", help="the search's candidates validated statistically instead")
+    s.add_argument("--first", action="store_true", help="with --validate, only the stars planets_validate_first names; exit 3 if the weighing ended early")
     s.add_argument("--backfill", action="store_true", help="the stored searches given their noise measures instead")
     s.add_argument("--tess", action="store_true", help="TESS's stars with SPOC two-minute light curves searched one at a time instead, into a TESS root")
+    s.add_argument("--ffi", action="store_true", help="with --tess, the stars only TESS-SPOC's full-frame light curves hold")
+    s.add_argument("--skip", type=int, default=0, help="with --tess, that many stars of the order passed over, for a second machine working far from the first")
+    s.add_argument("--dossier", help="NAME: everything the root holds on that star's transit signals, printed (planets_transit_dossier)")
     s.add_argument("--setup", help="with --tess, the data root this one is set up from as a TESS root")
     s = sub.add_parser("eccentric", help="the census's residuals searched by a Keplerian periodogram, merged where every star is; a share with --part")
     s.add_argument("--part", help="K/N: the census's share")
     s.add_argument("--perms", type=int, default=50, help="permuted sets in the null of a star whose best orbit passes --min-dchi2")
     s.add_argument("--min-dchi2", type=float, default=25.0)
     s.add_argument("--merge", action="store_true", help="the shares joined into candidates.csv")
-    sub.add_parser("calibrate", help="the blind census, run where it is missing, scored on the archive's planets")
+    s = sub.add_parser("calibrate", help="the blind census, run where it is missing, scored on the archive's planets")
+    s.add_argument("--wobble", action="store_true", help="the weighing's wobble rule set on Gaia DR3's published orbits and accelerations instead (planets_wobble_calibration)")
     sub.add_parser("benchmark", help="the census on stars whose answers are known: Proxima, alpha Cen A and B, and the Sun")
     s = sub.add_parser("system", help="a planetary system's case: models, aliases, stability, limits and figures")
     s.add_argument("star")
@@ -7507,6 +9645,16 @@ def planets_cli():
     s.add_argument("--max-snr", type=float, help="toi: the signal-to-noise ratio below which a candidate is taken")
     s.add_argument("--redo", action="store_true")
     s.add_argument("--benchmark", type=int, default=0, help="that many TOIs of each settled fate weighed and scored instead, into RESULTS/validate_benchmark")
+    s.add_argument("--shapes", action="store_true", help="the folded light's shape added to the passing records weighed before it was read, instead "
+                                                          "(planets_validate_shapes); with --part, that share of the records")
+    s.add_argument("--refine", action="store_true", help="the candidates that did not pass measured for their own ephemeris and weighed again where it moves them, "
+                                                          "instead (planets_validate_refine); with --part, that share")
+    s.add_argument("--control", action="store_true", help="the decision rules tried on confirmed planets, instead (planets_control)")
+    s.add_argument("--checks", action="store_true", help="the shape's harmonics, the dip's source and Gaia's RUWE and rotation added to the passing records, equal dips "
+                                                          "weighed at half the period, instead (planets_validate_checks); with --part, that share")
+    s.add_argument("--tess", action="store_true", help="the stars' TESS readings read again from each sector's detrended flux, instead (planets_tess_refresh); with --part, that share")
+    s.add_argument("--orbits", action="store_true", help="the stars' orbits sampled again by their conjunctions, instead (planets_orbits_refresh); with --part, that share")
+    s.add_argument("--second", action="store_true", help="the new planets' orbits tested in another spectrograph's archived spectra, instead (planets_second); with --part, that share")
     s = sub.add_parser("tois", help="TESS's planet candidates weighed with archived velocities from every source")
     s.add_argument("--source", nargs="+", choices=("dace", "eso", "rvcat"), default=["dace", "eso", "rvcat"],
                    help="DACE's velocities, the archive's HARPS spectra measured line by line and ESO's catalogue of HARPS pipeline velocities, each in turn")
@@ -7558,14 +9706,21 @@ def planets_cli():
     elif a.cmd == "merge":
         planets_merge()
     elif a.cmd == "transitsearch":
-        if a.tess:
-            planets_tess_root(a.setup) if a.setup else planets_tess_search(a.part)
+        if a.dossier:
+            planets_transit_dossier(a.dossier)
+        elif a.tess:
+            planets_tess_root(a.setup) if a.setup else planets_tess_search(a.part, a.ffi, a.skip)
+        elif a.validate and a.first:
+            first = planets_validate_first()
+            if first:
+                planets_validate_transits(part=a.part, names=first)
+            sys.exit(3 if planets_search_ends() else 0)
         else:
             planets_transit_backfill(a.part) if a.backfill else planets_validate_transits(part=a.part) if a.validate else planets_transit_search_all(a.part)
     elif a.cmd == "eccentric":
         planets_eccentric_merge() if a.merge else planets_eccentric(a.part, a.perms, a.min_dchi2)
     elif a.cmd == "calibrate":
-        planets_calibrate()
+        planets_wobble_calibration() if a.wobble else planets_calibrate()
     elif a.cmd == "benchmark":
         planets_benchmark()
     elif a.cmd == "tois":
@@ -7577,6 +9732,20 @@ def planets_cli():
         planets_weigh(a.star, a.steps, a.pmin, a.pmax, [float(x) for x in a.m1.split(",")] if a.m1 else None, a.extra)
     elif a.cmd == "ledger":
         planets_ledger(a.workers, a.most)
+    elif a.cmd == "validate" and a.shapes:
+        planets_validate_shapes(a.part)
+    elif a.cmd == "validate" and a.refine:
+        planets_validate_refine(a.part)
+    elif a.cmd == "validate" and a.checks:
+        planets_validate_checks(a.part)
+    elif a.cmd == "validate" and a.control:
+        planets_control()
+    elif a.cmd == "validate" and a.tess:
+        planets_tess_refresh(a.part)
+    elif a.cmd == "validate" and a.orbits:
+        planets_orbits_refresh(a.part)
+    elif a.cmd == "validate" and a.second:
+        planets_second(a.part)
     elif a.cmd == "validate":
         planets_validate(a.part, a.draws, a.runs, tuple(a.source), tuple(a.dispositions), a.min_snr, a.max_snr, a.redo, a.workers, a.candidates, a.benchmark)
     elif a.cmd == "lbl":
@@ -10543,13 +12712,13 @@ eclipses_ROOT = archive_data("eclipses")
 
 
 def eclipses_fetch(name, ra, dec, radius_arcsec=10.0):
-    """A star's TESS light curves within RADIUS_ARCSEC of a position: each sector's at its shortest cadence from SPOC, else TESS-SPOC, else QLP, quality-flagged (for QLP, any flag) and non-finite points dropped, each sector divided by its median; ROOT/lightcurves/<name>.npz (time in BTJD, flux, error, sector, cadence in minutes)."""
+    """A star's TESS light curves within RADIUS_ARCSEC of a position: each sector's at its shortest cadence from SPOC, else TESS-SPOC, else QLP, its PDCSAP flux or QLP's detrended flux, DET_FLUX or in its first releases KSPSAP_FLUX, quality-flagged (for QLP, any flag) and non-finite points dropped, each sector divided by its median; ROOT/lightcurves/<name>.npz (time in BTJD, flux, error, sector, cadence in minutes, whether the flux is PDCSAP's)."""
     warnings.filterwarnings("ignore")
     import lightkurve as lk
     from astropy.coordinates import SkyCoord
     import astropy.units as u
     res = lk.search_lightcurve(SkyCoord(ra * u.deg, dec * u.deg), radius=radius_arcsec * u.arcsec, mission="TESS")
-    T, F, E, S, C = [], [], [], [], []
+    T, F, E, S, C, D = [], [], [], [], [], []
     picked = {}
     for i in range(len(res)):
         rank = {"SPOC": 0, "TESS-SPOC": 1, "QLP": 2}.get(str(res.table["author"][i]))
@@ -10565,7 +12734,7 @@ def eclipses_fetch(name, ra, dec, radius_arcsec=10.0):
             lc = res[i].download(quality_bitmask="default")
         except Exception:
             continue
-        col = "pdcsap_flux" if "pdcsap_flux" in lc.columns else "flux"
+        col = next((c for c in ("pdcsap_flux", "det_flux", "kspsap_flux") if c in lc.columns), "flux")
         t = np.asarray(lc.time.value, float)
         f = np.asarray(lc[col].value, float)
         e = np.asarray(lc[col + "_err"].value if col + "_err" in lc.columns else lc.flux_err.value, float)
@@ -10576,13 +12745,13 @@ def eclipses_fetch(name, ra, dec, radius_arcsec=10.0):
         if ok.sum() < 100:
             continue
         med = np.median(f[ok])
-        T.append(t[ok]), F.append(f[ok] / med), E.append(e[ok] / med), S.append(np.full(ok.sum(), sector)), C.append(np.full(ok.sum(), key[1] / 60.0))
+        T.append(t[ok]), F.append(f[ok] / med), E.append(e[ok] / med), S.append(np.full(ok.sum(), sector)), C.append(np.full(ok.sum(), key[1] / 60.0)), D.append(np.full(ok.sum(), col == "pdcsap_flux"))
     if not T:
         print("%s: no TESS light curve" % name, flush=True)
         return None
     os.makedirs(os.path.join(eclipses_ROOT, "lightcurves"), exist_ok=True)
     path = os.path.join(eclipses_ROOT, "lightcurves", name + ".npz")
-    np.savez_compressed(path, time=np.concatenate(T), flux=np.concatenate(F), err=np.concatenate(E), sector=np.concatenate(S), cadence=np.concatenate(C))
+    np.savez_compressed(path, time=np.concatenate(T), flux=np.concatenate(F), err=np.concatenate(E), sector=np.concatenate(S), cadence=np.concatenate(C), pdcsap=np.concatenate(D))
     print("%s: %d sectors saved" % (name, len(T)), flush=True)
     return path
 
@@ -10791,8 +12960,8 @@ def eclipses_cli():
 publish_DOC = """The repository's files, made from the results of one or more data roots, each given as LABEL=DATA in order of precedence with its results
 under DATA/results; the solar, giants, transits and companions results are the first root's. Every root's planets tables are joined, each row led by its
 root, a new body that an earlier root's body matches in host and kind and within 5 per cent in period listed once, under the earlier root, with every
-root that found it. The new planets are planets.csv in OUT, and each mode's other results are files in a folder of its own, a .jsonl file holding
-one record a line and the .npz file of its name the records' numeric arrays, each under the key its record names.
+root that found it. The new planets are planets.csv in OUT, the new planets and companions orbitlight itself found discoveries.csv, and each mode's other results are files in a folder of its own, a
+.jsonl file holding one record a line and the .npz file of its name the records' numeric arrays, each under the key its record names.
 
     planets/      companions.csv, the new stellar and brown-dwarf companions; signals.csv, every signal with its decision and what orbitlight's
                   evidence contributes; validation.jsonl, every TESS candidate's statistical validation; followup.jsonl and
@@ -10808,11 +12977,15 @@ one record a line and the .npz file of its name the records' numeric arrays, eac
     python orbitlight.py publish OUT bank=DATA [LABEL=DATA ...]"""
 
 
+# an absolute path in a JSON string, a drive's or a home's, its last part kept
+publish_PATH = re.compile(r"(?<![A-Za-z0-9/])(?:[A-Za-z]:(?:\\\\|/)|(?<![A-Za-z0-9/])/(?:home|Users|root|mnt|tmp)/)(?:[^\"\s:;,()'/\\]+(?:\\\\|/))*([^\"\s:;,()'/\\]*)")
+
+
 def publish_lines(path, rows):
-    """ROWS, dicts, written to PATH as JSON Lines, a compact record a line."""
+    """ROWS, dicts, written to PATH as JSON Lines, a compact record a line, any absolute path in their text, as an error's message can hold, cut to its last part."""
     with open(path, "w", encoding="utf-8", newline="\n") as fh:
         for r in rows:
-            fh.write(json.dumps(r, separators=(",", ":")) + "\n")
+            fh.write(publish_PATH.sub(r"\1", json.dumps(r, separators=(",", ":"))) + "\n")
 
 
 def publish_load(path):
@@ -10865,6 +13038,7 @@ def publish_planets(out, pairs, save):
             kept.append(dict(r, roots=r["root"]))
     planets_write(os.path.join(out, "planets.csv"), [r for r in kept if r["kind"] == "planet"], found_keys + ["roots"])
     planets_write(os.path.join(out, "planets", "companions.csv"), [r for r in kept if r["kind"] != "planet"], found_keys + ["roots"])
+    planets_write(os.path.join(out, "discoveries.csv"), [r for r in kept if r["contribution"] == "discovery"], found_keys + ["roots"])
     planets_write(os.path.join(out, "planets", "signals.csv"), sig, sig_keys)
     current = {(r["root"], archive_tag(r["planet"])) for r in found} - twins
     ledger, keys = gather("ledger.csv")
@@ -10932,7 +13106,7 @@ def publish_planets(out, pairs, save):
     publish_lines(os.path.join(out, "planets", "validation.jsonl"), valid)
     cal = {}
     for key, name in (("summary", "calibration.json"), ("planets", "calibration_planets.csv"), ("unmatched", "calibration_unmatched.csv"), ("benchmark", "benchmark.json"),
-                      ("validation", "validation_benchmark.json")):
+                      ("validation", "validation_benchmark.json"), ("wobble", "wobble_calibration.json")):
         p = res(pairs[0][1], name)
         if os.path.exists(p):
             cal[key] = publish_load(p) if name.endswith(".json") else [{k: publish_cell(v) for k, v in r.items()} for r in planets_read(p)]