Merge commit 'db87270972c9b243e3a1fccdf2c1fa96975dffc1' into HEAD

autoload/simulation_runtime.gd

@@ -37,6 +37,7 @@ const CleaningBridge = preload("res://scripts/environment/facility_cleaning_brid
 const CleaningPolicy = preload("res://scripts/environment/facility_cleaning_policy.gd")
 const UPKEEP_RUNTIME_SNAPSHOT_VERSION := 10
 const WeatherTimeline = preload("res://scripts/environment/weather_timeline.gd")
+const NaturalWeather = preload("res://scripts/environment/natural_weather_policy.gd")
 const STAIRS_RUNTIME_SNAPSHOT_VERSION := 9
 const TRANSPORT_RUNTIME_SNAPSHOT_VERSION := 8
 const SUPPLY_RUNTIME_SNAPSHOT_VERSION := 7
@@ -85,6 +86,7 @@ const RNG_STREAM_IDS: Array[StringName] = [
 	&"defense",
 	&"event",
 	&"loot",
+	&"weather",
 ]
 const DEFENSE_COMMAND_TYPES: Array[StringName] = [
 	&"create_defense_raid",
@@ -463,6 +465,8 @@ func initialize(clock: SimulationKernel, state: Variant, seed := DEFAULT_WORLD_S
 	if not report[&"valid"]:
 		_clock.set_paused(true)
 		definition_validation_failed.emit(report)
+	# A13: a new game opening at 06:00 draws its first day once streams exist.
+	_draw_natural_weather_if_due(_clock.absolute_minute)
 	_publish_snapshot(_clock.absolute_minute)
 	return report
 
@@ -1291,6 +1295,18 @@ func _restore_snapshot_internal(snapshot: Dictionary, recovery_mode: bool) -> bo
 			return false
 	elif runtime_data.has(&"weather") or not restored_weather.initialize(&"clear", restored_minute):
 		return false
+	# A13: the saved day's draw must be the draw rule's own result (SPEC section 5.3).
+	if not NaturalWeather.is_consistent_draw(restored_weather.get_today_draw()):
+		return false
+	# A13 rain holds must still describe a present guest's extended plan.
+	var rain_holds := restored_weather.get_rain_holds()
+	for held_key: Variant in rain_holds:
+		var held_guest := restored_guests.get_guest(StringName(held_key))
+		if held_guest == null or held_guest.planned_exit_at != int(rain_holds[held_key]["extended_to"]):
+			return false
+	var saved_weather: Variant = runtime_data.get(&"weather", null)
+	var weather_stream_required: bool = saved_weather is Dictionary \
+		and int(saved_weather.get("version", 0)) >= WeatherTimeline.VERSION
 	var restored_cleanliness := FacilityCleanliness.new()
 	if runtime_schema_version >= CLEANING_RUNTIME_SNAPSHOT_VERSION:
 		if not runtime_data.get(&"facility_cleanliness") is Dictionary or not restored_cleanliness.restore_snapshot(runtime_data[&"facility_cleanliness"]):
@@ -1323,6 +1339,12 @@ func _restore_snapshot_internal(snapshot: Dictionary, recovery_mode: bool) -> bo
 		if has_defense_snapshot:
 			return false
 		restored_streams[&"defense"] = DeterministicRng.from_root_seed(restored_world_seed, &"defense")
+	# A13 migration: saves before natural weather start the weather stream from
+	# the world seed, as defense did (SPEC section 5.2).
+	if not restored_streams.has(&"weather"):
+		if weather_stream_required:
+			return false
+		restored_streams[&"weather"] = DeterministicRng.from_root_seed(restored_world_seed, &"weather")
 	if runtime_schema_version >= DEFENSE_RUNTIME_SNAPSHOT_VERSION:
 		for required_stream_id: StringName in RNG_STREAM_IDS:
 			if not restored_streams.has(required_stream_id):
@@ -2951,6 +2973,8 @@ func _operations_arrival_boundary(
 			&"ok": not captured.is_empty(),
 			&"token": captured,
 			&"capacity_remaining": maxi(population_cap - guest_service.guest_count(), 0) if int(_state.get_resource(&"mana")) > 0 and weather.permits_new_arrivals() else 0,
+			# A13: rain halves the planned new arrivals of this boundary.
+			&"arrival_percent": NaturalWeather.arrival_percent(weather.get_kind()),
 		}
 	if phase == OperationsCoordinator.PHASE_VALIDATE:
 		return {
@@ -8784,6 +8808,7 @@ func _advance_guest_vitals(absolute_minute: int) -> void:
 			&"is_night": minute_of_day < 360 or minute_of_day >= 1_080,
 			&"intimacy_day": 3,
 			&"intimacy_night": 7,
+			&"mana_fog": weather.get_kind() == &"mana_fog",
 		}
 	})
 
@@ -9035,7 +9060,7 @@ func _advance_guest_ai_decisions(absolute_minute: int) -> void:
 			GuestRuntime.State.ENTERING:
 				guest_service.transition_guest(guest.guest_id, GuestRuntime.State.DECIDING, absolute_minute, &"ENTRY_COMPLETED")
 			GuestRuntime.State.DECIDING:
-				if guest.planned_exit_at <= absolute_minute:
+				if guest.planned_exit_at <= absolute_minute and not _hold_guest_for_rain(guest, absolute_minute):
 					guest_service.begin_leaving(guest.guest_id, absolute_minute, &"PLANNED_EXIT")
 					continue
 				guest.wallet_gold = economy_service.get_balance(_guest_wallet_account(guest.guest_id))
@@ -10993,13 +11018,14 @@ func _reservation_references_are_valid(
 ## HUD view of the A06 reserve: supply, consumption and storage per interval.
 func get_mana_reserve_report() -> Dictionary:
 	var demand := _mana_reserve_demand()
+	var generation := NaturalWeather.mana_yield(ManaReserveCycle.WORLD_TREE_GENERATION, weather.get_kind())
 	return {
 		&"amount": int(_state.get_resource(&"mana")),
 		&"capacity": ManaReserveCycle.CAPACITY,
-		&"generation": ManaReserveCycle.WORLD_TREE_GENERATION,
+		&"generation": generation,
 		&"interval_minutes": ManaReserveCycle.INTERVAL_MINUTES,
 		&"demand": demand,
-		&"net": ManaReserveCycle.WORLD_TREE_GENERATION - demand,
+		&"net": generation - demand,
 		&"last_flow": mana_reserve.get_last_flow(),
 	}
 
@@ -11032,8 +11058,10 @@ func _advance_mana(absolute_minute: int) -> void:
 		return
 	# A06: generation and upkeep demand settle before local distribution and the
 	# whole-tower gate, so the network and projection see the committed reserve.
+	# A13: mana fog raises the world tree yield of this boundary to x1.2 (floor).
 	var reserve_flow := mana_reserve.advance_to(
-		absolute_minute, int(_state.get_resource(&"mana")), _mana_reserve_demand()
+		absolute_minute, int(_state.get_resource(&"mana")), _mana_reserve_demand(),
+		NaturalWeather.mana_yield(ManaReserveCycle.WORLD_TREE_GENERATION, weather.get_kind())
 	)
 	if not bool(reserve_flow.get(&"ok", false)):
 		_latch_infrastructure_failure(
@@ -12392,6 +12420,8 @@ func _on_guest_despawned(guest_id: StringName, persistent_record: Dictionary) ->
 	elevators.cancel_actor(actor_id)
 	var path_removed := path_service.despawn_actor(actor_id)
 	_movement_credits.erase(actor_id)
+	# A13: a rain hold describes a present guest, so it leaves with the guest.
+	weather.release_rain_hold(guest_id)
 	_synchronize_operations_population()
 	var payload := persistent_record.duplicate(true)
 	payload[&"path_actor_id"] = actor_id
@@ -13572,10 +13602,66 @@ func get_staff_rest_report(staff_id: StringName) -> Dictionary:
 
 func _advance_weather(absolute_minute: int) -> void:
 	weather.advance_to(absolute_minute)
+	_draw_natural_weather_if_due(absolute_minute)
+	if not weather.get_rain_holds().is_empty():
+		var present := {}
+		for guest: GuestRuntime in guest_service.get_guests():
+			present[guest.guest_id] = true
+		weather.prune_rain_holds(present)
+
+
+## A13: one draw per day at 06:00 from the saved weather stream. The weather
+## boundary runs first, so the same minute's arrivals and closes see the result.
+func _draw_natural_weather_if_due(absolute_minute: int) -> void:
+	if not NaturalWeather.is_draw_minute(absolute_minute) or weather.get_minute() != absolute_minute:
+		return
+	var day := NaturalWeather.day_of(absolute_minute)
+	var stream := get_rng_stream(&"weather")
+	if day <= weather.get_last_draw_day() or stream == null:
+		return
+	var draw := NaturalWeather.draw(stream, day)
+	var applied := weather.apply_draw(draw)
+	var no_entities: Array[StringName] = []
+	_publish_actor_event(&"WEATHER_FORECAST_DRAWN", &"weather", no_entities, {
+		&"day": day,
+		&"kind": String(draw[&"kind"]),
+		&"roll": int(draw[&"roll"]),
+		&"slot": int(draw[&"slot"]),
+		&"start": int(draw[&"start"]),
+		&"end": int(draw[&"end"]),
+		&"applied": bool(applied.get(&"ok", false)),
+		&"code": String(applied.get(&"code", &"")),
+	})
+
+
+## A13: a guest due to leave while it rains stays until the rain ends, at most
+## 240 minutes after the original plan, once per guest (SPEC section 4.3).
+func _hold_guest_for_rain(guest: GuestRuntime, absolute_minute: int) -> bool:
+	if weather.get_kind() != &"rain" or not weather.get_rain_hold(guest.guest_id).is_empty():
+		return false
+	var original := guest.planned_exit_at
+	var extended := original + NaturalWeather.RAIN_HOLD_MAX_MINUTES
+	var rain_end := weather.rain_end_minute()
+	if rain_end >= 0:
+		extended = mini(extended, rain_end)
+	if extended <= absolute_minute or not weather.add_rain_hold(guest.guest_id, original, extended):
+		return false
+	guest.planned_exit_at = extended
+	return true
 
 
 func get_weather_report() -> Dictionary:
-	return {&"kind": weather.get_kind(), &"minute": weather.get_minute()}
+	var kind := weather.get_kind()
+	return {
+		&"kind": kind,
+		&"minute": weather.get_minute(),
+		&"since": weather.get_since(),
+		&"next_change": weather.next_change(),
+		&"today_draw": weather.get_today_draw(),
+		&"effect_text": NaturalWeather.effect_text(kind),
+		&"arrival_percent": NaturalWeather.arrival_percent(kind),
+		&"rain_holds": weather.get_rain_holds().size(),
+	}
 
 
 ## Read-only migration preview; applying dimensions remains a separate transaction.

docs/plans/original-completion-2026-10-02/execution/completion_marker_contracts.json

@@ -3958,6 +3958,39 @@
         "path": "docs/plans/original-completion-2026-10-02/execution/p05-02/SPEC.md",
         "scope": "new P05-02 F6 restart reader marker; native execution pending"
       }
+    },
+    {
+      "test": "tests/environment/test_p07_weather_runtime.gd",
+      "template": "PASS: <checks> checks",
+      "required": true,
+      "fixed_check_count_used": false,
+      "source_sha256_at_schema_audit": "e34b52ba3511f7391de1435c2f907997dd10235742ebc029831808af969c68e0",
+      "authority": {
+        "path": "docs/plans/original-completion-2026-10-02/execution/p07-01/SPEC.md",
+        "scope": "new P07-01 suite marker; native execution pending"
+      }
+    },
+    {
+      "test": "tests/environment/test_p07_weather_restart_1_write.gd",
+      "template": "PASS: <checks> checks",
+      "required": true,
+      "fixed_check_count_used": false,
+      "source_sha256_at_schema_audit": "d85e56dcf75535b19b1af615f8b75e010f4f3906a0e71afdf97102e1bfbffc65",
+      "authority": {
+        "path": "docs/plans/original-completion-2026-10-02/execution/p07-01/SPEC.md",
+        "scope": "new P07-01 F7 restart writer marker; native execution pending"
+      }
+    },
+    {
+      "test": "tests/environment/test_p07_weather_restart_2_read.gd",
+      "template": "PASS: <checks> checks",
+      "required": true,
+      "fixed_check_count_used": false,
+      "source_sha256_at_schema_audit": "e5c2376e9cb3197d6a0a8d99c9dea020cad2648328178949cd188d999e72071a",
+      "authority": {
+        "path": "docs/plans/original-completion-2026-10-02/execution/p07-01/SPEC.md",
+        "scope": "new P07-01 F7 restart reader marker; native execution pending"
+      }
     }
   ],
   "unknown_roster_suite_policy": "refuse, explicitly review its source/schema before accepting",

docs/plans/original-completion-2026-10-02/execution/p07-01/EXPECTATION_CHANGES.json

@@ -0,0 +1,46 @@
+{
+  "task": "P07-01",
+  "spec": "docs/plans/original-completion-2026-10-02/execution/p07-01/SPEC.md",
+  "rule": "SPEC F8: every changed expectation of an existing suite is listed with the value before and after and the reason. Only the natural-weather contract (A13, SPEC sections 4 and 5) causes these changes.",
+  "changes": [
+    {
+      "suite": "tests/environment/test_runtime_weather.gd",
+      "check": "old neutral save migration preserves other state",
+      "before": "runtime.create_snapshot() == original (the whole snapshot after migrating a version 10 save equals the original new game)",
+      "after": "the whole snapshot without systems.runtime.weather equals the original without it, and the migrated weather has last_draw_day -1 and no drawn day",
+      "reason": "A13: a new game opening at 06:00 draws its first day (SPEC 4.1), and a pre-weather save has no draw and must not draw for the past (SPEC 5.2). Only the weather section can differ; every other system stays byte-equal."
+    },
+    {
+      "suite": "tests/environment/test_runtime_weather.gd",
+      "check": "future weather clock rejects atomically",
+      "before": "the refused restore leaves runtime.create_snapshot() == original",
+      "after": "the refused restore leaves runtime.create_snapshot() == the migrated snapshot taken just before",
+      "reason": "The state before this refusal is the migrated state of the previous check, which now differs from the original only in the weather section; the check still proves the refusal is atomic."
+    },
+    {
+      "suite": "tests/environment/test_weather_timeline.gd",
+      "check": "malformed or contradictory state rejects atomically (unknown version case)",
+      "before": "{\"version\": 2} is an unknown version",
+      "after": "{\"version\": 3} is an unknown version",
+      "reason": "Version 2 is now the current weather snapshot (natural state and rain holds, SPEC 5.1); version 1 is read as the legacy format (SPEC 5.2)."
+    },
+    {
+      "suite": "tests/environment/test_weather_recovery.gd",
+      "check": "disk-restored recovery occurs once at scheduled minute",
+      "before": "after the recovery the pending weather list is empty",
+      "after": "after the recovery the pending weather list equals only the opening day's natural draw (rain 16:30-22:30 for seed 424242)",
+      "reason": "A13: the opening day's natural draw schedules its own start and return to clear (SPEC 4.1); the manually scheduled storm and recovery are still consumed exactly once."
+    }
+  ],
+  "unchanged_related_suites_passing_locally": [
+    "tests/mvp/test_runtime_operations_integration.gd",
+    "tests/s2/test_runtime_operations_cycle.gd",
+    "tests/s2/test_runtime_mana_reserve.gd",
+    "tests/s2/test_mana_reserve_cycle.gd",
+    "tests/s3/test_guest_service.gd",
+    "tests/s6/test_runtime_save_lifecycle.gd",
+    "tests/s6/test_runtime_snapshot_serialization.gd",
+    "tests/ui/test_main_dashboard.gd"
+  ],
+  "local_run_scope": "diagnostic direct runs on a scratch stage; the formal evidence is the submitted S native collection, the registered validation and the final full roster"
+}

docs/plans/original-completion-2026-10-02/execution/p07-01/IMPLEMENTATION_NOTES.md

@@ -0,0 +1,42 @@
+# P07-01 実装の記録（実 Opus の実装担当、2026-10-24）
+
+- 仕様: 同じフォルダの `SPEC.md`（固定の commit `4654789`、Runner の `spec_sha256` `2626d70b…7956`）。決定 A13（`PROVENANCE.json`）。
+- この記録は、仕様の §4・§5 を実装した場所と、実装担当として選んだ詳細、開示を書く。人の新しい承認は主張しない。
+
+## 1. 実装した場所
+
+- `scripts/environment/natural_weather_policy.gd`（新しい）: A13 の値（確率の境 60・85・95、続く時間 360・240・120 分、開始の 29 個の 30 分刻み、雨の来客 50%、雨の延長の上限 240 分、霧のマナ ×1.2・性欲 ×1.5）と、1日1回の抽選の手順。天候の仕組みは確率を持たない方針のままにするため分けた。
+- `scripts/environment/weather_timeline.gd`（VERSION 2）: 自然天候の状態（最後に抽選した日、その日の抽選）と雨の延長の記録を持つ。予定の規則（同じ分の別の種類・過去の時刻・上限）は変えない。その日の抽選の当てはめ（`apply_draw`）は、その日の 06:00 にだけ、1回だけ受け付ける。予定と重なれば `SCHEDULE_CONFLICT` で拒む。VERSION 1 の保存は、過去の抽選をさかのぼらない形で読む。
+- `autoload/simulation_runtime.gd`:
+  - 系列 `weather` を足した。
+  - 06:00 の抽選と出来事 `WEATHER_FORECAST_DRAWN`。新しいゲームが 06:00 に始まる時は、初期化の最後に開始の日を抽選する。
+  - 来客の受付の境界は、雨の割合（`arrival_percent`）を渡す。
+  - 帰りの判定は、雨の延長（`_hold_guest_for_rain`）を通す。
+  - マナの境界は、霧の産出を渡す。
+  - 客の生理の文脈に `mana_fog` を足した。
+  - 予報を含む `get_weather_report`。
+  - 復元では、延長の記録と客の予定を照合し、旧保存の系列を `world_seed` から作る。
+- `scripts/operations/operations_coordinator.gd`: 来客の計画を2段にした（行ごとの受け入れと持ち越しを決め、雨なら合計を floor(×50/100) まで後ろの行から減らし、減らした分は持ち越さない）。雨でない時の計画と客の ID は今と同じ。
+- `scripts/mana/mana_reserve_cycle.gd`: 境界の世界樹の産出を引数で受ける（既定 20、霧 24）。炉の受け入れの判定と `plan` も霧の量（24・120）を受ける。保存の照合は産出 20 と 24 だけを許す。上限 300（A06）は変えない。
+- `scripts/guest/guest_service.gd`: 文脈の真偽値 `mana_fog` を検査し、成人確認済みの客の正の性欲の増分 n を n + floor(n / 2)（= floor(1.5n)）にする。
+- `scenes/main/main.gd`: 上部の天候の名前の表示はそのままにし、隣に予報（`WeatherForecastLabel`、「次: 晴れ 12:00」「次: 予定なし」）を足した。天候の名前の案内（tooltip）に効果の案内を出す。
+
+## 2. 実装担当として選んだ詳細（SPEC §2 のとおり人の承認ではない）
+
+- 抽選の乱数: 0〜99 の整数を1つ、晴れ以外は開始の枠（0〜28）を1つ引く。
+- 日の数え方: 絶対分 ÷ 1440 の切り捨て。06:00 ちょうどは、まだ抽選していない日として数える（新しいゲームの開始の日のため）。旧保存の移行では、06:00 を過ぎていればその日は抽選済みとして数える。
+- 当てはめに失敗した抽選（手で置いた予定と同じ分になる時など）は、系列を進めたまま `applied: false` と理由を出来事に残し、その日の予定は変えない。次の日の 06:00 には抽選する。
+- 雨の延長は、帰りの判定（客が「決める」状態の時）で行う。延長の後の時刻には天候に関わらず今の規則で帰る。帰った客の記録は、天候の境界で片づける。
+- 霧の性欲は、その分の正の増分だけに掛ける（減少と、成人確認の無い客は変えない）。
+
+## 3. 開示
+
+- マナ炉の施設と産出の経路は今のゲームに無い（P06 の未決定）。霧の炉の ×1.2（120）は、マナの貯蔵の規則（受け入れの判定と `plan`）にだけ入り、通常の営業で観測できるのは世界樹の産出（20→24）だけ。
+- 今の客の種類で性欲が増えるのは、成人確認済みの客（`adventurer` など）に Runtime が渡す昼 3・夜 7 だけなので、霧の効果は昼 4・夜 10 として表れる。
+- 予報はその日の予定だけを出す（翌日は 06:00 に決まる）。UI は今の部品のままで、完成の見た目ではない。Windows の実機は後。
+- 性能の調整はしていない。横断条件の性能の回帰は、最終の S の全 roster の既存の性能の suite の結果で見る。
+- 新しい出来事 `WEATHER_FORECAST_DRAWN` が毎日 1 件増える。出来事の番号は、その分だけ後ろへずれる。
+
+## 4. 確かめ（局所。正式の証拠ではない）
+
+- 既存の天候の 3 本（期待値の変更は `EXPECTATION_CHANGES.json`）、関係する既存の 8 本、新しい suite（88 checks）、再開の書き手（28 checks）と読み手（47 checks、別の process）が、scratch の stage で全て合格した。正式の証拠は、提出の S の native の収集、登録の validation、最終の S の全 roster。

docs/plans/original-completion-2026-10-02/execution/p07-01/wx/EXPECTATION_CHANGES.json

