"""P3 (GO) — the demo runs the DELIVERED bundle, and its numbers come FROM that bundle. P4 pkt. 0 anchored the demo against a repo-local reserve whose ``cost-baseline.json`` was DERIVED in code from the scripted register (``baseline_from_scripted_candidate``): the reserve's numbers are synthetic, so the script was the only ground truth there was. On GO day the direction **reverses** — a domain team delivered ``shared/examples/veglys-fv-soer/`` (commons ``002f000``) with its own ``cost-baseline.json``, so the register is written FROM that file and the derivation helper is not used on this path. That reversal is what these tests guard. The risk it models is drift: two copies of the same numbers — one in commons' delivered file, one in our register — that stop agreeing without anyone noticing. A drifted register does not crash; it makes the deterministic gate reject the demo's own hypothesis at stage 0 instead of at the P90 stage, which on screen is the SAME ``REJECTED`` line telling a different story. So the agreement is asserted directly (below), and the 10 % test proves the gate would actually catch a disagreement. The 10 % test is repeated here against delivered content on purpose. Its twin in ``test_anchored_reserve_loadbearing`` proves the MECHANISM; this one measures the CONTENT — the mechanism could be perfect while the delivered file and the register disagree. """ from __future__ import annotations import json from portfolio_optimiser import okf from portfolio_optimiser.ir import CostBaseline, CostBaselineLine from portfolio_optimiser.simulation import ( _CANDIDATES, _INBOX_MARKER, _VEGLYS_PROJECT_ID, ScriptedCandidate, _delivered_bundle_dir, materialize_anchored_bundle, simulate_learning_loop, ) from portfolio_optimiser.persona import load_persona_example from portfolio_optimiser.validator import Rejection, ValidatedProposal def _veglys() -> ScriptedCandidate: """The registry entry for the delivered project — selected by id, never by index (the registry is a set of DATA entries whose order carries no meaning).""" (candidate,) = [c for c in _CANDIDATES if c.project_id == _VEGLYS_PROJECT_ID] return candidate def _delivered_baseline() -> CostBaseline: baseline = okf.load_optional_cost_baseline(str(_delivered_bundle_dir())) assert baseline is not None, "the delivered bundle no longer ships a cost-baseline.json" return baseline def test_the_delivered_bundle_ships_its_own_baseline() -> None: """The delivered bundle is anchored WITHOUT ``materialize_anchored_bundle`` — which is exactly what let GO day be a call-site change rather than a new seam. RED if commons ever drops the file: the demo would then run un-anchored while every other line stayed byte-identical.""" baseline = _delivered_baseline() assert baseline.project_id == _VEGLYS_PROJECT_ID assert set(baseline.items) == {"ENERGI-VEGLYS-EL"} def test_the_register_states_the_delivered_numbers_verbatim() -> None: """LOAD-BEARING on the DIRECTION of derivation (plan P3 b): the register's cost lines are written FROM the delivered ``cost-baseline.json``, so they must equal it exactly — in BOTH scripted replies. RED when the two drift: if commons re-states the baseline (or someone re-types it here), the demo's own hypothesis starts being felled by stage 0's reconciliation instead of by the P90 stage it narrates. Same ``REJECTED`` line on screen, different mechanism behind it. Both replies are checked, not just the corrected one: the overclaimed hypothesis must differ from it in the CLAIM alone, never in the cost lines.""" candidate = _veglys() delivered = _delivered_baseline().items for reply in (candidate.overclaimed, candidate.corrected): items = json.loads(reply)["affected_items"] assert {i["code"] for i in items} == set(delivered), ( "the scripted reply names cost codes the delivered baseline does not declare" ) for item in items: line = delivered[item["code"]] assert (item["quantity"], item["unit_cost"]) == (line.quantity, line.unit_cost), ( f"register and delivered cost-baseline.json disagree on {item['code']}: " f"script says {(item['quantity'], item['unit_cost'])}, " f"delivered says {(line.quantity, line.unit_cost)}" ) overclaimed = json.loads(candidate.overclaimed) corrected = json.loads(candidate.corrected) assert overclaimed["claimed_saving_nok"] != corrected["claimed_saving_nok"] assert overclaimed["affected_items"] == corrected["affected_items"] def test_the_overclaim_and_the_markers_are_absent_from_the_delivered_bundle() -> None: """The three tokens the walkthrough traces must not already be IN the content it traces. ``flip_key`` absent: otherwise attempt 1's prompt carries it and the proposer 'corrects' before anything was falsified — Step 5 would show a correction nothing caused. Both markers absent: otherwise Run A's 'markøren er FRAVÆRENDE' line is false, and the promotion / inbox paths would each appear to work while carrying nothing. This is a CONTENT check, and delivered content is the reason it exists: the register's figure was chosen against commons' number inventory, and this is what keeps that choice honest if either side changes.""" text = "\n".join( path.read_text(encoding="utf-8") for path in sorted(_delivered_bundle_dir().rglob("*")) if path.is_file() ) for token in (_veglys().flip_key, load_persona_example().marker, _INBOX_MARKER): assert token not in text, ( f"{token!r} already occurs in the delivered bundle — the walkthrough would trace a " "token the content supplied, not one the loop carried" ) async def test_the_delivered_bundle_runs_the_whole_demo(tmp_path) -> None: """CONTROL, and demo-criterion 2 measured against delivered content: hypothesis #1 is falsified by the P90 stage, the corrected one validates, and both runs end FORESLÅTT. A gate that rejects everything proves nothing, so this is what gives the 10 % test below its meaning. It also pins WHICH stage rejects #1 — were stage 0 to start rejecting it, the screen would still show a REJECTED and a VALIDATED line while demonstrating a different mechanism.""" result = await simulate_learning_loop( str(_delivered_bundle_dir()), str(tmp_path), project_id=_VEGLYS_PROJECT_ID ) assert isinstance(result.run_a.outcome, ValidatedProposal) assert isinstance(result.run_b.outcome, ValidatedProposal) assert result.run_a.refinements, "no falsification was fed back — Step 5 is not being shown" assert "exceeds P90 feasible" in result.run_a.refinements[0].reason, ( "hypothesis #1 was rejected by some other stage than the P90 one the demo narrates" ) # Both learning paths close on delivered content too (Step 8 wiki + Step 7 inbox). assert result.marker_in_run_b_prompt and result.inbox_marker_in_run_b_prompt assert not result.marker_in_run_a_prompt async def test_a_deviating_delivered_baseline_forkaster_the_run_before_the_solver(tmp_path) -> None: """LOAD-BEARING (the 10 % test, on DELIVERED content): when the project's declared cost lines deviate 10 % from what the script asserts, the run is FORKASTET at stage 0 — with the reconciliation reason, never the P90 one. This is the answer to "the register was copied from the baseline, so of course they agree": the agreement is only worth something if a DISagreement would be caught. The script is byte-identical to the control above; only the declared baseline moves. The deviated copy is materialized outside ``shared/`` — the delivered bundle is a pull-only subtree and criterion 8 requires it byte-unchanged.""" delivered = _delivered_baseline() deviated = CostBaseline( project_id=delivered.project_id, items={ code: CostBaselineLine(quantity=line.quantity * 1.10, unit_cost=line.unit_cost) for code, line in delivered.items.items() }, ) bundle = materialize_anchored_bundle( tmp_path / "avvikende", source=_delivered_bundle_dir(), baseline=deviated ) result = await simulate_learning_loop(str(bundle), str(tmp_path), project_id=_VEGLYS_PROJECT_ID) outcome = result.run_a.outcome assert isinstance(outcome, Rejection), ( "a proposal 10 % away from the project's declared cost lines was NOT rejected — the " "deterministic gate is not anchored to the delivered baseline" ) assert "outside the 5.0% tolerance" in outcome.reason assert "ENERGI-VEGLYS-EL" in outcome.reason assert "P90" not in outcome.reason, ( "rejected by the solver stage, not by the reconciliation stage 0 that must run BEFORE it" ) def test_the_delivered_bundle_is_never_mutated_by_a_run() -> None: """Criterion 8's day-to-day half: the demo copies the bundle, so the commons-owned files under ``shared/`` are byte-unchanged after everything above has run.""" import subprocess proc = subprocess.run( ["git", "status", "--porcelain", "--", "shared/examples/veglys-fv-soer"], capture_output=True, text=True, check=True, ) assert proc.stdout == "", f"the delivered bundle was modified in place: {proc.stdout!r}" def test_the_reserve_entry_and_the_delivered_entry_are_both_registered() -> None: """The abort path stays reachable: pointing ``main`` back at the anchored reserve must remain a three-line revert, which it only is while the reserve's registry entry still exists.""" ids = {c.project_id for c in _CANDIDATES} assert {"BYGG-KONTOR-NORD", _VEGLYS_PROJECT_ID} <= ids def test_the_projection_names_the_project_the_register_keys_on() -> None: """The id must stand VERBATIM in the delivered IR projection: ``run._project_from_bundle`` raises on a mismatch, and ``scripted_proposer`` keys on this exact string. Two files, one identifier — so it is asserted, not assumed.""" projection = json.loads( (_delivered_bundle_dir() / "validator-input.json").read_text(encoding="utf-8") ) assert projection["project_id"] == _VEGLYS_PROJECT_ID assert _delivered_baseline().project_id == projection["project_id"]