feat(cli): --mandate — a run announces what it will do, and settles for it

Krav 2: a run must be clear about what it shall do and achieve. `--mandate`
makes both ends explicit. BEFORE the first (paid) model call the run prints what
it was commissioned to do — objective, every named approach, whether its own
proposals are allowed, the scope, the caps, and which external services it will
contact. AFTER the run it settles: one row per approach, validated with the
figure, rejected with the validator's reason, or not evaluated with why.

The announcement is placed with the other refusals and above the scripted
banner, for the reason the required-args guard was hoisted there: a refused run
must not first print a banner about work it never did. `--live-dry-run`
announces without contacting anything, so a commission can be inspected before
it costs money.

`settle` renders the goal verdict it is GIVEN and never decides it. `ledger.to_ore`
is the framework's one NOK->øre conversion and the goal comparison already runs on
quantised integers, but `mandate.py` cannot import it without dragging `verdicts`
— and therefore agent_framework — into a deliberately framework-neutral module,
while a private copy of a money conversion is exactly the (p) defect. So the
caller decides and this renders; a goal figure without a decided verdict makes no
claim at all.

The caps the announcement prints come from named constants shared with
`run_project`/`run_portfolio`'s defaults — a second copy could drift and make the
announcement describe a run that never happened.

Load-bearing MEASURED against the whole 717-test suite, four mutations all red:
detach the announcement (4) · detach the settlement print (2) · make the CLI
loader tolerant (2) · announce the commission but never hand it to the run (2).
The last one is the one that matters: without it, a run could print a commission
it had no intention of executing.

DEVIATION from the approved plan, stated rather than quietly dropped: --goals is
still refused outside portfolio mode. Accepting it in single-project mode would
have admitted a flag whose documented function (the goal-stop against the ledger)
still does nothing there — the same accepted-but-inert defect --embedder-config
was just fixed for. The mandate's success_criteria carries "what shall this run
achieve" in the expert's own words instead; the numeric target stays portfolio-level.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01ULCqjLF61rehj5cZmdUoR3

tests/test_mandate.py

@@ -24,9 +24,11 @@ from pydantic import ValidationError
 from portfolio_optimiser.mandate import (
     OWN_PROPOSAL_ID,
     Approach,
+    ApproachOutcome,
     Mandate,
     announce,
     load_mandate,
+    settle,
 )
 
 
@@ -222,3 +224,86 @@ def test_announce_states_the_caps() -> None:
 def test_announce_is_deterministic() -> None:
     """Byte-stable: no wall clock, no set-iteration ordering — so it can be golden-tested."""
     assert _announce() == _announce()
+
+
+# --- the settlement (Trekk A4): what the run actually did about each approach -------------------
+
+_ROWS = (
+    ApproachOutcome(id="led-retrofit", label="LED", status="validated", saving_nok=30_000.0),
+    ApproachOutcome(
+        id="service-contract",
+        label="Contract",
+        status="rejected",
+        detail="claimed 200000 exceeds feasible 90000",
+    ),
+    ApproachOutcome(
+        id="night-setback",
+        label="Setback",
+        status="not_evaluated",
+        detail="budget exhausted before this approach was evaluated",
+    ),
+)
+
+
+def test_settle_reports_every_row_including_the_unevaluated_one() -> None:
+    """All three statuses reach the report. The unevaluated row is the point: an approach the run
+    never got to must be visibly unreached, not absent."""
+    text = settle(_ROWS)
+    assert "led-retrofit" in text
+    assert "service-contract" in text
+    assert "night-setback" in text
+    assert "NOT EVALUATED" in text
+
+
+def test_settle_carries_the_rejection_reason() -> None:
+    """A rejected approach without its reason tells the expert nothing they can act on."""
+    assert "claimed 200000 exceeds feasible 90000" in settle(_ROWS)
+
+
+def test_settle_totals_only_the_validated_savings() -> None:
+    """The total is what passed the validator — never the claimed sum of everything attempted."""
+    text = settle(_ROWS)
+    assert "30000" in text
+    assert "200000 NOK" not in text  # the rejected claim is never folded into a total
+
+
+def test_settle_states_whether_the_target_was_reached() -> None:
+    """Krav 2's second half: the run answers, in its own output, whether it achieved what it was
+    commissioned to achieve."""
+    missed = settle(_ROWS, goal_nok=150_000.0, goal_reached=False)
+    hit = settle(_ROWS, goal_nok=10_000.0, goal_reached=True)
+    assert "not reached" in missed
+    assert "reached" in hit and "not reached" not in hit
+
+
+def test_settle_renders_the_goal_verdict_it_is_GIVEN_and_never_decides_it() -> None:
+    """The renderer must not form a SECOND opinion on a money question.
+
+    ``ledger.to_ore`` is the framework's one NOK->øre conversion and the goal comparison already
+    runs on quantised integers; this module cannot import it without dragging ``verdicts`` — and
+    therefore ``agent_framework`` — into a deliberately framework-neutral file, and a private copy
+    of a money conversion is exactly the ``(p)`` defect. So the caller decides and this renders.
+    Told the opposite of what its own float sum suggests, it prints what it was told.
+    """
+    text = settle(_ROWS, goal_nok=150_000.0, goal_reached=True)
+    assert "not reached" not in text
+
+
+def test_settle_omits_the_target_line_when_no_goal_was_configured() -> None:
+    """No goal configured -> no verdict on a goal. An absent target must not read as a missed one."""
+    assert "Target" not in settle(_ROWS)
+    # ...and a goal figure without a decided verdict renders no claim either.
+    assert "Target" not in settle(_ROWS, goal_nok=150_000.0)
+
+
+def test_settle_is_empty_without_coverage() -> None:
+    """No mandate -> nothing to settle. An empty block beats a header over zero rows, which would
+    imply a commission that never existed."""
+    assert settle(()) == ""
+
+
+def test_settle_is_deterministic() -> None:
+    """Byte-stable, like the announcement."""
+    assert settle(_ROWS, goal_nok=150_000.0, goal_reached=False) == settle(
+        _ROWS, goal_nok=150_000.0, goal_reached=False
+    )