@@ -0,0 +1,18 @@
+{
+  "task": "P07-01-WX",
+  "spec": "docs/plans/original-completion-2026-10-02/execution/p07-01/wx/SPEC.md",
+  "rule": "SPEC WX8: every changed expectation of an existing suite is listed with the value before and after and the reason. The four changes carried from the original task stay listed in ../EXPECTATION_CHANGES.json (byte for byte); this file lists the changes made in P07-01-WX.",
+  "changes": [
+    {
+      "suite": "tests/business/test_required_kitchen.gd",
+      "check": "whole typed loaded state unchanged except complete identity/saveID-bound IO1: legacy14-load (and the byte-identical-copy legacy migration control, which uses the same mapped expectation)",
+      "before": "_approved_runtime_migrations maps A06 (mana reserve fresh start), P14-03 (elevators v1 to v2) and P05-02 A12 (empty fund accounts) into the old checkpoint before the whole typed comparison",
+      "after": "it also maps the P07-01 A13 migration, each part checked against its own contract before it is mapped: the weather snapshot v1 to v2 gains only the natural state (last_draw_day counts every day whose 06:00 has passed, today empty) and empty rain_holds, with minute, kind, since and pending unchanged; rng_streams gains only the weather stream from the world seed, every other stream byte-identical",
+      "reason": "A13 (SPEC section 5.2) migrates a save from before natural weather on load. The genuine legacy14 fixture is such a save, so its loaded state differs from the old checkpoint exactly in these two fields. Found by the S c501360 full roster (phase 003, 163 checks, 2 failures) and the independent review finding 1."
+    }
+  ],
+  "found_by": {
+    "full_roster": "FULL_ROSTER_C501360_FAILURE_R01.json",
+    "review": "p07-01-wx-independent-review-c501360-r01/DESKTOP_RESULT.json (sha256 aea0cc4f2c00a6a093ca256154c62812a4d83749d075c6a4a9d36c1270026da7)"
+  }
+}

docs/plans/original-completion-2026-10-02/execution/p07-01/wx/IMPLEMENTATION_NOTES.md

@@ -0,0 +1,123 @@
+# P07-01-WX 実装の記録（実 Opus の実装担当、2026-10-24）
+
+- 仕様: 同じフォルダの `SPEC.md`（main `7ac2224` に固定。Runner の `spec_sha256` は `f1cd4262…fbd783`）。出典は `PROVENANCE.json`。
+- 原本への加算は 0。原 P07-01 の F1〜F8・炉 120・`AR.weather.fog_magic`・原 88 の分母は未達のまま。
+- 管理の記録は `artifacts/original-completion-2026-10-02/p07-01-wx-control-r01/` にある（git の外）。
+
+## 1. 持ち越し（SPEC §3）
+
+- 原 task の提出 S `dfacc83` の差分 24 ファイルを、`CARRY_OVER_DFACC83.patch`（SHA-256 `a880ea89…58f9`）で W に1回だけ当てた。
+- 当てた後、24 ファイル全部が manifest（`CARRY_OVER_DFACC83.json`）の bytes・SHA-256 と、S `dfacc83` の blob の両方に一致した（`CARRY_OVER_APPLY_R01.json`）。
+- 1回目は sandbox が W への書き込みを拒み、何も当たらなかった（W は clean のまま）。その記録を残してから当て直した。
+- 製品と試験は持ち越しのまま。変えたのは下の照合の道具だけ。
+
+## 2. 照合の直し（`tools/run_p07_weather_tests.py` の `verify`）
+
+- 原因:
+  - S `dfacc83` の native の収集では、14 本の suite が全て PASS した。その後の照合が「exact controlled Guard/proof environment」で止まった。
+  - 照合は `ordinary_cleanup_prepared` の suite の環境しか期待していなかった。`old_bounded_teardown` の suite（`tests/environment/test_p07_weather_runtime.gd` と `tests/ui/test_main_dashboard.gd`）には、共通の収集が `THE_TREE_AUDIO_TEARDOWN_PROOF_DIR` を渡しているのに、それを期待していなかった。
+- 直し（`VERIFY_OLD_BOUNDED_FIX_DRAFT_R01.md` のとおり）:
+  1. 段ごとの分類（ordinary・old_bounded）を、共通の収集（`tools/run_all_tests.py`）と同じ `phase_policy` から決める。
+  2. 期待する環境:
+     - ordinary の時は今のまま（`<段>-teardown/owned-audio` と `control.json`）。
+     - old_bounded の時は `<段>-teardown`（共通の収集と同じ）。
+     - どちらでもない時は無し。
+  3. old_bounded の suite は、共通の `teardown_gate` で証明を照合し直し、収集の記録（`old_bounded_proof`）と一致することを求める。
+  4. 照合を build の場所の写しにかけた時のために、`teardown_gate` が読む証明の path を読み替える。方法は ordinary の照合（`owners.read`）と同じ。照合の道具の中で作った module の写しだけを変え、共通の gate は変えていない。
+  5. ordinary の証明・old_bounded の証明・`<段>-teardown` のファイルが、分類された suite にだけあることを求める（import と parse の段を含む）。
+- 消した検査は無い。任意の環境は許さない。
+
+## 3. 訂正
+
+- 持ち越した `../IMPLEMENTATION_NOTES.md` §3 の「（P06 の未決定）」は誤り。
+- 炉の産出を通常の営業で示すのに要るものは、次の3つ（SPEC §6）:
+  - P13 の炉の施設
+  - D04 のユニットの消費
+  - A06 の別承認
+- 持ち越しのファイルは bytes のまま残し、訂正はここに書く。
+
+## 4. 確かめ（局所。正式の証拠ではない）
+
+- 直した判定を、旧 S の native の生の出力（読むだけ）に当てた（`VERIFIER_FIX_LOCAL_CHECK_R01.json`）。照合の全体は、受領が旧い道具の bytes を固定しているので、旧い出力にはかけられない。
+  - 16 段の環境と分類が記録と一致した。
+  - bounded の 2 本の証明が、元の場所と別の場所の写しの両方で記録と一致した。
+  - 直す前の期待は、元の失敗と同じ 000・011 の段で外れる。
+  - 読み替えの無い写しと、1 byte 変えた写しは拒まれる。
+- 直した道具の `--prepare-only` は exit 0（engine 0）。
+- 製品は S `dfacc83` と同じ bytes なので、engine の局所の再実行はしていない。
+- 正式の証拠は、新しい S の native の収集、登録の validation、全 roster、独立レビュー。旧 S の結果は流用しない。
+
+## 5. 開示
+
+- 炉 120 と `AR.weather.fog_magic` は受け入れない（SPEC §6）。
+- 他の開示は、持ち越した `../IMPLEMENTATION_NOTES.md` §2・§3（P06 の句を除く）と `../EXPECTATION_CHANGES.json` のとおり。
+- 出来事の一覧の表示: 毎日 06:00 の出来事 `WEATHER_FORECAST_DRAWN` には、`scripts/ui/event_log_dialog.gd` の `EVENT_NAMES` に日本語の名前が無い。そのため、プレイヤーが見る出来事の一覧では「未識別の記録」と出る。
+  - このファイルは契約の `allowed_paths` の外なので、この作業では直さない。
+  - 名前を足す作業は、別の単位として提案する。
+- 照合の ordinary の分岐: 狭い roster に `ordinary_cleanup_prepared` の suite が無い。そのため、照合の ordinary の分岐は、この validation では実地には動かない。
+  - 実地に動くのは、old_bounded（000・011）と、後片付けの無い段だけ。
+  - ordinary の分岐は、共通の収集と同じ環境と証明の照合を、コードの上で求めている。
+
+## 6. 直し 1（S `c5013601` の独立レビューと全 roster の後。repair 1）
+
+- 契機:
+  - S `c5013601` の全 roster が、段 003 の `tests/business/test_required_kitchen.gd` で止まった（`FULL_ROSTER_C501360_FAILURE_R01.json`）。
+  - 独立レビュー（`local_21295ab0`）は changes_requested で、high 1・medium 1・low 4。
+  - 管理の記録は `COMMANDER_REPAIR_PLAN_P07_01_WX_R01.md`。
+- 直したもの:
+  1. high: kitchen の試験の `_approved_runtime_migrations` に、A13 の移行を足した。2つの部分を、それぞれの契約で照合してから写す（`./EXPECTATION_CHANGES.json`）。
+     - 天候 v1→v2 では、`natural` と空の `rain_holds` だけが足される。
+     - `rng_streams` には、`world_seed` から作った `weather` だけが足される。
+  2. medium: 再開の台本に霧の場面を足した（`tests/helpers/p07_weather_restart_fixture.gd`、writer、reader）。
+     - seed 1592（0 日目 06:00〜10:00 がマナ霧）を使う。
+     - 06:58 と 09:58 に成人確認済みの客が着く。この世界には施設が無いので、客は数分で帰る。そのため、保存の時刻に館内に居るように着く時刻を選んだ。
+     - 保存は 419・420・421・599・600・601 分。
+     - 比べる状態に、客の `needs`（性欲）と、マナの貯蔵の snapshot を足した。
+     - writer は、straight の進行で次を確かめる。
+       - 成人の客の性欲が、霧の間は1分に4、霧の後は3上がる。
+       - 10 分ごとのマナの境界が、霧の間は 24、霧の後は 20。
+     - writer は、同じ process で各保存ファイルを読み直す。読んだ直後と1分後、最後の状態が、straight と bytes で一致することを確かめる。
+     - reader は、別の process で同じことを確かめる。
+     - これで、霧の産出と性欲の効果が二重に効かないことを示す。
+  3. low（試験の不足）:
+     - (a) 霧の間に帰りの時刻になった客は延びない。
+     - (b) 延びた客は、10:02 の決定（`_advance_guest_ai_decisions`）で PLANNED_EXIT で帰り始める。施設の無いこの世界では、客は延長の前に次の決定で施設が無いので帰る。そのため writer の雨の場面では、hold の記録の後も今の規則どおり（`NO_SUITABLE_FACILITY`）帰ることを、厳密に確かめた。元の「or has left since」は外した。
+     - (c) 上部の表示で、嵐とマナ霧の名前・予報・効果の案内を確かめる。霧の案内が炉を主張しないことも確かめる。
+  4. low（§5.3 の細部）: 製品の `scripts/environment/natural_weather_policy.gd` に `is_consistent_draw` を足した。
+     - 保存されたその日の抽選について、roll と種類、slot と開始、終わりと続く時間の対応を照合する。
+     - Runtime の復元（`autoload/simulation_runtime.gd`）は、矛盾した記録を拒否し、状態を保つ。
+     - 拒否の試験を3つ足した。
+  5. 開示: 上の §5 の2つ。
+- 比べる状態の `needs` は、名前を文字の順に並べる。読み直した客は needs のキーの順が違うことがあり、`StringName` の並べ替えは文字の順ではなく、process ごとに違うため。
+- 固定の値: 変えた3本（`test_p07_weather_runtime.gd`・writer・reader）の source の SHA を、`tools/regression/suite-policy.json` と `completion_marker_contracts.json` で更新した。
+- 確かめ（局所。正式の証拠ではない）: scratch の stage で、変えた suite と狭い roster の 12 本、kitchen を直接動かして合格した（`P07_01_WX_REPAIR1_LOCAL_CHECKS_R01.json`）。正式の証拠は、新しい S の native の収集、登録の validation、全 roster、独立レビュー。
+
+## 7. 直し 2（S `f99c881b` の最終の独立レビューの後。repair 2）
+
+- 契機:
+  - S `f99c881b` の最終の独立レビュー（`local_c4c1a8d6`）は changes_requested（medium 1・low 1）。前のレビューの high と medium は解消したと判定された。
+  - S `f99c881b` の全 roster は合格した（198 本・22,857 checks）。
+  - 管理の記録は `COMMANDER_REPAIR_PLAN_P07_01_WX_R02.md`。
+- 診断（scratch の stage）で分かったこと:
+  - 施設の無い試験の世界では、延びた客は 06:03 に帰り始め（`NO_SUITABLE_FACILITY`）、06:04 に居なくなる。必要（needs）の値や客の種類を変えても同じ。
+  - そのため、再開の保存には延長の記録が一度も乗っていなかった。
+  - 製品の不具合（持ち越したコード）: 延長の記録は、次の tick の天候の境界まで片づかなかった。
+    - そのため、客が居なくなった分の保存は、保存は成功するが読み込めなかった（`RESTORE_FAILED`）。
+    - 原因は、復元の照合「延長は館内の客の予定と一致すること」。
+- 直したもの:
+  1. 製品: 客が居なくなった時（`autoload/simulation_runtime.gd` の `_on_guest_despawned`）に、その客の延長の記録をすぐ片づける。
+     - `scripts/environment/weather_timeline.gd` に `release_rain_hold` を足した。
+     - 天候の境界での片づけは今のまま残した。
+  2. medium（WX7）: 再開の台本の雨の場面に、2つの保存を足した。
+     - 363 分: 延びた客が帰る途中で館内に居て、延長の記録がある。
+     - 364 分: 客が居なくなった直後で、延長の記録が無い。上の不具合の回帰の確かめ。
+     - writer は、雨の全ての保存を同じ process で読み直す。読んだ直後・1分後・最後の状態が、straight と bytes で一致することを確かめる。
+     - reader は、別の process で同じことを確かめる。
+     - 363 分の保存では、延長の記録が1つで、`planned_exit_at` が 602 であることを厳密に確かめる。1分後の一致で、二度目の延長が無いことを示す。
+     - 500 分の確かめから、誤っていた「with the hold of a present guest」を外した。
+  3. 回帰: `test_p07_weather_runtime.gd` で、通常の進行で延びた客が帰った分に、延長の記録が片づいていて、その分の snapshot が復元できることを確かめる。
+- 開示（U1）: 施設の無い試験の世界では、延びた客は延長の時刻より前に、施設が無いので帰る。
+  - そのため、通常の時刻の進行で延長の時刻（10:02）に着いて帰る場面は、この試験では作れない。施設を建てて客が使う場面が要る。
+  - 延長の時刻の帰りは、決定の処理を延長の時刻でじかに呼んで確かめている（`_test_rain_hold_exit`）。延長の時刻に、二度目の延長をせず、PLANNED_EXIT で帰り始める。
+- 固定の値: 変えた3本の source の SHA を、`tools/regression/suite-policy.json` と `completion_marker_contracts.json` で更新した。
+- 確かめ（局所。正式の証拠ではない）: scratch の stage で、狭い roster の 12 本・再開の2段・kitchen を直接動かして合格した（`P07_01_WX_REPAIR2_LOCAL_CHECKS_R01.json`）。

scenes/main/main.gd

@@ -136,6 +136,7 @@ var rank_button: Button
 var rank_dialog: ConfirmationDialog
 var event_log_dialog: AcceptDialog
 var weather_label: Label
+var weather_forecast_label: Label
 var guest_count_label: Button
 var dimension_migration_dialog: ConfirmationDialog
 var _dimension_migration_digest := ""
@@ -467,6 +468,11 @@ func _create_top_bar() -> Control:
 	weather_label.tooltip_text = "嵐の間は新規入館が停止します。現在のお客様は館内に残ります。"
 	weather_label.mouse_filter = Control.MOUSE_FILTER_STOP
 	row.add_child(weather_label)
+	# A13 forecast: the next change of today's weather (kind and time).
+	weather_forecast_label = _hud_value_label("", 72)
+	weather_forecast_label.name = "WeatherForecastLabel"
+	weather_forecast_label.mouse_filter = Control.MOUSE_FILTER_STOP
+	row.add_child(weather_forecast_label)
 
 	guest_count_label = Button.new()
 	guest_count_label.text = "来客  0人"
@@ -1550,6 +1556,16 @@ func _refresh_dashboard() -> void:
 		var weather_report: Dictionary = _runtime.get_weather_report()
 		var weather_names := {&"clear": "晴れ", &"rain": "雨", &"storm": "嵐", &"mana_fog": "マナ霧"}
 		weather_label.text = weather_names.get(weather_report.get(&"kind", &""), "天候 —")
+		var next_change: Dictionary = weather_report.get(&"next_change", {})
+		var forecast := "次: 予定なし"
+		if not next_change.is_empty():
+			var change_minute := posmod(int(next_change.get(&"minute", 0)), 1_440)
+			forecast = "次: %s %02d:%02d" % [weather_names.get(StringName(next_change.get(&"kind", &"")), "天候 —"), change_minute / 60, change_minute % 60]
+		var effect := String(weather_report.get(&"effect_text", ""))
+		weather_label.tooltip_text = "%s\n毎朝6時にその日の天候が決まります。" % effect if not effect.is_empty() else weather_label.tooltip_text
+		if weather_forecast_label != null:
+			weather_forecast_label.text = forecast
+			weather_forecast_label.tooltip_text = "%s\n%s" % [forecast, effect]
 	var guests := _call_array(_service(&"guest_service"), &"get_guests")
 	var queued_guests := 0
 	var served_guests := 0

scripts/environment/natural_weather_policy.gd

@@ -0,0 +1,92 @@
+extends RefCounted
+
+## Approved initial weather values A13 (P07-01 SPEC sections 2 and 4). The
+## timeline stays a pure state model; this file owns the draw and the effects.
+const DAY_MINUTES := 1440
+const DRAW_MINUTE_OF_DAY := 360
+const FIRST_START_MINUTE_OF_DAY := 360
+const START_SLOT_MINUTES := 30
+const START_SLOTS := 29
+## Rolls 0..99: clear 0-59, rain 60-84, mana fog 85-94, storm 95-99.
+const CLEAR_BELOW := 60
+const RAIN_BELOW := 85
+const FOG_BELOW := 95
+const DURATION_MINUTES := {&"rain": 360, &"mana_fog": 240, &"storm": 120}
+const RAIN_ARRIVAL_PERCENT := 50
+const RAIN_HOLD_MAX_MINUTES := 240
+const FOG_MANA_NUMERATOR := 12
+const FOG_MANA_DENOMINATOR := 10
+const FOG_INTIMACY_NUMERATOR := 3
+const FOG_INTIMACY_DENOMINATOR := 2
+
+static func is_draw_minute(absolute_minute: int) -> bool:
+	return absolute_minute >= 0 and posmod(absolute_minute, DAY_MINUTES) == DRAW_MINUTE_OF_DAY
+
+static func day_of(absolute_minute: int) -> int:
+	return int(floor(float(absolute_minute) / DAY_MINUTES)) if absolute_minute >= 0 else -1
+
+## One draw per day from the saved weather stream. A clear day consumes one
+## roll; other days also consume one start-slot roll.
+static func draw(rng: DeterministicRng, day: int) -> Dictionary:
+	var roll := rng.randi_range(0, 99)
+	var kind: StringName = &"clear"
+	if roll >= FOG_BELOW:
+		kind = &"storm"
+	elif roll >= RAIN_BELOW:
+		kind = &"mana_fog"
+	elif roll >= CLEAR_BELOW:
+		kind = &"rain"
+	if kind == &"clear":
+		return {&"day": day, &"kind": kind, &"roll": roll, &"slot": -1, &"start": -1, &"end": -1}
+	var slot := rng.randi_range(0, START_SLOTS - 1)
+	var start := day * DAY_MINUTES + FIRST_START_MINUTE_OF_DAY + slot * START_SLOT_MINUTES
+	return {&"day": day, &"kind": kind, &"roll": roll, &"slot": slot,
+		&"start": start, &"end": start + int(DURATION_MINUTES[kind])}
+
+## A saved day's draw must be this rule's own result (SPEC section 5.3): the roll
+## picks the kind, a clear day has no slot, and any other day starts on its slot
+## and lasts its kind's duration. An empty draw (no day drawn yet) is consistent.
+static func is_consistent_draw(draw: Dictionary) -> bool:
+	if draw.is_empty():
+		return true
+	var roll := int(draw[&"roll"])
+	var kind := StringName(draw[&"kind"])
+	var expected: StringName = &"clear"
+	if roll >= FOG_BELOW:
+		expected = &"storm"
+	elif roll >= RAIN_BELOW:
+		expected = &"mana_fog"
+	elif roll >= CLEAR_BELOW:
+		expected = &"rain"
+	if kind != expected:
+		return false
+	if kind == &"clear":
+		return int(draw[&"slot"]) == -1 and int(draw[&"start"]) == -1 and int(draw[&"end"]) == -1
+	var slot := int(draw[&"slot"])
+	var start := int(draw[&"day"]) * DAY_MINUTES + FIRST_START_MINUTE_OF_DAY + slot * START_SLOT_MINUTES
+	return slot >= 0 and slot < START_SLOTS and int(draw[&"start"]) == start \
+		and int(draw[&"end"]) == start + int(DURATION_MINUTES[kind])
+
+static func arrival_percent(kind: StringName) -> int:
+	return RAIN_ARRIVAL_PERCENT if kind == &"rain" else 100
+
+static func mana_yield(base_amount: int, kind: StringName) -> int:
+	if kind != &"mana_fog":
+		return base_amount
+	return int(floor(float(base_amount * FOG_MANA_NUMERATOR) / FOG_MANA_DENOMINATOR))
+
+static func fog_intimacy_increase(increase: int) -> int:
+	if increase <= 0:
+		return increase
+	return int(floor(float(increase * FOG_INTIMACY_NUMERATOR) / FOG_INTIMACY_DENOMINATOR))
+
+## Japanese HUD guidance for the current kind (SPEC section 4.6).
+static func effect_text(kind: StringName) -> String:
+	match kind:
+		&"rain":
+			return "雨: 新規来客が半分になり、帰る予定の客は雨が止むまで（最大4時間）残ります。"
+		&"storm":
+			return "嵐: 新規来客はありません。館内の客は残ります。"
+		&"mana_fog":
+			return "マナ霧: 世界樹のマナ産出が1.2倍、成人確認済みの客の性欲の増え方が1.5倍になります。"
+	return "晴れ: 天候の影響はありません。"

scripts/environment/natural_weather_policy.gd.uid

@@ -0,0 +1 @@
+uid://bkr55x5to4cgi

scripts/environment/weather_timeline.gd

@@ -2,14 +2,25 @@ extends RefCounted
 
 ## Weather state and scheduled transitions. The caller owns generation policy;
 ## this model invents neither probabilities nor rain/fog balance multipliers.
