Publish Trackformer 1.2 announcement assets and matched DeepMind benchmark protocol

.gitattributes

@@ -195,3 +195,4 @@ evaluation/storm_structure/meranti_wind_radius.png filter=lfs diff=lfs merge=lfs
 evaluation/storm_structure/soudelor_wind_radius.png filter=lfs diff=lfs merge=lfs -text
 evaluation/release_data/pressure_core/mangkhut/common-pressure.npz filter=lfs diff=lfs merge=lfs -text
 evaluation/released_daily/pressure_comparison.png filter=lfs diff=lfs merge=lfs -text
+evaluation/released_daily/model_1_2_benchmark.png filter=lfs diff=lfs merge=lfs -text

docs/deepmind_daily_benchmark.md

@@ -0,0 +1,43 @@
+# Matched WeatherNext Cyclones Mini daily benchmark
+
+## Model and frozen plan
+
+The reference is Google's official [WeatherNext Cyclones Mini](https://github.com/google-deepmind/weathernext), the released `<2024` checkpoint trained through 2023—not a custom imitation or full-sized WeatherNext. It runs one seeded member using the existing JAX CPU runtime on the Mac. This is a new benchmark; scores remain pending until saved forecasts and the full verification receipt exist.
+
+- Cohort: **1,473 daily starts / 270 Western Pacific storms**, identical to the frozen Trackformer 1.1/1.2 route comparison.
+- Forecast: twenty six-hour steps, **+6 to +120 h**, with the exact observed issue-time centre as the initialized-storm anchor.
+- Inputs: exact ERA5 analyses at **issue−6 h and issue**, calendar forcings only after issue. No future weather, storm labels or official forecast tracks enter the worker.
+- Weights SHA-256: `a1bb151457077248d70a458b1a7b19deacd2926fbcb46eee4ff2691444e3596e`.
+- Cohort SHA-256: `965184f1e5ab3fcb52e304f39b38583a14f753870aa2295f2d01942a441dcfd6`.
+- Official code commit: `89c4b2a77a1c57b328b909c575550fd2e5aadc9c`.
+
+## Like-for-like scoring
+
+All three models use the frozen starts, exact future label times and original issue-relative kilometre projection. Routes are unshifted. Direction is recomputed on **common moving steps across truth and all three models**, not compared using different masks.
+
+Pressure uses the original 134 eligible native-intensity starts / 40 storms, restricted to common valid leads across three predictions and the selected reference. JMA and USA remain separate. MAE and centred time-curve similarity are separate; missing, nonphysical or failed outputs are not zeros. Flat or shorter-than-six-point curves have unavailable shape similarity.
+
+Average valid leads within an issue, days within a storm, then storms equally. Partial aggregates contain only fully completed storms and explicit coverage. Recent 2024+ and historical 1980–1999 groups are separate because the latter overlap WeatherNext fitting years. Different input pipelines and the one-member Mini versus 50-input-member 1.2 policy make this an output comparison, not an equal-compute architecture ablation or a certified unused test.
+
+The official six-hour direct tracker uses a frozen initialized-storm continuity policy: no cyclogenesis, no dissipation pruning and no nearby-cyclone pruning. This is disclosed rather than called the operational default. Native 1° WP MSLP grids are saved in physical hPa; cyclone-head central pressure is not the basin-grid minimum.
+
+## Execution and verification
+
+The [resumable runner](../release_tools/deepmind_daily_benchmark.py) freezes source hashes, the cohort, original baseline forecast hashes and checkpoint identity. Workers save exact input-state hashes, twenty route points, central-pressure values/masks and twenty native WP grids. Future truth is read only **after** inference for scoring; Trackformer forecasts and weights are unchanged.
+
+Local output: `/Volumes/D/typhoon_predict/output/deepmind-daily-20261002`. `progress.json` records on-disk coverage; `logs/` holds diagnostics. `verification.json` is produced only after all 1,473 cases pass the final audit. These are local results, not automatically published Site API data. No score is uploaded before review.
+
+Existing Mac runtime and weights are reused without package installation. Earlier CPU rollouts suggest **several days** for the full run; retrieval and compilation affect the total. All generated states, caches and outputs stay on `/Volumes/D`. Cloud backfill, training and Site deployments are untouched.
+
+```bash
+# Existing compatible WeatherNext environment and project assets required.
+python release_tools/deepmind_daily_benchmark.py prepare \
+  --project /Volumes/D/typhoon_predict \
+  --output /Volumes/D/typhoon_predict/output/deepmind-daily-20261002
+
+python release_tools/deepmind_daily_benchmark.py launch \
+  --project /Volumes/D/typhoon_predict \
+  --output /Volumes/D/typhoon_predict/output/deepmind-daily-20261002
+```
+
+`prepare` is only for a fresh directory. `launch` refuses an active run; `run` resumes completed cases without repetition. Source retrieval has bounded retries and failures remain visible. Final completion requires all planned cases, exact leads, valid routes/fields, unchanged forecast hashes and the verification receipt—not a process exit or count alone.

docs/showcase_archive.md

