Submission 007 - temperature-gated causal identity ensemble

Primary artifact SHA-256: 3fdac6f588b779f6a1aa6bd224ed7ad460b7165eda5e7b1060ef5484edf4b804. Preserves the successful V05 artifact byte-for-byte as submission_artifacts/v05_planner.joblib (63d71091d7f46e8fb11798b7c2be936cc7e0022954824a4eb98c07dc1bf9b0b3). Verified CPU/no-network Docker package; 57 tests and deterministic 19,890-row replay passed.

.dockerignore

@@ -0,0 +1,10 @@
+.git
+.venv
+__pycache__
+*.py[cod]
+.pytest_cache
+.env
+artifacts
+data
+submission.csv
+catboost_info

.gitignore

@@ -5,10 +5,27 @@ __pycache__/
 .venv/
 .env
 
-data/
-artifacts/
-submission.csv
-*.log
+# Competition data and generated artifacts
+data/raw/*
+!data/raw/.gitkeep
+data/processed/*
+!data/processed/.gitkeep
+artifacts/*
+!artifacts/.gitkeep
+submission_artifacts/*
+!submission_artifacts/planner.json
+!submission_artifacts/identity_planner.json
+!submission_artifacts/temperature_planner.json
 
+# Model files
+*.cbm
+*.pkl
 *.joblib
 !submission_artifacts/planner.joblib
+!submission_artifacts/identity_planner.joblib
+!submission_artifacts/temperature_planner.joblib
+!submission_artifacts/v05_planner.joblib
+
+# Local training logs
+catboost_info/
+submission.csv

Dockerfile

@@ -1,6 +1,4 @@
-FROM huggingface/competitions:latest
-
-ENV BATTERYSWAP_SPLITS=train
+FROM huggingface/competitions@sha256:6cea4ff69a6832761484f48c07ccfbf49f701f285ffcb9fc72a4ecfb81b6b4e5
 
 ENV BATTERYSWAP_SUBMISSION_PATH=submission.csv
 ENV PYTHONPATH=/app/src
@@ -10,8 +8,8 @@ WORKDIR /app
 COPY requirements.txt ./
 RUN /app/env/bin/python3 -m pip install --no-cache-dir -r requirements.txt
 
-# Fail instead of silently benchmarking against a different competition runtime.
-RUN /app/env/bin/python3 -c "import importlib.metadata as m; expected={'batteryswap_public':'0.3.4','fastparquet':'2026.5.0','joblib':'1.5.3','numpy':'2.2.6','pandas':'2.3.3','scikit-learn':'1.7.2'}; actual={name:m.version(name) for name in expected}; assert actual == expected, (actual, expected); print(actual)"
+# Verifies evaluator package versions.
+RUN /app/env/bin/python3 -c "import importlib.metadata as m; expected={'batteryswap_public':'0.3.4','fastparquet':'2026.5.0','joblib':'1.5.3','numpy':'2.2.6','pandas':'2.3.3','pydantic-settings':'2.15.0','scikit-learn':'1.7.2','scipy':'1.14.1','structlog':'26.1.0'}; actual={name:m.version(name) for name in expected}; assert actual == expected, (actual, expected); print(actual)"
 
 COPY src/ ./src/
 COPY submission_artifacts/ ./submission_artifacts/

README.md

@@ -1,47 +1,66 @@
-# BatterySwapAI 2026 — V05 (official scenario interface)
+# BatterySwapAI 2026 — temperature-gated identity candidate
 
-Candidate. Not submitted. V04 remains the best public result (1407.63), but it was produced by a
-pipeline that read sensor rows timestamped after the scenario start.
+Local candidate only. It has not been submitted to the evaluator. The publicly proven V05 artifact
+remains preserved in the Hugging Face repository and its history (`1541.3141`, Hub revision
+`dfa8acbc`, artifact SHA-256 `63d71091d7f46e8fb11798b7c2be936cc7e0022954824a4eb98c07dc1bf9b0b3`).
 
-- Building-held-out score, official cut: **1598.26**
-- Late / early: **754.79 / 618.06**
-- Event ranking: AP **0.4170**, AUC 0.9586
-- Mean scheduled batteries: **15.75**
-- Tests: **44/44 passed**
-- Artifact SHA-256: `63d71091d7f46e8fb11798b7c2be936cc7e0022954824a4eb98c07dc1bf9b0b3`
-- Base: `research/v4-first-place` at `5ade97b8ab7b33e10a00f9d182a7ebcde69bc89c`
+## Current result
 
-## What changed
+The primary candidate combines the V06 full-lookback planner with two independently fitted identity-preserving
+rank signals (censored long-term first-passage AFT and K=8 cross-building trajectory similarity),
+then applies a seasonal temperature forecast only to batteries whose forecast minimum smoothed
+voltage is at most **2.50 V**. The 2.50 V gate is fixed in production and preserves the planner's
+risk multiset within each freshness stratum.
 
-**Official scenario input.** `iterate_scenarios` yields a `cut` truncated at
-`end_time <= scenario.start_time`, and `make_submissions` passes exactly that to the planner.
-Our pipeline discarded it and rebuilt features from the whole split, so the cutoff day's bucket
-carried that day's later hourly readings — 7,274 to 9,847 rows per scenario. Inference now
-consumes the cut, and `scenario_history` truncates defensively at the same boundary.
+Leakage-clean outer replay on all 48 official train scenarios:
 
-**Degradation dynamics.** Threshold-crossing forecasts trained on every observed sensor
-transition plus biweekly voltage bins back to one year, blended into the event ranking as a 0.25
-residual nudge. Worth −76.0 against the same blend under the official cut.
+| candidate | mean total | delta vs clean operational reference | first / second half | paired t |
+|---|---:|---:|---:|---:|
+| **temperature <=2.50 V (primary)** | **1534.8431** | **-78.4134** | **-110.9689 / -45.8578** | **-2.3034** |
+| identity-only fallback | 1569.8205 | -43.4359 | -75.3522 / -11.5196 | -1.1667 |
+| clean V05 predictions + V06/V07 policy reference | 1613.2564 | — | — | — |
 
-## Validation
+The primary improved 23 scenarios, tied 12, and worsened 13. It passes the predeclared gate:
+delta <= -40, neither chronological half worse, and paired t <= -2. The unrestricted temperature
+rerank and the tighter 2.40 V gate were both weaker; no post-result grid search is used.
 
-Historical families re-baselined on identical building-held-out folds and the official cut:
+These local absolute totals are not directly comparable with the public leaderboard. The evidence
+supports the candidate by paired delta against the same clean reference, not by claiming a public
+score. The public V05 result remains the only submitted anchor.
 
-| generation | public | AP | total | late | early |
-|---|---|---|---|---|---|
-| **V05** | — | 0.4170 | **1598.26** | 754.79 | 618.06 |
-| V04 | 1407.63 | 0.4099 | 1674.27 | 831.88 | 623.12 |
-| V03 | 1700.12 | 0.3947 | 1757.11 | 657.29 | 826.50 |
-| V01 | 1576.57 | 0.3972 | 1766.77 | 892.08 | 598.99 |
+## Causal and official contract
 
-Removing the post-cutoff readings costs about 290 points: the same V04 model scores 1384.08 under
-the old pipeline and 1674.27 under the official cut.
+- Every scenario uses only readings with `end_time <= scenario.start_time`.
+- EOL is reconstructed exactly as the organizer evaluator does: strict `10 < temperature < 30`,
+  daily median, days with fewer than five readings masked, seven-calendar-day rolling median with
+  `min_periods=3`, and first smoothed voltage `<= 2.40 V`.
+- The reconstruction matches all 82 observed train EOL devices exactly; censored devices remain
+  censored.
+- Each outer validation fold rebuilds trajectory, EOL, and model state from outer-train batteries
+  only. Assertions require zero held-out battery, building, trajectory, and EOL overlap.
+- Production feature replay matches all 19,890 frozen causal rows; see
+  `artifacts/identity_feature_parity.json` after running the release checks.
+- Runtime uses `batteryswap_public==0.3.4`, CPU only, no network, and emits every live battery once
+  with a valid plan date.
 
-## Artifact
+## Artifacts
 
-Trained and serialised under scikit-learn `1.7.2`, numpy `2.2.6`, pandas `2.3.3`.
-215 s and 1.68 GB per split; deterministic and byte-identical with `--network none`.
+- `submission_artifacts/temperature_planner.joblib`: primary candidate and the default in
+  `script.py`.
+- `submission_artifacts/identity_planner.joblib`: identity-only fallback.
+- `submission_artifacts/planner.joblib`: byte-preserved V06 full-lookback base, SHA-256
+  `3cfca2e7dd2c05ddd84f2eca42a484168a1ab4ad3cd454806ef4e687fe8f1569`.
+- During the Hub upload, the public V05 artifact is archived byte-for-byte as
+  `submission_artifacts/v05_planner.joblib` before the local V06 base is placed at
+  `submission_artifacts/planner.joblib`.
 
-## How to reproduce
+Each candidate manifest records its artifact hash, raw dataset hashes, source hashes, fitted AFT
+parameters, donor-library hashes, temperature coefficient/gate, dependency versions, and the
+unchanged embedded V06 base hash. Exact release commands and evidence are in `REPRODUCIBILITY.md`.
 
-See `REPRODUCIBILITY.md`.
+## External eligibility checks
+
+Participant code is MIT. The organizer-required `batteryswap_public` package does not declare a
+license in its PyPI metadata, and the official evaluator base includes an NVIDIA container license
+notice. These are recorded in `THIRD_PARTY_LICENSES.md`; organizer confirmation is the only
+remaining user-owned licensing check.

REPRODUCIBILITY.md

@@ -1,62 +1,114 @@
-# Reproduce V05
+# Reproduce the temperature-gated candidate
 
-Dataset revision:
+Dataset revision: `7f423ac4cb6ab146f7ea7a37872eb4dfc3c9705c`.
 
-```text
-7f423ac4cb6ab146f7ea7a37872eb4dfc3c9705c
-```
+Place the official train split in `data/raw/train/`. All fitting commands below rebuild features
+from raw official data; persisted experiment rows are optional equality checks, never training
+inputs. Do not replace the pinned local V06 full-lookback base artifact. The public V05 artifact is
+preserved separately on the Hub and on the `public/v05` Git branch.
 
-Put the public train split in `data/raw/train/`.
+## Build both fallbacks and the primary
 
-## Install
+Build the pinned evaluator image:
 
 ```bash
-python -m venv .venv
-source .venv/bin/activate
-pip install -e . -r requirements.txt -r requirements.dev.txt
+docker build -t batteryswap-temperature .
 ```
 
-## Train and validate
+Use the evaluator interpreter for fitting:
 
 ```bash
-python scripts/train_submission.py
-python scripts/validate_submission.py --outer-group building
-pytest
+docker run --rm -v "$(pwd)":/work -w /work -e PYTHONPATH=/work/src \
+  batteryswap-temperature /app/env/bin/python3 scripts/build_identity_submission.py \
+  --output submission_artifacts/identity_planner.joblib \
+  --manifest submission_artifacts/identity_planner.json
+
+docker run --rm -v "$(pwd)":/work -w /work -e PYTHONPATH=/work/src \
+  batteryswap-temperature /app/env/bin/python3 scripts/build_identity_submission.py \
+  --with-seasonal \
+  --output submission_artifacts/temperature_planner.joblib \
+  --manifest submission_artifacts/temperature_planner.json
 ```
 
-Expected checks:
+Each build records the exact resulting artifact hash in its manifest. Re-pickling the wrapped V06
+estimator is not guaranteed to reproduce identical artifact bytes; release determinism is therefore
+checked on the two emitted submission CSVs below. The builder asserts the raw row count, all 82
+exact EOL crossings, AFT reference equality when available, expected donor-library dimensions
+(82 devices, 24 buildings, 7,257 endpoints), rounded temperature coefficient, and byte preservation
+of the local V06 base artifact.
 
-```text
-44/44 tests pass
-building-held-out score: 1598.26
-mean scheduled batteries: 15.75
-artifact SHA-256: 63d71091d7f46e8fb11798b7c2be936cc7e0022954824a4eb98c07dc1bf9b0b3
+## Leakage-clean validation
+
+Generate outer predictions with all auxiliary state restricted to the outer-train batteries:
+
+```bash
+docker run --rm -v "$(pwd)":/work -w /work -e PYTHONPATH=/work/src \
+  batteryswap-temperature /app/env/bin/python3 scripts/validate_submission.py \
+  --outer-group building --output artifacts/clean_v05_outer_oof.json
 ```
 
-Train the artifact under the evaluator runtime, not a local interpreter:
+Replay production features and the exact evaluator:
 
 ```bash
-docker run --rm -v "$(pwd)":/work -v "$(pwd)/data/raw":/data:ro -w /work \
-  -e PYTHONPATH=/work/src batteryswap-v4 \
-  /app/env/bin/python3 scripts/train_submission.py --dataset-path /data/train
+docker run --rm -v "$(pwd)":/work -w /work -e PYTHONPATH=/work/src \
+  batteryswap-temperature /app/env/bin/python3 scripts/verify_identity_feature_parity.py
+
+docker run --rm -v "$(pwd)":/work -w /work -e PYTHONPATH=/work/src \
+  batteryswap-temperature /app/env/bin/python3 scripts/evaluate_clean_identity_candidate.py
 ```
 
-## Docker check
+Expected primary evidence:
+
+```text
+rows: 19,890
+clean operational reference mean total: 1613.256409722222
+temperature <=2.50 V mean total: 1534.843055555556
+mean paired delta: -78.413354166667
+chronological halves: -110.968895833333 / -45.857812500000
+paired t: -2.303438305449
+strict promotion gate: PASS
+```
+
+The clean prediction CSV fingerprint is
+`c810f68e73f62f15cf1d4d19574d5a1ec4ab0916edde3096bca9ad6b00332cbb`.
+
+## Tests and evaluator-runtime release gate
 
 ```bash
-docker build -t batteryswap-v4 .
+docker run --rm -v "$(pwd)":/work -w /work -e PYTHONPATH=/work/src \
+  batteryswap-temperature /app/env/bin/python3 -m pytest -q
 ```
 
+Rebuild the image after the final artifacts are frozen, then run the submission twice with network
+disabled. Use separate output filenames and compare their SHA-256 hashes:
+
 ```bash
-docker run --rm -e BATTERYSWAP_SPLITS=train -v "$(pwd)/data/raw":/tmp/data:ro batteryswap-v4 \
-  bash -c "/app/env/bin/python3 script.py && /app/env/bin/python3 -m batteryswap_public.metric"
+docker build -t batteryswap-temperature .
+
+docker run --rm --network none \
+  -e BATTERYSWAP_SPLITS=train \
+  -e BATTERYSWAP_SUBMISSION_PATH=/out/submission-1.csv \
+  -v "$(pwd)/data/raw":/tmp/data:ro -v "$(pwd)/artifacts":/out \
+  batteryswap-temperature \
+  bash -lc 'time /app/env/bin/python3 script.py'
+
+docker run --rm --network none \
+  -e BATTERYSWAP_SPLITS=train \
+  -e BATTERYSWAP_SUBMISSION_PATH=/out/submission-2.csv \
+  -v "$(pwd)/data/raw":/tmp/data:ro -v "$(pwd)/artifacts":/out \
+  batteryswap-temperature \
+  bash -lc 'time /app/env/bin/python3 script.py'
+
+sha256sum artifacts/submission-1.csv artifacts/submission-2.csv
 ```
 
-The Docker run must produce all 19,890 required rows under the evaluator runtime.
-Measured: 215 s per split, 1.68 GB peak RSS, byte-identical output across repeated runs.
+The hashes must match, every plan must pass the output invariants in `script.py`, elapsed time must
+remain under 30 minutes per evaluator split, and peak container memory from `docker stats` must
+remain below 32 GB. Record the measured final values in `artifacts/release_gate.json`; artifact
+hashes are authoritative in the two candidate manifests.
 
-## Artifact reproducibility
+## Deliberate staging only
 
-Retraining reproduces the model but not the exact bytes: independently trained artifacts differ
-in serialisation while agreeing to 5e-11 in predicted risk and producing byte-identical plans.
-Verify a rebuild by comparing plans, not SHAs.
+No command in this document pushes, submits, or chooses a final. After reviewing the ranked
+handoff, stage a chosen artifact explicitly with `BATTERYSWAP_PLANNER_PATH`; keep V05 available for
+immediate rollback.

THIRD_PARTY_LICENSES.md

@@ -4,15 +4,25 @@ This table lists the direct third-party packages used by the project. No third-p
 
 | Package | Declared / verified version | Source | License |
 |---|---:|---|---|
-| NumPy | >=2.2.0 / 2.5.2 training, 2.2.6 parity | https://numpy.org/ | BSD-3-Clause and bundled permissive licenses |
-| pandas | >=2.3.0 / 3.0.5 training, 2.3.3 parity | https://pandas.pydata.org/ | BSD-3-Clause |
-| scikit-learn | >=1.7.0 / 1.9.0 training, 1.7.2 parity | https://scikit-learn.org/ | BSD-3-Clause |
-| joblib | >=1.5.3 / 1.5.3 | https://joblib.readthedocs.io/ | BSD-3-Clause |
-| fastparquet | >=2026.5.0 / 2026.5.0 | https://github.com/dask/fastparquet | Apache-2.0 |
-| pydantic-settings | >=2.14.1 / 2.15.0 parity | https://github.com/pydantic/pydantic-settings | MIT |
-| structlog | >=25.5.0 / 26.1.0 parity | https://www.structlog.org/ | MIT or Apache-2.0 |
-| huggingface-hub | >=0.34 | https://github.com/huggingface/huggingface_hub | Apache-2.0 |
-| PyYAML | >=6.0 | https://pyyaml.org/ | MIT |
-| batteryswap_public | >=0.1.0 / 0.3.4 | https://pypi.org/project/batteryswap-public/ | Organizer package; PyPI metadata does not declare a license |
+| NumPy | 2.2.6 | https://numpy.org/ | BSD-3-Clause and bundled permissive licenses |
+| pandas | 2.3.3 | https://pandas.pydata.org/ | BSD-3-Clause |
+| scikit-learn | 1.7.2 | https://scikit-learn.org/ | BSD-3-Clause |
+| SciPy | 1.14.1 | https://scipy.org/ | BSD-3-Clause and bundled permissive licenses |
+| joblib | 1.5.3 | https://joblib.readthedocs.io/ | BSD-3-Clause |
+| fastparquet | 2026.5.0 | https://github.com/dask/fastparquet | Apache-2.0 |
+| pydantic-settings | 2.15.0 | https://github.com/pydantic/pydantic-settings | MIT |
+| structlog | 26.1.0 | https://www.structlog.org/ | MIT or Apache-2.0 |
+| huggingface-hub | 0.34.4 (development/publishing only) | https://github.com/huggingface/huggingface_hub | Apache-2.0 |
+| PyYAML | 6.0.2 (development only) | https://pyyaml.org/ | MIT |
+| pyarrow | 25.0.1 (optional development parquet backend) | https://arrow.apache.org/ | Apache-2.0 |
+| pytest | 9.0.2 (tests only) | https://pytest.org/ | MIT |
+| batteryswap_public | 0.3.4 | https://pypi.org/project/batteryswap-public/ | Organizer package; PyPI metadata does not declare a license |
 
 `batteryswap_public` is required by the official example and evaluation interface. Its PyPI metadata does not state a license. Obtain written organizer confirmation before the competition deadline.
+
+The submission image is the organizer/example base
+`huggingface/competitions@sha256:6cea4ff69a6832761484f48c07ccfbf49f701f285ffcb9fc72a4ecfb81b6b4e5`.
+It contains the NVIDIA Deep Learning Container license notice even though this entry is
+CPU-only. Because this is the official evaluator base rather than participant code, it is
+recorded separately; obtain organizer confirmation together with `batteryswap_public` if
+prize-eligibility review requires an explicit exception.

pyproject.toml

@@ -5,8 +5,30 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "batteryswapai-2026"
 version = "0.1.0"
-description = "BatterySwapAI 2026 submission"
+description = "Battery replacement planner for BatterySwapAI 2026"
+readme = "README.md"
 requires-python = ">=3.10"
+dependencies = [
+  "batteryswap_public==0.3.4",
+  "fastparquet==2026.5.0",
+  "huggingface-hub==0.34.4",
+  "joblib==1.5.3",
+  "numpy==2.2.6",
+  "pandas==2.3.3",
+  "pydantic-settings==2.15.0",
+  "pyyaml==6.0.2",
+  "scipy==1.14.1",
+  "scikit-learn==1.7.2",
+  "structlog==26.1.0",
+]
+
+[project.optional-dependencies]
+dev = ["pytest==9.0.2"]
+parquet = ["pyarrow>=19.0"]
+legacy-trees = ["catboost>=1.2.8", "lightgbm>=4.6"]
+
+[project.scripts]
+bsa = "batteryswapai.cli:main"
 
 [tool.setuptools.packages.find]
 where = ["src"]

requirements.dev.txt

@@ -1,5 +1,5 @@
 -r requirements.txt
-huggingface-hub>=0.34
+huggingface-hub==0.34.4
 pyarrow==25.0.1
-pytest>=8.3
-pyyaml>=6.0
+pytest==9.0.2
+pyyaml==6.0.2

requirements.txt

@@ -1,11 +1,10 @@
-# Core packages observed in the competition runtime.
 batteryswap_public==0.3.4
 fastparquet==2026.5.0
 joblib==1.5.3
 numpy==2.2.6
 pandas==2.3.3
 scikit-learn==1.7.2
+scipy==1.14.1
 
-# Supporting packages used by the project tooling.
-pydantic-settings>=2.14.1
-structlog>=25.5.0
+pydantic-settings==2.15.0
+structlog==26.1.0

script.py

@@ -13,24 +13,65 @@ from batteryswap_public.utils import iterate_scenarios, load_dataset
 from batteryswapai.competition_features import scenario_history_snapshot
 
 
+def _assert_complete_plan(
+    plan: pd.DataFrame, locations: pd.DataFrame, scenario_name: str
+) -> None:
+    required = {"day", "battery"}
+    missing = required - set(plan.columns)
+    if missing:
+        raise AssertionError(
+            f"plan {scenario_name} lacks columns: {sorted(missing)}"
+        )
+    expected = locations["battery"].astype(str)
+    actual = plan["battery"].astype(str)
+    if len(plan) != len(locations) or actual.duplicated().any():
+        raise AssertionError(
+            f"plan {scenario_name} must contain each live battery exactly once"
+        )
+    if set(actual) != set(expected):
+        missing_batteries = sorted(set(expected) - set(actual))
+        extra_batteries = sorted(set(actual) - set(expected))
+        raise AssertionError(
+            f"plan {scenario_name} battery mismatch: "
+            f"missing={missing_batteries[:3]}, extra={extra_batteries[:3]}"
+        )
+    parsed_days = pd.to_datetime(plan["day"], errors="coerce")
+    if parsed_days.isna().any():
+        raise AssertionError(f"plan {scenario_name} contains an invalid day")
+
+
 def main() -> None:
     dataset_path = Path(os.environ.get("BATTERYSWAP_DATASET_PATH", "/tmp/data"))
     artifact_path = Path(
-        os.environ.get("BATTERYSWAP_PLANNER_PATH", "submission_artifacts/planner.joblib")
+        os.environ.get(
+            "BATTERYSWAP_PLANNER_PATH",
+            "submission_artifacts/temperature_planner.joblib",
+        )
     )
-    splits = os.environ.get("BATTERYSWAP_SPLITS", "public,private").split(",")
+    splits = [
+        split.strip()
+        for split in os.environ.get("BATTERYSWAP_SPLITS", "public,private").split(",")
+        if split.strip()
+    ]
     output_path = Path(os.environ.get("BATTERYSWAP_SUBMISSION_PATH", "submission.csv"))
 
+    if not artifact_path.is_file():
+        raise FileNotFoundError(f"Planner artifact does not exist: {artifact_path}")
     planner = joblib.load(artifact_path)
 
     plans = []
     for split in splits:
-        locations, timeseries, hidden_eol_times, scenarios = load_dataset(dataset_path / split)
+        locations, timeseries, eol_times_for_iterator, scenarios = load_dataset(
+            dataset_path / split
+        )
+        reset_split = getattr(planner, "reset_split", None)
+        if reset_split is not None:
+            reset_split(split)
 
         for scenario, locs, visible_history, _ in iterate_scenarios(
             locations,
             timeseries,
-            hidden_eol_times,
+            eol_times_for_iterator,
             scenarios,
         ):
             snapshot = scenario_history_snapshot(
@@ -40,19 +81,33 @@ def main() -> None:
                 scenario["start_time"],
             )
 
-            plan = planner.plan_snapshot(
-                snapshot,
-                locs,
-                scenario["travel_costs"],
-                scenario["settings"],
-                scenario["start_time"],
-            )
+            plan_scenario = getattr(planner, "plan_scenario", None)
+            if plan_scenario is None:
+                plan = planner.plan_snapshot(
+                    snapshot,
+                    locs,
+                    scenario["travel_costs"],
+                    scenario["settings"],
+                    scenario["start_time"],
+                )
+            else:
+                plan = plan_scenario(
+                    visible_history,
+                    snapshot,
+                    locs,
+                    scenario["travel_costs"],
+                    scenario["settings"],
+                    scenario["start_time"],
+                )
 
+            _assert_complete_plan(plan, locs, str(scenario["name"]))
             plan["split"] = split
             plan["scenario"] = scenario["name"]
             plans.append(plan)
 
     submission = pd.concat(plans, ignore_index=True)
+    if submission.duplicated(["split", "scenario", "battery"]).any():
+        raise AssertionError("submission contains duplicate split/scenario/battery rows")
     submission.to_csv(output_path, index=False)
 
     if not output_path.exists():

scripts/build_identity_submission.py

@@ -0,0 +1,490 @@
+"""Fit and serialize the deployable LT/sim/seasonal identity wrapper.
+
+This builder never overwrites the frozen base planner.  OOF experiment rows are
+used only for their strictly causal first-passage training covariates; the AFT
+is refit on every train building and the similarity library is rebuilt directly
+from the train split.
+"""
+
+from __future__ import annotations
+
+import argparse
+import dataclasses
+import hashlib
+import importlib.metadata
+import json
+from pathlib import Path
+
+import joblib
+import numpy as np
+import pandas as pd
+from batteryswap_public.utils import iterate_scenarios, load_dataset
+
+from batteryswapai.identity_ensemble import (
+    FROZEN_TEMPERATURE_BETA_V_PER_C,
+    TEMPERATURE_MAX_PREDICTED_MIN_VOLTAGE,
+    CausalHistoryCache,
+    IdentityEnsembleModel,
+    IdentityEnsemblePlanner,
+    LongTermAFTResidual,
+    OriginalSimilarityResidual,
+    SCHEMA_VERSION,
+    SeasonalTemperatureResidual,
+    WeightedIdentityResidual,
+    build_similarity_donor_library,
+    exact_smoothed_voltage,
+    fit_aft,
+    fit_temperature_beta,
+    _first_passage_lifetime,
+)
+
+
+DATASET_REVISION = "7f423ac4cb6ab146f7ea7a37872eb4dfc3c9705c"
+EXPECTED_BASE_SHA256 = "3cfca2e7dd2c05ddd84f2eca42a484168a1ab4ad3cd454806ef4e687fe8f1569"
+EXPECTED_ROWS = 19_890
+EXPECTED_EOL_DEVICES = 82
+EXPECTED_DONOR_DEVICES = 82
+EXPECTED_DONOR_BUILDINGS = 24
+EXPECTED_DONOR_ENDPOINTS = 7_257
+CONTAINER_BASE = (
+    "huggingface/competitions@sha256:"
+    "6cea4ff69a6832761484f48c07ccfbf49f701f285ffcb9fc72a4ecfb81b6b4e5"
+)
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--dataset-path", type=Path, default=Path("data/raw/train"))
+    parser.add_argument(
+        "--base-artifact",
+        type=Path,
+        default=Path("submission_artifacts/planner.joblib"),
+    )
+    parser.add_argument(
+        "--lt-reference-rows",
+        type=Path,
+        default=Path("artifacts/lt_fp_aft_official.rows.csv"),
+        help=(
+            "Optional validation-only reference. Training covariates are always "
+            "rebuilt from raw train prefixes; this file is never required."
+        ),
+    )
+    parser.add_argument(
+        "--output",
+        type=Path,
+        default=Path("submission_artifacts/identity_planner.joblib"),
+    )
+    parser.add_argument(
+        "--manifest",
+        type=Path,
+        default=Path("submission_artifacts/identity_planner.json"),
+    )
+    parser.add_argument(
+        "--expected-base-sha256", default=EXPECTED_BASE_SHA256
+    )
+    parser.add_argument(
+        "--with-seasonal",
+        action="store_true",
+        help="Add the promoted <=2.50 V seasonal-temperature post-rerank.",
+    )
+    return parser.parse_args()
+
+
+def _sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        while chunk := handle.read(1024 * 1024):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def _array_sha256(values: np.ndarray) -> str:
+    contiguous = np.ascontiguousarray(np.asarray(values))
+    if contiguous.dtype.hasobject:
+        payload = "\n".join(contiguous.astype(str).ravel()).encode("utf-8")
+    else:
+        payload = contiguous.view(np.uint8)
+    return hashlib.sha256(payload).hexdigest()
+
+
+def _dataset_manifest(dataset_path: Path) -> dict[str, str]:
+    return {
+        path.relative_to(dataset_path).as_posix(): _sha256(path)
+        for path in sorted(dataset_path.rglob("*"))
+        if path.is_file()
+    }
+
+
+def _source_hashes(repo_root: Path) -> dict[str, str]:
+    paths = (
+        repo_root / "src/batteryswapai/identity_ensemble.py",
+        repo_root / "src/batteryswapai/competition_planner.py",
+        repo_root / "scripts/build_identity_submission.py",
+        repo_root / "scripts/experiment_lt_fp_aft.py",
+        repo_root / "scripts/experiment_similarity_eol.py",
+        repo_root / "scripts/experiment_identity_ensemble.py",
+        repo_root / "scripts/experiment_temperature_physics_ensemble.py",
+        repo_root / "scripts/evaluate_clean_identity_candidate.py",
+        repo_root / "scripts/verify_identity_feature_parity.py",
+        repo_root / "script.py",
+        repo_root / "Dockerfile",
+        repo_root / "requirements.txt",
+        repo_root / "pyproject.toml",
+        repo_root / "LICENSE",
+        repo_root / "THIRD_PARTY_LICENSES.md",
+        repo_root / "README.md",
+        repo_root / "REPRODUCIBILITY.md",
+    )
+    return {
+        path.relative_to(repo_root).as_posix(): _sha256(path)
+        for path in paths
+        if path.exists()
+    }
+
+
+def _evidence_hashes(repo_root: Path) -> dict[str, str]:
+    paths = (
+        "artifacts/lt_fp_aft_official.json",
+        "artifacts/lt_fp_aft_official.rows.csv",
+        "artifacts/similarity_eol_official.json",
+        "artifacts/similarity_eol_official.rows.csv",
+        "artifacts/identity_ensemble_official.json",
+        "artifacts/identity_ensemble_official.rows.csv",
+        "artifacts/temperature_physics_ensemble_official.json",
+        "artifacts/temperature_physics_ensemble_official.rows.csv",
+        "artifacts/temperature_physics_globalbeta_diagnostic.json",
+    )
+    return {
+        name: _sha256(repo_root / name)
+        for name in paths
+        if (repo_root / name).exists()
+    }
+
+
+def _assert_eol_reconstruction(
+    smoothed: pd.DataFrame, eol_times: pd.Series
+) -> dict[str, int]:
+    crossings = (
+        smoothed[smoothed["smooth_voltage"].le(2.40)]
+        .groupby("device_id", observed=True)["end_time"]
+        .min()
+    )
+    crossings.index = crossings.index.astype(str)
+    observed = pd.to_datetime(eol_times.dropna(), errors="raise")
+    observed.index = observed.index.astype(str)
+    comparison = pd.DataFrame(
+        {
+            "official": observed.dt.normalize(),
+            "reconstructed": pd.to_datetime(crossings).dt.normalize(),
+        }
+    )
+    exact = int(
+        comparison.dropna()["official"].eq(comparison.dropna()["reconstructed"]).sum()
+    )
+    if len(observed) != EXPECTED_EOL_DEVICES or exact != EXPECTED_EOL_DEVICES:
+        raise AssertionError(
+            f"exact EOL reconstruction failed: observed={len(observed)}, exact={exact}"
+        )
+    return {"observed_eol_devices": len(observed), "exact_eol_matches": exact}
+
+
+def _build_aft_training_rows(
+    locations: pd.DataFrame,
+    timeseries: pd.DataFrame,
+    eol_times: pd.Series,
+    scenarios: list[dict],
+) -> pd.DataFrame:
+    """Rebuild the full-train AFT landmarks from official visible prefixes.
+
+    The serialized winner must be reproducible from the allowed train split alone.
+    Persisted OOF rows are useful parity evidence, but are deliberately not an input
+    to this builder.
+    """
+
+    cache = CausalHistoryCache(
+        beta_v_per_c=FROZEN_TEMPERATURE_BETA_V_PER_C,
+        split_id="train",
+    )
+    records: list[dict[str, object]] = []
+    for scenario, locs, visible, _ in iterate_scenarios(
+        locations, timeseries, eol_times, scenarios
+    ):
+        start = pd.Timestamp(scenario["start_time"])
+        history = cache.update(visible, start)
+        for row in locs.itertuples(index=False):
+            battery = str(row.battery)
+            installation = pd.Timestamp(row.start_time)
+            lifetime, reliable = _first_passage_lifetime(
+                battery,
+                start,
+                installation,
+                history.smooth_lookup,
+            )
+            event_time = pd.to_datetime(eol_times.get(battery), errors="coerce")
+            event_observed = bool(pd.notna(event_time))
+            outcome_time = (
+                pd.Timestamp(event_time)
+                if event_observed
+                else pd.Timestamp(row.end_time)
+            )
+            records.append(
+                {
+                    "scenario": str(scenario["name"]),
+                    "battery": battery,
+                    "fp_reliable": reliable,
+                    "fp_lifetime_days": lifetime,
+                    "landmark_age_days": float(
+                        (start - installation) / pd.Timedelta(days=1)
+                    ),
+                    "outcome_lifetime_days": float(
+                        (outcome_time - installation) / pd.Timedelta(days=1)
+                    ),
+                    "event_observed": event_observed,
+                }
+            )
+    result = pd.DataFrame(records)
+    if len(result) != EXPECTED_ROWS or result.duplicated(
+        ["scenario", "battery"]
+    ).any():
+        raise AssertionError(
+            "raw AFT landmark rebuild did not produce 19,890 unique rows"
+        )
+    return result
+
+
+def _verify_optional_aft_reference(
+    rebuilt: pd.DataFrame, reference_path: Path
+) -> dict[str, object] | None:
+    if not reference_path.exists():
+        return None
+    columns = [
+        "scenario",
+        "battery",
+        "fp_reliable",
+        "fp_lifetime_days",
+        "landmark_age_days",
+        "outcome_lifetime_days",
+        "event_observed",
+    ]
+    reference = pd.read_csv(reference_path, usecols=columns)
+    if len(reference) != len(rebuilt):
+        raise AssertionError("optional LT reference row count differs from raw rebuild")
+    if not rebuilt[["scenario", "battery"]].astype(str).equals(
+        reference[["scenario", "battery"]].astype(str)
+    ):
+        raise AssertionError("optional LT reference key order differs from raw rebuild")
+    for column in ("fp_reliable", "event_observed"):
+        if not np.array_equal(
+            rebuilt[column].to_numpy(bool),
+            reference[column].to_numpy(bool),
+        ):
+            raise AssertionError(
+                f"raw AFT {column} flags differ from LT reference"
+            )
+    for column in (
+        "fp_lifetime_days",
+        "landmark_age_days",
+        "outcome_lifetime_days",
+    ):
+        np.testing.assert_allclose(
+            rebuilt[column].to_numpy(float),
+            reference[column].to_numpy(float),
+            rtol=0.0,
+            atol=1e-12,
+            equal_nan=True,
+        )
+    return {
+        "path": reference_path.as_posix(),
+        "sha256": _sha256(reference_path),
+        "rows": len(reference),
+        "raw_rebuild_exact": True,
+    }
+
+
+def main() -> None:
+    args = parse_args()
+    repo_root = Path(__file__).resolve().parents[1]
+    base_sha_before = _sha256(args.base_artifact)
+    if base_sha_before != args.expected_base_sha256:
+        raise AssertionError(
+            "frozen base artifact changed: "
+            f"expected={args.expected_base_sha256}, actual={base_sha_before}"
+        )
+
+    locations, timeseries, eol_times, scenarios = load_dataset(args.dataset_path)
+    if len(scenarios) != 48:
+        raise AssertionError(f"expected 48 train scenarios, found {len(scenarios)}")
+    eol_times = eol_times.copy()
+    eol_times.index = eol_times.index.astype(str)
+
+    aft_rows = _build_aft_training_rows(
+        locations, timeseries, eol_times, scenarios
+    )
+    aft_reference = _verify_optional_aft_reference(
+        aft_rows, args.lt_reference_rows
+    )
+    aft_parameters, aft_diagnostics = fit_aft(aft_rows)
+
+    full_smoothed = exact_smoothed_voltage(timeseries)
+    smoothing_audit = _assert_eol_reconstruction(full_smoothed, eol_times)
+    mapping_rows = locations[["battery", "building"]].drop_duplicates()
+    if mapping_rows["battery"].duplicated().any():
+        raise AssertionError("a train battery maps to multiple buildings")
+    battery_building = dict(
+        zip(
+            mapping_rows["battery"].astype(str),
+            mapping_rows["building"].astype(str),
+            strict=True,
+        )
+    )
+    donor_library = build_similarity_donor_library(
+        full_smoothed, eol_times, battery_building
+    )
+    donor_counts = (
+        donor_library.donor_count,
+        donor_library.building_count,
+        donor_library.endpoint_count,
+    )
+    expected_counts = (
+        EXPECTED_DONOR_DEVICES,
+        EXPECTED_DONOR_BUILDINGS,
+        EXPECTED_DONOR_ENDPOINTS,
+    )
+    if donor_counts != expected_counts:
+        raise AssertionError(
+            f"full donor library changed: expected={expected_counts}, actual={donor_counts}"
+        )
+
+    fitted_beta, beta_diagnostics = fit_temperature_beta(timeseries)
+    if round(fitted_beta, 5) != FROZEN_TEMPERATURE_BETA_V_PER_C:
+        raise AssertionError(
+            "full-train temperature beta no longer reproduces the frozen value: "
+            f"fit={fitted_beta}, frozen={FROZEN_TEMPERATURE_BETA_V_PER_C}"
+        )
+    seasonal = SeasonalTemperatureResidual(
+        beta_v_per_c=FROZEN_TEMPERATURE_BETA_V_PER_C,
+        fitted_raw_beta_v_per_c=fitted_beta,
+        training_readings=int(beta_diagnostics["training_readings"]),
+        maximum_predicted_min_voltage=TEMPERATURE_MAX_PREDICTED_MIN_VOLTAGE,
+    )
+    ensemble = IdentityEnsembleModel(
+        identity_residuals=(
+            WeightedIdentityResidual(LongTermAFTResidual(aft_parameters), 0.50),
+            WeightedIdentityResidual(OriginalSimilarityResidual(donor_library), 0.50),
+        ),
+        post_residuals=(seasonal,) if args.with_seasonal else (),
+        history_temperature_beta_v_per_c=FROZEN_TEMPERATURE_BETA_V_PER_C,
+    )
+    base_planner = joblib.load(args.base_artifact)
+    wrapper = IdentityEnsemblePlanner(
+        base_planner=base_planner,
+        ensemble=ensemble,
+        base_artifact_sha256=base_sha_before,
+    )
+
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    joblib.dump(wrapper, args.output, compress=3)
+    base_sha_after = _sha256(args.base_artifact)
+    if base_sha_after != base_sha_before:
+        raise AssertionError("builder modified the frozen base artifact")
+
+    library_arrays = {
+        "values": donor_library.values,
+        "masks": donor_library.masks,
+        "donor_ids": donor_library.donor_ids,
+        "donor_buildings": donor_library.donor_buildings,
+        "donor_codes": donor_library.donor_codes,
+        "endpoint_days": donor_library.endpoint_days,
+        "residual_days": donor_library.residual_days,
+        "device_ids_by_code": donor_library.device_ids_by_code,
+        "device_buildings_by_code": donor_library.device_buildings_by_code,
+    }
+    manifest = {
+        "schema_version": SCHEMA_VERSION,
+        "dataset_revision": DATASET_REVISION,
+        "container_base": CONTAINER_BASE,
+        "artifact": args.output.as_posix(),
+        "artifact_sha256": _sha256(args.output),
+        "artifact_size_bytes": args.output.stat().st_size,
+        "base_artifact": args.base_artifact.as_posix(),
+        "base_artifact_sha256_before": base_sha_before,
+        "base_artifact_sha256_after": base_sha_after,
+        "base_artifact_byte_preserved": base_sha_before == base_sha_after,
+        "dataset_files": _dataset_manifest(args.dataset_path),
+        "training_source": {
+            "aft_landmarks": "rebuilt from official raw train visible prefixes",
+            "optional_lt_reference": aft_reference,
+        },
+        "source_sha256": _source_hashes(repo_root),
+        "validation_evidence_sha256": _evidence_hashes(repo_root),
+        "aft": {
+            "parameters": dataclasses.asdict(aft_parameters),
+            "diagnostics": aft_diagnostics,
+        },
+        "similarity_library": {
+            "donor_devices": donor_library.donor_count,
+            "donor_buildings": donor_library.building_count,
+            "donor_endpoints": donor_library.endpoint_count,
+            "prefix_lags": donor_library.values.shape[1],
+            "arrays": {
+                name: {
+                    "shape": list(np.asarray(values).shape),
+                    "dtype": str(np.asarray(values).dtype),
+                    "sha256": _array_sha256(values),
+                }
+                for name, values in library_arrays.items()
+            },
+        },
+        "seasonal_temperature": {
+            "enabled": args.with_seasonal,
+            "frozen_beta_v_per_c": FROZEN_TEMPERATURE_BETA_V_PER_C,
+            "maximum_predicted_min_voltage": (
+                TEMPERATURE_MAX_PREDICTED_MIN_VOLTAGE
+                if args.with_seasonal
+                else None
+            ),
+            "full_train_fit": beta_diagnostics,
+        },
+        "ensemble": {
+            "identity_components": [
+                {"name": item.residual.name, "weight": item.weight}
+                for item in ensemble.identity_residuals
+            ],
+            "post_components": [item.name for item in ensemble.post_residuals],
+            "freshness_stratified": True,
+            "raw_risk_multiset_preserved": True,
+            "planner_effective_risk_multiset_preserved": True,
+            "v07_emergency_scale": 0.75,
+            "v07_mean_trip_gate_hours": 8.0,
+        },
+        "smoothing_audit": smoothing_audit,
+        "runtime_versions": {
+            package: importlib.metadata.version(package)
+            for package in (
+                "batteryswap_public",
+                "fastparquet",
+                "joblib",
+                "numpy",
+                "pandas",
+                "pydantic-settings",
+                "scikit-learn",
+                "scipy",
+                "structlog",
+            )
+        },
+        "random_seeds": {
+            "base_model": 2026,
+            "identity_residuals": None,
+        },
+        "official_evaluator_run": False,
+    }
+    args.manifest.parent.mkdir(parents=True, exist_ok=True)
+    args.manifest.write_text(
+        json.dumps(manifest, indent=2, sort_keys=True, default=float),
+        encoding="utf-8",
+    )
+    print(json.dumps(manifest, indent=2, sort_keys=True, default=float))
+
+
+if __name__ == "__main__":
+    main()

scripts/evaluate_clean_identity_candidate.py

@@ -0,0 +1,450 @@
+"""Evaluate the frozen identity+temperature rerank on leakage-clean base OOF risks.
+
+The base predictions must come from outer-building fits whose trajectory matrix and
+EOL targets contain outer-train batteries only. Identity signals are the already
+frozen building-held-out AFT/similarity/temperature signals. No weights or policies
+are searched here.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import math
+from dataclasses import replace
+from pathlib import Path
+
+import joblib
+import numpy as np
+import pandas as pd
+from batteryswap_public.evaluate import evaluate_plan
+from batteryswap_public.utils import iterate_scenarios, load_dataset
+
+from batteryswapai.competition_planner import CompetitionPlanner
+from batteryswapai.identity_ensemble import (
+    IdentityEnsembleModel,
+    ResidualSignal,
+    SeasonalTemperatureResidual,
+    planner_freshness_factors,
+    v07_emergency_scale,
+)
+
+
+KEYS = ["scenario", "battery"]
+COST_COLUMNS = (
+    "battery_swap",
+    "building_change",
+    "room_change",
+    "travel",
+    "overtime",
+    "daily_limit",
+    "weekly_limit",
+    "late_swap",
+    "early_swap",
+    "total_cost",
+)
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--dataset-path", type=Path, default=Path("data/raw/train"))
+    parser.add_argument(
+        "--clean-predictions",
+        type=Path,
+        default=Path("artifacts/clean_v05_outer_oof.csv"),
+    )
+    parser.add_argument(
+        "--artifact",
+        type=Path,
+        default=Path("submission_artifacts/identity_planner.joblib"),
+    )
+    parser.add_argument(
+        "--lt-rows",
+        type=Path,
+        default=Path("artifacts/lt_fp_aft_official.rows.csv"),
+    )
+    parser.add_argument(
+        "--similarity-rows",
+        type=Path,
+        default=Path("artifacts/similarity_eol_official.rows.csv"),
+    )
+    parser.add_argument(
+        "--temperature-rows",
+        type=Path,
+        default=Path("artifacts/temperature_physics_ensemble_official.rows.csv"),
+    )
+    parser.add_argument(
+        "--output-prefix",
+        type=Path,
+        default=Path("artifacts/clean_identity_temperature_official"),
+    )
+    return parser.parse_args()
+
+
+def _sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+
+def _bool(values: pd.Series) -> np.ndarray:
+    if pd.api.types.is_bool_dtype(values):
+        return values.to_numpy(bool)
+    return values.astype(str).str.lower().isin({"true", "1"}).to_numpy(bool)
+
+
+def _paired_t(delta: np.ndarray) -> float:
+    delta = np.asarray(delta, dtype=float)
+    standard_error = float(delta.std(ddof=1) / math.sqrt(len(delta)))
+    if standard_error == 0.0:
+        return -1e99 if delta.mean() < 0.0 else 1e99
+    return float(delta.mean() / standard_error)
+
+
+def _score(
+    planner: CompetitionPlanner,
+    scenario: dict,
+    locs: pd.DataFrame,
+    not_dead: pd.Series,
+    snapshot: pd.DataFrame,
+    risk: np.ndarray,
+    rul: np.ndarray,
+    survivor: np.ndarray,
+) -> tuple[pd.DataFrame, dict[str, float]]:
+    plan = planner.plan_snapshot(
+        snapshot,
+        locs,
+        scenario["travel_costs"],
+        scenario["settings"],
+        scenario["start_time"],
+        predicted_risk=risk,
+        predicted_rul=rul,
+        predicted_survivor_rul=survivor,
+    )
+    _, _, score = evaluate_plan(
+        plan,
+        locs,
+        scenario["travel_costs"],
+        scenario["settings"],
+        eol_times=not_dead,
+        start_time=pd.Timestamp(scenario["start_time"]),
+        verbose=0,
+    )
+    return plan, {column: float(score[column]) for column in COST_COLUMNS}
+
+
+def main() -> None:
+    args = parse_args()
+    clean = pd.read_csv(args.clean_predictions)
+    lt = pd.read_csv(
+        args.lt_rows, usecols=KEYS + ["fp_aft_risk_oof", "fp_reliable"]
+    )
+    similarity = pd.read_csv(
+        args.similarity_rows,
+        usecols=KEYS
+        + [
+            "planner_data_gap_days",
+            "planner_freshness_factor",
+            "sim_neighbor_risk_oof",
+            "sim_neighbor_reliable",
+        ],
+    )
+    temperature = pd.read_csv(
+        args.temperature_rows,
+        usecols=KEYS + ["reliable", "predicted_min_smooth_voltage"],
+    )
+    frames = {
+        "clean": clean,
+        "lt": lt,
+        "similarity": similarity,
+        "temperature": temperature,
+    }
+    for name, frame in frames.items():
+        frame["scenario"] = frame["scenario"].astype(str)
+        frame["battery"] = frame["battery"].astype(str)
+        if len(frame) != 19_890 or frame.duplicated(KEYS).any():
+            raise AssertionError(f"{name} does not contain 19,890 unique keys")
+        if not clean[KEYS].equals(frame[KEYS]):
+            raise AssertionError(f"{name} key order differs from clean base")
+
+    rows = clean[
+        KEYS
+        + [
+            "oof_event_risk",
+            "oof_rul_days",
+            "oof_survivor_rul",
+            "target_rul_days",
+            "event_observed",
+        ]
+    ].copy()
+    for column in (
+        "planner_data_gap_days",
+        "planner_freshness_factor",
+        "sim_neighbor_risk_oof",
+        "sim_neighbor_reliable",
+    ):
+        rows[column] = similarity[column].to_numpy()
+    rows["fp_aft_risk_oof"] = lt["fp_aft_risk_oof"].to_numpy()
+    rows["fp_reliable"] = lt["fp_reliable"].to_numpy()
+    rows["temperature_reliable"] = temperature["reliable"].to_numpy()
+    rows["temperature_predicted_min_voltage"] = temperature[
+        "predicted_min_smooth_voltage"
+    ].to_numpy(float)
+    rows["temperature_urgency"] = -rows[
+        "temperature_predicted_min_voltage"
+    ].to_numpy(float)
+
+    wrapper = joblib.load(args.artifact)
+    identity_only = IdentityEnsembleModel(wrapper.ensemble.identity_residuals)
+    temperature_ensemble = IdentityEnsembleModel(
+        wrapper.ensemble.identity_residuals,
+        (SeasonalTemperatureResidual(),),
+    )
+    row_index = rows.set_index(KEYS)
+    locations, timeseries, eol_times, scenarios = load_dataset(args.dataset_path)
+    case_rows: list[dict[str, object]] = []
+    risk_rows: list[pd.DataFrame] = []
+    scale_counts = {"0.0": 0, "0.75": 0}
+
+    for scenario, locs, _, not_dead in iterate_scenarios(
+        locations,
+        timeseries,
+        eol_times,
+        scenarios,
+    ):
+        name = str(scenario["name"])
+        batteries = locs["battery"].astype(str).to_numpy()
+        keys = pd.MultiIndex.from_arrays(
+            [np.repeat(name, len(batteries)), batteries], names=KEYS
+        )
+        aligned = row_index.reindex(keys)
+        if aligned.isna().all(axis=1).any():
+            raise AssertionError(f"clean row alignment failed for {name}")
+        base = aligned["oof_event_risk"].to_numpy(float)
+        rul = aligned["oof_rul_days"].to_numpy(float)
+        survivor = aligned["oof_survivor_rul"].to_numpy(float)
+        freshness = aligned["planner_freshness_factor"].to_numpy(float)
+        expected_freshness = planner_freshness_factors(
+            aligned["planner_data_gap_days"].to_numpy(float),
+            wrapper.base_planner.policy,
+        )
+        np.testing.assert_array_equal(freshness, expected_freshness)
+        identity_signals = (
+            ResidualSignal(
+                aligned["fp_aft_risk_oof"].to_numpy(float),
+                _bool(aligned["fp_reliable"]),
+            ),
+            ResidualSignal(
+                aligned["sim_neighbor_risk_oof"].to_numpy(float),
+                _bool(aligned["sim_neighbor_reliable"]),
+            ),
+        )
+        temperature_urgency = aligned["temperature_urgency"].to_numpy(float)
+        temperature_reliable = _bool(aligned["temperature_reliable"])
+        predicted_min_voltage = aligned[
+            "temperature_predicted_min_voltage"
+        ].to_numpy(float)
+        temperature_signals = {
+            "temperature_all": ResidualSignal(
+                temperature_urgency, temperature_reliable
+            ),
+            "temperature_below_250": ResidualSignal(
+                temperature_urgency,
+                temperature_reliable & (predicted_min_voltage <= 2.50),
+            ),
+            "temperature_below_240": ResidualSignal(
+                temperature_urgency,
+                temperature_reliable & (predicted_min_voltage <= 2.40),
+            ),
+        }
+        identity_risk = identity_only.rerank_from_signals(
+            base, freshness, batteries, identity_signals
+        )
+        temperature_risks = {
+            name: temperature_ensemble.rerank_from_signals(
+                base,
+                freshness,
+                batteries,
+                identity_signals,
+                (signal,),
+            )
+            for name, signal in temperature_signals.items()
+        }
+        snapshot = locs[["battery", "building", "room"]].copy()
+        snapshot["data_gap_days"] = aligned[
+            "planner_data_gap_days"
+        ].to_numpy(float)
+        scale = v07_emergency_scale(
+            snapshot, scenario["travel_costs"], scenario["settings"]
+        )
+        scale_counts[str(scale)] += 1
+        planner = CompetitionPlanner(
+            None,
+            replace(
+                wrapper.base_planner.policy,
+                emergency_operational_scale=scale,
+            ),
+        )
+        arm_scores: dict[str, dict[str, float]] = {}
+        arm_plans: dict[str, pd.DataFrame] = {}
+        risks_by_arm = {
+            "baseline": base,
+            "identity": identity_risk,
+            **temperature_risks,
+        }
+        for arm, risk in risks_by_arm.items():
+            arm_plans[arm], arm_scores[arm] = _score(
+                planner, scenario, locs, not_dead, snapshot, risk, rul, survivor
+            )
+        start = pd.Timestamp(scenario["start_time"])
+        horizon_end = start + pd.Timedelta(
+            days=float(scenario["settings"].planning_window_days)
+        )
+        selected = {
+            arm: set(plan.loc[plan["day"].le(horizon_end), "battery"].astype(str))
+            for arm, plan in arm_plans.items()
+        }
+        expected_quota = min(max(int(round(0.038 * len(locs))), 8), 24)
+        if any(len(value) != expected_quota for value in selected.values()):
+            raise AssertionError(f"fixed quota drifted in {name}")
+        case: dict[str, object] = {
+            "scenario": name,
+            "start_time": start.isoformat(),
+            "effective_emergency_scale": scale,
+            "quota": expected_quota,
+        }
+        for arm, score in arm_scores.items():
+            case.update({f"{arm}_{key}": value for key, value in score.items()})
+        case_rows.append(case)
+        risk_rows.append(
+            pd.DataFrame(
+                {
+                    "scenario": name,
+                    "battery": batteries,
+                    "planner_freshness_factor": freshness,
+                    "clean_baseline_event_risk": base,
+                    "clean_identity_event_risk": identity_risk,
+                    **{
+                        f"clean_{arm}_event_risk": risk
+                        for arm, risk in temperature_risks.items()
+                    },
+                    "baseline_selected": [battery in selected["baseline"] for battery in batteries],
+                    "identity_selected": [battery in selected["identity"] for battery in batteries],
+                    **{
+                        f"{arm}_selected": [
+                            battery in selected[arm] for battery in batteries
+                        ]
+                        for arm in temperature_risks
+                    },
+                }
+            )
+        )
+
+    cases = pd.DataFrame(case_rows).sort_values("start_time").reset_index(drop=True)
+    risks = pd.concat(risk_rows, ignore_index=True)
+    baseline = cases["baseline_total_cost"].to_numpy(float)
+    identity = cases["identity_total_cost"].to_numpy(float)
+    identity_delta = identity - baseline
+    temperature_deltas_vs_identity = {
+        arm: cases[f"{arm}_total_cost"].to_numpy(float) - identity
+        for arm in (
+            "temperature_all",
+            "temperature_below_250",
+            "temperature_below_240",
+        )
+    }
+    temperature_variants = {}
+    for arm, incremental in temperature_deltas_vs_identity.items():
+        values = cases[f"{arm}_total_cost"].to_numpy(float)
+        delta = values - baseline
+        temperature_variants[arm] = {
+            "total": float(values.mean()),
+            "delta_vs_baseline": float(delta.mean()),
+            "delta_vs_identity": float(incremental.mean()),
+            "paired_t_vs_baseline": _paired_t(delta),
+            "paired_t_vs_identity": _paired_t(incremental),
+            "first_half_delta_vs_baseline": float(delta[:24].mean()),
+            "second_half_delta_vs_baseline": float(delta[24:].mean()),
+            "first_half_delta_vs_identity": float(incremental[:24].mean()),
+            "second_half_delta_vs_identity": float(incremental[24:].mean()),
+            "improved": int((delta < 0).sum()),
+            "unchanged": int((delta == 0).sum()),
+            "worse": int((delta > 0).sum()),
+            "strict_gate_vs_baseline": bool(
+                delta.mean() <= -40.0
+                and delta[:24].mean() <= 0.0
+                and delta[24:].mean() <= 0.0
+                and _paired_t(delta) <= -2.0
+            ),
+        }
+    candidate = cases["temperature_below_250_total_cost"].to_numpy(float)
+    delta = candidate - baseline
+    report = {
+        "experiment": (
+            "outer-clean V05 plus frozen LT/sim identity and promoted "
+            "seasonal temperature <=2.50 V gate"
+        ),
+        "rows": len(risks),
+        "cases": len(cases),
+        "baseline_total": float(baseline.mean()),
+        "identity_total": float(identity.mean()),
+        "candidate_total": float(candidate.mean()),
+        "temperature_variants": temperature_variants,
+        "candidate_vs_baseline": {
+            "mean_delta": float(delta.mean()),
+            "paired_t": _paired_t(delta),
+            "first_half_delta": float(delta[:24].mean()),
+            "second_half_delta": float(delta[24:].mean()),
+            "improved": int((delta < 0).sum()),
+            "unchanged": int((delta == 0).sum()),
+            "worse": int((delta > 0).sum()),
+        },
+        "identity_vs_baseline": {
+            "mean_delta": float(identity_delta.mean()),
+            "paired_t": _paired_t(identity_delta),
+            "first_half_delta": float(identity_delta[:24].mean()),
+            "second_half_delta": float(identity_delta[24:].mean()),
+        },
+        "components": {
+            column: {
+                "baseline_mean": float(cases[f"baseline_{column}"].mean()),
+                "candidate_mean": float(
+                    cases[f"temperature_below_250_{column}"].mean()
+                ),
+                "mean_delta": float(
+                    (
+                        cases[f"temperature_below_250_{column}"]
+                        - cases[f"baseline_{column}"]
+                    ).mean()
+                ),
+            }
+            for column in COST_COLUMNS
+        },
+        "gate": {
+            "definition": "delta <= -40, both halves <= 0, paired_t <= -2",
+            "pass": bool(
+                delta.mean() <= -40.0
+                and delta[:24].mean() <= 0.0
+                and delta[24:].mean() <= 0.0
+                and _paired_t(delta) <= -2.0
+            ),
+        },
+        "v07_scale_counts": scale_counts,
+        "fingerprints": {
+            "clean_predictions": _sha256(args.clean_predictions),
+            "artifact": _sha256(args.artifact),
+            "lt_rows": _sha256(args.lt_rows),
+            "similarity_rows": _sha256(args.similarity_rows),
+            "temperature_rows": _sha256(args.temperature_rows),
+        },
+    }
+    args.output_prefix.parent.mkdir(parents=True, exist_ok=True)
+    cases.to_csv(args.output_prefix.with_suffix(".cases.csv"), index=False)
+    risks.to_csv(args.output_prefix.with_suffix(".rows.csv"), index=False)
+    args.output_prefix.with_suffix(".json").write_text(
+        json.dumps(report, indent=2), encoding="utf-8"
+    )
+    print(json.dumps(report, indent=2))
+
+
+if __name__ == "__main__":
+    main()

scripts/train_submission.py

@@ -38,7 +38,9 @@ def parse_args() -> argparse.Namespace:
     parser.add_argument("--risk-calibration-scale", type=float, default=1.5)
     parser.add_argument("--expected-gain-margin", type=float, default=10.0)
     parser.add_argument("--expected-service-cost-hours", type=float, default=2.0)
+    parser.add_argument("--emergency-operational-scale", type=float, default=0.0)
     parser.add_argument("--scheduled-fraction", type=float, default=0.038)
+    parser.add_argument("--capacity-lookback-days", type=int, default=42)
     parser.add_argument("--weekly-guard-fraction", type=float, default=0.95)
     parser.add_argument("--hard-limit-penalty-multiplier", type=float, default=1.5)
     parser.add_argument("--minimum-scheduled-batteries", type=int, default=8)
@@ -83,12 +85,14 @@ def main() -> None:
             risk_calibration_scale=args.risk_calibration_scale,
             expected_gain_margin=args.expected_gain_margin,
             expected_service_cost_hours=args.expected_service_cost_hours,
+            emergency_operational_scale=args.emergency_operational_scale,
             scheduled_fraction=args.scheduled_fraction,
             capacity_weekly_limit_fraction=args.weekly_guard_fraction,
             capacity_limit_penalty_multiplier=args.hard_limit_penalty_multiplier,
             minimum_scheduled_batteries=args.minimum_scheduled_batteries,
             maximum_scheduled_batteries=args.maximum_scheduled_batteries,
             capacity_lookahead_days=21,
+            capacity_lookback_days=args.capacity_lookback_days,
         ),
     )
     args.artifact.parent.mkdir(parents=True, exist_ok=True)
@@ -103,7 +107,9 @@ def main() -> None:
         "risk_calibration_scale": args.risk_calibration_scale,
         "expected_gain_margin": args.expected_gain_margin,
         "expected_service_cost_hours": args.expected_service_cost_hours,
+        "emergency_operational_scale": args.emergency_operational_scale,
         "scheduled_fraction": args.scheduled_fraction,
+        "capacity_lookback_days": args.capacity_lookback_days,
         "weekly_guard_fraction": args.weekly_guard_fraction,
         "hard_limit_penalty_multiplier": args.hard_limit_penalty_multiplier,
         "minimum_scheduled_batteries": args.minimum_scheduled_batteries,

scripts/validate_submission.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import argparse
+import itertools
 import json
 from pathlib import Path
 
@@ -74,10 +75,14 @@ def parse_args() -> argparse.Namespace:
     parser.add_argument("--risk-scales", default="1.50")
     parser.add_argument("--gain-margins", default="10")
     parser.add_argument("--service-costs", default="2")
+    parser.add_argument("--emergency-operational-scales", default="0")
     parser.add_argument("--offsets", default="-5")
     parser.add_argument("--schedule-fractions", default="0.038")
     parser.add_argument("--schedule-quotas", default="")
     parser.add_argument("--schedule-bands", default="")
+    parser.add_argument("--capacity-lookback-days", type=int, default=42)
+    parser.add_argument("--weekly-guard-fractions", default="0.95")
+    parser.add_argument("--hard-limit-penalty-multipliers", default="1.5")
     parser.add_argument(
         "--predictions-csv",
         type=Path,
@@ -118,6 +123,7 @@ def main() -> None:
     oof_residual = np.full(len(training), np.nan)
     oof_residual_weight = np.zeros(len(training))
     blend_weights = (1.0, 0.0, 0.0, 0.0)
+    outer_fold_audits: list[dict[str, int]] = []
     if args.predictions_csv is not None:
         cached = pd.read_csv(args.predictions_csv).set_index(["scenario", "battery"])
         keys = pd.MultiIndex.from_frame(training[["scenario", "battery"]])
@@ -134,16 +140,44 @@ def main() -> None:
         for fold_number, (train_index, valid_index) in enumerate(
             splitter.split(training, groups=groups), start=1
         ):
+            train_rows = training.iloc[train_index]
+            valid_rows = training.iloc[valid_index]
+            train_batteries = set(train_rows["battery"].astype(str))
+            valid_batteries = set(valid_rows["battery"].astype(str))
+            train_buildings = set(train_rows["building"].astype(str))
+            valid_buildings = set(valid_rows["building"].astype(str))
+            if train_batteries & valid_batteries:
+                raise AssertionError(f"outer fold {fold_number} leaks a battery")
+            if args.outer_group == "building" and train_buildings & valid_buildings:
+                raise AssertionError(f"outer fold {fold_number} leaks a building")
+
+            # The dense trajectory forecasters have future-voltage and EOL targets.
+            # Their matrix and labels must therefore obey the same outer split as the
+            # snapshot model. Passing the full matrix here made the old OOF report
+            # optimistic even though hidden inference itself remained train-only.
+            fold_daily = daily.loc[
+                daily["device_id"].astype(str).isin(train_batteries)
+            ].copy()
+            fold_trajectory = build_trajectory_matrix(fold_daily)
+            trajectory_batteries = set(fold_trajectory["index"])
+            if trajectory_batteries & valid_batteries:
+                raise AssertionError(
+                    f"outer fold {fold_number} leaks a trajectory battery"
+                )
+            fold_eol_times = eol_times.reindex(sorted(train_batteries)).copy()
+            if set(fold_eol_times.index.astype(str)) & valid_batteries:
+                raise AssertionError(f"outer fold {fold_number} leaks an EOL label")
+
             model = fit_event_time_model(
-                training.iloc[train_index],
+                train_rows,
                 quantile=args.quantile,
                 dataset_revision=DATASET_REVISION,
                 random_state=2026 + fold_number,
                 calibration_folds=args.inner_calibration_folds,
-                trajectory=build_trajectory_matrix(daily),
-                eol_times=eol_times,
+                trajectory=fold_trajectory,
+                eol_times=fold_eol_times,
             )
-            valid = training.iloc[valid_index]
+            valid = valid_rows
             for name, values in model.predict_risk_components(valid).items():
                 oof_components.setdefault(
                     name, np.full(len(training), np.nan)
@@ -157,6 +191,18 @@ def main() -> None:
             survivor = model.predict_survivor_rul(valid)
             if survivor is not None:
                 oof_survivor[valid_index] = survivor
+            outer_fold_audits.append(
+                {
+                    "fold": fold_number,
+                    "train_batteries": len(train_batteries),
+                    "valid_batteries": len(valid_batteries),
+                    "train_buildings": len(train_buildings),
+                    "valid_buildings": len(valid_buildings),
+                    "trajectory_batteries": len(trajectory_batteries),
+                    "battery_overlap": 0,
+                    "building_overlap": 0 if args.outer_group == "building" else -1,
+                }
+            )
 
     scenario_groups = training["scenario"].astype(str).to_numpy()
     if oof_components:
@@ -202,85 +248,131 @@ def main() -> None:
     classification["due_within_horizon_rul_mae_days"] = float(np.mean(due_rul_error))
 
     policy_results = []
+    case_results = []
     placeholder_model = None
-    for risk_scale in _numbers(args.risk_scales):
-        for gain_margin in _numbers(args.gain_margins):
-            for service_cost in _numbers(args.service_costs):
-                for offset in _numbers(args.offsets):
-                    for fraction, minimum, maximum in _schedule_plans(
-                        args.schedule_fractions,
-                        args.schedule_quotas,
-                        args.schedule_bands,
-                    ):
-                        planner = CompetitionPlanner(
-                            placeholder_model,
-                            PlannerPolicy(
-                                event_risk_threshold=0.50,
-                                prediction_offset_days=offset,
-                                use_expected_cost=True,
-                                risk_calibration_scale=risk_scale,
-                                expected_service_cost_hours=service_cost,
-                                expected_gain_margin=gain_margin,
-                                capacity_lookahead_days=21,
-                                scheduled_fraction=fraction,
-                                minimum_scheduled_batteries=minimum,
-                                maximum_scheduled_batteries=maximum,
-                            ),
-                        )
-                        scores = []
-                        scheduled_counts = []
-                        for scenario_name, (scenario, locs, not_dead) in scenario_inputs.items():
-                            mask = training["scenario"].eq(scenario_name).to_numpy()
-                            snapshot = training.loc[mask]
-                            risk = oof_risk[mask]
-                            rul = oof_rul[mask]
-                            survivor = oof_survivor[mask]
-                            plan = planner.plan_snapshot(
-                                snapshot,
-                                locs,
-                                scenario["travel_costs"],
-                                scenario["settings"],
-                                scenario["start_time"],
-                                predicted_rul=rul,
-                                predicted_risk=risk,
-                                predicted_survivor_rul=(
-                                    None if np.isnan(survivor).all() else survivor
-                                ),
-                            )
-                            start = pd.Timestamp(scenario["start_time"])
-                            horizon_end = start + pd.Timedelta(
-                                days=scenario["settings"].planning_window_days
-                            )
-                            scheduled_counts.append(int(plan["day"].le(horizon_end).sum()))
-                            _, _, score = evaluate_plan(
-                                plan,
-                                locs,
-                                scenario["travel_costs"],
-                                scenario["settings"],
-                                eol_times=not_dead,
-                                start_time=start,
-                                verbose=0,
-                            )
-                            scores.append(score)
-                        mean_score = pd.concat(scores, axis=1).mean(axis=1)
-                        policy_results.append(
-                            {
-                                "risk_calibration_scale": risk_scale,
-                                "expected_gain_margin": gain_margin,
-                                "expected_service_cost_hours": service_cost,
-                                "prediction_offset_days": offset,
-                                "scheduled_fraction": fraction,
-                                "minimum_scheduled_batteries": minimum,
-                                "maximum_scheduled_batteries": maximum,
-                                "stale_risk_cutoff_days": planner.policy.stale_risk_cutoff_days,
-                                "recent_gap_risk_factor": planner.policy.recent_gap_risk_factor,
-                                "stale_risk_factor": planner.policy.stale_risk_factor,
-                                "building_batch_window_days": planner.policy.building_batch_window_days,
-                                "capacity_operational_cost_weight": planner.policy.capacity_operational_cost_weight,
-                                "mean_scheduled_batteries": float(np.mean(scheduled_counts)),
-                                **{key: float(value) for key, value in mean_score.items()},
-                            }
-                        )
+    grid = itertools.product(
+        _numbers(args.risk_scales),
+        _numbers(args.gain_margins),
+        _numbers(args.service_costs),
+        _numbers(args.emergency_operational_scales),
+        _numbers(args.weekly_guard_fractions),
+        _numbers(args.hard_limit_penalty_multipliers),
+        _numbers(args.offsets),
+        _schedule_plans(
+            args.schedule_fractions,
+            args.schedule_quotas,
+            args.schedule_bands,
+        ),
+    )
+    for (
+        risk_scale,
+        gain_margin,
+        service_cost,
+        emergency_scale,
+        weekly_guard,
+        hard_multiplier,
+        offset,
+        (fraction, minimum, maximum),
+    ) in grid:
+        policy_id = f"p{len(policy_results):03d}"
+        planner = CompetitionPlanner(
+            placeholder_model,
+            PlannerPolicy(
+                event_risk_threshold=0.50,
+                prediction_offset_days=offset,
+                use_expected_cost=True,
+                risk_calibration_scale=risk_scale,
+                expected_service_cost_hours=service_cost,
+                expected_gain_margin=gain_margin,
+                emergency_operational_scale=emergency_scale,
+                capacity_lookahead_days=21,
+                capacity_lookback_days=args.capacity_lookback_days,
+                capacity_weekly_limit_fraction=weekly_guard,
+                capacity_limit_penalty_multiplier=hard_multiplier,
+                scheduled_fraction=fraction,
+                minimum_scheduled_batteries=minimum,
+                maximum_scheduled_batteries=maximum,
+            ),
+        )
+        scores = []
+        scheduled_counts = []
+        for scenario_name, (scenario, locs, not_dead) in scenario_inputs.items():
+            mask = training["scenario"].eq(scenario_name).to_numpy()
+            snapshot = training.loc[mask]
+            risk = oof_risk[mask]
+            rul = oof_rul[mask]
+            survivor = oof_survivor[mask]
+            plan = planner.plan_snapshot(
+                snapshot,
+                locs,
+                scenario["travel_costs"],
+                scenario["settings"],
+                scenario["start_time"],
+                predicted_rul=rul,
+                predicted_risk=risk,
+                predicted_survivor_rul=(
+                    None if np.isnan(survivor).all() else survivor
+                ),
+            )
+            start = pd.Timestamp(scenario["start_time"])
+            horizon_end = start + pd.Timedelta(
+                days=scenario["settings"].planning_window_days
+            )
+            scheduled = plan["day"].le(horizon_end)
+            scheduled_count = int(scheduled.sum())
+            scheduled_counts.append(scheduled_count)
+            _, _, score = evaluate_plan(
+                plan,
+                locs,
+                scenario["travel_costs"],
+                scenario["settings"],
+                eol_times=not_dead,
+                start_time=start,
+                verbose=0,
+            )
+            scores.append(score)
+            required = pd.to_datetime(not_dead).between(
+                start,
+                horizon_end,
+                inclusive="right",
+            )
+            required_ids = set(not_dead.index[required].astype(str))
+            scheduled_ids = set(plan.loc[scheduled, "battery"].astype(str))
+            case_results.append(
+                {
+                    "policy_id": policy_id,
+                    "scenario": scenario_name,
+                    "start_time": start.isoformat(),
+                    "scheduled_count": scheduled_count,
+                    "required_count": len(required_ids),
+                    "true_positive_count": len(required_ids & scheduled_ids),
+                    "missed_count": len(required_ids - scheduled_ids),
+                    **{key: float(value) for key, value in score.items()},
+                }
+            )
+        mean_score = pd.concat(scores, axis=1).mean(axis=1)
+        policy_results.append(
+            {
+                "policy_id": policy_id,
+                "risk_calibration_scale": risk_scale,
+                "expected_gain_margin": gain_margin,
+                "expected_service_cost_hours": service_cost,
+                "emergency_operational_scale": emergency_scale,
+                "prediction_offset_days": offset,
+                "scheduled_fraction": fraction,
+                "minimum_scheduled_batteries": minimum,
+                "maximum_scheduled_batteries": maximum,
+                "capacity_weekly_limit_fraction": weekly_guard,
+                "capacity_limit_penalty_multiplier": hard_multiplier,
+                "stale_risk_cutoff_days": planner.policy.stale_risk_cutoff_days,
+                "recent_gap_risk_factor": planner.policy.recent_gap_risk_factor,
+                "stale_risk_factor": planner.policy.stale_risk_factor,
+                "building_batch_window_days": planner.policy.building_batch_window_days,
+                "capacity_operational_cost_weight": planner.policy.capacity_operational_cost_weight,
+                "mean_scheduled_batteries": float(np.mean(scheduled_counts)),
+                **{key: float(value) for key, value in mean_score.items()},
+            }
+        )
 
     policy_results.sort(key=lambda item: item["total_cost"])
     report = {
@@ -288,6 +380,22 @@ def main() -> None:
         "folds": args.folds,
         "inner_calibration_folds": args.inner_calibration_folds,
         "outer_group": args.outer_group,
+        "prediction_source": (
+            args.predictions_csv.as_posix()
+            if args.predictions_csv is not None
+            else "generated by this run"
+        ),
+        "outer_fold_trajectory_scope": (
+            "caller-supplied predictions; not refit"
+            if args.predictions_csv is not None
+            else "outer-train batteries only"
+        ),
+        "outer_fold_eol_scope": (
+            "caller-supplied predictions; not refit"
+            if args.predictions_csv is not None
+            else "outer-train batteries only"
+        ),
+        "outer_fold_audits": outer_fold_audits,
         "quantile": args.quantile,
         "classification": classification,
         "policies": policy_results,
@@ -299,6 +407,9 @@ def main() -> None:
     predictions["oof_rul_days"] = oof_rul
     predictions["oof_survivor_rul"] = oof_survivor
     predictions.to_csv(args.output.with_suffix(".csv"), index=False)
+    pd.DataFrame(case_results).to_csv(
+        args.output.with_suffix(".cases.csv"), index=False
+    )
     print(json.dumps(report, indent=2))
 
 

scripts/verify_identity_feature_parity.py

@@ -0,0 +1,261 @@
+"""Verify production feature extraction against frozen causal experiment rows.
+
+This is a release test, not a model fit. It replays every official train cut through
+the deployable raw-history cache and compares AFT, similarity-query, and rounded-beta
+seasonal physics features to the persisted experiment evidence.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+from batteryswap_public.utils import iterate_scenarios, load_dataset
+
+from batteryswapai.identity_ensemble import (
+    FROZEN_TEMPERATURE_BETA_V_PER_C,
+    TEMPERATURE_MAX_PREDICTED_MIN_VOLTAGE,
+    CausalHistoryCache,
+    _first_passage_lifetime,
+    _query_similarity,
+    _seasonal_physics_signal,
+)
+
+
+KEYS = ["scenario", "battery"]
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--dataset-path", type=Path, default=Path("data/raw/train"))
+    parser.add_argument(
+        "--lt-rows",
+        type=Path,
+        default=Path("artifacts/lt_fp_aft_official.rows.csv"),
+    )
+    parser.add_argument(
+        "--similarity-rows",
+        type=Path,
+        default=Path("artifacts/similarity_eol_official.rows.csv"),
+    )
+    parser.add_argument(
+        "--temperature-rows",
+        type=Path,
+        default=Path("artifacts/temperature_physics_globalbeta_diagnostic.rows.csv"),
+    )
+    parser.add_argument(
+        "--output",
+        type=Path,
+        default=Path("artifacts/identity_feature_parity.json"),
+    )
+    return parser.parse_args()
+
+
+def _sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+
+def _bool(values: pd.Series) -> np.ndarray:
+    if pd.api.types.is_bool_dtype(values):
+        return values.to_numpy(bool)
+    return values.astype(str).str.lower().isin({"true", "1"}).to_numpy(bool)
+
+
+def _max_abs(actual: np.ndarray, expected: np.ndarray) -> float:
+    finite = np.isfinite(actual) & np.isfinite(expected)
+    return float(np.max(np.abs(actual[finite] - expected[finite]))) if finite.any() else 0.0
+
+
+def main() -> None:
+    args = parse_args()
+    lag_columns = [f"sim_hi_lag_{lag}d" for lag in range(0, 337, 7)]
+    lt = pd.read_csv(
+        args.lt_rows,
+        usecols=KEYS
+        + ["installation_start", "fp_lifetime_days", "fp_reliable"],
+    ).set_index(KEYS)
+    similarity = pd.read_csv(
+        args.similarity_rows,
+        usecols=KEYS
+        + ["sim_query_ready", "sim_staleness_days", *lag_columns],
+    ).set_index(KEYS)
+    temperature = pd.read_csv(
+        args.temperature_rows,
+        usecols=KEYS + ["reliable", "predicted_min_smooth_voltage"],
+    ).set_index(KEYS)
+    if not (len(lt) == len(similarity) == len(temperature) == 19_890):
+        raise AssertionError("feature references must contain 19,890 rows")
+
+    locations, timeseries, eol_times, scenarios = load_dataset(args.dataset_path)
+    cache = CausalHistoryCache(
+        beta_v_per_c=FROZEN_TEMPERATURE_BETA_V_PER_C,
+        split_id="train",
+    )
+    aft_max_error = 0.0
+    similarity_max_error = 0.0
+    similarity_staleness_max_error = 0.0
+    temperature_max_error = 0.0
+    aft_reliable_matches = 0
+    similarity_ready_matches = 0
+    temperature_reliable_matches = 0
+    temperature_gate_matches = 0
+    rows = 0
+
+    for scenario, locs, visible, _ in iterate_scenarios(
+        locations, timeseries, eol_times, scenarios
+    ):
+        name = str(scenario["name"])
+        start = pd.Timestamp(scenario["start_time"])
+        history = cache.update(visible, start)
+        batteries = locs["battery"].astype(str).to_numpy()
+        keys = pd.MultiIndex.from_arrays(
+            [np.repeat(name, len(batteries)), batteries], names=KEYS
+        )
+        lt_expected = lt.reindex(keys)
+        sim_expected = similarity.reindex(keys)
+        temp_expected = temperature.reindex(keys)
+        if (
+            lt_expected.isna().all(axis=1).any()
+            or sim_expected.isna().all(axis=1).any()
+            or temp_expected.isna().all(axis=1).any()
+        ):
+            raise AssertionError(f"reference alignment failed for {name}")
+
+        actual_lifetime = np.full(len(batteries), np.nan)
+        actual_aft_reliable = np.zeros(len(batteries), dtype=bool)
+        installation = pd.to_datetime(lt_expected["installation_start"])
+        for position, battery in enumerate(batteries):
+            lifetime, reliable = _first_passage_lifetime(
+                battery,
+                start,
+                pd.Timestamp(installation.iloc[position]),
+                history.smooth_lookup,
+            )
+            actual_lifetime[position] = lifetime
+            actual_aft_reliable[position] = reliable
+        expected_lifetime = lt_expected["fp_lifetime_days"].to_numpy(float)
+        expected_aft_reliable = _bool(lt_expected["fp_reliable"])
+        np.testing.assert_allclose(
+            actual_lifetime,
+            expected_lifetime,
+            rtol=0.0,
+            atol=1e-12,
+            equal_nan=True,
+        )
+        np.testing.assert_array_equal(actual_aft_reliable, expected_aft_reliable)
+        aft_max_error = max(aft_max_error, _max_abs(actual_lifetime, expected_lifetime))
+        aft_reliable_matches += int((actual_aft_reliable == expected_aft_reliable).sum())
+
+        query, ready, staleness = _query_similarity(
+            batteries, start, history.smooth_lookup
+        )
+        expected_query = sim_expected[lag_columns].to_numpy(float)
+        expected_ready = _bool(sim_expected["sim_query_ready"])
+        expected_staleness = sim_expected["sim_staleness_days"].to_numpy(float)
+        np.testing.assert_allclose(
+            query, expected_query, rtol=0.0, atol=1e-12, equal_nan=True
+        )
+        np.testing.assert_array_equal(ready, expected_ready)
+        np.testing.assert_allclose(
+            staleness, expected_staleness, rtol=0.0, atol=1e-12, equal_nan=True
+        )
+        similarity_max_error = max(
+            similarity_max_error, _max_abs(query, expected_query)
+        )
+        similarity_staleness_max_error = max(
+            similarity_staleness_max_error,
+            _max_abs(staleness, expected_staleness),
+        )
+        similarity_ready_matches += int((ready == expected_ready).sum())
+
+        temp_signal = _seasonal_physics_signal(
+            history,
+            batteries,
+            start,
+            FROZEN_TEMPERATURE_BETA_V_PER_C,
+        )
+        expected_temp_reliable = _bool(temp_expected["reliable"])
+        expected_urgency = -temp_expected[
+            "predicted_min_smooth_voltage"
+        ].to_numpy(float)
+        np.testing.assert_array_equal(
+            temp_signal.reliable, expected_temp_reliable
+        )
+        np.testing.assert_allclose(
+            temp_signal.values,
+            expected_urgency,
+            rtol=0.0,
+            atol=2e-7,
+            equal_nan=True,
+        )
+        temperature_max_error = max(
+            temperature_max_error,
+            _max_abs(temp_signal.values, expected_urgency),
+        )
+        temperature_reliable_matches += int(
+            (temp_signal.reliable == expected_temp_reliable).sum()
+        )
+        gated_temp_signal = _seasonal_physics_signal(
+            history,
+            batteries,
+            start,
+            FROZEN_TEMPERATURE_BETA_V_PER_C,
+            TEMPERATURE_MAX_PREDICTED_MIN_VOLTAGE,
+        )
+        expected_gated_reliable = expected_temp_reliable & (
+            temp_expected["predicted_min_smooth_voltage"].to_numpy(float)
+            <= TEMPERATURE_MAX_PREDICTED_MIN_VOLTAGE
+        )
+        np.testing.assert_array_equal(
+            gated_temp_signal.reliable, expected_gated_reliable
+        )
+        temperature_gate_matches += int(
+            (gated_temp_signal.reliable == expected_gated_reliable).sum()
+        )
+        rows += len(batteries)
+
+    if rows != 19_890:
+        raise AssertionError(f"feature replay produced {rows} rows")
+    report = {
+        "rows": rows,
+        "all_feature_flags_match": bool(
+            aft_reliable_matches
+            == similarity_ready_matches
+            == temperature_reliable_matches
+            == temperature_gate_matches
+            == rows
+        ),
+        "aft": {
+            "reliable_flag_matches": aft_reliable_matches,
+            "maximum_absolute_lifetime_error_days": aft_max_error,
+        },
+        "similarity_query": {
+            "ready_flag_matches": similarity_ready_matches,
+            "maximum_absolute_prefix_error": similarity_max_error,
+            "maximum_absolute_staleness_error_days": similarity_staleness_max_error,
+        },
+        "seasonal_temperature": {
+            "reliable_flag_matches": temperature_reliable_matches,
+            "below_250_gate_flag_matches": temperature_gate_matches,
+            "maximum_predicted_min_voltage": (
+                TEMPERATURE_MAX_PREDICTED_MIN_VOLTAGE
+            ),
+            "maximum_absolute_urgency_error_v": temperature_max_error,
+        },
+        "evidence_sha256": {
+            "lt_rows": _sha256(args.lt_rows),
+            "similarity_rows": _sha256(args.similarity_rows),
+            "temperature_rows": _sha256(args.temperature_rows),
+        },
+    }
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    args.output.write_text(json.dumps(report, indent=2), encoding="utf-8")
+    print(json.dumps(report, indent=2))
+
+
+if __name__ == "__main__":
+    main()

src/batteryswapai/competition_planner.py

@@ -28,6 +28,7 @@ class PlannerPolicy:
     expected_service_cost_hours: float = 2.0
     expected_gain_margin: float = 10.0
     expected_emergency_buffer_days: float = 6.0
+    emergency_operational_scale: float = 0.0
     stale_risk_cutoff_days: float = 7.0
     recent_gap_risk_factor: float = 0.75
     stale_risk_factor: float = 0.10
@@ -130,6 +131,7 @@ class CompetitionPlanner(Planner):
                 float(settings.late_replacement_penalty_daily)
                 * np.maximum(emergency_day - expected_event_day, 0.0)
                 + self.policy.expected_service_cost_hours
+                + self._emergency_operational_cost(work, travel_costs, settings)
             )
             survivor_rul = self._survivor_rul(
                 snapshot, horizon, predicted_survivor_rul
@@ -225,6 +227,50 @@ class CompetitionPlanner(Planner):
         )
         return pd.DataFrame(planned_rows, columns=["day", "battery"]).reset_index(drop=True)
 
+    def _emergency_operational_cost(self, work, travel_costs, settings) -> np.ndarray:
+        """What the evaluator actually charges for a battery left to the emergency queue.
+
+        A missed required battery becomes its own working day: a dedicated round trip from
+        base, the swap itself, then straight home. Measured over 144 train cases that costs
+        65.56 beyond the late penalty, against the flat 2.0 the selection assumed - a 33x
+        underestimate that hid the geography of a miss entirely. Scaling by distance is what
+        lets a remote candidate outrank an equally risky one next door.
+        """
+
+        scale = float(self.policy.emergency_operational_scale)
+        if scale <= 0.0:
+            return np.zeros(len(work), dtype=float)
+        distances = travel_costs.set_index(["from", "to"])["hours"]
+        base = settings.base_location
+        buildings = work["building"].astype(str).to_numpy()
+        out = np.zeros(len(work), dtype=float)
+        cache: dict[str, float] = {}
+        for position, building in enumerate(buildings):
+            if building not in cache:
+                try:
+                    leg = float(distances.loc[(base, building)])
+                except KeyError:
+                    leg = 0.0
+                hours = (
+                    2.0 * leg
+                    + float(settings.time_per_building_change_hours)
+                    + float(settings.time_per_room_change_hours)
+                    + float(settings.time_per_battery_hours)
+                )
+                overtime = float(settings.overtime_penalty_factor) * max(
+                    hours - float(settings.overtime_start), 0.0
+                )
+                limits = 0.0
+                if hours > float(settings.worker_limit_daily_hours):
+                    limits += float(settings.worker_limit_daily_penalty)
+                # each emergency day consumes this share of a week's budget
+                limits += float(settings.worker_limit_weekly_penalty) * min(
+                    hours / float(settings.worker_limit_weekly_hours), 1.0
+                )
+                cache[building] = hours + overtime + limits
+            out[position] = cache[building]
+        return scale * out
+
     def _survivor_rul(
         self,
         snapshot: pd.DataFrame,

src/batteryswapai/identity_ensemble.py

@@ -0,0 +1,1291 @@
+"""Causal, deployable identity residuals for the BatterySwapAI planner.
+
+The frozen base model supplies calibrated event risk and both RUL heads.  This
+module changes only which battery receives each already-calibrated risk value.
+Every permutation is confined to one exact planner-freshness stratum, so both
+the raw and planner-consumed risk multisets remain unchanged.
+
+Only raw history supplied by ``iterate_scenarios`` may enter ``plan_scenario``.
+The runtime cache is an incremental acceleration of that visible prefix; it is
+never trained, serialized with observations, or populated from the full hidden
+split.
+"""
+
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass, field, replace
+from typing import Protocol
+
+import numpy as np
+import pandas as pd
+from scipy.optimize import minimize
+from scipy.special import log_ndtr, ndtr
+from scipy.stats import rankdata
+
+from .competition_planner import CompetitionPlanner, PlannerPolicy
+
+
+SCHEMA_VERSION = 1
+HORIZON_DAYS = 42.0
+EOL_VOLTAGE = 2.40
+
+FP_WINDOWS_DAYS = (30, 60, 90, 180)
+MIN_SMOOTHED_POINTS = 8
+MIN_WINDOW_SPAN_FRACTION = 0.5
+MIN_DEGRADATION_RATE = 1e-5
+MAX_EXTRAPOLATION_DAYS = 730.0
+MAX_SMOOTHED_STALENESS_DAYS = 7.0
+MAX_LIFETIME_MAD_DAYS = 90.0
+MIN_RELIABLE_WINDOWS = 3
+
+NEIGHBORS = 8
+PREFIX_LAGS_DAYS = tuple(range(0, 337, 7))
+RECENCY_HALF_LIFE_DAYS = 42.0
+BASELINE_VALID_POINTS = 30
+MIN_PAIRED_LAGS = 8
+MIN_WEIGHTED_COVERAGE = 0.50
+MIN_EFFECTIVE_NEIGHBORS = 4.0
+MIN_UNIQUE_DONOR_BUILDINGS = NEIGHBORS
+MIN_EFFECTIVE_DONOR_BUILDINGS = 4.0
+MAX_LOGIT_RESIDUAL = 1.0
+INVERSE_DISTANCE_EPSILON = 1e-6
+DISTANCE_BATCH_SIZE = 64
+PREFIX_WEIGHTS = np.power(
+    2.0,
+    -np.asarray(PREFIX_LAGS_DAYS, dtype=float) / RECENCY_HALF_LIFE_DAYS,
+)
+
+FROZEN_TEMPERATURE_BETA_V_PER_C = 0.00549
+REFERENCE_TEMPERATURE_C = 20.0
+TEMPERATURE_MAX_PREDICTED_MIN_VOLTAGE = 2.50
+SEASONAL_LAG_DAYS = 364
+DRIFT_WINDOW_DAYS = 90
+MIN_DRIFT_POINTS = 30
+MIN_DRIFT_SPAN_DAYS = 60
+MIN_ANALOG_DAYS = 28
+MAX_HEALTH_STALENESS_DAYS = 7
+
+V07_EMERGENCY_OPERATIONAL_SCALE = 0.75
+V07_MAX_MEAN_DEDICATED_TRIP_HOURS = 8.0
+
+
+def _as_bool(values: pd.Series | np.ndarray) -> np.ndarray:
+    array = np.asarray(values)
+    if np.issubdtype(array.dtype, np.bool_):
+        return array.astype(bool, copy=False)
+    return np.asarray(
+        [str(value).strip().lower() in {"1", "true", "yes"} for value in array],
+        dtype=bool,
+    )
+
+
+def _rank(values: np.ndarray) -> np.ndarray:
+    values = np.asarray(values, dtype=float)
+    if not len(values) or not np.isfinite(values).all():
+        raise ValueError("rank input must be finite and non-empty")
+    return rankdata(values, method="average") / len(values)
+
+
+def _logit(values: np.ndarray) -> np.ndarray:
+    clipped = np.clip(np.asarray(values, dtype=float), 1e-6, 1.0 - 1e-6)
+    return np.log(clipped / (1.0 - clipped))
+
+
+def assign_multiset(
+    baseline: np.ndarray,
+    score: np.ndarray,
+    batteries: np.ndarray,
+    eligible: np.ndarray,
+) -> np.ndarray:
+    """Give high scores high baseline values, with deterministic battery ties."""
+
+    baseline = np.asarray(baseline, dtype=float)
+    score = np.asarray(score, dtype=float)
+    batteries = np.asarray(batteries, dtype=object)
+    eligible = np.asarray(eligible, dtype=bool)
+    if not (len(baseline) == len(score) == len(batteries) == len(eligible)):
+        raise ValueError("multiset assignment inputs have different lengths")
+    out = baseline.copy()
+    positions = np.flatnonzero(eligible)
+    if len(positions) < 2:
+        return out
+    if not np.isfinite(score[positions]).all():
+        raise ValueError("eligible multiset scores must be finite")
+    order = np.lexsort((batteries[positions].astype(str), score[positions]))
+    out[positions[order]] = np.sort(baseline[positions])
+    if not np.array_equal(out[~eligible], baseline[~eligible]):
+        raise AssertionError("ineligible rows changed during multiset assignment")
+    if not np.array_equal(np.sort(out), np.sort(baseline)):
+        raise AssertionError("risk multiset changed during assignment")
+    return out
+
+
+def planner_freshness_factors(
+    data_gap_days: np.ndarray, policy: PlannerPolicy
+) -> np.ndarray:
+    gaps = np.asarray(data_gap_days, dtype=float)
+    factors = np.ones(len(gaps), dtype=float)
+    recent = (gaps > 0.0) & (gaps <= policy.stale_risk_cutoff_days)
+    stale = (gaps > policy.stale_risk_cutoff_days) | ~np.isfinite(gaps)
+    factors[recent] = policy.recent_gap_risk_factor
+    factors[stale] = policy.stale_risk_factor
+    return factors
+
+
+def mean_dedicated_trip_hours(
+    snapshot: pd.DataFrame, travel_costs: pd.DataFrame, settings
+) -> float:
+    """Frozen V07 inference-only geometry gate."""
+
+    distances = travel_costs.set_index(["from", "to"])["hours"]
+    if distances.index.has_duplicates:
+        raise ValueError("travel matrix paths must be unique")
+    base = str(settings.base_location)
+    base_room = str(settings.base_room)
+    hours: list[float] = []
+    for row in snapshot[["building", "room"]].itertuples(index=False):
+        building = str(row.building)
+        room = str(row.room)
+        try:
+            outbound = 0.0 if building == base else float(distances.loc[(base, building)])
+            inbound = float(distances.loc[(building, base)])
+        except KeyError as error:
+            raise ValueError(f"travel matrix lacks {base}<->{building}") from error
+        hours.append(
+            outbound
+            + inbound
+            + (building != base) * float(settings.time_per_building_change_hours)
+            + (room != base_room) * float(settings.time_per_room_change_hours)
+            + float(settings.time_per_battery_hours)
+        )
+    return float(np.mean(hours)) if hours else math.inf
+
+
+def v07_emergency_scale(
+    snapshot: pd.DataFrame, travel_costs: pd.DataFrame, settings
+) -> float:
+    mean_hours = mean_dedicated_trip_hours(snapshot, travel_costs, settings)
+    return (
+        V07_EMERGENCY_OPERATIONAL_SCALE
+        if mean_hours <= V07_MAX_MEAN_DEDICATED_TRIP_HOURS
+        else 0.0
+    )
+
+
+def _raw_columns(timeseries: pd.DataFrame) -> pd.DataFrame:
+    frame = timeseries
+    if "device_id" not in frame.columns or "end_time" not in frame.columns:
+        frame = frame.reset_index()
+    required = {"device_id", "end_time", "voltage", "temperature"}
+    missing = required - set(frame.columns)
+    if missing:
+        raise ValueError(f"battery time series lacks columns: {sorted(missing)}")
+    frame = frame[["device_id", "end_time", "voltage", "temperature"]].copy()
+    frame["device_id"] = frame["device_id"].astype(str)
+    frame["end_time"] = pd.to_datetime(frame["end_time"], errors="raise")
+    frame["voltage"] = pd.to_numeric(frame["voltage"], errors="coerce")
+    frame["temperature"] = pd.to_numeric(frame["temperature"], errors="coerce")
+    return frame
+
+
+def exact_smoothed_voltage(timeseries: pd.DataFrame) -> pd.DataFrame:
+    """Reproduce ``batteryswap_public==0.3.4`` smoothing exactly."""
+
+    frame = _raw_columns(timeseries).dropna(
+        subset=["device_id", "end_time", "voltage", "temperature"]
+    )
+    stable = frame[
+        frame["temperature"].gt(10.0) & frame["temperature"].lt(30.0)
+    ].reset_index(drop=True)
+    daily_parts: list[pd.DataFrame] = []
+    for device_id, group in stable.groupby("device_id", observed=True, sort=True):
+        indexed = group.set_index("end_time").sort_index()
+        resample = indexed[["voltage"]].resample("1D")
+        daily_quantile = resample.quantile(0.5)
+        daily_quantile = daily_quantile[resample.count() >= 5]
+        daily_quantile["device_id"] = str(device_id)
+        daily_parts.append(daily_quantile.reset_index())
+    if not daily_parts:
+        return pd.DataFrame(columns=["device_id", "end_time", "smooth_voltage"])
+    daily = pd.concat(daily_parts, ignore_index=True).sort_values(
+        ["device_id", "end_time"], kind="stable"
+    )
+    rolled = (
+        daily.set_index("end_time")
+        .groupby("device_id", observed=True)[["voltage"]]
+        .rolling(window=7, min_periods=3)
+        .quantile(0.5)
+        .reset_index()
+        .rename(columns={"voltage": "smooth_voltage"})
+    )
+    return rolled.sort_values(["device_id", "end_time"], kind="stable").reset_index(
+        drop=True
+    )
+
+
+def _daily_aggregates(timeseries: pd.DataFrame, beta_v_per_c: float) -> pd.DataFrame:
+    frame = _raw_columns(timeseries).dropna(
+        subset=["device_id", "end_time", "voltage", "temperature"]
+    )
+    frame = frame[
+        frame["temperature"].gt(10.0) & frame["temperature"].lt(30.0)
+    ].copy()
+    if frame.empty:
+        return pd.DataFrame(
+            columns=[
+                "device_id",
+                "day",
+                "smooth_voltage_day",
+                "raw_voltage",
+                "temperature",
+                "health",
+                "count",
+            ]
+        )
+    frame["day"] = frame["end_time"].dt.normalize()
+    frame["health"] = frame["voltage"] - beta_v_per_c * (
+        frame["temperature"] - REFERENCE_TEMPERATURE_C
+    )
+    grouped = frame.groupby(["device_id", "day"], observed=True, sort=True)
+    daily = grouped.agg(
+        raw_voltage=("voltage", "median"),
+        temperature=("temperature", "median"),
+        health=("health", "median"),
+        count=("voltage", "size"),
+    )
+    daily["smooth_voltage_day"] = grouped["voltage"].quantile(0.5)
+    daily = daily.reset_index()
+    invalid = daily["count"].lt(5)
+    daily.loc[
+        invalid,
+        ["smooth_voltage_day", "raw_voltage", "temperature", "health"],
+    ] = np.nan
+    return daily.sort_values(["device_id", "day"], kind="stable").reset_index(drop=True)
+
+
+@dataclass
+class CausalHistoryView:
+    smooth_lookup: dict[str, pd.Series]
+    devices: np.ndarray
+    device_index: dict[str, int]
+    day0: pd.Timestamp | None
+    raw_voltage: np.ndarray
+    temperature: np.ndarray
+    smooth_health: np.ndarray
+
+    @classmethod
+    def from_daily(cls, daily: pd.DataFrame) -> "CausalHistoryView":
+        if daily.empty:
+            empty = np.zeros((0, 1), dtype=np.float32)
+            return cls({}, np.asarray([], dtype=object), {}, None, empty, empty, empty)
+
+        lookup: dict[str, pd.Series] = {}
+        for device_id, group in daily.groupby("device_id", observed=True, sort=True):
+            group = group.sort_values("day", kind="stable")
+            index = pd.date_range(group["day"].min(), group["day"].max(), freq="1D")
+            index.name = "end_time"
+            raw = group.set_index("day")["smooth_voltage_day"].reindex(index)
+            lookup[str(device_id)] = raw.rolling(7, min_periods=3).quantile(0.5)
+
+        devices = np.asarray(sorted(daily["device_id"].astype(str).unique()), dtype=object)
+        device_index = {device: position for position, device in enumerate(devices)}
+        day0 = pd.Timestamp(daily["day"].min()).normalize()
+        day_n = pd.Timestamp(daily["day"].max()).normalize()
+        width = int((day_n - day0) / pd.Timedelta(days=1)) + 1
+        shape = (len(devices), width)
+        raw_voltage = np.full(shape, np.nan, dtype=np.float32)
+        temperature = np.full(shape, np.nan, dtype=np.float32)
+        health = np.full(shape, np.nan, dtype=np.float32)
+        rows = daily["device_id"].astype(str).map(device_index).to_numpy(dtype=int)
+        columns = ((pd.to_datetime(daily["day"]) - day0) / pd.Timedelta(days=1)).to_numpy(
+            dtype=int
+        )
+        raw_voltage[rows, columns] = daily["raw_voltage"].to_numpy(dtype=np.float32)
+        temperature[rows, columns] = daily["temperature"].to_numpy(dtype=np.float32)
+        health[rows, columns] = daily["health"].to_numpy(dtype=np.float32)
+        smooth_health = np.full(shape, np.nan, dtype=np.float32)
+        for row in range(len(devices)):
+            smooth_health[row] = (
+                pd.Series(health[row])
+                .rolling(7, min_periods=3)
+                .median()
+                .to_numpy(dtype=np.float32)
+            )
+        return cls(
+            lookup,
+            devices,
+            device_index,
+            day0,
+            raw_voltage,
+            temperature,
+            smooth_health,
+        )
+
+
+@dataclass
+class CausalHistoryCache:
+    """Incremental daily aggregation of scenario-visible raw histories."""
+
+    beta_v_per_c: float = FROZEN_TEMPERATURE_BETA_V_PER_C
+    split_id: str | None = None
+    last_cutoff: pd.Timestamp | None = None
+    daily: pd.DataFrame = field(default_factory=pd.DataFrame)
+    seen_devices: set[str] = field(default_factory=set)
+
+    def reset(self, split_id: str | None = None) -> None:
+        self.split_id = split_id
+        self.last_cutoff = None
+        self.daily = pd.DataFrame()
+        self.seen_devices = set()
+
+    def update(
+        self, visible_history: pd.DataFrame, cutoff: pd.Timestamp | str
+    ) -> CausalHistoryView:
+        cutoff = pd.Timestamp(cutoff)
+        flat = _raw_columns(visible_history)
+        if not flat.empty and flat["end_time"].max() > cutoff:
+            raise AssertionError(
+                f"visible history reaches {flat['end_time'].max()} after cutoff {cutoff}"
+            )
+
+        rebuild = self.last_cutoff is None or cutoff <= self.last_cutoff
+        if rebuild:
+            self.daily = _daily_aggregates(flat, self.beta_v_per_c)
+            self.seen_devices = set(flat["device_id"].astype(str))
+        else:
+            overlap_day = self.last_cutoff.normalize()
+            current_devices = set(flat["device_id"].astype(str))
+            new_devices = current_devices - self.seen_devices
+            use = flat["end_time"].ge(overlap_day) | flat["device_id"].isin(new_devices)
+            replacement = _daily_aggregates(flat.loc[use], self.beta_v_per_c)
+            if not self.daily.empty:
+                replace_devices = current_devices | new_devices
+                keep = ~(
+                    self.daily["device_id"].astype(str).isin(replace_devices)
+                    & pd.to_datetime(self.daily["day"]).ge(overlap_day)
+                )
+                self.daily = self.daily.loc[keep]
+            self.daily = pd.concat([self.daily, replacement], ignore_index=True)
+            if not self.daily.empty:
+                self.daily = self.daily.sort_values(
+                    ["device_id", "day"], kind="stable"
+                ).reset_index(drop=True)
+                if self.daily.duplicated(["device_id", "day"]).any():
+                    raise AssertionError("incremental daily cache contains duplicate device-days")
+            self.seen_devices.update(current_devices)
+        self.last_cutoff = cutoff
+        return CausalHistoryView.from_daily(self.daily)
+
+
+@dataclass(frozen=True)
+class AFTParameters:
+    beta0: float
+    beta1: float
+    sigma: float
+
+
+def fit_aft(frame: pd.DataFrame) -> tuple[AFTParameters, dict[str, int | float]]:
+    required = {
+        "battery",
+        "fp_reliable",
+        "fp_lifetime_days",
+        "landmark_age_days",
+        "outcome_lifetime_days",
+        "event_observed",
+    }
+    missing = required - set(frame.columns)
+    if missing:
+        raise ValueError(f"AFT training frame lacks columns: {sorted(missing)}")
+    reliable = _as_bool(frame["fp_reliable"])
+    age_all = pd.to_numeric(frame["landmark_age_days"], errors="coerce").to_numpy(float)
+    lifetime_all = pd.to_numeric(
+        frame["outcome_lifetime_days"], errors="coerce"
+    ).to_numpy(float)
+    fp_all = pd.to_numeric(frame["fp_lifetime_days"], errors="coerce").to_numpy(float)
+    eligible = (
+        reliable
+        & np.isfinite(fp_all)
+        & np.isfinite(age_all)
+        & np.isfinite(lifetime_all)
+        & (lifetime_all > age_all)
+        & (age_all > 0.0)
+    )
+    work = frame.loc[eligible].copy()
+    if work.empty:
+        raise ValueError("AFT fit has no reliable likelihood-eligible rows")
+    event = _as_bool(work["event_observed"])
+    event_devices = int(work.loc[event, "battery"].nunique())
+    devices = int(work["battery"].nunique())
+    if event_devices < 10 or devices < 20:
+        raise ValueError(
+            "AFT fit is not identifiable: "
+            f"event_devices={event_devices}, devices={devices}"
+        )
+    counts = work.groupby("battery", observed=True)["battery"].transform("size")
+    weights = 1.0 / counts.to_numpy(dtype=float)
+    x = np.log(pd.to_numeric(work["fp_lifetime_days"]).to_numpy(dtype=float))
+    age = pd.to_numeric(work["landmark_age_days"]).to_numpy(dtype=float)
+    outcome = pd.to_numeric(work["outcome_lifetime_days"]).to_numpy(dtype=float)
+
+    observed_x = x[event]
+    observed_y = np.log(outcome[event])
+    observed_w = weights[event]
+    design = np.column_stack([np.ones(len(observed_x)), observed_x])
+    initial_beta = np.linalg.lstsq(
+        design * np.sqrt(observed_w)[:, None],
+        observed_y * np.sqrt(observed_w),
+        rcond=None,
+    )[0]
+    initial_beta[0] = np.clip(initial_beta[0], -20.0, 20.0)
+    initial_beta[1] = np.clip(initial_beta[1], 0.0, 3.0)
+    residual = observed_y - (initial_beta[0] + initial_beta[1] * observed_x)
+    initial_sigma = float(
+        np.clip(np.sqrt(np.average(residual**2, weights=observed_w)), 0.1, 1.5)
+    )
+
+    def objective(raw: np.ndarray) -> float:
+        beta0, beta1, log_sigma = raw
+        sigma = float(np.exp(log_sigma))
+        mu = beta0 + beta1 * x
+        z_age = (np.log(age) - mu) / sigma
+        log_survival_age = log_ndtr(-z_age)
+        z_outcome = (np.log(outcome) - mu) / sigma
+        likelihood = np.empty(len(work), dtype=float)
+        likelihood[event] = (
+            -np.log(outcome[event])
+            - log_sigma
+            - 0.5 * math.log(2.0 * math.pi)
+            - 0.5 * z_outcome[event] ** 2
+            - log_survival_age[event]
+        )
+        likelihood[~event] = log_ndtr(-z_outcome[~event]) - log_survival_age[~event]
+        if not np.isfinite(likelihood).all():
+            return 1e100
+        return float(-np.sum(weights * likelihood))
+
+    fitted = minimize(
+        objective,
+        np.asarray(
+            [initial_beta[0], initial_beta[1], math.log(initial_sigma)], dtype=float
+        ),
+        method="L-BFGS-B",
+        bounds=(
+            (-20.0, 20.0),
+            (0.0, 3.0),
+            (math.log(0.05), math.log(2.0)),
+        ),
+        options={"maxiter": 1_000, "ftol": 1e-12, "gtol": 1e-8},
+    )
+    if not fitted.success or not np.isfinite(fitted.fun):
+        raise RuntimeError(f"three-parameter AFT optimization failed: {fitted.message}")
+    parameters = AFTParameters(
+        beta0=float(fitted.x[0]),
+        beta1=float(fitted.x[1]),
+        sigma=float(np.exp(fitted.x[2])),
+    )
+    diagnostics: dict[str, int | float] = {
+        "eligible_rows": int(len(work)),
+        "devices": devices,
+        "event_devices": event_devices,
+        "censored_devices": int(work.loc[~event, "battery"].nunique()),
+        "objective": float(fitted.fun),
+        "iterations": int(fitted.nit),
+    }
+    return parameters, diagnostics
+
+
+def _theil_sen_slope(days: np.ndarray, values: np.ndarray) -> float:
+    x = days.astype("datetime64[ns]").astype(np.int64) / 86_400_000_000_000.0
+    parts: list[np.ndarray] = []
+    for offset in range(1, len(x)):
+        delta_x = x[offset:] - x[:-offset]
+        usable = delta_x > 0.0
+        if usable.any():
+            parts.append((values[offset:] - values[:-offset])[usable] / delta_x[usable])
+    return float(np.median(np.concatenate(parts))) if parts else math.nan
+
+
+def _first_passage_lifetime(
+    device_id: str,
+    cutoff: pd.Timestamp,
+    installation_start: pd.Timestamp,
+    lookup: dict[str, pd.Series],
+) -> tuple[float, bool]:
+    series = lookup.get(str(device_id))
+    if series is None:
+        return math.nan, False
+    finite = series.dropna()
+    finite = finite[finite.index <= pd.Timestamp(cutoff).normalize()]
+    if finite.empty:
+        return math.nan, False
+    days = finite.index.to_numpy(dtype="datetime64[ns]")
+    values = finite.to_numpy(dtype=float)
+    last_day = pd.Timestamp(days[-1])
+    last_value = float(values[-1])
+    staleness = float((pd.Timestamp(cutoff) - last_day) / pd.Timedelta(days=1))
+    cutoff64 = np.datetime64(pd.Timestamp(cutoff).to_datetime64(), "ns")
+    lifetimes: list[float] = []
+    for window in FP_WINDOWS_DAYS:
+        low = cutoff64 - np.timedelta64(window - 1, "D")
+        use = days >= low
+        window_days = days[use]
+        window_values = values[use]
+        if len(window_values) < MIN_SMOOTHED_POINTS:
+            continue
+        span = float(
+            (pd.Timestamp(window_days[-1]) - pd.Timestamp(window_days[0]))
+            / pd.Timedelta(days=1)
+        )
+        if span < window * MIN_WINDOW_SPAN_FRACTION:
+            continue
+        slope = _theil_sen_slope(window_days, window_values)
+        if not np.isfinite(slope) or slope >= -MIN_DEGRADATION_RATE:
+            continue
+        eta = float(
+            np.clip((last_value - EOL_VOLTAGE) / -slope, 0.0, MAX_EXTRAPOLATION_DAYS)
+        )
+        lifetime = float(
+            (last_day - installation_start) / pd.Timedelta(days=1)
+        ) + eta
+        if np.isfinite(lifetime) and lifetime > 0.0:
+            lifetimes.append(lifetime)
+    if not lifetimes:
+        return math.nan, False
+    median = float(np.median(lifetimes))
+    mad = float(np.median(np.abs(np.asarray(lifetimes) - median)))
+    reliable = bool(
+        len(lifetimes) >= MIN_RELIABLE_WINDOWS
+        and 0.0 <= staleness <= MAX_SMOOTHED_STALENESS_DAYS
+        and mad <= MAX_LIFETIME_MAD_DAYS
+    )
+    return median, reliable
+
+
+@dataclass(frozen=True)
+class ResidualSignal:
+    values: np.ndarray
+    reliable: np.ndarray
+
+
+@dataclass(frozen=True)
+class ResidualContext:
+    history: CausalHistoryView
+    batteries: np.ndarray
+    locations: pd.DataFrame
+    cutoff: pd.Timestamp
+
+
+class IdentityRankResidual(Protocol):
+    name: str
+
+    def predict(self, context: ResidualContext) -> ResidualSignal: ...
+
+    def component_risk(
+        self,
+        baseline: np.ndarray,
+        batteries: np.ndarray,
+        signal: ResidualSignal,
+    ) -> np.ndarray: ...
+
+
+@dataclass(frozen=True)
+class LongTermAFTResidual:
+    parameters: AFTParameters
+    name: str = "lt_fp_aft"
+    base_weight: float = 0.90
+    aft_weight: float = 0.10
+
+    def predict(self, context: ResidualContext) -> ResidualSignal:
+        location_index = context.locations.assign(
+            battery=context.locations["battery"].astype(str)
+        ).set_index("battery", drop=False)
+        values = np.full(len(context.batteries), np.nan)
+        reliable = np.zeros(len(context.batteries), dtype=bool)
+        for position, battery in enumerate(context.batteries.astype(str)):
+            if battery not in location_index.index:
+                continue
+            installation = pd.Timestamp(location_index.loc[battery, "start_time"])
+            lifetime, is_reliable = _first_passage_lifetime(
+                battery,
+                context.cutoff,
+                installation,
+                context.history.smooth_lookup,
+            )
+            age = float((context.cutoff - installation) / pd.Timedelta(days=1))
+            if not is_reliable or not np.isfinite(lifetime) or lifetime <= 0.0 or age <= 0.0:
+                continue
+            mu = self.parameters.beta0 + self.parameters.beta1 * math.log(lifetime)
+            z_now = (math.log(age) - mu) / self.parameters.sigma
+            z_horizon = (math.log(age + HORIZON_DAYS) - mu) / self.parameters.sigma
+            survival_now = float(ndtr(-z_now))
+            probability = (float(ndtr(z_horizon)) - float(ndtr(z_now))) / max(
+                survival_now, np.finfo(float).tiny
+            )
+            values[position] = float(np.clip(probability, 0.0, 1.0))
+            reliable[position] = True
+        return ResidualSignal(values, reliable)
+
+    def component_risk(
+        self,
+        baseline: np.ndarray,
+        batteries: np.ndarray,
+        signal: ResidualSignal,
+    ) -> np.ndarray:
+        positions = np.flatnonzero(signal.reliable)
+        if len(positions) < 2:
+            return np.asarray(baseline, dtype=float).copy()
+        score = np.zeros(len(baseline), dtype=float)
+        score[positions] = self.base_weight * _rank(
+            np.asarray(baseline)[positions]
+        ) + self.aft_weight * _rank(signal.values[positions])
+        return assign_multiset(baseline, score, batteries, signal.reliable)
+
+
+@dataclass(frozen=True)
+class SimilarityDonorLibrary:
+    values: np.ndarray
+    masks: np.ndarray
+    donor_ids: np.ndarray
+    donor_buildings: np.ndarray
+    donor_codes: np.ndarray
+    endpoint_days: np.ndarray
+    residual_days: np.ndarray
+    endpoint_groups: tuple[np.ndarray, ...]
+    device_ids_by_code: np.ndarray
+    device_buildings_by_code: np.ndarray
+    building_groups: tuple[np.ndarray, ...]
+
+    @property
+    def donor_count(self) -> int:
+        return len(self.endpoint_groups)
+
+    @property
+    def endpoint_count(self) -> int:
+        return len(self.values)
+
+    @property
+    def building_count(self) -> int:
+        return len(self.building_groups)
+
+
+def _series_lookup(smoothed: pd.DataFrame) -> dict[str, pd.Series]:
+    lookup: dict[str, pd.Series] = {}
+    for device_id, group in smoothed.groupby("device_id", observed=True, sort=False):
+        ordered = group.sort_values("end_time", kind="stable")
+        days = pd.DatetimeIndex(ordered["end_time"]).normalize()
+        if days.has_duplicates:
+            raise AssertionError(f"smoothed grid has duplicate days for {device_id}")
+        lookup[str(device_id)] = pd.Series(
+            ordered["smooth_voltage"].to_numpy(dtype=float), index=days
+        )
+    return lookup
+
+
+def _normalised_prefix(
+    series: pd.Series, anchor: pd.Timestamp, baseline_voltage: float
+) -> np.ndarray:
+    target_days = pd.Timestamp(anchor).normalize() - pd.to_timedelta(
+        np.asarray(PREFIX_LAGS_DAYS), unit="D"
+    )
+    voltage = series.reindex(target_days).to_numpy(dtype=float)
+    margin = float(baseline_voltage) - EOL_VOLTAGE
+    if not np.isfinite(margin) or margin <= 1e-6:
+        return np.full(len(PREFIX_LAGS_DAYS), np.nan)
+    return (voltage - EOL_VOLTAGE) / margin
+
+
+def build_similarity_donor_library(
+    full_smoothed: pd.DataFrame,
+    eol_times: pd.Series,
+    battery_building: dict[str, str],
+) -> SimilarityDonorLibrary:
+    lookup = _series_lookup(full_smoothed)
+    values: list[np.ndarray] = []
+    donor_ids: list[str] = []
+    donor_buildings: list[str] = []
+    endpoint_days: list[np.datetime64] = []
+    residual_days: list[float] = []
+    observed = pd.to_datetime(eol_times.dropna(), errors="raise").sort_index()
+    for raw_device_id, raw_eol in observed.items():
+        device_id = str(raw_device_id)
+        building = str(battery_building.get(device_id, ""))
+        if not building:
+            continue
+        series = lookup.get(device_id)
+        if series is None:
+            continue
+        eol_day = pd.Timestamp(raw_eol).normalize()
+        pre_eol = series[series.index <= eol_day]
+        finite = pre_eol.dropna()
+        if len(finite) < BASELINE_VALID_POINTS:
+            continue
+        baseline = float(finite.iloc[:BASELINE_VALID_POINTS].median())
+        if not np.isfinite(baseline) or baseline <= EOL_VOLTAGE + 1e-6:
+            continue
+        baseline_ready = pd.Timestamp(finite.index[BASELINE_VALID_POINTS - 1]).normalize()
+        maximum_residual = int((eol_day - baseline_ready) / pd.Timedelta(days=1))
+        for residual in range(1, maximum_residual + 1, 7):
+            endpoint = eol_day - pd.Timedelta(days=residual)
+            vector = _normalised_prefix(pre_eol, endpoint, baseline)
+            if not np.isfinite(vector[0]) or np.isfinite(vector).sum() < MIN_PAIRED_LAGS:
+                continue
+            values.append(vector)
+            donor_ids.append(device_id)
+            donor_buildings.append(building)
+            endpoint_days.append(np.datetime64(endpoint, "ns"))
+            residual_days.append(float(residual))
+    if not values:
+        raise ValueError("full training split has no usable similarity donor endpoints")
+    donor_order = sorted(set(donor_ids))
+    donor_to_code = {device: code for code, device in enumerate(donor_order)}
+    donor_codes = np.asarray([donor_to_code[device] for device in donor_ids], dtype=int)
+    endpoint_groups = tuple(
+        np.flatnonzero(donor_codes == code) for code in range(len(donor_order))
+    )
+    device_buildings = np.asarray(
+        [donor_buildings[int(group[0])] for group in endpoint_groups], dtype=object
+    )
+    building_groups = tuple(
+        np.flatnonzero(device_buildings.astype(str) == building)
+        for building in sorted(set(device_buildings.astype(str)))
+    )
+    if len(endpoint_groups) < NEIGHBORS or len(building_groups) < NEIGHBORS:
+        raise ValueError("full donor library cannot supply K=8 distinct buildings")
+    value_array = np.asarray(values, dtype=float)
+    return SimilarityDonorLibrary(
+        values=value_array,
+        masks=np.isfinite(value_array),
+        donor_ids=np.asarray(donor_ids, dtype=object),
+        donor_buildings=np.asarray(donor_buildings, dtype=object),
+        donor_codes=donor_codes,
+        endpoint_days=np.asarray(endpoint_days, dtype="datetime64[ns]"),
+        residual_days=np.asarray(residual_days, dtype=float),
+        endpoint_groups=endpoint_groups,
+        device_ids_by_code=np.asarray(donor_order, dtype=object),
+        device_buildings_by_code=device_buildings,
+        building_groups=building_groups,
+    )
+
+
+def _query_similarity(
+    batteries: np.ndarray,
+    cutoff: pd.Timestamp,
+    lookup: dict[str, pd.Series],
+) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    vectors = np.full((len(batteries), len(PREFIX_LAGS_DAYS)), np.nan)
+    ready = np.zeros(len(batteries), dtype=bool)
+    staleness = np.full(len(batteries), np.nan)
+    for position, battery in enumerate(batteries.astype(str)):
+        series = lookup.get(battery)
+        if series is None:
+            continue
+        finite = series.dropna()
+        finite = finite[finite.index <= cutoff.normalize()]
+        if finite.empty:
+            continue
+        anchor = pd.Timestamp(finite.index[-1]).normalize()
+        local_staleness = float((cutoff - anchor) / pd.Timedelta(days=1))
+        baseline = (
+            float(finite.iloc[:BASELINE_VALID_POINTS].median())
+            if len(finite) >= BASELINE_VALID_POINTS
+            else math.nan
+        )
+        vector = _normalised_prefix(series, anchor, baseline)
+        mask = np.isfinite(vector)
+        coverage = float(PREFIX_WEIGHTS[mask].sum() / PREFIX_WEIGHTS.sum())
+        vectors[position] = vector
+        staleness[position] = local_staleness
+        ready[position] = bool(
+            len(finite) >= BASELINE_VALID_POINTS
+            and np.isfinite(baseline)
+            and baseline > EOL_VOLTAGE + 1e-6
+            and 0.0 <= local_staleness <= MAX_SMOOTHED_STALENESS_DAYS
+            and int(mask.sum()) >= MIN_PAIRED_LAGS
+            and coverage >= MIN_WEIGHTED_COVERAGE
+        )
+    return vectors, ready, staleness
+
+
+def score_similarity(
+    query_values: np.ndarray,
+    query_ready: np.ndarray,
+    query_staleness: np.ndarray,
+    library: SimilarityDonorLibrary,
+) -> ResidualSignal:
+    row_count = len(query_values)
+    risk = np.full(row_count, np.nan)
+    reliable_out = np.zeros(row_count, dtype=bool)
+    donor_values = np.nan_to_num(library.values, nan=0.0)
+    donor_mask = library.masks.astype(float)
+    donor_value_mask = donor_values * donor_mask
+    donor_square_mask = donor_values**2 * donor_mask
+    ready_positions = np.flatnonzero(np.asarray(query_ready, dtype=bool))
+    for begin in range(0, len(ready_positions), DISTANCE_BATCH_SIZE):
+        positions = ready_positions[begin : begin + DISTANCE_BATCH_SIZE]
+        raw_query = np.asarray(query_values[positions], dtype=float)
+        query_mask = np.isfinite(raw_query).astype(float)
+        query = np.nan_to_num(raw_query, nan=0.0)
+        weighted_mask = query_mask * PREFIX_WEIGHTS[None, :]
+        overlap_weight = weighted_mask @ donor_mask.T
+        paired_lags = query_mask @ donor_mask.T
+        query_weight = weighted_mask.sum(axis=1, keepdims=True)
+        coverage = overlap_weight / np.maximum(query_weight, np.finfo(float).tiny)
+        first = (weighted_mask * query**2) @ donor_mask.T
+        second = weighted_mask @ donor_square_mask.T
+        cross = (weighted_mask * query) @ donor_value_mask.T
+        numerator = np.maximum(first + second - 2.0 * cross, 0.0)
+        with np.errstate(divide="ignore", invalid="ignore"):
+            distance = np.sqrt(numerator / overlap_weight) / np.sqrt(coverage)
+        usable = (
+            (paired_lags >= MIN_PAIRED_LAGS)
+            & (coverage >= MIN_WEIGHTED_COVERAGE)
+            & np.isfinite(distance)
+        )
+        distance = np.where(usable, distance, np.inf)
+        block_size = len(positions)
+        best_distance = np.full((block_size, library.donor_count), np.inf)
+        best_endpoint = np.full((block_size, library.donor_count), -1, dtype=int)
+        for donor_code, endpoint_index in enumerate(library.endpoint_groups):
+            local = distance[:, endpoint_index]
+            choice = np.argmin(local, axis=1)
+            best_distance[:, donor_code] = local[np.arange(block_size), choice]
+            best_endpoint[:, donor_code] = endpoint_index[choice]
+        best_building_distance = np.full((block_size, library.building_count), np.inf)
+        best_building_endpoint = np.full(
+            (block_size, library.building_count), -1, dtype=int
+        )
+        for building_code, donor_codes in enumerate(library.building_groups):
+            local = best_distance[:, donor_codes]
+            choice = np.argmin(local, axis=1)
+            chosen_donor = donor_codes[choice]
+            best_building_distance[:, building_code] = local[
+                np.arange(block_size), choice
+            ]
+            best_building_endpoint[:, building_code] = best_endpoint[
+                np.arange(block_size), chosen_donor
+            ]
+        top_buildings = np.argsort(
+            best_building_distance, axis=1, kind="stable"
+        )[:, :NEIGHBORS]
+        top_distance = np.take_along_axis(
+            best_building_distance, top_buildings, axis=1
+        )
+        top_endpoint = np.take_along_axis(
+            best_building_endpoint, top_buildings, axis=1
+        )
+        has_k = np.isfinite(top_distance).all(axis=1) & (top_endpoint >= 0).all(axis=1)
+        safe_endpoint = np.maximum(top_endpoint, 0)
+        top_rul = np.maximum(
+            library.residual_days[safe_endpoint] - query_staleness[positions, None],
+            0.0,
+        )
+        inverse = 1.0 / (top_distance + INVERSE_DISTANCE_EPSILON)
+        inverse = np.where(has_k[:, None], inverse, 0.0)
+        weights = inverse / np.maximum(
+            inverse.sum(axis=1, keepdims=True), np.finfo(float).tiny
+        )
+        neighbor_risk = np.sum(weights * (top_rul <= HORIZON_DAYS), axis=1)
+        effective_neighbors = 1.0 / np.maximum(
+            np.sum(weights**2, axis=1), np.finfo(float).tiny
+        )
+        selected_buildings = library.donor_buildings[safe_endpoint]
+        unique_buildings = np.zeros(block_size)
+        effective_buildings = np.zeros(block_size)
+        for row in range(block_size):
+            by_building: dict[str, float] = {}
+            for building, weight in zip(
+                selected_buildings[row], weights[row], strict=True
+            ):
+                name = str(building)
+                by_building[name] = by_building.get(name, 0.0) + float(weight)
+            unique_buildings[row] = len(by_building)
+            effective_buildings[row] = 1.0 / max(
+                sum(weight**2 for weight in by_building.values()),
+                np.finfo(float).tiny,
+            )
+        reliable = (
+            has_k
+            & (effective_neighbors >= MIN_EFFECTIVE_NEIGHBORS)
+            & (unique_buildings >= MIN_UNIQUE_DONOR_BUILDINGS)
+            & (effective_buildings >= MIN_EFFECTIVE_DONOR_BUILDINGS)
+        )
+        risk[positions] = np.where(has_k, neighbor_risk, np.nan)
+        reliable_out[positions] = reliable
+    return ResidualSignal(risk, reliable_out)
+
+
+@dataclass(frozen=True)
+class OriginalSimilarityResidual:
+    library: SimilarityDonorLibrary
+    name: str = "original_similarity_eol"
+
+    def predict(self, context: ResidualContext) -> ResidualSignal:
+        query, ready, staleness = _query_similarity(
+            context.batteries, context.cutoff, context.history.smooth_lookup
+        )
+        return score_similarity(query, ready, staleness, self.library)
+
+    def component_risk(
+        self,
+        baseline: np.ndarray,
+        batteries: np.ndarray,
+        signal: ResidualSignal,
+    ) -> np.ndarray:
+        del batteries  # Reference experiment deliberately used stable row-order ties.
+        baseline = np.asarray(baseline, dtype=float)
+        out = baseline.copy()
+        positions = np.flatnonzero(signal.reliable)
+        if len(positions) < 2:
+            return out
+        local_risk = signal.values[positions]
+        if not np.isfinite(local_risk).all():
+            raise ValueError("reliable similarity rows have non-finite risk")
+        score = _logit(baseline)
+        score[positions] += np.clip(
+            2.0 * local_risk - 1.0, -MAX_LOGIT_RESIDUAL, MAX_LOGIT_RESIDUAL
+        )
+        order = np.argsort(score[positions], kind="stable")
+        reassigned = np.empty(len(positions), dtype=float)
+        reassigned[order] = np.sort(baseline[positions])
+        out[positions] = reassigned
+        if not np.array_equal(out[~signal.reliable], baseline[~signal.reliable]):
+            raise AssertionError("unreliable similarity rows changed")
+        if not np.array_equal(np.sort(out), np.sort(baseline)):
+            raise AssertionError("similarity component changed risk multiset")
+        return out
+
+
+def fit_temperature_beta(timeseries: pd.DataFrame) -> tuple[float, dict[str, int | float]]:
+    frame = _raw_columns(timeseries).dropna(subset=["voltage", "temperature"])
+    frame = frame[
+        frame["temperature"].gt(10.0) & frame["temperature"].lt(30.0)
+    ].copy()
+    frame["day"] = frame["end_time"].dt.normalize()
+    grouped = frame.groupby(["device_id", "day"], observed=True, sort=False)
+    count = grouped["voltage"].transform("size")
+    usable = count.ge(5)
+    centered_voltage = frame["voltage"] - grouped["voltage"].transform("mean")
+    centered_temperature = frame["temperature"] - grouped["temperature"].transform(
+        "mean"
+    )
+    x = centered_temperature[usable].to_numpy(dtype=float)
+    y = centered_voltage[usable].to_numpy(dtype=float)
+    denominator = float(np.dot(x, x))
+    if denominator <= 0.0:
+        raise ValueError("temperature coefficient has no within-device-day variation")
+    raw_beta = float(np.dot(x, y) / denominator)
+    return max(raw_beta, 0.0), {
+        "raw_beta_v_per_c": raw_beta,
+        "clipped_beta_v_per_c": max(raw_beta, 0.0),
+        "training_readings": int(usable.sum()),
+        "training_device_days": int(
+            frame.loc[usable, ["device_id", "day"]].drop_duplicates().shape[0]
+        ),
+    }
+
+
+def _seasonal_physics_signal(
+    history: CausalHistoryView,
+    batteries: np.ndarray,
+    cutoff: pd.Timestamp,
+    beta_v_per_c: float,
+    maximum_predicted_min_voltage: float | None = None,
+) -> ResidualSignal:
+    count = len(batteries)
+    reliable = np.zeros(count, dtype=bool)
+    urgency = np.full(count, np.nan)
+    if history.day0 is None:
+        return ResidualSignal(urgency, reliable)
+    cut_column = int((cutoff.normalize() - history.day0) / pd.Timedelta(days=1))
+    forecast_offsets = np.arange(1, int(HORIZON_DAYS) + 1, dtype=int)
+    for position, battery in enumerate(batteries.astype(str)):
+        row = history.device_index.get(battery)
+        if row is None or cut_column <= 0:
+            continue
+        history_start = max(0, cut_column - DRIFT_WINDOW_DAYS)
+        health = history.smooth_health[row, history_start:cut_column].astype(float)
+        finite = np.flatnonzero(np.isfinite(health))
+        if len(finite) < MIN_DRIFT_POINTS:
+            continue
+        if finite[-1] - finite[0] < MIN_DRIFT_SPAN_DAYS:
+            continue
+        last_column = history_start + int(finite[-1])
+        staleness = cut_column - 1 - last_column
+        if staleness > MAX_HEALTH_STALENESS_DAYS:
+            continue
+        x = finite.astype(float)
+        y = health[finite]
+        centered = x - x.mean()
+        denominator = float(np.dot(centered, centered))
+        if denominator <= 0.0:
+            continue
+        slope = min(float(np.dot(centered, y - y.mean()) / denominator), 0.0)
+        current_health = float(y[-1])
+        analog_columns = cut_column + forecast_offsets - SEASONAL_LAG_DAYS
+        valid_columns = (analog_columns >= 0) & (
+            analog_columns < history.temperature.shape[1]
+        )
+        analog = np.full(int(HORIZON_DAYS), np.nan)
+        analog[valid_columns] = history.temperature[
+            row, analog_columns[valid_columns]
+        ].astype(float)
+        finite_temperature = np.isfinite(analog)
+        if int(finite_temperature.sum()) < MIN_ANALOG_DAYS:
+            continue
+        analog_filled = np.interp(
+            forecast_offsets.astype(float),
+            forecast_offsets[finite_temperature].astype(float),
+            analog[finite_temperature],
+        )
+        forecast_health = current_health + slope * forecast_offsets
+        forecast_raw = forecast_health + beta_v_per_c * (
+            analog_filled - REFERENCE_TEMPERATURE_C
+        )
+        trailing = history.raw_voltage[
+            row, max(0, cut_column - 6) : cut_column
+        ].astype(float)
+        if len(trailing) < 6:
+            trailing = np.pad(trailing, (6 - len(trailing), 0), constant_values=np.nan)
+        combined = np.concatenate([trailing[-6:], forecast_raw])
+        forecast_smooth = (
+            pd.Series(combined).rolling(7, min_periods=3).median().to_numpy()[6:]
+        )
+        if not np.isfinite(forecast_smooth).all():
+            continue
+        predicted_min_voltage = float(np.min(forecast_smooth))
+        urgency[position] = -predicted_min_voltage
+        reliable[position] = bool(
+            maximum_predicted_min_voltage is None
+            or predicted_min_voltage <= maximum_predicted_min_voltage
+        )
+    return ResidualSignal(urgency, reliable)
+
+
+class PostRankResidual(Protocol):
+    name: str
+
+    def predict(self, context: ResidualContext) -> ResidualSignal: ...
+
+    def rerank(
+        self,
+        baseline: np.ndarray,
+        batteries: np.ndarray,
+        signal: ResidualSignal,
+    ) -> np.ndarray: ...
+
+
+@dataclass(frozen=True)
+class SeasonalTemperatureResidual:
+    beta_v_per_c: float = FROZEN_TEMPERATURE_BETA_V_PER_C
+    fitted_raw_beta_v_per_c: float = FROZEN_TEMPERATURE_BETA_V_PER_C
+    training_readings: int = 0
+    maximum_predicted_min_voltage: float = TEMPERATURE_MAX_PREDICTED_MIN_VOLTAGE
+    name: str = "seasonal_temperature_below_250_logit1"
+
+    def predict(self, context: ResidualContext) -> ResidualSignal:
+        return _seasonal_physics_signal(
+            context.history,
+            context.batteries,
+            context.cutoff,
+            self.beta_v_per_c,
+            self.maximum_predicted_min_voltage,
+        )
+
+    def rerank(
+        self,
+        baseline: np.ndarray,
+        batteries: np.ndarray,
+        signal: ResidualSignal,
+    ) -> np.ndarray:
+        positions = np.flatnonzero(signal.reliable)
+        if len(positions) < 2:
+            return np.asarray(baseline, dtype=float).copy()
+        score = _logit(baseline)
+        score[positions] += 2.0 * _rank(signal.values[positions]) - 1.0
+        return assign_multiset(baseline, score, batteries, signal.reliable)
+
+
+@dataclass(frozen=True)
+class WeightedIdentityResidual:
+    residual: IdentityRankResidual
+    weight: float
+
+
+@dataclass(frozen=True)
+class IdentityEnsembleModel:
+    """Composable rank residuals followed by optional bounded post-residuals."""
+
+    identity_residuals: tuple[WeightedIdentityResidual, ...]
+    post_residuals: tuple[PostRankResidual, ...] = ()
+    history_temperature_beta_v_per_c: float = FROZEN_TEMPERATURE_BETA_V_PER_C
+
+    def predict_risk(
+        self,
+        baseline: np.ndarray,
+        freshness: np.ndarray,
+        context: ResidualContext,
+    ) -> np.ndarray:
+        identity_signals = tuple(
+            item.residual.predict(context) for item in self.identity_residuals
+        )
+        post_signals = tuple(residual.predict(context) for residual in self.post_residuals)
+        return self.rerank_from_signals(
+            baseline,
+            freshness,
+            context.batteries,
+            identity_signals,
+            post_signals,
+        )
+
+    def rerank_from_signals(
+        self,
+        baseline: np.ndarray,
+        freshness: np.ndarray,
+        batteries: np.ndarray,
+        identity_signals: tuple[ResidualSignal, ...],
+        post_signals: tuple[ResidualSignal, ...] = (),
+    ) -> np.ndarray:
+        """Pure parity surface for already-computed causal component signals."""
+
+        baseline = np.asarray(baseline, dtype=float)
+        freshness = np.asarray(freshness, dtype=float)
+        batteries = np.asarray(batteries, dtype=object)
+        if not (len(baseline) == len(freshness) == len(batteries)):
+            raise ValueError("ensemble inputs have different lengths")
+        if not np.isfinite(baseline).all() or not np.isfinite(freshness).all():
+            raise ValueError("base risks and freshness factors must be finite")
+        if not self.identity_residuals:
+            identity = baseline.copy()
+        else:
+            if len(identity_signals) != len(self.identity_residuals):
+                raise ValueError("identity signal count differs from configured residuals")
+            identity = baseline.copy()
+            for factor in np.sort(np.unique(freshness)):
+                positions = np.flatnonzero(freshness == factor)
+                local_base = baseline[positions]
+                local_batteries = batteries[positions]
+                components: list[np.ndarray] = []
+                union = np.zeros(len(positions), dtype=bool)
+                total_weight = 0.0
+                borda = np.zeros(len(positions), dtype=float)
+                for item, signal in zip(
+                    self.identity_residuals, identity_signals, strict=True
+                ):
+                    local_signal = ResidualSignal(
+                        signal.values[positions], signal.reliable[positions]
+                    )
+                    component = item.residual.component_risk(
+                        local_base, local_batteries, local_signal
+                    )
+                    components.append(component)
+                    union |= local_signal.reliable
+                    if item.weight > 0.0:
+                        borda += item.weight * _rank(component)
+                        total_weight += item.weight
+                if total_weight <= 0.0:
+                    raise ValueError("identity residual weights must contain a positive value")
+                borda /= total_weight
+                identity[positions] = assign_multiset(
+                    local_base, borda, local_batteries, union
+                )
+                if not np.array_equal(
+                    np.sort(local_base * factor),
+                    np.sort(identity[positions] * factor),
+                ):
+                    raise AssertionError("identity changed planner-effective risk multiset")
+
+        treatment = identity
+        if len(post_signals) != len(self.post_residuals):
+            raise ValueError("post signal count differs from configured residuals")
+        for residual, signal in zip(self.post_residuals, post_signals, strict=True):
+            updated = treatment.copy()
+            for factor in np.sort(np.unique(freshness)):
+                positions = np.flatnonzero(freshness == factor)
+                local_signal = ResidualSignal(
+                    signal.values[positions], signal.reliable[positions]
+                )
+                updated[positions] = residual.rerank(
+                    treatment[positions], batteries[positions], local_signal
+                )
+                if not np.array_equal(
+                    np.sort(treatment[positions] * factor),
+                    np.sort(updated[positions] * factor),
+                ):
+                    raise AssertionError(
+                        f"{residual.name} changed planner-effective risk multiset"
+                    )
+            treatment = updated
+        if not np.array_equal(np.sort(treatment), np.sort(baseline)):
+            raise AssertionError("ensemble changed scenario raw risk multiset")
+        if not np.array_equal(
+            np.sort(treatment * freshness), np.sort(baseline * freshness)
+        ):
+            raise AssertionError("ensemble changed scenario effective risk multiset")
+        return treatment
+
+
+@dataclass
+class IdentityEnsemblePlanner:
+    """Deployable wrapper that preserves the frozen base planner and its heads."""
+
+    base_planner: CompetitionPlanner
+    ensemble: IdentityEnsembleModel
+    base_artifact_sha256: str
+    schema_version: int = SCHEMA_VERSION
+    _history_cache: CausalHistoryCache | None = field(
+        default=None, init=False, repr=False, compare=False
+    )
+
+    def reset_split(self, split_id: str | None = None) -> None:
+        self._history_cache = CausalHistoryCache(
+            beta_v_per_c=self.ensemble.history_temperature_beta_v_per_c,
+            split_id=split_id,
+        )
+
+    def plan_scenario(
+        self,
+        visible_history: pd.DataFrame,
+        snapshot: pd.DataFrame,
+        locations: pd.DataFrame,
+        travel_costs: pd.DataFrame,
+        settings,
+        start_time: pd.Timestamp | str,
+    ) -> pd.DataFrame:
+        if self.schema_version != SCHEMA_VERSION:
+            raise RuntimeError(
+                f"identity artifact schema {self.schema_version} != runtime {SCHEMA_VERSION}"
+            )
+        if self._history_cache is None:
+            self.reset_split(None)
+        assert self._history_cache is not None
+        start = pd.Timestamp(start_time)
+        history = self._history_cache.update(visible_history, start)
+        batteries = snapshot["battery"].astype(str).to_numpy()
+        if not np.array_equal(batteries, locations["battery"].astype(str).to_numpy()):
+            raise AssertionError("snapshot and locations battery order differs")
+        base_risk = self.base_planner.model.predict_event_risk(snapshot)
+        predicted_rul = self.base_planner.model.predict_rul(snapshot)
+        predicted_survivor = self.base_planner.model.predict_survivor_rul(snapshot)
+        if predicted_survivor is None:
+            predicted_survivor = np.full(len(snapshot), float(settings.planning_window_days))
+        freshness = planner_freshness_factors(
+            snapshot["data_gap_days"].to_numpy(dtype=float), self.base_planner.policy
+        )
+        context = ResidualContext(history, batteries, locations, start)
+        treatment_risk = self.ensemble.predict_risk(base_risk, freshness, context)
+        scale = v07_emergency_scale(snapshot, travel_costs, settings)
+        policy = replace(
+            self.base_planner.policy, emergency_operational_scale=float(scale)
+        )
+        planner = CompetitionPlanner(None, policy)
+        return planner.plan_snapshot(
+            snapshot,
+            locations,
+            travel_costs,
+            settings,
+            start,
+            predicted_rul=predicted_rul,
+            predicted_risk=treatment_risk,
+            predicted_survivor_rul=predicted_survivor,
+        )

submission_artifacts/planner.joblib

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:63d71091d7f46e8fb11798b7c2be936cc7e0022954824a4eb98c07dc1bf9b0b3
-size 15508289
+oid sha256:3cfca2e7dd2c05ddd84f2eca42a484168a1ab4ad3cd454806ef4e687fe8f1569
+size 15508355

submission_artifacts/planner.json

@@ -8,6 +8,7 @@
   "expected_gain_margin": 10.0,
   "expected_service_cost_hours": 2.0,
   "scheduled_fraction": 0.038,
+  "capacity_lookback_days": 42,
   "weekly_guard_fraction": 0.95,
   "hard_limit_penalty_multiplier": 1.5,
   "minimum_scheduled_batteries": 8,
@@ -18,7 +19,7 @@
     "prediction_offset_days": -5.0,
     "building_batch_window_days": 4,
     "unscheduled_margin_days": 1,
-    "capacity_lookback_days": 14,
+    "capacity_lookback_days": 42,
     "capacity_lookahead_days": 21,
     "capacity_daily_limit_fraction": 1.0,
     "capacity_weekly_limit_fraction": 0.95,
@@ -135,7 +136,7 @@
     "building_battery_count",
     "room_battery_count"
   ],
-  "artifact_sha256": "63d71091d7f46e8fb11798b7c2be936cc7e0022954824a4eb98c07dc1bf9b0b3",
+  "artifact_sha256": "3cfca2e7dd2c05ddd84f2eca42a484168a1ab4ad3cd454806ef4e687fe8f1569",
   "runtime_versions": {
     "batteryswap_public": "0.3.4",
     "fastparquet": "2026.5.0",
@@ -146,15 +147,15 @@
   },
   "validation_report": "artifacts/submission_cv_final.json",
   "optimistic_train_score": {
-    "daily_limit": 12.5,
-    "weekly_limit": 43.75,
-    "late_swap": 75.83333333333333,
+    "building_change": 10.25,
+    "daily_limit": 14.583333333333334,
+    "travel": 32.68057291666667,
     "battery_swap": 4.026041666666667,
-    "room_change": 6.791666666666667,
-    "overtime": 57.756944444444464,
-    "early_swap": 386.8645833333333,
-    "building_change": 10.520833333333334,
-    "travel": 36.906100694444454,
-    "total_cost": 634.9495034722223
+    "early_swap": 391.3229166666667,
+    "weekly_limit": 39.583333333333336,
+    "overtime": 51.89251388888891,
+    "room_change": 6.75,
+    "late_swap": 75.83333333333333,
+    "total_cost": 626.9220451388888
   }
 }

submission_artifacts/temperature_planner.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3fdac6f588b779f6a1aa6bd224ed7ad460b7165eda5e7b1060ef5484edf4b804
+size 16513962

submission_artifacts/temperature_planner.json

@@ -0,0 +1,196 @@
+{
+  "aft": {
+    "diagnostics": {
+      "censored_devices": 374,
+      "devices": 450,
+      "eligible_rows": 10636,
+      "event_devices": 76,
+      "iterations": 27,
+      "objective": 549.3019842852074
+    },
+    "parameters": {
+      "beta0": 0.8736216147089645,
+      "beta1": 0.8894051370094506,
+      "sigma": 0.23315668503034834
+    }
+  },
+  "artifact": "submission_artifacts/temperature_planner.joblib",
+  "artifact_sha256": "3fdac6f588b779f6a1aa6bd224ed7ad460b7165eda5e7b1060ef5484edf4b804",
+  "artifact_size_bytes": 16513962,
+  "base_artifact": "submission_artifacts/planner.joblib",
+  "base_artifact_byte_preserved": true,
+  "base_artifact_sha256_after": "3cfca2e7dd2c05ddd84f2eca42a484168a1ab4ad3cd454806ef4e687fe8f1569",
+  "base_artifact_sha256_before": "3cfca2e7dd2c05ddd84f2eca42a484168a1ab4ad3cd454806ef4e687fe8f1569",
+  "container_base": "huggingface/competitions@sha256:6cea4ff69a6832761484f48c07ccfbf49f701f285ffcb9fc72a4ecfb81b6b4e5",
+  "dataset_files": {
+    "battery_metrics.parquet": "d333e69cd1145ca025904511ee517d234a0616a9bc9c2d056a056a66ac7432e2",
+    "devices.csv": "59819728f367b05c09b15038b28239253419a640a7dfd7caed366dffa4f71eb2",
+    "eol_times.csv": "c02984228e6b791c75c65d3a1a9d1727864ff30dfd6c1147cd6784125e8ba189",
+    "scenarios.json": "49917e65fe5194af5a9f0a46413187bf47e4453f0e09860f6249f7ad654559f9"
+  },
+  "dataset_revision": "7f423ac4cb6ab146f7ea7a37872eb4dfc3c9705c",
+  "ensemble": {
+    "freshness_stratified": true,
+    "identity_components": [
+      {
+        "name": "lt_fp_aft",
+        "weight": 0.5
+      },
+      {
+        "name": "original_similarity_eol",
+        "weight": 0.5
+      }
+    ],
+    "planner_effective_risk_multiset_preserved": true,
+    "post_components": [
+      "seasonal_temperature_below_250_logit1"
+    ],
+    "raw_risk_multiset_preserved": true,
+    "v07_emergency_scale": 0.75,
+    "v07_mean_trip_gate_hours": 8.0
+  },
+  "official_evaluator_run": false,
+  "random_seeds": {
+    "base_model": 2026,
+    "identity_residuals": null
+  },
+  "runtime_versions": {
+    "batteryswap_public": "0.3.4",
+    "fastparquet": "2026.5.0",
+    "joblib": "1.5.3",
+    "numpy": "2.2.6",
+    "pandas": "2.3.3",
+    "pydantic-settings": "2.15.0",
+    "scikit-learn": "1.7.2",
+    "scipy": "1.14.1",
+    "structlog": "26.1.0"
+  },
+  "schema_version": 1,
+  "seasonal_temperature": {
+    "enabled": true,
+    "frozen_beta_v_per_c": 0.00549,
+    "full_train_fit": {
+      "clipped_beta_v_per_c": 0.005490315451361821,
+      "raw_beta_v_per_c": 0.005490315451361821,
+      "training_device_days": 327760,
+      "training_readings": 7203213
+    },
+    "maximum_predicted_min_voltage": 2.5
+  },
+  "similarity_library": {
+    "arrays": {
+      "device_buildings_by_code": {
+        "dtype": "object",
+        "sha256": "14952b5a526c6a2f56ab004728d3a2f08ade7588f7e4e7e099401522e376d3bc",
+        "shape": [
+          82
+        ]
+      },
+      "device_ids_by_code": {
+        "dtype": "object",
+        "sha256": "d9c4639bc36ccd9d015b6693dec35c7623448b0615a3ea85bec023007c1a2cd0",
+        "shape": [
+          82
+        ]
+      },
+      "donor_buildings": {
+        "dtype": "object",
+        "sha256": "69003f56da7d9f40a693d72092ab08b00e54c009c7a3c24a842389f4ce8f4fc1",
+        "shape": [
+          7257
+        ]
+      },
+      "donor_codes": {
+        "dtype": "int64",
+        "sha256": "91ec85d3ad42e60422e736642e5bc70677df34a774bd1f12133801f8b3104171",
+        "shape": [
+          7257
+        ]
+      },
+      "donor_ids": {
+        "dtype": "object",
+        "sha256": "bdd4bd413919359fcbc689f189a4f3513ede64ec73ccfae2486dafb189dc5c6a",
+        "shape": [
+          7257
+        ]
+      },
+      "endpoint_days": {
+        "dtype": "datetime64[ns]",
+        "sha256": "4c12f0cf07d5fd8fb94d2de1badab8b9bd3728c6279d72f92939c241cba923d3",
+        "shape": [
+          7257
+        ]
+      },
+      "masks": {
+        "dtype": "bool",
+        "sha256": "c6db4208d17c3ea575510d0ef484adb21010495a460415c94bc7fdacf81980a3",
+        "shape": [
+          7257,
+          49
+        ]
+      },
+      "residual_days": {
+        "dtype": "float64",
+        "sha256": "eb425df66eb6136810506a663fb79c2b41ba3df4ff0c9241d2b8513e9e0d6f31",
+        "shape": [
+          7257
+        ]
+      },
+      "values": {
+        "dtype": "float64",
+        "sha256": "767a4fc753a4d1971713de79259136a119defa3c7c3be952e7e2cdfe5627ad03",
+        "shape": [
+          7257,
+          49
+        ]
+      }
+    },
+    "donor_buildings": 24,
+    "donor_devices": 82,
+    "donor_endpoints": 7257,
+    "prefix_lags": 49
+  },
+  "smoothing_audit": {
+    "exact_eol_matches": 82,
+    "observed_eol_devices": 82
+  },
+  "source_sha256": {
+    "Dockerfile": "84a3f71b2ba664f91ceb8a2980dd5397a002eed02af9fdd264325caf89158573",
+    "LICENSE": "02a0be95f0bbc0d5d656ef7983a9267141f1cd201b5c0ac7ff7c9b9c6c765985",
+    "README.md": "400e54feb8c26148079379ceb76a9d39c9af9a513aed842a74340df609a963a3",
+    "REPRODUCIBILITY.md": "cce05ccbaee8b0bf119ff7dac1c7660fcbd2c1ad2b405e6c5d9e9d57504fe56e",
+    "THIRD_PARTY_LICENSES.md": "c530152f46533b773acaffb76fb452fc7511765ce343fb35d3e7830edfb2f267",
+    "pyproject.toml": "154acd67853b696aecc62c4db1c29c44b50c8d57b10a5d8deb58148978344136",
+    "requirements.txt": "53d9c582b98b392c0517dc87c78949cd13b99b3f09ebfce601d0c8eadd4f2db3",
+    "script.py": "4c4537adef9531380a17161d720e864999a708497ddae31888e851b221480ea5",
+    "scripts/build_identity_submission.py": "5ad4fb55db9817da4295e69e98d843d0fdf3986d2b169b6f114f550911775bc4",
+    "scripts/evaluate_clean_identity_candidate.py": "d665105b8eff79f44d6a493ca241ab96f5c3b6ef06b16dd708908251845829f8",
+    "scripts/experiment_identity_ensemble.py": "06bc341f13eec3893ff0c1343a20bd085d9447f329d66d0ffb6c33f957598a40",
+    "scripts/experiment_lt_fp_aft.py": "3c0b8e6d1f5a4e36e5d84a3ce61c38d861a65e2adb999bee9515490c50db6c97",
+    "scripts/experiment_similarity_eol.py": "a84ef4d194b96afd17e630faff589011aff7f88c84835ca2ffdbccf8b75caa7b",
+    "scripts/experiment_temperature_physics_ensemble.py": "d3cc15e017691b06f4b093e8304e160a1139c5b1fa886a10b4eca9bc9d99b441",
+    "scripts/verify_identity_feature_parity.py": "a5ca2c72881d4760dee5b0d68ddc31f9e72fd0c18ac25fe3187984063facf30d",
+    "src/batteryswapai/competition_planner.py": "a56bfe549a3d6fcfe59217f7bd8a647533a4484fdbb26fe3ef8f1d6c84035a98",
+    "src/batteryswapai/identity_ensemble.py": "fa1f9aeaa89fba1bc5fc437c478c876544f2973960db18ef2c83f0042cc9df4a"
+  },
+  "training_source": {
+    "aft_landmarks": "rebuilt from official raw train visible prefixes",
+    "optional_lt_reference": {
+      "path": "artifacts/lt_fp_aft_official.rows.csv",
+      "raw_rebuild_exact": true,
+      "rows": 19890,
+      "sha256": "f8ce13b8b77453b01e81e1a788ab490dd0768eb7aec1162f3ef03492b0aaad11"
+    }
+  },
+  "validation_evidence_sha256": {
+    "artifacts/identity_ensemble_official.json": "6841c68160ef2decdd372bc98e1e4cfb33fab5eab83251133bc143f9ed5c113f",
+    "artifacts/identity_ensemble_official.rows.csv": "582673ce8e57707294175f26194a03b086f6021f19362568deae59e9285a2be8",
+    "artifacts/lt_fp_aft_official.json": "7446090f1a3e809a64526821176cc01f8d5302d93aa9c03431993e629b8c75a8",
+    "artifacts/lt_fp_aft_official.rows.csv": "f8ce13b8b77453b01e81e1a788ab490dd0768eb7aec1162f3ef03492b0aaad11",
+    "artifacts/similarity_eol_official.json": "07921417a05f81ad5c22d2b39ba241c4fe98a51ba0fb02583d2da489d824ff51",
+    "artifacts/similarity_eol_official.rows.csv": "18ee1f5ba39e10276c5a643841b9d3e8e4552aa8df53817a936d8b9de6585947",
+    "artifacts/temperature_physics_ensemble_official.json": "005dbcd8e5189c090b6b824b203b6ec6c012d1ceaea3b05bd04bd9970d9cc7eb",
+    "artifacts/temperature_physics_ensemble_official.rows.csv": "45959940bb44a7aacf98a20ff8bc5bbd7c4348aec1fa028f464eb260b066a9ca",
+    "artifacts/temperature_physics_globalbeta_diagnostic.json": "2352beb54b52a8b5f7767797c25c1e9282c5bab75f557d394d5c84419954d5e8"
+  }
+}

submission_artifacts/v05_planner.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:63d71091d7f46e8fb11798b7c2be936cc7e0022954824a4eb98c07dc1bf9b0b3
+size 15508289