-const VERSION := 1
+## Version 2 also keeps the natural-weather bookkeeping (last daily draw, the
+## current day's draw) and the once-per-guest rain holds; version 1 snapshots
+## migrate with no draw for the past and no holds (P07-01 SPEC section 5).
+const VERSION := 2
+const LEGACY_VERSION := 1
 const KINDS := [&"clear", &"rain", &"storm", &"mana_fog"]
 const MAX_MINUTE := 2147483647
 const MAX_PENDING := 4096
+const MAX_RAIN_HOLDS := 100000
+const DAY_MINUTES := 1440
+const DRAW_MINUTE_OF_DAY := 360
+const RAIN_HOLD_MAX_MINUTES := 240
 var _minute := -1
 var _kind: StringName = &""
 var _since := -1
 var _pending: Array[Dictionary] = []
+var _last_draw_day := -1
+var _today_draw: Dictionary = {}
+var _rain_holds: Dictionary = {}
 
 func initialize(kind: Variant, minute: Variant) -> bool:
 	if _minute >= 0 or not _valid_kind(kind) or not _valid_minute(minute):
@@ -17,6 +28,7 @@ func initialize(kind: Variant, minute: Variant) -> bool:
 	_minute = minute
 	_since = minute
 	_kind = StringName(kind)
+	_last_draw_day = _days_before(minute)
 	return true
 
 func get_kind() -> StringName:
@@ -25,6 +37,9 @@ func get_kind() -> StringName:
 func get_minute() -> int:
 	return _minute
 
+func get_since() -> int:
+	return _since
+
 func permits_new_arrivals() -> bool:
 	return _minute >= 0 and _kind != &"storm"
 
@@ -55,13 +70,100 @@ func advance_to(minute: Variant) -> Dictionary:
 	_minute = minute
 	return {&"ok": true, &"replayed": replayed, &"changes": changes}
 
+## Natural weather (A13): the caller draws once per day at 06:00 and applies
+## the result here. A start at the current minute switches now; later starts
+## and the return to clear use the ordinary schedule rules, applied together.
+func get_last_draw_day() -> int:
+	return _last_draw_day
+
+func get_today_draw() -> Dictionary:
+	return _today_draw.duplicate(true)
+
+func apply_draw(draw: Dictionary) -> Dictionary:
+	if _minute < 0 or not _valid_draw(draw):
+		return {&"ok": false, &"code": &"INVALID_DRAW"}
+	var day: int = draw[&"day"]
+	if day <= _last_draw_day or _minute != day * DAY_MINUTES + DRAW_MINUTE_OF_DAY:
+		return {&"ok": false, &"code": &"DRAW_NOT_DUE"}
+	var kind := StringName(draw[&"kind"])
+	var start: int = draw[&"start"]
+	var end: int = draw[&"end"]
+	var changes: Array[Dictionary] = []
+	if kind != &"clear":
+		for row: Dictionary in _pending:
+			if int(row[&"minute"]) == start or int(row[&"minute"]) == end:
+				return {&"ok": false, &"code": &"SCHEDULE_CONFLICT"}
+		if _pending.size() + 2 > MAX_PENDING:
+			return {&"ok": false, &"code": &"SCHEDULE_FULL"}
+		if start == _minute:
+			if kind != _kind:
+				changes.append({&"from": _kind, &"to": kind, &"minute": start})
+				_kind = kind
+				_since = start
+		else:
+			_pending.append({&"kind": kind, &"minute": start})
+		_pending.append({&"kind": &"clear", &"minute": end})
+		_pending.sort_custom(func(a: Dictionary, b: Dictionary) -> bool: return a[&"minute"] < b[&"minute"])
+	_last_draw_day = day
+	_today_draw = _copy_draw(draw)
+	return {&"ok": true, &"changes": changes}
+
+## The next scheduled change away from the current kind, for the forecast.
+func next_change() -> Dictionary:
+	for row: Dictionary in _pending:
+		if row[&"kind"] != _kind:
+			return {&"kind": row[&"kind"], &"minute": row[&"minute"]}
+	return {}
+
+## When the current rain ends (-1 when it is not raining or no end is known).
+func rain_end_minute() -> int:
+	if _kind != &"rain":
+		return -1
+	for row: Dictionary in _pending:
+		if row[&"kind"] != &"rain":
+			return int(row[&"minute"])
+	return -1
+
+func get_rain_hold(guest_id: StringName) -> Dictionary:
+	var row: Variant = _rain_holds.get(String(guest_id), null)
+	return row.duplicate(true) if row is Dictionary else {}
+
+func get_rain_holds() -> Dictionary:
+	return _rain_holds.duplicate(true)
+
+func add_rain_hold(guest_id: StringName, original_exit: int, extended_to: int) -> bool:
+	var key := String(guest_id)
+	if key.is_empty() or _rain_holds.has(key) or _rain_holds.size() >= MAX_RAIN_HOLDS \
+			or not _valid_hold({"original_exit": original_exit, "extended_to": extended_to}):
+		return false
+	_rain_holds[key] = {"original_exit": original_exit, "extended_to": extended_to}
+	return true
+
+## Holds of guests that have left are history; the caller passes who remains.
+func prune_rain_holds(present_guest_ids: Dictionary) -> void:
+	for key: String in _rain_holds.keys():
+		if not present_guest_ids.has(StringName(key)):
+			_rain_holds.erase(key)
+
+## The hold of a guest that has just left; a save in that same minute then
+## holds only present guests' holds (P07-01 SPEC section 5).
+func release_rain_hold(guest_id: StringName) -> void:
+	_rain_holds.erase(String(guest_id))
+
 func create_snapshot() -> Dictionary:
 	return {&"version": VERSION, &"minute": _minute, &"kind": _kind,
-		&"since": _since, &"pending": _pending.duplicate(true)}
+		&"since": _since, &"pending": _pending.duplicate(true),
+		&"natural": {&"last_draw_day": _last_draw_day, &"today": _today_draw.duplicate(true)},
+		&"rain_holds": _rain_holds.duplicate(true)}
 
 func restore_snapshot(source: Dictionary) -> bool:
-	if not _keys(source, ["version", "minute", "kind", "since", "pending"]) \
+	var version: Variant = source.get("version", source.get(&"version", null))
-		or typeof(source["version"]) != TYPE_INT or source["version"] != VERSION \
+	if typeof(version) != TYPE_INT or version not in [LEGACY_VERSION, VERSION]:
+		return false
+	var expected := ["version", "minute", "kind", "since", "pending"]
+	if version == VERSION:
+		expected = expected + ["natural", "rain_holds"]
+	if not _keys(source, expected) \
 		or not _valid_minute(source["minute"]) or not _valid_minute(source["since"]) \
 		or source["since"] > source["minute"] or not _valid_kind(source["kind"]) \
 		or not source["pending"] is Array or source["pending"].size() > MAX_PENDING:
@@ -75,12 +177,75 @@ func restore_snapshot(source: Dictionary) -> bool:
 			return false
 		previous = value["minute"]
 		pending.append({&"kind": StringName(value["kind"]), &"minute": value["minute"]})
+	var last_draw_day := _days_before(source["minute"])
+	var today: Dictionary = {}
+	var holds: Dictionary = {}
+	if version == VERSION:
+		var natural: Variant = source["natural"]
+		if not natural is Dictionary or not _keys(natural, ["last_draw_day", "today"]) \
+			or typeof(natural["last_draw_day"]) != TYPE_INT or natural["last_draw_day"] < -1 \
+			or natural["last_draw_day"] > _day_of(source["minute"]) or not natural["today"] is Dictionary:
+			return false
+		last_draw_day = natural["last_draw_day"]
+		if not natural["today"].is_empty():
+			if not _valid_draw(natural["today"]) or int(natural["today"]["day"]) != last_draw_day:
+				return false
+			today = _copy_draw(natural["today"])
+		var raw_holds: Variant = source["rain_holds"]
+		if not raw_holds is Dictionary or raw_holds.size() > MAX_RAIN_HOLDS:
+			return false
+		for key: Variant in raw_holds:
+			if typeof(key) not in [TYPE_STRING, TYPE_STRING_NAME] or String(key).is_empty() \
+				or not raw_holds[key] is Dictionary or not _keys(raw_holds[key], ["original_exit", "extended_to"]) \
+				or not _valid_hold(raw_holds[key]):
+				return false
+			holds[String(key)] = {"original_exit": int(raw_holds[key]["original_exit"]),
+				"extended_to": int(raw_holds[key]["extended_to"])}
 	_minute = source["minute"]
 	_kind = StringName(source["kind"])
 	_since = source["since"]
 	_pending = pending
+	_last_draw_day = last_draw_day
+	_today_draw = today
+	_rain_holds = holds
 	return true
 
+## A day whose 06:00 is before the minute counts as drawn, so a new or migrated
+## timeline never draws for the past (SPEC section 5.2). At exactly 06:00 the
+## day is still due, which lets a new game draw its opening day.
+static func _days_before(minute: int) -> int:
+	var day := _day_of(minute)
+	return day if posmod(minute, DAY_MINUTES) > DRAW_MINUTE_OF_DAY else day - 1
+
+static func _day_of(minute: int) -> int:
+	return int(floor(float(minute) / DAY_MINUTES))
+
+static func _valid_draw(draw: Variant) -> bool:
+	if not draw is Dictionary or not _keys(draw, ["day", "kind", "roll", "slot", "start", "end"]):
+		return false
+	for key: String in ["day", "roll", "slot", "start", "end"]:
+		if typeof(draw[key]) != TYPE_INT:
+			return false
+	if not _valid_kind(draw["kind"]) or draw["day"] < 0 or draw["roll"] < 0 or draw["roll"] > 99:
+		return false
+	if StringName(draw["kind"]) == &"clear":
+		return draw["slot"] == -1 and draw["start"] == -1 and draw["end"] == -1
+	var day_start: int = draw["day"] * DAY_MINUTES + DRAW_MINUTE_OF_DAY
+	return draw["slot"] >= 0 and draw["start"] >= day_start and draw["start"] <= day_start + 14 * 60 \
+		and draw["end"] > draw["start"] and draw["end"] < day_start + DAY_MINUTES
+
+static func _copy_draw(draw: Dictionary) -> Dictionary:
+	var result := {}
+	for key: String in ["day", "kind", "roll", "slot", "start", "end"]:
+		result[key] = draw[key] if key != "kind" else String(draw[key])
+	return result
+
+static func _valid_hold(row: Dictionary) -> bool:
+	var original: Variant = row.get("original_exit", null)
+	var extended: Variant = row.get("extended_to", null)
+	return typeof(original) == TYPE_INT and typeof(extended) == TYPE_INT and original >= 0 \
+		and extended > original and extended <= original + RAIN_HOLD_MAX_MINUTES
+
 static func _valid_kind(value: Variant) -> bool:
 	return typeof(value) in [TYPE_STRING, TYPE_STRING_NAME] and StringName(value) in KINDS
 

scripts/guest/guest_service.gd

@@ -365,6 +365,10 @@ func _update_needs_runtime(
 		delta_medical += int(normalized_effects.get(&"medical", 0))
 		delta_leisure += int(normalized_effects.get(&"leisure", 0))
 		delta_intimacy += int(normalized_effects.get(&"intimacy", 0))
+	## A13: mana fog raises an adult-verified guest's positive intimacy increase
+	## to floor(x1.5) = n + floor(n / 2); decreases and other guests are unchanged.
+	if definition.adult_verified and delta_intimacy > 0 and bool(_value(context, &"mana_fog", false)):
+		delta_intimacy += delta_intimacy >> 1
 
 	var after_hunger := clampi(before_hunger + delta_hunger, 0, 100)
 	var after_sleep := clampi(before_sleep + delta_sleep, 0, 100)
@@ -1157,7 +1161,7 @@ func _need_context_error(context: Dictionary) -> String:
 		var raw_value: Variant = _value(context, field_id, null)
 		if not raw_value is int or int(raw_value) < 0 or int(raw_value) > 100:
 			return "%s must be an integer from 0 through 100." % field_id
-	for field_id: StringName in [&"is_night", &"work_like_activity", &"unstimulated"]:
+	for field_id: StringName in [&"is_night", &"work_like_activity", &"unstimulated", &"mana_fog"]:
 		if _has_value(context, field_id) and not _value(context, field_id, null) is bool:
 			return "%s must be boolean." % field_id
 	if _has_value(context, &"need_effects"):

scripts/mana/mana_reserve_cycle.gd

@@ -11,6 +11,10 @@ const CAPACITY := 300
 const WORLD_TREE_GENERATION := 20
 const INTERVAL_MINUTES := 10
 const FURNACE_YIELD := 100
+## A13 mana fog: world tree and furnace yields x1.2 (floor) at fog boundaries.
+const FOG_WORLD_TREE_GENERATION := 24
+const FOG_FURNACE_YIELD := 120
+const GENERATIONS: Array[int] = [WORLD_TREE_GENERATION, FOG_WORLD_TREE_GENERATION]
 const LIMIT := 1000000000
 const FLOW_KEYS: Array[String] = [
 	"from_minute", "to_minute", "before", "generation", "furnace", "demand",
@@ -35,12 +39,14 @@ func get_last_flow() -> Dictionary:
 ## Processes every boundary in (last boundary, minute]. Boundaries already
 ## processed are no-ops, so per-minute callers and same-minute retries are safe.
 ## Mana may rise between boundaries (event refunds, commands); anything above
-## capacity is discarded and recorded as overflow at the next boundary.
+## capacity is discarded and recorded as overflow at the next boundary. The
-func advance_to(minute: Variant, before: Variant, demand: Variant) -> Dictionary:
+## caller passes the world tree yield of the boundary (A13 fog: 24, else 20).
+func advance_to(minute: Variant, before: Variant, demand: Variant, generation: Variant = WORLD_TREE_GENERATION) -> Dictionary:
 	if _minute < 0:
 		return _failure(&"NOT_STARTED")
 	if typeof(minute) != TYPE_INT or not _amount(before) \
-			or typeof(demand) != TYPE_INT or demand < 0 or demand > LIMIT or minute < _minute:
+			or typeof(demand) != TYPE_INT or demand < 0 or demand > LIMIT or minute < _minute \
+			or typeof(generation) != TYPE_INT or generation not in GENERATIONS:
 		return _failure(&"INVALID_FLOW")
 	var boundary: int = minute - minute % INTERVAL_MINUTES
 	if boundary <= _minute:
@@ -49,7 +55,7 @@ func advance_to(minute: Variant, before: Variant, demand: Variant) -> Dictionary
 	var flow := {}
 	var count := 0
 	for to_minute: int in range(_minute + INTERVAL_MINUTES, boundary + 1, INTERVAL_MINUTES):
-		flow = plan(amount, demand, 0, to_minute - INTERVAL_MINUTES, to_minute)
+		flow = plan(amount, demand, 0, to_minute - INTERVAL_MINUTES, to_minute, generation)
 		amount = flow[&"after"]
 		count += 1
 	_minute = boundary
@@ -57,17 +63,18 @@ func advance_to(minute: Variant, before: Variant, demand: Variant) -> Dictionary
 	return {&"ok": true, &"processed": true, &"boundaries": count, &"after": amount, &"flow": flow.duplicate(true)}
 
 ## Furnace offers are judged after natural generation and upkeep demand are
-## paid: base_after = min(C, max(0, B + G - D)); accept only with 100 free.
+## paid: base_after = min(C, max(0, B + G - D)); accept only with the yield free
-static func furnace_offer_accepted(before: int, demand: int) -> bool:
+## (100, or 120 at an A13 fog boundary where G is 24).
-	var base_after := mini(CAPACITY, maxi(0, before + WORLD_TREE_GENERATION - demand))
+static func furnace_offer_accepted(before: int, demand: int, generation: int = WORLD_TREE_GENERATION, furnace_yield: int = FURNACE_YIELD) -> bool:
-	return CAPACITY - base_after >= FURNACE_YIELD
+	var base_after := mini(CAPACITY, maxi(0, before + generation - demand))
+	return CAPACITY - base_after >= furnace_yield
 
-static func plan(before: int, demand: int, furnace: int, start: int, end: int) -> Dictionary:
+static func plan(before: int, demand: int, furnace: int, start: int, end: int, generation: int = WORLD_TREE_GENERATION) -> Dictionary:
-	var available := before + WORLD_TREE_GENERATION + furnace
+	var available := before + generation + furnace
 	var consumed := mini(available, demand)
 	var remaining := available - consumed
 	return {&"from_minute": start, &"to_minute": end, &"before": before,
-		&"generation": WORLD_TREE_GENERATION, &"furnace": furnace, &"demand": demand,
+		&"generation": generation, &"furnace": furnace, &"demand": demand,
 		&"consumed": consumed, &"shortage": demand - consumed,
 		&"overflow": maxi(remaining - CAPACITY, 0), &"after": mini(remaining, CAPACITY)}
 
@@ -105,10 +112,10 @@ func restore_snapshot(source: Variant) -> bool:
 			if not _amount(flow[key]):
 				return false
 		if flow["to_minute"] != source["minute"] \
-				or flow["generation"] != WORLD_TREE_GENERATION \
+				or flow["generation"] not in GENERATIONS \
 				or flow["from_minute"] + INTERVAL_MINUTES != flow["to_minute"]:
 			return false
-		var expected := plan(flow["before"], flow["demand"], flow["furnace"], flow["from_minute"], flow["to_minute"])
+		var expected := plan(flow["before"], flow["demand"], flow["furnace"], flow["from_minute"], flow["to_minute"], flow["generation"])
 		if not _same_flow(expected, flow):
 			return false
 	_minute = source["minute"]

scripts/operations/operations_coordinator.gd

@@ -1013,6 +1013,15 @@ func _process_arrival_boundary(minute: int) -> CommandResult:
 			&"ARRIVAL_PLAN", minute, PHASE_CAPTURE, &"ARRIVAL_CAPTURE_INVALID"
 		)
 	var external_capacity := int(capacity_value)
+	# A13: the arrival boundary reports the weather share of planned arrivals
+	# (rain 50, otherwise 100). Absent means 100 for callers without weather.
+	var percent_value: Variant = capture.get(&"arrival_percent", 100)
+	if not _is_integral_value(percent_value) or int(percent_value) < 0 or int(percent_value) > 100:
+		return _failed_boundary_after_capture(
+			_arrival_boundary, capture_payload, token,
+			&"ARRIVAL_PLAN", minute, PHASE_CAPTURE, &"ARRIVAL_CAPTURE_INVALID"
+		)
+	var arrival_percent := int(percent_value)
 	var remaining := mini(
 		mini(local_capacity, external_capacity),
 		int(_config[&"max_arrivals_per_interval"])
@@ -1022,6 +1031,8 @@ func _process_arrival_boundary(minute: int) -> CommandResult:
 	var plans: Array[Dictionary] = []
 	var total_count := 0
 	var capped_rows: Array[Dictionary] = []
+	var accepted_by_row: Array[int] = []
+	var planned_total := 0
 	for row: Dictionary in intent_rows:
 		var accepted := mini(int(row[&"desired_count"]), remaining)
 		var key: String = row[&"key"]
@@ -1034,6 +1045,21 @@ func _process_arrival_boundary(minute: int) -> CommandResult:
 				&"guest_class": String(row[&"guest_class"]),
 				&"discarded_numerator": retained - capped_retained,
 			})
+		accepted_by_row.append(accepted)
+		planned_total += accepted
+		remaining -= accepted
+	# Rain keeps floor(planned * percent / 100) arrivals; the dropped arrivals
+	# are lost to the weather and are not carried to the next boundary.
+	var dropped := planned_total - planned_total * arrival_percent / 100
+	var drop_index := accepted_by_row.size() - 1
+	while dropped > 0 and drop_index >= 0:
+		var cut := mini(dropped, accepted_by_row[drop_index])
+		accepted_by_row[drop_index] -= cut
+		dropped -= cut
+		drop_index -= 1
+	for row_index in intent_rows.size():
+		var row: Dictionary = intent_rows[row_index]
+		var accepted := accepted_by_row[row_index]
 		if accepted <= 0:
 			continue
 		if plan_sequence > MAX_SEQUENCE_VALUE \
@@ -1058,7 +1084,6 @@ func _process_arrival_boundary(minute: int) -> CommandResult:
 		})
 		plan_sequence += 1
 		total_count += accepted
-		remaining -= accepted
 
 	var payload := capture_payload.duplicate(true)
 	payload[&"plans"] = plans

tests/business/test_required_kitchen.gd

@@ -276,8 +276,9 @@ func _legacy_controls(writer: Dictionary, reader: Dictionary) -> void:
 
 ## Approved later save migrations applied when an older save is loaded, each
 ## checked against its own contract and then mapped into `expected` in place:
-## A06 starts a fresh finite Mana reserve at the restored boundary, and P14-03
+## A06 starts a fresh finite Mana reserve at the restored boundary, P14-03
-## raises the elevator snapshot from v1 to v2 with every other field unchanged.
+## raises the elevator snapshot from v1 to v2 with every other field unchanged,
+## and P07-01 A13 migrates the weather snapshot and adds the weather stream.
 func _approved_runtime_migrations(expected: Dictionary, reader: Dictionary) -> Dictionary:
 	var old: Dictionary = expected[&"systems"][&"runtime"]
 	var now: Dictionary = reader[&"systems"][&"runtime"]
@@ -322,6 +323,35 @@ func _approved_runtime_migrations(expected: Dictionary, reader: Dictionary) -> D
 		old[&"economy"] = economy
 		fields.append("economy_A12_empty_fund_accounts")
 		proof["economy_A12"] = {"added_accounts": added.keys(), "only_accounts_added": only_accounts_added}
