CDN, aislamiento medido y proponente de cazoleta
Browse files- docs/CONTRATOS_Y_TRAMPAS.md +68 -0
docs/CONTRATOS_Y_TRAMPAS.md
ADDED
|
@@ -0,0 +1,68 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
# Project workflow
|
| 2 |
+
|
| 3 |
+
- This is a private project. Do not publish, push, upload datasets or capture its findings in a global knowledge base.
|
| 4 |
+
- **Exception for the extraction dataset, widened by the user on 2026-09-09 after being shown the costs.** Two Hugging Face dataset repositories are in use: `EXCALORIO/fencingly-extraccion` (**private**: notebooks, helper code, docs) and `EXCALORIO/fencingly-datos` (**public**: poses, per-frame metric tables, the index including fencer names, and the 128×128 corridor crops). The reasoning the user gave and which stands: competition results with names are **published record** (FIE, and fencingdatabase.com, which is where the clips come from), so publishing them adds nothing already outside; and the public tier is **8.7 TB against 100 GB private**, which is what the growing payload needs. Two things were stated before the decision and remain true rather than resolved: fencingdatabase.com is **itself an aggregator, so it transfers no rights** — the underlying footage is the broadcasters' and this is second-order redistribution of 128×128 patches; and what is genuinely new in the public set is **biomechanical measurement attached to named athletes**, which published scorelines do not contain. The dataset card credits the source and licenses CC BY-NC 4.0. Do not widen further — no second service, no payload beyond extraction artefacts, no web application or scientific report — without a new explicit decision. The token is a credential: read it from a Colab secret or an environment variable, never hardcode it, never print it, and never write it into a notebook, a log or a report. Writing to the Hub requires a token **even for a public repo**; public only removes authentication for reading.
|
| 5 |
+
- Exactly **three** of the 119 index columns contain personal names — `fotl_name`, `fotr_name`, `bout_id` — measured by scanning all 119 for anthroponyms across 16,933 rows rather than guessing from column names, and covering 355 athletes. `clip_id` is a codename inherited from the source platform (`MixedDecisiveCurlew`), so clips are addressable without identity. The `.npz` files carry **no** names: verified by parsing `meta_json` and inspecting every text leaf, plus a substring search for all 355 names and 605 name tokens across every file. The first version of that check passed while measuring nothing, because it treated the 1,564-character `meta_json` as a single value that no anchored anthroponym pattern could match. The notebook keeps a `QUITAR_NOMBRES` switch, off by default, so the redaction path stays exercised and one line away.
|
| 6 |
+
- Storage note that makes the private tier sufficient: dense optical flow does **not** need to be stored. Recomputing it from the 128×128 corridor crops reproduces the video path **bit-exactly** at 394 ms/clip against 1,250, so ~45 GB of crops replaces ~550 GB of flow. Store what cannot be regenerated; regenerate what can.
|
| 7 |
+
- User preference: perform delivery verification with existing local files/dependencies only. Do not download external resources or retry restricted/denied access. Record the blocked step and defer it; no alternate hosts, credential changes or security-policy workarounds without a new explicit decision.
|
| 8 |
+
- Run CPU regression tests from the application root with `python -B run_checks.py`. A focused run accepts `--pattern test_pdf_scope_selection.py`. The runner isolates the default web workspace and caps numerical thread pools at one.
|
| 9 |
+
- Use a short local path on Windows. Deep staging directories can exceed Windows path limits for cache hashes and checkpoint filenames; do not change system policies to work around this.
|
| 10 |
+
- Start the packaged application with `python -B webapp_react/launch.py`. It resumes the last explicitly activated workspace. `--fresh` selects packaged data without deleting prior workspaces; `--work-dir` selects an explicit directory.
|
| 11 |
+
- The browser and optional third notebook use the same FastAPI backend and compiled React frontend. A production launch does not need Node.js or node_modules.
|
| 12 |
+
- UI style: premium sporting arena, native responsive controls, local sans fonts, explicit units/sample sizes and no invented ratings. Reuse `--arena-*`, `--hud-*` and shared components; respect keyboard access and reduced motion.
|
| 13 |
+
- UI reliability: normalize optional fencer metadata at the presentation boundary; invalid identities/responses stay explicit errors, not valid empty archives. Search retry must bypass invalid cached responses. Reading recents must not mutate the stored original. Country display-name formatters are shared per supported locale.
|
| 14 |
+
- Video-library state belongs in the `video_*` query namespace, separate from analytical/PDF scope. Preserve filters and clip selection across tabs/reloads/history, render the selected clip even beyond the first page, and avoid duplicate history entries for the same selection.
|
| 15 |
+
- UI language defaults to English, with Spanish and Italian persisted in Settings. New copy should use `t(en, es, it)`/`tr(en, es, it)`; structured source labels use local catalogs. Preserve proper names and identify untranslated original source documents. Do not add remote translation or flag/font services.
|
| 16 |
+
- Locale/contract checks use `python -B agents/ui_game_20260906_i18n/audit_i18n.py` and `node --experimental-vm-modules agents/ui_game_20260906_i18n/test_i18n.mjs` (Node 22.13+; no dependency installation required).
|
| 17 |
+
- Frontend source verification/build: `npm ci`, then `npm run build` from `webapp_react/frontend`. Preserve existing local outputs; the delivery copies only files referenced by the current Vite manifest.
|
| 18 |
+
- Portable notebooks are in `notebooks/` in the working repository and `../colab/notebooks/` relative to the packaged application root. The three historical notebooks under test fixtures are not the recommended workflow.
|
| 19 |
+
- Treat raw NPZ arrays, their semantic manifest bindings, temporal masks, producer descriptors and model conformance as separate contracts. Do not relax validators to make a stale artifact pass.
|
| 20 |
+
- Symptom: a fencer's page shows N clips of M and no error appears anywhere. Cause: `AnalysisRepository.index()` skips a directory of NPZ that has no `npz/index.csv` **silently**, so the clips do not exist for the app or for any measurement even though the files are on disk. An extraction worker that writes only `indice.jsonl` produces invisible output; 689 extracted clips sat unread this way on 2026-09-09, and earlier the same fault held one fencer's page at 180 of 587 for days. Generate `index.csv` as each shard closes, copy the column order from an index that already loads, and emit a row only when its `.npz` is present. Before proposing to compute or re-extract anything, measure the set at every link of `manifest ∩ index.csv(ok|cached) ∩ .npz in a registered dir` and find which link drops it.
|
| 21 |
+
- Second, deeper instance of the same class: `AnalysisRepository.valid_id` requires `[A-Za-z0-9_-]{1,200}`, so a **non-ASCII `clip_id` is dropped from the index with no error** even when its row is written and its `.npz` exists. Exactly 13 clips in the archive are affected (`Vicuña`, `Kauai‘Ō‘ō`, `Vendéen`; 7 right, 6 left, no doubles, 0.04%). Their downloads were separately fixed on 2026-09-09 by percent-encoding the request, but that recovery has **no effect through this reader**, so do not count them as extracted. Known and accepted gap: do not relax the validator to make them pass, and do not spend time hunting them as phantom clips.
|
| 22 |
+
- `producer_sha256` is **not** a hash of the 20 `MEASUREMENT_SOURCES` files. `measurement_artifacts._producer()` hashes the whole producer dict, which also carries `runtime_versions` (numpy, pandas, scipy), the effective constants of eight modules including the fitted stature calibration, `reporting_version`, the 68-column unit catalogue and `policy`. Measured: `.venv` and `.venv-gpu` (numpy 2.5.2) both give `3e1dbe0a…9827`, while `scratchpad/cuda/.venv` (numpy 2.5.3) gives `0645f2c8…8f1f` from byte-identical sources. (Before the 2026-09-09 guard-window alignment those two values were `0b87d014…3c4f` and `874c1ca9…6533`; the motion producer moved from `994c874b…2658` to `6c9fa66b…3ce7` in the same change, because `measurement_artifacts.py` is in both source lists.) A numpy patch release invalidates every cached artefact and the failure is a silent cache miss, not an error. Check with `measurement_producer()["producer_sha256"]`, and materialise measurements only from an interpreter pinned to the production versions. A frozen source copy is fine to extract with and must never be used to measure.
|
| 23 |
+
- `export_measurements` and the batch path `coach_panel.py:279` must anchor the analysis window the same way: both pass the sample through `_ventana_de_analisis` before measuring. The artefact producer was the only one of the two that did not, and it was aligned on 2026-09-09. On the 15,452 clips extracted with `pre_s = 4.0` the crop is a measured no-op — it returns **the same object**, with `a == 0` and `b == total` in all of them — so those artefacts rematerialise to identical values under a new fingerprint. Four of them are a no-op via `b - a < minimo` (12 frames) rather than `a == 0 and b == total`: they are the very low fps clips (down to 1.66) whose whole stored window is under 12 frames, and they would be the first to start cropping if that threshold were lowered. On long windows the crop **does** correct: the `scratchpad/detector/ws/*` NPZ carry a median 7.5 s of pre-roll (max 15.97 s), the crop fires on 78 % of them, and the guard values move by up to 269° in `aw_fore_ang_guard` and 4.95 m in `dc_dist_guard_m`, with per-column r of 0.06-0.35 — so artefacts written for those clips before the alignment measure the guard about 7.5 s before the touch and are wrong without any flag. `poses.shape[0] == n_frames_window` held on all 15,452 clips of the `pre_s = 4.0` corpus, so full-duration NPZ entered the archive only with those detector shards. Vía documented and not taken: `export_cached_motion:712` and `analysis_service.py:570` still measure on the raw sample, but they are consistent with each other and aligning them would require putting `coach_panel.py` into `MOTION_SOURCES`, where it is not.
|
| 24 |
+
- `export_measurements` refuses to overwrite an artefact whose producer differs (`use a new workspace version, never overwrite history`), so a fingerprint change cannot be rematerialised in place: it needs a new dated workspace under `localrun/runs_full/` and a server repointed at it. The workspace the server uses keeps `npz/index.csv` but **no** `.npz`; the arrays come from the dirs passed as `--npz-dir` to `launch.py`, which forwards them to the server as `FENCINGLY_NPZ_DIRS` (`launch.py:84`) rather than on the server's own command line — so `ps` on the server process shows no NPZ dirs even when eight are registered. `AnalysisRepository.index()` resolves `_npz_path` as `index_dir/<clip_id>.npz` and keeps the **first** registered dir on a duplicate `clip_id`, so when the same clip exists in two extractions the `--npz-dir` order decides which window the web serves; materialise against that same order, or the artefact's `input_npz_sha256` will not match the NPZ the reader resolves and every lookup becomes a silent cache miss.
|
| 25 |
+
- Run the full battery with **`scratchpad/fz/.venv`**, not `.venv-gpu`: the reference 1,321 / 0 failures / 0 errors / 31 skipped needs the web layer, and `.venv-gpu` has no `fastapi`/`starlette`, which turns the API and web-workspace modules into 34 import errors and silently drops the run to 1,233 tests / 16 skipped. Both interpreters give the same `producer_sha256`, so `.venv-gpu` stays correct for materialising; only the battery needs `.venv`.
|
| 26 |
+
- Pose interpolation is not video interpolation or new observed evidence. Pixel/torso/leg units are not independently calibrated metres. Event/light anchors are not verified contact times.
|
| 27 |
+
- Official FIE publications, local fragments, individual bouts, relays and team totals have different denominators. Missing values must not become zeros or inferred final results. Boolean flags must not become numeric scores; use the shared numeric score coercion and preserve invalid source values.
|
| 28 |
+
- Signal handling: a single detected valid light is an apparatus hypothesis, not an ML probability or an official ruling. Two lights must not be awarded from first-light order or greater speed. Keep movement hypotheses, detector events and source winners distinct; invalid/nonintegral/boolean light counts and inconsistent onset metadata are not valid single-light examples.
|
| 29 |
+
- Referee uploads require an explicitly chosen weapon in the UI, sent in the `/api/judge` query parameter `weapon` (`foil`, `epee` or `sabre`); the API may retain an unknown weapon for older clients but must never infer foil from the model. Preserve `diagnostics`, including decision source and audio availability, in both success and failure responses.
|
| 30 |
+
- Never wrap/replace `infer.model_probs` for web timing: portable v3 verifies that callable and its live identity. Preserve the neural binding and the gate; omit an unavailable stage timer rather than modifying verification receipts or fingerprints. The API/native bridge must be checked with an actually loaded portable model, not just separately mocked layers.
|
| 31 |
+
- Symptom: `load_bundle` starts failing with `ContractError: Portable: semantica AST/configuracion no conforme`, the app silently runs with no neural model, `judge` reports `model_unavailable`, and the only trace is `STORE.model_error`. Cause: `portable_contract.semantic_manifest` hashes every UPPERCASE module-level name of `infer.py`, import aliases included, not just `model_probs`. Adding one two-letter alias such as `from . import x as PH` changes `configuration_sha256` and invalidates every trained bundle. Use a lowercase alias and `_UPPER` for module constants; `test_priority_two_lights.py` pins the allowed list, and adding a public uppercase name means re-exporting the bundle on purpose in the same change.
|
| 32 |
+
- Rule confidences in `rules_fie_v2.PARAMS["conf"]` are measured accuracies shrunk toward 0.5, not calibrated probabilities, and `judge` publishes them to the client as `reglas_confianza`. Re-derive them with `rules_fie_v2.calibrate(rows)` against labelled outcomes and update `CONF_PROVENANCE` in the same change; never hand-write a value. Rules below 0.5 are worse than a coin flip on two lights and must keep saying so. They never gate a branch, so changing them cannot move a decision.
|
| 33 |
+
- `SignalTrainingRecipe` is opt-in; `TrainingRecipe` defaults and F78 native feature semantics remain separate. Focused selection uses only declared consistent two-valid-light validation rows for native early stopping/pruning. Never fall back to one-light validation or test. Audit light/audio coverage per split before claiming an improvement; finite zero audio values are not missing audio.
|
| 34 |
+
- Signal regression checks: `python -B run_checks.py --pattern test_signal_training.py` and `--pattern test_api_judge_signals.py`. Augmentation profiles are `none`, `flip`, `conservative`; timewarp remains disabled in the supported recipes. Compare seeds as repetitions, not favourable hyperparameter choices, and preserve source data/old Stores rather than rewriting their compatibility fingerprints.
|
| 35 |
+
- `HistGradientBoostingClassifier(early_stopping='auto')` turns early stopping on only above 10,000 training rows, which adds a random validation split and makes seeds matter. Seeds are currently bit-identical **by size, not by luck**: both stochasticity sources are off because a fold trains 2,836 pairs = 5,672 rows, and `max_bins=255` is far below the 200,000 rows that trigger binning subsampling. Note the threshold tests the row count **of the fit call, not of the population**: the two-light block is 4,958 pairs and crosses 10,000 rows with the mirror at ~5,116 pairs, but a cross-validated fold stays ~41% under even then, so **the crossing does not affect LOTO/GroupKFold evaluation at all**. It bites only on a fit over the full population: a final export, or seed-averaging across all data. Set `early_stopping` explicitly rather than leaving it on `'auto'`, so estimator behaviour does not depend on how many clips were extracted last night. `prio2/e1_tabular.hgb` pins it (the kwarg travels in `**d` outside the call parens, so a regex audit false-negatives it); `prio2/e10_afina.hgb_semillas` was the one unprotected site and was pinned on 2026-09-09 — it is the site that matters most, because it exists to average over `random_state=100..104` and would otherwise stop being comparable to the pinned config it exists to tune.
|
| 36 |
+
- A feature block's null control must match the feature's type. The circular time shift is a permutation of the window, so window means and peaks-by-absolute-value are invariant by construction: it left `d_ext_media` and `d_com_masa_media` at r = +1.000 and `d_com_frac_avanza` at +0.993, which is the column with the most univariate signal. It also **inflates** derivative features, because `np.roll` leaves a seam that becomes a large derivative (`d_com_a_min` at 7.79x scale). The phase surrogate preserves `F[0]`, the mean. Neither failure is visible in the aggregate metric. For level features use the random side-sign null, which destroys side information while preserving marginals, inter-column covariance and per-clip magnitude; it reproduced the published 0.8 pp floor from scratch at +0.82 pp.
|
| 37 |
+
- The 128 px interaction-corridor crops in `scratchpad/vorticidad/recortes/` (4,865 clips, the dataset intended to spare Colab any video decoding) **contain the FIE scoreboard band in 2,272 of 3,006 measured clips (75.6%), a median 18% of the crop**, and at the touch anchor that band shows the lamps themselves: a green stripe on one side and a red stripe on the other, asymmetric by side, inside the model input. Mask it (grey out `y > 0.82·H`) in any experiment on these crops. **Correction of 2026-09-09: `0.82·H` is not sufficient.** In `BlindWellwornJunco` the referee's own scoring box, lamps included, sits **above** that line and inside the crop. For any experiment whose target is the label, that mask leaves a leak; detect the box rather than assuming a fixed row.
|
| 38 |
+
- Blade visibility is a limit of the **material**, not of the models, and it is now closed twice over. Classical route: 10 clips × 9 methods (LSD, Hough, Canny, Sato, Frangi, tophat, temporal difference, flow, Radon) in `scratchpad/hoja_resultado/resumen.json` — **8 of 9 detect 0.00**, only `radon_mano` reaches 0.29. Tracking route (2026-09-09): SAM2.1-large returns a blade-shaped mask in **2 of 15 clips (13 %)**, and the reason is architectural rather than tunable — at broadcast 1080p the blade is **1–2 px wide** while SAM2's mask decoder emits 256×256 logits for a 1024 input, i.e. a **4 px minimum grain**, so the object is thinner than the model's output cell. Video memory itself works: where it latches on, it tracks the blade 61 of 73 frames without re-prompting. More frame rate does not help, because the limit is spatial (best and worst case were both at 60 fps), and a human located the blade with confidence in only **6 of 15 clips**. If ever retaken, the only lever with physical meaning is material with more pixels per blade — native close-ups, not rescaled replays — never a better model. The 128 px corridor crops are unusable for this by construction: they reduce an ~847 px box to 128, a 6.6× loss.
|
| 39 |
+
- Validate any geometric detection against the metric scale before believing it. The dominant false positive in the blade study was the edge of the piste band: a bright diagonal measuring 287 px where the fencer's scale (157 px/m) implies 141 px for a 0.9 m blade. Without that length check the study would have reported two false hits.
|
| 40 |
+
- **Clips above 30 fps are not "the same material, faster."** A substantial part are slow-motion replays with close framing, and some carry shot cuts inside a 1.2 s window. Their velocities are distorted by construction, so native-cadence extraction stores a false velocity faithfully. Cross frame rate against `reloj_parado_todo_el_clip` (a replay is broadcast with the clock stopped), `dup_rate` and `cuts` before treating high-cadence clips as the finest-motion subset. Measured consequence: with the band visible the delta is +0.28 pp and AUC 0.5631, no better than masked, so the shortcut was served and one representation happened not to exploit it — an unexploited leak is not a safe leak.
|
| 41 |
+
- A circular time-shift null is **nearly inert on a mean-pooled embedding**: pooling 1,568 tokens already erases temporal order, so the shifted embedding has cosine 0.9980 with the real one. Using it as a null over pooled representations tests nothing. This is the third distinct way this null fails, alongside preserving level features and inflating derivative ones; pick the null from what the representation actually encodes.
|
| 42 |
+
- Never evaluate a feature inside a subgroup defined by the outcome. `gana_enciende` is whether the *winner* lit first, and `accion` is defined relative to the outcome (for `parada-respuesta` the scorer attacked), so conditioning on either fixes the correspondence between "who extended" and "who won" and any extension feature predicts the label by definition: AUC 0.895 inside blade actions against 0.224 outside, sign flipping with the label. Inside such a region the base falls below chance, and there an information-free block bought +3.08 pp. The verdict is always the global paired number; the subgroup is a description of where the gain landed, never the evaluation population, never an optimisation target, and never a routing gate.
|
| 43 |
+
- Blade image evidence is experimental and separate from hand-motion proxies, F78 and referee decisions. A thin line near a wrist is insufficient: reject broad/background edges, require root-axis support, keep hand identity as a hypothesis, and treat rival/shared-pixel alternatives as ownership ambiguity. Missing geometry must not be drawn as an observed continuation.
|
| 44 |
+
- Build explicit local reviews with `python -B tools/build_blade_review.py --video <local-file> --start-frame <a> --end-frame <b> --weights <existing-local-weights> --output <new-root>`. The producer bounds windows to 300 frames and a 512 MiB decoded-window RGB budget, not a total-process RAM cap; pose/model/temporary buffers need additional memory. It never downloads weights and never overwrites an existing review. Audio is not required by this visual layer.
|
| 45 |
+
- Blade artifacts keep `human_verified=false`, `tip_verified=false`, priority unset and contact unverified. Selected-candidate counts/lengths are not detection accuracy, physical blade length, parry counts or technique ratings. Reference examples are explicitly separate from workspace-derived reviews; current candidate quality is not sufficient for automatic priority or athlete statistics.
|
| 46 |
+
- Blade review UI: `/blade-lab`, also via the clip viewer used by fencer/bout pages. `GET /api/blade-reviews`, `/api/clips/{id}/blades` and `/api/clips/{id}/blade-frame/{index}` only read precomputed artifacts/images. Fingerprints, revision, dimensions and actor slots must agree; hide overlays on stale, missing or mismatched images. An invalid preferred artifact must not fall back silently to an older reference.
|
| 47 |
+
- Blade verification uses `test_blade_evidence.py`, `test_blade_artifacts.py` and `test_api_blade_reviews.py` with the CPU runner. Review raw/candidate images, including false positives and ownership failures; do not promote assistant visual review to independent human gold.
|
| 48 |
+
- Grouped training evaluation must aggregate each group's indexed rows, not rescan full prediction vectors per group. Preserve exact metrics, abstentions and original row order; the focused training-recipe tests check both parity and row-visit cost.
|
| 49 |
+
- The historical 81-label pseudo-gold is LLM-labelled, not independent human ground truth. CPU tests and portable-conformance fixtures do not establish sporting accuracy or actual Colab/CUDA compatibility.
|
| 50 |
+
- Scientific-paper preference: the EN/ES/IT LaTeX should explain analytical entities, score ordering, poses/signals, measurements, experiments and limitations. Exclude web/API/retrieval/deployment documentation from all article chapters and appendices; keep operational instructions outside the article. Regenerate appendices from the scientific generators rather than restoring historical product ledgers.
|
| 51 |
+
- Article PDF compilation is explicitly deferred. The dark web reports are separate products; do not build a placeholder article PDF or modify network/security settings to obtain TeX tools.
|
| 52 |
+
- **Never monkey-patch a module in `SEMANTIC_SCOPE` before calling `build_store`: it poisons the store permanently.** `build_store` calls `runtime_compatibility()` on its own and writes the result into `store.json`, and that value hashes `_module_bindings_sha256(dataset)`. A hot wrapper around `dataset.load_sample` therefore freezes a hash that no clean process can reproduce, and every later open fails with `ContractError('Bindings runtime incompatibles: dataset.py')` — the store is unopenable for good, with perfect data inside it. Checking that the caller never invokes `load_bundle`/`save_bundle` is **not** sufficient, because `build_store` reaches the same check by another path. To change what a store ingests, write trimmed NPZ to a new directory and leave `load_sample` untouched.
|
| 53 |
+
- Store alignment must be proven on the material that will actually be stored, not on the window. With full-duration NPZ and no explicit trimming, `store_truncated` fires on **6 of 6** clips and the touch-to-end distance runs to a 1.633 s median (max 3.900 s) against 0.566 s when trimmed. Right-alignment with head truncation means the guard window disappears silently, so saving and training are two separate controls and the training slice is always explicit.
|
| 54 |
+
- Cadence: separate "has duplicates" from "is slow motion", because the first is the corpus and the second is a rounding error. In the 15,452 clips with `dup_mode` measured, the 30 fps band is **8,503 clips of 11,211 (75.8 %) on 25→30 telecine**, `dup_rate` 0.164 with an exact 6-frame period — one repeated frame in six, which is what a derivative actually has to survive. **50 fps has zero clips with a regular pattern**, so its 20 ms step is genuine. Only **54 clips (0.35 %) are multiplied at ratio ≥ 2**, with ratios up to 12.0, i.e. eleven zero-velocity frames followed by one twelve times too fast. Carry `src_fps` and `fps/src_fps` as columns; nominal cadence alone is not the sampling interval.
|
| 55 |
+
- `dup_mode` is measured on 15,452 of the 29,220 clips that have `fps` (52.9 %), and that subsample is **not random with respect to the census** — it is what got processed, and the unprocessed residue is known to be biased (detection rate correlates r = −0.861 with the fraction already extracted). Report the census total and the measured rate each with its own n; never multiply one by the other.
|
| 56 |
+
- "High cadence" is largely one venue. All 877 clips at ≥ 50 fps come from **three** tournaments, and **637 (72.6 %) are `tokyoolympics2020`**; the 154 clips with a detected shot cut are all from the same venue. Any contrast computed across cadence bands is therefore confounded with venue and must not be read as an effect of frame rate.
|
| 57 |
+
- **The "blade is sub-pixel, therefore undetectable" argument is wrong, and the 2026-09-09 closure of blade segmentation must be read narrowly.** The width arithmetic is right — the forte is ~4 mm, so 0.43 px at 480p, **0.64 px at 720p**, 0.96 px at 1080p, and only 1.92 px at 4K — but detectability does not follow from width, because **contrast compensates**: a sub-pixel bright object against a dark background still leaves a detectable intensity ridge. Rendered frames settle it. At 1080p (Tokyo, dark blue background) the blade is plainly visible as a thin bright streak, and at **720p the guard is unmistakable in every frame** as a bright metallic blob, matching the predicted 19 px. What is closed is **zero-shot** localisation, not localisation: Grounding DINO with text prompts boxes the guard correctly with `sword handle` at 0.20–0.32 in some frames and then drifts to large high-contrast distractors — Olympic rings as `a metal disc`, a yellow barrier, the arm. Declared before measuring, over runs of 15 consecutive frames: detection rate ≥ 70 %, centre jump ≤ 1.5× the wrist's own displacement, area CV ≤ 0.50. Result **0 of 12 cases**, with detection rate **100 %** and failures entirely in consistency (10 of 12 on jump, 9 of 12 on area) — it always finds something of roughly the right size and rarely the same thing twice. Positive controls both passed, so the negatives are informative: SAM2 on a hip returns 42,651 px, and the text prompt `a person` finds fencers at 0.57–0.75 in 7 of 7 clips.
|
| 58 |
+
- **Guard localisation is open, not closed, and the route is SAM3 text prompts on an upscaled crop.** Measured 2026-09-09 with a verbal decoy control: on crops around the armed wrist upscaled 8×, over **120 crops per word** and counting a crop with no detection as a failure, `the hilt of a sword` fires in **0.62** and **places within one guard diameter in 0.33**, against **0.05 / 0.04** for `a banana` and **0.72 / 0.61** for the `a hand` control — a margin of **+0.29** over the decoy, which matters because the crop is centred on the prior and a box anywhere inside it would land close by construction; the decoy's 0.04 is what proves the prior is not doing the work. An earlier version of this entry claimed **71 % / 53 % / 25 %** by resolution: that was computed over returned boxes with n=4–20 per cell rather than over crops, and with n=120 the rates are 0.20 / 0.55 / 0.23 for 480/720/1080, so **there is no clean resolution trend** and the headline is 0.33. `a thin metal rod` fires as often and places worse (0–45 %). **`a bell guard`, the actual domain term, returns exactly nothing (0.00) everywhere** — the phrasing dominates the result, so never conclude from one wording. Two hard constraints on any pipeline built on this: the object must be **cropped and upscaled** (on full 1920-wide frames every sword word returns ~0 instances at scores 0.03–0.13, while `a person` returns 2–23 at 0.96–0.97, so the failure is scale, not vocabulary); and **the confidence score cannot be used to filter**, because hits average **0.238** and misses **0.253** — misses score higher. Filter with the geometric prior instead: wrist + 0.6 guard diameters along the forearm, which the rendered crops confirm is well centred on the guard.
|
| 59 |
+
- SAM2-video propagation cannot be validated by temporal consistency, and the control proves it. Seeding a box at the expected guard passed a declared consistency criterion in **11 of 12** cases — and seeding the mirrored box **into the body, where no guard exists**, passed in **10 of 12**. Propagation tracks whatever it is given, smoothly, so a smooth track is not evidence of having found anything. Any propagation-based labeller needs annotation or an independent discriminator, never self-consistency.
|
| 60 |
+
- Clips are reachable directly at `https://clips.fencingdatabase.com/<tournament>/<clip_id>.mp4`; the HTML pages return 403 to non-browser clients, which is what made the site look inaccessible. Measured on `hongkongfoil2026`: **1920×1080 at 60 fps**, so newer material gains cadence (16.7 ms steps) but **not resolution** — it is 1080p like turin/tokyo, so the blade-width arithmetic is unchanged and only 4K would move it.
|
| 61 |
+
- A geometric acceptance criterion invented in place of ground truth will admit the wrong object. The first guard test scored 5 of 10 by taking whichever of SAM2's three returned masks fitted the expectation — including one SAM2 itself rated **IoU 0.013**. Taking SAM2's own best mask instead gives **2 of 10**, and the rendered crops show those two are **the glove**, not the guard: a 15° minimum separation from the forearm axis cannot exclude a hand, because the wrist bends and the glove always sits slightly off-axis. Judge a localiser against annotation or against temporal self-consistency, never against a threshold chosen to match a mental picture.
|
| 62 |
+
- **`np.unwrap` is cumulative, so a single NaN poisons every sample after it.** Applied to a whole angle series it silently dropped angular-velocity coverage from 0.846 to **0.577** with no data actually missing — the operator was erasing it, not the source. Unwrap per contiguous finite run. This is the third data-destroying operator of its family in this project, alongside the circular null preserving level features and the whole-clip median contaminated by the replay it was meant to detect; the shared tell is an operation whose output looks plausible while its input assumption is violated.
|
| 63 |
+
- **Pooled and paired statistics can disagree in sign, and only the paired one is valid here.** For the forearm-axis control the *pooled* medians say the touch angle (24.0°) is smaller than guard (29.4°) — which reads as passing — while the *paired* per clip×side difference is **−2.9°**, a coin flip. Pooling mixes clips with different frame counts, so long clips dominate the pool; the unit of analysis is the clip×side, never the frame. Quoting the pooled figure would have reported a false pass on a control the signal does not clear.
|
| 64 |
+
- Redundancy between features is measured with **mean |r|, never mean signed r**. Because the side convention is antisymmetric (`FACING = {L:+1, R:-1}`), clips of opposite sign cancel: the same pair gave signed mean **−0.243 with max 0.997** — reassuring and wrong — against a mean |r| of 0.166. A signed mean near zero is what perfect correlation looks like after cancellation.
|
| 65 |
+
- A control that only passes on the scoring fencer has not passed. The forearm-axis-vs-opponent proxy failed its pre-declared control (median guard−touch **−15.0°**, expected sign in only **12 of 36**, 33.3 %), and restricting to the scorer would make it pass — which is conditioning on the outcome and forbidden above. Two candidate mechanisms were excluded first: it is not a distance proxy (global r **+0.155**, per clip×side median +0.046, non-monotonic deciles), and ill-conditioning at contact is only partial (the angle does fall with distance inside the touch window, 18.96° at 0.19 to 112.46° at 0.57, but the IQR doubles, **99.9° vs 53.9°**). The direction is genuinely undefined when elbow and wrist nearly coincide through foreshortening, which no average shows — only the rendered frames did.
|
| 66 |
+
- Forearm angle already exists as `forearm_ang` in `features.FENCER_NAMES`; what does not exist is its **derivative**. `arm_ext_v`, `wrist_vx/vy`, `wrist_speed` and `wrist_acc` are all present, so add angular velocity, not the angle. And pick the armed wrist with `clip_stats.dominant_hand(P, side, end, fps)`, which returns hand, wrist index 9/10 and a confidence in [0.5, 1] from two indicators; a highest-mean-confidence heuristic instead correlates only **0.468** with `forearm_ang` because it selects a different wrist, i.e. in some clips it measures the wrong arm.
|
| 67 |
+
- Referee deliberation time is a corpus limitation, not a detector one: it is measurable in **2 of 24 clips (8.3 %)** because **the clip ends before the referee restarts the clock** (median deliberation 1.56 s where defined, post-touch tail 1.84 s). Full duration is necessary and **not sufficient** — extracting better cannot recover it, only clips cut later can. Any era or venue effect on deliberation must be measured **within venue** before it is believed.
|
| 68 |
+
- Broadcast replay inserts contaminate poses **with no alarm on any existing check**. A clip opening on tight replay close-ups with a wipe transition, then cutting to the live wide shot, scores pose coverage **1.000 on both fencers**: the detector finds them because they are genuinely there, only at a different framing and scale, so falling coverage never fires and `cuts` reports 1 where three shots are visible. Four detection routes were tried and none discriminates; normalising box height by the whole-clip median fails because the insert is half the clip and **contaminates the normaliser with the thing it should detect**, and normalising by the touch window gives 1.58 against a clean clip's 1.32, which overlaps. `escala_r` ships as a raw continuous column (defined in 91.8 % of frames, NaN meaning undefined and not zero, precision: no reference) and replay detection stays a declared gap. Do not lower a threshold to make a positive control pass.
|