python-yama 0.1.0__py3-none-any.whl

yama/report.py

@@ -0,0 +1,854 @@
+from __future__ import annotations
+
+import hashlib
+import json
+from datetime import datetime, timezone
+from html import escape
+from pathlib import Path
+from typing import Any, Sequence
+
+from .models import ResolvedCase, StepResult
+from .runner import CaseResult, RunResult, _tool_result_content
+
+
+def _text(value: Any) -> str:
+    return escape(str(value), quote=True)
+
+
+def _json(value: Any) -> str:
+    return escape(
+        json.dumps(value, ensure_ascii=False, indent=2, default=str), quote=False
+    )
+
+
+def _stamp_angle(seed: str | None) -> float:
+    """A small deterministic tilt so repeated verdict stamps don't all sit
+    at an identical, obviously-templated angle."""
+    if not seed:
+        return 0.0
+    digest = hashlib.sha1(seed.encode("utf-8")).digest()
+    return (digest[0] / 255) * 6.4 - 3.2
+
+
+def _status(
+    passed: bool,
+    *,
+    kind: str = "stamp",
+    size: str = "md",
+    seed: str | None = None,
+) -> str:
+    """Render a verdict. High-frequency, low-stakes rows (check/mock-event
+    lists) get a quiet inline tick; the handful of hierarchical verdicts
+    per report (report/case/run/step/judge) get a stamped chop instead."""
+    label = "PASS" if passed else "FAIL"
+    css_class = "pass" if passed else "fail"
+    if kind == "tick":
+        return (
+            f'<span class="verdict tick {css_class}">'
+            '<i class="tick-mark" aria-hidden="true"></i>'
+            f"{label}</span>"
+        )
+    angle = _stamp_angle(seed)
+    return (
+        f'<span class="verdict stamp size-{size} {css_class}" '
+        f'style="--tilt:{angle:.2f}deg">{label}</span>'
+    )
+
+
+def _tally(score: Any, max_score: int = 5) -> str:
+    """Render a score as filled/unfilled tally strokes alongside the number,
+    echoing the 正-character five-stroke tally used for hand counting."""
+    try:
+        filled = max(0, min(max_score, round(float(score))))
+    except (TypeError, ValueError):
+        filled = 0
+    bars = "".join(
+        f'<i class="tally-bar{" filled" if i < filled else ""}"></i>'
+        for i in range(max_score)
+    )
+    return f'<span class="tally" role="img" aria-label="{filled}/{max_score}">{bars}</span>'
+
+
+def _file_uri(value: Any) -> str | None:
+    if not isinstance(value, str) or not value:
+        return None
+    try:
+        return Path(value).resolve().as_uri()
+    except ValueError:
+        return None
+
+
+def _render_content(content: Any) -> str:
+    if isinstance(content, str):
+        return f'<pre class="message-content">{_text(content)}</pre>'
+    if not isinstance(content, list):
+        return f'<pre class="message-content">{_json(content)}</pre>'
+
+    parts: list[str] = []
+    for part in content:
+        if not isinstance(part, dict):
+            parts.append(f'<pre class="message-content">{_json(part)}</pre>')
+            continue
+        part_type = part.get("type")
+        if part_type == "text":
+            parts.append(
+                f'<pre class="message-content">{_text(part.get("text", ""))}</pre>'
+            )
+            continue
+        fixture = part.get("fixture")
+        uri = _file_uri(fixture)
+        filename = part.get("filename") or (
+            Path(fixture).name if isinstance(fixture, str) else "attachment"
+        )
+        media_type = part.get("media_type", "unknown")
+        metadata = (
+            f'<span class="attachment-name">{_text(filename)}</span>'
+            f'<span class="muted">{_text(media_type)}</span>'
+        )
+        if part_type == "input_image" and uri:
+            parts.append(
+                '<figure class="attachment image-attachment">'
+                f'<img src="{_text(uri)}" alt="{_text(filename)}" loading="lazy">'
+                f"<figcaption>{metadata}</figcaption>"
+                "</figure>"
+            )
+        else:
+            link_start = f'<a href="{_text(uri)}">' if uri else ""
+            link_end = "</a>" if uri else ""
+            parts.append(
+                '<div class="attachment file-attachment">'
+                f"{link_start}{metadata}{link_end}"
+                f'<span class="path">{_text(fixture or "")}</span>'
+                "</div>"
+            )
+    return "".join(parts)
+
+
+def _render_message(role: str, title: str, content: Any) -> str:
+    return (
+        f'<article class="event message {role}">'
+        '<div class="event-head">'
+        f'<span class="event-kind">{_text(role)}</span>'
+        f"<strong>{_text(title)}</strong>"
+        "</div>"
+        f'{_render_content(content)}'
+        "</article>"
+    )
+
+
+def _render_tool_result(result: Any) -> str:
+    """Render a tool call's result the same way the model sees it.
+
+    Reuses `runner._tool_result_content` so bash results show their raw
+    `stdout + stderr` text and skill results show the raw file text,
+    instead of the report re-encoding them as JSON (which would quote and
+    escape plain-text output rather than displaying it verbatim).
+    """
+    return f'<pre><code>{_text(_tool_result_content(result))}</code></pre>'
+
+
+def _render_tool_call(record: Any) -> str:
+    error_class = " error" if record.is_error else ""
+    return (
+        f'<article class="event tool{error_class}">'
+        '<div class="event-head">'
+        '<span class="event-kind">tool</span>'
+        f'<strong>{_text(record.call.name)}</strong>'
+        '<span class="muted">'
+        f'request {record.request_index} · call {record.call_index}'
+        "</span>"
+        "</div>"
+        '<div class="split">'
+        '<div><h5>Arguments</h5>'
+        f'<pre><code>{_json(record.call.arguments)}</code></pre></div>'
+        '<div><h5>Result</h5>'
+        f'{_render_tool_result(record.result)}</div>'
+        "</div>"
+        "</article>"
+    )
+
+
+def _title_for_role(role: str, global_index: int) -> str:
+    if role == "system":
+        return "System prompt" if global_index == 0 else "System message"
+    if role == "user":
+        return "User message"
+    if role == "developer":
+        return "Developer message"
+    return f"{role.capitalize()} message"
+
+
+def _render_tool_list(tools: Any) -> str:
+    if not isinstance(tools, list) or not tools:
+        return '<p class="muted">No tools available.</p>'
+    names: list[str] = []
+    cards: list[str] = []
+    for tool in tools:
+        function = tool.get("function", {}) if isinstance(tool, dict) else {}
+        name = function.get("name", "unknown") if isinstance(function, dict) else "unknown"
+        names.append(str(name))
+        description = (function.get("description") or "") if isinstance(function, dict) else ""
+        parameters = function.get("parameters", {}) if isinstance(function, dict) else {}
+        cards.append(
+            '<div class="tool-def">'
+            f'<div class="tool-def-head">{_text(name)}</div>'
+            f'<p class="muted">{_text(description)}</p>'
+            '<details><summary>Parameters</summary>'
+            f'<pre><code>{_json(parameters)}</code></pre></details>'
+            "</div>"
+        )
+    return (
+        '<details class="raw tool-list"><summary>'
+        f'Available tools ({len(names)}): {_text(", ".join(names))}'
+        "</summary>"
+        f'<div class="tool-list-grid">{"".join(cards)}</div>'
+        "</details>"
+    )
+
+
+def _render_llm_request_details(request: dict[str, Any]) -> str:
+    invocation = request.get("invocation")
+    if not isinstance(invocation, dict):
+        invocation = {}
+    return (
+        '<h5>Method</h5>'
+        f'<pre><code>{_text(invocation.get("method", "unknown"))}</code></pre>'
+        '<h5>Arguments</h5>'
+        f'<pre><code>{_json(invocation.get("arguments", {}))}</code></pre>'
+    )
+
+
+def _render_assistant_call(request: dict[str, Any]) -> str:
+    resolved_provider = request.get("resolved_provider")
+    provider_name = (
+        resolved_provider.get("name", "unknown")
+        if isinstance(resolved_provider, dict)
+        else "unknown"
+    )
+    resolved_model = (
+        resolved_provider.get("model")
+        if isinstance(resolved_provider, dict)
+        else None
+    )
+    invocation = request.get("invocation", {})
+    arguments = (
+        invocation.get("arguments", {}) if isinstance(invocation, dict) else {}
+    )
+    model_name = resolved_model or arguments.get("model", "unknown")
+    response = request.get("response")
+    error = request.get("error")
+    error_class = " error" if error else ""
+
+    content = response.get("content", "") if isinstance(response, dict) else ""
+    response_html = (
+        '<div class="assistant-content"><h5>Assistant text content</h5>'
+        + (
+            _render_content(content)
+            if content
+            else '<div class="empty-content">Empty assistant text content <code>""</code></div>'
+        )
+        + "</div>"
+    )
+    error_html = (
+        f'<div class="model-error"><h5>Error</h5><pre><code>{_text(error)}</code></pre></div>'
+        if error
+        else ""
+    )
+
+    return (
+        f'<article class="event assistant{error_class}">'
+        '<div class="event-head">'
+        '<span class="event-kind">assistant</span>'
+        '<strong>Assistant response</strong>'
+        f'<span class="muted">request {_text(request.get("request_index", "?"))} · '
+        f'{_text(provider_name)} · {_text(model_name)}</span>'
+        "</div>"
+        f'<div class="assistant-response">{response_html}{error_html}</div>'
+        '<details class="raw model-input"><summary>LLM request</summary>'
+        f'{_render_llm_request_details(request)}'
+        "</details>"
+        f'{_render_tool_list(arguments.get("tools", []) if isinstance(arguments, dict) else [])}'
+        "</article>"
+    )
+
+
+def _render_checks(step: StepResult) -> str:
+    if not step.hard_checks:
+        return '<p class="muted">No hard checks configured.</p>'
+    rows: list[str] = []
+    for index, check in enumerate(step.hard_checks, 1):
+        passed = bool(check.get("passed", False))
+        rows.append(
+            f'<tr class="{"passed" if passed else "failed"}">'
+            f'<td>{_status(passed, kind="tick")}</td>'
+            f'<td><strong>{index:02d} · {_text(check.get("label") or check.get("type", "hard check"))}</strong></td>'
+            f'<td>{_text(check.get("expected", "assertion passes"))}</td>'
+            f'<td>{_text(check.get("actual", check.get("detail", "unknown")))}</td>'
+            f'<td>{_text(check.get("reason", check.get("detail", "")))}</td>'
+            "</tr>"
+        )
+    return (
+        '<div class="table-wrap"><table class="checks">'
+        "<thead><tr><th>Status</th><th>Check</th><th>Expected</th>"
+        "<th>Actual</th><th>Reason</th></tr></thead>"
+        f'<tbody>{"".join(rows)}</tbody></table></div>'
+    )
+
+
+def _render_judge(judge: dict[str, Any] | None) -> str:
+    if judge is None:
+        return ""
+    passed = bool(judge.get("passed", False))
+    overall = judge.get("overall")
+    overall_label = (
+        f"{overall:.0%}" if isinstance(overall, (int, float)) else "unknown"
+    )
+    dimensions: list[str] = []
+    for item in judge.get("dimensions", []):
+        score = item.get("score", "?")
+        dimensions.append(
+            '<div class="judge-dimension">'
+            '<div class="judge-score">'
+            f'<strong>{_text(item.get("name", "unnamed"))}</strong>'
+            f'<span class="judge-score-value">{_tally(score)}<b>{_text(score)}/5</b></span>'
+            "</div>"
+            f'<p>{_text(item.get("reason", ""))}</p>'
+            f'<p class="muted">Evidence: {_text(item.get("evidence", ""))}</p>'
+            "</div>"
+        )
+    return (
+        '<section class="subsection">'
+        '<div class="section-heading"><h4>Judge</h4>'
+        f'{_status(passed, kind="stamp", size="sm", seed="judge")}'
+        f'<span class="metric-inline">Overall {overall_label}</span>'
+        "</div>"
+        f'<div class="judge-grid">{"".join(dimensions)}</div>'
+        "</section>"
+    )
+
+
+def _new_turn_messages(
+    request_messages: Any, seen_messages: list[Any]
+) -> tuple[list[Any], int]:
+    """Diff a request's outgoing message list against the previous turn's.
+
+    Every LLM request in a run resends the full conversation so far, so
+    consecutive requests share an identical prefix. Returns the messages
+    that are new in this turn and a count of the (unchanged) prefix that
+    can be collapsed instead of re-rendered.
+    """
+    if not isinstance(request_messages, list):
+        return [], len(seen_messages)
+    if request_messages[: len(seen_messages)] == seen_messages:
+        return request_messages[len(seen_messages) :], len(seen_messages)
+    return request_messages, 0
+
+
+def _render_step(
+    step: StepResult,
+    requests: Sequence[dict[str, Any]],
+    *,
+    prior_messages: list[Any],
+) -> tuple[str, list[Any]]:
+    failed_checks = sum(
+        not check.get("passed", False) for check in step.hard_checks
+    )
+    judge_passed = step.judge_result is None or bool(
+        step.judge_result.get("passed", False)
+    )
+    passed = step.hard_pass and judge_passed
+    step_requests = sorted(
+        (request for request in requests if request.get("step_id") == step.step_id),
+        key=lambda request: request.get("request_index", 0),
+    )
+    events: list[str] = []
+    seen_messages = prior_messages
+    rendered_records: set[int] = set()
+    for request in step_requests:
+        invocation = request.get("invocation")
+        arguments = (
+            invocation.get("arguments", {}) if isinstance(invocation, dict) else {}
+        )
+        request_messages = arguments.get("messages") if isinstance(arguments, dict) else None
+        new_messages, hidden_count = _new_turn_messages(request_messages, seen_messages)
+        if hidden_count:
+            events.append(
+                '<div class="turn-prefix-note muted">'
+                f'{hidden_count} earlier message(s) already shown above (collapsed)'
+                "</div>"
+            )
+        for offset, message in enumerate(new_messages):
+            if not isinstance(message, dict):
+                continue
+            role = message.get("role", "message")
+            if role not in ("system", "user", "developer"):
+                continue
+            title = _title_for_role(role, hidden_count + offset)
+            events.append(_render_message(role, title, message.get("content")))
+        if isinstance(request_messages, list):
+            seen_messages = request_messages
+        events.append(_render_assistant_call(request))
+        request_index = request.get("request_index")
+        for record_index, record in enumerate(step.tool_calls):
+            if record.request_index == request_index:
+                events.append(_render_tool_call(record))
+                rendered_records.add(record_index)
+    events.extend(
+        _render_tool_call(record)
+        for record_index, record in enumerate(step.tool_calls)
+        if record_index not in rendered_records
+    )
+    if not step_requests or not isinstance(step_requests[-1].get("response"), dict):
+        events.append(
+            _render_message(
+                "assistant",
+                "Assistant response",
+                step.assistant_message.get("content", ""),
+            )
+        )
+    next_prior_messages = step.messages if step.messages else prior_messages
+    html = (
+        f'<details class="step" {"open" if not passed else ""}>'
+        "<summary>"
+        f'{_status(passed, kind="stamp", size="sm", seed=step.step_id)}'
+        f'<strong>{_text(step.step_id)}</strong>'
+        '<span class="summary-meta">'
+        f'{len(step.tool_calls)} tool calls · '
+        f'{len(step.hard_checks) - failed_checks}/{len(step.hard_checks)} checks passed'
+        "</span>"
+        "</summary>"
+        '<div class="step-body">'
+        '<details class="subsection timeline-section" open>'
+        '<summary><span>Execution timeline</span>'
+        f'<span class="muted">{len(events)} events</span></summary>'
+        f'<div class="timeline">{"".join(events)}</div></details>'
+        '<section class="subsection"><h4>Hard checks</h4>'
+        f'{_render_checks(step)}</section>'
+        f'{_render_judge(step.judge_result)}'
+        '<details class="raw"><summary>Resolved transcript</summary>'
+        f'<pre><code>{_json(step.messages)}</code></pre></details>'
+        "</div>"
+        "</details>"
+    )
+    return html, next_prior_messages
+
+
+def _render_request(request: dict[str, Any]) -> str:
+    resolved_provider = request.get("resolved_provider")
+    provider = (
+        f' · {_text(resolved_provider.get("name", ""))}'
+        if isinstance(resolved_provider, dict)
+        else ""
+    )
+    return (
+        '<details class="raw request">'
+        "<summary>"
+        f'Request {_text(request.get("request_index", "?"))} · '
+        f'{_text(request.get("step_id", "unknown step"))}{provider}'
+        "</summary>"
+        f'{_render_llm_request_details(request)}'
+        "</details>"
+    )
+
+
+def _render_mock_event(event: dict[str, Any]) -> str:
+    failed = bool(event.get("is_error", False))
+    match_failed = bool(event.get("match_failed", False))
+    return (
+        '<details class="raw mock-event">'
+        "<summary>"
+        f'{_status(not failed, kind="tick")}<strong>{_text(event.get("tool", "unknown"))}</strong>'
+        '<span class="summary-meta">'
+        f'call {event.get("call_index", "?")} · '
+        f'{event.get("duration_ms", "?")} ms · '
+        f'{_text(event.get("handler_kind", "unknown"))}'
+        f'{" · match failed" if match_failed else ""}'
+        "</span>"
+        "</summary>"
+        '<div class="split">'
+        '<div><h5>Arguments</h5>'
+        f'<pre><code>{_json(event.get("arguments", {}))}</code></pre></div>'
+        '<div><h5>Result</h5>'
+        f'<pre><code>{_json(event.get("result"))}</code></pre></div>'
+        "</div>"
+        '<h5>State diff</h5>'
+        f'<pre><code>{_json(event.get("state_diff", []))}</code></pre>'
+        "</details>"
+    )
+
+
+def _render_run(run: RunResult) -> str:
+    error = ""
+    if run.error:
+        error = (
+            '<div class="run-error"><strong>Run error</strong>'
+            f'<pre>{_text(run.error)}</pre>'
+            f'<details><summary>Traceback</summary><pre>{_text(run.traceback or "")}</pre></details>'
+            "</div>"
+        )
+    step_htmls: list[str] = []
+    seen_messages: list[Any] = []
+    for step in run.steps:
+        step_html, seen_messages = _render_step(step, run.requests, prior_messages=seen_messages)
+        step_htmls.append(step_html)
+    steps = "".join(step_htmls)
+    requests = "".join(_render_request(request) for request in run.requests)
+    mocks = "".join(_render_mock_event(event) for event in run.mock_events)
+    artifact = (
+        f'<span class="summary-meta">Artifacts: {_text(run.artifact_dir)}</span>'
+        if run.artifact_dir
+        else ""
+    )
+    return (
+        f'<details class="run" {"open" if not run.passed else ""}>'
+        "<summary>"
+        f'{_status(run.passed, kind="stamp", size="sm", seed=f"run-{run.run_index}")}'
+        f'<strong>Run {run.run_index}</strong>{artifact}'
+        "</summary>"
+        '<div class="run-body">'
+        f"{error}{steps}"
+        '<details class="diagnostics"><summary>LLM requests '
+        f'({len(run.requests)})</summary><div>{requests or "<p>No requests recorded.</p>"}</div></details>'
+        '<details class="diagnostics"><summary>Mock events '
+        f'({len(run.mock_events)})</summary><div>{mocks or "<p>No mock events recorded.</p>"}</div></details>'
+        '<details class="raw"><summary>Final mock state</summary>'
+        f'<pre><code>{_json(run.mock_state)}</code></pre></details>'
+        "</div>"
+        "</details>"
+    )
+
+
+def _render_fixtures(case: ResolvedCase) -> str:
+    if not case.fixture_manifest:
+        return '<p class="muted">No fixtures.</p>'
+    return '<div class="fixture-grid">' + "".join(
+        _render_content([fixture]) for fixture in case.fixture_manifest
+    ) + "</div>"
+
+
+def _render_case(case: ResolvedCase, result: CaseResult) -> str:
+    passed_runs = sum(run.passed for run in result.runs)
+    tools = ", ".join(tool.name for tool in case.tools) or "none"
+    skills = ", ".join(skill.name for skill in case.skills) or "none"
+    runs = "".join(_render_run(run) for run in result.runs)
+    return (
+        '<section class="case">'
+        '<header class="case-header">'
+        '<div><div class="eyebrow">Case</div>'
+        f'<h2>{_text(result.case_key)}</h2>'
+        f'<p class="path">{_text(case.path)}</p></div>'
+        '<div class="case-outcome">'
+        f'{_status(result.passed, kind="stamp", size="md", seed=result.case_key)}'
+        f'<strong>{result.pass_rate:.0%}</strong>'
+        f'<span>{passed_runs}/{len(result.runs)} runs passed</span>'
+        "</div>"
+        "</header>"
+        '<div class="metadata">'
+        f'<div><span>Model</span><strong>{_text(case.model.get("name", "unknown"))}</strong></div>'
+        f'<div><span>Tools</span><strong>{_text(tools)}</strong></div>'
+        f'<div><span>Skills</span><strong>{_text(skills)}</strong></div>'
+        "</div>"
+        '<details class="case-context"><summary>Resolved Case context</summary>'
+        '<div class="context-grid">'
+        '<div><h4>Execution</h4>'
+        f'<pre><code>{_json(case.execution)}</code></pre></div>'
+        '<div><h4>Model</h4>'
+        f'<pre><code>{_json(case.model)}</code></pre></div>'
+        "</div>"
+        '<h4>Input fixtures</h4>'
+        f'{_render_fixtures(case)}'
+        '<details class="raw"><summary>System prompt</summary>'
+        f'<pre>{_text(case.system_prompt)}</pre></details>'
+        "</details>"
+        f'<div class="runs">{runs}</div>'
+        "</section>"
+    )
+
+
+def render_html_report(
+    cases: Sequence[ResolvedCase], results: Sequence[CaseResult]
+) -> str:
+    if len(cases) != len(results):
+        raise ValueError("HTML report requires one result for every resolved case")
+
+    total_runs = sum(len(result.runs) for result in results)
+    passed_runs = sum(run.passed for result in results for run in result.runs)
+    checks = [
+        check
+        for result in results
+        for run in result.runs
+        for step in run.steps
+        for check in step.hard_checks
+    ]
+    passed_checks = sum(check.get("passed", False) for check in checks)
+    passed_cases = sum(result.passed for result in results)
+    overall_passed = passed_cases == len(results) and bool(results)
+    generated_at = datetime.now(timezone.utc).astimezone().isoformat(timespec="seconds")
+    rendered_cases = "".join(
+        _render_case(case, result) for case, result in zip(cases, results, strict=True)
+    )
+
+    return f"""<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Yama Eval Report</title>
+<style>
+:root {{
+  color-scheme: light dark;
+  --bg: #e7e6dd;
+  --surface: #f3f1e7;
+  --surface-2: #eae7da;
+  --text: #24261f;
+  --muted: #6b6c5e;
+  --border: #cfcdbb;
+  --accent: #33507d;
+  --pass: #2f6b4f;
+  --pass-bg: #dee7de;
+  --fail: #a6332a;
+  --fail-bg: #f1ded9;
+  --warn: #8a6a2c;
+  --system: #6b4c7a;
+  --system-bg: #e6dee8;
+  --user: #33507d;
+  --user-bg: #dce2ec;
+  --assistant: #2f6b4f;
+  --assistant-bg: #dee7de;
+  --tool: #8a6a2c;
+  --tool-bg: #ede4ce;
+  --code: #23241f;
+  --code-bg: #dbd9cb;
+  --font-display: "Iowan Old Style", "Palatino Linotype", "Songti SC", "Noto Serif SC", Georgia, "Times New Roman", serif;
+  --font-body: -apple-system, BlinkMacSystemFont, "PingFang SC", "Microsoft YaHei", "Segoe UI", "Noto Sans SC", sans-serif;
+  --font-mono: ui-monospace, "SF Mono", "Cascadia Code", "Roboto Mono", Consolas, Menlo, "Liberation Mono", monospace;
+}}
+@media (prefers-color-scheme: dark) {{
+  :root {{
+    --bg: #14161b;
+    --surface: #1b1e24;
+    --surface-2: #23262e;
+    --text: #e8e3d2;
+    --muted: #9c9d8d;
+    --border: #383a31;
+    --accent: #93a9d6;
+    --pass: #6fbf97;
+    --pass-bg: #1e3128;
+    --fail: #e2756a;
+    --fail-bg: #3a2320;
+    --warn: #d9ae63;
+    --system: #b79bc7;
+    --system-bg: #2c2436;
+    --user: #93a9d6;
+    --user-bg: #212a3a;
+    --assistant: #6fbf97;
+    --assistant-bg: #1e3128;
+    --tool: #d9ae63;
+    --tool-bg: #362b18;
+    --code: #e7e2d1;
+    --code-bg: #1b1d17;
+  }}
+}}
+* {{ box-sizing: border-box; }}
+body {{
+  margin: 0;
+  background-color: var(--bg);
+  background-image: repeating-linear-gradient(90deg, transparent 0 39px, color-mix(in srgb, var(--border) 55%, transparent) 39px 40px);
+  color: var(--text);
+  font-family: var(--font-body);
+  font-size: 14px;
+  line-height: 1.55;
+}}
+main {{ width: min(1500px, calc(100% - 32px)); margin: 32px auto 64px; }}
+h1, h2, h3, h4, h5, p {{ margin-top: 0; }}
+h1, h2, h3, h4 {{ font-family: var(--font-display); font-weight: 700; }}
+h1 {{ margin-bottom: 4px; font-size: 30px; letter-spacing: -.01em; }}
+h2 {{ margin-bottom: 4px; font-size: 21px; overflow-wrap: anywhere; }}
+h3 {{ margin: 0; font-size: 16px; }}
+h4 {{ margin-bottom: 12px; font-size: 15px; }}
+h5 {{ margin: 0 0 6px; color: var(--muted); font-family: var(--font-display); text-transform: uppercase; letter-spacing: .08em; font-size: 11px; font-weight: 600; }}
+a {{ color: var(--accent); }}
+summary {{ cursor: pointer; list-style-position: outside; }}
+summary:focus-visible, a:focus-visible, .verdict:focus-visible {{ outline: 2px solid var(--accent); outline-offset: 3px; border-radius: 3px; }}
+.report-header {{ display: flex; justify-content: space-between; align-items: flex-end; gap: 24px; padding-bottom: 18px; margin-bottom: 26px; border-bottom: 5px double color-mix(in srgb, var(--text) 45%, transparent); }}
+.report-header > div {{ min-width: 0; }}
+.report-header p, .path, .muted, .summary-meta {{ color: var(--muted); }}
+.report-header p {{ font-family: var(--font-mono); font-size: 12px; letter-spacing: .02em; }}
+.overall {{ display: flex; flex-direction: column; align-items: flex-end; gap: 8px; }}
+.overall span {{ font-family: var(--font-display); text-transform: uppercase; letter-spacing: .12em; font-size: 11px; color: var(--muted); }}
+.summary-grid {{ display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)); background: var(--surface); border: 1px solid var(--border); border-radius: 6px; margin-bottom: 30px; overflow: clip; }}
+.summary-card {{ padding: 16px 22px; border-right: 1px solid var(--border); }}
+.summary-card:last-child {{ border-right: 0; }}
+.summary-card span {{ display: block; color: var(--muted); font-family: var(--font-display); text-transform: uppercase; letter-spacing: .08em; font-size: 11px; }}
+.summary-card strong {{ display: block; margin-top: 6px; font-family: var(--font-mono); font-size: 25px; font-weight: 600; }}
+
+/* Verdicts: quiet ticks for high-frequency rows (checks, mock events);
+   stamped chops for the handful of hierarchical calls per report
+   (report/case/run/step/judge) — ceremony scales with significance,
+   not with how often a verdict appears. */
+.verdict {{ display: inline-flex; align-items: center; width: max-content; white-space: nowrap; }}
+.verdict.tick {{ gap: 6px; font-family: var(--font-mono); font-size: 11px; font-weight: 600; letter-spacing: .04em; }}
+.verdict.tick.pass {{ color: var(--pass); }}
+.verdict.tick.fail {{ color: var(--fail); }}
+.tick-mark {{ width: 6px; height: 6px; border-radius: 50%; background: currentColor; flex: none; }}
+.verdict.stamp {{
+  --tilt: 0deg;
+  position: relative;
+  justify-content: center;
+  font-family: var(--font-display);
+  font-weight: 700;
+  text-transform: uppercase;
+  letter-spacing: .1em;
+  border: 2px solid currentColor;
+  border-radius: 3px 9px 4px 8px / 8px 4px 9px 3px;
+  padding: 3px 11px;
+  font-size: 11px;
+  background: color-mix(in srgb, currentColor 10%, transparent);
+  box-shadow: 0 0 0 3px color-mix(in srgb, currentColor 14%, transparent);
+  transform: rotate(var(--tilt));
+  transition: transform .15s ease;
+}}
+.verdict.stamp.pass {{ color: var(--pass); }}
+.verdict.stamp.fail {{ color: var(--fail); }}
+.verdict.stamp.size-sm {{ font-size: 10px; padding: 2px 9px; }}
+.verdict.stamp.size-md {{ font-size: 12px; padding: 4px 13px; }}
+.verdict.stamp.size-lg {{ font-size: 17px; padding: 8px 22px; letter-spacing: .16em; }}
+.verdict.stamp.size-lg::before {{
+  content: "";
+  position: absolute;
+  inset: -14px;
+  border-radius: inherit;
+  background: radial-gradient(circle, color-mix(in srgb, currentColor 16%, transparent), transparent 72%);
+}}
+.case {{ background: var(--surface); border: 1px solid var(--border); border-radius: 6px; margin-bottom: 20px; overflow: clip; }}
+.case-header {{ display: flex; justify-content: space-between; gap: 24px; padding: 20px; border-bottom: 1px solid var(--border); }}
+.case-header > div {{ min-width: 0; }}
+.case-header .path {{ margin: 0; overflow-wrap: anywhere; font-family: var(--font-mono); font-size: 12px; }}
+.eyebrow {{ color: var(--muted); font-family: var(--font-display); text-transform: uppercase; letter-spacing: .12em; font-size: 11px; }}
+.case-outcome {{ min-width: 130px; display: grid; justify-items: end; align-content: start; gap: 5px; }}
+.case-outcome strong {{ font-family: var(--font-mono); font-size: 22px; }}
+.metadata {{ display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)); border-bottom: 1px solid var(--border); }}
+.metadata > div {{ min-width: 0; padding: 14px 20px; border-right: 1px solid var(--border); }}
+.metadata > div:last-child {{ border-right: 0; }}
+.metadata span, .metadata strong {{ display: block; }}
+.metadata span {{ color: var(--muted); font-family: var(--font-display); text-transform: uppercase; letter-spacing: .06em; font-size: 11px; }}
+.metadata strong {{ overflow-wrap: anywhere; font-weight: 600; }}
+.case-context {{ padding: 14px 20px; border-bottom: 1px solid var(--border); }}
+.case-context > summary, .diagnostics > summary {{ font-weight: 650; }}
+.case-context[open] > summary, .diagnostics[open] > summary {{ margin-bottom: 14px; }}
+.context-grid, .split {{ display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 12px; }}
+.run {{ border-bottom: 1px solid var(--border); }}
+.run:last-child {{ border-bottom: 0; }}
+.run > summary, .step > summary {{ display: flex; align-items: center; gap: 10px; padding: 14px 20px; }}
+.run > summary {{ background: var(--surface-2); }}
+.run-body {{ padding: 0 20px 20px; }}
+.step {{ margin-top: 16px; border: 1px solid var(--border); border-radius: 5px; overflow: clip; }}
+.step > summary {{ background: var(--surface-2); }}
+.step-body {{ padding: 18px; }}
+.summary-meta {{ margin-left: auto; font-size: 12px; }}
+.subsection {{ margin-bottom: 22px; }}
+.section-heading {{ display: flex; align-items: center; gap: 10px; }}
+.section-heading h4 {{ margin: 0; }}
+.metric-inline {{ color: var(--muted); }}
+.timeline {{ border-left: 2px solid var(--border); margin-left: 8px; padding-left: 20px; }}
+.event {{ position: relative; margin-bottom: 14px; border: 1px solid transparent; border-radius: 6px; padding: 14px; }}
+.event::before {{ content: ""; position: absolute; left: -29px; top: 21px; width: 8px; height: 8px; background: var(--accent); border: 2px solid var(--surface); transform: rotate(45deg); }}
+.event.system {{ color: var(--text); background: var(--system-bg); border-color: color-mix(in srgb, var(--system) 35%, transparent); }}
+.event.system::before {{ background: var(--system); }}
+.event.user {{ color: var(--text); background: var(--user-bg); border-color: color-mix(in srgb, var(--user) 35%, transparent); }}
+.event.user::before {{ background: var(--user); }}
+.event.assistant {{ color: var(--text); background: var(--assistant-bg); border-color: color-mix(in srgb, var(--assistant) 35%, transparent); }}
+.event.assistant::before {{ background: var(--assistant); }}
+.event.tool {{ color: var(--text); background: var(--tool-bg); border-color: color-mix(in srgb, var(--tool) 35%, transparent); }}
+.event.tool::before {{ background: var(--tool); }}
+.event.error::before {{ background: var(--fail); }}
+.event-head {{ display: flex; align-items: center; flex-wrap: wrap; gap: 8px; margin-bottom: 10px; }}
+.event-kind {{ color: var(--muted); font-family: var(--font-display); text-transform: uppercase; letter-spacing: .08em; font-size: 10px; }}
+.message-content {{ white-space: pre-wrap; overflow-wrap: anywhere; background: transparent; color: var(--text); padding: 0; margin: 0; font-family: var(--font-mono); }}
+.model-input h5 {{ margin-top: 12px; }}
+.empty-content {{ color: var(--muted); font-style: italic; }}
+.empty-content code {{ font-style: normal; }}
+.model-error {{ color: var(--fail); }}
+.turn-prefix-note {{ margin: -4px 0 14px; font-size: 12px; font-style: italic; }}
+.tool-list {{ margin-top: 12px; }}
+.tool-list > summary {{ color: var(--muted); font-size: 12px; }}
+.tool-list-grid {{ display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 8px; margin-top: 10px; }}
+.tool-def {{ background: var(--surface-2); border-radius: 6px; padding: 10px; min-width: 0; }}
+.tool-def-head {{ font-weight: 650; font-family: var(--font-mono); }}
+.tool-def p {{ margin: 4px 0; }}
+.timeline-section > summary {{ display: flex; align-items: center; gap: 10px; margin-bottom: 12px; font-weight: 650; }}
+.timeline-section > summary .muted {{ margin-left: auto; font-size: 12px; }}
+.timeline-section:not([open]) > summary {{ margin-bottom: 0; }}
+pre {{ margin: 0; max-height: 520px; overflow: auto; border-radius: 5px; padding: 12px; background: var(--code-bg); color: var(--code); white-space: pre-wrap; overflow-wrap: anywhere; font-family: var(--font-mono); }}
+.table-wrap {{ overflow-x: auto; }}
+table {{ width: 100%; border-collapse: collapse; }}
+th, td {{ padding: 10px; border-bottom: 1px solid var(--border); text-align: left; vertical-align: top; min-width: 100px; }}
+th {{ color: var(--muted); font-family: var(--font-display); font-size: 11px; text-transform: uppercase; letter-spacing: .06em; }}
+tr.failed td {{ background: color-mix(in srgb, var(--fail-bg) 45%, transparent); }}
+.judge-grid, .fixture-grid {{ display: grid; grid-template-columns: repeat(auto-fit, minmax(220px, 1fr)); gap: 10px; }}
+.judge-dimension, .attachment {{ background: var(--surface-2); border-radius: 6px; padding: 12px; }}
+.judge-score {{ display: flex; justify-content: space-between; align-items: center; gap: 12px; }}
+.judge-score-value {{ display: inline-flex; align-items: center; }}
+.judge-score-value b {{ font-family: var(--font-mono); font-weight: 600; margin-left: 6px; }}
+.tally {{ display: inline-flex; align-items: center; gap: 2px; }}
+.tally-bar {{ width: 3px; height: 14px; border-radius: 1px; background: color-mix(in srgb, var(--muted) 30%, transparent); }}
+.tally-bar.filled {{ background: var(--pass); }}
+.judge-dimension p {{ margin: 8px 0 0; }}
+.attachment {{ min-width: 0; }}
+.image-attachment img {{ display: block; width: 100%; max-height: 260px; object-fit: contain; border-radius: 5px; background: var(--code-bg); }}
+.image-attachment figcaption, .file-attachment a {{ display: flex; justify-content: space-between; gap: 8px; margin-top: 8px; }}
+.attachment-name {{ font-weight: 650; }}
+.file-attachment .path {{ display: block; margin-top: 8px; font-size: 12px; overflow-wrap: anywhere; }}
+.raw, .diagnostics {{ margin-top: 12px; }}
+.raw > summary, .diagnostics > summary {{ color: var(--accent); }}
+.raw[open] > summary {{ margin-bottom: 8px; }}
+.request, .mock-event {{ padding: 10px 0; border-bottom: 1px solid var(--border); }}
+.request > summary, .mock-event > summary {{ display: flex; align-items: center; gap: 8px; }}
+.run-error {{ margin-top: 16px; padding: 14px; border-radius: 6px; background: var(--fail-bg); color: var(--fail); }}
+.run-error pre {{ margin-top: 8px; }}
+@media (prefers-reduced-motion: reduce) {{
+  * {{ transition: none !important; animation: none !important; }}
+}}
+@media (max-width: 760px) {{
+  main {{ width: min(100% - 20px, 1500px); margin-top: 16px; }}
+  .report-header, .case-header {{ display: grid; }}
+  .overall {{ align-items: flex-start; }}
+  .case-outcome {{ justify-items: start; }}
+  .summary-grid, .metadata, .context-grid, .split {{ grid-template-columns: 1fr; }}
+  .summary-card {{ border-right: 0; border-bottom: 1px solid var(--border); }}
+  .summary-card:last-child {{ border-bottom: 0; }}
+  .metadata > div {{ border-right: 0; border-bottom: 1px solid var(--border); }}
+  .metadata > div:last-child {{ border-bottom: 0; }}
+  .run > summary, .step > summary {{ align-items: flex-start; flex-wrap: wrap; }}
+  .summary-meta {{ width: 100%; margin-left: 0; }}
+  .step-body, .run-body {{ padding-left: 12px; padding-right: 12px; }}
+}}
+</style>
+</head>
+<body>
+<main>
+  <header class="report-header">
+    <div><h1>Yama Eval Report</h1><p>Generated {_text(generated_at)}</p></div>
+    <div class="overall">{_status(overall_passed, kind="stamp", size="lg", seed="overall")}<span>Overall result</span></div>
+  </header>
+  <section class="summary-grid" aria-label="Summary">
+    <div class="summary-card"><span>Cases passed</span><strong>{passed_cases}/{len(results)}</strong></div>
+    <div class="summary-card"><span>Runs passed</span><strong>{passed_runs}/{total_runs}</strong></div>
+    <div class="summary-card"><span>Hard checks passed</span><strong>{passed_checks}/{len(checks)}</strong></div>
+  </section>
+  {rendered_cases or '<p>No cases were included in this report.</p>'}
+</main>
+</body>
+</html>
+"""
+
+
+def write_html_report(
+    cases: Sequence[ResolvedCase],
+    results: Sequence[CaseResult],
+    path: Path,
+) -> Path:
+    target = path.expanduser().resolve()
+    target.parent.mkdir(parents=True, exist_ok=True)
+    target.write_text(render_html_report(cases, results), encoding="utf-8")
+    return target