+	# P07-01 A13 (SPEC section 5.2): a save from before natural weather keeps its
+	# weather and pending schedule, counts every day whose 06:00 has passed as
+	# drawn (no past draw), holds no rain extension, and starts the weather
+	# stream from the world seed; every other field stays byte-identical.
+	var old_weather: Variant = old.get(&"weather")
+	var now_weather: Variant = now.get(&"weather")
+	if old_weather is Dictionary and int(old_weather.get(&"version", 0)) == 1 and now_weather is Dictionary and int(now_weather.get(&"version", 0)) == 2:
+		var weather_minute := int(old_weather[&"minute"])
+		var last_draw_day := floori(weather_minute / 1440.0) - (0 if posmod(weather_minute, 1440) > 360 else 1)
+		var migrated: Dictionary = (old_weather as Dictionary).duplicate(true)
+		migrated[&"version"] = 2
+		migrated[&"natural"] = {&"last_draw_day": last_draw_day, &"today": {}}
+		migrated[&"rain_holds"] = {}
+		var only_natural_state_added: bool = migrated == now_weather
+		ok = ok and only_natural_state_added
+		old[&"weather"] = (now_weather as Dictionary).duplicate(true)
+		fields.append("weather_v1_to_v2_A13")
+		proof["weather_A13"] = {"last_draw_day": last_draw_day, "only_natural_state_added": only_natural_state_added}
+	var old_streams: Variant = old.get(&"rng_streams")
+	var now_streams: Variant = now.get(&"rng_streams")
+	if old_streams is Dictionary and now_streams is Dictionary and not (old_streams as Dictionary).has("weather") and (now_streams as Dictionary).has("weather"):
+		var seeded: Dictionary = DeterministicRng.from_root_seed(int(old[&"world_seed"]), &"weather").snapshot()
+		var others: Dictionary = (now_streams as Dictionary).duplicate(true)
+		others.erase("weather")
+		var only_weather_stream_added: bool = now_streams["weather"] == seeded and var_to_bytes(others) == var_to_bytes(old_streams)
+		ok = ok and only_weather_stream_added
+		old[&"rng_streams"] = (now_streams as Dictionary).duplicate(true)
+		fields.append("rng_streams_weather_from_world_seed_A13")
+		proof["rng_streams_A13"] = {"only_weather_stream_added": only_weather_stream_added}
 	if not fields.is_empty():
 		# Saves keep the Runtime's own key order, so the mapped tree follows it.
 		ok = ok and old.size() == now.size()

tests/environment/test_p07_weather_restart_1_write.gd

@@ -0,0 +1,210 @@
+extends SceneTree
+
+## P07-01 F7, writer phase. Plays the minute script, writes ordinary save files
+## mid-rain, just before and after the rain end and just before and after the
+## day 1 draw, and hands the exact save packages to the reader suite
+## (test_p07_weather_restart_2_read.gd), which runs as a separate engine process.
+## The fog scene (WX7) writes saves around the 07:00 fog mana boundary and the
+## fog end, reloads each one in this process and continues it, and hands those
+## packages to the reader too.
+## The handoff is the declared generated report res://artifacts/p07-01/restart-handoff.json
+## (tools/regression/suite-policy.json fixed_generated_report_routes).
+
+const Fixture := preload("res://tests/helpers/p07_weather_restart_fixture.gd")
+
+var _checks := 0
+var _failures := 0
+
+
+func _initialize() -> void:
+	call_deferred("_run")
+
+
+func _run() -> void:
+	print("P07-01: restart writer")
+	var fixtures := Fixture.new(_expect)
+	var straight := fixtures.new_fixture()
+	var straight_runtime: Variant = straight[&"runtime"]
+	var held_guest: Variant = straight_runtime.guest_service.get_guest(Fixture.HELD_GUEST)
+	var held := {"hold": {}, "reason": &"", "after": {}}
+	fixtures.play(straight, Fixture.FIRST_MINUTE, Fixture.LAST_MINUTE, func(minute: int) -> void:
+		if (held["hold"] as Dictionary).is_empty():
+			held["hold"] = straight_runtime.weather.get_rain_hold(Fixture.HELD_GUEST)
+		if StringName(held["reason"]).is_empty():
+			held["reason"] = held_guest.exit_reason
+		if minute == 363:
+			_expect(straight_runtime.guest_service.get_guest(Fixture.HELD_GUEST) != null and held_guest.state == GuestRuntime.State.LEAVING
+				and straight_runtime.weather.get_rain_hold(Fixture.HELD_GUEST) == Fixture.HOLD, "at 06:03 the held guest is still present and leaving with its hold")
+		if minute == 364:
+			_expect(straight_runtime.guest_service.get_guest(Fixture.HELD_GUEST) == null and straight_runtime.weather.get_rain_holds().is_empty(),
+				"at 06:04 the held guest is gone and its hold left with it")
+		if minute - 1 in Fixture.SAVE_MINUTES:
+			held["after"][minute] = fixtures.state_bytes(straight_runtime))
+	# The hold only moves the planned exit; every other current rule still applies,
+	# so in this world without facilities the guest leaves for lack of one.
+	_expect(held["hold"] == Fixture.HOLD and held_guest.planned_exit_at == 602 and held["reason"] == &"NO_SUITABLE_FACILITY",
+		"the guest due at 06:02 was held to 10:02 and still left by the current rules (%s)" % String(held["reason"]))
+	_expect(straight[&"draws"][&"count"] == Fixture.DRAW_MINUTES.size() and straight_runtime.weather.get_last_draw_day() == 1, "the uninterrupted script draws day 1 once")
+	var saving := fixtures.new_fixture()
+	var saving_runtime: Variant = saving[&"runtime"]
+	var saved_states := {}
+	var saved_paths := {}
+	fixtures.play(saving, Fixture.FIRST_MINUTE, Fixture.LAST_MINUTE, func(minute: int) -> void:
+		if minute in Fixture.SAVE_MINUTES:
+			if minute == 363:
+				_expect(saving_runtime.guest_service.get_guest(Fixture.HELD_GUEST) != null and saving_runtime.weather.get_rain_holds() == {String(Fixture.HELD_GUEST): Fixture.HOLD}
+					and saving_runtime.guest_service.get_guest(Fixture.HELD_GUEST).planned_exit_at == 602, "minute 363 saves the hold of the present held guest")
+			if minute == 364:
+				_expect(saving_runtime.guest_service.get_guest(Fixture.HELD_GUEST) == null and saving_runtime.weather.get_rain_holds().is_empty(), "minute 364 saves just after the held guest left, without its hold")
+			if minute == 500:
+				_expect(saving_runtime.weather.get_kind() == &"rain", "minute 500 saves mid-rain")
+			var path := Fixture.WRITER_SAVE % minute
+			saved_states[minute] = fixtures.state_bytes(saving_runtime)
+			_expect(bool(saving_runtime.save_to_path(path).get(&"ok", false)), "save file at minute %d" % minute)
+			saved_paths[minute] = path)
+	_expect(fixtures.state_bytes(saving_runtime) == fixtures.state_bytes(straight_runtime), "writing the save files leaves the weather state as without saving")
+	var final_state := fixtures.state_bytes(straight_runtime)
+	for minute: int in Fixture.SAVE_MINUTES:
+		var reload := fixtures.new_fixture(false)
+		var reload_runtime: Variant = reload[&"runtime"]
+		_expect(bool(reload_runtime.load_from_path(str(saved_paths.get(minute, Fixture.WRITER_SAVE % minute))).get(&"ok", false))
+			and fixtures.state_bytes(reload_runtime) == saved_states.get(minute, PackedByteArray()) and reload[&"clock"].absolute_minute == minute,
+			"this process reloads the save file of minute %d exactly" % minute)
+		if minute == 363:
+			_expect(reload_runtime.weather.get_rain_holds() == {String(Fixture.HELD_GUEST): Fixture.HOLD} and reload_runtime.guest_service.get_guest(Fixture.HELD_GUEST).planned_exit_at == 602,
+				"the reloaded minute 363 save keeps the one hold and the extended plan")
+		fixtures.play(reload, minute, minute + 1, Callable())
+		_expect(fixtures.state_bytes(reload_runtime) == held["after"].get(minute + 1, PackedByteArray()),
+			"one minute after the minute %d reload equals the uninterrupted run (no second extension)" % minute)
+		fixtures.play(reload, minute + 1, Fixture.LAST_MINUTE, Callable())
+		_expect(fixtures.state_bytes(reload_runtime) == final_state, "the minute %d reload continues to the uninterrupted final state" % minute)
+		fixtures.free_fixture(reload)
+	var saves := _packages(Fixture.SAVE_MINUTES, saved_paths, saved_states, Fixture.WRITER_SAVE)
+	var after := {}
+	for minute: int in held["after"]:
+		var bytes: PackedByteArray = held["after"][minute]
+		after[str(minute)] = {"sha256": Fixture.sha256(bytes), "base64": Marshalls.raw_to_base64(bytes)}
+	var fog := _fog_scene(fixtures)
+	var handoff := {
+		"schema": Fixture.HANDOFF_SCHEMA,
+		"writer_pid": OS.get_process_id(),
+		"writer_source_sha256": FileAccess.get_sha256(Fixture.WRITER_SOURCE),
+		"seed": Fixture.SEED,
+		"last_minute": Fixture.LAST_MINUTE,
+		"straight_final_state_sha256": Fixture.sha256(final_state),
+		"straight_final_state_base64": Marshalls.raw_to_base64(final_state),
+		"after_states": after,
+		"saves": saves,
+		"fog": fog,
+	}
+	DirAccess.make_dir_recursive_absolute(Fixture.HANDOFF_PATH.get_base_dir())
+	var file := FileAccess.open(Fixture.HANDOFF_PATH, FileAccess.WRITE)
+	_expect(file != null, "handoff file opens for writing")
+	if file != null:
+		file.store_string(JSON.stringify(handoff, "\t") + "\n")
+		file.close()
+	print("P07_RESTART_WRITER pid=%d handoff_sha256=%s" % [OS.get_process_id(), FileAccess.get_sha256(Fixture.HANDOFF_PATH)])
+	fixtures.free_fixture(straight)
+	fixtures.free_fixture(saving)
+	await process_frame
+	if _failures == 0:
+		print("PASS: %d checks" % _checks)
+	else:
+		push_error("FAIL: %d of %d checks failed" % [_failures, _checks])
+	quit(_failures)
+
+
+## WX7 fog scene: the uninterrupted run, the run that writes the save files, and
+## a same-process reload of every save file continued to the end.
+func _fog_scene(fixtures: Variant) -> Dictionary:
+	var straight: Dictionary = fixtures.new_fixture(false, Fixture.FOG_SEED)
+	var runtime: Variant = straight[&"runtime"]
+	_expect(runtime.weather.get_kind() == &"mana_fog" and int(runtime.weather.get_today_draw().get("end", -1)) == 600, "seed 1592 opens the fog scene with mana fog 06:00-10:00")
+	var seen := {"intimacy": {}, "rises": 0, "fog_rises": 0, "rises_ok": true, "flows": 0, "fog_flows": 0, "flows_ok": true, "after": {}}
+	fixtures.play(straight, Fixture.FIRST_MINUTE, Fixture.FOG_LAST_MINUTE, func(minute: int) -> void:
+		var fog_now: bool = runtime.weather.get_kind() == &"mana_fog"
+		var last: Dictionary = seen["intimacy"]
+		for guest_id: StringName in Fixture.FOG_ADULTS.values():
+			var guest: Variant = runtime.guest_service.get_guest(guest_id)
+			if guest == null:
+				continue
+			var now := int(guest.needs[&"intimacy"])
+			if last.has(guest_id) and now < 100:
+				seen["rises"] += 1
+				seen["rises_ok"] = seen["rises_ok"] and now - int(last[guest_id]) == (4 if fog_now else 3)
+				if fog_now:
+					seen["fog_rises"] += 1
+			last[guest_id] = now
+		if minute % 10 == 0:
+			seen["flows"] += 1
+			seen["flows_ok"] = seen["flows_ok"] and int(runtime.mana_reserve.get_last_flow().get(&"generation", -1)) == (24 if fog_now else 20)
+			if fog_now:
+				seen["fog_flows"] += 1
+		if minute - 1 in Fixture.FOG_SAVE_MINUTES:
+			seen["after"][minute] = fixtures.state_bytes(runtime))
+	_expect(seen["rises_ok"] and int(seen["fog_rises"]) >= 3 and int(seen["rises"]) - int(seen["fog_rises"]) >= 2,
+		"adult-verified intimacy rises by 4 a minute in fog and 3 after it (%d rises, %d in fog)" % [int(seen["rises"]), int(seen["fog_rises"])])
+	_expect(seen["flows_ok"] and int(seen["fog_flows"]) >= 20 and int(seen["flows"]) > int(seen["fog_flows"]),
+		"each 10-minute mana boundary adds 24 in fog and 20 after it (%d boundaries, %d in fog)" % [int(seen["flows"]), int(seen["fog_flows"])])
+	var saving: Dictionary = fixtures.new_fixture(false, Fixture.FOG_SEED)
+	var saving_runtime: Variant = saving[&"runtime"]
+	var states := {}
+	var paths := {}
+	fixtures.play(saving, Fixture.FIRST_MINUTE, Fixture.FOG_LAST_MINUTE, func(minute: int) -> void:
+		if minute in Fixture.FOG_SAVE_MINUTES:
+			var path := Fixture.FOG_WRITER_SAVE % minute
+			states[minute] = fixtures.state_bytes(saving_runtime)
+			_expect(bool(saving_runtime.save_to_path(path).get(&"ok", false)), "fog save file at minute %d" % minute)
+			paths[minute] = path)
+	var final_state: PackedByteArray = fixtures.state_bytes(runtime)
+	_expect(fixtures.state_bytes(saving_runtime) == final_state, "writing the fog save files leaves the state as without saving")
+	for minute: int in Fixture.FOG_SAVE_MINUTES:
+		var reload: Dictionary = fixtures.new_fixture(false, Fixture.FOG_SEED)
+		var reload_runtime: Variant = reload[&"runtime"]
+		_expect(bool(reload_runtime.load_from_path(str(paths.get(minute, Fixture.FOG_WRITER_SAVE % minute))).get(&"ok", false))
+			and fixtures.state_bytes(reload_runtime) == states.get(minute, PackedByteArray()) and reload[&"clock"].absolute_minute == minute,
+			"this process reloads the fog save file of minute %d exactly" % minute)
+		fixtures.play(reload, minute, minute + 1, Callable())
+		_expect(fixtures.state_bytes(reload_runtime) == seen["after"].get(minute + 1, PackedByteArray()),
+			"one minute after the minute %d fog reload equals the uninterrupted run (the fog yield and intimacy apply once)" % minute)
+		fixtures.play(reload, minute + 1, Fixture.FOG_LAST_MINUTE, Callable())
+		_expect(fixtures.state_bytes(reload_runtime) == final_state, "the minute %d fog reload continues to the uninterrupted final state" % minute)
+		fixtures.free_fixture(reload)
+	var after := {}
+	for minute: int in seen["after"]:
+		var bytes: PackedByteArray = seen["after"][minute]
+		after[str(minute)] = {"sha256": Fixture.sha256(bytes), "base64": Marshalls.raw_to_base64(bytes)}
+	var saves := _packages(Fixture.FOG_SAVE_MINUTES, paths, states, Fixture.FOG_WRITER_SAVE)
+	fixtures.free_fixture(straight)
+	fixtures.free_fixture(saving)
+	return {
+		"seed": Fixture.FOG_SEED,
+		"last_minute": Fixture.FOG_LAST_MINUTE,
+		"straight_final_state_sha256": Fixture.sha256(final_state),
+		"straight_final_state_base64": Marshalls.raw_to_base64(final_state),
+		"after_states": after,
+		"saves": saves,
+	}
+
+
+## The exact save packages and the compared state at each save minute.
+func _packages(minutes: Array[int], paths: Dictionary, states: Dictionary, path_format: String) -> Array:
+	var saves: Array = []
+	for minute: int in minutes:
+		var directory := ProjectSettings.globalize_path(str(paths.get(minute, path_format % minute)))
+		_expect(DirAccess.dir_exists_absolute(directory) and DirAccess.get_directories_at(directory).is_empty(), "save package %s holds only files" % (path_format % minute))
+		var files := {}
+		for name: String in DirAccess.get_files_at(directory):
+			var bytes := FileAccess.get_file_as_bytes(directory.path_join(name))
+			files[name] = {"sha256": Fixture.sha256(bytes), "bytes": bytes.size(), "base64": Marshalls.raw_to_base64(bytes)}
+		_expect(files.has("manifest.json") and files.has("world.bin"), "save package %s has its manifest and world" % (path_format % minute))
+		var state: PackedByteArray = states.get(minute, PackedByteArray())
+		saves.append({"minute": minute, "files": files, "state_sha256": Fixture.sha256(state), "state_base64": Marshalls.raw_to_base64(state)})
+	return saves
+
+
+func _expect(condition: bool, message: String) -> void:
+	_checks += 1
+	if not condition:
+		_failures += 1
+		push_error(message)

tests/environment/test_p07_weather_restart_1_write.gd.uid

@@ -0,0 +1 @@
+uid://bz9x67zdqdrc6

tests/environment/test_p07_weather_restart_2_read.gd

@@ -0,0 +1,138 @@
+extends SceneTree
+
+## P07-01 F7, reader phase (a separate engine process after the writer). Each
+## handed-off save package is loaded into a fresh Runtime, must equal the writer's
+## state at that minute, and must continue to the writer's uninterrupted final
+## state, with every remaining 06:00 draw happening exactly once. The fog scene
+## (WX7) packages must also equal the writer's state one minute after each save,
+## so the fog mana yield and the adult intimacy apply exactly once across the
+## process boundary.
+
+const Fixture := preload("res://tests/helpers/p07_weather_restart_fixture.gd")
+
+var _checks := 0
+var _failures := 0
+
+
+func _initialize() -> void:
+	call_deferred("_run")
+
+
+func _run() -> void:
+	print("P07-01: restart reader")
+	var handoff := _read_handoff()
+	if not handoff.is_empty():
+		_check_restarts(handoff)
+		_check_fog(handoff.get("fog", {}))
+	await process_frame
+	if _failures == 0:
+		print("PASS: %d checks" % _checks)
+	else:
+		push_error("FAIL: %d of %d checks failed" % [_failures, _checks])
+	quit(_failures)
+
+
+func _read_handoff() -> Dictionary:
+	_expect(FileAccess.file_exists(Fixture.HANDOFF_PATH), "the writer phase left its handoff (run test_p07_weather_restart_1_write.gd first)")
+	if not FileAccess.file_exists(Fixture.HANDOFF_PATH):
+		return {}
+	var parsed: Variant = JSON.parse_string(FileAccess.get_file_as_string(Fixture.HANDOFF_PATH))
+	_expect(parsed is Dictionary and str((parsed as Dictionary).get("schema", "")) == Fixture.HANDOFF_SCHEMA, "handoff schema")
+	if not parsed is Dictionary:
+		return {}
+	var handoff: Dictionary = parsed
+	var writer_pid := int(handoff.get("writer_pid", 0))
+	_expect(writer_pid > 0 and writer_pid != OS.get_process_id(), "the writer ran in another engine process")
+	_expect(str(handoff.get("writer_source_sha256", "")) == FileAccess.get_sha256(Fixture.WRITER_SOURCE), "the handoff comes from the current writer suite")
+	_expect(int(handoff.get("seed", -1)) == Fixture.SEED and int(handoff.get("last_minute", -1)) == Fixture.LAST_MINUTE, "same fixture and minute script")
+	print("P07_RESTART_READER pid=%d writer_pid=%d handoff_sha256=%s" % [OS.get_process_id(), writer_pid, FileAccess.get_sha256(Fixture.HANDOFF_PATH)])
+	return handoff
+
+
+func _check_restarts(handoff: Dictionary) -> void:
+	var fixtures := Fixture.new(_expect)
+	var final_state := Marshalls.base64_to_raw(str(handoff.get("straight_final_state_base64", "")))
+	_expect(Fixture.sha256(final_state) == str(handoff.get("straight_final_state_sha256", "")), "the writer's final state arrived intact")
+	var saves: Array = handoff.get("saves", [])
+	_expect(saves.size() == Fixture.SAVE_MINUTES.size(), "every save package was handed off")
+	var after: Dictionary = handoff.get("after_states", {})
+	for save: Variant in saves:
+		var minute := int((save as Dictionary).get("minute", -1))
+		var path := Fixture.READER_SAVE % minute
+		_expect(_write_package(save, path), "save package at minute %d arrived byte-exact" % minute)
+		var expected_state := Marshalls.base64_to_raw(str((save as Dictionary).get("state_base64", "")))
+		var next_row: Dictionary = after.get(str(minute + 1), {})
+		var next_state := Marshalls.base64_to_raw(str(next_row.get("base64", "")))
+		_expect(not next_state.is_empty() and Fixture.sha256(next_state) == str(next_row.get("sha256", "")), "the writer's state one minute after %d arrived intact" % minute)
+		var fixture := fixtures.new_fixture(false)
+		var runtime: Variant = fixture[&"runtime"]
+		_expect(bool(runtime.load_from_path(path).get(&"ok", false)), "the reader loads the minute %d save" % minute)
+		_expect(fixtures.state_bytes(runtime) == expected_state and fixture[&"clock"].absolute_minute == minute, "the minute %d save resumes the writer's weather, holds, stream and plans" % minute)
+		if minute == 363:
+			_expect(runtime.weather.get_rain_holds() == {String(Fixture.HELD_GUEST): Fixture.HOLD} and runtime.guest_service.get_guest(Fixture.HELD_GUEST) != null
+				and runtime.guest_service.get_guest(Fixture.HELD_GUEST).planned_exit_at == 602, "the reader resumes the one hold of the present held guest and its extended plan")
+		# Loading replaces the event stream, so the draw counter subscribes again.
+		fixture[&"draws"][&"count"] = 0
+		fixtures.watch_draws(fixture)
+		fixtures.play(fixture, minute, minute + 1, Callable())
+		_expect(fixtures.state_bytes(runtime) == next_state, "one minute after the minute %d save the reader equals the writer (no second extension)" % minute)
+		fixtures.play(fixture, minute + 1, Fixture.LAST_MINUTE, Callable())
+		var expected_draws := 0
+		for draw_minute: int in Fixture.DRAW_MINUTES:
+			if draw_minute > minute:
+				expected_draws += 1
+		_expect(fixture[&"draws"][&"count"] == expected_draws, "after the minute %d save the remaining 06:00 draws happen once (%d)" % [minute, expected_draws])
+		_expect(fixtures.state_bytes(runtime) == final_state, "continuing from minute %d reaches the uninterrupted final state" % minute)
+		fixtures.free_fixture(fixture)
+		SaveService.delete_save(path)
+
+
+func _check_fog(fog: Dictionary) -> void:
+	var fixtures := Fixture.new(_expect)
+	_expect(int(fog.get("seed", -1)) == Fixture.FOG_SEED and int(fog.get("last_minute", -1)) == Fixture.FOG_LAST_MINUTE, "same fog scene and minute script")
+	var final_state := Marshalls.base64_to_raw(str(fog.get("straight_final_state_base64", "")))
+	_expect(not final_state.is_empty() and Fixture.sha256(final_state) == str(fog.get("straight_final_state_sha256", "")), "the writer's fog final state arrived intact")
+	var saves: Array = fog.get("saves", [])
+	_expect(saves.size() == Fixture.FOG_SAVE_MINUTES.size(), "every fog save package was handed off")
+	var after: Dictionary = fog.get("after_states", {})
+	for save: Variant in saves:
+		var minute := int((save as Dictionary).get("minute", -1))
+		var path := Fixture.FOG_READER_SAVE % minute
+		_expect(_write_package(save, path), "fog save package at minute %d arrived byte-exact" % minute)
+		var expected_state := Marshalls.base64_to_raw(str((save as Dictionary).get("state_base64", "")))
+		var next_row: Dictionary = after.get(str(minute + 1), {})
+		var next_state := Marshalls.base64_to_raw(str(next_row.get("base64", "")))
+		_expect(not next_state.is_empty() and Fixture.sha256(next_state) == str(next_row.get("sha256", "")), "the writer's state one minute after %d arrived intact" % minute)
+		var fixture := fixtures.new_fixture(false, Fixture.FOG_SEED)
+		var runtime: Variant = fixture[&"runtime"]
+		_expect(bool(runtime.load_from_path(path).get(&"ok", false)) and fixtures.state_bytes(runtime) == expected_state and fixture[&"clock"].absolute_minute == minute,
+			"the reader resumes the minute %d fog save exactly" % minute)
+		fixtures.play(fixture, minute, minute + 1, Callable())
+		_expect(fixtures.state_bytes(runtime) == next_state, "one minute after the minute %d fog save the reader equals the uninterrupted run (no double fog yield or intimacy)" % minute)
+		fixtures.play(fixture, minute + 1, Fixture.FOG_LAST_MINUTE, Callable())
+		_expect(fixtures.state_bytes(runtime) == final_state, "continuing the minute %d fog save reaches the uninterrupted final state" % minute)
+		fixtures.free_fixture(fixture)
+		SaveService.delete_save(path)
+
+
+## Writes one handed-off save package byte for byte; true when every file matches its pin.
+func _write_package(save: Dictionary, path: String) -> bool:
+	var directory := ProjectSettings.globalize_path(path)
+	DirAccess.make_dir_recursive_absolute(directory)
+	var files: Dictionary = save.get("files", {})
+	var intact := not files.is_empty()
+	for name: String in files:
+		var bytes := Marshalls.base64_to_raw(str(files[name].get("base64", "")))
+		intact = intact and Fixture.sha256(bytes) == str(files[name].get("sha256", "")) and bytes.size() == int(files[name].get("bytes", -1))
+		var file := FileAccess.open(directory.path_join(name), FileAccess.WRITE)
+		if file != null:
+			file.store_buffer(bytes)
+			file.close()
+	return intact
+
+
+func _expect(condition: bool, message: String) -> void:
+	_checks += 1
+	if not condition:
+		_failures += 1
+		push_error(message)

