minima-cli 0.4.9__py3-none-any.whl

minima_harness/minima/goals.py

@@ -0,0 +1,226 @@
+"""Goal / task tracking for the harness — the data model behind ``/goals``.
+
+A :class:`Goal` is a high-level objective plus a checklist of :class:`GoalTask` items the agent
+maintains as it works (one ``in_progress`` at a time). Phase 1 uses this purely to keep the
+agent on-track and show progress; Phase 2 adds cost fields (``est_cost_usd`` / ``actual_cost_usd``
+/ ``budget_usd``) so a goal can be tracked against a budget — Minima's differentiator.
+
+State is owned by :class:`GoalStore`, which (de)serializes to the per-session store so a goal
+survives ``--continue`` / ``--resume``.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import asdict, dataclass, field
+from typing import Any
+
+_STATUSES = ("pending", "in_progress", "completed", "blocked")
+
+
+def _slug(text: str, n: int = 24) -> str:
+    s = re.sub(r"[^a-z0-9]+", "-", text.lower()).strip("-")
+    return (s[:n].rstrip("-")) or "task"
+
+
+@dataclass
+class GoalTask:
+    id: str
+    content: str  # imperative form ("Add OAuth login")
+    active_form: str = ""  # present-continuous ("Adding OAuth login"); falls back to content
+    status: str = "pending"  # pending | in_progress | completed | blocked
+    est_cost_usd: float = 0.0  # routing estimate captured while worked (Phase 2)
+    actual_cost_usd: float = 0.0  # realized cost attributed to this task (Phase 2)
+
+    @property
+    def label(self) -> str:
+        if self.status == "in_progress" and self.active_form:
+            return self.active_form
+        return self.content
+
+    @classmethod
+    def make(cls, content: str, active_form: str = "", status: str = "pending") -> GoalTask:
+        status = status if status in _STATUSES else "pending"
+        return cls(id=_slug(content), content=content, active_form=active_form, status=status)
+
+
+@dataclass
+class Goal:
+    title: str
+    tasks: list[GoalTask] = field(default_factory=list)
+    task_type: str | None = None
+    tags: list[str] = field(default_factory=list)
+    budget_usd: float | None = None
+    started_ts: float = 0.0
+    done: bool = False
+    # Cost attributed to turns that ran while no task was in_progress (Phase 2).
+    spent_extra_usd: float = 0.0
+
+    def progress(self) -> tuple[int, int]:
+        """(completed, total)."""
+        return (sum(1 for t in self.tasks if t.status == "completed"), len(self.tasks))
+
+    def active(self) -> GoalTask | None:
+        return next((t for t in self.tasks if t.status == "in_progress"), None)
+
+    def routing_signals(self) -> tuple[str | None, list[str]]:
+        """(task_type, tags) to feed the router so a goal's turns cluster + route coherently."""
+        tags = list(self.tags)
+        if self.title:
+            tags = [f"goal:{_slug(self.title)}", *tags]
+        return self.task_type, tags
+
+    def record_turn_cost(
+        self, actual_usd: float, est_usd: float, newly_completed_ids: list[str] | None = None
+    ) -> None:
+        """Attribute a turn's realized cost. Order of preference:
+
+        1. the in_progress task (the model marked one — ideal);
+        2. else split evenly across tasks that flipped to completed THIS turn (the common case
+           where a model batches: plan → do the work → mark several done at once);
+        3. else the goal at large (``spent_extra_usd``), so goal-level spend is always accurate.
+        """
+        task = self.active()
+        if task is not None:
+            task.actual_cost_usd += actual_usd
+            if task.est_cost_usd == 0.0:
+                task.est_cost_usd = est_usd
+            return
+        targets = [t for t in self.tasks if t.id in (newly_completed_ids or [])]
+        if targets:
+            share_a, share_e = actual_usd / len(targets), est_usd / len(targets)
+            for t in targets:
+                t.actual_cost_usd += share_a
+                if t.est_cost_usd == 0.0:
+                    t.est_cost_usd = share_e
+            return
+        self.spent_extra_usd += actual_usd
+
+    def spent_usd(self) -> float:
+        return sum(t.actual_cost_usd for t in self.tasks) + self.spent_extra_usd
+
+    def projected_total_usd(self) -> float | None:
+        """Linear extrapolation of total goal cost from progress (None until ≥1 task done)."""
+        done, total = self.progress()
+        if done <= 0 or total <= 0:
+            return None
+        return self.spent_usd() / done * total
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> Goal:
+        tasks = [GoalTask(**t) for t in data.get("tasks", [])]
+        return cls(
+            title=data.get("title", ""),
+            tasks=tasks,
+            task_type=data.get("task_type"),
+            tags=list(data.get("tags", [])),
+            budget_usd=data.get("budget_usd"),
+            started_ts=float(data.get("started_ts", 0.0)),
+            done=bool(data.get("done", False)),
+            spent_extra_usd=float(data.get("spent_extra_usd", 0.0)),
+        )
+
+
+class GoalStore:
+    """Owns the active goal and (de)serializes it to/from the session store.
+
+    The session store is the single source of truth: :meth:`save` appends a GOAL entry and
+    :meth:`load` reads the latest one, so a goal survives resume with no extra storage.
+    """
+
+    def __init__(self, goal: Goal | None = None) -> None:
+        self.goal = goal
+
+    @property
+    def active(self) -> bool:
+        return self.goal is not None and not self.goal.done
+
+    # ---- mutation (driven by the `tasks` tool and the /goals command) ----
+    def start(self, title: str, *, now: float = 0.0) -> Goal:
+        self.goal = Goal(title=title, started_ts=now)
+        return self.goal
+
+    def clear(self) -> None:
+        if self.goal is not None:
+            self.goal.done = True
+
+    def set_budget(self, amount: float | None) -> None:
+        if self.goal is not None:
+            self.goal.budget_usd = amount
+
+    def completed_ids(self) -> set[str]:
+        return {t.id for t in self.goal.tasks if t.status == "completed"} if self.goal else set()
+
+    def record_turn_cost(
+        self, actual_usd: float, est_usd: float, newly_completed_ids: list[str] | None = None
+    ) -> None:
+        if self.active and self.goal is not None:
+            self.goal.record_turn_cost(actual_usd, est_usd, newly_completed_ids)
+
+    def set_tasks(self, items: list[dict[str, Any]]) -> None:
+        """Replace the task list (the model's `tasks set` op)."""
+        if self.goal is None:
+            self.goal = Goal(title="")
+        self.goal.tasks = [
+            GoalTask.make(
+                str(it.get("content", "")).strip(),
+                str(it.get("active_form", "")).strip(),
+                str(it.get("status", "pending")),
+            )
+            for it in items
+            if str(it.get("content", "")).strip()
+        ]
+
+    def update_task(self, task_id: str, status: str) -> bool:
+        """Set one task's status; enforces the single-in_progress invariant. Returns matched."""
+        if self.goal is None or status not in _STATUSES:
+            return False
+        match = next((t for t in self.goal.tasks if t.id == task_id), None)
+        if match is None:
+            return False
+        if status == "in_progress":  # demote any other in_progress task
+            for t in self.goal.tasks:
+                if t.status == "in_progress":
+                    t.status = "pending"
+        match.status = status
+        return True
+
+    # ---- persistence ----
+    def save(self, session: Any) -> None:
+        if self.goal is None:
+            return
+        try:
+            from minima_harness.session.format import EntryType
+
+            session.append(EntryType.GOAL, self.goal.to_dict())
+        except Exception:  # noqa: BLE001 - goal persistence must never break a turn
+            pass
+
+    def load(self, session: Any) -> None:
+        try:
+            from minima_harness.session.format import EntryType
+
+            latest = None
+            for entry in getattr(session, "entries", []):
+                if entry.type == EntryType.GOAL:
+                    latest = entry
+            if latest is not None:
+                self.goal = Goal.from_dict(latest.payload)
+        except Exception:  # noqa: BLE001
+            pass
+
+    # ---- prompt rendering ----
+    def prompt_block(self) -> str:
+        """The goal + open tasks, injected into the system prompt each turn to re-anchor."""
+        if not self.active or self.goal is None:
+            return ""
+        lines = [f"# Current goal: {self.goal.title}".rstrip()]
+        if self.goal.tasks:
+            lines.append("Task list (keep it current via the `tasks` tool; one in_progress):")
+            mark = {"completed": "[x]", "in_progress": "[~]", "blocked": "[!]", "pending": "[ ]"}
+            for t in self.goal.tasks:
+                lines.append(f"  {mark.get(t.status, '[ ]')} {t.content}")
+        return "\n".join(lines)