@@ -0,0 +1,30 @@
+# Forecast examples and diagnostics
+
+The [model announcement](../README.md) features the geographically registered moving-core Mangkhut (2018) forecast. Its 50-member arrays and replay/playback receipts are linked there. These are development illustrations, not representative or untouched-test evidence.
+
+## Additional films
+
+These earlier 50-member films retain a fixed issue-relative regional pressure patch. When the centre leaves it, only the saved coarse basin field covers that position. They use 4 hPa isobars and 23-second playback with a held ending; do not confuse them with the current moving-core Mangkhut rendering. Their original model outputs remain preserved.
+
+- [Fung-wong (2025), 7 November 00 UTC](https://huggingface.co/euler314/typhoon-predict/resolve/87a6e366b42bb4cc0edc95d2c50c55fca21a2c93/docs/trackformer_1_2_fung_wong.mp4) · [provenance](../evaluation/release_data/fung_wong_video.json)
+- [Soudelor (2015), 5 August 00 UTC](https://huggingface.co/euler314/typhoon-predict/resolve/87a6e366b42bb4cc0edc95d2c50c55fca21a2c93/docs/trackformer_1_2_soudelor.mp4) · [provenance](../evaluation/release_data/soudelor_video.json)
+- [Meranti (2016), 10 September 00 UTC](https://huggingface.co/euler314/typhoon-predict/resolve/87a6e366b42bb4cc0edc95d2c50c55fca21a2c93/docs/trackformer_1_2_meranti.mp4) · [provenance](../evaluation/release_data/meranti_video.json)
+
+## Wind and structure
+
+[Four-storm wind comparison](../evaluation/storm_structure/four_storm_wind_candidate.png) · [audit index](../evaluation/storm_structure/index.json) · [experimental structure method](../release_tools/STORM_STRUCTURE_DIAGNOSTICS.md)
+
+USA one-minute and JMA ten-minute winds are separate references. Native 1.1 RMW and quadrant R34/R50/R64 are scored against matching USA definitions. Trackformer 1.2 has an auxiliary maximum-wind scalar but no native radius head. Its pressure-derived radius candidate is not an official-equivalent prediction; masked/persistent components are not learned radius forecasts.
+
+| Storm | Exact-time comparisons | Data and assumptions |
+| --- | --- | --- |
+| Fung-wong | [Plot](../evaluation/storm_structure/fung_wong_wind_radius.png) | [Record](../evaluation/storm_structure/fung_wong_structure.json) |
+| Soudelor | [Plot](../evaluation/storm_structure/soudelor_wind_radius.png) | [Record](../evaluation/storm_structure/soudelor_structure.json) |
+| Mangkhut | [Plot](../evaluation/storm_structure/mangkhut_wind_radius.png) | [Record](../evaluation/storm_structure/mangkhut_structure.json) |
+| Meranti | [Plot](../evaluation/storm_structure/meranti_wind_radius.png) | [Record](../evaluation/storm_structure/meranti_structure.json) |
+
+## Full evaluation
+
+[Daily protocol](daily_storm_benchmark.md) · [all daily scores](../evaluation/daily_storm_final.json) · [intensity/radius protocol](intensity_benchmark.md) · [native intensity results](../evaluation/intensity/intensity_final.json) · [matched pressure curves](../evaluation/released_daily/pressure_comparison.png)
+
+Route uses 1,473 starts / 270 storms; the matched native pressure comparison uses 134 starts / 40 storms. JMA pressure MAE falls from 13.53 to 12.84 hPa, with paired uncertainty including zero. JMA curve similarity is 0.7074 / 0.7118 (1.1 / 1.2), while USA curve similarity is 0.7237 / 0.6637 on 131 eligible days—a regression. A centred shape score discards level and amplitude and must be read with physical hPa timelines, not used to conceal pressure errors.

evaluation/released_daily/model_1_2_benchmark.json

@@ -0,0 +1,28 @@
+{
+  "source": "evaluation/released_daily/released_daily_benchmark.json",
+  "source_sha256": "79f67a5f4490150cf0ab24d73e5d3cdedb4884d37e86560cbadde1d4ecdafc43",
+  "chart": "evaluation/released_daily/model_1_2_benchmark.png",
+  "chart_sha256": "3bd866eede33fc93d36a0a5373a3b1637bf0f56860938c3d5691b9b7dfe770b4",
+  "metrics": [
+    "pressure_JMA_hpa",
+    "mean_track_error_km",
+    "direction_error_deg"
+  ],
+  "values": {
+    "pressure_JMA_hpa": {
+      "1.1": 13.53233861138585,
+      "1.2": 12.837077366789085
+    },
+    "mean_track_error_km": {
+      "1.1": 798.4143395733709,
+      "1.2": 471.2045276140213
+    },
+    "direction_error_deg": {
+      "1.1": 51.58419207122625,
+      "1.2": 34.95994745459279
+    }
+  },
+  "deepmind_score": null,
+  "zero_fill": false,
+  "model_forecasts_modified": false
+}

models/trackformer_1_2_field/README.md

@@ -1,6 +1,6 @@
 # Trackformer 1.2 field-model inference
 
-**Documentation revision: 1 October 2026.** This describes the current GitHub/Hugging Face wrapper. The 29 September release tarball remains an earlier snapshot; its optional wind/radius diagnostics may differ. Released neural weights, architecture, causal input schema and route/pressure predictions are unchanged.
+The released pressure-field model predicts Western Pacific storm tracks, central pressure and spatial MSLP through +120 h. This is the inference reference; see the [model announcement](../../README.md) for capabilities, the pressure-map showcase and development results.
 
 This folder contains the exact source, input contract and inference-only weights for the research model in the [main README](../../README.md). `model.py`, `baseline_model.py` and `v165_base.py` are source-identical to the selected training implementation. The weight file is distributed via the [GitHub release](https://github.com/yu314-coder/typhoon-predict/releases/tag/trackformer-1.2) and [Hugging Face](https://huggingface.co/euler314/typhoon-predict/tree/main/models/trackformer_1_2_field), not Git.
 
@@ -45,6 +45,6 @@ No model weights, learned architecture or existing benchmark results changed.
 
 The published 50-member mean is a separate evaluation policy: 50 deterministic seeds perturb only normalized historical basin/regional fields with smooth zero-centred noise, then average routes, central pressures and common-grid fields. `predict.py` computes one clean forecast; do not label it a 50-member mean.
 
-**Matched development evaluation:** the released 1.1 and 1.2 route comparison uses the same frozen **1,473 daily starts / 270 equal-weight storms**, +6 to +120 h. The completed native-pressure comparison has **134 common starts / 40 storms**; the other 1,339 starts lack valid frozen 1.1 intensity inputs and are not zero-scored. The Site defaults to central-pressure MAE: **13.53 / 12.84 hPa** against JMA and **12.84 / 12.55 hPa** against USA (1.1 / 1.2), slight mean improvements with paired whole-storm uncertainty including zero. The optional curve-similarity diagnostic is **(1 + centred cosine) / 2 at exact common valid times**, without time shifting or warping. JMA similarity is **0.7074 / 0.7118**; USA is **0.7237 / 0.6637** on 131 eligible non-flat curves. Removing level/amplitude makes this a shape diagnostic, not proof of correct pressure levels. Actual unshifted hPa timelines, agency masks and uncertainty remain separate. See the [shared snapshot](../../evaluation/released_daily/released_daily_benchmark.json), [verification receipt](../../evaluation/released_daily/released_daily_verification.json), [pressure protocol](../../docs/intensity_benchmark.md) and [public benchmark API](https://trackformer-weatherlab.rudin-euler-8253.chatgpt.site/api/benchmarks/released). DeepMind Mini has not run on this daily cohort; no old score is transferred into it.
+**Matched development evaluation:** the released 1.1 and 1.2 route comparison uses the same frozen **1,473 daily starts / 270 equal-weight storms**, +6 to +120 h. The completed native-pressure comparison has **134 common starts / 40 storms**; the other 1,339 starts lack valid frozen 1.1 intensity inputs and are not zero-scored. The Site defaults to central-pressure MAE: **13.53 / 12.84 hPa** against JMA and **12.84 / 12.55 hPa** against USA (1.1 / 1.2), slight mean improvements with paired whole-storm uncertainty including zero. The optional curve-similarity diagnostic is **(1 + centred cosine) / 2 at exact common valid times**, without time shifting or warping. JMA similarity is **0.7074 / 0.7118**; USA is **0.7237 / 0.6637** on 131 eligible non-flat curves. Removing level/amplitude makes this a shape diagnostic, not proof of correct pressure levels. Actual unshifted hPa timelines, agency masks and uncertainty remain separate. See the [shared snapshot](../../evaluation/released_daily/released_daily_benchmark.json), [verification receipt](../../evaluation/released_daily/released_daily_verification.json), [pressure protocol](../../docs/intensity_benchmark.md) and [public benchmark API](https://trackformer-weatherlab.rudin-euler-8253.chatgpt.site/api/benchmarks/released). A new matched WeatherNext Cyclones Mini run is in progress on these exact daily starts; results remain pending. See the [frozen protocol](../../docs/deepmind_daily_benchmark.md); no old scores are transferred.
 
-**Pressure-display coverage:** `regional_mslp_hpa` is the original fixed issue-relative composite, not an automatically extended moving-core map. When the forecast centre leaves that patch, a scalar central-pressure readout must not be inserted into the image to make it appear consistent. The corrected Mangkhut film separately exports the actual moving model cores and registers member fields before averaging; [the current model card](https://huggingface.co/euler314/typhoon-predict) links the verified pressure arrays and shows which other films retain their older fixed patches. The automatic History archive and its separate core recovery expose exact geography and coverage through [the public API](https://trackformer-weatherlab.rudin-euler-8253.chatgpt.site/history-api).
+**Pressure-display coverage:** `regional_mslp_hpa` is the original fixed issue-relative composite, not an automatically extended moving-core map. When the forecast centre leaves that patch, a scalar central-pressure readout must not be inserted into the image to make it appear consistent. The Mangkhut film separately exports the actual moving model cores and registers member fields before averaging; [the current model card](https://huggingface.co/euler314/typhoon-predict) links the verified pressure arrays and links older fixed-patch films in a separate archive. The automatic History archive and its separate core recovery expose exact geography and coverage through [the public API](https://trackformer-weatherlab.rudin-euler-8253.chatgpt.site/history-api).

release_tools/deepmind_daily_benchmark.py

@@ -0,0 +1,483 @@
+"""Frozen WeatherNext Cyclones Mini daily benchmark. No fitting or old scores.
+
+The supervisor is resumable and CPU-only on the Mac. Each isolated worker runs
+the official released predictor and tracker, using only two causal ERA5 states
+and the frozen issue-time storm anchor. Truth is loaded afterwards for scoring.
+All output, source caches and compilation caches remain on /Volumes/D.
+"""
+from __future__ import annotations
+
+import argparse
+from collections import defaultdict
+from datetime import datetime, timezone
+import fcntl
+import hashlib
+import json
+import os
+from pathlib import Path
+import subprocess
+import sys
+import time
+
+import numpy as np
+
+COHORT = '965184f1e5ab3fcb52e304f39b38583a14f753870aa2295f2d01942a441dcfd6'
+WEIGHTS = 'a1bb151457077248d70a458b1a7b19deacd2926fbcb46eee4ff2691444e3596e'
+CHECKPOINT = 'f194a23d3f91ea76ad776dfad942fabd669eeae8b3fd665815463095367e9ee0'
+STEP_NS = 6 * 3600 * 10**9
+HERE = Path(__file__).resolve()
+
+
+def sha(path):
+    with Path(path).open('rb') as stream:
+        return hashlib.file_digest(stream, 'sha256').hexdigest()
+
+
+def read(path):
+    return json.loads(Path(path).read_text())
+
+
+def write(path, value):
+    path = Path(path)
+    temporary = path.with_suffix(path.suffix + '.tmp')
+    temporary.write_text(json.dumps(value, indent=2, allow_nan=False) + '\n')
+    temporary.replace(path)
+
+
+def stamp():
+    return datetime.now(timezone.utc).isoformat()
+
+
+def assets(project):
+    return {
+        'weights': project/'v226/weathernext_global/weights/WeatherNextCyclones_Mini_<2024.npz',
+        'shape_template': project/'v226/weathernext_global/data/hres_2024-10-07_00z_1deg_steps20.nc',
+        'initial_state_reader': project/'v226_build_arco_weathernext_state.py',
+        'inference_adapter': project/'v226_weathernext_cyclones_baseline.py',
+        'scoring_definition': project/'benchmark_daily_storms_1_2.py',
+        'runner': HERE,
+    }
+
+
+def prepare(project, out):
+    if (out/'protocol.json').exists():
+        raise ValueError('Protocol already frozen; run or status, not prepare again')
+    original = project/'benchmark_daily_storms_1_2/cohort.json'
+    plan = read(original)
+    if sha(original) != COHORT or len(plan['cases']) != 1473 or plan['storm_count'] != 270:
+        raise ValueError('Wrong frozen daily cohort')
+    if plan['models']['1.2']['checkpoint_sha256'] != CHECKPOINT:
+        raise ValueError('Wrong Trackformer reference')
+    sources = {key: {'path': str(path), 'sha256': sha(path)} for key, path in assets(project).items()}
+    if sources['weights']['sha256'] != WEIGHTS:
+        raise ValueError('Wrong official WeatherNext Mini checkpoint')
+    rows = []
+    for case in plan['cases']:
+        path = project/'benchmark_daily_storms_1_2/cases'/f"{case['case_index']:05d}.npz"
+        metadata = read(path.with_suffix('.json'))
+        if any(metadata[key] != value for key, value in case.items()) or sha(path) != metadata['forecast_sha256']:
+            raise ValueError('Original daily forecast differs')
+        rows.append(dict(case, original_forecast_sha256=metadata['forecast_sha256']))
+    out.mkdir(parents=True, exist_ok=True)
+    vendor = subprocess.check_output(['git', '-C', str(project/'vendor/weathernext'), 'rev-parse', 'HEAD'], text=True).strip()
+    write(out/'protocol.json', {
+        'schema': 'weathernext-mini-daily-equal-storm-v1', 'frozen_at_utc': stamp(),
+        'cohort_sha256': COHORT, 'target_daily_cases': 1473, 'target_storms': 270,
+        'model': 'Google DeepMind WeatherNext Cyclones Mini <2024', 'members': 1,
+        'seed': 0, 'trained_through': 2023, 'resolution_degrees': 1,
+        'official_weights_url': 'https://storage.googleapis.com/dm_graphcast/weathernext2/params/WeatherNextCyclones_Mini_%3C2024.npz',
+        'vendor_commit': vendor, 'sources': sources, 'cases': rows,
+        'leads_hours': list(range(6, 121, 6)), 'backend': 'JAX CPU',
+        'causal_policy': 'Exactly issue -6h and issue ERA5 analyses; frozen observed issue centre only. Calendar forcings only after issue. No future weather, truth or official forecast route in inference.',
+        'tracker_policy': 'Official direct_tracker_6h_v1 with initialized-storm continuity and no cyclogenesis; dissipation and nearby pruning disabled, disclosed rather than official operational tracker policy.',
+        'aggregation': 'Mean valid leads per day, days within storm, then equal storm weights. All three direction scores recomputed on common moving steps. Pressure uses the original matched native intensity cases, common leads and separate JMA/USA labels.',
+        'failure_policy': 'Failures stay visible and unscored. No zero fills, source substitutions, calibration or case selection by performance. Full-cohort completion requires all 1473 forecasts.',
+        'interpretation': 'Development comparison, different input pipelines and member policies. Historical 1980-1999 cases overlap WeatherNext fitting years; recent 2024+ cases are separately reported. Not a certified untouched test.',
+    })
+    print(json.dumps({'status': 'protocol_frozen', 'cases': len(rows), 'storms': 270, 'protocol_sha256': sha(out/'protocol.json')}), flush=True)
+
+
+def validate_state(path, case):
+    import xarray as xr
+    with xr.open_dataset(path, engine='h5netcdf') as state:
+        times = state.datetime.values.astype('datetime64[ns]').astype('int64')
+        expected = int(case['issue_ns']) + np.array([-STEP_NS, 0])
+        if times.shape != (2,) or not np.array_equal(times, expected):
+            raise ValueError('Weather initial state is not the exact causal two-analysis history')
+        for key in ('future_weather_fields_used', 'official_forecast_fields_used'):
+            if str(state.attrs.get(key)).lower() != 'false':
+                raise ValueError('Weather source does not declare causal analysis inputs')
+
+
+def state_path(project, out, case):
+    tag = case['issue_time_utc'][:16].replace('-', '').replace(':', '').replace('T', '_')
+    filename = f'arco_era5_1deg_{tag}.nc'
+    for directory in (project/'benchmark_weathernext_cyclones_mini_same270/arco_states',
+                      project/'benchmark_tip_ten/deepmind_states', out/'states'):
+        candidate = directory/filename
+        if candidate.exists():
+            validate_state(candidate, case)
+            return candidate
+    dest = out/'states'
+    subprocess.run([sys.executable, str(project/'v226_build_arco_weathernext_state.py'),
+        '--init', case['issue_time_utc'], '--output-dir', str(dest), '--skip-land-cache',
+        '--download-workers', '2', '--download-retries', '2'], check=True, cwd=project)
+    candidate = dest/filename
+    validate_state(candidate, case)
+    return candidate
+
+
+def worker(project, out, index):
+    """Inference has no access to any future labels or original forecast outputs."""
+    import dataclasses
+    import haiku as hk
+    import jax
+    import pandas as pd
+    import xarray as xr
+    import xarray_jax
+    sys.path.insert(0, str(project))
+    import v226_weathernext_cyclones_baseline as adapter
+    from weathernext.utils import checkpoint, data_utils, fiddle_config_io, rollout
+    from weathernext.weathernext2 import fgn
+    from weathernext.cyclones import direct_tracker, direct_tracker_6h_v1_config
+    protocol = read(out/'protocol.json')
+    case = protocol['cases'][index]
+    initial = state_path(project, out, case)
+    config = fiddle_config_io.get_fiddle_config_by_name(adapter.CONFIG_NAME)
+    if jax.default_backend() != 'cpu':
+        raise ValueError('This frozen run requires its declared CPU backend')
+    jax.config.update('jax_compilation_cache_dir', str(out/'jax-cache'))
+    jax.config.update('jax_persistent_cache_min_compile_time_secs', 0)
+    attention = adapter.configure_attention(config, 'cpu')
+    paths = assets(project)
+    with paths['weights'].open('rb') as stream:
+        ckpt = checkpoint.load(stream, fgn.CheckPoint)
+    template = xr.load_dataset(paths['shape_template'], engine='h5netcdf').compute()
+    template, issue = adapter.inject_initial_state(template, initial, config.task)
+    if int(np.datetime64(issue, 'ns').astype('int64')) != case['issue_ns']:
+        raise ValueError('Issue does not match frozen cohort')
+    if set(config.task.forcing_variables) != adapter.ALLOWED_FORCINGS:
+        raise ValueError('Unexpected future forcing')
+    inputs, targets, forcings = data_utils.extract_inputs_targets_forcings(template,
+        target_lead_times=slice('6h', '120h'), **dataclasses.asdict(config.task))
+    if not np.array_equal(inputs.time.values.astype('timedelta64[h]').astype(int), [-6, 0]):
+        raise ValueError('Non-causal predictor input times')
+    prediction_config = fgn.PredictorConfig(task=config.task,
+        predictor_constructor=config.predictor_constructor,
+        predictor_kwargs=config.predictor_kwargs, predictor_wrappers=config.predictor_wrappers[:-1])
+
+    @hk.transform
+    def forward(history, shape, forcing):
+        return fgn.construct_predictor(prediction_config)(history, targets_template=shape, forcings=forcing)
+
+    compiled = jax.jit(lambda rng, history, shape, forcing: forward.apply(ckpt.params, rng, history, shape, forcing))
+    mapped = xarray_jax.pmap(compiled, dim='sample')
+    rngs = np.stack([jax.random.fold_in(jax.random.PRNGKey(protocol['seed']), 0)])
+    chunks = []
+    started = time.monotonic()
+    for i, chunk in enumerate(rollout.chunked_prediction_generator_multiple_runs(
+            predictor_fn=mapped, rngs=rngs, inputs=inputs,
+            targets_template=targets*np.nan, forcings=forcings,
+            num_steps_per_chunk=1, num_samples=1, pmap_devices=jax.local_devices())):
+        if i >= 20:
+            break
+        chunks.append(jax.device_get(chunk))
+        print(json.dumps({'case': index, 'step': i+1, 'steps': 20, 'elapsed_seconds': round(time.monotonic()-started, 1)}), flush=True)
+    predictions = xr.combine_by_coords(chunks).isel(time=slice(0, 20), batch=0, sample=0)
+    if predictions.sizes.get('time') != 20:
+        raise ValueError('Incomplete model rollout')
+    config_tracker = direct_tracker_6h_v1_config.get_config()
+    kwargs = dict(config_tracker.tracker_kwargs,
+        dissipation_min_mean_probability_threshold=None, prune_nearby_cyclones=False)
+    tracker = config_tracker.tracker_constructor(**kwargs)
+    scalar = predictions['cyclone_exists_gaussian_unit_mode']
+    for key in direct_tracker.IBTRACS_VARIABLE_NAME_TO_GRIDDED_VARIABLE_NAME.values():
+        if key not in predictions:
+            predictions[key] = xr.full_like(scalar, np.nan)
+    grid = tracker.preprocess_gridded_ds(predictions).expand_dims(forecast_datetime=[np.datetime64(issue)])
+    grid = grid.assign_coords(lead_time_secs=grid.time.astype('timedelta64[s]').astype(int),
+        date_time=np.datetime64(issue)+grid.time).as_numpy()
+    anchor = pd.DataFrame([dict(track_id=case['storm_id'], lat=case['base_lat'],
+        lon=case['base_lon'], valid_time=issue, init_time=issue)])
+    tracks = tracker(gridded_ds=grid, initial_storms_df=anchor, do_cyclogenesis=False)
+    tracks = tracks[tracks.track_id == case['storm_id']].copy()
+    wanted = pd.to_datetime(case['issue_ns'] + np.arange(1, 21)*STEP_NS)
+    rows = tracks.set_index('valid_time').reindex(wanted)
+    route = rows[['lat', 'lon']].to_numpy(dtype='float64')
+    route[:, 1] %= 360
+    if route.shape != (20, 2) or not np.isfinite(route).all():
+        raise ValueError('Tracker did not produce twenty finite exact-time points')
+    pressure = rows['minimum_sea_level_pressure_hpa'].to_numpy(dtype='float64')
+    pressure_valid = np.isfinite(pressure) & (pressure >= 800) & (pressure <= 1100)
+    native = predictions.mean_sea_level_pressure.sel(lat=slice(0, 60), lon=slice(100, 180)) / 100
+    values = native.transpose('time', 'lat', 'lon').values.astype('float32')
+    if values.shape != (20, 61, 81) or not np.isfinite(values).all() or values.min() < 800 or values.max() > 1100:
+        raise ValueError('Nonphysical or incomplete native Western Pacific pressure fields')
+    dest = out/'cases'/f'{index:05d}.npz'
+    temporary = dest.with_suffix('.npz.tmp')
+    with temporary.open('wb') as stream:
+        np.savez_compressed(stream, route_lat_lon=route,
+            central_pressure_hpa=np.where(pressure_valid, pressure, np.nan), pressure_valid=pressure_valid,
+            wp_pressure_hpa=values, latitude=native.lat.values, longitude=native.lon.values,
+            lead_hours=np.arange(6, 121, 6), valid_time_ns=case['issue_ns']+np.arange(1, 21)*STEP_NS)
+    temporary.replace(dest)
+    write(dest.with_suffix('.json'), dict(case, status='complete', members=1,
+        model=protocol['model'], checkpoint_sha256=WEIGHTS, protocol_sha256=sha(out/'protocol.json'),
+        forecast_sha256=sha(dest), input_state_sha256=sha(initial), input_state_path=str(initial),
+        input_time_ns=[case['issue_ns']-STEP_NS, case['issue_ns']], backend='cpu',
+        attention_override=attention, runtime_seconds=time.monotonic()-started, completed_at_utc=stamp(),
+        future_weather_used=False, future_storm_labels_used=False))
+
+
+def route_metrics(routes, truth):
+    steps = [np.diff(np.vstack([np.zeros((1, 2)), p]), axis=0) for p in [*routes.values(), truth]]
+    valid = np.logical_and.reduce([np.linalg.norm(p, axis=-1) > 1 for p in steps])
+    result = {}
+    for (key, path), step in zip(routes.items(), steps[:-1]):
+        error = np.linalg.norm(path-truth, axis=-1)
+        angle = np.arctan2(step[:, 1], step[:, 0])-np.arctan2(steps[-1][:, 1], steps[-1][:, 0])
+        angle = np.degrees(np.abs(np.arctan2(np.sin(angle), np.cos(angle))))
+        a, b = (path-path.mean(0)).ravel(), (truth-truth.mean(0)).ravel()
+        similarity = (1+np.dot(a, b)/max(np.linalg.norm(a)*np.linalg.norm(b), 1e-8))/2
+        result[key] = dict(mean_track_error_km=float(error.mean()), track_error_120h_km=float(error[-1]),
+            track_error_by_lead_km=error.tolist(), direction_error_deg=float(angle[valid].mean()) if valid.any() else None,
+            direction_valid_steps=int(valid.sum()), shape_similarity=float(np.clip(similarity, 0, 1)))
+    return result
+
+
+def local(route, lat, lon):
+    return np.stack([((route[:, 1]-lon+180)%360-180)*111.2*max(np.cos(np.deg2rad(lat)), .2),
+                     (route[:, 0]-lat)*111.2], -1)
+
+
+def curve_similarity(forecast, truth):
+    if len(truth) < 6:
+        return None
+    a, b = forecast-forecast.mean(), truth-truth.mean()
+    norm = np.linalg.norm(a)*np.linalg.norm(b)
+    return float(np.clip((1+np.dot(a, b)/norm)/2, 0, 1)) if norm > 1e-8 else None
+
+
+def score(project, out, case):
+    index = case['case_index']
+    path = out/'cases'/f'{index:05d}.npz'
+    record = read(path.with_suffix('.json'))
+    if record['forecast_sha256'] != sha(path) or record['protocol_sha256'] != sha(out/'protocol.json'):
+        raise ValueError('Saved candidate identity changed')
+    original = project/'benchmark_daily_storms_1_2/cases'/path.name
+    if sha(original) != case['original_forecast_sha256']:
+        raise ValueError('Frozen baseline forecast changed')
+    with np.load(path, allow_pickle=False) as z, np.load(original, allow_pickle=False) as reference:
+        candidate = local(z['route_lat_lon'], case['base_lat'], case['base_lon'])
+        metrics = route_metrics({'1.1': reference['v11_local'], '1.2': reference['v12_local'], 'deepmind': candidate}, reference['truth_local'])
+        pressure = z['central_pressure_hpa'].copy()
+    source = read(project/'output/intensity-v12-v11-20261001/cases'/f'{index:05d}.json')
+    pressure_scores = {}
+    if source['v11'] is not None:
+        curves = {'1.1': np.array([p['central_pressure_hpa'] for p in source['v11']], dtype=float),
+                  '1.2': np.array(source['v12_pressure_hpa'], dtype=float), 'deepmind': pressure}
+        for agency in ('JMA', 'USA'):
+            truth = np.array(source['truth']['pressure_'+agency+'_hpa'], dtype=float)
+            mask = pressure_mask(truth, curves)
+            pressure_scores[agency] = {'valid_leads': int(mask.sum()), 'models': {
+                key: {'mae_hpa': float(np.abs(p[mask]-truth[mask]).mean()) if mask.any() else None,
+                      'curve_similarity': curve_similarity(p[mask], truth[mask]),
+                      'error_by_lead_hpa': [float(abs(p[i]-truth[i])) if mask[i] else None for i in range(20)]}
+                for key, p in curves.items()}}
+    record.update(route_metrics=metrics, pressure_metrics=pressure_scores)
+    write(path.with_suffix('.json'), record)
+    return record
+
+
+def pressure_mask(truth, curves):
+    arrays = [np.asarray(p, dtype=float) for p in [truth, *curves.values()]]
+    if any(p.shape != (20,) for p in arrays):
+        raise ValueError('Pressure comparison requires twenty matching exact leads')
+    return np.logical_and.reduce([np.isfinite(p) & (p >= 800) & (p <= 1100) for p in arrays])
+
+
+def aggregate(groups):
+    scores = {}
+    for model in ('1.1', '1.2', 'deepmind'):
+        scores[model] = {}
+        for metric in ('mean_track_error_km', 'track_error_120h_km', 'direction_error_deg', 'shape_similarity'):
+            storms = []
+            for days in groups.values():
+                values = [d['route_metrics'][model][metric] for d in days if d['route_metrics'][model][metric] is not None]
+                if values:
+                    storms.append(float(np.mean(values)))
+            scores[model][metric] = {'value': float(np.mean(storms)) if storms else None, 'storms': len(storms)}
+        scores[model]['track_error_by_lead_km'] = np.mean([
+            np.mean([d['route_metrics'][model]['track_error_by_lead_km'] for d in days], axis=0)
+            for days in groups.values()], axis=0).tolist() if groups else [None]*20
+    pressure = {}
+    for agency in ('JMA', 'USA'):
+        eligible = {sid: [d['pressure_metrics'][agency] for d in days
+                         if agency in d['pressure_metrics'] and d['pressure_metrics'][agency]['valid_leads']]
+                    for sid, days in groups.items()}
+        eligible = {sid: days for sid, days in eligible.items() if days}
+        pressure[agency] = {'daily_cases': sum(map(len, eligible.values())), 'storms': len(eligible),
+                           'common_lead_points': sum(d['valid_leads'] for days in eligible.values() for d in days), 'models': {}}
+        for model in ('1.1', '1.2', 'deepmind'):
+            values = {}
+            for metric in ('mae_hpa', 'curve_similarity'):
+                storm_values = []
+                case_count = 0
+                for days in eligible.values():
+                    valid = [d['models'][model][metric] for d in days if d['models'][model][metric] is not None]
+                    if valid:
+                        storm_values.append(float(np.mean(valid)))
+                        case_count += len(valid)
+                values[metric] = {'value': float(np.mean(storm_values)) if storm_values else None,
+                                  'storms': len(storm_values), 'daily_cases': case_count}
+            pressure[agency]['models'][model] = values
+    return {'route': scores, 'pressure': pressure}
+
+
+def status(project, out, active=None):
+    protocol = read(out/'protocol.json')
+    groups = defaultdict(list)
+    expected = defaultdict(int)
+    failures = []
+    for case in protocol['cases']:
+        expected[case['storm_id']] += 1
+        path = out/'cases'/f"{case['case_index']:05d}.json"
+        completed = False
+        if path.exists():
+            record = read(path)
+            if 'route_metrics' in record:
+                groups[case['storm_id']].append(record)
+                completed = True
+        failure = out/'failures'/f"{case['case_index']:05d}.json"
+        if failure.exists() and not completed:
+            failures.append(read(failure))
+    full = {key: days for key, days in groups.items() if len(days) == expected[key]}
+    done = sum(map(len, groups.values()))
+    receipt = read(out/'verification.json') if (out/'verification.json').exists() else {}
+    verified = (receipt.get('verified_daily_cases') == 1473 and receipt.get('protocol_sha256') == sha(out/'protocol.json'))
+    report = {'state': 'complete_verified' if verified else 'forecasts_finished_audit_pending' if done == 1473 else 'running_partial' if active is not False else 'finished_with_unavailable',
+        'updated_at_utc': stamp(), 'cohort_sha256': COHORT, 'protocol_sha256': sha(out/'protocol.json'),
+        'completed_daily_cases': done, 'target_daily_cases': 1473, 'completed_storms': len(full),
+        'target_storms': 270, 'failed_daily_cases': len(failures), 'failures': failures,
+        'checkpoint_sha256': WEIGHTS, 'members': 1, 'backend': 'JAX CPU',
+        'aggregate_equal_complete_storm': aggregate(full), 'final_results': verified,
+        'periods': {period: aggregate({sid: days for sid, days in full.items() if days[0]['period'] == period})
+                   for period in sorted({c['period'] for c in protocol['cases']})},
+        'original_forecasts_modified': False, 'original_model_weights_modified': False,
+        'missing_results_scored_as_zero': 0, 'pressure_note': 'Per-case three-way common-support pressure MAE and curve similarity in cases/*.json; separate agency masks. Final publication requires coverage audit, including pressure-specific coverage.'}
+    write(out/'progress.json', report)
+    return report
+
+
+def verify(project, out):
+    protocol = read(out/'protocol.json')
+    verified = []
+    for case in protocol['cases']:
+        path = out/'cases'/f"{case['case_index']:05d}.npz"
+        record = read(path.with_suffix('.json'))
+        if any(record.get(k) != v for k, v in case.items()):
+            raise ValueError('Forecast case does not match the frozen definition')
+        if record.get('checkpoint_sha256') != WEIGHTS or record.get('members') != 1:
+            raise ValueError('Forecast model/member identity differs')
+        if record.get('input_time_ns') != [case['issue_ns']-STEP_NS, case['issue_ns']]:
+            raise ValueError('Weather history is noncausal')
+        with np.load(path, allow_pickle=False) as z:
+            if not np.array_equal(z['lead_hours'], np.arange(6, 121, 6)) or not np.array_equal(
+                    z['valid_time_ns'], case['issue_ns']+np.arange(1, 21)*STEP_NS):
+                raise ValueError('Forecast leads are not exact +6 to +120h')
+            if z['route_lat_lon'].shape != (20, 2) or not np.isfinite(z['route_lat_lon']).all():
+                raise ValueError('Incomplete route')
+            p = z['wp_pressure_hpa']
+            if p.shape != (20, 61, 81) or not np.isfinite(p).all() or p.min() < 800 or p.max() > 1100:
+                raise ValueError('Incomplete physical native pressure fields')
+        score(project, out, case)  # Recheck hashes and recompute common-support metrics.
+        verified.append(case['case_index'])
+    if len(set(verified)) != 1473:
+        raise ValueError('Audit did not cover every planned case')
+    write(out/'verification.json', {'status': 'complete_verified', 'verified_at_utc': stamp(),
+        'protocol_sha256': sha(out/'protocol.json'), 'cohort_sha256': COHORT,
+        'checkpoint_sha256': WEIGHTS, 'verified_daily_cases': 1473, 'verified_storms': 270,
+        'case_indices': verified, 'checks': ['exact frozen issue identity', 'forecast and baseline SHA256',
+        'one official Mini member', 'causal two-analysis history', 'twenty exact leads',
+        'finite unshifted routes', 'twenty native physical WP pressure grids',
+        'recomputed matched three-way route and pressure masks']})
+
+
+def run(project, out, limit=0):
+    out.mkdir(parents=True, exist_ok=True)
+    lock = (out/'run.lock').open('a')
+    fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB)
+    protocol = read(out/'protocol.json')
+    for row in protocol['sources'].values():
+        if sha(row['path']) != row['sha256']:
+            raise ValueError('Frozen source changed: '+row['path'])
+    for name in ('cases', 'failures', 'logs', 'states', 'jax-cache'):
+        (out/name).mkdir(exist_ok=True)
+    write(out/'runtime.json', {'pid': os.getpid(), 'started_at_utc': stamp(), 'backend': 'JAX CPU',
+        'python': sys.executable, 'protocol_sha256': sha(out/'protocol.json')})
+    count = 0
+    status(project, out, True)
+    for case in protocol['cases']:
+        index = case['case_index']
+        saved = out/'cases'/f'{index:05d}.json'
+        if saved.exists() and 'route_metrics' in read(saved):
+            continue
+        if limit and count >= limit:
+            break
+        count += 1
+        try:
+            if not saved.exists():
+                with (out/'logs'/f'{index:05d}.log').open('a') as log:
+                    subprocess.run([sys.executable, str(HERE), 'worker', '--project', str(project),
+                        '--output', str(out), '--case-index', str(index)], cwd=project,
+                        env=dict(os.environ, JAX_PLATFORMS='cpu', PYTHONUNBUFFERED='1',
+                                 XLA_PYTHON_CLIENT_PREALLOCATE='false'), stdout=log, stderr=subprocess.STDOUT, check=True)
+            score(project, out, case)
+            print(json.dumps({'case_complete': index, 'storm_id': case['storm_id'], 'issue': case['issue_time_utc']}), flush=True)
+        except Exception as error:
+            write(out/'failures'/f'{index:05d}.json', dict(case_index=index, storm_id=case['storm_id'],
+                issue_time_utc=case['issue_time_utc'], error=str(error), at_utc=stamp(), result=None))
+            print(json.dumps({'case_failed': index, 'error': str(error)}), flush=True)
+        status(project, out, True)
+    report = status(project, out, False)
+    if report['completed_daily_cases'] == 1473:
+        verify(project, out)
+        report = status(project, out, False)
+    print(json.dumps({k: v for k, v in report.items() if k not in ('failures', 'aggregate_equal_complete_storm')}), flush=True)
+
+
+def launch(project, out):
+    # Lock is acquired by run; launch never stops or replaces an existing job.
+    with (out/'run.lock').open('a') as lock:
+        fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB)
+    log = (out/'run.log').open('a')
+    command = [sys.executable, str(HERE), 'run', '--project', str(project), '--output', str(out)]
+    if sys.platform == 'darwin':
+        command = ['/usr/bin/caffeinate', '-i', '-s', *command]
+    child = subprocess.Popen(command, cwd=project, stdin=subprocess.DEVNULL,
+        stdout=log, stderr=subprocess.STDOUT, start_new_session=True,
+        env=dict(os.environ, JAX_PLATFORMS='cpu', PYTHONUNBUFFERED='1', XLA_PYTHON_CLIENT_PREALLOCATE='false'))
+    write(out/'launcher.json', {'pid': child.pid, 'launched_at_utc': stamp(), 'command': command})
+    print(json.dumps({'launched_pid': child.pid, 'output': str(out), 'backend': 'JAX CPU'}), flush=True)
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('mode', choices=('prepare', 'run', 'worker', 'status', 'launch'))
+    parser.add_argument('--project', type=Path, required=True)
+    parser.add_argument('--output', type=Path, required=True)
+    parser.add_argument('--case-index', type=int, default=0)
+    parser.add_argument('--limit', type=int, default=0)
+    args = parser.parse_args()
+    project, out = args.project.resolve(), args.output.resolve()
+    if not out.is_relative_to(Path('/Volumes/D')) or not project.is_relative_to(Path('/Volumes/D')):
+        raise ValueError('Project and all generated artifacts must remain on D')
+    if args.mode == 'prepare': prepare(project, out)
+    elif args.mode == 'worker': worker(project, out, args.case_index)
+    elif args.mode == 'run': run(project, out, args.limit)
+    elif args.mode == 'launch': launch(project, out)
+    else: print(json.dumps(status(project, out), indent=2))
+
+
+if __name__ == '__main__':
+    main()

release_tools/plot_model_announcement.py

@@ -0,0 +1,67 @@
+"""Three release metrics from frozen scores; pending models have no fake bars."""
+import hashlib
+import json
+from pathlib import Path
+import matplotlib
+matplotlib.use('Agg')
+import matplotlib.pyplot as plt
+
+ROOT = Path(__file__).resolve().parents[1]
+SOURCE = ROOT/'evaluation/released_daily/released_daily_benchmark.json'
+DEST = ROOT/'evaluation/released_daily/model_1_2_benchmark.png'
+
+
+def main():
+    source = json.loads(SOURCE.read_text())
+    if source['status'] != 'complete_verified' or source['cohort']['daily_issues'] != 1473:
+        raise ValueError('Chart requires verified daily-cohort results')
+    metrics = {m['key']: m for m in source['metrics']}
+    plt.rcParams.update({'font.family': 'DejaVu Sans', 'font.size': 11,
+                         'axes.spines.top': False, 'axes.spines.right': False,
+                         'axes.spines.left': False, 'axes.spines.bottom': False})
+    fig, axes = plt.subplots(1, 3, figsize=(13.8, 5.7))
+    fig.set_facecolor('#f6f8fc')
+    specs = [('pressure_JMA_hpa', 'Pressure intensity', 'Central-pressure MAE · hPa', 18, 2),
+             ('mean_track_error_km', 'Track position', 'Mean position error · km', 1050, 1),
+             ('direction_error_deg', 'Track direction', 'Six-hour heading error · degrees', 65, 2)]
+    for ax, (key, title, label, maximum, digits) in zip(axes, specs):
+        row = metrics[key]
+        values = [row['values'][k] for k in ('1.1', '1.2')]
+        ax.set_facecolor('#f6f8fc')
+        ax.set_axisbelow(True)
+        ax.grid(axis='y', color='#dfe5ee', linewidth=.8)
+        ax.bar([0, 1], values, width=.53, color=['#9aa9bc', '#3c67d6'], zorder=3)
+        if key == 'pressure_JMA_hpa':
+            intervals = [row['intervals'][k] for k in ('1.1', '1.2')]
+            ax.errorbar([0, 1], values, yerr=[[v-low for v, (low, high) in zip(values, intervals)],
+                        [high-v for v, (low, high) in zip(values, intervals)]],
+                        fmt='none', color='#253853', capsize=5, linewidth=1.2, zorder=4)
+        for x, value in enumerate(values):
+            top = row['intervals'][('1.1', '1.2')[x]][1] if key == 'pressure_JMA_hpa' else value
+            ax.text(x, top+maximum*.038, f'{value:,.{digits}f}', ha='center',
+                    fontsize=17, fontweight='bold', color='#21334c')
+        ax.set_ylim(0, maximum)
+        ax.set_xticks([0, 1], ['1.1', '1.2 · mean of 50'])
+        ax.tick_params(axis='both', length=0, labelcolor='#53647c')
+        ax.set_title(title, loc='left', fontsize=16, fontweight='bold', color='#21334c', pad=38)
+        ax.text(0, 1.03, label, transform=ax.transAxes, color='#53647c', fontsize=10)
+        coverage = row['coverage']
+        ax.text(.5, -.16, f"{coverage['daily_issues']:,} daily starts / {coverage['storms']} storms",
+                transform=ax.transAxes, ha='center', color='#53647c', fontsize=10)
+    fig.text(.055, .945, 'Trackformer 1.2', fontsize=23, fontweight='bold', color='#182b45')
+    fig.text(.055, .895, 'Matched five-day forecasts · equal weight per storm · lower is better', fontsize=12, color='#53647c')
+    fig.text(.055, .095, 'Pressure: JMA reference; bars show 95% whole-storm intervals. Paired improvement is uncertain.', fontsize=10, color='#53647c')
+    fig.text(.055, .057, 'DeepMind Mini: matched run in progress — no score yet. Different pipelines/member policies; development evidence.', fontsize=10, color='#53647c')
+    fig.subplots_adjust(left=.055, right=.975, top=.735, bottom=.25, wspace=.36)
+    fig.savefig(DEST, dpi=180, facecolor=fig.get_facecolor())
+    plt.close(fig)
+    receipt = {'source': SOURCE.relative_to(ROOT).as_posix(), 'source_sha256': hashlib.sha256(SOURCE.read_bytes()).hexdigest(),
+               'chart': DEST.relative_to(ROOT).as_posix(), 'chart_sha256': hashlib.sha256(DEST.read_bytes()).hexdigest(),
+               'metrics': [s[0] for s in specs], 'values': {k: metrics[k]['values'] for k, *_ in specs},
+               'deepmind_score': None, 'zero_fill': False, 'model_forecasts_modified': False}
+    DEST.with_suffix('.json').write_text(json.dumps(receipt, indent=2)+'\n')
+    print(json.dumps(receipt, indent=2))
+
+
+if __name__ == '__main__':
+    main()

release_tools/sync_public_model_cards.py

@@ -1,6 +1,6 @@
 """Render the complete HF card from the canonical GitHub README.
 
-Preserve remote metadata, four inline films and frozen neural weights. Default
+Preserve remote metadata, the featured film and frozen neural weights. Default
 mode only prepares artifacts on D; --publish explicitly updates the HF card,
 matching existing inference wrapper/docs and this small reproduction utility.
 No forecasts are rerun, no media are regenerated and no neural modules change.
@@ -20,11 +20,10 @@ REPO = 'euler314/typhoon-predict'
 MEDIA_REVISION = '87a6e366b42bb4cc0edc95d2c50c55fca21a2c93'
 CACHE = '/Volumes/D/typhoon_predict/.cache/huggingface-intensity'
 HF = 'https://huggingface.co/' + REPO
-GALLERY = '| Soudelor (2015) | Mangkhut (2018) | Meranti (2016) |\n'
-FILMS = ('mangkhut', 'fung_wong', 'soudelor', 'meranti')
+FILMS = ('mangkhut',)
 CURRENT_FIGURES = frozenset((
-    'evaluation/trackformer_1_2_vs_1_1_270_storms_bars.png',
-    'evaluation/released_daily/pressure_comparison.png',
+    'evaluation/released_daily/model_1_2_benchmark.png',
+    'docs/trackformer_1_2_architecture.svg',
 ))
 SYNC_FILES = (
     'models/trackformer_1_2_field/README.md',
@@ -36,9 +35,15 @@ SYNC_FILES = (
     'release_tools/build_release_benchmark.py',
     'release_tools/plot_release_pressure_benchmark.py',
     'release_tools/plot_daily_storm_final.py',
+    'release_tools/plot_model_announcement.py',
+    'release_tools/deepmind_daily_benchmark.py',
+    'release_tools/test_deepmind_daily_benchmark.py',
     'docs/daily_storm_benchmark.md',
     'docs/intensity_benchmark.md',
     'docs/trackformer_1_2_evaluation.md',
+    'docs/deepmind_daily_benchmark.md',
+    'docs/showcase_archive.md',
+    'docs/trackformer_1_2_architecture.svg',
     'evaluation/daily_storm_final.json',
     'evaluation/released_daily/released_daily_benchmark.json',
     'evaluation/released_daily/released_daily_verification.json',
@@ -46,8 +51,8 @@ SYNC_FILES = (
     'evaluation/intensity/verification.json',
     'evaluation/trackformer_1_2_vs_1_1_270_storms_bars.png',
     'evaluation/released_daily/pressure_comparison.png',
-    'paper/trackformer.tex',
-    'paper/trackformer.pdf',
+    'evaluation/released_daily/model_1_2_benchmark.png',
+    'evaluation/released_daily/model_1_2_benchmark.json',
 )
 
 
@@ -73,38 +78,14 @@ def render_card(original, github, figure_revision='main'):
     metadata = re.match(r'\A---\n.*?\n---\n', original, re.S)
     if not metadata:
         raise ValueError('Preserve existing HF YAML metadata; missing header')
-    if github.count('## Corrected pressure forecast — Mangkhut (2018)\n') != 1:
-        raise ValueError('Missing or ambiguous corrected-film section')
-    if github.count(GALLERY) != 1:
-        raise ValueError('Missing or ambiguous historical video gallery')
+    if github.count('## See the forecast: Mangkhut (2018)\n') != 1:
+        raise ValueError('Missing or ambiguous featured-film section')
     card = github
-    for stem, alt in (
-        ('mangkhut', 'Corrected Mangkhut moving-core pressure forecast — 1 October 2026 revision'),
-        ('fung_wong', 'Play the Trackformer 1.2 Fung-wong pressure forecast MP4'),
-    ):
+    for stem, alt in (('mangkhut', 'Trackformer 1.2 Mangkhut pressure and route forecast'),):
         old = '[![' + alt + '](' + media_url(stem, True) + ')](' + media_url(stem) + ')'
         if card.count(old) != 1:
             raise ValueError('Missing or ambiguous primary preview: ' + stem)
         card = card.replace(old, player(stem, alt), 1)
-    start = card.index(GALLERY)
-    end = card.index('\n\n', start)
-    original_gallery = card[start:end]
-    if len(original_gallery.splitlines()) != 5:
-        raise ValueError('Unexpected gallery; preserve existing documentation')
-    replacements = []
-    for stem, name, issue in (
-        ('soudelor', 'Soudelor (2015)', '5 August 2015, 00 UTC'),
-        ('mangkhut', 'Mangkhut (2018)', '11 September 2018, 00 UTC'),
-        ('meranti', 'Meranti (2016)', '10 September 2016, 00 UTC'),
-    ):
-        replacements.append('### ' + name + ' — issue ' + issue)
-        if stem == 'mangkhut':
-            replacements.append('The corrected 20-second player appears near the top of this card; its moving-core repair and audit are described there.')
-        else:
-            replacements.append(player(stem, name + ' original fixed-patch film'))
-        replacements.append('[Play / download ' + name.split(' (')[0] + ' MP4](' + media_url(stem) + ') · [Provenance](evaluation/release_data/' + stem + '_video.json)')
-    card = card[:start] + '\n\n'.join(replacements) + card[end:]
-
     # Relative GitHub links need HF-specific URLs. Keep evolving documentation
     # on main; pin unchanged scientific image bytes to the verified asset commit.
     def link(match):
@@ -121,12 +102,12 @@ def render_card(original, github, figure_revision='main'):
         return image + '[' + label + '](' + target + ')'
     card = re.sub(r'(!?)\[([^\[\]\n]*)\]\(([^)\s]+)\)', link, card)
     card = metadata.group(0) + '\n' + card
-    if card.count('<video ') != 4:
-        raise ValueError('Expected exactly one native player for each of four films')
+    if card.count('<video ') != 1:
+        raise ValueError('Expected exactly one featured native player')
     for stem in FILMS:
         if card.count('src="' + media_url(stem) + '"') != 1:
             raise ValueError('Missing, repeated or stale player: ' + stem)
-    if '/resolve/main/docs/trackformer_1_2_' in card:
+    if re.search(r'/resolve/main/docs/trackformer_1_2_[^"\s)]+\.mp4', card):
         raise ValueError('Unversioned movie source')
     return card
 
@@ -171,7 +152,7 @@ def run(output, publish=False):
         'github_readme_sha256': sha(ROOT / 'README.md'),
         'original_hf_readme_sha256': sha(original),
         'files': {name: sha(path) for name, path in files.items()},
-        'media_revision': MEDIA_REVISION, 'native_video_players': 4,
+        'media_revision': MEDIA_REVISION, 'native_video_players': 1,
         'inference_weights_sha256': weights_before,
         'weights_changed': False, 'neural_modules_changed': False,
         'forecast_arrays_changed': False, 'videos_changed': False,
@@ -184,13 +165,13 @@ def run(output, publish=False):
         # immutable commit in the card. Never pin new bytes to the old movie
         # revision or let a missing future image render as a stale figure.
         assets = api.create_commit(repo_id=REPO, repo_type='model', parent_commit=parent,
-            commit_message='Publish verified matched pressure-curve benchmark and revised technical paper',
+            commit_message='Publish Trackformer 1.2 announcement assets and matched DeepMind benchmark protocol',
             operations=[CommitOperationAdd(path_in_repo=name, path_or_fileobj=str(ROOT/name)) for name in SYNC_FILES])
         card_path.write_text(render_card(original.read_text(), github, assets.oid))
         receipt['files']['README.md'] = sha(card_path)
         receipt['figure_revision'] = assets.oid
         committed = api.create_commit(repo_id=REPO, repo_type='model', parent_commit=assets.oid,
-            commit_message='Refresh model card with exact-time pressure graph similarity and pinned figures',
+            commit_message='Introduce Trackformer 1.2 with a focused showcase and verified daily metrics',
             operations=[CommitOperationAdd(path_in_repo='README.md', path_or_fileobj=str(card_path))])
         for name, expected in receipt['files'].items():
             saved = hf_hub_download(REPO, name, revision=committed.oid, cache_dir=CACHE)

release_tools/test_deepmind_daily_benchmark.py

@@ -0,0 +1,60 @@
+"""Small offline checks; never import the weather model or run inference."""
+import ast
+from pathlib import Path
+import unittest
+import numpy as np
+from deepmind_daily_benchmark import aggregate, curve_similarity, local, pressure_mask, route_metrics
+
+
+class DeepMindBenchmarkTest(unittest.TestCase):
+    def test_identical_routes_have_zero_error_and_matching_shape(self):
+        truth = np.stack([np.arange(1, 21)*3, np.arange(1, 21)*4], -1)
+        metrics = route_metrics({k: truth.copy() for k in ('1.1', '1.2', 'deepmind')}, truth)
+        for result in metrics.values():
+            self.assertAlmostEqual(result['mean_track_error_km'], 0)
+            self.assertAlmostEqual(result['direction_error_deg'], 0)
+            self.assertAlmostEqual(result['shape_similarity'], 1)
+
+    def test_direction_mask_is_common_to_all_three_models(self):
+        path = np.stack([np.arange(1, 21)*10, np.zeros(20)], -1)
+        stationary = np.zeros((20, 2))
+        results = route_metrics({'1.1': path, '1.2': path, 'deepmind': stationary}, path)
+        self.assertTrue(all(r['direction_valid_steps'] == 0 and r['direction_error_deg'] is None for r in results.values()))
+
+    def test_curve_shape_is_not_pressure_level_error(self):
+        truth = np.arange(20, dtype=float)+950
+        self.assertAlmostEqual(curve_similarity(truth+20, truth), 1)
+        self.assertIsNone(curve_similarity(np.ones(20), truth))
+        self.assertIsNone(curve_similarity(truth[:5], truth[:5]))
+
+    def test_missing_and_invalid_pressure_never_become_zero_errors(self):
+        truth = np.full(20, 950.)
+        one, two, candidate = truth.copy(), truth.copy(), truth.copy()
+        one[0], two[1], candidate[2] = np.nan, 0, 700
+        mask = pressure_mask(truth, {'1.1': one, '1.2': two, 'deepmind': candidate})
+        self.assertEqual(mask.sum(), 17)
+        self.assertFalse(mask[:3].any())
+        with self.assertRaises(ValueError):
+            pressure_mask(truth, {'model': truth[:19]})
+
+    def test_longitude_wrap_keeps_geographic_alignment(self):
+        result = local(np.array([[0., 1.]]), 0., 359.)
+        self.assertAlmostEqual(result[0, 0], 222.4)
+
+    def test_empty_coverage_is_null_not_a_zero_score(self):
+        results = aggregate({})
+        self.assertIsNone(results['route']['deepmind']['mean_track_error_km']['value'])
+        self.assertIsNone(results['pressure']['JMA']['models']['deepmind']['mae_hpa']['value'])
+
+    def test_worker_never_reads_scoring_labels(self):
+        source = Path(__file__).with_name('deepmind_daily_benchmark.py').read_text()
+        worker = next(n for n in ast.parse(source).body if isinstance(n, ast.FunctionDef) and n.name == 'worker')
+        segment = ast.get_source_segment(source, worker)
+        self.assertNotIn('truth_local', segment)
+        self.assertNotIn('intensity-v12-v11', segment)
+        self.assertNotIn('np.load', segment)
+        self.assertIn('targets*np.nan', segment)
+
+
+if __name__ == '__main__':
+    unittest.main()

release_tools/test_public_model_cards.py

@@ -13,22 +13,22 @@ class PublicModelCardsTest(unittest.TestCase):
     def test_full_card_and_remote_metadata_are_preserved(self):
         rendered = render_card(self.original, self.source)
         self.assertTrue(rendered.startswith(self.header))
-        for text in ('README revision: 1 October 2026',
-                     'Daily-issue benchmark: 1,473 forecasts',
-                     'API contract **1.1**', 'still partial', '25.03 kt'):
+        for text in ('# Introducing Trackformer 1.2', '1,473 days / 270 storms',
+                     '134 days / 40 storms', '13.53', '12.84',
+                     'scores are **pending**', 'no native wind-radius forecast head'):
             self.assertIn(text, rendered)
-        self.assertIn('N/A — no radius head', rendered)
+        self.assertNotIn('README revision', rendered)
+        self.assertNotIn('Corrected pressure forecast', rendered)
         self.assertNotIn('Old model card', rendered)
 
-    def test_exactly_four_pinned_players_and_corrected_primary(self):
+    def test_one_pinned_featured_player(self):
         rendered = render_card(self.original, self.source)
-        self.assertEqual(rendered.count('<video '), 4)
-        for stem in ('fung_wong', 'soudelor', 'mangkhut', 'meranti'):
-            self.assertEqual(rendered.count('src="' + media_url(stem) + '"'), 1)
-        self.assertLess(rendered.index('src="' + media_url('mangkhut') + '"'), rendered.index('## What changed'))
-        self.assertNotIn('/resolve/main/docs/trackformer_', rendered)
+        self.assertEqual(rendered.count('<video '), 1)
+        self.assertEqual(rendered.count('src="' + media_url('mangkhut') + '"'), 1)
+        self.assertLess(rendered.index('src="' + media_url('mangkhut') + '"'), rendered.index('## What improves'))
+        self.assertIsNone(re.search(r'/resolve/main/docs/trackformer_[^"\s)]+\.mp4', rendered))
         self.assertIn(MEDIA_REVISION, rendered)
-        self.assertIn('Original fixed-patch film', rendered)
+        self.assertIn('docs/showcase_archive.md', rendered)
 
     def test_no_github_relative_links_survive(self):
         rendered = render_card(self.original, self.source)
@@ -36,8 +36,8 @@ class PublicModelCardsTest(unittest.TestCase):
             self.assertTrue(url.startswith(('https:', 'http:', '#', 'mailto:')), url)
 
     def test_missing_anchor_fails_instead_of_partial_stale_update(self):
-        with self.assertRaisesRegex(ValueError, 'corrected-film'):
-            render_card(self.original, self.source.replace('## Corrected pressure forecast', '## Wrong heading'))
+        with self.assertRaisesRegex(ValueError, 'featured-film'):
+            render_card(self.original, self.source.replace('## See the forecast:', '## Wrong heading:'))
 
     def test_missing_metadata_fails_closed(self):
         with self.assertRaisesRegex(ValueError, 'YAML metadata'):
@@ -47,19 +47,22 @@ class PublicModelCardsTest(unittest.TestCase):
         with self.assertRaisesRegex(ValueError, 'relative public link'):
             render_card(self.original, self.source + '\n[No secrets](../../private-file.txt)\n')
 
-    def test_updated_pressure_graph_and_paper_are_published_together(self):
+    def test_new_figures_are_pinned_without_changing_weights_or_paper(self):
         revision = 'a' * 40
         rendered = render_card(self.original, self.source, revision)
-        for text in ('Pressure graph similarity', '0.7074', '0.7118', '0.7237', '0.6637', '131 days', 'time-warped', 'slight mean improvement', '13.53 to 12.84'):
+        for text in ('41.0%', '95% interval includes no improvement', 'same frozen starts',
+                     'Missing labels', 'certified untouched holdout', '50-member mean'):
             self.assertIn(text, rendered)
         for path in CURRENT_FIGURES:
             self.assertIn('/resolve/' + revision + '/' + path, rendered)
             self.assertIn(path, SYNC_FILES)
-        for path in ('paper/trackformer.tex', 'paper/trackformer.pdf',
+        for path in ('docs/deepmind_daily_benchmark.md', 'docs/showcase_archive.md',
                      'evaluation/released_daily/released_daily_benchmark.json',
                      'evaluation/released_daily/released_daily_verification.json'):
             self.assertIn(path, SYNC_FILES)
         self.assertNotIn('models/trackformer_1_2_field/weights.pt', SYNC_FILES)
+        self.assertNotIn('paper/trackformer.tex', SYNC_FILES)
+        self.assertNotIn('paper/trackformer.pdf', SYNC_FILES)
         for path in SYNC_FILES:
             self.assertTrue((ROOT / path).is_file(), path)