tests/environment/test_p07_weather_restart_2_read.gd.uid

@@ -0,0 +1 @@
+uid://bni9w8axk6f97

tests/environment/test_p07_weather_runtime.gd

@@ -0,0 +1,403 @@
+extends SceneTree
+
+## P07-01 (rain, mana fog and natural weather) F1-F7 on the real Runtime with the
+## approved initial values A13 (SPEC sections 4 and 5). F6 reads the ordinary Main
+## HUD. The seeds open day 0 with clear (1000), rain (1106), mana fog (1592) and
+## storm (2501) starting at 06:00; the draws are asserted, not assumed.
+
+const NaturalWeather := preload("res://scripts/environment/natural_weather_policy.gd")
+const WeatherTimeline := preload("res://scripts/environment/weather_timeline.gd")
+const ManaReserveCycle := preload("res://scripts/mana/mana_reserve_cycle.gd")
+const AudioTeardown := preload("res://tests/helpers/ui_audio_teardown.gd")
+const SEED_CLEAR := 1000
+const SEED_RAIN := 1106
+const SEED_FOG := 1592
+const SEED_STORM := 2501
+
+var _checks := 0
+var _failures := 0
+var _fixtures: Array[Dictionary] = []
+
+
+func _initialize() -> void:
+	call_deferred("_run")
+
+
+func _run() -> void:
+	print("P07-01: natural weather runtime")
+	_test_policy_draws()
+	_test_daily_natural_draw()
+	_test_rain_arrivals()
+	_test_rain_stay_and_saves()
+	_test_rain_hold_exit()
+	_test_storm()
+	_test_mana_fog()
+	_test_migration_and_rejection()
+	await _test_hud_forecast()
+	_release_fixtures()
+	if _failures == 0:
+		print("PASS: %d checks" % _checks)
+	else:
+		push_error("FAIL: %d of %d checks failed" % [_failures, _checks])
+	quit(_failures)
+
+
+func _new_runtime(seed: int, hour := 6, minute := 0) -> Dictionary:
+	var runtime: Variant = load("res://autoload/simulation_runtime.gd").new()
+	var clock: Variant = load("res://autoload/game_clock.gd").new()
+	var state: Variant = load("res://autoload/game_state.gd").new()
+	clock.reset(1, hour, minute)
+	state.reset()
+	_expect(runtime.initialize(clock, state, seed)[&"valid"], "initialize Runtime with seed %d" % seed)
+	clock.set_paused(true)
+	var fixture := {&"runtime": runtime, &"clock": clock, &"state": state}
+	_fixtures.append(fixture)
+	return fixture
+
+
+func _release_fixtures() -> void:
+	for fixture: Dictionary in _fixtures:
+		for key: StringName in [&"runtime", &"clock", &"state"]:
+			if is_instance_valid(fixture[key]):
+				fixture[key].free()
+	_fixtures.clear()
+
+
+func _drawn_events(runtime: Variant) -> Array:
+	var found: Array = []
+	for event: SimulationDomainEvent in runtime.domain_events.recent_events():
+		if event.event_type == &"WEATHER_FORECAST_DRAWN":
+			found.append(event.payload.duplicate(true))
+	return found
+
+
+func _spawn(runtime: Variant, guest_id: StringName, guest_type: StringName, planned_exit_at: int) -> Variant:
+	var result: CommandResult = runtime.submit_command(&"spawn_guest", {
+		&"guest_id": guest_id,
+		&"guest_type_id": guest_type,
+		&"gold": 100,
+		&"options": {
+			&"current_cell": Vector3i(0, 0, WorldService.LAYER_FRONT),
+			&"needs": {&"hunger": 10, &"sleep": 10, &"hygiene": 10, &"medical": 0, &"leisure": 10, &"intimacy": 0},
+			&"planned_exit_at": planned_exit_at,
+		},
+	}, &"world", guest_id, 10, -1, StringName("p07." + String(guest_id)))
+	_expect(result.is_success(), "spawn %s" % guest_id)
+	return runtime.guest_service.get_guest(guest_id)
+
+
+## F1: the A13 draw rule, determinism and the once-per-day timeline rule.
+func _test_policy_draws() -> void:
+	var rng := DeterministicRng.from_root_seed(77, &"weather") as DeterministicRng
+	var counts := {&"clear": 0, &"rain": 0, &"mana_fog": 0, &"storm": 0}
+	var rule_ok := true
+	for day in range(2000):
+		var draw: Dictionary = NaturalWeather.draw(rng, day)
+		var kind: StringName = draw[&"kind"]
+		counts[kind] += 1
+		var roll: int = draw[&"roll"]
+		var expected_kind: StringName = &"clear" if roll < 60 else (&"rain" if roll < 85 else (&"mana_fog" if roll < 95 else &"storm"))
+		rule_ok = rule_ok and kind == expected_kind and roll >= 0 and roll <= 99
+		if kind == &"clear":
+			rule_ok = rule_ok and draw[&"slot"] == -1 and draw[&"start"] == -1 and draw[&"end"] == -1
+		else:
+			var offset: int = int(draw[&"start"]) - day * 1440 - 360
+			rule_ok = rule_ok and offset >= 0 and offset <= 14 * 60 and offset % 30 == 0 and offset / 30 == int(draw[&"slot"]) \
+				and int(draw[&"end"]) - int(draw[&"start"]) == int(NaturalWeather.DURATION_MINUTES[kind])
+	_expect(rule_ok, "every draw maps rolls 0-59/60-84/85-94/95-99 to clear/rain/fog/storm, starts 06:00-20:00 in 30-minute steps and lasts 6/4/2 hours")
+	_expect(counts[&"clear"] > 1100 and counts[&"clear"] < 1300 and counts[&"rain"] > 400 and counts[&"rain"] < 600
+		and counts[&"mana_fog"] > 140 and counts[&"mana_fog"] < 260 and counts[&"storm"] > 60 and counts[&"storm"] < 140,
+		"2000 draws follow 60/25/10/5 percent (%s)" % str(counts))
+	var left := DeterministicRng.from_root_seed(5, &"weather") as DeterministicRng
+	var right := DeterministicRng.from_root_seed(5, &"weather") as DeterministicRng
+	var same := true
+	for day in range(60):
+		same = same and NaturalWeather.draw(left, day) == NaturalWeather.draw(right, day)
+	_expect(same, "the same seed draws the same weather list")
+	var timeline := WeatherTimeline.new()
+	_expect(timeline.initialize(&"clear", 360) and timeline.get_last_draw_day() == -1, "a timeline opened at 06:00 still owes that day's draw")
+	var rain := {&"day": 0, &"kind": &"rain", &"roll": 70, &"slot": 2, &"start": 420, &"end": 780}
+	_expect(timeline.apply_draw(rain)[&"ok"] and timeline.get_last_draw_day() == 0 and timeline.next_change() == {&"kind": &"rain", &"minute": 420}, "a drawn rain is scheduled with its return to clear")
+	_expect(timeline.apply_draw(rain)[&"code"] == &"DRAW_NOT_DUE", "a second draw for the same day is refused")
+	var later := WeatherTimeline.new()
+	later.initialize(&"clear", 361)
+	_expect(later.apply_draw(rain)[&"code"] == &"DRAW_NOT_DUE", "a draw outside its 06:00 is refused")
+
+
+## F1: one draw at 06:00 on the saved stream, recorded as WEATHER_FORECAST_DRAWN.
+func _test_daily_natural_draw() -> void:
+	var opening := _new_runtime(SEED_RAIN)
+	var runtime: Variant = opening[&"runtime"]
+	var today: Dictionary = runtime.weather.get_today_draw()
+	_expect(String(today.get("kind", "")) == "rain" and int(today.get("start", -1)) == 360 and int(today.get("end", -1)) == 720, "seed 1106 opens day 0 with rain 06:00-12:00 (%s)" % str(today))
+	_expect(runtime.weather.get_kind() == &"rain" and runtime.weather.get_last_draw_day() == 0, "a start at the draw minute switches at once")
+	var events := _drawn_events(runtime)
+	_expect(events.size() == 1 and int(events[0][&"day"]) == 0 and String(events[0][&"kind"]) == "rain" and bool(events[0][&"applied"]), "the opening draw is recorded once")
+	runtime.call("_draw_natural_weather_if_due", 360)
+	_expect(_drawn_events(runtime).size() == 1, "the same minute does not draw again")
+	var twin: Variant = _new_runtime(SEED_RAIN)[&"runtime"]
+	_expect(twin.weather.create_snapshot() == runtime.weather.create_snapshot()
+		and twin.get_rng_stream(&"weather").snapshot() == runtime.get_rng_stream(&"weather").snapshot(), "the same seed gives the same weather and stream")
+	var early := _new_runtime(SEED_RAIN, 5, 50)
+	var early_runtime: Variant = early[&"runtime"]
+	_expect(early_runtime.weather.get_today_draw().is_empty() and _drawn_events(early_runtime).is_empty(), "a game opened before 06:00 waits for the boundary")
+	early[&"clock"].advance_minutes(10)
+	_expect(early_runtime.weather.get_today_draw() == today and early_runtime.weather.get_kind() == &"rain", "the 06:00 boundary draws the same day from the same stream")
+	var daily := _new_runtime(SEED_CLEAR)
+	var daily_runtime: Variant = daily[&"runtime"]
+	_expect(String(daily_runtime.weather.get_today_draw().get("kind", "")) == "clear" and daily_runtime.weather.get_kind() == &"clear", "seed 1000 opens day 0 clear")
+	var seen := {&"count": 0}
+	daily_runtime.domain_events.subscribe(&"WEATHER_FORECAST_DRAWN", &"p07_test", func(_event: SimulationDomainEvent) -> void: seen[&"count"] += 1)
+	daily[&"clock"].advance_minutes(1439)
+	_expect(seen[&"count"] == 0 and daily_runtime.weather.get_last_draw_day() == 0, "no draw before the next 06:00")
+	daily[&"clock"].advance_minutes(1)
+	_expect(seen[&"count"] == 1 and daily_runtime.weather.get_last_draw_day() == 1 and int(daily_runtime.weather.get_today_draw().get("day", -1)) == 1, "the next 06:00 draws day 1 once")
+
+
+## F2: rain halves the planned new arrivals of a boundary; the dropped ones are not carried.
+func _test_rain_arrivals() -> void:
+	var clear_side := _new_runtime(SEED_CLEAR)
+	var rain_side := _new_runtime(SEED_CLEAR)
+	var clear_runtime: Variant = clear_side[&"runtime"]
+	var rain_runtime: Variant = rain_side[&"runtime"]
+	_expect(clear_runtime.enable_production_operations()[&"ok"] and rain_runtime.enable_production_operations()[&"ok"], "enable production arrivals on both sides")
+	_expect(rain_runtime.weather.schedule(&"rain", 361)[&"ok"] and rain_runtime.weather.schedule(&"clear", 1200)[&"ok"], "rain from 06:01 on one side only")
+	var compared := false
+	for _minute in range(300):
+		clear_side[&"clock"].advance_minutes(1)
+		rain_side[&"clock"].advance_minutes(1)
+		var clear_reports: Array = clear_runtime.operations_coordinator.get_arrival_reports()
+		var rain_reports: Array = rain_runtime.operations_coordinator.get_arrival_reports()
+		# Only boundaries inside the rain (from 06:01) are compared.
+		if clear_reports.is_empty() or int(clear_reports[-1][&"minute"]) <= 360 or int(clear_reports[-1][&"total_count"]) < 2:
+			continue
+		var minute: int = clear_reports[-1][&"minute"]
+		var clear_total: int = clear_reports[-1][&"total_count"]
+		_expect(not rain_reports.is_empty() and int(rain_reports[-1][&"minute"]) == minute
+			and int(rain_reports[-1][&"total_count"]) == clear_total / 2, "rain plans floor(%d / 2) arrivals at minute %d" % [clear_total, minute])
+		var carry_same := true
+		for profile: Dictionary in clear_runtime.operations_coordinator.get_demand_profiles():
+			carry_same = carry_same and clear_runtime.operations_coordinator.get_arrival_carry(profile[&"facility_tag"], profile[&"guest_class"], profile[&"time_band"]) \
+				== rain_runtime.operations_coordinator.get_arrival_carry(profile[&"facility_tag"], profile[&"guest_class"], profile[&"time_band"])
+		_expect(carry_same, "arrivals lost to rain are not carried to the next boundary")
+		compared = true
+		break
+	_expect(compared, "an arrival boundary with at least two arrivals was compared")
+	var rain_capture: Dictionary = rain_runtime.call("_operations_arrival_boundary", {}, OperationsCoordinator.PHASE_CAPTURE, null)
+	var clear_capture: Dictionary = clear_runtime.call("_operations_arrival_boundary", {}, OperationsCoordinator.PHASE_CAPTURE, null)
+	_expect(int(rain_capture[&"arrival_percent"]) == 50 and int(clear_capture[&"arrival_percent"]) == 100, "the arrival boundary reports the rain share")
+
+
+## F3 and F7 (same process): a guest due to leave in rain stays once, up to the rain end or 240 minutes.
+func _test_rain_stay_and_saves() -> void:
+	var rainy := _new_runtime(SEED_RAIN)
+	var runtime: Variant = rainy[&"runtime"]
+	var guest: Variant = _spawn(runtime, &"p07_rain_guest", &"traveler", 362)
+	# Spawned 06:00, entering 06:01, deciding 06:02, first exit check at 06:03.
+	rainy[&"clock"].advance_minutes(3)
+	var hold: Dictionary = runtime.weather.get_rain_hold(&"p07_rain_guest")
+	_expect(hold == {"original_exit": 362, "extended_to": 602} and guest.planned_exit_at == 602, "a guest due at 06:02 in rain stays to 10:02 (+240, before the rain end 12:00) (%s)" % str(hold))
+	_expect(guest.exit_reason != &"PLANNED_EXIT", "the held guest did not leave at its first plan")
+	_expect(not runtime.call("_hold_guest_for_rain", guest, 400), "a guest is held only once")
+	var late: Variant = _spawn(runtime, &"p07_late_guest", &"traveler", 650)
+	_expect(runtime.call("_hold_guest_for_rain", late, 650) and late.planned_exit_at == 720, "a guest due at 10:50 stays to the rain end 12:00")
+	var saved: Dictionary = runtime.create_snapshot()
+	_expect(runtime.restore_snapshot(saved) and runtime.create_snapshot() == saved, "rain, holds and the stream restore exactly in the same process")
+	var path := "user://tests/p07_weather_%d" % OS.get_process_id()
+	var weather_before: Dictionary = runtime.weather.create_snapshot()
+	var stream_before: Dictionary = runtime.get_rng_stream(&"weather").snapshot()
+	_expect(bool(runtime.save_to_path(path).get(&"ok", false)) and bool(runtime.load_from_path(path).get(&"ok", false))
+		and runtime.weather.create_snapshot() == weather_before and runtime.get_rng_stream(&"weather").snapshot() == stream_before
+		and runtime.guest_service.get_guest(&"p07_late_guest").planned_exit_at == 720, "an ordinary save file restores rain, holds and the weather stream")
+	SaveService.delete_save(path)
+	# The ordinary save operation records its own lifecycle; later checks compare with the loaded state.
+	saved = runtime.create_snapshot()
+	for bad_hold: Dictionary in [{"original_exit": 362, "extended_to": 603}, {"original_exit": 362, "extended_to": 362}]:
+		var malformed := saved.duplicate(true)
+		malformed[&"systems"][&"runtime"][&"weather"][&"rain_holds"]["p07_rain_guest"] = bad_hold
+		_expect(not runtime.restore_snapshot(malformed) and runtime.create_snapshot() == saved, "a hold beyond 240 minutes or not extending is refused atomically (%s)" % str(bad_hold))
+	var ghost := saved.duplicate(true)
+	ghost[&"systems"][&"runtime"][&"weather"][&"rain_holds"]["nobody"] = {"original_exit": 400, "extended_to": 500}
+	_expect(not runtime.restore_snapshot(ghost) and runtime.create_snapshot() == saved, "a hold of a missing guest is refused atomically")
+	var unmatched := saved.duplicate(true)
+	unmatched[&"systems"][&"runtime"][&"weather"][&"rain_holds"]["p07_late_guest"] = {"original_exit": 650, "extended_to": 700}
+	_expect(not runtime.restore_snapshot(unmatched) and runtime.create_snapshot() == saved, "a hold that differs from the guest plan is refused atomically")
+	var clear_runtime: Variant = _new_runtime(SEED_CLEAR)[&"runtime"]
+	var dry: Variant = _spawn(clear_runtime, &"p07_dry_guest", &"traveler", 361)
+	_expect(not clear_runtime.call("_hold_guest_for_rain", dry, 361) and dry.planned_exit_at == 361, "no hold without rain")
+	_expect(clear_runtime.weather.schedule(&"storm", 361)[&"ok"], "schedule a storm")
+	clear_runtime.weather.advance_to(361)
+	_expect(not clear_runtime.call("_hold_guest_for_rain", dry, 361), "no hold in a storm")
+	var fog_runtime: Variant = _new_runtime(SEED_FOG)[&"runtime"]
+	var misty: Variant = _spawn(fog_runtime, &"p07_fog_due_guest", &"traveler", 361)
+	_expect(fog_runtime.weather.get_kind() == &"mana_fog" and not fog_runtime.call("_hold_guest_for_rain", misty, 361) and misty.planned_exit_at == 361, "no hold in mana fog")
+
+
+## F3: after its hold the guest leaves by the current rule. A guest without a
+## suitable facility leaves at its next decision, so the ordinary decision step
+## itself runs at the extended time: it is not held again and begins leaving
+## with the ordinary PLANNED_EXIT.
+func _test_rain_hold_exit() -> void:
+	var natural := _new_runtime(SEED_RAIN)
+	var natural_runtime: Variant = natural[&"runtime"]
+	var departing: Variant = _spawn(natural_runtime, &"p07_departing_guest", &"traveler", 362)
+	natural[&"clock"].advance_minutes(3)
+	_expect(natural_runtime.weather.get_rain_hold(&"p07_departing_guest") == {"original_exit": 362, "extended_to": 602} and departing.state == GuestRuntime.State.LEAVING
+		and departing.exit_reason == &"NO_SUITABLE_FACILITY", "in ordinary minutes the held guest still leaves by the current rules")
+	natural[&"clock"].advance_minutes(1)
+	var departed: Dictionary = natural_runtime.create_snapshot()
+	_expect(natural_runtime.guest_service.get_guest(&"p07_departing_guest") == null and natural_runtime.weather.get_rain_holds().is_empty()
+		and natural_runtime.restore_snapshot(departed) and natural_runtime.create_snapshot() == departed, "the hold leaves with the guest, so the minute it left restores")
+	var rainy := _new_runtime(SEED_RAIN)
+	var runtime: Variant = rainy[&"runtime"]
+	var guest: Variant = _spawn(runtime, &"p07_exit_guest", &"traveler", 362)
+	rainy[&"clock"].advance_minutes(2)
+	_expect(guest.state == GuestRuntime.State.DECIDING and runtime.weather.get_kind() == &"rain", "the guest decides at 06:02 in rain")
+	_expect(runtime.call("_hold_guest_for_rain", guest, 362) and guest.planned_exit_at == 602 and runtime.weather.get_rain_hold(&"p07_exit_guest") == {"original_exit": 362, "extended_to": 602}, "the rain holds the guest due at 06:02 to 10:02")
+	runtime.call("_advance_guest_ai_decisions", 602)
+	_expect(guest.exit_reason == &"PLANNED_EXIT" and guest.state == GuestRuntime.State.LEAVING and guest.planned_exit_at == 602, "at 10:02 the held guest's decision begins leaving with PLANNED_EXIT (%s)" % String(guest.exit_reason))
+
+
+## F4: natural storm keeps zero new arrivals.
+func _test_storm() -> void:
+	var stormy := _new_runtime(SEED_STORM)
+	var runtime: Variant = stormy[&"runtime"]
+	_expect(runtime.weather.get_kind() == &"storm" and String(runtime.weather.get_today_draw().get("kind", "")) == "storm" and int(runtime.weather.get_today_draw().get("end", -1)) == 480, "seed 2501 opens day 0 with a natural storm 06:00-08:00")
+	_expect(runtime.enable_production_operations()[&"ok"], "enable production arrivals in the storm")
+	var capture: Dictionary = runtime.call("_operations_arrival_boundary", {}, OperationsCoordinator.PHASE_CAPTURE, null)
+	_expect(int(capture[&"capacity_remaining"]) == 0, "a natural storm exposes zero admission capacity")
+	var spawned := {&"count": 0}
+	runtime.guest_service.guest_spawned.connect(func(_guest: GuestRuntime) -> void: spawned[&"count"] += 1)
+	stormy[&"clock"].advance_minutes(119)
+	_expect(spawned[&"count"] == 0 and runtime.weather.get_kind() == &"storm", "no new guest enters during the natural storm")
+	stormy[&"clock"].advance_minutes(1)
+	_expect(runtime.weather.get_kind() == &"clear", "the storm returns to clear at 08:00")
+
+
+## F5: mana fog x1.2 world tree and furnace yield (floor), adult intimacy increase x1.5 (floor).
+func _test_mana_fog() -> void:
+	var foggy := _new_runtime(SEED_FOG)
+	var fog_runtime: Variant = foggy[&"runtime"]
+	var clear_side := _new_runtime(SEED_CLEAR)
+	var clear_runtime: Variant = clear_side[&"runtime"]
+	_expect(fog_runtime.weather.get_kind() == &"mana_fog" and int(fog_runtime.weather.get_today_draw().get("end", -1)) == 600, "seed 1592 opens day 0 with mana fog 06:00-10:00")
+	_expect(int(fog_runtime.get_mana_reserve_report()[&"generation"]) == 24 and int(clear_runtime.get_mana_reserve_report()[&"generation"]) == 20, "the reserve report shows yield 24 in fog and 20 in clear")
+	foggy[&"clock"].advance_minutes(10)
+	clear_side[&"clock"].advance_minutes(10)
+	_expect(int(fog_runtime.mana_reserve.get_last_flow().get(&"generation", -1)) == 24 and int(clear_runtime.mana_reserve.get_last_flow().get(&"generation", -1)) == 20, "the 06:10 boundary adds 24 in fog and 20 in clear")
+	var fog_saved: Dictionary = fog_runtime.create_snapshot()
+	_expect(fog_runtime.restore_snapshot(fog_saved) and fog_runtime.create_snapshot() == fog_saved, "a fog boundary flow restores")
+	var reserve := ManaReserveCycle.new()
+	var bad_reserve: Dictionary = fog_saved[&"systems"][&"runtime"][&"mana_reserve"].duplicate(true)
+	bad_reserve[&"last_flow"][&"generation"] = 23
+	_expect(not reserve.restore_snapshot(bad_reserve), "a yield that is neither 20 nor 24 is refused")
+	_expect(ManaReserveCycle.furnace_offer_accepted(160, 0) and not ManaReserveCycle.furnace_offer_accepted(160, 0, ManaReserveCycle.FOG_WORLD_TREE_GENERATION, ManaReserveCycle.FOG_FURNACE_YIELD), "a fog boundary judges the furnace with yield 24 and 120")
+	_expect(int(ManaReserveCycle.plan(100, 0, ManaReserveCycle.FOG_FURNACE_YIELD, 0, 10, ManaReserveCycle.FOG_WORLD_TREE_GENERATION)[&"after"]) == 244 and int(ManaReserveCycle.plan(200, 0, 120, 0, 10, 24)[&"after"]) == 300, "a fog furnace adds 120 and capacity 300 stays")
+	foggy[&"clock"].advance_minutes(230)
+	_expect(fog_runtime.weather.get_kind() == &"clear" and int(fog_runtime.mana_reserve.get_last_flow().get(&"generation", -1)) == 20, "after the fog the yield is 20 again")
+	var adult: Variant = _spawn(fog_runtime, &"p07_adult", &"adventurer", 2000)
+	var minor: Variant = _spawn(fog_runtime, &"p07_other", &"traveler", 2000)
+	var fog_report: Dictionary = fog_runtime.guest_service.update_needs(&"p07_adult", {&"intimacy_day": 3, &"mana_fog": true})
+	var plain_report: Dictionary = fog_runtime.guest_service.update_needs(&"p07_adult", {&"intimacy_day": 3, &"mana_fog": false})
+	var other_report: Dictionary = fog_runtime.guest_service.update_needs(&"p07_other", {&"intimacy_day": 3, &"mana_fog": true})
+	var down_report: Dictionary = fog_runtime.guest_service.update_needs(&"p07_adult", {&"need_effects": {&"intimacy": -4}, &"mana_fog": true})
+	_expect(int(fog_report[&"deltas"]["intimacy"]) == 4 and int(plain_report[&"deltas"]["intimacy"]) == 3, "fog raises an adult-verified increase of 3 to floor(4.5) = 4")
+	_expect(int(other_report[&"deltas"]["intimacy"]) == 0 and int(down_report[&"deltas"]["intimacy"]) == -4, "fog leaves guests without adult verification and decreases unchanged")
+	_expect(not fog_runtime.guest_service.update_needs(&"p07_adult", {&"mana_fog": 1})[&"ok"], "a non-boolean fog context is refused")
+	var vital_fog := _new_runtime(SEED_FOG)
+	var vital_clear := _new_runtime(SEED_CLEAR)
+	var fog_guest: Variant = _spawn(vital_fog[&"runtime"], &"p07_fog_adult", &"adventurer", 2000)
+	var clear_guest: Variant = _spawn(vital_clear[&"runtime"], &"p07_clear_adult", &"adventurer", 2000)
+	vital_fog[&"clock"].advance_minutes(1)
+	vital_clear[&"clock"].advance_minutes(1)
+	_expect(int(fog_guest.needs[&"intimacy"]) == 4 and int(clear_guest.needs[&"intimacy"]) == 3, "the ordinary minute raises intimacy by 4 in fog and 3 in clear (day)")
+	_expect(adult != null and minor != null, "fog guests exist")
+
+
+## F1 and F7: a pre-natural save migrates without a past draw; malformed natural state is refused.
+func _test_migration_and_rejection() -> void:
+	var opened := _new_runtime(SEED_RAIN)
+	var runtime: Variant = opened[&"runtime"]
+	opened[&"clock"].advance_minutes(5)
+	var saved: Dictionary = runtime.create_snapshot()
+	var legacy := saved.duplicate(true)
+	var legacy_weather: Dictionary = legacy[&"systems"][&"runtime"][&"weather"]
+	legacy_weather.erase(&"natural")
+	legacy_weather.erase(&"rain_holds")
+	legacy_weather[&"version"] = 1
+	legacy[&"systems"][&"runtime"][&"rng_streams"].erase("weather")
+	_expect(runtime.restore_snapshot(legacy), "a version 1 weather save without the weather stream loads")
+	_expect(runtime.weather.get_kind() == &"rain" and runtime.weather.get_last_draw_day() == 0 and runtime.weather.get_today_draw().is_empty() and runtime.weather.get_rain_holds().is_empty(), "the migration keeps the current weather and does not draw for the past")
+	_expect(runtime.get_rng_stream(&"weather").snapshot() == DeterministicRng.from_root_seed(SEED_RAIN, &"weather").snapshot(), "the migrated weather stream starts from the world seed")
+	var migrated: Dictionary = runtime.create_snapshot()
+	var missing_stream := saved.duplicate(true)
+	missing_stream[&"systems"][&"runtime"][&"rng_streams"].erase("weather")
+	_expect(not runtime.restore_snapshot(missing_stream) and runtime.create_snapshot() == migrated, "a natural-weather save without its stream is refused atomically")
+	var wrong_day := saved.duplicate(true)
+	wrong_day[&"systems"][&"runtime"][&"weather"][&"natural"][&"last_draw_day"] = 1
+	_expect(not runtime.restore_snapshot(wrong_day) and runtime.create_snapshot() == migrated, "a draw day after the saved minute is refused atomically")
+	var unknown_kind := saved.duplicate(true)
+	unknown_kind[&"systems"][&"runtime"][&"weather"][&"natural"][&"today"]["kind"] = "snow"
+	_expect(not runtime.restore_snapshot(unknown_kind) and runtime.create_snapshot() == migrated, "an unknown drawn kind is refused atomically")
+	var overlap := saved.duplicate(true)
+	overlap[&"systems"][&"runtime"][&"weather"][&"pending"] = [{"kind": "storm", "minute": 700}, {"kind": "clear", "minute": 700}]
+	_expect(not runtime.restore_snapshot(overlap) and runtime.create_snapshot() == migrated, "overlapping weather changes are refused atomically")
+	# The saved rain draw of seed 1106 (roll 60-84, slot 0, 06:00-12:00) changed in one field
+	# each: a roll of a clear day, a slot that does not match the start, a wrong duration.
+	var today: Dictionary = saved[&"systems"][&"runtime"][&"weather"][&"natural"][&"today"]
+	_expect(NaturalWeather.is_consistent_draw(today) and String(today["kind"]) == "rain" and int(today["slot"]) == 0, "the saved opening draw follows the draw rule")
+	for change: Dictionary in [{"roll": 10}, {"slot": 1}, {"end": 700}]:
+		var inconsistent := saved.duplicate(true)
+		var drawn: Dictionary = inconsistent[&"systems"][&"runtime"][&"weather"][&"natural"][&"today"]
+		for key: String in change:
+			drawn[key] = change[key]
+		_expect(not runtime.restore_snapshot(inconsistent) and runtime.create_snapshot() == migrated, "an internally inconsistent saved draw is refused atomically (%s)" % str(change))
+
+
+## F6: the ordinary Main HUD shows the weather, the forecast and the effect guidance.
+func _test_hud_forecast() -> void:
+	var clock: Variant = root.get_node("GameClock")
+	var state: Variant = root.get_node("GameState")
+	var runtime: Variant = root.get_node("SimulationRuntime")
+	clock.reset(1, 6, 0)
+	state.reset()
+	_expect(runtime.initialize(clock, state, SEED_RAIN)[&"valid"], "initialize the ordinary Runtime with seed 1106")
+	clock.set_paused(true)
+	var main := load("res://scenes/main/main.tscn").instantiate() as Control
+	main.set("manual_save_path", "user://tests/p07_weather_main_%d/manual_ui" % OS.get_process_id())
+	root.add_child(main)
+	await process_frame
+	await process_frame
+	main.call("_refresh_dashboard")
+	var weather_label := main.get("weather_label") as Label
+	var forecast_label := main.get("weather_forecast_label") as Label
+	var report: Dictionary = runtime.get_weather_report()
+	_expect(weather_label.text == "雨" and report[&"kind"] == &"rain", "HUD shows the Runtime rain")
+	_expect(forecast_label != null and forecast_label.text == "次: 晴れ 12:00" and report[&"next_change"] == {&"kind": &"clear", &"minute": 720}, "HUD forecast shows the next change from the Runtime (%s)" % (forecast_label.text if forecast_label != null else "none"))
+	_expect(String(report[&"effect_text"]) in weather_label.tooltip_text and "新規来客が半分" in weather_label.tooltip_text, "HUD guidance explains the rain effect")
+	clock.advance_minutes(360)
+	main.call("_refresh_dashboard")
+	_expect(weather_label.text == "晴れ" and forecast_label.text == "次: 予定なし" and "影響はありません" in weather_label.tooltip_text, "HUD follows the end of the rain")
+	var now: int = clock.absolute_minute
+	_expect(runtime.weather.schedule(&"storm", now + 1)[&"ok"] and runtime.weather.schedule(&"mana_fog", now + 2)[&"ok"], "schedule a storm and then mana fog on the ordinary Runtime")
+	clock.advance_minutes(1)
+	main.call("_refresh_dashboard")
+	report = runtime.get_weather_report()
+	var fog_minute := posmod(now + 2, 1440)
+	_expect(weather_label.text == "嵐" and report[&"kind"] == &"storm" and String(report[&"effect_text"]) in weather_label.tooltip_text and "新規来客はありません" in weather_label.tooltip_text, "HUD shows the storm and its guidance")
+	_expect(forecast_label.text == "次: マナ霧 %02d:%02d" % [fog_minute / 60, fog_minute % 60], "HUD forecast shows the next change to mana fog (%s)" % forecast_label.text)
+	clock.advance_minutes(1)
+	main.call("_refresh_dashboard")
+	report = runtime.get_weather_report()
+	_expect(weather_label.text == "マナ霧" and report[&"kind"] == &"mana_fog" and String(report[&"effect_text"]) in weather_label.tooltip_text
+		and "1.2倍" in weather_label.tooltip_text and "1.5倍" in weather_label.tooltip_text and not "炉" in weather_label.tooltip_text, "HUD shows the mana fog and its guidance without a furnace claim")
+	var teardown: Dictionary = await AudioTeardown.free_owner_and_wait(self, main)
+	_expect(bool(teardown.get(&"passed", false)) and not bool(teardown.get(&"deadline_reached", true)), "owned audio references release before bounded teardown deadline with whole Runtime unchanged")
+
+
+func _expect(condition: bool, message: String) -> void:
+	_checks += 1
+	if condition:
+		return
+	_failures += 1
+	push_error(message)