minima_harness/minima/judge.py

@@ -0,0 +1,144 @@
+"""Quality judging for the Minima feedback loop.
+
+A judge turns a model's output into a [0, 1] quality score, which the router folds into
+the outcome label it sends to ``POST /v1/feedback``. Three implementations cover the
+common cases: an LLM grader (default when a key is present), a deterministic scorer
+(wraps a ``quality_fn``, matching ``minima_harness.tasks``), and a constant for when
+judging is disabled.
+
+``grade`` returns ``float | None``: ``None`` means the judge ABSTAINS — it could not
+produce a trustworthy score (LLM call failed, output unparseable, or no judge
+configured). Abstention is NOT a failure: feeding a fabricated 0.0 (API error) or a
+neutral 0.5 (unparseable) into ``/v1/feedback`` poisons the learning loop, so the caller
+records the realized cost/latency but sends NO quality/outcome signal on abstention.
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+from typing import TYPE_CHECKING, Protocol, runtime_checkable
+
+from minima_harness.ai import Context, Message, complete
+from minima_harness.ai.types import Model
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+_log = logging.getLogger("minima_harness.judge")
+
+JUDGE_SYSTEM = (
+    "You grade an AI assistant's response to a task on a 0-10 scale: 10 excellent, "
+    "5 acceptable, 0 wrong. Judge correctness, completeness, and adherence to any rubric. "
+    "Reply with ONLY a single integer 0-10, nothing else."
+)
+
+
+@runtime_checkable
+class QualityJudge(Protocol):
+    async def grade(
+        self, task: str, output: str, *, rubric: str = "", expected: str = ""
+    ) -> float | None:
+        """Return a quality score in [0, 1], or ``None`` to abstain (no trustworthy score)."""
+        ...
+
+
+def clamp01(x: float) -> float:
+    return max(0.0, min(1.0, x))
+
+
+class DeterministicJudge:
+    """Wraps a ``quality_fn(output) -> float`` callable (the tasks/task_set convention)."""
+
+    def __init__(self, fn: Callable[[str], float]) -> None:
+        self._fn = fn
+
+    async def grade(
+        self, task: str, output: str, *, rubric: str = "", expected: str = ""
+    ) -> float | None:
+        try:
+            return clamp01(float(self._fn(output)))
+        except Exception:  # noqa: BLE001 - a broken scorer must ABSTAIN, not record a failure
+            _log.warning("deterministic_judge_failed", exc_info=True)
+            return None
+
+
+class ConstJudge:
+    """Returns a fixed quality (or ``None`` to abstain). ``ConstJudge(None)`` = always abstain."""
+
+    def __init__(self, quality: float | None = 0.5) -> None:
+        self._quality = clamp01(quality) if quality is not None else None
+
+    async def grade(
+        self, task: str, output: str, *, rubric: str = "", expected: str = ""
+    ) -> float | None:
+        return self._quality
+
+
+class LLMJudge:
+    """Grades via a cheap independent model (default claude-haiku). 0-10 -> /10 -> clamp.
+
+    Uses the harness's own ``ai.complete`` so it shares provider plumbing; pick a
+    different provider than your candidates to avoid self-grading bias.
+    """
+
+    def __init__(
+        self,
+        model: Model,
+        *,
+        api_key: str | None = None,
+        timeout: float = 30.0,
+    ) -> None:
+        self._model = model
+        self._api_key = api_key
+        self._timeout = timeout
+
+    async def grade(
+        self, task: str, output: str, *, rubric: str = "", expected: str = ""
+    ) -> float | None:
+        user = f"TASK:\n{task[:4000]}\n\nRESPONSE:\n{output[:4000]}"
+        if rubric:
+            user += f"\n\nRUBRIC:\n{rubric[:1000]}"
+        if expected:
+            user += f"\n\nEXPECTED:\n{expected[:1000]}"
+        # Judge inputs (task + response) are unique per turn, so prompt caching would only
+        # incur a cache-write with no future read — disable it.
+        options: dict = {"timeout": self._timeout, "prompt_cache": False}
+        if self._api_key:
+            options["api_key"] = self._api_key
+        try:
+            resp = await complete(
+                self._model,
+                Context(
+                    system_prompt=JUDGE_SYSTEM,
+                    messages=[Message(role="user", content=user)],
+                ),
+                options=options,
+            )
+        except Exception:  # noqa: BLE001 - a judge API error is NOT a model failure: abstain
+            _log.warning("llm_judge_call_failed", exc_info=True)
+            return None
+        score = _parse_score(resp.text)
+        # Unparseable judge output -> abstain rather than fabricate a neutral 0.5.
+        return None if score is None else clamp01(score / 10.0)
+
+
+def _parse_score(text: str) -> float | None:
+    """Extract a 0-10 integer score from the judge's reply; ``None`` when none is found.
+
+    The judge is asked for a bare integer, but real replies vary. Prefer, in order:
+    an exact single integer, an ``N/10`` form, a ``score/rating/grade: N`` form, and
+    finally the LAST standalone 0-10 integer (judges tend to conclude with the score,
+    e.g. "there were 3 issues, so 7"). Returns ``None`` only when no 0-10 integer exists.
+    """
+    t = text.strip()
+    if re.fullmatch(r"\d+", t) and 0 <= int(t) <= 10:
+        return float(t)
+    m = re.search(r"\b(\d+)\s*/\s*10\b", t)
+    if m and 0 <= int(m.group(1)) <= 10:
+        return float(m.group(1))
+    m = re.search(r"(?:score|rating|grade)\D{0,5}(\d+)", t, re.IGNORECASE)
+    if m and 0 <= int(m.group(1)) <= 10:
+        return float(m.group(1))
+    candidates = [int(x) for x in re.findall(r"\d+", t) if 0 <= int(x) <= 10]
+    return float(candidates[-1]) if candidates else None

minima_harness/minima/mapping.py

@@ -0,0 +1,147 @@
+"""Map a Minima ``RankedModel`` to a harness :class:`~minima_harness.ai.types.Model`.
+
+Minima's catalog and the harness registry are kept deliberately separate: Minima is the
+source of truth for *routing*, the harness registry for *calling*. This module bridges
+them with a tolerant lookup (exact -> id-only -> ``provider/model`` split -> fallback) so
+a recommendation resolves to a callable model even when ids drift slightly between the
+two catalogs.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+from minima_harness.ai.provider_catalog import provider_key_present
+from minima_harness.ai.registry import all_models, find_model_by_id, try_get_model
+from minima_harness.ai.types import Model
+
+if TYPE_CHECKING:
+    from minima.schemas.recommend import RankedModel
+
+_log = logging.getLogger("minima_harness.mapping")
+
+
+def _has_provider_key(model: Model) -> bool:
+    """True if a key for ``model``'s OWN provider is set (or it needs none, e.g. a local runtime).
+
+    Provider-specific (via the provider catalog): a Groq model needs GROQ_API_KEY, an OpenAI
+    model needs OPENAI_API_KEY — an OpenRouter key never green-lights an api.openai.com model.
+    """
+    return provider_key_present(model.provider)
+
+
+def _fallback_cost(model: Model) -> float:
+    """Sort key for the offline fallback: combined per-token cost, but treat an unpriced
+    (cost 0) model as most-expensive so a local/custom 0-cost stub isn't mistaken for the
+    cheapest runnable default."""
+    total = model.cost.input + model.cost.output
+    return float("inf") if total <= 0 else total
+
+
+class ModelMapping:
+    """Resolve Minima's pick to a callable harness model."""
+
+    def to_model(
+        self,
+        ranked: RankedModel,
+        *,
+        offline_default: Model | None = None,
+    ) -> Model:
+        model = self._resolve(ranked.provider, ranked.model_id)
+        if model is not None:
+            return model
+        if offline_default is not None:
+            _log.debug(
+                "mapping_fallback_to_offline_default provider=%s model_id=%s",
+                ranked.provider,
+                ranked.model_id,
+            )
+            return offline_default
+        raise KeyError(
+            f"no harness model for minima pick {ranked.provider}/{ranked.model_id!r}; "
+            "register it or pass an offline_default"
+        )
+
+    def default_model(self) -> Model:
+        """Offline fallback: the cheapest registered model the user can actually run.
+
+        Prefers the cheapest model whose provider key is configured, so an offline
+        fallback doesn't pick (say) gpt-4o-mini when only Anthropic/Gemini keys are set.
+        Falls back to the globally cheapest model if no provider key is present (the run
+        will then surface a clear provider-auth error rather than a silent mismatch)."""
+        models = all_models()
+        if not models:
+            raise KeyError("harness model registry is empty")
+        by_cost = sorted(models, key=lambda m: (_fallback_cost(m), m.id))
+        for model in by_cost:
+            if _has_provider_key(model):
+                return model
+        return by_cost[0]
+
+    def _resolve(self, provider: str, model_id: str) -> Model | None:
+        # 1. exact (provider, id)
+        model = try_get_model(provider, model_id)
+        if model is not None:
+            return model
+        # 2. id-only (Minima's provider string may differ from ours)
+        model = find_model_by_id(model_id)
+        if model is not None:
+            return model
+        # 3. openrouter-style "provider/model" ids
+        if "/" in model_id:
+            prov, _, mid = model_id.partition("/")
+            model = (
+                try_get_model(prov, model_id) or try_get_model(prov, mid) or find_model_by_id(mid)
+            )
+            if model is not None:
+                return model
+        return None
+
+
+def sync_catalog(client: object, mapping: ModelMapping | None = None) -> int:
+    """Overlay Minima's authoritative live pricing onto the registered harness models.
+
+    Minima's ``GET /v1/models`` carries cost/context that the server overlays from live
+    LiteLLM pricing and *scores routing against*. The harness registry is hand-seeded and can
+    drift from it, so the cost the harness reports for a call can disagree with the cost the
+    server routed on — which corrupts the est-vs-actual loop. This pulls the catalog and
+    overlays cost/context/max_output onto each matching registered model (tolerant id match,
+    reusing :meth:`ModelMapping._resolve`). Returns the number of models updated.
+
+    Offline-safe: any failure (unreachable Minima, bad shape) is logged at DEBUG and returns 0,
+    leaving the seeded prices in place. ``client`` is duck-typed on a sync ``.models()``.
+    """
+    from minima_harness.ai.registry import register_model
+    from minima_harness.ai.types import ModelCost
+
+    mapping = mapping or ModelMapping()
+    try:
+        resp = client.models(include_stale=True)  # type: ignore[attr-defined]
+        cards = list(getattr(resp, "models", None) or [])
+    except Exception:  # noqa: BLE001 - the harness must run on the seeded catalog if this fails
+        _log.debug("catalog_overlay_skipped", exc_info=True)
+        return 0
+    updated = 0
+    for card in cards:
+        model = mapping._resolve(card.provider, card.model_id)
+        if model is None:
+            continue
+        model.cost = ModelCost(
+            input=card.input_cost_per_mtok,
+            output=card.output_cost_per_mtok,
+            cache_read=(
+                card.cache_read_cost_per_mtok
+                if card.cache_read_cost_per_mtok is not None
+                else model.cost.cache_read
+            ),
+            cache_write=model.cost.cache_write,
+        )
+        if card.context_window:
+            model.context_window = card.context_window
+        if card.max_output_tokens:
+            model.max_tokens = card.max_output_tokens
+        register_model(model)  # re-register (same instance) so the overlay is authoritative
+        updated += 1
+    _log.debug("catalog_overlay matched %d of %d minima catalog models", updated, len(cards))
+    return updated