tests/environment/test_p07_weather_runtime.gd.uid

@@ -0,0 +1 @@
+uid://bsaoksmz5s26w

tests/environment/test_runtime_weather.gd

@@ -20,10 +20,15 @@ func run() -> void:
 	legacy[&"systems"][&"runtime"].erase(&"weather")
 	legacy[&"systems"][&"runtime"].erase(&"facility_cleanliness")
 	expect(runtime.restore_snapshot(legacy) and runtime.weather.get_kind() == &"clear" and runtime.weather.get_minute() == 360, "v10 migrates to neutral weather at saved minute")
-	expect(runtime.create_snapshot() == original, "old neutral save migration preserves other state")
+	# P07-01 (A13): the original carries the opening day's natural draw, which a
+	# pre-weather save never had; every other system must stay byte-equal.
+	var migrated: Dictionary = runtime.create_snapshot()
+	var migrated_rest: Dictionary = migrated.duplicate(true); migrated_rest[&"systems"][&"runtime"].erase(&"weather")
+	var original_rest: Dictionary = original.duplicate(true); original_rest[&"systems"][&"runtime"].erase(&"weather")
+	expect(migrated_rest == original_rest and runtime.weather.get_last_draw_day() == -1 and runtime.weather.get_today_draw().is_empty(), "old neutral save migration preserves other state")
 	var malformed := original.duplicate(true)
 	malformed[&"systems"][&"runtime"][&"weather"][&"minute"] = 361
-	expect(not runtime.restore_snapshot(malformed) and runtime.create_snapshot() == original, "future weather clock rejects atomically")
+	expect(not runtime.restore_snapshot(malformed) and runtime.create_snapshot() == migrated, "future weather clock rejects atomically")
 	malformed = original.duplicate(true)
 	malformed[&"systems"][&"runtime"].erase(&"weather")
 	expect(not runtime.restore_snapshot(malformed), "new schema cannot silently lose weather")

tests/environment/test_weather_recovery.gd

@@ -32,7 +32,11 @@ func run() -> void:
 	var completed: Dictionary = runtime.create_snapshot()
 	expect(runtime.restore_snapshot(completed) and runtime.create_snapshot() == completed, "completed retry restores exactly")
 	clock.advance_minutes(30)
-	expect(runtime.weather.get_kind() == &"clear" and runtime.weather.create_snapshot()[&"pending"].is_empty(), "disk-restored recovery occurs once at scheduled minute")
+	# P07-01 (A13): only the opening day's natural draw may remain scheduled.
+	var today: Dictionary = runtime.weather.get_today_draw()
+	var natural_pending: Array = [] if String(today.get("kind", "clear")) == "clear" else [
+		{&"kind": StringName(today["kind"]), &"minute": int(today["start"])}, {&"kind": &"clear", &"minute": int(today["end"])}]
+	expect(runtime.weather.get_kind() == &"clear" and runtime.weather.create_snapshot()[&"pending"] == natural_pending, "disk-restored recovery occurs once at scheduled minute")
 	expect(not runtime.get_operations_report()[&"runtime_failure_latched"], "recovery resumes ordinary operations")
 	expect(SaveService.delete_save(path), "delete isolated test save")
 	runtime.free(); clock.free(); state.free()

tests/environment/test_weather_timeline.gd

@@ -32,7 +32,7 @@ func _initialize() -> void:
 	for field: String in ["version", "minute", "kind", "since", "pending"]:
 		var bad := baseline.duplicate(true); bad.erase(field)
 		expect(not weather.restore_snapshot(bad) and weather.create_snapshot() == baseline, "missing field rejects atomically: " + field)
-	for change: Dictionary in [{"version": 2}, {"minute": 380.0}, {"kind": "snow"}, {"since": 381}, {"pending": [{"kind":"clear","minute":380}]}, {"pending": [{"kind":"clear","minute":400},{"kind":"rain","minute":390}]}, {"extra":true}]:
+	for change: Dictionary in [{"version": 3}, {"minute": 380.0}, {"kind": "snow"}, {"since": 381}, {"pending": [{"kind":"clear","minute":380}]}, {"pending": [{"kind":"clear","minute":400},{"kind":"rain","minute":390}]}, {"extra":true}]:
 		var bad := baseline.duplicate(true)
 		bad.merge(change, true)
 		expect(not weather.restore_snapshot(bad) and weather.create_snapshot() == baseline, "malformed or contradictory state rejects atomically")

tests/helpers/p07_weather_restart_fixture.gd

@@ -0,0 +1,151 @@
+extends RefCounted
+
+## P07-01 F7: the fixture and minute script shared by the restart writer
+## (tests/environment/test_p07_weather_restart_1_write.gd) and reader
+## (tests/environment/test_p07_weather_restart_2_read.gd), which run as separate
+## engine processes. Seed 1106 opens day 0 with rain 06:00-12:00 (A13), a guest
+## due at 06:02 is held to 10:02, production arrivals run, and day 1 draws at 06:00.
+## With no facility in this world the held guest starts leaving at 06:03 (still
+## present with its hold) and is gone at 06:04 (its hold leaves with it).
+## The fog scene (WX7): seed 1592 opens day 0 with mana fog 06:00-10:00, two
+## adult-verified guests arrive at 06:58 and 09:58 (with no facility in this
+## world a guest leaves after a few minutes, so each one is present at its
+## saves), and the saves bracket the 07:00 mana boundary and the fog end.
+const HANDOFF_PATH := "res://artifacts/p07-01/restart-handoff.json"
+const HANDOFF_SCHEMA := "p07-01-restart-handoff-v2"
+const WRITER_SOURCE := "res://tests/environment/test_p07_weather_restart_1_write.gd"
+const WRITER_SAVE := "user://p07_restart_write/minute_%d"
+const READER_SAVE := "user://p07_restart_read/minute_%d"
+const SEED := 1106
+const FIRST_MINUTE := 360
+# The held guest present with its hold, the minute it left, mid-rain, just before and
+# just after the rain end, just before and just after the day 1 draw.
+const SAVE_MINUTES: Array[int] = [363, 364, 500, 719, 720, 1799, 1800]
+const HOLD := {"original_exit": 362, "extended_to": 602}
+const LAST_MINUTE := 1830
+const DRAW_MINUTES: Array[int] = [1800]
+const HELD_GUEST := &"p07_restart_guest"
+const FOG_SEED := 1592
+const FOG_WRITER_SAVE := "user://p07_restart_write/fog_minute_%d"
+const FOG_READER_SAVE := "user://p07_restart_read/fog_minute_%d"
+# Just before, at and after the 07:00 mana boundary in fog; just before, at and after the fog end.
+const FOG_SAVE_MINUTES: Array[int] = [419, 420, 421, 599, 600, 601]
+const FOG_LAST_MINUTE := 630
+const FOG_ADULTS := {418: &"p07_restart_fog_adult_a", 598: &"p07_restart_fog_adult_b"}
+
+var _expect: Callable
+
+
+func _init(expect: Callable) -> void:
+	_expect = expect
+
+
+func new_fixture(with_guest := true, seed := SEED) -> Dictionary:
+	var clock: Variant = load("res://autoload/game_clock.gd").new()
+	var state: Variant = load("res://autoload/game_state.gd").new()
+	var runtime: Variant = load("res://autoload/simulation_runtime.gd").new()
+	clock.reset(1, 6, 0)
+	state.reset()
+	_expect.call(bool(runtime.initialize(clock, state, seed).get(&"valid", false)), "fixture Runtime initializes")
+	clock.set_paused(true)
+	runtime.configure_save_policy({&"enabled": false, &"daily_checkpoint_enabled": false})
+	_expect.call(bool(runtime.enable_production_operations().get(&"ok", false)), "fixture enables production Operations")
+	var fixture := {&"clock": clock, &"state": state, &"runtime": runtime, &"draws": {&"count": 0}, &"seed": seed}
+	if with_guest and seed == SEED:
+		var result: CommandResult = runtime.submit_command(&"spawn_guest", {
+			&"guest_id": HELD_GUEST,
+			&"guest_type_id": &"traveler",
+			&"gold": 100,
+			&"options": {
+				&"current_cell": Vector3i(0, 0, WorldService.LAYER_FRONT),
+				&"needs": {&"hunger": 10, &"sleep": 10, &"hygiene": 10, &"medical": 0, &"leisure": 10, &"intimacy": 0},
+				&"planned_exit_at": 362,
+			},
+		}, &"world", HELD_GUEST, 10, -1, &"p07.restart.guest")
+		_expect.call(result.is_success(), "fixture spawns the guest due at 06:02")
+	watch_draws(fixture)
+	return fixture
+
+
+func watch_draws(fixture: Dictionary) -> void:
+	var draws: Dictionary = fixture[&"draws"]
+	fixture[&"runtime"].domain_events.subscribe(&"WEATHER_FORECAST_DRAWN", &"p07_restart",
+		func(_event: SimulationDomainEvent) -> void: draws[&"count"] += 1)
+
+
+func free_fixture(fixture: Dictionary) -> void:
+	for key: StringName in [&"runtime", &"clock", &"state"]:
+		if fixture.get(key) != null and is_instance_valid(fixture[key]):
+			fixture[key].free()
+
+
+## Advances one minute at a time after `after_minute` through `through_minute`
+## and calls `on_minute` after each minute (the writer saves there). In the fog
+## scene the adult-verified guests arrive at their minutes in every run.
+func play(fixture: Dictionary, after_minute: int, through_minute: int, on_minute: Callable) -> void:
+	var clock: Variant = fixture[&"clock"]
+	_expect.call(clock.absolute_minute == after_minute, "play starts at minute %d" % after_minute)
+	for minute: int in range(after_minute + 1, through_minute + 1):
+		clock.advance_minutes(1)
+		if fixture[&"seed"] == FOG_SEED and FOG_ADULTS.has(minute):
+			_spawn_adult(fixture[&"runtime"], FOG_ADULTS[minute])
+		if on_minute.is_valid():
+			on_minute.call(minute)
+
+
+func _spawn_adult(runtime: Variant, guest_id: StringName) -> void:
+	var result: CommandResult = runtime.submit_command(&"spawn_guest", {
+		&"guest_id": guest_id,
+		&"guest_type_id": &"adventurer",
+		&"gold": 100,
+		&"options": {
+			&"current_cell": Vector3i(0, 0, WorldService.LAYER_FRONT),
+			&"needs": {&"hunger": 10, &"sleep": 10, &"hygiene": 10, &"medical": 0, &"leisure": 10, &"intimacy": 0},
+			&"planned_exit_at": 2000,
+		},
+	}, &"world", guest_id, 10, -1, StringName("p07.restart." + String(guest_id)))
+	_expect.call(result.is_success(), "the fog scene spawns the adult-verified guest %s" % guest_id)
+
+
+## The weather-facing state compared across processes: weather and its stream,
+## guest plans and needs (the fog intimacy), the whole reserve with its last
+## flow (the fog yield) and the arrival totals. Needs are listed in text order of
+## their names, because a loaded guest may keep its needs in another key order
+## (StringName ordering is not text ordering and differs between processes).
+func state_value(runtime: Variant) -> Dictionary:
+	var plans := {}
+	var needs := {}
+	for guest: GuestRuntime in runtime.guest_service.get_guests():
+		plans[String(guest.guest_id)] = guest.planned_exit_at
+		var names: Array[String] = []
+		for name: Variant in guest.needs:
+			names.append(String(name))
+		names.sort()
+		var row := {}
+		for name: String in names:
+			row[name] = guest.needs[name]
+		needs[String(guest.guest_id)] = row
+	var arrivals := 0
+	for report: Dictionary in runtime.operations_coordinator.get_arrival_reports():
+		arrivals += int(report[&"total_count"])
+	return {
+		"minute": runtime.weather.get_minute(),
+		"weather": runtime.weather.create_snapshot(),
+		"stream": runtime.get_rng_stream(&"weather").snapshot(),
+		"plans": plans,
+		"needs": needs,
+		"reserve": runtime.mana_reserve.create_snapshot(),
+		"reserve_flow": runtime.mana_reserve.get_last_flow(),
+		"arrivals": arrivals,
+	}
+
+
+func state_bytes(runtime: Variant) -> PackedByteArray:
+	return var_to_bytes(state_value(runtime))
+
+
+static func sha256(bytes: PackedByteArray) -> String:
+	var context := HashingContext.new()
+	context.start(HashingContext.HASH_SHA256)
+	context.update(bytes)
+	return context.finish().hex_encode()

tests/helpers/p07_weather_restart_fixture.gd.uid

@@ -0,0 +1 @@
+uid://bczrqi1qiv5zk

tools/regression/suite-policy.json

@@ -438,6 +438,28 @@
       "old_bounded_teardown": false,
       "new_audio_QA": false
     }