minima_harness/minima/meter.py

@@ -0,0 +1,143 @@
+"""CostMeter — per-prompt cost observability for a MinimaAgent run.
+
+Owned by :class:`MinimaAgent` (the routing decision isn't part of the ``AgentEvent``
+stream, so the meter is fed directly from ``prompt()`` rather than via ``subscribe()``).
+Accumulates one row per prompt — model picked, why, est vs actual $, savings vs the
+configured baseline, quality, outcome — and renders a report + summary totals. This is
+the "see exactly what you spend and why" surface: the data already flowed to Minima; the
+meter just surfaces it to the human.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from minima_harness.minima.router import RoutingResult
+
+
+@dataclass(slots=True)
+class CostRow:
+    label: str
+    model: str
+    decision_basis: str
+    est_cost_usd: float
+    actual_cost_usd: float
+    baseline_cost_usd: float | None
+    quality: float | None
+    outcome: str
+    turns: int = 0
+
+
+@dataclass(slots=True)
+class CostTotals:
+    n: int = 0
+    est_cost_usd: float = 0.0
+    actual_cost_usd: float = 0.0
+    baseline_cost_usd: float = 0.0
+    baseline_rows: int = 0  # prompts that had a baseline to compare against
+    successes: int = 0
+
+    @property
+    def savings_usd(self) -> float:
+        return self.baseline_cost_usd - self.actual_cost_usd
+
+    @property
+    def savings_pct(self) -> float:
+        if self.baseline_cost_usd <= 0:
+            return 0.0
+        return 100.0 * self.savings_usd / self.baseline_cost_usd
+
+    @property
+    def success_rate(self) -> float:
+        return (100.0 * self.successes / self.n) if self.n else 0.0
+
+
+class CostMeter:
+    def __init__(self) -> None:
+        self.rows: list[CostRow] = []
+
+    def record(
+        self,
+        *,
+        label: str,
+        routing: RoutingResult | None,
+        actual_cost_usd: float,
+        quality: float | None,
+        outcome: str,
+        turns: int = 0,
+    ) -> CostRow:
+        row = CostRow(
+            label=label,
+            model=(routing.chosen_model_id if routing else None) or "(offline)",
+            decision_basis=routing.decision_basis if routing else "-",
+            est_cost_usd=routing.est_cost_usd if routing else 0.0,
+            actual_cost_usd=actual_cost_usd,
+            baseline_cost_usd=routing.baseline_cost_usd if routing else None,
+            quality=quality,
+            outcome=outcome,
+            turns=turns,
+        )
+        self.rows.append(row)
+        return row
+
+    def totals(self) -> CostTotals:
+        t = CostTotals()
+        for r in self.rows:
+            t.n += 1
+            t.est_cost_usd += r.est_cost_usd
+            t.actual_cost_usd += r.actual_cost_usd
+            if r.baseline_cost_usd is not None:
+                t.baseline_cost_usd += r.baseline_cost_usd
+                t.baseline_rows += 1
+            if r.outcome == "success":
+                t.successes += 1
+        return t
+
+    def report(self) -> str:
+        if not self.rows:
+            return "(cost meter: no prompts recorded)"
+        cols = [
+            "label",
+            "model",
+            "basis",
+            "est$",
+            "actual$",
+            "save$",
+            "turns",
+            "quality",
+            "outcome",
+        ]
+        rendered = [
+            {
+                "label": r.label,
+                "model": r.model,
+                "basis": r.decision_basis,
+                "est$": f"{r.est_cost_usd:.6f}",
+                "actual$": f"{r.actual_cost_usd:.6f}",
+                "save$": (
+                    f"{r.baseline_cost_usd - r.actual_cost_usd:.6f}"
+                    if r.baseline_cost_usd is not None
+                    else "-"
+                ),
+                "turns": str(r.turns),
+                "quality": f"{r.quality:.2f}" if r.quality is not None else "-",
+                "outcome": r.outcome,
+            }
+            for r in self.rows
+        ]
+        widths = {c: max(len(c), max(len(str(row[c])) for row in rendered)) for c in cols}
+        header = "  ".join(c.ljust(widths[c]) for c in cols)
+        lines = [header, "-" * len(header)]
+        for row in rendered:
+            lines.append("  ".join(str(row[c]).ljust(widths[c]) for c in cols))
+        t = self.totals()
+        lines.append("")
+        lines.append(
+            f"total actual ${t.actual_cost_usd:.6f} | "
+            f"baseline ${t.baseline_cost_usd:.6f} ({t.baseline_rows} rows) | "
+            f"savings {t.savings_pct:.1f}% (${t.savings_usd:.6f}) | "
+            f"success {t.success_rate:.1f}% ({t.successes}/{t.n})"
+        )
+        return "\n".join(lines)