+,
+    "tests/environment/test_p07_weather_runtime.gd": {
+      "source_sha256": "e34b52ba3511f7391de1435c2f907997dd10235742ebc029831808af969c68e0",
+      "ordinary_cleanup_prepared": false,
+      "ordinary_control_labels": [],
+      "old_bounded_teardown": true,
+      "new_audio_QA": false
+    },
+    "tests/environment/test_p07_weather_restart_1_write.gd": {
+      "source_sha256": "d85e56dcf75535b19b1af615f8b75e010f4f3906a0e71afdf97102e1bfbffc65",
+      "ordinary_cleanup_prepared": false,
+      "ordinary_control_labels": [],
+      "old_bounded_teardown": false,
+      "new_audio_QA": false
+    },
+    "tests/environment/test_p07_weather_restart_2_read.gd": {
+      "source_sha256": "e5c2376e9cb3197d6a0a8d99c9dea020cad2648328178949cd188d999e72071a",
+      "ordinary_cleanup_prepared": false,
+      "ordinary_control_labels": [],
+      "old_bounded_teardown": false,
+      "new_audio_QA": false
+    }
   },
   "outside_routes": {
     "tests/supply/test_normal_auto_purchase_chain.gd": {
@@ -474,6 +496,9 @@
     "tests/economy/test_p05_funds_restart_1_write.gd": [
       "artifacts/p05-02/restart-handoff.json"
     ],
+    "tests/environment/test_p07_weather_restart_1_write.gd": [
+      "artifacts/p07-01/restart-handoff.json"
+    ],
     "tests/mvp/test_runtime_upkeep.gd": [
       "artifacts/upkeep-2026-09-29/preclose-snapshot.txt",
       "artifacts/upkeep-2026-09-29/closed-snapshot.txt"

tools/run_p07_weather_tests.py

@@ -0,0 +1,632 @@
+#!/usr/bin/env python3
+"""Root-owned narrow P07-01 (natural weather, rain, mana fog, storm, HUD forecast; A13) collection using the
+unchanged guarded phase protocol of tools/run_p05_funds_tests.py (itself the protocol of
+tools/run_p18_relationship_tests.py). After the roster, the F7 restart writer and reader suites run as two more
+phases (separate engine processes); the writer's only declared generated report is the save handoff the reader loads."""
+import argparse
+import hashlib
+import json
+import os
+import re
+import stat
+from pathlib import Path
+import shutil
+import sys
+import types
+import uuid
+
+sys.dont_write_bytecode = True
+import run_all_tests as shared
+
+ROSTER = [
+    'tests/environment/test_p07_weather_runtime.gd',
+    'tests/environment/test_runtime_weather.gd',
+    'tests/environment/test_weather_timeline.gd',
+    'tests/environment/test_weather_recovery.gd',
+    'tests/mvp/test_runtime_operations_integration.gd',
+    'tests/s2/test_runtime_operations_cycle.gd',
+    'tests/s2/test_runtime_mana_reserve.gd',
+    'tests/s2/test_mana_reserve_cycle.gd',
+    'tests/s3/test_guest_service.gd',
+    'tests/s6/test_runtime_save_lifecycle.gd',
+    'tests/s6/test_runtime_snapshot_serialization.gd',
+    'tests/ui/test_main_dashboard.gd',
+]
+# P07-01 F7 (SPEC section 8): the writer saves, the reader in the next phase's engine resumes.
+RESTART = [
+    'tests/environment/test_p07_weather_restart_1_write.gd',
+    'tests/environment/test_p07_weather_restart_2_read.gd',
+]
+HANDOFF = 'artifacts/p07-01/restart-handoff.json'
+SUITES = ROSTER + RESTART
+WRITER_LINE = r'(?m)^P07_RESTART_WRITER pid=([0-9]+) handoff_sha256=([0-9a-f]{64})$'
+READER_LINE = r'(?m)^P07_RESTART_READER pid=([0-9]+) writer_pid=([0-9]+) handoff_sha256=([0-9a-f]{64})$'
+
+
+def collect(args, root, out, refs, markers, contracts, policy, contract_path, contract_sha, parse_paths):
+    source_bytes = sum(pin['bytes'] for pin in refs.values())
+    free = shutil.disk_usage(out.parent).free
+    needed = source_bytes + shared.MIN_SPACE
+    shared.require(free >= needed, 'fresh source and phase disk admission')
+    outer = shared.module('p07_owned_outer', shared.SUPPORT / 'owned_outer.py')
+    shared.require(not outer.native.helper['live_engines'](), 'another Godot owns CPU')
+    engine = shutil.which('godot')
+    shared.require(engine and Path(engine).is_file(), 'native launcher exists')
+    engine = str(Path(engine).resolve())
+    out.mkdir(parents=True, exist_ok=False)
+    stage = out / 'stage'
+    stage.mkdir()
+    (out / 'starters').mkdir()
+    (out / 'bootstrap').mkdir()
+    for name, pin in shared.read(shared.SUPPORT / 'bootstrap-scripts.json').items():
+        data = pin['text'].encode('utf-8')
+        shared.require(hashlib.sha256(data).hexdigest() == pin['sha256'], 'unchanged external bootstrap bytes')
+        (out / 'bootstrap' / name).write_bytes(data)
+    protected = shared.default_player(root)
+    expected = {name: {'bytes': pin['bytes'], 'sha256': pin['sha256']} for name, pin in refs.items()}
+    selected = {'root_before': refs, 'map': {name: pin['sha256'] for name, pin in refs.items()}, 'timeout': args.timeout}
+    for name, pin in refs.items():
+        target = stage / name
+        target.parent.mkdir(parents=True, exist_ok=True)
+        shared.copy_source(Path(pin['path']), target)
+    shared.require(shared.inventory(stage, stage=True) == expected, 'complete private source copy')
+    public = (stage / 'project.godot').read_bytes()
+    shared.write(out / 'parse-paths.json', parse_paths)
+    run_id = uuid.uuid4().hex
+    shared.write(out / 'runner-input.json', dict(protocol='guarded-p07-01-v1', run_id=run_id,
+        owner_runner_pid=os.getpid(), project_root=str(root), stage=str(stage), roster=ROSTER,
+        restart_phases=RESTART, restart_handoff=HANDOFF,
+        selected_source_map=selected['map'], marker_contract_sha256=contract_sha,
+        runner_sha256=shared.sha(Path(__file__)), shared_runner_sha256=shared.sha(shared.HERE / 'run_all_tests.py'),
+        marker_module_sha256=shared.sha(shared.HERE / 'strict_test_markers.py'),
+        engine=engine, engine_sha256=shared.sha(engine), default_player_before=protected,
+        formal_acceptance=False, original_unit_complete=False))
+    shared.write(out / 'source-start.json', refs)
+    diagnostics = shared.module('p07_diagnostics', shared.SUPPORT / 'diagnostic_gate.py')
+    owners = shared.module('p07_owners', shared.SUPPORT / 'ordinary_proof_gate.py')
+    audio = shared.module('p07_audio', shared.SUPPORT / 'audio_evidence_gate.py')
+    phases, rows, previous = [], [], {}
+    error = None
+    try:
+        for phase, test in [('import', None), ('parse', None)] + [(str(i).zfill(3), name) for i, name in enumerate(SUITES)]:
+            shared.require(shared.sha(contract_path) == contract_sha, 'marker contract unchanged')
+            row = shared.execute_phase(engine, stage, out, phase, test, selected, expected, previous,
+                policy, contracts, parse_paths, public, protected, root, outer, markers, diagnostics, owners, audio)
+            archive_profiles(out, row)
+            phases.append(row)
+            if test:
+                row.update(sequence=len(rows), godot=engine)
+                rows.append(row)
+                (out / 'all-tests.json').write_text(json.dumps(rows, ensure_ascii=False, indent=2) + '\n')
+                print(('PASS ' if row['passed'] else 'FAIL ') + test, flush=True)
+            shared.require(row['passed'], 'first failed phase stops without retry: ' + phase)
+    except BaseException as caught:
+        error = type(caught).__name__ + ': ' + str(caught)
+    finally:
+        cleanup, cleanup_errors = outer.finish_captured(outer.OWNED)
+    guard_errors = []
+    try:
+        shared.require(shared.source_refs(root) == refs, 'whole source unchanged')
+        shared.require(shared.sha(contract_path) == contract_sha, 'marker contract unchanged at end')
+        shared.require(shared.default_player(root) == protected, 'default profile untouched')
+        shared.require(shared.inventory(stage, stage=True) == dict(expected, **previous), 'whole stage exact')
+    except BaseException as caught:
+        guard_errors.append(type(caught).__name__ + ': ' + str(caught))
+    ended = bool(outer.OWNED) and all(row['engine_ended'] is True for row in cleanup)
+    passed = error is None and not cleanup_errors and not guard_errors and ended and len(phases) == len(SUITES) + 2 and all(row['passed'] for row in phases)
+    context = shared.totals(rows, SUITES)
+    shared.write(out / 'runner-ended.json', dict(context, protocol='guarded-p07-01-v1', run_id=run_id,
+        owner_runner_pid=os.getpid(), passed=passed, engine_ended=ended,
+        actual_captured_PIDs=[process.pid for process in outer.OWNED], final_owned_cleanup=cleanup,
+        cleanup_errors=cleanup_errors, guard_errors=guard_errors, error=error, phases=phases,
+        all_tests_sha256=shared.sha(out / 'all-tests.json') if (out / 'all-tests.json').exists() else None,
+        default_player_after=shared.default_player(root), formal_acceptance=False,
+        original_unit_complete=False, independent_review='pending', native_Windows='pending'))
+    if passed:
+        seal(out, refs, engine, contract_sha)
+        # Root also exercises precisely the verifier that ordinary Runner uses.
+        verify(out, refs, markers, contracts, policy, contract_sha, parse_paths)
+    print(json.dumps(dict(context, passed=passed, error=error, cleanup_errors=cleanup_errors, guard_errors=guard_errors)), flush=True)
+    return 0 if passed else 1
+
+
+
+# Receipt file names are always relative; absolute paths in native receipts are
+# historical identity strings only and are never opened by the verifier.
+def require(ok, reason):
+    shared.require(ok, reason)
+
+
+def digest(value):
+    return hashlib.sha256(json.dumps(value, sort_keys=True, separators=(',', ':'),
+                                     ensure_ascii=False).encode()).hexdigest()
+
+
+def content_map(refs):
+    return {name: {'bytes': pin['bytes'], 'sha256': pin['sha256']}
+            for name, pin in refs.items()}
+
+
+def plain_path(path):
+    path = Path(path)
+    require('..' not in path.parts, 'parent traversal refused')
+    absolute = Path(os.path.abspath(path))
+    for part in [absolute, *absolute.parents]:
+        require(not part.is_symlink(), 'symlink path refused: ' + str(part))
+    return absolute
+
+
+def confined(out, name):
+    require(type(name) is str and name and '\\' not in name, 'ordinary relative evidence name')
+    path = Path(name)
+    require(not path.is_absolute() and '..' not in path.parts
+            and path.as_posix() == name and name != '.', 'evidence path escape or alias')
+    result = plain_path(out / path)
+    require(result.is_relative_to(out), 'evidence confined to output')
+    return result
+
+
+def inventory(out):
+    result = {}
+    require(out.is_dir(), 'output directory required')
+    for directory, dirs, files in os.walk(out, followlinks=False):
+        for name in dirs + files:
+            p = Path(directory) / name
+            mode = p.lstat().st_mode
+            require(stat.S_ISREG(mode) or stat.S_ISDIR(mode), 'nonordinary evidence refused')
+            if stat.S_ISREG(mode):
+                require(p.stat().st_nlink == 1, 'hardlinked evidence refused')
+                result[p.relative_to(out).as_posix()] = {
+                    'bytes': p.stat().st_size, 'sha256': shared.sha(p)}
+    return result
+
+
+def unique_object(pairs):
+    result = {}
+    for key, value in pairs:
+        require(key not in result, 'duplicate JSON key')
+        result[key] = value
+    return result
+
+
+def read_json(path):
+    return json.loads(path.read_text(encoding='utf-8'), object_pairs_hook=unique_object,
+                      parse_constant=lambda token: require(False, 'nonfinite JSON ' + token))
+
+
+def archive_profiles(out, row):
+    for label in ('startup', 'runtime'):
+        value = row.get('whole_' + label + '_profile_after')
+        if value is None:
+            continue
+        dest = out / 'profiles' / row['phase'] / label
+        dest.mkdir(parents=True, exist_ok=False)
+        source = plain_path(value['path'])
+        require(shared.inventory(source) == value['files'], 'whole owned profile before archive')
+        for name in value['files']:
+            target = confined(out, str((dest / name).relative_to(out)))
+            target.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copyfile(source / name, target)
+        require(shared.inventory(dest) == value['files'] == shared.inventory(source),
+                'whole owned profile archive exact')
+
+
+def seal(out, refs, engine, contract_sha):
+    # Last file written: an interrupted collection has no complete receipt.
+    shutil.copyfile(engine, out / 'engine.bin')
+    require(shared.sha(out / 'engine.bin') == shared.sha(engine), 'engine archive exact')
+    source = content_map(refs)
+    shared.write(out / 'receipt.json', {
+        'schema': 'guarded-p07-01-v1', 'source_map': source,
+        'parse_checks': len([name for name in refs if name.endswith('.gd')]),
+        'source_map_sha256': digest(source),
+        'project_settings_sha256': source['project.godot']['sha256'],
+        'marker_contract_sha256': contract_sha,
+        'engine_sha256': shared.sha(engine),
+        'files': inventory(out),
+    })
+
+
+def cleanup_gate(value):
+    require(value['owned_child_created'] is True and value['engine_ended'] is True
+            and value['actual_process_exit_code'] == 0 and value['errors'] == [],
+            'successful actual owned cleanup')
+    attempts = value['attempts']
+    require(1 <= len(attempts) <= 3, 'bounded cleanup attempts')
+    for index, row in enumerate(attempts):
+        require(row['attempt'] == index + 1 and row['errors'] == []
+                and row['wait_timeout_seconds'] == 5 and row['wait_completed'] is True
+                and row['wait_returned_code'] == 0 and row['poll_after'] == 0,
+                'complete bounded owned wait')
+
+
+def outer_cleanup(rows, pids):
+    require([r['pid'] for r in rows] == pids, 'exact captured cleanup PID order')
+    for row in rows:
+        require(row['engine_ended'] is True and row['outer_cleanup_errors'] == []
+                and row['foreign_process_or_group_signals'] == 0
+                and row['outer_maximum_helper_invocations'] == 3
+                and row['helper_maximum_waits'] == 3 and row['per_wait_timeout_seconds'] == 5,
+                'unchanged outer cleanup contract')
+        cleanup_gate(row['cleanup'])
+
+
+def verify(out, refs, markers, contracts, policy, contract_sha, parse_paths):
+    receipt_path = confined(out, 'receipt.json')
+    require(receipt_path.is_file(), 'regular final receipt required')
+    manifest = read_json(receipt_path)
+    require(manifest['schema'] == 'guarded-p07-01-v1', 'current receipt schema required')
+    files = manifest['files']
+    require(type(files) is dict and files, 'complete raw manifest')
+    for name, pin in files.items():
+        p = confined(out, name)
+        require(p.is_file() and set(pin) == {'bytes', 'sha256'}
+                and type(pin['bytes']) is int and pin['bytes'] >= 0
+                and re.fullmatch('[0-9a-f]{64}', pin['sha256']) is not None,
+                'ordinary artifact pin')
+    actual = inventory(out)
+    receipt_pin = actual.pop('receipt.json')
+    require(actual == files, 'complete raw file set and SHA-256 equality')
+    source = content_map(refs)
+    require(manifest['source_map'] == source and manifest['source_map_sha256'] == digest(source),
+            'current whole source content map independent of checkout path')
+    require(manifest['project_settings_sha256'] == source['project.godot']['sha256']
+            and manifest['marker_contract_sha256'] == contract_sha, 'current project/marker pins')
+
+    def read(name):
+        require(name in files, 'required raw file missing: ' + name)
+        return read_json(confined(out, name))
+
+    def text(name):
+        require(name in files, 'required raw transport missing: ' + name)
+        return confined(out, name).read_text(encoding='utf-8')
+
+    start, end = read('runner-input.json'), read('runner-ended.json')
+    require(start['protocol'] == end['protocol'] == 'guarded-p07-01-v1'
+            and start['run_id'] == end['run_id']
+            and re.fullmatch('[0-9a-f]{32}', start['run_id']) is not None,
+            'same current run')
+    require(type(start['owner_runner_pid']) is int and start['owner_runner_pid'] > 0
+            and start['owner_runner_pid'] == end['owner_runner_pid'], 'same collector owner')
+    require(start['roster'] == ROSTER and start['restart_phases'] == RESTART
+            and start['restart_handoff'] == HANDOFF and len(set(SUITES)) == len(SUITES),
+            'exact unique roster and restart tests')
+    require(start['selected_source_map'] == {n: p['sha256'] for n, p in source.items()}
+            and content_map(read('source-start.json')) == source, 'whole selected source pins')
+    for field, name in [('runner_sha256', 'tools/run_p07_weather_tests.py'),
+                        ('shared_runner_sha256', 'tools/run_all_tests.py'),
+                        ('marker_module_sha256', 'tools/strict_test_markers.py')]:
+        require(start[field] == source[name]['sha256'], 'current collector/shared/marker pin')
+    require(start['marker_contract_sha256'] == contract_sha, 'marker contract pin')
+    # Resolve only the locally configured launcher, never the receipt's engine path.
+    engine = shutil.which('godot')
+    require(engine and shared.sha(engine) == start['engine_sha256']
+            == manifest['engine_sha256'] == files['engine.bin']['sha256'],
+            'current native engine and retained bytes pinned')
+    derived_paths = ['res://' + name for name in sorted(refs) if name.endswith('.gd')]
+    require(read('parse-paths.json') == parse_paths == derived_paths
+            and manifest['parse_checks'] == len(derived_paths),
+            'all exact source parse paths and receipt count')
+    require(end['passed'] is True and end['engine_ended'] is True and end['error'] is None
+            and end['cleanup_errors'] == [] and end['guard_errors'] == [],
+            'finished successful collection without guard/cleanup error')
+    for receipt in (start, end):
+        require(receipt['formal_acceptance'] is False and receipt['original_unit_complete'] is False,
+                'backend evidence never completes original unit')
+    before = start['default_player_before']
+    require(before == end['default_player_after'] and before['logs_and_locks_included'] is True
+            and type(before['existed']) is bool and type(before['files']) is dict,
+            'complete default player before/after equality')
+    for name, pin in before['files'].items():
+        confined(out, name)  # Validate the inventory name; never open the player.
+        require(set(pin) == {'bytes', 'sha256'} and type(pin['bytes']) is int
+                and pin['bytes'] >= 0 and re.fullmatch('[0-9a-f]{64}', pin['sha256']),
+                'whole default player file pin')
+    require(before['existed'] or before['files'] == {}, 'absent player has no files')
+
+    native = shared.module('p07_verify_native', shared.SUPPORT / 'owned_diagnostic_process.py')
+    diagnostics = shared.module('p07_verify_diagnostics', shared.SUPPORT / 'diagnostic_gate.py')
+    owners = shared.module('p07_verify_owners', shared.SUPPORT / 'ordinary_proof_gate.py')
+    audio = shared.module('p07_verify_audio', shared.SUPPORT / 'audio_evidence_gate.py')
+    # Helpers are loaded for their pure gates only. No run/probe/cleanup is called.
+    origin = Path(start['stage']).parent
+    require(Path(start['stage']) == origin / 'stage' and origin.is_absolute()
+            and '..' not in origin.parts, 'original output identity')
+
+    def relocated(value):
+        if isinstance(value, dict):
+            return {relocated(k): relocated(v) for k, v in value.items()}
+        if isinstance(value, list):
+            return [relocated(v) for v in value]
+        if isinstance(value, str) and value.startswith(str(origin) + '/'):
+            return str(confined(out, value[len(str(origin)) + 1:]))
+        return value
+
+    def proof_read(path):
+        path = plain_path(path)
+        require(path.is_relative_to(out), 'proof path stays in output')
+        return relocated(read(path.relative_to(out).as_posix()))
+
+    owners.read = proof_read
+    # The bounded teardown gate parses its owner proof itself and pins the snapshots by their recorded
+    # absolute paths; this private module instance reads them relocated, as the ordinary gate does.
+    audio.json = types.SimpleNamespace(loads=lambda data: relocated(json.loads(data)))
+    phases = end['phases']
+    require(len(phases) == len(SUITES) + 2, 'exact import, parse, roster and restart phases')
+    tests = read('all-tests.json')
+    stage_files = shared.inventory(confined(out, 'stage'), stage=True)
+    require(set(stage_files) == set(source) | {HANDOFF}, 'retained stage is the source and the restart handoff')
+    handoff = stage_files[HANDOFF]
+    require(len(tests) == len(SUITES) and end['all_tests_sha256'] == files['all-tests.json']['sha256'],
+            'complete test rows')
+    pids = []
+    for index, (phase, test) in enumerate([('import', None), ('parse', None)]
+                                         + [(str(i).zfill(3), n) for i, n in enumerate(SUITES)]):
+        row = read(phase + '-receipt.json')
+        expected_row = dict(row)
+        if test:
+            expected_row.update(sequence=index - 2, godot=start['engine'])
+            require(tests[index - 2] == expected_row, 'test row matches raw phase receipt')
+        require(phases[index] == expected_row and row['phase'] == phase and row['test'] == test
+                and row['passed'] is True and row['failed'] is False
+                and row['validation_error'] is None and not row.get('guard_error')
+                and row['default_player_entire_profile_unchanged'] is True,
+                'exact successful phase')
+        # The same proof classification as the shared collector (tools/run_all_tests.py).
+        p = shared.phase_policy(test, Path(refs[test]['path']), policy['suite_policies']) if test else None
+        ordinary = bool(p) and p['ordinary_cleanup_prepared'] is True
+        bounded = bool(p) and p['old_bounded_teardown'] is True
+        pid = row['actual_pid']
+        require(type(pid) is int and pid > 0 and pid not in pids, 'distinct actual PIDs per phase')
+        pids.append(pid)
+        process = read(phase + '/process.json')
+        require(process == row['native_process'] and process['pid'] == pid
+                and process['owned_child_process_helper_sha256'] == native.HELPER_SHA
+                == source['tools/regression/p09_owned_engine_process.py']['sha256'],
+                'actual phase/process/helper agreement')
+        stdout, stderr, logger = (text(phase + '/' + n) for n in
+                                  ('stdout.log', 'stderr.log', 'engine-native.log'))
+        raw = stdout + stderr
+        require(text(row['log']) == raw and row['log_sha256'] == files[row['log']]['sha256'],
+                'literal complete raw stream')
+        require(process['stdout_sha256'] == files[phase + '/stdout.log']['sha256']
+                and process['stderr_sha256'] == files[phase + '/stderr.log']['sha256'],
+                'process transport SHA')
+        require(row['raw_native_log'] == dict(files[phase + '/engine-native.log'],
+                    path=str(origin / phase / 'engine-native.log')), 'native logger pin')
+        review = diagnostics.review_streams(native, {
+            'stdout': stdout, 'stderr': stderr, 'native_file': logger}, test)
+        require(row['finite_original_diagnostic_review'] == review
+                and diagnostics.diagnostic_result_gate(process, review)
+                and shared.process_gate(process, review['allowed_e31_error_lines']),
+                'strict diagnostics/process gates')
+        require(native.native_diagnostics(stdout, stderr, row['command'])
+                == process['strict_native_diagnostics'], 'raw banner/diagnostics recomputed')
+        command = [start['engine'], '--headless', '--path', start['stage']]
+        if phase == 'import':
+            command += ['--editor', '--import', '--quit', '--verbose']
+        else:
+            script = ('bootstrap/parse_full_dependencies.gd' if phase == 'parse'
+                      else 'starters/' + phase + '.gd')
+            command += ['--script', str(origin / script), '--verbose']
+            require(row['starter_sha256'] == files[script]['sha256'], 'exact starter pin')
+            if test:
+                expected_starter = ('extends ' + json.dumps('res://' + test) + '\nconst Guard := preload('
+                    + json.dumps(str(origin / 'bootstrap/profile_guard.gd'))
+                    + ')\nfunc _initialize() -> void:\n\tif not Guard.activate():\n\t\tquit(97)\n\t\treturn\n\tsuper._initialize()\n')
+                require(text(script) == expected_starter, 'unchanged guarded starter bytes')
+        command += ['--log-file', str(origin / phase / 'engine-native.log')]
+        require(row['command'] == process['argv'] == command, 'exact native argv/logger')
+        for filename, field, event in [('started.json', 'actual_start_binding', 'ENGINE_STARTED'),
+                                        ('ended.json', 'actual_end_binding', 'ENGINE_ENDED')]:
+            binding = read(phase + '/' + filename)
+            require(binding == process[field] and binding['event'] == event
+                    and binding['actual_pid'] == binding['pid'] == pid
+                    and binding['owner_pid'] == start['owner_runner_pid']
+                    and binding['command'] == binding['argv'] == command, 'actual START/END ownership')
+        binding = process['actual_start_binding']
+        identity = binding['current_process_identity']
+        if identity is None:
+            require(binding['tracked_child_ended_before_initial_probe'] is True, 'early ended tracked child')
+        else:
+            require(binding['live_identity_exact'] is True and identity == {
+                'pid': pid, 'ppid': start['owner_runner_pid'], 'pgid': pid, 'args': ' '.join(command)},
+                'recorded live child PID/PPID/PGID/argv')
+        finish = process['actual_end_binding']
+        require(finish['engine_ended'] is True and finish['timed_out'] is False
+                and finish['lifecycle_error'] is None and finish['exit_code'] == 0
+                and finish['actual_process_exit_code'] == 0
+                and finish['start_receipt_written'] is True
+                and finish['monotonic_ns'] >= binding['monotonic_ns'], 'complete native END')
+        cleanup = read(phase + '/adapter-owned-cleanup.json')
+        require(cleanup == process['adapter_owned_cleanup'], 'raw adapter cleanup')
+        cleanup_gate(cleanup)
+        capture = row['outer_actual_capture']
+        require(read(phase + '/outer-owned-finally.json') == {
+            k: v for k, v in capture.items()
+            if k not in ('outer_receipt_written', 'outer_receipt_error', 'passed')},
+            'whole raw outer receipt')
+        require(capture['actual_captured_pids'] == [pid] and capture['passed'] is True
+                and capture['all_captured_ended'] is True and capture['adapter_exception'] is None
+                and capture['outer_cleanup_errors'] == [] and capture['outer_receipt_error'] is None
+                and capture['outer_receipt_written'] is True
+                and capture['all_cleanup_before_outer_receipt'] is True
+                and capture['foreign_process_or_group_signals'] == 0
+                and row['engine_ended'] is True and row['exit_code'] == 0, 'owned outer capture')
+        outer_cleanup(capture['cleanup'], [pid])
+        startup = read(phase + '-startup-profile-before.json')
+        require(startup == {'path': row['whole_startup_profile_after']['path'], 'existed': False,
+                            'files': {}, 'before_native_spawn': True}, 'fresh startup profile')
+        require(row['whole_startup_profile_after']['fresh_before_engine'] is True,
+                'startup fresh before engine')
+        name = row['profile_startup_name']
+        require(re.fullmatch('TheTree-PCK-tests-[0-9a-f]{32}-standard-startup-' + phase, name)
+                and Path(startup['path']).name == name and row['private_project_fields'] == 2
+                and row['private_project_sha256'] == hashlib.sha256(shared.private_project(
+                    (shared.HERE.parent / 'project.godot').read_bytes(), name)).hexdigest(),
+                'exact two-field startup isolation')
+        for label in ('startup', 'runtime'):
+            if label == 'runtime' and phase == 'import':
+                continue
+            whole = row['whole_' + label + '_profile_after']
+            archive = confined(out, 'profiles/' + phase + '/' + label)
+            require(archive.is_dir() and shared.inventory(archive)
+                    == whole['files'], 'complete retained private profile')
+        if phase != 'import':
+            guard = read(phase + '-profile.json')
+            runtime = Path(row['whole_runtime_profile_after']['path'])
+            name = guard['custom_user_dir_name']
+            require(re.fullmatch('TheTree-PCK-tests-[0-9a-f]{32}-standard-runtime-' + phase, name)
+                    and runtime.name == name and guard['verified'] is True
+                    and guard['conditions'] == [True] * 5 and guard['conditions_checked'] == 5
+                    and guard['fresh_before_parent_initialize'] is True
+                    and guard['profile_writes_before_guard'] == 0
+                    and guard['actual_user_data_dir'] == guard['expected_user_data_dir'] == str(runtime)
+                    and guard['globalized_probe'] == str(runtime / 'guard-probe')
+                    and guard['project_settings_persisted'] is False, 'all unchanged Guard conditions')
+            require(row['actual_private_profile'] == {
+                'report': guard, 'report_sha256': files[phase + '-profile.json']['sha256'],
+                'whole_files': row['whole_runtime_profile_after']['files']}, 'whole raw Guard report')
+            require(row['controlled_environment'] == {
+                'THE_TREE_PACK_PROFILE_NAME': name, 'THE_TREE_PACK_PROFILE_EXPECTED': str(runtime),
+                'THE_TREE_PACK_PROFILE_REPORT': str(origin / (phase + '-profile.json')),
+                'THE_TREE_FULL_PARSE_PATHS': str(origin / 'parse-paths.json'),
+                **({'THE_TREE_AUDIO_TEARDOWN_PROOF_DIR': str(origin / (phase + '-teardown/owned-audio')),
+                    'THE_TREE_AUDIO_FIXTURE_CONTROL_PROOF': str(origin / (phase + '-teardown/control.json'))}
+                   if ordinary else {'THE_TREE_AUDIO_TEARDOWN_PROOF_DIR': str(origin / (phase + '-teardown'))}
+                   if bounded else {})},
+                'exact controlled Guard/proof environment')
+        else:
+            require(row['controlled_environment'] == {}, 'fresh import environment')
+        if phase == 'parse':
+            require(len(re.findall(r'(?m)^FULL_DEPENDENCY_PARSE\b', raw)) == 1
+                    and re.findall(r'(?m)^FULL_DEPENDENCY_PARSE checks=([0-9]+) failures=([0-9]+)\n', raw)
+                    == [(str(len(parse_paths)), '0')] and row['actual_parse_checks'] == len(parse_paths), 'unique all-script parse marker')
+        if test:
+            parsed = markers.parse_raw(test, raw, contracts, source[test]['sha256'])
+            require(parsed['passed'] and row['completion'] == parsed
+                    and row['reported_checks'] == parsed['checks']
+                    and row['reported_failures'] == parsed['failures']
+                    and row['completion_marker'] == parsed['marker'] and row['collector_errors'] == [],
+                    'source-pinned raw completion marker')
+            require(row['source_sha256'] == row['source_sha256_end'] == source[test]['sha256'],
+                    'exact test source before/after')
+            require(row['policy'] == p, 'current exact suite policy')
+            if ordinary:
+                proof = owners.ordinary_gate(confined(out, phase + '-teardown'), pid, out,
+                                             p['ordinary_control_labels'])
+                require(proof == relocated(row['ordinary_owner_pairs']), 'full ordinary/audio ownership proof')
+            if bounded:
+                proof = audio.teardown_gate(confined(out, phase + '-teardown'), pid, out)
+                require(proof == relocated(row['old_bounded_proof']), 'full bounded audio teardown proof')
+        require(('ordinary_owner_pairs' in row) == ordinary and ('old_bounded_proof' in row) == bounded
+                and any(name.startswith(phase + '-teardown/') for name in files) == (ordinary or bounded),
+                'teardown proofs exactly for the classified suites')
+        if test == RESTART[0]:
+            require(row['generated_reports'] == {HANDOFF: dict(handoff, actual_engine_pid=pid,
+                    producer_test=test, producer_source_sha256=source[test]['sha256'], payload_modified=False)},
+                    'the writer generates exactly the retained restart handoff')
+            require(re.findall(WRITER_LINE, raw) == [(str(pid), handoff['sha256'])]
+                    and read_json(confined(out, 'stage/' + HANDOFF))['writer_pid'] == pid,
+                    'the writer engine printed and recorded its own handoff')
+            writer_pid = pid
+        else:
+            require(row['generated_reports'] == {}, 'only the restart writer generates a report')
+        if test == RESTART[1]:
+            require(re.findall(READER_LINE, raw) == [(str(pid), str(writer_pid), handoff['sha256'])]
+                    and pid != writer_pid, 'a separate reader engine read the exact writer handoff')
+    require(end['actual_captured_PIDs'] == pids, 'all captured engines')
+    outer_cleanup(end['final_owned_cleanup'], pids)
+    require(all(end[k] == v for k, v in shared.totals(tests, SUITES).items()), 'recomputed exact totals')
+    require(shared.inventory(confined(out, 'stage'), stage=True) == dict(source, **{HANDOFF: handoff}),
+            'entire retained source/settings and handoff exact')
+    for name, pin in shared.read(shared.SUPPORT / 'bootstrap-scripts.json').items():
+        require(text('bootstrap/' + name).encode() == pin['text'].encode()
+                and files['bootstrap/' + name]['sha256'] == pin['sha256'], 'unchanged bootstrap/Guard pins')
+    require(inventory(out) == dict(files, **{'receipt.json': receipt_pin}),
+            'whole raw evidence unchanged during verification')
+    require(content_map(shared.source_refs(shared.HERE.parent)) == source,
+            'whole current source unchanged during verification')
+    print(json.dumps({'verified': True, 'actual_suites': len(SUITES), 'parse_checks': len(parse_paths),
+                      'actual_checks': end['actual_all_roster_checks'], 'engines_started': 0,
+                      'formal_acceptance': False, 'original_unit_complete': False}))
+    return 0
+
+
+def main(argv=None):
+    argv = list(sys.argv[1:] if argv is None else argv)
+    # No argparse abbreviation, repeated flags, = aliases or positional tokens.
+    parser = argparse.ArgumentParser(description=__doc__, allow_abbrev=False)
+    parser.add_argument('--output', required=True)
+    modes = parser.add_mutually_exclusive_group()
+    modes.add_argument('--collect', action='store_true', help='Root only; fresh native collection')
+    modes.add_argument('--prepare-only', action='store_true')
+    seen = set()
+    i = 0
+    while i < len(argv):
+        flag = argv[i]
+        require(flag in ('--output', '--collect', '--prepare-only', '--help')
+                and flag not in seen, 'unknown, duplicate or malformed flag')
+        seen.add(flag)
+        if flag == '--output':
+            i += 1
+            require(i < len(argv) and argv[i] and not argv[i].startswith('--'), 'output value required')
+        i += 1
+    args = parser.parse_args(argv)
+    args.timeout = 1200
+    root = shared.HERE.parent
+    output = args.output
+    # The registered validation passes the literal '{build_dir}/p07-weather-evidence'. The current Runner
+    # replaces only {python} in validation argv and gives the task's build directory as BUILD_OUTPUT_DIR.
+    if output.startswith('{build_dir}/'):
+        build = os.environ.get('BUILD_OUTPUT_DIR', '')
+        require(build and Path(build).is_absolute() and Path(build).is_dir() and not Path(build).is_symlink(),
+                'registered build directory from BUILD_OUTPUT_DIR')
+        output = build + output[len('{build_dir}'):]
+    out = plain_path(output)
+    refs = shared.source_refs(root)
+    require(set(SUITES).issubset(shared.roster(root)), 'normal discovery includes narrow roster and restart tests')
+    discovered = shared.roster(root)
+    require(discovered.index(RESTART[0]) < discovered.index(RESTART[1]), 'the full roster also runs the writer first')
+    markers = shared.module('p07_exact_markers', shared.HERE / 'strict_test_markers.py')
+    contract_path = root / 'docs/plans/original-completion-2026-10-02/execution/completion_marker_contracts.json'
+    contract_sha = shared.sha(contract_path)
+    contracts = markers.load_contracts(contract_path)
+    require(all(name in contracts for name in SUITES), 'complete marker roster')
+    policy = shared.read(shared.SUPPORT / 'suite-policy.json')
+    shared.policy_coverage(SUITES, refs, policy)
+    for test in SUITES:
+        shared.phase_policy(test, Path(refs[test]['path']), policy['suite_policies'])
+        require(test not in policy['outside_routes'], 'no outside report routes in the narrow run')
+        require(policy['fixed_generated_report_routes'].get(test, []) == ([HANDOFF] if test == RESTART[0] else []),
+                'only the restart writer declares one generated report')
+    for test in ROSTER[:1] + RESTART:
+        require(contracts[test]['source_sha256_at_schema_audit'] == refs[test]['sha256'],
+                'new strict source-hashed marker')
+    parse_paths = ['res://' + name for name in sorted(refs) if name.endswith('.gd')]
+    if args.prepare_only:
+        ancestor = out.parent
+        while not ancestor.exists():
+            ancestor = ancestor.parent
+        free = shutil.disk_usage(ancestor).free
+        size = sum(p['bytes'] for p in refs.values())
+        print(json.dumps({'roster': ROSTER, 'source_files': len(refs), 'source_bytes': size,
+            'free_bytes': free, 'conservative_required_bytes': size + shared.MIN_SPACE,
+            'capacity_available': free >= size + shared.MIN_SPACE, 'parse_paths': len(parse_paths),
+            'restart_phases': RESTART, 'future_native_phases': len(SUITES) + 2, 'actual_checks': None, 'engines': 0, 'stages': 0,
+            'formal_acceptance': False}))
+        return 0
+    if args.collect:
+        require(not out.exists() and out.parent.is_dir(), 'fresh output with existing parent required')
+        require(not out.is_relative_to(root), 'private collection outside source tree')
+        return collect(args, root, out, refs, markers, contracts, policy,
+                       contract_path, contract_sha, parse_paths)
+    return verify(out, refs, markers, contracts, policy, contract_sha, parse_paths)
+
+
+if __name__ == '__main__':
+    try:
+        raise SystemExit(main())
+    except (AssertionError, OSError, ValueError, KeyError, TypeError) as error:
+        print(type(error).__name__ + ': ' + str(error), file=sys.stderr)
+        raise SystemExit(1)