Add files using upload-large-folder tool

tasks/d1-c1-admanualgc-on-univ00-universal_ttd15m_at_off+10m/environment/Dockerfile

@@ -0,0 +1 @@
+FROM ag2435/sre-otel-snapshot:{code_tag}

tasks/d1-c1-admanualgc-on-univ00-universal_ttd15m_at_off+10m/environment/docker-compose.yaml

@@ -0,0 +1,21 @@
+services:
+  main:
+    build:
+      context: ${CONTEXT_DIR}
+      pull: true
+    image: ${MAIN_IMAGE_NAME}
+    command: [ "sh", "-c", "sleep infinity" ]
+    privileged: true
+    environment:
+      - TEST_DIR=${TEST_DIR}
+      - CONTEXT_DIR=${CONTEXT_DIR}
+    volumes:
+      - /var/run/docker.sock:/var/run/docker.sock
+      - ${CONTEXT_DIR}:${CONTEXT_DIR}
+      - ${HOST_VERIFIER_LOGS_PATH}:${ENV_VERIFIER_LOGS_PATH}
+      - ${HOST_AGENT_LOGS_PATH}:${ENV_AGENT_LOGS_PATH}
+    deploy:
+      resources:
+        limits:
+          cpus: ${CPUS}
+          memory: ${MEMORY}

tasks/d1-c1-admanualgc-on-univ00-universal_ttd15m_at_off+10m/solution/check_prediction.py

@@ -0,0 +1,1005 @@
+"""LLM-as-a-judge verifier for Harbor incident-RCA-report tasks.
+
+Supports two modes:
+
+1. **Harbor verifier** (default):
+       python /tests/check_prediction.py
+
+2. **Post-hoc single-trial**:
+       python check_prediction.py --expected expected.json --predictions report.md [--rubric rubric.json]
+
+Falls back to string-match scoring when OPENAI_API_KEY is not set.
+"""
+
+import argparse
+import asyncio
+import json
+import logging
+import os
+import sys
+import traceback
+from pathlib import Path
+from typing import Any
+
+from tabulate import tabulate
+
+logger = logging.getLogger(__name__)
+
+JUDGE_PROMPT_MULTI_HEADER = """\
+You are an expert SRE tasked with judging the quality of an AI-generated incident RCA report.
+
+You are given:
+1. **One or more** ground-truth rubrics. Each describes a plausible root cause, its incident time, mechanism, and symptoms. Several flags may have been active in the same window; the agent is credited if it correctly identifies **any one** of these rubrics.
+2. The SRE agent's incident RCA report.
+
+## SRE Agent's Incident RCA Report
+
+{predictions}
+
+## Ground-Truth Rubrics
+
+{rubrics}
+
+## Evaluation Questions
+
+For **each rubric** in order, answer every question with true or false. Base your answer only on evidence in the agent's report; if the report does not cite the required evidence, answer false. The output must contain one entry per rubric, in the same order, and must preserve cluster order within each rubric exactly as listed.
+
+For each rubric:
+
+- `incident_time_within_10min`: Did the agent's timeline place the incident start within ±10 minutes of this rubric's `incident_time`?
+- `feature_flag_match`: Did the agent identify this rubric's feature flag as a root cause? (The agent may name multiple flags; mark true if this flag is among them.)
+- `mechanism_match`: Did the agent correctly explain this rubric's mechanism — how the flag propagates to the user-visible failure?
+- For each metric/log/trace cluster listed for this rubric: per-cluster match flags as before.
+"""
+
+JUDGE_PROMPT_SCORING_FOOTER = """\
+
+## Overall Score
+
+Score the incident RCA report on a scale of 0 to 3. The agent is credited if it correctly identifies **any one** of the listed rubrics — score against the rubric the agent's report best matches. Scoring is based on content correctness only; do not penalize or reward for formatting, prose style, or structural polish. Materially incorrect or misleading claims count against the score: if the report would otherwise score N but also adds a materially wrong claim (e.g., invents an unrelated additional cause), drop to N-1 (floor at 0). A report that correctly identifies one root cause but introduces a misleading fabrication alongside it therefore scores 2, not 3. When applying this penalty, explicitly identify in your reasoning which specific claim is materially wrong — quote or paraphrase the offending text. Do not apply the penalty without naming the offending claim; missing detail or incomplete explanation does not qualify as a materially wrong claim. Naming several of the listed plausible root causes is **not** a materially wrong claim.
+
+- 0: AI findings are misaligned with every rubric's mechanism and completely miss the root cause
+- 1: AI verifies incident description — the report confirms symptoms described in the task prompt but does not investigate further
+- 2: AI makes correct progress beyond symptoms — the report identifies some of the ground-truth metrics, logs, or traces for at least one rubric and moves toward that root cause, but does not fully identify any single root cause
+- 3: AI nails at least one of the listed root causes — the report correctly identifies it, the mechanism, and the supporting signals
+
+Respond with ONLY a JSON object matching the provided output schema.
+"""
+
+DEFAULT_MODEL = "openai-gpt-5.4"
+
+
+# ---------------------------------------------------------------------------
+# Rubric rendering (JSON -> markdown)
+# ---------------------------------------------------------------------------
+
+
+def _format_log_clusters(clusters: list[dict], lines: list[str]) -> None:
+    """Render log clusters as markdown subsections."""
+    for cluster in clusters:
+        name = cluster.get("name", "Unknown")
+        count = cluster.get("count")
+        suffix = f" ({count} entries)" if count is not None else ""
+        lines.append(f"#### {name}{suffix}")
+        lines.append("")
+
+        description = cluster.get("description", "")
+        if description:
+            lines.append(description)
+            lines.append("")
+
+        cause = cluster.get("cause", "")
+        if cause:
+            lines.append(f"**Cause:** {cause}")
+            lines.append("")
+
+        source = cluster.get("source", "")
+        if source:
+            lines.append(f"**Source:** {source}")
+            lines.append("")
+
+        attrs = cluster.get("representative_attributes", {})
+        if attrs:
+            lines.append("**Representative attributes:**")
+            lines.append("")
+            rows = [[f"`{k}`", f"`{v}`"] for k, v in attrs.items()]
+            lines.append(tabulate(rows, headers=["Field", "Value"], tablefmt="github"))
+            lines.append("")
+
+        docs = cluster.get("log_documents", [])
+        if docs:
+            lines.append("**Log documents:**")
+            lines.append("")
+            rows = [
+                [f"`{d['_index']}`", f"`{d['_id']}`", d["@timestamp"]] for d in docs
+            ]
+            lines.append(
+                tabulate(
+                    rows, headers=["_index", "_id", "@timestamp"], tablefmt="github"
+                )
+            )
+            lines.append("")
+
+
+def _format_trace_clusters(clusters: list[dict], lines: list[str]) -> None:
+    """Render trace clusters as markdown subsections."""
+    for cluster in clusters:
+        name = cluster.get("name", "Unknown")
+        count = cluster.get("count")
+        suffix = f" ({count} traces)" if count is not None else ""
+        lines.append(f"#### {name}{suffix}")
+        lines.append("")
+
+        description = cluster.get("description", "")
+        if description:
+            lines.append(description)
+            lines.append("")
+
+        cause = cluster.get("cause", "")
+        if cause:
+            lines.append(f"**Cause:** {cause}")
+            lines.append("")
+
+        call_chain = cluster.get("call_chain", "")
+        if call_chain:
+            lines.append("**Call chain:**")
+            lines.append("")
+            lines.append("```")
+            lines.append(call_chain)
+            lines.append("```")
+            lines.append("")
+
+        smoking_gun = cluster.get("smoking_gun", [])
+        if smoking_gun:
+            lines.append("**Smoking-gun error messages:**")
+            lines.append("")
+            for msg in smoking_gun:
+                lines.append(f"- {msg}")
+            lines.append("")
+
+        docs = cluster.get("trace_documents", [])
+        if docs:
+            lines.append("**Trace documents:**")
+            lines.append("")
+            headers = ["traceID", "@timestamp"]
+            has_action = any("user_action" in d for d in docs)
+            if has_action:
+                headers.append("user_action")
+            rows = []
+            for d in docs:
+                row = [f"`{d['traceID']}`", d["@timestamp"]]
+                if has_action:
+                    row.append(d.get("user_action", ""))
+                rows.append(row)
+            lines.append(tabulate(rows, headers=headers, tablefmt="github"))
+            lines.append("")
+
+
+_LAYER_DESCRIPTIONS = {
+    "root_cause": "metric closest to the fault injection point",
+    "propagation": "intermediate services reflecting the error through the call chain",
+    "symptom": "user-facing impact visible to end users or clients",
+    "meta": "feature flag counters or internal plumbing",
+    "unknown": "unclassified",
+}
+
+_LAYER_ORDER = ["root_cause", "propagation", "symptom", "meta", "unknown"]
+
+
+def _format_onset(offset: int | None) -> str:
+    """Format an onset offset as '+Xs' or 'N/A'."""
+    if offset is None:
+        return "N/A"
+    return f"+{offset}s"
+
+
+def _format_label_values(labels: dict[str, str]) -> str:
+    """Format label values as a compact comma-separated string."""
+    if not labels:
+        return ""
+    return ", ".join(labels.values())
+
+
+def _earliest_onset(variants: list[dict]) -> int | None:
+    """Return the earliest onset_offset_seconds across variants, or None."""
+    offsets = [
+        v["onset_offset_seconds"]
+        for v in variants
+        if v.get("onset_offset_seconds") is not None
+    ]
+    return min(offsets) if offsets else None
+
+
+def _format_metrics_list(metrics_list: list[dict], lines: list[str]) -> None:
+    """Render metric families grouped by signal layer."""
+    by_layer: dict[str, list[dict]] = {}
+    for fam in metrics_list:
+        by_layer.setdefault(fam.get("signal_layer", "unknown"), []).append(fam)
+
+    for layer in _LAYER_ORDER:
+        layer_families = by_layer.get(layer, [])
+        if not layer_families:
+            continue
+
+        layer_onsets = [_earliest_onset(f["variants"]) for f in layer_families]
+        layer_onsets = [o for o in layer_onsets if o is not None]
+        layer_onset_str = (
+            f" (earliest onset: {_format_onset(min(layer_onsets))})"
+            if layer_onsets
+            else ""
+        )
+
+        display_layer = layer.replace("_", " ").title()
+        desc = _LAYER_DESCRIPTIONS.get(layer, "")
+        lines.append(f"**{display_layer}** — {desc}{layer_onset_str}")
+        lines.append("")
+
+        for fam in layer_families:
+            fam_onset = _earliest_onset(fam["variants"])
+            label_vals = _format_label_values(fam.get("defining_labels", {}))
+            label_part = f" ({label_vals})" if label_vals else ""
+            lines.append(
+                f"#### {fam['metric_family']} family{label_part}"
+                f" — onset: {_format_onset(fam_onset)}"
+            )
+            lines.append("")
+
+            first_desc = (
+                fam["variants"][0].get("description", "") if fam["variants"] else ""
+            )
+            if first_desc:
+                lines.append(first_desc)
+                lines.append("")
+
+            for v in fam["variants"]:
+                v_onset = _format_onset(v.get("onset_offset_seconds"))
+                lines.append(f"- **{v['type']}** (onset: {v_onset})")
+                lines.append(f"  `{v['query']}`")
+                lines.append("")
+
+
+def _format_frontend_issues(issues: list[dict], lines: list[str]) -> None:
+    """Render frontend issues as markdown subsections."""
+    for issue in issues:
+        route = issue.get("route", "Unknown route")
+        lines.append(f"#### {route}")
+        lines.append("")
+
+        description = issue.get("description", "")
+        if description:
+            lines.append(description)
+            lines.append("")
+
+        rows = [
+            ["Deterministic", str(issue.get("deterministic", ""))],
+            ["Trigger condition", issue.get("trigger_condition", "")],
+            ["Calling service", issue.get("calling_service", "")],
+            [
+                "Source",
+                f"`{issue.get('source_file', '')}:{issue.get('source_line', '')}`",
+            ],
+        ]
+        lines.append(tabulate(rows, headers=["Field", "Value"], tablefmt="github"))
+        lines.append("")
+
+        call_pattern = issue.get("call_pattern", "")
+        if call_pattern:
+            lines.append(f"**Call pattern:** {call_pattern}")
+            lines.append("")
+
+        cause = issue.get("cause", "")
+        if cause:
+            lines.append(f"**Cause:** {cause}")
+            lines.append("")
+
+
+def format_rubric(data: dict, include_frontend: bool = False) -> str:
+    """Convert a rubric JSON dict into a consistently formatted markdown string.
+
+    Args:
+        data: The rubric JSON dict.
+        include_frontend: If True, include the ``### Frontend`` section.
+            Defaults to False since frontend symptoms may be noisy for
+            downstream consumers (LLM judge, oracle solutions).
+            TODO(Albert): systematically test the impact of including vs.
+            excluding frontend symptoms on downstream consumers.
+
+    """
+    lines: list[str] = []
+
+    lines.append(f"# {data['feature_flag']}")
+    lines.append("")
+    lines.append(f"**Feature flag:** `{data['feature_flag']}`")
+    lines.append("")
+    lines.append(f"**Description:** {data['description']}")
+    lines.append("")
+    lines.append(f"**Incident time:** {data['incident_time']}")
+    lines.append("")
+
+    lines.append("## Mechanism")
+    lines.append("")
+    lines.append(data["mechanism"])
+    lines.append("")
+
+    interaction = data.get("interaction", "")
+    if interaction:
+        lines.append(f"**Interaction with other feature flags:** {interaction}")
+        lines.append("")
+
+    lines.append("## Evidence")
+    lines.append("")
+
+    gs = data["symptoms"]
+
+    metrics = gs.get("metrics", [])
+    lines.append("### Metrics")
+    lines.append("")
+    if metrics:
+        _format_metrics_list(metrics, lines)
+
+    logs = gs.get("logs", [])
+    lines.append("### Logs")
+    lines.append("")
+    if logs:
+        _format_log_clusters(logs, lines)
+
+    if include_frontend:
+        frontend = gs.get("frontend", [])
+        lines.append("### Frontend")
+        lines.append("")
+        if frontend:
+            _format_frontend_issues(frontend, lines)
+
+    traces = gs.get("traces", [])
+    lines.append("### Traces")
+    lines.append("")
+    if traces:
+        _format_trace_clusters(traces, lines)
+
+    return "\n".join(lines)
+
+
+# ---------------------------------------------------------------------------
+# Judge prompt + output-schema builders
+# ---------------------------------------------------------------------------
+
+
+def _render_checklist(rubric_data: dict) -> str:
+    """Build per-cluster checklist blocks for metrics/logs/traces."""
+    symptoms = rubric_data.get("symptoms", {}) or {}
+    metric_clusters = symptoms.get("metrics", []) or []
+    log_clusters = symptoms.get("logs", []) or []
+    trace_clusters = symptoms.get("traces", []) or []
+
+    blocks: list[str] = []
+
+    if metric_clusters:
+        lines = ["#### Metric clusters"]
+        for i, m in enumerate(metric_clusters):
+            family = m.get("metric_family", "")
+            lines.append(
+                f'- Cluster {i}: `metric_family = "{family}"`'
+                f" — family_match: did the agent cite a query targeting"
+                f" metric_family `{family}` under a Why-step whose causal chain"
+                f" aligns with the rubric?"
+            )
+        blocks.append("\n".join(lines))
+
+    if log_clusters:
+        lines = ["#### Log clusters"]
+        for i, log in enumerate(log_clusters):
+            attrs = log.get("representative_attributes") or {}
+            body = attrs.get("body", "")
+            service_name = attrs.get("resource.service.name", "")
+            lines.append(
+                f"- Cluster {i}:\n"
+                f"  - `resource.service.name`: `{service_name}`\n"
+                f"  - `body`: `{body}`\n"
+                f"  - body_match: did the agent cite log evidence whose body"
+                f" matches the rubric's `body` under a Why-step whose causal"
+                f" chain aligns with the rubric?\n"
+                f"  - service_name_match: did the agent attribute the cited"
+                f" log evidence to the OTel service `{service_name}`"
+                f" (`resource.service.name`)?"
+            )
+        blocks.append("\n".join(lines))
+
+    if trace_clusters:
+        lines = ["#### Trace clusters"]
+        for i, trace in enumerate(trace_clusters):
+            call_chain = trace.get("call_chain", "")
+            smoking_gun = trace.get("smoking_gun", []) or []
+            sg_rendered = "\n".join(f"    - {s}" for s in smoking_gun)
+            lines.append(
+                f"- Cluster {i}:\n"
+                f"  - call_chain: `{call_chain}`\n"
+                f"  - smoking_gun:\n{sg_rendered}\n"
+                f"  - call_chain_match: did the agent cite evidence matching"
+                f" this service-level call chain under a Why-step whose causal"
+                f" chain aligns with the rubric?\n"
+                f"  - smoking_gun_match: did the agent cite at least one of"
+                f" the listed smoking-gun signals?"
+            )
+        blocks.append("\n".join(lines))
+
+    return (
+        "\n\n".join(blocks)
+        if blocks
+        else "(No metric, log, or trace clusters in rubric.)"
+    )
+
+
+def build_judge_prompt(
+    rubrics_data: list[dict],
+    predictions: str,
+) -> str:
+    """Render the judge prompt for one or more ground-truth rubrics.
+
+    The prompt asks the LLM to evaluate the agent's report against **each**
+    rubric independently. The agent is credited if it correctly identifies
+    any one rubric (the overall score reflects the best match).
+    """
+    if not rubrics_data:
+        raise ValueError("build_judge_prompt called with no rubrics")
+
+    rubric_blocks: list[str] = []
+    checklist_blocks: list[str] = []
+    for i, rubric in enumerate(rubrics_data):
+        feature_flag = rubric.get("feature_flag", "")
+        rubric_blocks.append(
+            f"### Rubric {i + 1} of {len(rubrics_data)} — `{feature_flag}`\n\n"
+            + format_rubric(rubric)
+        )
+        checklist_blocks.append(
+            f"### Rubric {i + 1} of {len(rubrics_data)} — `{feature_flag}`\n\n"
+            + _render_checklist(rubric)
+        )
+
+    rubrics_text = "\n\n---\n\n".join(rubric_blocks)
+    checklist_text = "\n\n---\n\n".join(checklist_blocks)
+
+    header = JUDGE_PROMPT_MULTI_HEADER.format(
+        rubrics=rubrics_text,
+        predictions=predictions,
+    )
+    return header + "\n" + checklist_text + "\n" + JUDGE_PROMPT_SCORING_FOOTER
+
+
+_METRIC_ITEM_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        "metric_family": {"type": "string"},
+        "family_match": {"type": "boolean"},
+    },
+    "required": ["metric_family", "family_match"],
+    "additionalProperties": False,
+}
+
+_LOG_ITEM_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        "body_match": {"type": "boolean"},
+        "service_name_match": {"type": "boolean"},
+    },
+    "required": ["body_match", "service_name_match"],
+    "additionalProperties": False,
+}
+
+_TRACE_ITEM_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        "call_chain_match": {"type": "boolean"},
+        "smoking_gun_match": {"type": "boolean"},
+    },
+    "required": ["call_chain_match", "smoking_gun_match"],
+    "additionalProperties": False,
+}
+
+
+_PER_RUBRIC_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        "feature_flag": {"type": "string"},
+        "incident_time_within_10min": {"type": "boolean"},
+        "feature_flag_match": {"type": "boolean"},
+        "mechanism_match": {"type": "boolean"},
+        "symptoms": {
+            "type": "object",
+            "properties": {
+                "metrics": {"type": "array", "items": _METRIC_ITEM_SCHEMA},
+                "logs": {"type": "array", "items": _LOG_ITEM_SCHEMA},
+                "traces": {"type": "array", "items": _TRACE_ITEM_SCHEMA},
+            },
+            "required": ["metrics", "logs", "traces"],
+            "additionalProperties": False,
+        },
+    },
+    "required": [
+        "feature_flag",
+        "incident_time_within_10min",
+        "feature_flag_match",
+        "mechanism_match",
+        "symptoms",
+    ],
+    "additionalProperties": False,
+}
+
+
+def build_judge_output_schema(rubrics_data: list[dict]) -> dict:
+    """Build a strict JSON Schema for the judge output: one verdict per rubric
+    + an overall ``score`` integer. Falls back to a minimal ``{score: int}``
+    schema when no rubrics are supplied (no-incident path).
+
+    Per-rubric cluster-array lengths vary across rubrics; rather than encode
+    a per-element schema (which Structured Outputs doesn't support), we leave
+    the array lengths unconstrained and rely on the prompt instructions to
+    keep cluster order matching.
+    """
+    if not rubrics_data:
+        return {
+            "type": "object",
+            "properties": {"score": {"type": "integer"}},
+            "required": ["score"],
+            "additionalProperties": False,
+        }
+
+    n = len(rubrics_data)
+    return {
+        "type": "object",
+        "properties": {
+            "rubrics": {
+                "type": "array",
+                "minItems": n,
+                "maxItems": n,
+                "items": _PER_RUBRIC_SCHEMA,
+            },
+            "score": {"type": "integer"},
+        },
+        "required": ["rubrics", "score"],
+        "additionalProperties": False,
+    }
+
+
+# ---------------------------------------------------------------------------
+# API call
+# ---------------------------------------------------------------------------
+
+
+async def async_call_llm_judge(
+    client: Any,
+    prompt: str,
+    model: str = DEFAULT_MODEL,
+    reasoning_effort: str | None = None,
+    output_schema: dict | None = None,
+) -> tuple[str, list[dict] | None]:
+    """Call the LLM judge via the OpenAI Responses API (falling back to Chat).
+
+    When ``output_schema`` is provided, uses Structured Outputs (strict JSON
+    Schema) so the returned text is guaranteed to conform to the schema.
+
+    Returns:
+        A tuple of (output_text, reasoning_summaries). reasoning_summaries is
+        None when reasoning_effort is not set.
+
+    """
+    text_format: dict[str, Any] = (
+        {
+            "type": "json_schema",
+            "name": "judge_response",
+            "schema": output_schema,
+            "strict": True,
+        }
+        if output_schema is not None
+        else {"type": "text"}
+    )
+    try:
+        kwargs: dict[str, Any] = {
+            "model": model,
+            "input": prompt,
+            "text": {"format": text_format},
+            "tools": [],
+            "store": True,
+            "max_output_tokens": 16384,
+        }
+        if reasoning_effort is not None:
+            kwargs["reasoning"] = {"effort": reasoning_effort, "summary": "auto"}
+        response = await client.responses.create(**kwargs)
+        reasoning_summaries = None
+        if reasoning_effort is not None:
+            reasoning_summaries = [
+                [
+                    s.model_dump() if hasattr(s, "model_dump") else s
+                    for s in item.summary
+                ]
+                for item in response.output
+                if getattr(item, "type", None) == "reasoning"
+                and getattr(item, "summary", None) is not None
+            ]
+        return response.output_text, reasoning_summaries
+    except Exception as exc:
+        if "404" not in str(exc):
+            raise
+        logger.info(
+            f"Responses API returned 404 for {model}, falling back to Chat Completions"
+        )
+        chat_kwargs: dict[str, Any] = {
+            "model": model,
+            "messages": [{"role": "user", "content": prompt}],
+            "max_tokens": 16384,
+        }
+        if output_schema is not None:
+            chat_kwargs["response_format"] = {
+                "type": "json_schema",
+                "json_schema": {
+                    "name": "judge_response",
+                    "schema": output_schema,
+                    "strict": True,
+                },
+            }
+        if reasoning_effort is not None:
+            chat_kwargs["reasoning_effort"] = reasoning_effort
+        response = await client.chat.completions.create(**chat_kwargs)
+        reasoning_summaries = None
+        if reasoning_effort is not None:
+            reasoning_content = getattr(
+                response.choices[0].message, "reasoning_content", None
+            )
+            if reasoning_content is not None:
+                reasoning_summaries = [{"type": "text", "text": reasoning_content}]
+            else:
+                reasoning_summaries = []
+        return response.choices[0].message.content, reasoning_summaries
+
+
+# ---------------------------------------------------------------------------
+# Parsing + aggregation
+# ---------------------------------------------------------------------------
+
+
+def parse_judge_response(response_text: str) -> dict:
+    """Parse the judge response JSON and range-check ``score``.
+
+    When Structured Outputs are used upstream, the response is already
+    schema-validated; this function only decodes the JSON and enforces the
+    0-3 range for ``score``.
+    """
+    parsed = json.loads(response_text)
+    score = int(parsed["score"])
+    if score < 0 or score > 3:
+        raise ValueError(f"Score {score} out of range [0, 3]")
+    parsed["score"] = score
+    return parsed
+
+
+def _aggregate_one_rubric(verdict: dict) -> dict:
+    """Roll up cluster verdicts for a single per-rubric judge entry."""
+    symptoms = verdict.get("symptoms", {}) or {}
+    metrics = symptoms.get("metrics", []) or []
+    logs = symptoms.get("logs", []) or []
+    traces = symptoms.get("traces", []) or []
+
+    metric_hits = [bool(m.get("family_match")) for m in metrics]
+    log_hits = [
+        bool(l.get("body_match")) and bool(l.get("service_name_match")) for l in logs
+    ]
+    trace_hits = [
+        bool(t.get("call_chain_match")) and bool(t.get("smoking_gun_match"))
+        for t in traces
+    ]
+
+    def _all(hits: list[bool]) -> bool | None:
+        return all(hits) if hits else None
+
+    def _any(hits: list[bool]) -> bool | None:
+        return any(hits) if hits else None
+
+    return {
+        "feature_flag": verdict.get("feature_flag", ""),
+        "incident_time_within_10min": bool(verdict.get("incident_time_within_10min")),
+        "feature_flag_match": bool(verdict.get("feature_flag_match")),
+        "mechanism_match": bool(verdict.get("mechanism_match")),
+        "metrics_all_match": _all(metric_hits),
+        "metrics_any_match": _any(metric_hits),
+        "logs_all_match": _all(log_hits),
+        "logs_any_match": _any(log_hits),
+        "traces_all_match": _all(trace_hits),
+        "traces_any_match": _any(trace_hits),
+    }
+
+
+def aggregate_judge_response(parsed: dict) -> dict:
+    """Aggregate per-rubric, per-cluster verdicts into flat any-of rollups.
+
+    The agent is credited if it matches any one of the listed rubrics.
+    Per-rubric rollups are computed via ``_aggregate_one_rubric``; the
+    task-level rollup is the ``any`` over rubrics for booleans (with ``None``
+    skipped — sections without clusters in any rubric stay ``None``).
+
+    The per-rubric rollups are also returned under ``per_rubric`` for
+    downstream analysis that needs to know which specific rubric matched.
+    """
+    rubrics = parsed.get("rubrics") or []
+    per_rubric = [_aggregate_one_rubric(r) for r in rubrics]
+
+    def _any_skip_none(values: list[bool | None]) -> bool | None:
+        truthy = [v for v in values if v is not None]
+        return any(truthy) if truthy else None
+
+    return {
+        "incident_time_within_10min": _any_skip_none(
+            [r["incident_time_within_10min"] for r in per_rubric]
+        )
+        or False,
+        "feature_flag_match": _any_skip_none(
+            [r["feature_flag_match"] for r in per_rubric]
+        )
+        or False,
+        "mechanism_match": _any_skip_none([r["mechanism_match"] for r in per_rubric])
+        or False,
+        "metrics_all_match": _any_skip_none(
+            [r["metrics_all_match"] for r in per_rubric]
+        ),
+        "metrics_any_match": _any_skip_none(
+            [r["metrics_any_match"] for r in per_rubric]
+        ),
+        "logs_all_match": _any_skip_none([r["logs_all_match"] for r in per_rubric]),
+        "logs_any_match": _any_skip_none([r["logs_any_match"] for r in per_rubric]),
+        "traces_all_match": _any_skip_none([r["traces_all_match"] for r in per_rubric]),
+        "traces_any_match": _any_skip_none([r["traces_any_match"] for r in per_rubric]),
+        "per_rubric": per_rubric,
+        "score": int(parsed["score"]),
+    }
+
+
+def string_match_fallback(expected: dict, predictions: str) -> dict:
+    """Fall back to case-insensitive string search for any plausible root_cause.
+
+    ``expected["events"]`` is a list of ``{"root_cause": <flag>, "event_time": ...}``;
+    the agent's report is credited if any listed root_cause appears in it.
+    Returns a result dict compatible with the judge output format.
+    """
+    events: list[dict] = expected.get("events") or []
+    if not events:
+        # No-incident task: agent should write an empty report.
+        return {"score": 3 if len(predictions.strip()) == 0 else 0}
+    text = predictions.lower()
+    found = any(e["root_cause"].strip().lower() in text for e in events)
+    return {"score": 3 if found else 0}
+
+
+# ---------------------------------------------------------------------------
+# Judge entry point (used by both modes)
+# ---------------------------------------------------------------------------
+
+
+async def judge(
+    client: Any,
+    expected: dict,
+    predictions: str,
+    rubrics_data: list[dict],
+    model: str = DEFAULT_MODEL,
+    reasoning_effort: str | None = None,
+) -> dict:
+    """Run the LLM judge over one or more ground-truth rubrics, or
+    short-circuit for no-incident tasks.
+
+    Returns:
+        A dict with keys: reward, mode, score, and (for LLM judge) model,
+        nested (raw judge response), reasoning_summary, rubric_used,
+        judge_prompt, judge_response_raw. Per-section rollups are derived
+        post-hoc from ``nested`` by formatters via ``aggregate_judge_response``.
+
+    """
+    events: list[dict] = expected.get("events") or []
+    if not events:
+        score = 3 if len(predictions.strip()) == 0 else 0
+        return {
+            "reward": score / 3.0,
+            "mode": "no_incident",
+            "model": model,
+            "score": score,
+        }
+
+    # Short-circuit when the agent emitted an empty report despite an incident.
+    # No LLM call can rescue this; score is a guaranteed 0. We synthesize the
+    # nested response shape (per-rubric all False, matching cluster counts)
+    # so that ``aggregate_judge_response`` produces the expected all-False
+    # rollups at load time.
+    if not predictions.strip():
+        synthetic_per_rubric = []
+        for rubric in rubrics_data:
+            symptoms = rubric.get("symptoms", {}) or {}
+            synthetic_per_rubric.append(
+                {
+                    "feature_flag": rubric.get("feature_flag", ""),
+                    "incident_time_within_10min": False,
+                    "feature_flag_match": False,
+                    "mechanism_match": False,
+                    "symptoms": {
+                        "metrics": [
+                            {
+                                "metric_family": m.get("metric_family", ""),
+                                "family_match": False,
+                            }
+                            for m in (symptoms.get("metrics") or [])
+                        ],
+                        "logs": [
+                            {"body_match": False, "service_name_match": False}
+                            for _ in (symptoms.get("logs") or [])
+                        ],
+                        "traces": [
+                            {"call_chain_match": False, "smoking_gun_match": False}
+                            for _ in (symptoms.get("traces") or [])
+                        ],
+                    },
+                }
+            )
+        return {
+            "mode": "empty_report",
+            "model": model,
+            "score": 0,
+            "reward": 0.0,
+            "rubric_used": bool(rubrics_data),
+            "nested": {"rubrics": synthetic_per_rubric, "score": 0},
+        }
+
+    prompt = build_judge_prompt(rubrics_data, predictions)
+    output_schema = build_judge_output_schema(rubrics_data)
+
+    raw_response, reasoning_summary = await async_call_llm_judge(
+        client,
+        prompt,
+        model=model,
+        reasoning_effort=reasoning_effort,
+        output_schema=output_schema,
+    )
+    parsed = parse_judge_response(raw_response)
+
+    # Per-section rollups are NOT spread into the result — they're a pure
+    # post-hoc derivation from ``nested`` via ``aggregate_judge_response``,
+    # applied by the formatters at load time so schema changes don't require
+    # rewriting saved JSONs.
+    return {
+        "mode": "llm_judge",
+        "model": model,
+        "score": parsed["score"],
+        "reward": parsed["score"] / 3.0,
+        "reasoning_summary": reasoning_summary,
+        "rubric_used": bool(rubrics_data),
+        "judge_prompt": prompt,
+        "judge_response_raw": raw_response,
+        "nested": parsed,
+    }
+
+
+# ---------------------------------------------------------------------------
+# CLI
+# ---------------------------------------------------------------------------
+
+
+async def main() -> None:
+    """Entry point: load expected + predictions, score, write reward/details."""
+    parser = argparse.ArgumentParser(
+        description="LLM-as-a-judge verifier for Harbor incident-RCA-report tasks."
+    )
+    parser.add_argument("--expected", type=str, default="/tests/expected.json")
+    parser.add_argument("--predictions", type=str, default="/app/report.md")
+    parser.add_argument(
+        "--rubrics-dir",
+        type=str,
+        default="/tests/rubrics",
+        help=(
+            "Directory containing one rubric JSON per plausible root cause "
+            "(e.g. /tests/rubrics/<event_id>.json). The judge scores the "
+            "agent against any one of them."
+        ),
+    )
+    parser.add_argument(
+        "--model", type=str, default=DEFAULT_MODEL, help="Judge LLM model name."
+    )
+    parser.add_argument(
+        "--effort",
+        type=str,
+        choices=["low", "medium", "high"],
+        default="high",
+        help="Reasoning effort level for the judge LLM (default: high).",
+    )
+    parser.add_argument(
+        "--mode",
+        type=str,
+        choices=["string_match", "llm_judge"],
+        default="string_match",
+        help="Scoring mode: string_match or llm_judge (default: string_match).",
+    )
+    parser.add_argument("--reward", type=str, default="/logs/verifier/reward.txt")
+    parser.add_argument("--details", type=str, default="/logs/verifier/details.json")
+    args = parser.parse_args()
+
+    expected_path = Path(args.expected)
+    predictions_path = Path(args.predictions)
+    rubrics_dir = Path(args.rubrics_dir)
+    reward_path = Path(args.reward)
+    details_path = Path(args.details)
+
+    try:
+        # Load expected
+        print(f"Loading expected results from {expected_path}...")
+        with expected_path.open() as f:
+            expected = json.load(f)
+
+        # Load predictions (markdown report)
+        print(f"Loading predictions from {predictions_path}...")
+        predictions = predictions_path.read_text()
+
+        # Load rubric JSONs — one per plausible root cause. Order is the
+        # filesystem sort order, which matches the build_harbor_tasks.py
+        # naming convention (event_id stems sort lexicographically).
+        rubrics_data: list[dict] = []
+        if expected.get("events"):
+            if rubrics_dir.is_dir():
+                rubric_paths = sorted(rubrics_dir.glob("*.json"))
+                for p in rubric_paths:
+                    with p.open() as f:
+                        rubrics_data.append(json.load(f))
+                print(f"Loaded {len(rubrics_data)} rubric(s) from {rubrics_dir}")
+            else:
+                print(f"Rubric directory missing: {rubrics_dir}")
+        else:
+            print("No incident events in expected results; skipping rubric load.")
+
+        # Run judge
+        if args.mode == "string_match":
+            em = string_match_fallback(expected, predictions)
+            result = {"reward": em["score"] / 3.0, "mode": "string_match", **em}
+        else:
+            from openai import AsyncOpenAI
+
+            client = AsyncOpenAI(
+                api_key=os.getenv("OPENAI_API_KEY"),
+                base_url=os.getenv("OPENAI_BASE_URL"),
+            )
+            result = await judge(
+                client,
+                expected,
+                predictions,
+                rubrics_data,
+                model=args.model,
+                reasoning_effort=args.effort,
+            )
+
+        # Write reward
+        reward_path.parent.mkdir(parents=True, exist_ok=True)
+        reward_path.write_text(str(result["reward"]))
+
+        # Write details
+        details_path.parent.mkdir(parents=True, exist_ok=True)
+        details_path.write_text(json.dumps(result, indent=2))
+
+        print(f"Score: {result.get('score', 'N/A')}/3 (reward: {result['reward']})")
+        print(f"Mode: {result['mode']}")
+        if result.get("reasoning_summary"):
+            print(f"Reasoning summary: {result['reasoning_summary']}")
+
+        if result["reward"] < 1.0:
+            sys.exit(1)
+
+    except Exception as exc:
+        reward_path.parent.mkdir(parents=True, exist_ok=True)
+        reward_path.write_text("0.0")
+        details_path.parent.mkdir(parents=True, exist_ok=True)
+        details_path.write_text(
+            json.dumps(
+                {
+                    "reward": 0.0,
+                    "error": f"{type(exc).__name__}: {exc}",
+                    "traceback": traceback.format_exc(),
+                },
+                indent=2,
+            )
+        )
+        print(f"Verifier error: {type(exc).__name__}: {exc}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

tasks/d1-c1-admanualgc-on-univ00-universal_ttd15m_at_off+10m/solution/rubric.json

@@ -0,0 +1,24 @@
+{
+  "incident_time": "2026-04-19T14:01:51.404464+00:00",
+  "feature_flag": "imageSlowLoad",
+  "description": "A feature flag in the frontend `ProductCard` React component added an `x-envoy-fault-delay-request` header (plus `Cache-Control: no-cache`) to every product-image fetch; Envoy honored the fault-injection header and artificially delayed each `GET /images/products/<picture>` response, so product thumbnails took seconds to render.",
+  "mechanism": "The flag is read in [`ProductCard.tsx#L32`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L32): the `ProductCard` React component calls `useNumberFlagValue('imageSlowLoad', 0)` to get the delay value in milliseconds (variants: `0` for off, `5000` for 5 sec, `10000` for 10 sec). When non-zero, the component sets the `x-envoy-fault-delay-request` header to the flag value on every product image fetch ([`ProductCard.tsx#L37`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L37)).\n\nThe image request is sent to `/images/products/<picture>`, which the frontend-proxy Envoy routes to the `image-provider` cluster ([`envoy.tmpl.yaml#L54-L55`](../../opentelemetry-demo/src/frontend-proxy/envoy.tmpl.yaml#L54)). Envoy's `envoy.filters.http.fault` filter is configured with `header_delay: {}` and 100% percentage ([`envoy.tmpl.yaml#L67-L74`](../../opentelemetry-demo/src/frontend-proxy/envoy.tmpl.yaml#L67)), meaning it honors the `x-envoy-fault-delay-request` header and injects the specified delay (in ms) before forwarding the request. Every product card image load is therefore delayed by the flag value (e.g. 5 or 10 seconds), causing the page to render with blank/loading images until the delayed responses arrive.",
+  "symptoms": {
+    "metrics": [],
+    "logs": [],
+    "frontend": [
+      {
+        "description": "Product card thumbnails on the homepage product grid (and the recommendations carousel on product/cart/checkout pages) render with a blank image placeholder for ~5 seconds before the actual thumbnail appears. The page text and layout render immediately; only the images are delayed. Affects every product card on every page load while the flag is on — the failure is silent slowness, not a visible error.",
+        "route": "GET /images/products/<picture>",
+        "deterministic": true,
+        "trigger_condition": "Every page load that renders a `ProductCard` component — homepage product grid (`/`), recommendations carousel on product detail (`/product/<id>`), cart, and checkout pages.",
+        "source_file": "src/frontend/components/ProductCard/ProductCard.tsx",
+        "source_line": 37,
+        "calling_service": "frontend",
+        "call_pattern": "ProductCard.useEffect ([`ProductCard.tsx#L34`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L34)) → fetch(`/images/products/<picture>`) with header `x-envoy-fault-delay-request: 5000` ([`ProductCard.tsx#L37`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L37)) → frontend-proxy Envoy → image-provider.",
+        "cause": "`useNumberFlagValue('imageSlowLoad', 0)` returns 5000 (the `5sec` variant value, [`demo.flagd.json` `imageSlowLoad.variants.5sec`](../../opentelemetry-demo/src/flagd/demo.flagd.json)). ProductCard sets `x-envoy-fault-delay-request: 5000` on every image fetch ([`ProductCard.tsx#L37`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L37)). The frontend-proxy `envoy.filters.http.fault` filter ([`envoy.tmpl.yaml#L67`](../../opentelemetry-demo/src/frontend-proxy/envoy.tmpl.yaml#L67)) honors this header and delays each image response by 5000ms before forwarding to image-provider, so each `<S.Image>` only resolves after that delay."
+      }
+    ],
+    "traces": []
+  }
+}

tasks/d1-c1-admanualgc-on-univ00-universal_ttd15m_at_off+10m/solution/rubrics/d1-i1-imageSlowLoad-on.json

@@ -0,0 +1,24 @@
+{
+  "incident_time": "2026-04-19T14:01:51.404464+00:00",
+  "feature_flag": "imageSlowLoad",
+  "description": "A feature flag in the frontend `ProductCard` React component added an `x-envoy-fault-delay-request` header (plus `Cache-Control: no-cache`) to every product-image fetch; Envoy honored the fault-injection header and artificially delayed each `GET /images/products/<picture>` response, so product thumbnails took seconds to render.",
+  "mechanism": "The flag is read in [`ProductCard.tsx#L32`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L32): the `ProductCard` React component calls `useNumberFlagValue('imageSlowLoad', 0)` to get the delay value in milliseconds (variants: `0` for off, `5000` for 5 sec, `10000` for 10 sec). When non-zero, the component sets the `x-envoy-fault-delay-request` header to the flag value on every product image fetch ([`ProductCard.tsx#L37`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L37)).\n\nThe image request is sent to `/images/products/<picture>`, which the frontend-proxy Envoy routes to the `image-provider` cluster ([`envoy.tmpl.yaml#L54-L55`](../../opentelemetry-demo/src/frontend-proxy/envoy.tmpl.yaml#L54)). Envoy's `envoy.filters.http.fault` filter is configured with `header_delay: {}` and 100% percentage ([`envoy.tmpl.yaml#L67-L74`](../../opentelemetry-demo/src/frontend-proxy/envoy.tmpl.yaml#L67)), meaning it honors the `x-envoy-fault-delay-request` header and injects the specified delay (in ms) before forwarding the request. Every product card image load is therefore delayed by the flag value (e.g. 5 or 10 seconds), causing the page to render with blank/loading images until the delayed responses arrive.",
+  "symptoms": {
+    "metrics": [],
+    "logs": [],
+    "frontend": [
+      {
+        "description": "Product card thumbnails on the homepage product grid (and the recommendations carousel on product/cart/checkout pages) render with a blank image placeholder for ~5 seconds before the actual thumbnail appears. The page text and layout render immediately; only the images are delayed. Affects every product card on every page load while the flag is on — the failure is silent slowness, not a visible error.",
+        "route": "GET /images/products/<picture>",
+        "deterministic": true,
+        "trigger_condition": "Every page load that renders a `ProductCard` component — homepage product grid (`/`), recommendations carousel on product detail (`/product/<id>`), cart, and checkout pages.",
+        "source_file": "src/frontend/components/ProductCard/ProductCard.tsx",
+        "source_line": 37,
+        "calling_service": "frontend",
+        "call_pattern": "ProductCard.useEffect ([`ProductCard.tsx#L34`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L34)) → fetch(`/images/products/<picture>`) with header `x-envoy-fault-delay-request: 5000` ([`ProductCard.tsx#L37`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L37)) → frontend-proxy Envoy → image-provider.",
+        "cause": "`useNumberFlagValue('imageSlowLoad', 0)` returns 5000 (the `5sec` variant value, [`demo.flagd.json` `imageSlowLoad.variants.5sec`](../../opentelemetry-demo/src/flagd/demo.flagd.json)). ProductCard sets `x-envoy-fault-delay-request: 5000` on every image fetch ([`ProductCard.tsx#L37`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L37)). The frontend-proxy `envoy.filters.http.fault` filter ([`envoy.tmpl.yaml#L67`](../../opentelemetry-demo/src/frontend-proxy/envoy.tmpl.yaml#L67)) honors this header and delays each image response by 5000ms before forwarding to image-provider, so each `<S.Image>` only resolves after that delay."
+      }
+    ],
+    "traces": []
+  }
+}

tasks/d1-c1-admanualgc-on-univ00-universal_ttd15m_at_off+10m/solution/rubrics/d1-i2-adFailure-on.json

@@ -0,0 +1,210 @@
+{
+  "incident_time": "2026-04-19T16:32:19.033653+00:00",
+  "feature_flag": "adFailure",
+  "description": "A feature flag in the ad service's `GetAds` handler threw `StatusRuntimeException(Status.UNAVAILABLE)` on ~10% of calls (`random.nextInt(10) == 0`); the frontend `/api/data` route caught the gRPC error and returned HTTP 500, but React Query's default `adList = []` fallback masked the failure in the UI — the yellow ad banner silently rendered blank rather than showing an error.",
+  "mechanism": "The flag is read in [`AdService.java#L205`](../../opentelemetry-demo/src/ad/src/main/java/oteldemo/AdService.java#L205): on every `getAds` gRPC call, after ads have been collected and the request/response type attributes set, the service evaluates `ffClient.getBooleanValue(\"adFailure\", false, evaluationContext)`. When `true`, it throws `StatusRuntimeException(Status.UNAVAILABLE)` with probability 1/10 (`random.nextInt(10) == 0`) at [`AdService.java#L206`](../../opentelemetry-demo/src/ad/src/main/java/oteldemo/AdService.java#L206).\n\nThe exception is caught at [`AdService.java#L218`](../../opentelemetry-demo/src/ad/src/main/java/oteldemo/AdService.java#L218): the catch block adds an \"Error\" span event (line 219-220), sets the span status to ERROR (line 221), logs a WARN \"GetAds Failed with status {UNAVAILABLE}\" (line 222), and calls `responseObserver.onError(e)` (line 223) which sends the gRPC UNAVAILABLE status back to the caller.\n\nThe frontend calls the ad service via [`Ad.gateway.ts#L14`](../../opentelemetry-demo/src/frontend/gateways/rpc/Ad.gateway.ts#L14) (`client.getAds`), invoked from the `/api/data` route at [`data.ts#L15`](../../opentelemetry-demo/src/frontend/pages/api/data.ts#L15). When the gRPC call fails, the error propagates through the Next.js API route as an unhandled rejection, and the frontend-proxy Envoy returns HTTP 500 to the client.",
+  "symptoms": {
+    "metrics": [
+      {
+        "metric_family": "rpc_server_duration_milliseconds",
+        "signal_layer": "root_cause",
+        "defining_labels": {
+          "rpc_grpc_status_code": "14",
+          "rpc_method": "GetAds",
+          "rpc_service": "oteldemo.AdService",
+          "service_name": "ad"
+        },
+        "variants": [
+          {
+            "type": "created (fixed after human verification)",
+            "query": "rate(rpc_server_duration_milliseconds_count{rpc_service=\"oteldemo.AdService\",rpc_method=\"GetAds\",rpc_grpc_status_code=\"14\",service_name=\"ad\"}[5m])",
+            "description": "gRPC server call count for AdService/GetAds with status code 14 (UNAVAILABLE). This new series appeared because the adFailure flag causes AdService.java to throw StatusRuntimeException(Status.UNAVAILABLE) with 1/10 probability on each GetAds call.",
+            "onset_utc": "2026-04-19 16:41:00 UTC",
+            "onset_offset_seconds": 520,
+            "onset_reasoning": "The metric type is 'created'. Pre-incident baseline is 0. At 16:41:00 UTC the rate first rises above zero (0.0048), approximately 9 minutes after the incident time. This is the first appearance of rpc_grpc_status_code=14 (UNAVAILABLE) errors for the AdService, indicating the onset of the fault."
+          },
+          {
+            "type": "created (fixed after human verification)",
+            "query": "rate(rpc_server_duration_milliseconds_sum{rpc_service=\"oteldemo.AdService\",rpc_method=\"GetAds\",rpc_grpc_status_code=\"14\",service_name=\"ad\"}[5m])",
+            "description": "Cumulative gRPC server call duration (ms) for AdService/GetAds UNAVAILABLE errors. Tracks the total latency of the failed GetAds RPCs triggered by the adFailure flag.",
+            "onset_utc": "2026-04-19 16:41:00 UTC",
+            "onset_offset_seconds": 520,
+            "onset_reasoning": "The metric type is 'created'. Pre-incident baseline is 0. At 16:41:00 UTC the value first rises to 0.0145643, which is the first non-zero reading after the incident time (16:32:19 UTC), indicating the onset of rpc_server_duration for status_code=14 (UNAVAILABLE) errors on AdService.GetAds."
+          }
+        ]
+      },
+      {
+        "metric_family": "traces_span_metrics_calls",
+        "signal_layer": "root_cause",
+        "defining_labels": {
+          "service_name": "ad",
+          "span_kind": "SPAN_KIND_SERVER",
+          "span_name": "oteldemo.AdService/GetAds",
+          "status_code": "STATUS_CODE_ERROR"
+        },
+        "variants": [
+          {
+            "type": "created (fixed after human verification)",
+            "query": "rate(traces_span_metrics_calls_total{service_name=\"ad\",span_name=\"oteldemo.AdService/GetAds\",span_kind=\"SPAN_KIND_SERVER\",status_code=\"STATUS_CODE_ERROR\"}[5m])",
+            "description": "Span-derived call counter for ad-service GetAds errors. This series did not exist before the incident; it appeared when the adFailure flag began triggering StatusRuntimeException(UNAVAILABLE) with ~10% probability on every GetAds gRPC call.",
+            "onset_utc": "2026-04-19 16:40:00 UTC",
+            "onset_offset_seconds": 460,
+            "onset_reasoning": "This is a 'created' metric type, meaning the series appeared after the incident. The incident occurred at 16:32:19 UTC, and the first data point in the series is at 16:40:00 UTC with a non-zero value of 0.00623, indicating error spans began appearing for the ad service's GetAds endpoint. This is the first timestamp where the metric exists, marking the onset of the error signal."
+          }
+        ]
+      },
+      {
+        "metric_family": "http_server_duration_milliseconds",
+        "signal_layer": "propagation",
+        "defining_labels": {
+          "http_method": "GET",
+          "http_status_code": "500",
+          "service_name": "frontend"
+        },
+        "variants": [
+          {
+            "type": "created (fixed after human verification)",
+            "query": "rate(http_server_duration_milliseconds_count{http_status_code=\"500\",service_name=\"frontend\",http_method=\"GET\"}[5m])",
+            "description": "HTTP server request count for frontend service returning 500 status. New series appeared as the ad service UNAVAILABLE errors propagate through the Next.js /api/data route handler, causing the frontend to return HTTP 500 to clients.",
+            "onset_utc": "2026-04-19 16:41:00 UTC",
+            "onset_offset_seconds": 520,
+            "onset_reasoning": "The metric is a 'created' type. Pre-incident baseline is 0. At 16:41:00, the rate rises from 0 to ~0.00476, marking the first appearance of HTTP 500 errors on the frontend service. This is approximately 9 minutes after the incident injection at 16:32:19, consistent with propagation delay."
+          },
+          {
+            "type": "created (fixed after human verification)",
+            "query": "rate(http_server_duration_milliseconds_sum{http_status_code=\"500\",service_name=\"frontend\",http_method=\"GET\"}[5m])",
+            "description": "Cumulative HTTP server request duration (ms) for frontend 500 responses. Tracks total latency of the error responses caused by the ad service failure cascade.",
+            "onset_utc": "2026-04-19 16:41:00 UTC",
+            "onset_offset_seconds": 520,
+            "onset_reasoning": "The metric is a 'created' type. Pre-incident baseline is 0. At 16:41:00 UTC the rate first rises to ~0.049, which is the first significant departure from zero after the incident time (16:32:19 UTC), indicating the onset of HTTP 500 errors on the frontend."
+          }
+        ]
+      },
+      {
+        "metric_family": "feature_flag_flagd_impression",
+        "signal_layer": "meta",
+        "defining_labels": {
+          "feature_flag_key": "adFailure",
+          "feature_flag_result_variant": "on"
+        },
+        "variants": [
+          {
+            "type": "created (fixed after human verification)",
+            "query": "feature_flag_flagd_impression_total{feature_flag_key=\"adFailure\",feature_flag_result_variant=\"on\"}",
+            "description": "flagd impression counter for adFailure flag with result variant 'on'. This new series appeared at 16:33 UTC when the adFailure feature flag was toggled from off to on, confirming the flag change that triggers the ad service failures.",
+            "onset_utc": "2026-04-19 16:33:00 UTC",
+            "onset_offset_seconds": 40,
+            "onset_reasoning": "This is a 'created' metric — the series did not exist before the incident. The first data point appears at 16:33:00 UTC, approximately 1 minute after the incident time (16:32:19 UTC), indicating the feature flag was toggled on and the metric was created at that point."
+          }
+        ]
+      }
+    ],
+    "logs": [
+      {
+        "name": "GET /api/data → 500",
+        "description": "Between 16:37:08 and 16:39:42 UTC, GET /api/data?contextKeys={category} returned 500 errors twice (2 failures out of 20 completed /api/data requests after the incident, ~10%, matching the 1/10 probabilistic failure rate). Each failing request shares its traceId with an ad-service GetAds UNAVAILABLE WARN logged ~15-20 ms later.",
+        "cause": "Direct effect of the adFailure flag. pages/api/data.ts calls AdGateway.listAds, which invokes the ad service's GetAds gRPC. When adFailure is on, AdService.java:205 throws StatusRuntimeException(Status.UNAVAILABLE) with 1/10 probability (random.nextInt(10) == 0), which propagates back through the frontend gateway as a 500. The two failing requests sample different categories (telescopes, books) — each page load picks a category before the ad fetch.",
+        "source": "frontend-proxy Envoy access logs",
+        "representative_attributes": {
+          "body": "[2026-04-19T16:37:08.414Z] \"GET /api/data?contextKeys=telescopes HTTP/1.1\" 500 - via_upstream - \"-\" 0 21 27 26 \"-\" \"python-requests/2.32.5\" \"6261b255-4f6c-9a2d-b2d6-0da5a59774b5\" \"frontend-proxy:8080\" \"172.18.0.27:8080\" frontend 172.18.0.29:41088 172.18.0.29:8080 172.18.0.28:42900 - -",
+          "event.name": "proxy.access",
+          "url.full": "http://frontend-proxy:8080/api/data?contextKeys=telescopes",
+          "url.path": "/api/data?contextKeys=telescopes",
+          "upstream.cluster": "frontend",
+          "upstream.host": "172.18.0.27:8080",
+          "destination.address": "172.18.0.27",
+          "source.address": "172.18.0.28",
+          "server.address": "172.18.0.29:8080",
+          "user_agent.original": "python-requests/2.32.5",
+          "resource.service.name": "frontend-proxy",
+          "resource.log_name": "otel_envoy_access_log",
+          "traceId": "4a9c115c071f58e00205700b7ff2b852",
+          "spanId": "bf1dc411e2a87489"
+        },
+        "log_documents": [
+          {
+            "_index": "otel-logs-2026-04-19",
+            "_id": "lIWapp0Br_RFnSwRY0tx",
+            "@timestamp": "16:37:08.414"
+          },
+          {
+            "_index": "otel-logs-2026-04-19",
+            "_id": "yIWcpp0Br_RFnSwRvVEg",
+            "@timestamp": "16:39:42.669"
+          }
+        ]
+      },
+      {
+        "name": "ad: GetAds Failed (WARN)",
+        "description": "Between 16:37:08 and 16:39:42 UTC, the ad service emitted 2 WARN logs reporting that GetAds failed with gRPC status UNAVAILABLE. Each WARN arrives ~15 ms after its corresponding /api/data 500 in the frontend-proxy access log, giving a 1:1 correspondence with the GetAds UNAVAILABLE Cascade traces (matching the 2 failing traces under that cluster). These are the only WARN-severity logs from the ad service in the incident window.",
+        "cause": "Smoking-gun direct evidence of the adFailure flag. Each time AdService.java:205 throws StatusRuntimeException(Status.UNAVAILABLE), execution enters the catch block at AdService.java:218, which calls logger.log(Level.WARN, \"GetAds Failed with status {}\", e.getStatus()) at AdService.java:222 before rethrowing to the gRPC client. The ad service explicitly names the failing RPC and echoes the UNAVAILABLE status code from the feature-flag code path.",
+        "source": "ad service (Java, oteldemo.AdService logger via OpenTelemetry Java agent)",
+        "representative_attributes": {
+          "body": "GetAds Failed with status Status{code=UNAVAILABLE, description=null, cause=null}",
+          "severity.text": "WARN",
+          "severity.number": "13",
+          "instrumentationScope.name": "oteldemo.AdService",
+          "resource.service.name": "ad",
+          "resource.service.namespace": "opentelemetry-demo",
+          "resource.service.version": "2.2.0",
+          "resource.telemetry.sdk.language": "java",
+          "resource.telemetry.distro.name": "opentelemetry-java-instrumentation",
+          "traceId": "4a9c115c071f58e00205700b7ff2b852",
+          "spanId": "c8be6b167e3936cb"
+        },
+        "log_documents": [
+          {
+            "_index": "otel-logs-2026-04-19",
+            "_id": "mIWapp0Br_RFnSwRZEt3",
+            "@timestamp": "16:37:08.429"
+          },
+          {
+            "_index": "otel-logs-2026-04-19",
+            "_id": "0YWcpp0Br_RFnSwRvlE6",
+            "@timestamp": "16:39:42.676"
+          }
+        ]
+      }
+    ],
+    "frontend": [
+      {
+        "description": "The yellow ad banner at the bottom of product detail and checkout confirmation pages renders as a blank yellow box with no ad text and no link. The rest of the page loads normally — the failure is silent degradation, not a visible error.",
+        "route": "GET /api/data",
+        "deterministic": false,
+        "trigger_condition": "User visits a product detail page or checkout confirmation page, triggering an ad fetch via AdProvider. The ad service fails with 10% probability (`random.nextInt(10) == 0` in [`AdService.java#L205`](../../opentelemetry-demo/src/ad/src/main/java/oteldemo/AdService.java#L205)).",
+        "source_file": "src/frontend/pages/api/data.ts",
+        "source_line": 15,
+        "calling_service": "frontend",
+        "call_pattern": "Single direct call: AdProvider.useQuery ([`Ad.provider.tsx#L30`](../../opentelemetry-demo/src/frontend/providers/Ad.provider.tsx#L30)) → ApiGateway.listAds ([`Api.gateway.ts#L103`](../../opentelemetry-demo/src/frontend/gateways/Api.gateway.ts#L103)) → [`data.ts#L15`](../../opentelemetry-demo/src/frontend/pages/api/data.ts#L15) → AdGateway.listAds → gRPC client.getAds ([`Ad.gateway.ts#L14`](../../opentelemetry-demo/src/frontend/gateways/rpc/Ad.gateway.ts#L14)).",
+        "cause": "The [`data.ts#L15`](../../opentelemetry-demo/src/frontend/pages/api/data.ts#L15) API route calls `AdGateway.listAds` with no try-catch. When adFailure is on and the 1/10 random gate fires, the ad service throws `StatusRuntimeException(Status.UNAVAILABLE)` at [`AdService.java#L206`](../../opentelemetry-demo/src/ad/src/main/java/oteldemo/AdService.java#L206). The gRPC error rejects the promise in [`Ad.gateway.ts#L14`](../../opentelemetry-demo/src/frontend/gateways/rpc/Ad.gateway.ts#L14), propagates to [`InstrumentationMiddleware.ts#L23`](../../opentelemetry-demo/src/frontend/utils/telemetry/InstrumentationMiddleware.ts#L23) which records the exception on the span and re-throws, and Next.js returns HTTP 500. On the client side, React Query in [`Ad.provider.tsx#L30`](../../opentelemetry-demo/src/frontend/providers/Ad.provider.tsx#L30) catches the failure and defaults `adList` to `[]`. The Ad component ([`Ad.tsx#L10`](../../opentelemetry-demo/src/frontend/components/Ad/Ad.tsx#L10)) falls back to `{ text: '', redirectUrl: '' }`, rendering the styled yellow banner with empty content.",
+        "symptom_type": "visual_degradation"
+      }
+    ],
+    "traces": [
+      {
+        "name": "GetAds UNAVAILABLE Cascade",
+        "description": "Between 16:37:08 and 16:39:42 UTC, 2 traces show ad:oteldemo.AdService/GetAds failing with gRPC status 14 UNAVAILABLE and cascading through the frontend /api/data path. Both traces have root operation load-generator:user_get_ads. The failures land roughly 2.5 minutes apart, consistent with the load generator's user_get_ads cadence multiplied by the ~1/10 probabilistic failure rate.",
+        "cause": "Direct effect of the adFailure flag. When adFailure is on, AdService.java:205 throws StatusRuntimeException(Status.UNAVAILABLE) with 1/10 probability (random.nextInt(10) == 0). The exception is caught at AdService.java:218, logged as WARN at line 222, then surfaced to the gRPC client via responseObserver.onError(...). The error propagates through frontend's AdGateway to the Next.js /api/data route handler, which returns HTTP 500, and finally back out through the frontend-proxy Envoy to the load generator.",
+        "call_chain": "ad:oteldemo.AdService/GetAds → frontend:oteldemo.AdService/GetAds → frontend:executing api route (pages) /api/data → frontend:GET /api/data → frontend-proxy:router frontend egress → frontend-proxy:GET → load-generator:GET",
+        "smoking_gun": [
+          "ad:oteldemo.AdService/GetAds span: otel.status_code=ERROR, rpc.grpc.status_code=14, rpc.service=oteldemo.AdService, rpc.method=GetAds, and log event {event: \"Error\", exception.message: \"UNAVAILABLE\"} — no description, no stacktrace, matching the bare `throw new StatusRuntimeException(Status.UNAVAILABLE)` at AdService.java:206",
+          "ad:oteldemo.AdService/GetAds span attributes app.ads.count=1-2 and app.ads.ad_request_type=TARGETED with app.ads.contextKeys=[telescopes] or [books], set at AdService.java:195 before the flag check at line 205 — proves execution reached the flag-triggered throw with ads already prepared (rules out upstream failures in getAdsByCategory/getRandomAds)",
+          "ad:getAdsByCategory child span completes successfully with no errors — the failure is injected by the explicit flag-triggered throw in getAds, not by any downstream dependency",
+          "frontend:oteldemo.AdService/GetAds client span carries the received gRPC error as tag grpc.error_message=\"14 UNAVAILABLE: \" with rpc.grpc.status_code=14 (trailing colon with empty description, characteristic of the Java server not calling .withDescription(...))"
+        ],
+        "trace_documents": [
+          {
+            "traceID": "4a9c115c071f58e00205700b7ff2b852",
+            "@timestamp": "16:37:08",
+            "user_action": "user_get_ads"
+          },
+          {
+            "traceID": "bec127aafcab40a93d1d79411951afd7",
+            "@timestamp": "16:39:42",
+            "user_action": "user_get_ads"
+          }
+        ]
+      }
+    ]
+  }
+}

tasks/d1-c1-admanualgc-on-univ00-universal_ttd15m_at_off+10m/solution/solve.py

@@ -0,0 +1,298 @@
+#!/usr/bin/env python3
+"""Generate an incident report from a rubric JSON via LLM.
+
+Standalone script designed to run inside a Harbor task container.
+Also importable by ``run_solve.py`` for local batch generation.
+
+Examples::
+
+    # Inside Harbor container (solve.sh calls this):
+    python solve.py --rubric /tests/rubric.json --output /app/report.md
+
+    # With custom model/effort:
+    python solve.py --rubric /tests/rubric.json --output /app/report.md -m openai-gpt-5.4 -e high
+"""
+
+import argparse
+import asyncio
+import json
+import logging
+import os
+from pathlib import Path
+from typing import Any
+
+from check_prediction import async_call_llm_judge, format_rubric
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_MODEL: str | None = None
+DEFAULT_EFFORT = "high"
+
+# Report format from harbor-template/instruction.md.template — sections 1-4.
+REPORT_FORMAT = """\
+Write a structured incident report with four sections: Summary, Timeline, \
+5 Whys, and Remediation. Follow all section-specific rules below.
+
+---
+
+## Section 1: Summary
+
+2-3 sentences describing what happened, when, and the high-level impact. \
+This should be understandable by someone unfamiliar with the system. Focus \
+on what DID happen and the observable impact — mention request failures if \
+they occurred, but do NOT mention the absence of failures or errors as this \
+can be misread and cause confusion. You may name the root cause in a single \
+phrase (e.g. "due to a misconfigured batch job") but do not explain the \
+causal chain — that belongs in the 5 Whys section.
+
+Example: "Between 13:00 and 13:11 UTC on April 2, the order service returned \
+503 errors for 14% of checkout requests, affecting paying users, due to a \
+Redis cache eviction. The full causal chain is detailed in the 5 Whys section \
+below."
+
+---
+
+## Section 2: Timeline
+
+A chronological narrative of ONLY what went wrong, reconstructed from the \
+provided telemetry. Each entry should be a single succinct line. Cover \
+higher-level events — when a change was introduced, when symptoms started, \
+when a change was reverted, when symptoms subsided — not individual error \
+occurrences. The first entry should be the earliest anomaly visible in the \
+provided telemetry; this establishes the incident start time referenced by \
+the Summary and 5 Whys sections.
+
+For each entry:
+- State the time (UTC), the service(s) involved, and what happened
+- Quantify where possible (error rate, duration, number of affected requests)
+- Do NOT include normal/healthy behavior, baseline noise, or things that \
+worked correctly
+
+Example format:
+```
+09:44 UTC — analytics-job deployed with no memory limit set
+14:17 UTC — redis-cache-0 OOMKilled; node memory at 97%
+14:18 UTC — inventory-svc cache misses begin; all requests fall through to Postgres
+14:18 UTC — order-svc goroutine pool exhaustion begins; 503 error rate climbs to 14%
+14:29 UTC — redis-cache-0 rescheduled; error rate returns to baseline
+```
+
+---
+
+## Section 3: 5 Whys
+
+Rules:
+1. Start by stating the problem as a precise, observable symptom — not a \
+cause. Include what failed, when, and impact (error rate, affected users, \
+duration).
+2. Each "why" answer must be grounded in the provided telemetry. Cite only \
+the telemetry types relevant to that step, using the format below for each.
+
+   - Metrics: one sentence describing the baseline value (or typical range), \
+what it changed to, and at what UTC timestamp. Where relevant, include rate \
+of change or duration. Follow with the exact PromQL query that would surface it.
+     Example — "Error rate on order-svc was 0.1% at 14:17 UTC, jumping to \
+14% at 14:18 UTC. PromQL: rate(http_requests_total{service="order-svc",\
+status=~"5.."}[1m])"
+
+   - Traces: the cascade from the highest-level operation down to the deepest \
+failing span, followed by representative trace IDs from the provided data.
+     Example — "checkout request → order-svc goroutine exhaustion → \
+inventory-svc Redis GET timeout. Trace IDs: 4bf92f3577b34da6, a3ce929d0e0e4736"
+
+   - Logs: one sentence with service, endpoint, error, and time range, \
+followed by the exact Lucene query that would retrieve the relevant log lines.
+     Example — "Between 14:18:02 and 14:29:11 UTC, POST /api/checkout \
+returned 503s. Lucene: service:order-svc AND status:503 AND \
+endpoint:\\"/api/checkout\\""
+3. Each "why" targets the previous answer, not the original problem. Drill \
+down one causal chain; do not branch.
+4. Never accept "human error" or "operator mistake" as a terminal answer. \
+Ask why the human was in a position to make that error.
+5. Stop when you reach a cause that is: (a) actionable — something a team \
+can change, or (b) a process or system gap that allowed the failure to \
+propagate. The number of steps is not fixed at 5.
+6. Only include steps that are directly supported by the provided telemetry. \
+If the causal chain cannot be completed with the available evidence, stop \
+and note what additional telemetry would be needed to continue.
+7. After the chain, note any branches you did NOT follow. If the incident \
+has multiple contributing causes that cannot fit a single chain, say so \
+explicitly rather than forcing one.
+
+Output format:
+
+```
+Problem statement:
+[Observable symptom with time, impact, and detection method]
+
+Why 1: [question] → [answer]
+Evidence: [specific signal]
+
+Why 2: [question] → [answer]
+Evidence: [specific signal]
+
+...
+
+Root cause:
+[Single sentence naming the systemic or process failure]
+
+Unexplored branches:
+[Contributing factors visible in telemetry that were not followed, \
+and why they were set aside]
+```
+
+---
+
+## Section 4: Remediation
+
+For each corrective action, identify which step in the causal chain it \
+targets and what class of fix it is:
+
+- **Root cause fix**: eliminates the condition that started the chain
+- **Propagation fix**: limits blast radius if the root cause recurs
+- **Detection fix**: reduces time-to-detect or time-to-mitigate
+
+List actions from root cause outward. Prefer fixes that prevent recurrence \
+over fixes that only improve response.
+
+Output format:
+
+| Action | Targets | Type |
+|--------|---------|------|
+| [What to do] | Why N | Root cause fix / Propagation fix / Detection fix |
+"""
+
+SOLUTION_PROMPT_TEMPLATE = """\
+You are an expert site reliability engineer. You are given a ground-truth \
+rubric describing an incident's root cause, mechanism, and telemetry evidence.
+
+Your task: write an incident report as if you investigated this incident \
+yourself. Use the rubric evidence to populate each section. Do NOT mention \
+the rubric or that you were given ground-truth data — write as though you \
+discovered everything through telemetry analysis.
+
+## Ground-Truth Rubric
+
+{rubric}
+
+## Report Format
+
+{report_format}
+"""
+
+
+def build_solution_prompt(rubric_md: str) -> str:
+    """Build the LLM prompt from a formatted rubric markdown string."""
+    return SOLUTION_PROMPT_TEMPLATE.format(
+        rubric=rubric_md,
+        report_format=REPORT_FORMAT,
+    )
+
+
+async def generate_report(
+    client: Any,
+    rubric_data: dict,
+    model: str | None = DEFAULT_MODEL,
+    effort: str | None = DEFAULT_EFFORT,
+) -> tuple[str, str, list[dict] | None]:
+    """Generate an incident report from rubric JSON.
+
+    If ``model`` is ``None``, the formatted rubric is returned directly with
+    no LLM call. Otherwise the rubric is passed to the LLM to be reformatted
+    into an incident report.
+
+    Returns:
+        A tuple of (report_text, prompt, reasoning_summary). When ``model``
+        is ``None``, ``prompt`` is empty and ``reasoning_summary`` is ``None``.
+
+    """
+    rubric_md = format_rubric(rubric_data)
+    if model is None:
+        return rubric_md, "", None
+    prompt = build_solution_prompt(rubric_md)
+    response_text, reasoning_summary = await async_call_llm_judge(
+        client, prompt, model=model, reasoning_effort=effort
+    )
+    return response_text, prompt, reasoning_summary
+
+
+async def async_main() -> None:
+    """CLI entry point: read rubric, call LLM, write report."""
+    parser = argparse.ArgumentParser(
+        description="Generate an incident report from a rubric JSON via LLM."
+    )
+    parser.add_argument(
+        "--rubric",
+        type=str,
+        default="/tests/rubric.json",
+        help="Path to rubric JSON file.",
+    )
+    parser.add_argument(
+        "--output",
+        type=str,
+        default="/app/report.md",
+        help="Path to write the generated report.",
+    )
+    parser.add_argument(
+        "--model",
+        "-m",
+        type=str,
+        default=DEFAULT_MODEL,
+        help=(
+            "LLM model name. If omitted, the formatted rubric is written "
+            "directly as the report with no LLM call."
+        ),
+    )
+    parser.add_argument(
+        "--effort",
+        "-e",
+        type=str,
+        choices=["low", "medium", "high"],
+        default=DEFAULT_EFFORT,
+        help=f"Reasoning effort level (default: {DEFAULT_EFFORT}).",
+    )
+    args = parser.parse_args()
+
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s - %(levelname)s - %(message)s",
+    )
+
+    rubric_path = Path(args.rubric)
+    output_path = Path(args.output)
+
+    if not rubric_path.is_file():
+        logger.warning(f"Rubric file not found: {rubric_path}; writing empty report")
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        output_path.write_text("")
+        return
+
+    rubric_data = json.loads(rubric_path.read_text())
+    logger.info(
+        f"Loaded rubric: {rubric_data.get('feature_flag', 'unknown')} "
+        f"from {rubric_path}"
+    )
+
+    client: Any = None
+    if args.model is not None:
+        from openai import AsyncOpenAI
+
+        client = AsyncOpenAI(
+            api_key=os.getenv("OPENAI_API_KEY"),
+            base_url=os.getenv("OPENAI_BASE_URL"),
+        )
+
+    report_text, _prompt, reasoning_summary = await generate_report(
+        client, rubric_data, model=args.model, effort=args.effort
+    )
+
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    output_path.write_text(report_text)
+    logger.info(f"Wrote report to {output_path}")
+
+    if reasoning_summary:
+        logger.info(f"Reasoning summary: {reasoning_summary}")
+
+
+if __name__ == "__main__":
+    asyncio.run(async_main())

tasks/d1-c1-admanualgc-on-univ00-universal_ttd15m_at_off+10m/solution/solve.sh

@@ -0,0 +1,28 @@
+#!/bin/bash
+set -euo pipefail
+
+# ── Wait for the entrypoint to finish setting up the environment ──
+echo "[solve] Waiting for environment to be ready..."
+for i in $(seq 1 180); do
+    [ -f /tmp/env-ready ] && break
+    sleep 1
+done
+if [ ! -f /tmp/env-ready ]; then
+    echo "[solve] ERROR: Environment did not become ready within 180s" >&2
+    exit 1
+fi
+echo "[solve] Environment is ready."
+
+# ── Verify all services are healthy ──
+echo "[solve] Running health checks..."
+source /tmp/env-ports
+/app/check_health.sh || {
+    echo "[solve] ERROR: Health checks failed" >&2
+    exit 1
+}
+
+# ── Generate solution report via LLM ──
+echo "[solve] Installing dependencies..."
+pip install tabulate
+echo "[solve] Generating report..."
+python /solution/solve.py --rubric /solution/rubric.json

tasks/d1-c1-admanualgc-on-univ00-universal_ttd15m_at_off+10m/tests/check_prediction.py

@@ -0,0 +1,1005 @@
+"""LLM-as-a-judge verifier for Harbor incident-RCA-report tasks.
+
+Supports two modes:
+
+1. **Harbor verifier** (default):
+       python /tests/check_prediction.py
+
+2. **Post-hoc single-trial**:
+       python check_prediction.py --expected expected.json --predictions report.md [--rubric rubric.json]
+
+Falls back to string-match scoring when OPENAI_API_KEY is not set.
+"""
+
+import argparse
+import asyncio
+import json
+import logging
+import os
+import sys
+import traceback
+from pathlib import Path
+from typing import Any
+
+from tabulate import tabulate
+
+logger = logging.getLogger(__name__)
+
+JUDGE_PROMPT_MULTI_HEADER = """\
+You are an expert SRE tasked with judging the quality of an AI-generated incident RCA report.
+
+You are given:
+1. **One or more** ground-truth rubrics. Each describes a plausible root cause, its incident time, mechanism, and symptoms. Several flags may have been active in the same window; the agent is credited if it correctly identifies **any one** of these rubrics.
+2. The SRE agent's incident RCA report.
+
+## SRE Agent's Incident RCA Report
+
+{predictions}
+
+## Ground-Truth Rubrics
+
+{rubrics}
+
+## Evaluation Questions
+
+For **each rubric** in order, answer every question with true or false. Base your answer only on evidence in the agent's report; if the report does not cite the required evidence, answer false. The output must contain one entry per rubric, in the same order, and must preserve cluster order within each rubric exactly as listed.
+
+For each rubric:
+
+- `incident_time_within_10min`: Did the agent's timeline place the incident start within ±10 minutes of this rubric's `incident_time`?
+- `feature_flag_match`: Did the agent identify this rubric's feature flag as a root cause? (The agent may name multiple flags; mark true if this flag is among them.)
+- `mechanism_match`: Did the agent correctly explain this rubric's mechanism — how the flag propagates to the user-visible failure?
+- For each metric/log/trace cluster listed for this rubric: per-cluster match flags as before.
+"""
+
+JUDGE_PROMPT_SCORING_FOOTER = """\
+
+## Overall Score
+
+Score the incident RCA report on a scale of 0 to 3. The agent is credited if it correctly identifies **any one** of the listed rubrics — score against the rubric the agent's report best matches. Scoring is based on content correctness only; do not penalize or reward for formatting, prose style, or structural polish. Materially incorrect or misleading claims count against the score: if the report would otherwise score N but also adds a materially wrong claim (e.g., invents an unrelated additional cause), drop to N-1 (floor at 0). A report that correctly identifies one root cause but introduces a misleading fabrication alongside it therefore scores 2, not 3. When applying this penalty, explicitly identify in your reasoning which specific claim is materially wrong — quote or paraphrase the offending text. Do not apply the penalty without naming the offending claim; missing detail or incomplete explanation does not qualify as a materially wrong claim. Naming several of the listed plausible root causes is **not** a materially wrong claim.
+
+- 0: AI findings are misaligned with every rubric's mechanism and completely miss the root cause
+- 1: AI verifies incident description — the report confirms symptoms described in the task prompt but does not investigate further
+- 2: AI makes correct progress beyond symptoms — the report identifies some of the ground-truth metrics, logs, or traces for at least one rubric and moves toward that root cause, but does not fully identify any single root cause
+- 3: AI nails at least one of the listed root causes — the report correctly identifies it, the mechanism, and the supporting signals
+
+Respond with ONLY a JSON object matching the provided output schema.
+"""
+
+DEFAULT_MODEL = "openai-gpt-5.4"
+
+
+# ---------------------------------------------------------------------------
+# Rubric rendering (JSON -> markdown)
+# ---------------------------------------------------------------------------
+
+
+def _format_log_clusters(clusters: list[dict], lines: list[str]) -> None:
+    """Render log clusters as markdown subsections."""
+    for cluster in clusters:
+        name = cluster.get("name", "Unknown")
+        count = cluster.get("count")
+        suffix = f" ({count} entries)" if count is not None else ""
+        lines.append(f"#### {name}{suffix}")
+        lines.append("")
+
+        description = cluster.get("description", "")
+        if description:
+            lines.append(description)
+            lines.append("")
+
+        cause = cluster.get("cause", "")
+        if cause:
+            lines.append(f"**Cause:** {cause}")
+            lines.append("")
+
+        source = cluster.get("source", "")
+        if source:
+            lines.append(f"**Source:** {source}")
+            lines.append("")
+
+        attrs = cluster.get("representative_attributes", {})
+        if attrs:
+            lines.append("**Representative attributes:**")
+            lines.append("")
+            rows = [[f"`{k}`", f"`{v}`"] for k, v in attrs.items()]
+            lines.append(tabulate(rows, headers=["Field", "Value"], tablefmt="github"))
+            lines.append("")
+
+        docs = cluster.get("log_documents", [])
+        if docs:
+            lines.append("**Log documents:**")
+            lines.append("")
+            rows = [
+                [f"`{d['_index']}`", f"`{d['_id']}`", d["@timestamp"]] for d in docs
+            ]
+            lines.append(
+                tabulate(
+                    rows, headers=["_index", "_id", "@timestamp"], tablefmt="github"
+                )
+            )
+            lines.append("")
+
+
+def _format_trace_clusters(clusters: list[dict], lines: list[str]) -> None:
+    """Render trace clusters as markdown subsections."""
+    for cluster in clusters:
+        name = cluster.get("name", "Unknown")
+        count = cluster.get("count")
+        suffix = f" ({count} traces)" if count is not None else ""
+        lines.append(f"#### {name}{suffix}")
+        lines.append("")
+
+        description = cluster.get("description", "")
+        if description:
+            lines.append(description)
+            lines.append("")
+
+        cause = cluster.get("cause", "")
+        if cause:
+            lines.append(f"**Cause:** {cause}")
+            lines.append("")
+
+        call_chain = cluster.get("call_chain", "")
+        if call_chain:
+            lines.append("**Call chain:**")
+            lines.append("")
+            lines.append("```")
+            lines.append(call_chain)
+            lines.append("```")
+            lines.append("")
+
+        smoking_gun = cluster.get("smoking_gun", [])
+        if smoking_gun:
+            lines.append("**Smoking-gun error messages:**")
+            lines.append("")
+            for msg in smoking_gun:
+                lines.append(f"- {msg}")
+            lines.append("")
+
+        docs = cluster.get("trace_documents", [])
+        if docs:
+            lines.append("**Trace documents:**")
+            lines.append("")
+            headers = ["traceID", "@timestamp"]
+            has_action = any("user_action" in d for d in docs)
+            if has_action:
+                headers.append("user_action")
+            rows = []
+            for d in docs:
+                row = [f"`{d['traceID']}`", d["@timestamp"]]
+                if has_action:
+                    row.append(d.get("user_action", ""))
+                rows.append(row)
+            lines.append(tabulate(rows, headers=headers, tablefmt="github"))
+            lines.append("")
+
+
+_LAYER_DESCRIPTIONS = {
+    "root_cause": "metric closest to the fault injection point",
+    "propagation": "intermediate services reflecting the error through the call chain",
+    "symptom": "user-facing impact visible to end users or clients",
+    "meta": "feature flag counters or internal plumbing",
+    "unknown": "unclassified",
+}
+
+_LAYER_ORDER = ["root_cause", "propagation", "symptom", "meta", "unknown"]
+
+
+def _format_onset(offset: int | None) -> str:
+    """Format an onset offset as '+Xs' or 'N/A'."""
+    if offset is None:
+        return "N/A"
+    return f"+{offset}s"
+
+
+def _format_label_values(labels: dict[str, str]) -> str:
+    """Format label values as a compact comma-separated string."""
+    if not labels:
+        return ""
+    return ", ".join(labels.values())
+
+
+def _earliest_onset(variants: list[dict]) -> int | None:
+    """Return the earliest onset_offset_seconds across variants, or None."""
+    offsets = [
+        v["onset_offset_seconds"]
+        for v in variants
+        if v.get("onset_offset_seconds") is not None
+    ]
+    return min(offsets) if offsets else None
+
+
+def _format_metrics_list(metrics_list: list[dict], lines: list[str]) -> None:
+    """Render metric families grouped by signal layer."""
+    by_layer: dict[str, list[dict]] = {}
+    for fam in metrics_list:
+        by_layer.setdefault(fam.get("signal_layer", "unknown"), []).append(fam)
+
+    for layer in _LAYER_ORDER:
+        layer_families = by_layer.get(layer, [])
+        if not layer_families:
+            continue
+
+        layer_onsets = [_earliest_onset(f["variants"]) for f in layer_families]
+        layer_onsets = [o for o in layer_onsets if o is not None]
+        layer_onset_str = (
+            f" (earliest onset: {_format_onset(min(layer_onsets))})"
+            if layer_onsets
+            else ""
+        )
+
+        display_layer = layer.replace("_", " ").title()
+        desc = _LAYER_DESCRIPTIONS.get(layer, "")
+        lines.append(f"**{display_layer}** — {desc}{layer_onset_str}")
+        lines.append("")
+
+        for fam in layer_families:
+            fam_onset = _earliest_onset(fam["variants"])
+            label_vals = _format_label_values(fam.get("defining_labels", {}))
+            label_part = f" ({label_vals})" if label_vals else ""
+            lines.append(
+                f"#### {fam['metric_family']} family{label_part}"
+                f" — onset: {_format_onset(fam_onset)}"
+            )
+            lines.append("")
+
+            first_desc = (
+                fam["variants"][0].get("description", "") if fam["variants"] else ""
+            )
+            if first_desc:
+                lines.append(first_desc)
+                lines.append("")
+
+            for v in fam["variants"]:
+                v_onset = _format_onset(v.get("onset_offset_seconds"))
+                lines.append(f"- **{v['type']}** (onset: {v_onset})")
+                lines.append(f"  `{v['query']}`")
+                lines.append("")
+
+
+def _format_frontend_issues(issues: list[dict], lines: list[str]) -> None:
+    """Render frontend issues as markdown subsections."""
+    for issue in issues:
+        route = issue.get("route", "Unknown route")
+        lines.append(f"#### {route}")
+        lines.append("")
+
+        description = issue.get("description", "")
+        if description:
+            lines.append(description)
+            lines.append("")
+
+        rows = [
+            ["Deterministic", str(issue.get("deterministic", ""))],
+            ["Trigger condition", issue.get("trigger_condition", "")],
+            ["Calling service", issue.get("calling_service", "")],
+            [
+                "Source",
+                f"`{issue.get('source_file', '')}:{issue.get('source_line', '')}`",
+            ],
+        ]
+        lines.append(tabulate(rows, headers=["Field", "Value"], tablefmt="github"))
+        lines.append("")
+
+        call_pattern = issue.get("call_pattern", "")
+        if call_pattern:
+            lines.append(f"**Call pattern:** {call_pattern}")
+            lines.append("")
+
+        cause = issue.get("cause", "")
+        if cause:
+            lines.append(f"**Cause:** {cause}")
+            lines.append("")
+
+
+def format_rubric(data: dict, include_frontend: bool = False) -> str:
+    """Convert a rubric JSON dict into a consistently formatted markdown string.
+
+    Args:
+        data: The rubric JSON dict.
+        include_frontend: If True, include the ``### Frontend`` section.
+            Defaults to False since frontend symptoms may be noisy for
+            downstream consumers (LLM judge, oracle solutions).
+            TODO(Albert): systematically test the impact of including vs.
+            excluding frontend symptoms on downstream consumers.
+
+    """
+    lines: list[str] = []
+
+    lines.append(f"# {data['feature_flag']}")
+    lines.append("")
+    lines.append(f"**Feature flag:** `{data['feature_flag']}`")
+    lines.append("")
+    lines.append(f"**Description:** {data['description']}")
+    lines.append("")
+    lines.append(f"**Incident time:** {data['incident_time']}")
+    lines.append("")
+
+    lines.append("## Mechanism")
+    lines.append("")
+    lines.append(data["mechanism"])
+    lines.append("")
+
+    interaction = data.get("interaction", "")
+    if interaction:
+        lines.append(f"**Interaction with other feature flags:** {interaction}")
+        lines.append("")
+
+    lines.append("## Evidence")
+    lines.append("")
+
+    gs = data["symptoms"]
+
+    metrics = gs.get("metrics", [])
+    lines.append("### Metrics")
+    lines.append("")
+    if metrics:
+        _format_metrics_list(metrics, lines)
+
+    logs = gs.get("logs", [])
+    lines.append("### Logs")
+    lines.append("")
+    if logs:
+        _format_log_clusters(logs, lines)
+
+    if include_frontend:
+        frontend = gs.get("frontend", [])
+        lines.append("### Frontend")
+        lines.append("")
+        if frontend:
+            _format_frontend_issues(frontend, lines)
+
+    traces = gs.get("traces", [])
+    lines.append("### Traces")
+    lines.append("")
+    if traces:
+        _format_trace_clusters(traces, lines)
+
+    return "\n".join(lines)
+
+
+# ---------------------------------------------------------------------------
+# Judge prompt + output-schema builders
+# ---------------------------------------------------------------------------
+
+
+def _render_checklist(rubric_data: dict) -> str:
+    """Build per-cluster checklist blocks for metrics/logs/traces."""
+    symptoms = rubric_data.get("symptoms", {}) or {}
+    metric_clusters = symptoms.get("metrics", []) or []
+    log_clusters = symptoms.get("logs", []) or []
+    trace_clusters = symptoms.get("traces", []) or []
+
+    blocks: list[str] = []
+
+    if metric_clusters:
+        lines = ["#### Metric clusters"]
+        for i, m in enumerate(metric_clusters):
+            family = m.get("metric_family", "")
+            lines.append(
+                f'- Cluster {i}: `metric_family = "{family}"`'
+                f" — family_match: did the agent cite a query targeting"
+                f" metric_family `{family}` under a Why-step whose causal chain"
+                f" aligns with the rubric?"
+            )
+        blocks.append("\n".join(lines))
+
+    if log_clusters:
+        lines = ["#### Log clusters"]
+        for i, log in enumerate(log_clusters):
+            attrs = log.get("representative_attributes") or {}
+            body = attrs.get("body", "")
+            service_name = attrs.get("resource.service.name", "")
+            lines.append(
+                f"- Cluster {i}:\n"
+                f"  - `resource.service.name`: `{service_name}`\n"
+                f"  - `body`: `{body}`\n"
+                f"  - body_match: did the agent cite log evidence whose body"
+                f" matches the rubric's `body` under a Why-step whose causal"
+                f" chain aligns with the rubric?\n"
+                f"  - service_name_match: did the agent attribute the cited"
+                f" log evidence to the OTel service `{service_name}`"
+                f" (`resource.service.name`)?"
+            )
+        blocks.append("\n".join(lines))
+
+    if trace_clusters:
+        lines = ["#### Trace clusters"]
+        for i, trace in enumerate(trace_clusters):
+            call_chain = trace.get("call_chain", "")
+            smoking_gun = trace.get("smoking_gun", []) or []
+            sg_rendered = "\n".join(f"    - {s}" for s in smoking_gun)
+            lines.append(
+                f"- Cluster {i}:\n"
+                f"  - call_chain: `{call_chain}`\n"
+                f"  - smoking_gun:\n{sg_rendered}\n"
+                f"  - call_chain_match: did the agent cite evidence matching"
+                f" this service-level call chain under a Why-step whose causal"
+                f" chain aligns with the rubric?\n"
+                f"  - smoking_gun_match: did the agent cite at least one of"
+                f" the listed smoking-gun signals?"
+            )
+        blocks.append("\n".join(lines))
+
+    return (
+        "\n\n".join(blocks)
+        if blocks
+        else "(No metric, log, or trace clusters in rubric.)"
+    )
+
+
+def build_judge_prompt(
+    rubrics_data: list[dict],
+    predictions: str,
+) -> str:
+    """Render the judge prompt for one or more ground-truth rubrics.
+
+    The prompt asks the LLM to evaluate the agent's report against **each**
+    rubric independently. The agent is credited if it correctly identifies
+    any one rubric (the overall score reflects the best match).
+    """
+    if not rubrics_data:
+        raise ValueError("build_judge_prompt called with no rubrics")
+
+    rubric_blocks: list[str] = []
+    checklist_blocks: list[str] = []
+    for i, rubric in enumerate(rubrics_data):
+        feature_flag = rubric.get("feature_flag", "")
+        rubric_blocks.append(
+            f"### Rubric {i + 1} of {len(rubrics_data)} — `{feature_flag}`\n\n"
+            + format_rubric(rubric)
+        )
+        checklist_blocks.append(
+            f"### Rubric {i + 1} of {len(rubrics_data)} — `{feature_flag}`\n\n"
+            + _render_checklist(rubric)
+        )
+
+    rubrics_text = "\n\n---\n\n".join(rubric_blocks)
+    checklist_text = "\n\n---\n\n".join(checklist_blocks)
+
+    header = JUDGE_PROMPT_MULTI_HEADER.format(
+        rubrics=rubrics_text,
+        predictions=predictions,
+    )
+    return header + "\n" + checklist_text + "\n" + JUDGE_PROMPT_SCORING_FOOTER
+
+
+_METRIC_ITEM_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        "metric_family": {"type": "string"},
+        "family_match": {"type": "boolean"},
+    },
+    "required": ["metric_family", "family_match"],
+    "additionalProperties": False,
+}
+
+_LOG_ITEM_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        "body_match": {"type": "boolean"},
+        "service_name_match": {"type": "boolean"},
+    },
+    "required": ["body_match", "service_name_match"],
+    "additionalProperties": False,
+}
+
+_TRACE_ITEM_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        "call_chain_match": {"type": "boolean"},
+        "smoking_gun_match": {"type": "boolean"},
+    },
+    "required": ["call_chain_match", "smoking_gun_match"],
+    "additionalProperties": False,
+}
+
+
+_PER_RUBRIC_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        "feature_flag": {"type": "string"},
+        "incident_time_within_10min": {"type": "boolean"},
+        "feature_flag_match": {"type": "boolean"},
+        "mechanism_match": {"type": "boolean"},
+        "symptoms": {
+            "type": "object",
+            "properties": {
+                "metrics": {"type": "array", "items": _METRIC_ITEM_SCHEMA},
+                "logs": {"type": "array", "items": _LOG_ITEM_SCHEMA},
+                "traces": {"type": "array", "items": _TRACE_ITEM_SCHEMA},
+            },
+            "required": ["metrics", "logs", "traces"],
+            "additionalProperties": False,
+        },
+    },
+    "required": [
+        "feature_flag",
+        "incident_time_within_10min",
+        "feature_flag_match",
+        "mechanism_match",
+        "symptoms",
+    ],
+    "additionalProperties": False,
+}
+
+
+def build_judge_output_schema(rubrics_data: list[dict]) -> dict:
+    """Build a strict JSON Schema for the judge output: one verdict per rubric
+    + an overall ``score`` integer. Falls back to a minimal ``{score: int}``
+    schema when no rubrics are supplied (no-incident path).
+
+    Per-rubric cluster-array lengths vary across rubrics; rather than encode
+    a per-element schema (which Structured Outputs doesn't support), we leave
+    the array lengths unconstrained and rely on the prompt instructions to
+    keep cluster order matching.
+    """
+    if not rubrics_data:
+        return {
+            "type": "object",
+            "properties": {"score": {"type": "integer"}},
+            "required": ["score"],
+            "additionalProperties": False,
+        }
+
+    n = len(rubrics_data)
+    return {
+        "type": "object",
+        "properties": {
+            "rubrics": {
+                "type": "array",
+                "minItems": n,
+                "maxItems": n,
+                "items": _PER_RUBRIC_SCHEMA,
+            },
+            "score": {"type": "integer"},
+        },
+        "required": ["rubrics", "score"],
+        "additionalProperties": False,
+    }
+
+
+# ---------------------------------------------------------------------------
+# API call
+# ---------------------------------------------------------------------------
+
+
+async def async_call_llm_judge(
+    client: Any,
+    prompt: str,
+    model: str = DEFAULT_MODEL,
+    reasoning_effort: str | None = None,
+    output_schema: dict | None = None,
+) -> tuple[str, list[dict] | None]:
+    """Call the LLM judge via the OpenAI Responses API (falling back to Chat).
+
+    When ``output_schema`` is provided, uses Structured Outputs (strict JSON
+    Schema) so the returned text is guaranteed to conform to the schema.
+
+    Returns:
+        A tuple of (output_text, reasoning_summaries). reasoning_summaries is
+        None when reasoning_effort is not set.
+
+    """
+    text_format: dict[str, Any] = (
+        {
+            "type": "json_schema",
+            "name": "judge_response",
+            "schema": output_schema,
+            "strict": True,
+        }
+        if output_schema is not None
+        else {"type": "text"}
+    )
+    try:
+        kwargs: dict[str, Any] = {
+            "model": model,
+            "input": prompt,
+            "text": {"format": text_format},
+            "tools": [],
+            "store": True,
+            "max_output_tokens": 16384,
+        }
+        if reasoning_effort is not None:
+            kwargs["reasoning"] = {"effort": reasoning_effort, "summary": "auto"}
+        response = await client.responses.create(**kwargs)
+        reasoning_summaries = None
+        if reasoning_effort is not None:
+            reasoning_summaries = [
+                [
+                    s.model_dump() if hasattr(s, "model_dump") else s
+                    for s in item.summary
+                ]
+                for item in response.output
+                if getattr(item, "type", None) == "reasoning"
+                and getattr(item, "summary", None) is not None
+            ]
+        return response.output_text, reasoning_summaries
+    except Exception as exc:
+        if "404" not in str(exc):
+            raise
+        logger.info(
+            f"Responses API returned 404 for {model}, falling back to Chat Completions"
+        )
+        chat_kwargs: dict[str, Any] = {
+            "model": model,
+            "messages": [{"role": "user", "content": prompt}],
+            "max_tokens": 16384,
+        }
+        if output_schema is not None:
+            chat_kwargs["response_format"] = {
+                "type": "json_schema",
+                "json_schema": {
+                    "name": "judge_response",
+                    "schema": output_schema,
+                    "strict": True,
+                },
+            }
+        if reasoning_effort is not None:
+            chat_kwargs["reasoning_effort"] = reasoning_effort
+        response = await client.chat.completions.create(**chat_kwargs)
+        reasoning_summaries = None
+        if reasoning_effort is not None:
+            reasoning_content = getattr(
+                response.choices[0].message, "reasoning_content", None
+            )
+            if reasoning_content is not None:
+                reasoning_summaries = [{"type": "text", "text": reasoning_content}]
+            else:
+                reasoning_summaries = []
+        return response.choices[0].message.content, reasoning_summaries
+
+
+# ---------------------------------------------------------------------------
+# Parsing + aggregation
+# ---------------------------------------------------------------------------
+
+
+def parse_judge_response(response_text: str) -> dict:
+    """Parse the judge response JSON and range-check ``score``.
+
+    When Structured Outputs are used upstream, the response is already
+    schema-validated; this function only decodes the JSON and enforces the
+    0-3 range for ``score``.
+    """
+    parsed = json.loads(response_text)
+    score = int(parsed["score"])
+    if score < 0 or score > 3:
+        raise ValueError(f"Score {score} out of range [0, 3]")
+    parsed["score"] = score
+    return parsed
+
+
+def _aggregate_one_rubric(verdict: dict) -> dict:
+    """Roll up cluster verdicts for a single per-rubric judge entry."""
+    symptoms = verdict.get("symptoms", {}) or {}
+    metrics = symptoms.get("metrics", []) or []
+    logs = symptoms.get("logs", []) or []
+    traces = symptoms.get("traces", []) or []
+
+    metric_hits = [bool(m.get("family_match")) for m in metrics]
+    log_hits = [
+        bool(l.get("body_match")) and bool(l.get("service_name_match")) for l in logs
+    ]
+    trace_hits = [
+        bool(t.get("call_chain_match")) and bool(t.get("smoking_gun_match"))
+        for t in traces
+    ]
+
+    def _all(hits: list[bool]) -> bool | None:
+        return all(hits) if hits else None
+
+    def _any(hits: list[bool]) -> bool | None:
+        return any(hits) if hits else None
+
+    return {
+        "feature_flag": verdict.get("feature_flag", ""),
+        "incident_time_within_10min": bool(verdict.get("incident_time_within_10min")),
+        "feature_flag_match": bool(verdict.get("feature_flag_match")),
+        "mechanism_match": bool(verdict.get("mechanism_match")),
+        "metrics_all_match": _all(metric_hits),
+        "metrics_any_match": _any(metric_hits),
+        "logs_all_match": _all(log_hits),
+        "logs_any_match": _any(log_hits),
+        "traces_all_match": _all(trace_hits),
+        "traces_any_match": _any(trace_hits),
+    }
+
+
+def aggregate_judge_response(parsed: dict) -> dict:
+    """Aggregate per-rubric, per-cluster verdicts into flat any-of rollups.
+
+    The agent is credited if it matches any one of the listed rubrics.
+    Per-rubric rollups are computed via ``_aggregate_one_rubric``; the
+    task-level rollup is the ``any`` over rubrics for booleans (with ``None``
+    skipped — sections without clusters in any rubric stay ``None``).
+
+    The per-rubric rollups are also returned under ``per_rubric`` for
+    downstream analysis that needs to know which specific rubric matched.
+    """
+    rubrics = parsed.get("rubrics") or []
+    per_rubric = [_aggregate_one_rubric(r) for r in rubrics]
+
+    def _any_skip_none(values: list[bool | None]) -> bool | None:
+        truthy = [v for v in values if v is not None]
+        return any(truthy) if truthy else None
+
+    return {
+        "incident_time_within_10min": _any_skip_none(
+            [r["incident_time_within_10min"] for r in per_rubric]
+        )
+        or False,
+        "feature_flag_match": _any_skip_none(
+            [r["feature_flag_match"] for r in per_rubric]
+        )
+        or False,
+        "mechanism_match": _any_skip_none([r["mechanism_match"] for r in per_rubric])
+        or False,
+        "metrics_all_match": _any_skip_none(
+            [r["metrics_all_match"] for r in per_rubric]
+        ),
+        "metrics_any_match": _any_skip_none(
+            [r["metrics_any_match"] for r in per_rubric]
+        ),
+        "logs_all_match": _any_skip_none([r["logs_all_match"] for r in per_rubric]),
+        "logs_any_match": _any_skip_none([r["logs_any_match"] for r in per_rubric]),
+        "traces_all_match": _any_skip_none([r["traces_all_match"] for r in per_rubric]),
+        "traces_any_match": _any_skip_none([r["traces_any_match"] for r in per_rubric]),
+        "per_rubric": per_rubric,
+        "score": int(parsed["score"]),
+    }
+
+
+def string_match_fallback(expected: dict, predictions: str) -> dict:
+    """Fall back to case-insensitive string search for any plausible root_cause.
+
+    ``expected["events"]`` is a list of ``{"root_cause": <flag>, "event_time": ...}``;
+    the agent's report is credited if any listed root_cause appears in it.
+    Returns a result dict compatible with the judge output format.
+    """
+    events: list[dict] = expected.get("events") or []
+    if not events:
+        # No-incident task: agent should write an empty report.
+        return {"score": 3 if len(predictions.strip()) == 0 else 0}
+    text = predictions.lower()
+    found = any(e["root_cause"].strip().lower() in text for e in events)
+    return {"score": 3 if found else 0}
+
+
+# ---------------------------------------------------------------------------
+# Judge entry point (used by both modes)
+# ---------------------------------------------------------------------------
+
+
+async def judge(
+    client: Any,
+    expected: dict,
+    predictions: str,
+    rubrics_data: list[dict],
+    model: str = DEFAULT_MODEL,
+    reasoning_effort: str | None = None,
+) -> dict:
+    """Run the LLM judge over one or more ground-truth rubrics, or
+    short-circuit for no-incident tasks.
+
+    Returns:
+        A dict with keys: reward, mode, score, and (for LLM judge) model,
+        nested (raw judge response), reasoning_summary, rubric_used,
+        judge_prompt, judge_response_raw. Per-section rollups are derived
+        post-hoc from ``nested`` by formatters via ``aggregate_judge_response``.
+
+    """
+    events: list[dict] = expected.get("events") or []
+    if not events:
+        score = 3 if len(predictions.strip()) == 0 else 0
+        return {
+            "reward": score / 3.0,
+            "mode": "no_incident",
+            "model": model,
+            "score": score,
+        }
+
+    # Short-circuit when the agent emitted an empty report despite an incident.
+    # No LLM call can rescue this; score is a guaranteed 0. We synthesize the
+    # nested response shape (per-rubric all False, matching cluster counts)
+    # so that ``aggregate_judge_response`` produces the expected all-False
+    # rollups at load time.
+    if not predictions.strip():
+        synthetic_per_rubric = []
+        for rubric in rubrics_data:
+            symptoms = rubric.get("symptoms", {}) or {}
+            synthetic_per_rubric.append(
+                {
+                    "feature_flag": rubric.get("feature_flag", ""),
+                    "incident_time_within_10min": False,
+                    "feature_flag_match": False,
+                    "mechanism_match": False,
+                    "symptoms": {
+                        "metrics": [
+                            {
+                                "metric_family": m.get("metric_family", ""),
+                                "family_match": False,
+                            }
+                            for m in (symptoms.get("metrics") or [])
+                        ],
+                        "logs": [
+                            {"body_match": False, "service_name_match": False}
+                            for _ in (symptoms.get("logs") or [])
+                        ],
+                        "traces": [
+                            {"call_chain_match": False, "smoking_gun_match": False}
+                            for _ in (symptoms.get("traces") or [])
+                        ],
+                    },
+                }
+            )
+        return {
+            "mode": "empty_report",
+            "model": model,
+            "score": 0,
+            "reward": 0.0,
+            "rubric_used": bool(rubrics_data),
+            "nested": {"rubrics": synthetic_per_rubric, "score": 0},
+        }
+
+    prompt = build_judge_prompt(rubrics_data, predictions)
+    output_schema = build_judge_output_schema(rubrics_data)
+
+    raw_response, reasoning_summary = await async_call_llm_judge(
+        client,
+        prompt,
+        model=model,
+        reasoning_effort=reasoning_effort,
+        output_schema=output_schema,
+    )
+    parsed = parse_judge_response(raw_response)
+
+    # Per-section rollups are NOT spread into the result — they're a pure
+    # post-hoc derivation from ``nested`` via ``aggregate_judge_response``,
+    # applied by the formatters at load time so schema changes don't require
+    # rewriting saved JSONs.
+    return {
+        "mode": "llm_judge",
+        "model": model,
+        "score": parsed["score"],
+        "reward": parsed["score"] / 3.0,
+        "reasoning_summary": reasoning_summary,
+        "rubric_used": bool(rubrics_data),
+        "judge_prompt": prompt,
+        "judge_response_raw": raw_response,
+        "nested": parsed,
+    }
+
+
+# ---------------------------------------------------------------------------
+# CLI
+# ---------------------------------------------------------------------------
+
+
+async def main() -> None:
+    """Entry point: load expected + predictions, score, write reward/details."""
+    parser = argparse.ArgumentParser(
+        description="LLM-as-a-judge verifier for Harbor incident-RCA-report tasks."
+    )
+    parser.add_argument("--expected", type=str, default="/tests/expected.json")
+    parser.add_argument("--predictions", type=str, default="/app/report.md")
+    parser.add_argument(
+        "--rubrics-dir",
+        type=str,
+        default="/tests/rubrics",
+        help=(
+            "Directory containing one rubric JSON per plausible root cause "
+            "(e.g. /tests/rubrics/<event_id>.json). The judge scores the "
+            "agent against any one of them."
+        ),
+    )
+    parser.add_argument(
+        "--model", type=str, default=DEFAULT_MODEL, help="Judge LLM model name."
+    )
+    parser.add_argument(
+        "--effort",
+        type=str,
+        choices=["low", "medium", "high"],
+        default="high",
+        help="Reasoning effort level for the judge LLM (default: high).",
+    )
+    parser.add_argument(
+        "--mode",
+        type=str,
+        choices=["string_match", "llm_judge"],
+        default="string_match",
+        help="Scoring mode: string_match or llm_judge (default: string_match).",
+    )
+    parser.add_argument("--reward", type=str, default="/logs/verifier/reward.txt")
+    parser.add_argument("--details", type=str, default="/logs/verifier/details.json")
+    args = parser.parse_args()
+
+    expected_path = Path(args.expected)
+    predictions_path = Path(args.predictions)
+    rubrics_dir = Path(args.rubrics_dir)
+    reward_path = Path(args.reward)
+    details_path = Path(args.details)
+
+    try:
+        # Load expected
+        print(f"Loading expected results from {expected_path}...")
+        with expected_path.open() as f:
+            expected = json.load(f)
+
+        # Load predictions (markdown report)
+        print(f"Loading predictions from {predictions_path}...")
+        predictions = predictions_path.read_text()
+
+        # Load rubric JSONs — one per plausible root cause. Order is the
+        # filesystem sort order, which matches the build_harbor_tasks.py
+        # naming convention (event_id stems sort lexicographically).
+        rubrics_data: list[dict] = []
+        if expected.get("events"):
+            if rubrics_dir.is_dir():
+                rubric_paths = sorted(rubrics_dir.glob("*.json"))
+                for p in rubric_paths:
+                    with p.open() as f:
+                        rubrics_data.append(json.load(f))
+                print(f"Loaded {len(rubrics_data)} rubric(s) from {rubrics_dir}")
+            else:
+                print(f"Rubric directory missing: {rubrics_dir}")
+        else:
+            print("No incident events in expected results; skipping rubric load.")
+
+        # Run judge
+        if args.mode == "string_match":
+            em = string_match_fallback(expected, predictions)
+            result = {"reward": em["score"] / 3.0, "mode": "string_match", **em}
+        else:
+            from openai import AsyncOpenAI
+
+            client = AsyncOpenAI(
+                api_key=os.getenv("OPENAI_API_KEY"),
+                base_url=os.getenv("OPENAI_BASE_URL"),
+            )
+            result = await judge(
+                client,
+                expected,
+                predictions,
+                rubrics_data,
+                model=args.model,
+                reasoning_effort=args.effort,
+            )
+
+        # Write reward
+        reward_path.parent.mkdir(parents=True, exist_ok=True)
+        reward_path.write_text(str(result["reward"]))
+
+        # Write details
+        details_path.parent.mkdir(parents=True, exist_ok=True)
+        details_path.write_text(json.dumps(result, indent=2))
+
+        print(f"Score: {result.get('score', 'N/A')}/3 (reward: {result['reward']})")
+        print(f"Mode: {result['mode']}")
+        if result.get("reasoning_summary"):
+            print(f"Reasoning summary: {result['reasoning_summary']}")
+
+        if result["reward"] < 1.0:
+            sys.exit(1)
+
+    except Exception as exc:
+        reward_path.parent.mkdir(parents=True, exist_ok=True)
+        reward_path.write_text("0.0")
+        details_path.parent.mkdir(parents=True, exist_ok=True)
+        details_path.write_text(
+            json.dumps(
+                {
+                    "reward": 0.0,
+                    "error": f"{type(exc).__name__}: {exc}",
+                    "traceback": traceback.format_exc(),
+                },
+                indent=2,
+            )
+        )
+        print(f"Verifier error: {type(exc).__name__}: {exc}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

tasks/d1-c1-admanualgc-on-univ00-universal_ttd15m_at_off+10m/tests/expected.json

@@ -0,0 +1,14 @@
+{
+  "events": [
+    {
+      "event_id": "d1-i1-imageSlowLoad-on",
+      "root_cause": "imageSlowLoad",
+      "event_time": "2026-04-19T14:01:51.404464+00:00"
+    },
+    {
+      "event_id": "d1-i2-adFailure-on",
+      "root_cause": "adFailure",
+      "event_time": "2026-04-19T16:32:19.033653+00:00"
+    }
+  ]
+}

tasks/d1-c1-admanualgc-on-univ00-universal_ttd15m_at_off+10m/tests/rubrics/d1-i1-imageSlowLoad-on.json

@@ -0,0 +1,24 @@
+{
+  "incident_time": "2026-04-19T14:01:51.404464+00:00",
+  "feature_flag": "imageSlowLoad",
+  "description": "A feature flag in the frontend `ProductCard` React component added an `x-envoy-fault-delay-request` header (plus `Cache-Control: no-cache`) to every product-image fetch; Envoy honored the fault-injection header and artificially delayed each `GET /images/products/<picture>` response, so product thumbnails took seconds to render.",
+  "mechanism": "The flag is read in [`ProductCard.tsx#L32`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L32): the `ProductCard` React component calls `useNumberFlagValue('imageSlowLoad', 0)` to get the delay value in milliseconds (variants: `0` for off, `5000` for 5 sec, `10000` for 10 sec). When non-zero, the component sets the `x-envoy-fault-delay-request` header to the flag value on every product image fetch ([`ProductCard.tsx#L37`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L37)).\n\nThe image request is sent to `/images/products/<picture>`, which the frontend-proxy Envoy routes to the `image-provider` cluster ([`envoy.tmpl.yaml#L54-L55`](../../opentelemetry-demo/src/frontend-proxy/envoy.tmpl.yaml#L54)). Envoy's `envoy.filters.http.fault` filter is configured with `header_delay: {}` and 100% percentage ([`envoy.tmpl.yaml#L67-L74`](../../opentelemetry-demo/src/frontend-proxy/envoy.tmpl.yaml#L67)), meaning it honors the `x-envoy-fault-delay-request` header and injects the specified delay (in ms) before forwarding the request. Every product card image load is therefore delayed by the flag value (e.g. 5 or 10 seconds), causing the page to render with blank/loading images until the delayed responses arrive.",
+  "symptoms": {
+    "metrics": [],
+    "logs": [],
+    "frontend": [
+      {
+        "description": "Product card thumbnails on the homepage product grid (and the recommendations carousel on product/cart/checkout pages) render with a blank image placeholder for ~5 seconds before the actual thumbnail appears. The page text and layout render immediately; only the images are delayed. Affects every product card on every page load while the flag is on — the failure is silent slowness, not a visible error.",
+        "route": "GET /images/products/<picture>",
+        "deterministic": true,
+        "trigger_condition": "Every page load that renders a `ProductCard` component — homepage product grid (`/`), recommendations carousel on product detail (`/product/<id>`), cart, and checkout pages.",
+        "source_file": "src/frontend/components/ProductCard/ProductCard.tsx",
+        "source_line": 37,
+        "calling_service": "frontend",
+        "call_pattern": "ProductCard.useEffect ([`ProductCard.tsx#L34`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L34)) → fetch(`/images/products/<picture>`) with header `x-envoy-fault-delay-request: 5000` ([`ProductCard.tsx#L37`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L37)) → frontend-proxy Envoy → image-provider.",
+        "cause": "`useNumberFlagValue('imageSlowLoad', 0)` returns 5000 (the `5sec` variant value, [`demo.flagd.json` `imageSlowLoad.variants.5sec`](../../opentelemetry-demo/src/flagd/demo.flagd.json)). ProductCard sets `x-envoy-fault-delay-request: 5000` on every image fetch ([`ProductCard.tsx#L37`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L37)). The frontend-proxy `envoy.filters.http.fault` filter ([`envoy.tmpl.yaml#L67`](../../opentelemetry-demo/src/frontend-proxy/envoy.tmpl.yaml#L67)) honors this header and delays each image response by 5000ms before forwarding to image-provider, so each `<S.Image>` only resolves after that delay."
+      }
+    ],
+    "traces": []
+  }
+}

tasks/d1-c1-admanualgc-on-univ00-universal_ttd15m_at_off+10m/tests/rubrics/d1-i2-adFailure-on.json

@@ -0,0 +1,210 @@
+{
+  "incident_time": "2026-04-19T16:32:19.033653+00:00",
+  "feature_flag": "adFailure",
+  "description": "A feature flag in the ad service's `GetAds` handler threw `StatusRuntimeException(Status.UNAVAILABLE)` on ~10% of calls (`random.nextInt(10) == 0`); the frontend `/api/data` route caught the gRPC error and returned HTTP 500, but React Query's default `adList = []` fallback masked the failure in the UI — the yellow ad banner silently rendered blank rather than showing an error.",
+  "mechanism": "The flag is read in [`AdService.java#L205`](../../opentelemetry-demo/src/ad/src/main/java/oteldemo/AdService.java#L205): on every `getAds` gRPC call, after ads have been collected and the request/response type attributes set, the service evaluates `ffClient.getBooleanValue(\"adFailure\", false, evaluationContext)`. When `true`, it throws `StatusRuntimeException(Status.UNAVAILABLE)` with probability 1/10 (`random.nextInt(10) == 0`) at [`AdService.java#L206`](../../opentelemetry-demo/src/ad/src/main/java/oteldemo/AdService.java#L206).\n\nThe exception is caught at [`AdService.java#L218`](../../opentelemetry-demo/src/ad/src/main/java/oteldemo/AdService.java#L218): the catch block adds an \"Error\" span event (line 219-220), sets the span status to ERROR (line 221), logs a WARN \"GetAds Failed with status {UNAVAILABLE}\" (line 222), and calls `responseObserver.onError(e)` (line 223) which sends the gRPC UNAVAILABLE status back to the caller.\n\nThe frontend calls the ad service via [`Ad.gateway.ts#L14`](../../opentelemetry-demo/src/frontend/gateways/rpc/Ad.gateway.ts#L14) (`client.getAds`), invoked from the `/api/data` route at [`data.ts#L15`](../../opentelemetry-demo/src/frontend/pages/api/data.ts#L15). When the gRPC call fails, the error propagates through the Next.js API route as an unhandled rejection, and the frontend-proxy Envoy returns HTTP 500 to the client.",
+  "symptoms": {
+    "metrics": [
+      {
+        "metric_family": "rpc_server_duration_milliseconds",
+        "signal_layer": "root_cause",
+        "defining_labels": {
+          "rpc_grpc_status_code": "14",
+          "rpc_method": "GetAds",
+          "rpc_service": "oteldemo.AdService",
+          "service_name": "ad"
+        },
+        "variants": [
+          {
+            "type": "created (fixed after human verification)",
+            "query": "rate(rpc_server_duration_milliseconds_count{rpc_service=\"oteldemo.AdService\",rpc_method=\"GetAds\",rpc_grpc_status_code=\"14\",service_name=\"ad\"}[5m])",
+            "description": "gRPC server call count for AdService/GetAds with status code 14 (UNAVAILABLE). This new series appeared because the adFailure flag causes AdService.java to throw StatusRuntimeException(Status.UNAVAILABLE) with 1/10 probability on each GetAds call.",
+            "onset_utc": "2026-04-19 16:41:00 UTC",
+            "onset_offset_seconds": 520,
+            "onset_reasoning": "The metric type is 'created'. Pre-incident baseline is 0. At 16:41:00 UTC the rate first rises above zero (0.0048), approximately 9 minutes after the incident time. This is the first appearance of rpc_grpc_status_code=14 (UNAVAILABLE) errors for the AdService, indicating the onset of the fault."
+          },
+          {
+            "type": "created (fixed after human verification)",
+            "query": "rate(rpc_server_duration_milliseconds_sum{rpc_service=\"oteldemo.AdService\",rpc_method=\"GetAds\",rpc_grpc_status_code=\"14\",service_name=\"ad\"}[5m])",
+            "description": "Cumulative gRPC server call duration (ms) for AdService/GetAds UNAVAILABLE errors. Tracks the total latency of the failed GetAds RPCs triggered by the adFailure flag.",
+            "onset_utc": "2026-04-19 16:41:00 UTC",
+            "onset_offset_seconds": 520,
+            "onset_reasoning": "The metric type is 'created'. Pre-incident baseline is 0. At 16:41:00 UTC the value first rises to 0.0145643, which is the first non-zero reading after the incident time (16:32:19 UTC), indicating the onset of rpc_server_duration for status_code=14 (UNAVAILABLE) errors on AdService.GetAds."
+          }
+        ]
+      },
+      {
+        "metric_family": "traces_span_metrics_calls",
+        "signal_layer": "root_cause",
+        "defining_labels": {
+          "service_name": "ad",
+          "span_kind": "SPAN_KIND_SERVER",
+          "span_name": "oteldemo.AdService/GetAds",
+          "status_code": "STATUS_CODE_ERROR"
+        },
+        "variants": [
+          {
+            "type": "created (fixed after human verification)",
+            "query": "rate(traces_span_metrics_calls_total{service_name=\"ad\",span_name=\"oteldemo.AdService/GetAds\",span_kind=\"SPAN_KIND_SERVER\",status_code=\"STATUS_CODE_ERROR\"}[5m])",
+            "description": "Span-derived call counter for ad-service GetAds errors. This series did not exist before the incident; it appeared when the adFailure flag began triggering StatusRuntimeException(UNAVAILABLE) with ~10% probability on every GetAds gRPC call.",
+            "onset_utc": "2026-04-19 16:40:00 UTC",
+            "onset_offset_seconds": 460,
+            "onset_reasoning": "This is a 'created' metric type, meaning the series appeared after the incident. The incident occurred at 16:32:19 UTC, and the first data point in the series is at 16:40:00 UTC with a non-zero value of 0.00623, indicating error spans began appearing for the ad service's GetAds endpoint. This is the first timestamp where the metric exists, marking the onset of the error signal."
+          }
+        ]
+      },
+      {
+        "metric_family": "http_server_duration_milliseconds",
+        "signal_layer": "propagation",
+        "defining_labels": {
+          "http_method": "GET",
+          "http_status_code": "500",
+          "service_name": "frontend"
+        },
+        "variants": [
+          {
+            "type": "created (fixed after human verification)",
+            "query": "rate(http_server_duration_milliseconds_count{http_status_code=\"500\",service_name=\"frontend\",http_method=\"GET\"}[5m])",
+            "description": "HTTP server request count for frontend service returning 500 status. New series appeared as the ad service UNAVAILABLE errors propagate through the Next.js /api/data route handler, causing the frontend to return HTTP 500 to clients.",
+            "onset_utc": "2026-04-19 16:41:00 UTC",
+            "onset_offset_seconds": 520,
+            "onset_reasoning": "The metric is a 'created' type. Pre-incident baseline is 0. At 16:41:00, the rate rises from 0 to ~0.00476, marking the first appearance of HTTP 500 errors on the frontend service. This is approximately 9 minutes after the incident injection at 16:32:19, consistent with propagation delay."
+          },
+          {
+            "type": "created (fixed after human verification)",
+            "query": "rate(http_server_duration_milliseconds_sum{http_status_code=\"500\",service_name=\"frontend\",http_method=\"GET\"}[5m])",
+            "description": "Cumulative HTTP server request duration (ms) for frontend 500 responses. Tracks total latency of the error responses caused by the ad service failure cascade.",
+            "onset_utc": "2026-04-19 16:41:00 UTC",
+            "onset_offset_seconds": 520,
+            "onset_reasoning": "The metric is a 'created' type. Pre-incident baseline is 0. At 16:41:00 UTC the rate first rises to ~0.049, which is the first significant departure from zero after the incident time (16:32:19 UTC), indicating the onset of HTTP 500 errors on the frontend."
+          }
+        ]
+      },
+      {
+        "metric_family": "feature_flag_flagd_impression",
+        "signal_layer": "meta",
+        "defining_labels": {
+          "feature_flag_key": "adFailure",
+          "feature_flag_result_variant": "on"
+        },
+        "variants": [
+          {
+            "type": "created (fixed after human verification)",
+            "query": "feature_flag_flagd_impression_total{feature_flag_key=\"adFailure\",feature_flag_result_variant=\"on\"}",
+            "description": "flagd impression counter for adFailure flag with result variant 'on'. This new series appeared at 16:33 UTC when the adFailure feature flag was toggled from off to on, confirming the flag change that triggers the ad service failures.",
+            "onset_utc": "2026-04-19 16:33:00 UTC",
+            "onset_offset_seconds": 40,
+            "onset_reasoning": "This is a 'created' metric — the series did not exist before the incident. The first data point appears at 16:33:00 UTC, approximately 1 minute after the incident time (16:32:19 UTC), indicating the feature flag was toggled on and the metric was created at that point."
+          }
+        ]
+      }
+    ],
+    "logs": [
+      {
+        "name": "GET /api/data → 500",
+        "description": "Between 16:37:08 and 16:39:42 UTC, GET /api/data?contextKeys={category} returned 500 errors twice (2 failures out of 20 completed /api/data requests after the incident, ~10%, matching the 1/10 probabilistic failure rate). Each failing request shares its traceId with an ad-service GetAds UNAVAILABLE WARN logged ~15-20 ms later.",
+        "cause": "Direct effect of the adFailure flag. pages/api/data.ts calls AdGateway.listAds, which invokes the ad service's GetAds gRPC. When adFailure is on, AdService.java:205 throws StatusRuntimeException(Status.UNAVAILABLE) with 1/10 probability (random.nextInt(10) == 0), which propagates back through the frontend gateway as a 500. The two failing requests sample different categories (telescopes, books) — each page load picks a category before the ad fetch.",
+        "source": "frontend-proxy Envoy access logs",
+        "representative_attributes": {
+          "body": "[2026-04-19T16:37:08.414Z] \"GET /api/data?contextKeys=telescopes HTTP/1.1\" 500 - via_upstream - \"-\" 0 21 27 26 \"-\" \"python-requests/2.32.5\" \"6261b255-4f6c-9a2d-b2d6-0da5a59774b5\" \"frontend-proxy:8080\" \"172.18.0.27:8080\" frontend 172.18.0.29:41088 172.18.0.29:8080 172.18.0.28:42900 - -",
+          "event.name": "proxy.access",
+          "url.full": "http://frontend-proxy:8080/api/data?contextKeys=telescopes",
+          "url.path": "/api/data?contextKeys=telescopes",
+          "upstream.cluster": "frontend",
+          "upstream.host": "172.18.0.27:8080",
+          "destination.address": "172.18.0.27",
+          "source.address": "172.18.0.28",
+          "server.address": "172.18.0.29:8080",
+          "user_agent.original": "python-requests/2.32.5",
+          "resource.service.name": "frontend-proxy",
+          "resource.log_name": "otel_envoy_access_log",
+          "traceId": "4a9c115c071f58e00205700b7ff2b852",
+          "spanId": "bf1dc411e2a87489"
+        },
+        "log_documents": [
+          {
+            "_index": "otel-logs-2026-04-19",
+            "_id": "lIWapp0Br_RFnSwRY0tx",
+            "@timestamp": "16:37:08.414"
+          },
+          {
+            "_index": "otel-logs-2026-04-19",
+            "_id": "yIWcpp0Br_RFnSwRvVEg",
+            "@timestamp": "16:39:42.669"
+          }
+        ]
+      },
+      {
+        "name": "ad: GetAds Failed (WARN)",
+        "description": "Between 16:37:08 and 16:39:42 UTC, the ad service emitted 2 WARN logs reporting that GetAds failed with gRPC status UNAVAILABLE. Each WARN arrives ~15 ms after its corresponding /api/data 500 in the frontend-proxy access log, giving a 1:1 correspondence with the GetAds UNAVAILABLE Cascade traces (matching the 2 failing traces under that cluster). These are the only WARN-severity logs from the ad service in the incident window.",
+        "cause": "Smoking-gun direct evidence of the adFailure flag. Each time AdService.java:205 throws StatusRuntimeException(Status.UNAVAILABLE), execution enters the catch block at AdService.java:218, which calls logger.log(Level.WARN, \"GetAds Failed with status {}\", e.getStatus()) at AdService.java:222 before rethrowing to the gRPC client. The ad service explicitly names the failing RPC and echoes the UNAVAILABLE status code from the feature-flag code path.",
+        "source": "ad service (Java, oteldemo.AdService logger via OpenTelemetry Java agent)",
+        "representative_attributes": {
+          "body": "GetAds Failed with status Status{code=UNAVAILABLE, description=null, cause=null}",
+          "severity.text": "WARN",
+          "severity.number": "13",
+          "instrumentationScope.name": "oteldemo.AdService",
+          "resource.service.name": "ad",
+          "resource.service.namespace": "opentelemetry-demo",
+          "resource.service.version": "2.2.0",
+          "resource.telemetry.sdk.language": "java",
+          "resource.telemetry.distro.name": "opentelemetry-java-instrumentation",
+          "traceId": "4a9c115c071f58e00205700b7ff2b852",
+          "spanId": "c8be6b167e3936cb"
+        },
+        "log_documents": [
+          {
+            "_index": "otel-logs-2026-04-19",
+            "_id": "mIWapp0Br_RFnSwRZEt3",
+            "@timestamp": "16:37:08.429"
+          },
+          {
+            "_index": "otel-logs-2026-04-19",
+            "_id": "0YWcpp0Br_RFnSwRvlE6",
+            "@timestamp": "16:39:42.676"
+          }
+        ]
+      }
+    ],
+    "frontend": [
+      {
+        "description": "The yellow ad banner at the bottom of product detail and checkout confirmation pages renders as a blank yellow box with no ad text and no link. The rest of the page loads normally — the failure is silent degradation, not a visible error.",
+        "route": "GET /api/data",
+        "deterministic": false,
+        "trigger_condition": "User visits a product detail page or checkout confirmation page, triggering an ad fetch via AdProvider. The ad service fails with 10% probability (`random.nextInt(10) == 0` in [`AdService.java#L205`](../../opentelemetry-demo/src/ad/src/main/java/oteldemo/AdService.java#L205)).",
+        "source_file": "src/frontend/pages/api/data.ts",
+        "source_line": 15,
+        "calling_service": "frontend",
+        "call_pattern": "Single direct call: AdProvider.useQuery ([`Ad.provider.tsx#L30`](../../opentelemetry-demo/src/frontend/providers/Ad.provider.tsx#L30)) → ApiGateway.listAds ([`Api.gateway.ts#L103`](../../opentelemetry-demo/src/frontend/gateways/Api.gateway.ts#L103)) → [`data.ts#L15`](../../opentelemetry-demo/src/frontend/pages/api/data.ts#L15) → AdGateway.listAds → gRPC client.getAds ([`Ad.gateway.ts#L14`](../../opentelemetry-demo/src/frontend/gateways/rpc/Ad.gateway.ts#L14)).",
+        "cause": "The [`data.ts#L15`](../../opentelemetry-demo/src/frontend/pages/api/data.ts#L15) API route calls `AdGateway.listAds` with no try-catch. When adFailure is on and the 1/10 random gate fires, the ad service throws `StatusRuntimeException(Status.UNAVAILABLE)` at [`AdService.java#L206`](../../opentelemetry-demo/src/ad/src/main/java/oteldemo/AdService.java#L206). The gRPC error rejects the promise in [`Ad.gateway.ts#L14`](../../opentelemetry-demo/src/frontend/gateways/rpc/Ad.gateway.ts#L14), propagates to [`InstrumentationMiddleware.ts#L23`](../../opentelemetry-demo/src/frontend/utils/telemetry/InstrumentationMiddleware.ts#L23) which records the exception on the span and re-throws, and Next.js returns HTTP 500. On the client side, React Query in [`Ad.provider.tsx#L30`](../../opentelemetry-demo/src/frontend/providers/Ad.provider.tsx#L30) catches the failure and defaults `adList` to `[]`. The Ad component ([`Ad.tsx#L10`](../../opentelemetry-demo/src/frontend/components/Ad/Ad.tsx#L10)) falls back to `{ text: '', redirectUrl: '' }`, rendering the styled yellow banner with empty content.",
+        "symptom_type": "visual_degradation"
+      }
+    ],
+    "traces": [
+      {
+        "name": "GetAds UNAVAILABLE Cascade",
+        "description": "Between 16:37:08 and 16:39:42 UTC, 2 traces show ad:oteldemo.AdService/GetAds failing with gRPC status 14 UNAVAILABLE and cascading through the frontend /api/data path. Both traces have root operation load-generator:user_get_ads. The failures land roughly 2.5 minutes apart, consistent with the load generator's user_get_ads cadence multiplied by the ~1/10 probabilistic failure rate.",
+        "cause": "Direct effect of the adFailure flag. When adFailure is on, AdService.java:205 throws StatusRuntimeException(Status.UNAVAILABLE) with 1/10 probability (random.nextInt(10) == 0). The exception is caught at AdService.java:218, logged as WARN at line 222, then surfaced to the gRPC client via responseObserver.onError(...). The error propagates through frontend's AdGateway to the Next.js /api/data route handler, which returns HTTP 500, and finally back out through the frontend-proxy Envoy to the load generator.",
+        "call_chain": "ad:oteldemo.AdService/GetAds → frontend:oteldemo.AdService/GetAds → frontend:executing api route (pages) /api/data → frontend:GET /api/data → frontend-proxy:router frontend egress → frontend-proxy:GET → load-generator:GET",
+        "smoking_gun": [
+          "ad:oteldemo.AdService/GetAds span: otel.status_code=ERROR, rpc.grpc.status_code=14, rpc.service=oteldemo.AdService, rpc.method=GetAds, and log event {event: \"Error\", exception.message: \"UNAVAILABLE\"} — no description, no stacktrace, matching the bare `throw new StatusRuntimeException(Status.UNAVAILABLE)` at AdService.java:206",
+          "ad:oteldemo.AdService/GetAds span attributes app.ads.count=1-2 and app.ads.ad_request_type=TARGETED with app.ads.contextKeys=[telescopes] or [books], set at AdService.java:195 before the flag check at line 205 — proves execution reached the flag-triggered throw with ads already prepared (rules out upstream failures in getAdsByCategory/getRandomAds)",
+          "ad:getAdsByCategory child span completes successfully with no errors — the failure is injected by the explicit flag-triggered throw in getAds, not by any downstream dependency",
+          "frontend:oteldemo.AdService/GetAds client span carries the received gRPC error as tag grpc.error_message=\"14 UNAVAILABLE: \" with rpc.grpc.status_code=14 (trailing colon with empty description, characteristic of the Java server not calling .withDescription(...))"
+        ],
+        "trace_documents": [
+          {
+            "traceID": "4a9c115c071f58e00205700b7ff2b852",
+            "@timestamp": "16:37:08",
+            "user_action": "user_get_ads"
+          },
+          {
+            "traceID": "bec127aafcab40a93d1d79411951afd7",
+            "@timestamp": "16:39:42",
+            "user_action": "user_get_ads"
+          }
+        ]
+      }
+    ]
+  }
+}

tasks/d1-c1-admanualgc-on-univ00-universal_ttd15m_at_off+10m/tests/test.sh

@@ -0,0 +1,19 @@
+#!/bin/bash
+set -euo pipefail
+
+set +e
+python /tests/check_prediction.py 2>&1 | tee /logs/verifier/log.txt
+status=${PIPESTATUS[0]}
+set -e
+
+# Preserve agent predictions even on verifier failure (Harbor deletes containers).
+if [[ -f /app/report.md ]]; then
+  mkdir -p /logs/verifier
+  cp /app/report.md /logs/verifier/report.md 2>/dev/null || true
+fi
+
+if [[ -f /app/task_meta.json ]]; then
+  cp /app/task_meta.json /logs/verifier/task_meta.json 2>/dev/null || true
+fi
+
+exit $status

tasks/d1-i1-imageslowload-on-02-medium_ttd60m_at_off+10m/environment/Dockerfile

@@ -0,0 +1 @@
+FROM ag2435/sre-otel-snapshot:{code_tag}

tasks/d1-i1-imageslowload-on-02-medium_ttd60m_at_off+10m/environment/docker-compose.yaml

@@ -0,0 +1,21 @@
+services:
+  main:
+    build:
+      context: ${CONTEXT_DIR}
+      pull: true
+    image: ${MAIN_IMAGE_NAME}
+    command: [ "sh", "-c", "sleep infinity" ]
+    privileged: true
+    environment:
+      - TEST_DIR=${TEST_DIR}
+      - CONTEXT_DIR=${CONTEXT_DIR}
+    volumes:
+      - /var/run/docker.sock:/var/run/docker.sock
+      - ${CONTEXT_DIR}:${CONTEXT_DIR}
+      - ${HOST_VERIFIER_LOGS_PATH}:${ENV_VERIFIER_LOGS_PATH}
+      - ${HOST_AGENT_LOGS_PATH}:${ENV_AGENT_LOGS_PATH}
+    deploy:
+      resources:
+        limits:
+          cpus: ${CPUS}
+          memory: ${MEMORY}

tasks/d1-i1-imageslowload-on-02-medium_ttd60m_at_off+10m/solution/check_prediction.py

@@ -0,0 +1,1005 @@
+"""LLM-as-a-judge verifier for Harbor incident-RCA-report tasks.
+
+Supports two modes:
+
+1. **Harbor verifier** (default):
+       python /tests/check_prediction.py
+
+2. **Post-hoc single-trial**:
+       python check_prediction.py --expected expected.json --predictions report.md [--rubric rubric.json]
+
+Falls back to string-match scoring when OPENAI_API_KEY is not set.
+"""
+
+import argparse
+import asyncio
+import json
+import logging
+import os
+import sys
+import traceback
+from pathlib import Path
+from typing import Any
+
+from tabulate import tabulate
+
+logger = logging.getLogger(__name__)
+
+JUDGE_PROMPT_MULTI_HEADER = """\
+You are an expert SRE tasked with judging the quality of an AI-generated incident RCA report.
+
+You are given:
+1. **One or more** ground-truth rubrics. Each describes a plausible root cause, its incident time, mechanism, and symptoms. Several flags may have been active in the same window; the agent is credited if it correctly identifies **any one** of these rubrics.
+2. The SRE agent's incident RCA report.
+
+## SRE Agent's Incident RCA Report
+
+{predictions}
+
+## Ground-Truth Rubrics
+
+{rubrics}
+
+## Evaluation Questions
+
+For **each rubric** in order, answer every question with true or false. Base your answer only on evidence in the agent's report; if the report does not cite the required evidence, answer false. The output must contain one entry per rubric, in the same order, and must preserve cluster order within each rubric exactly as listed.
+
+For each rubric:
+
+- `incident_time_within_10min`: Did the agent's timeline place the incident start within ±10 minutes of this rubric's `incident_time`?
+- `feature_flag_match`: Did the agent identify this rubric's feature flag as a root cause? (The agent may name multiple flags; mark true if this flag is among them.)
+- `mechanism_match`: Did the agent correctly explain this rubric's mechanism — how the flag propagates to the user-visible failure?
+- For each metric/log/trace cluster listed for this rubric: per-cluster match flags as before.
+"""
+
+JUDGE_PROMPT_SCORING_FOOTER = """\
+
+## Overall Score
+
+Score the incident RCA report on a scale of 0 to 3. The agent is credited if it correctly identifies **any one** of the listed rubrics — score against the rubric the agent's report best matches. Scoring is based on content correctness only; do not penalize or reward for formatting, prose style, or structural polish. Materially incorrect or misleading claims count against the score: if the report would otherwise score N but also adds a materially wrong claim (e.g., invents an unrelated additional cause), drop to N-1 (floor at 0). A report that correctly identifies one root cause but introduces a misleading fabrication alongside it therefore scores 2, not 3. When applying this penalty, explicitly identify in your reasoning which specific claim is materially wrong — quote or paraphrase the offending text. Do not apply the penalty without naming the offending claim; missing detail or incomplete explanation does not qualify as a materially wrong claim. Naming several of the listed plausible root causes is **not** a materially wrong claim.
+
+- 0: AI findings are misaligned with every rubric's mechanism and completely miss the root cause
+- 1: AI verifies incident description — the report confirms symptoms described in the task prompt but does not investigate further
+- 2: AI makes correct progress beyond symptoms — the report identifies some of the ground-truth metrics, logs, or traces for at least one rubric and moves toward that root cause, but does not fully identify any single root cause
+- 3: AI nails at least one of the listed root causes — the report correctly identifies it, the mechanism, and the supporting signals
+
+Respond with ONLY a JSON object matching the provided output schema.
+"""
+
+DEFAULT_MODEL = "openai-gpt-5.4"
+
+
+# ---------------------------------------------------------------------------
+# Rubric rendering (JSON -> markdown)
+# ---------------------------------------------------------------------------
+
+
+def _format_log_clusters(clusters: list[dict], lines: list[str]) -> None:
+    """Render log clusters as markdown subsections."""
+    for cluster in clusters:
+        name = cluster.get("name", "Unknown")
+        count = cluster.get("count")
+        suffix = f" ({count} entries)" if count is not None else ""
+        lines.append(f"#### {name}{suffix}")
+        lines.append("")
+
+        description = cluster.get("description", "")
+        if description:
+            lines.append(description)
+            lines.append("")
+
+        cause = cluster.get("cause", "")
+        if cause:
+            lines.append(f"**Cause:** {cause}")
+            lines.append("")
+
+        source = cluster.get("source", "")
+        if source:
+            lines.append(f"**Source:** {source}")
+            lines.append("")
+
+        attrs = cluster.get("representative_attributes", {})
+        if attrs:
+            lines.append("**Representative attributes:**")
+            lines.append("")
+            rows = [[f"`{k}`", f"`{v}`"] for k, v in attrs.items()]
+            lines.append(tabulate(rows, headers=["Field", "Value"], tablefmt="github"))
+            lines.append("")
+
+        docs = cluster.get("log_documents", [])
+        if docs:
+            lines.append("**Log documents:**")
+            lines.append("")
+            rows = [
+                [f"`{d['_index']}`", f"`{d['_id']}`", d["@timestamp"]] for d in docs
+            ]
+            lines.append(
+                tabulate(
+                    rows, headers=["_index", "_id", "@timestamp"], tablefmt="github"
+                )
+            )
+            lines.append("")
+
+
+def _format_trace_clusters(clusters: list[dict], lines: list[str]) -> None:
+    """Render trace clusters as markdown subsections."""
+    for cluster in clusters:
+        name = cluster.get("name", "Unknown")
+        count = cluster.get("count")
+        suffix = f" ({count} traces)" if count is not None else ""
+        lines.append(f"#### {name}{suffix}")
+        lines.append("")
+
+        description = cluster.get("description", "")
+        if description:
+            lines.append(description)
+            lines.append("")
+
+        cause = cluster.get("cause", "")
+        if cause:
+            lines.append(f"**Cause:** {cause}")
+            lines.append("")
+
+        call_chain = cluster.get("call_chain", "")
+        if call_chain:
+            lines.append("**Call chain:**")
+            lines.append("")
+            lines.append("```")
+            lines.append(call_chain)
+            lines.append("```")
+            lines.append("")
+
+        smoking_gun = cluster.get("smoking_gun", [])
+        if smoking_gun:
+            lines.append("**Smoking-gun error messages:**")
+            lines.append("")
+            for msg in smoking_gun:
+                lines.append(f"- {msg}")
+            lines.append("")
+
+        docs = cluster.get("trace_documents", [])
+        if docs:
+            lines.append("**Trace documents:**")
+            lines.append("")
+            headers = ["traceID", "@timestamp"]
+            has_action = any("user_action" in d for d in docs)
+            if has_action:
+                headers.append("user_action")
+            rows = []
+            for d in docs:
+                row = [f"`{d['traceID']}`", d["@timestamp"]]
+                if has_action:
+                    row.append(d.get("user_action", ""))
+                rows.append(row)
+            lines.append(tabulate(rows, headers=headers, tablefmt="github"))
+            lines.append("")
+
+
+_LAYER_DESCRIPTIONS = {
+    "root_cause": "metric closest to the fault injection point",
+    "propagation": "intermediate services reflecting the error through the call chain",
+    "symptom": "user-facing impact visible to end users or clients",
+    "meta": "feature flag counters or internal plumbing",
+    "unknown": "unclassified",
+}
+
+_LAYER_ORDER = ["root_cause", "propagation", "symptom", "meta", "unknown"]
+
+
+def _format_onset(offset: int | None) -> str:
+    """Format an onset offset as '+Xs' or 'N/A'."""
+    if offset is None:
+        return "N/A"
+    return f"+{offset}s"
+
+
+def _format_label_values(labels: dict[str, str]) -> str:
+    """Format label values as a compact comma-separated string."""
+    if not labels:
+        return ""
+    return ", ".join(labels.values())
+
+
+def _earliest_onset(variants: list[dict]) -> int | None:
+    """Return the earliest onset_offset_seconds across variants, or None."""
+    offsets = [
+        v["onset_offset_seconds"]
+        for v in variants
+        if v.get("onset_offset_seconds") is not None
+    ]
+    return min(offsets) if offsets else None
+
+
+def _format_metrics_list(metrics_list: list[dict], lines: list[str]) -> None:
+    """Render metric families grouped by signal layer."""
+    by_layer: dict[str, list[dict]] = {}
+    for fam in metrics_list:
+        by_layer.setdefault(fam.get("signal_layer", "unknown"), []).append(fam)
+
+    for layer in _LAYER_ORDER:
+        layer_families = by_layer.get(layer, [])
+        if not layer_families:
+            continue
+
+        layer_onsets = [_earliest_onset(f["variants"]) for f in layer_families]
+        layer_onsets = [o for o in layer_onsets if o is not None]
+        layer_onset_str = (
+            f" (earliest onset: {_format_onset(min(layer_onsets))})"
+            if layer_onsets
+            else ""
+        )
+
+        display_layer = layer.replace("_", " ").title()
+        desc = _LAYER_DESCRIPTIONS.get(layer, "")
+        lines.append(f"**{display_layer}** — {desc}{layer_onset_str}")
+        lines.append("")
+
+        for fam in layer_families:
+            fam_onset = _earliest_onset(fam["variants"])
+            label_vals = _format_label_values(fam.get("defining_labels", {}))
+            label_part = f" ({label_vals})" if label_vals else ""
+            lines.append(
+                f"#### {fam['metric_family']} family{label_part}"
+                f" — onset: {_format_onset(fam_onset)}"
+            )
+            lines.append("")
+
+            first_desc = (
+                fam["variants"][0].get("description", "") if fam["variants"] else ""
+            )
+            if first_desc:
+                lines.append(first_desc)
+                lines.append("")
+
+            for v in fam["variants"]:
+                v_onset = _format_onset(v.get("onset_offset_seconds"))
+                lines.append(f"- **{v['type']}** (onset: {v_onset})")
+                lines.append(f"  `{v['query']}`")
+                lines.append("")
+
+
+def _format_frontend_issues(issues: list[dict], lines: list[str]) -> None:
+    """Render frontend issues as markdown subsections."""
+    for issue in issues:
+        route = issue.get("route", "Unknown route")
+        lines.append(f"#### {route}")
+        lines.append("")
+
+        description = issue.get("description", "")
+        if description:
+            lines.append(description)
+            lines.append("")
+
+        rows = [
+            ["Deterministic", str(issue.get("deterministic", ""))],
+            ["Trigger condition", issue.get("trigger_condition", "")],
+            ["Calling service", issue.get("calling_service", "")],
+            [
+                "Source",
+                f"`{issue.get('source_file', '')}:{issue.get('source_line', '')}`",
+            ],
+        ]
+        lines.append(tabulate(rows, headers=["Field", "Value"], tablefmt="github"))
+        lines.append("")
+
+        call_pattern = issue.get("call_pattern", "")
+        if call_pattern:
+            lines.append(f"**Call pattern:** {call_pattern}")
+            lines.append("")
+
+        cause = issue.get("cause", "")
+        if cause:
+            lines.append(f"**Cause:** {cause}")
+            lines.append("")
+
+
+def format_rubric(data: dict, include_frontend: bool = False) -> str:
+    """Convert a rubric JSON dict into a consistently formatted markdown string.
+
+    Args:
+        data: The rubric JSON dict.
+        include_frontend: If True, include the ``### Frontend`` section.
+            Defaults to False since frontend symptoms may be noisy for
+            downstream consumers (LLM judge, oracle solutions).
+            TODO(Albert): systematically test the impact of including vs.
+            excluding frontend symptoms on downstream consumers.
+
+    """
+    lines: list[str] = []
+
+    lines.append(f"# {data['feature_flag']}")
+    lines.append("")
+    lines.append(f"**Feature flag:** `{data['feature_flag']}`")
+    lines.append("")
+    lines.append(f"**Description:** {data['description']}")
+    lines.append("")
+    lines.append(f"**Incident time:** {data['incident_time']}")
+    lines.append("")
+
+    lines.append("## Mechanism")
+    lines.append("")
+    lines.append(data["mechanism"])
+    lines.append("")
+
+    interaction = data.get("interaction", "")
+    if interaction:
+        lines.append(f"**Interaction with other feature flags:** {interaction}")
+        lines.append("")
+
+    lines.append("## Evidence")
+    lines.append("")
+
+    gs = data["symptoms"]
+
+    metrics = gs.get("metrics", [])
+    lines.append("### Metrics")
+    lines.append("")
+    if metrics:
+        _format_metrics_list(metrics, lines)
+
+    logs = gs.get("logs", [])
+    lines.append("### Logs")
+    lines.append("")
+    if logs:
+        _format_log_clusters(logs, lines)
+
+    if include_frontend:
+        frontend = gs.get("frontend", [])
+        lines.append("### Frontend")
+        lines.append("")
+        if frontend:
+            _format_frontend_issues(frontend, lines)
+
+    traces = gs.get("traces", [])
+    lines.append("### Traces")
+    lines.append("")
+    if traces:
+        _format_trace_clusters(traces, lines)
+
+    return "\n".join(lines)
+
+
+# ---------------------------------------------------------------------------
+# Judge prompt + output-schema builders
+# ---------------------------------------------------------------------------
+
+
+def _render_checklist(rubric_data: dict) -> str:
+    """Build per-cluster checklist blocks for metrics/logs/traces."""
+    symptoms = rubric_data.get("symptoms", {}) or {}
+    metric_clusters = symptoms.get("metrics", []) or []
+    log_clusters = symptoms.get("logs", []) or []
+    trace_clusters = symptoms.get("traces", []) or []
+
+    blocks: list[str] = []
+
+    if metric_clusters:
+        lines = ["#### Metric clusters"]
+        for i, m in enumerate(metric_clusters):
+            family = m.get("metric_family", "")
+            lines.append(
+                f'- Cluster {i}: `metric_family = "{family}"`'
+                f" — family_match: did the agent cite a query targeting"
+                f" metric_family `{family}` under a Why-step whose causal chain"
+                f" aligns with the rubric?"
+            )
+        blocks.append("\n".join(lines))
+
+    if log_clusters:
+        lines = ["#### Log clusters"]
+        for i, log in enumerate(log_clusters):
+            attrs = log.get("representative_attributes") or {}
+            body = attrs.get("body", "")
+            service_name = attrs.get("resource.service.name", "")
+            lines.append(
+                f"- Cluster {i}:\n"
+                f"  - `resource.service.name`: `{service_name}`\n"
+                f"  - `body`: `{body}`\n"
+                f"  - body_match: did the agent cite log evidence whose body"
+                f" matches the rubric's `body` under a Why-step whose causal"
+                f" chain aligns with the rubric?\n"
+                f"  - service_name_match: did the agent attribute the cited"
+                f" log evidence to the OTel service `{service_name}`"
+                f" (`resource.service.name`)?"
+            )
+        blocks.append("\n".join(lines))
+
+    if trace_clusters:
+        lines = ["#### Trace clusters"]
+        for i, trace in enumerate(trace_clusters):
+            call_chain = trace.get("call_chain", "")
+            smoking_gun = trace.get("smoking_gun", []) or []
+            sg_rendered = "\n".join(f"    - {s}" for s in smoking_gun)
+            lines.append(
+                f"- Cluster {i}:\n"
+                f"  - call_chain: `{call_chain}`\n"
+                f"  - smoking_gun:\n{sg_rendered}\n"
+                f"  - call_chain_match: did the agent cite evidence matching"
+                f" this service-level call chain under a Why-step whose causal"
+                f" chain aligns with the rubric?\n"
+                f"  - smoking_gun_match: did the agent cite at least one of"
+                f" the listed smoking-gun signals?"
+            )
+        blocks.append("\n".join(lines))
+
+    return (
+        "\n\n".join(blocks)
+        if blocks
+        else "(No metric, log, or trace clusters in rubric.)"
+    )
+
+
+def build_judge_prompt(
+    rubrics_data: list[dict],
+    predictions: str,
+) -> str:
+    """Render the judge prompt for one or more ground-truth rubrics.
+
+    The prompt asks the LLM to evaluate the agent's report against **each**
+    rubric independently. The agent is credited if it correctly identifies
+    any one rubric (the overall score reflects the best match).
+    """
+    if not rubrics_data:
+        raise ValueError("build_judge_prompt called with no rubrics")
+
+    rubric_blocks: list[str] = []
+    checklist_blocks: list[str] = []
+    for i, rubric in enumerate(rubrics_data):
+        feature_flag = rubric.get("feature_flag", "")
+        rubric_blocks.append(
+            f"### Rubric {i + 1} of {len(rubrics_data)} — `{feature_flag}`\n\n"
+            + format_rubric(rubric)
+        )
+        checklist_blocks.append(
+            f"### Rubric {i + 1} of {len(rubrics_data)} — `{feature_flag}`\n\n"
+            + _render_checklist(rubric)
+        )
+
+    rubrics_text = "\n\n---\n\n".join(rubric_blocks)
+    checklist_text = "\n\n---\n\n".join(checklist_blocks)
+
+    header = JUDGE_PROMPT_MULTI_HEADER.format(
+        rubrics=rubrics_text,
+        predictions=predictions,
+    )
+    return header + "\n" + checklist_text + "\n" + JUDGE_PROMPT_SCORING_FOOTER
+
+
+_METRIC_ITEM_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        "metric_family": {"type": "string"},
+        "family_match": {"type": "boolean"},
+    },
+    "required": ["metric_family", "family_match"],
+    "additionalProperties": False,
+}
+
+_LOG_ITEM_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        "body_match": {"type": "boolean"},
+        "service_name_match": {"type": "boolean"},
+    },
+    "required": ["body_match", "service_name_match"],
+    "additionalProperties": False,
+}
+
+_TRACE_ITEM_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        "call_chain_match": {"type": "boolean"},
+        "smoking_gun_match": {"type": "boolean"},
+    },
+    "required": ["call_chain_match", "smoking_gun_match"],
+    "additionalProperties": False,
+}
+
+
+_PER_RUBRIC_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        "feature_flag": {"type": "string"},
+        "incident_time_within_10min": {"type": "boolean"},
+        "feature_flag_match": {"type": "boolean"},
+        "mechanism_match": {"type": "boolean"},
+        "symptoms": {
+            "type": "object",
+            "properties": {
+                "metrics": {"type": "array", "items": _METRIC_ITEM_SCHEMA},
+                "logs": {"type": "array", "items": _LOG_ITEM_SCHEMA},
+                "traces": {"type": "array", "items": _TRACE_ITEM_SCHEMA},
+            },
+            "required": ["metrics", "logs", "traces"],
+            "additionalProperties": False,
+        },
+    },
+    "required": [
+        "feature_flag",
+        "incident_time_within_10min",
+        "feature_flag_match",
+        "mechanism_match",
+        "symptoms",
+    ],
+    "additionalProperties": False,
+}
+
+
+def build_judge_output_schema(rubrics_data: list[dict]) -> dict:
+    """Build a strict JSON Schema for the judge output: one verdict per rubric
+    + an overall ``score`` integer. Falls back to a minimal ``{score: int}``
+    schema when no rubrics are supplied (no-incident path).
+
+    Per-rubric cluster-array lengths vary across rubrics; rather than encode
+    a per-element schema (which Structured Outputs doesn't support), we leave
+    the array lengths unconstrained and rely on the prompt instructions to
+    keep cluster order matching.
+    """
+    if not rubrics_data:
+        return {
+            "type": "object",
+            "properties": {"score": {"type": "integer"}},
+            "required": ["score"],
+            "additionalProperties": False,
+        }
+
+    n = len(rubrics_data)
+    return {
+        "type": "object",
+        "properties": {
+            "rubrics": {
+                "type": "array",
+                "minItems": n,
+                "maxItems": n,
+                "items": _PER_RUBRIC_SCHEMA,
+            },
+            "score": {"type": "integer"},
+        },
+        "required": ["rubrics", "score"],
+        "additionalProperties": False,
+    }
+
+
+# ---------------------------------------------------------------------------
+# API call
+# ---------------------------------------------------------------------------
+
+
+async def async_call_llm_judge(
+    client: Any,
+    prompt: str,
+    model: str = DEFAULT_MODEL,
+    reasoning_effort: str | None = None,
+    output_schema: dict | None = None,
+) -> tuple[str, list[dict] | None]:
+    """Call the LLM judge via the OpenAI Responses API (falling back to Chat).
+
+    When ``output_schema`` is provided, uses Structured Outputs (strict JSON
+    Schema) so the returned text is guaranteed to conform to the schema.
+
+    Returns:
+        A tuple of (output_text, reasoning_summaries). reasoning_summaries is
+        None when reasoning_effort is not set.
+
+    """
+    text_format: dict[str, Any] = (
+        {
+            "type": "json_schema",
+            "name": "judge_response",
+            "schema": output_schema,
+            "strict": True,
+        }
+        if output_schema is not None
+        else {"type": "text"}
+    )
+    try:
+        kwargs: dict[str, Any] = {
+            "model": model,
+            "input": prompt,
+            "text": {"format": text_format},
+            "tools": [],
+            "store": True,
+            "max_output_tokens": 16384,
+        }
+        if reasoning_effort is not None:
+            kwargs["reasoning"] = {"effort": reasoning_effort, "summary": "auto"}
+        response = await client.responses.create(**kwargs)
+        reasoning_summaries = None
+        if reasoning_effort is not None:
+            reasoning_summaries = [
+                [
+                    s.model_dump() if hasattr(s, "model_dump") else s
+                    for s in item.summary
+                ]
+                for item in response.output
+                if getattr(item, "type", None) == "reasoning"
+                and getattr(item, "summary", None) is not None
+            ]
+        return response.output_text, reasoning_summaries
+    except Exception as exc:
+        if "404" not in str(exc):
+            raise
+        logger.info(
+            f"Responses API returned 404 for {model}, falling back to Chat Completions"
+        )
+        chat_kwargs: dict[str, Any] = {
+            "model": model,
+            "messages": [{"role": "user", "content": prompt}],
+            "max_tokens": 16384,
+        }
+        if output_schema is not None:
+            chat_kwargs["response_format"] = {
+                "type": "json_schema",
+                "json_schema": {
+                    "name": "judge_response",
+                    "schema": output_schema,
+                    "strict": True,
+                },
+            }
+        if reasoning_effort is not None:
+            chat_kwargs["reasoning_effort"] = reasoning_effort
+        response = await client.chat.completions.create(**chat_kwargs)
+        reasoning_summaries = None
+        if reasoning_effort is not None:
+            reasoning_content = getattr(
+                response.choices[0].message, "reasoning_content", None
+            )
+            if reasoning_content is not None:
+                reasoning_summaries = [{"type": "text", "text": reasoning_content}]
+            else:
+                reasoning_summaries = []
+        return response.choices[0].message.content, reasoning_summaries
+
+
+# ---------------------------------------------------------------------------
+# Parsing + aggregation
+# ---------------------------------------------------------------------------
+
+
+def parse_judge_response(response_text: str) -> dict:
+    """Parse the judge response JSON and range-check ``score``.
+
+    When Structured Outputs are used upstream, the response is already
+    schema-validated; this function only decodes the JSON and enforces the
+    0-3 range for ``score``.
+    """
+    parsed = json.loads(response_text)
+    score = int(parsed["score"])
+    if score < 0 or score > 3:
+        raise ValueError(f"Score {score} out of range [0, 3]")
+    parsed["score"] = score
+    return parsed
+
+
+def _aggregate_one_rubric(verdict: dict) -> dict:
+    """Roll up cluster verdicts for a single per-rubric judge entry."""
+    symptoms = verdict.get("symptoms", {}) or {}
+    metrics = symptoms.get("metrics", []) or []
+    logs = symptoms.get("logs", []) or []
+    traces = symptoms.get("traces", []) or []
+
+    metric_hits = [bool(m.get("family_match")) for m in metrics]
+    log_hits = [
+        bool(l.get("body_match")) and bool(l.get("service_name_match")) for l in logs
+    ]
+    trace_hits = [
+        bool(t.get("call_chain_match")) and bool(t.get("smoking_gun_match"))
+        for t in traces
+    ]
+
+    def _all(hits: list[bool]) -> bool | None:
+        return all(hits) if hits else None
+
+    def _any(hits: list[bool]) -> bool | None:
+        return any(hits) if hits else None
+
+    return {
+        "feature_flag": verdict.get("feature_flag", ""),
+        "incident_time_within_10min": bool(verdict.get("incident_time_within_10min")),
+        "feature_flag_match": bool(verdict.get("feature_flag_match")),
+        "mechanism_match": bool(verdict.get("mechanism_match")),
+        "metrics_all_match": _all(metric_hits),
+        "metrics_any_match": _any(metric_hits),
+        "logs_all_match": _all(log_hits),
+        "logs_any_match": _any(log_hits),
+        "traces_all_match": _all(trace_hits),
+        "traces_any_match": _any(trace_hits),
+    }
+
+
+def aggregate_judge_response(parsed: dict) -> dict:
+    """Aggregate per-rubric, per-cluster verdicts into flat any-of rollups.
+
+    The agent is credited if it matches any one of the listed rubrics.
+    Per-rubric rollups are computed via ``_aggregate_one_rubric``; the
+    task-level rollup is the ``any`` over rubrics for booleans (with ``None``
+    skipped — sections without clusters in any rubric stay ``None``).
+
+    The per-rubric rollups are also returned under ``per_rubric`` for
+    downstream analysis that needs to know which specific rubric matched.
+    """
+    rubrics = parsed.get("rubrics") or []
+    per_rubric = [_aggregate_one_rubric(r) for r in rubrics]
+
+    def _any_skip_none(values: list[bool | None]) -> bool | None:
+        truthy = [v for v in values if v is not None]
+        return any(truthy) if truthy else None
+
+    return {
+        "incident_time_within_10min": _any_skip_none(
+            [r["incident_time_within_10min"] for r in per_rubric]
+        )
+        or False,
+        "feature_flag_match": _any_skip_none(
+            [r["feature_flag_match"] for r in per_rubric]
+        )
+        or False,
+        "mechanism_match": _any_skip_none([r["mechanism_match"] for r in per_rubric])
+        or False,
+        "metrics_all_match": _any_skip_none(
+            [r["metrics_all_match"] for r in per_rubric]
+        ),
+        "metrics_any_match": _any_skip_none(
+            [r["metrics_any_match"] for r in per_rubric]
+        ),
+        "logs_all_match": _any_skip_none([r["logs_all_match"] for r in per_rubric]),
+        "logs_any_match": _any_skip_none([r["logs_any_match"] for r in per_rubric]),
+        "traces_all_match": _any_skip_none([r["traces_all_match"] for r in per_rubric]),
+        "traces_any_match": _any_skip_none([r["traces_any_match"] for r in per_rubric]),
+        "per_rubric": per_rubric,
+        "score": int(parsed["score"]),
+    }
+
+
+def string_match_fallback(expected: dict, predictions: str) -> dict:
+    """Fall back to case-insensitive string search for any plausible root_cause.
+
+    ``expected["events"]`` is a list of ``{"root_cause": <flag>, "event_time": ...}``;
+    the agent's report is credited if any listed root_cause appears in it.
+    Returns a result dict compatible with the judge output format.
+    """
+    events: list[dict] = expected.get("events") or []
+    if not events:
+        # No-incident task: agent should write an empty report.
+        return {"score": 3 if len(predictions.strip()) == 0 else 0}
+    text = predictions.lower()
+    found = any(e["root_cause"].strip().lower() in text for e in events)
+    return {"score": 3 if found else 0}
+
+
+# ---------------------------------------------------------------------------
+# Judge entry point (used by both modes)
+# ---------------------------------------------------------------------------
+
+
+async def judge(
+    client: Any,
+    expected: dict,
+    predictions: str,
+    rubrics_data: list[dict],
+    model: str = DEFAULT_MODEL,
+    reasoning_effort: str | None = None,
+) -> dict:
+    """Run the LLM judge over one or more ground-truth rubrics, or
+    short-circuit for no-incident tasks.
+
+    Returns:
+        A dict with keys: reward, mode, score, and (for LLM judge) model,
+        nested (raw judge response), reasoning_summary, rubric_used,
+        judge_prompt, judge_response_raw. Per-section rollups are derived
+        post-hoc from ``nested`` by formatters via ``aggregate_judge_response``.
+
+    """
+    events: list[dict] = expected.get("events") or []
+    if not events:
+        score = 3 if len(predictions.strip()) == 0 else 0
+        return {
+            "reward": score / 3.0,
+            "mode": "no_incident",
+            "model": model,
+            "score": score,
+        }
+
+    # Short-circuit when the agent emitted an empty report despite an incident.
+    # No LLM call can rescue this; score is a guaranteed 0. We synthesize the
+    # nested response shape (per-rubric all False, matching cluster counts)
+    # so that ``aggregate_judge_response`` produces the expected all-False
+    # rollups at load time.
+    if not predictions.strip():
+        synthetic_per_rubric = []
+        for rubric in rubrics_data:
+            symptoms = rubric.get("symptoms", {}) or {}
+            synthetic_per_rubric.append(
+                {
+                    "feature_flag": rubric.get("feature_flag", ""),
+                    "incident_time_within_10min": False,
+                    "feature_flag_match": False,
+                    "mechanism_match": False,
+                    "symptoms": {
+                        "metrics": [
+                            {
+                                "metric_family": m.get("metric_family", ""),
+                                "family_match": False,
+                            }
+                            for m in (symptoms.get("metrics") or [])
+                        ],
+                        "logs": [
+                            {"body_match": False, "service_name_match": False}
+                            for _ in (symptoms.get("logs") or [])
+                        ],
+                        "traces": [
+                            {"call_chain_match": False, "smoking_gun_match": False}
+                            for _ in (symptoms.get("traces") or [])
+                        ],
+                    },
+                }
+            )
+        return {
+            "mode": "empty_report",
+            "model": model,
+            "score": 0,
+            "reward": 0.0,
+            "rubric_used": bool(rubrics_data),
+            "nested": {"rubrics": synthetic_per_rubric, "score": 0},
+        }
+
+    prompt = build_judge_prompt(rubrics_data, predictions)
+    output_schema = build_judge_output_schema(rubrics_data)
+
+    raw_response, reasoning_summary = await async_call_llm_judge(
+        client,
+        prompt,
+        model=model,
+        reasoning_effort=reasoning_effort,
+        output_schema=output_schema,
+    )
+    parsed = parse_judge_response(raw_response)
+
+    # Per-section rollups are NOT spread into the result — they're a pure
+    # post-hoc derivation from ``nested`` via ``aggregate_judge_response``,
+    # applied by the formatters at load time so schema changes don't require
+    # rewriting saved JSONs.
+    return {
+        "mode": "llm_judge",
+        "model": model,
+        "score": parsed["score"],
+        "reward": parsed["score"] / 3.0,
+        "reasoning_summary": reasoning_summary,
+        "rubric_used": bool(rubrics_data),
+        "judge_prompt": prompt,
+        "judge_response_raw": raw_response,
+        "nested": parsed,
+    }
+
+
+# ---------------------------------------------------------------------------
+# CLI
+# ---------------------------------------------------------------------------
+
+
+async def main() -> None:
+    """Entry point: load expected + predictions, score, write reward/details."""
+    parser = argparse.ArgumentParser(
+        description="LLM-as-a-judge verifier for Harbor incident-RCA-report tasks."
+    )
+    parser.add_argument("--expected", type=str, default="/tests/expected.json")
+    parser.add_argument("--predictions", type=str, default="/app/report.md")
+    parser.add_argument(
+        "--rubrics-dir",
+        type=str,
+        default="/tests/rubrics",
+        help=(
+            "Directory containing one rubric JSON per plausible root cause "
+            "(e.g. /tests/rubrics/<event_id>.json). The judge scores the "
+            "agent against any one of them."
+        ),
+    )
+    parser.add_argument(
+        "--model", type=str, default=DEFAULT_MODEL, help="Judge LLM model name."
+    )
+    parser.add_argument(
+        "--effort",
+        type=str,
+        choices=["low", "medium", "high"],
+        default="high",
+        help="Reasoning effort level for the judge LLM (default: high).",
+    )
+    parser.add_argument(
+        "--mode",
+        type=str,
+        choices=["string_match", "llm_judge"],
+        default="string_match",
+        help="Scoring mode: string_match or llm_judge (default: string_match).",
+    )
+    parser.add_argument("--reward", type=str, default="/logs/verifier/reward.txt")
+    parser.add_argument("--details", type=str, default="/logs/verifier/details.json")
+    args = parser.parse_args()
+
+    expected_path = Path(args.expected)
+    predictions_path = Path(args.predictions)
+    rubrics_dir = Path(args.rubrics_dir)
+    reward_path = Path(args.reward)
+    details_path = Path(args.details)
+
+    try:
+        # Load expected
+        print(f"Loading expected results from {expected_path}...")
+        with expected_path.open() as f:
+            expected = json.load(f)
+
+        # Load predictions (markdown report)
+        print(f"Loading predictions from {predictions_path}...")
+        predictions = predictions_path.read_text()
+
+        # Load rubric JSONs — one per plausible root cause. Order is the
+        # filesystem sort order, which matches the build_harbor_tasks.py
+        # naming convention (event_id stems sort lexicographically).
+        rubrics_data: list[dict] = []
+        if expected.get("events"):
+            if rubrics_dir.is_dir():
+                rubric_paths = sorted(rubrics_dir.glob("*.json"))
+                for p in rubric_paths:
+                    with p.open() as f:
+                        rubrics_data.append(json.load(f))
+                print(f"Loaded {len(rubrics_data)} rubric(s) from {rubrics_dir}")
+            else:
+                print(f"Rubric directory missing: {rubrics_dir}")
+        else:
+            print("No incident events in expected results; skipping rubric load.")
+
+        # Run judge
+        if args.mode == "string_match":
+            em = string_match_fallback(expected, predictions)
+            result = {"reward": em["score"] / 3.0, "mode": "string_match", **em}
+        else:
+            from openai import AsyncOpenAI
+
+            client = AsyncOpenAI(
+                api_key=os.getenv("OPENAI_API_KEY"),
+                base_url=os.getenv("OPENAI_BASE_URL"),
+            )
+            result = await judge(
+                client,
+                expected,
+                predictions,
+                rubrics_data,
+                model=args.model,
+                reasoning_effort=args.effort,
+            )
+
+        # Write reward
+        reward_path.parent.mkdir(parents=True, exist_ok=True)
+        reward_path.write_text(str(result["reward"]))
+
+        # Write details
+        details_path.parent.mkdir(parents=True, exist_ok=True)
+        details_path.write_text(json.dumps(result, indent=2))
+
+        print(f"Score: {result.get('score', 'N/A')}/3 (reward: {result['reward']})")
+        print(f"Mode: {result['mode']}")
+        if result.get("reasoning_summary"):
+            print(f"Reasoning summary: {result['reasoning_summary']}")
+
+        if result["reward"] < 1.0:
+            sys.exit(1)
+
+    except Exception as exc:
+        reward_path.parent.mkdir(parents=True, exist_ok=True)
+        reward_path.write_text("0.0")
+        details_path.parent.mkdir(parents=True, exist_ok=True)
+        details_path.write_text(
+            json.dumps(
+                {
+                    "reward": 0.0,
+                    "error": f"{type(exc).__name__}: {exc}",
+                    "traceback": traceback.format_exc(),
+                },
+                indent=2,
+            )
+        )
+        print(f"Verifier error: {type(exc).__name__}: {exc}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

tasks/d1-i1-imageslowload-on-02-medium_ttd60m_at_off+10m/solution/rubric.json

@@ -0,0 +1,24 @@
+{
+  "incident_time": "2026-04-19T14:01:51.404464+00:00",
+  "feature_flag": "imageSlowLoad",
+  "description": "A feature flag in the frontend `ProductCard` React component added an `x-envoy-fault-delay-request` header (plus `Cache-Control: no-cache`) to every product-image fetch; Envoy honored the fault-injection header and artificially delayed each `GET /images/products/<picture>` response, so product thumbnails took seconds to render.",
+  "mechanism": "The flag is read in [`ProductCard.tsx#L32`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L32): the `ProductCard` React component calls `useNumberFlagValue('imageSlowLoad', 0)` to get the delay value in milliseconds (variants: `0` for off, `5000` for 5 sec, `10000` for 10 sec). When non-zero, the component sets the `x-envoy-fault-delay-request` header to the flag value on every product image fetch ([`ProductCard.tsx#L37`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L37)).\n\nThe image request is sent to `/images/products/<picture>`, which the frontend-proxy Envoy routes to the `image-provider` cluster ([`envoy.tmpl.yaml#L54-L55`](../../opentelemetry-demo/src/frontend-proxy/envoy.tmpl.yaml#L54)). Envoy's `envoy.filters.http.fault` filter is configured with `header_delay: {}` and 100% percentage ([`envoy.tmpl.yaml#L67-L74`](../../opentelemetry-demo/src/frontend-proxy/envoy.tmpl.yaml#L67)), meaning it honors the `x-envoy-fault-delay-request` header and injects the specified delay (in ms) before forwarding the request. Every product card image load is therefore delayed by the flag value (e.g. 5 or 10 seconds), causing the page to render with blank/loading images until the delayed responses arrive.",
+  "symptoms": {
+    "metrics": [],
+    "logs": [],
+    "frontend": [
+      {
+        "description": "Product card thumbnails on the homepage product grid (and the recommendations carousel on product/cart/checkout pages) render with a blank image placeholder for ~5 seconds before the actual thumbnail appears. The page text and layout render immediately; only the images are delayed. Affects every product card on every page load while the flag is on — the failure is silent slowness, not a visible error.",
+        "route": "GET /images/products/<picture>",
+        "deterministic": true,
+        "trigger_condition": "Every page load that renders a `ProductCard` component — homepage product grid (`/`), recommendations carousel on product detail (`/product/<id>`), cart, and checkout pages.",
+        "source_file": "src/frontend/components/ProductCard/ProductCard.tsx",
+        "source_line": 37,
+        "calling_service": "frontend",
+        "call_pattern": "ProductCard.useEffect ([`ProductCard.tsx#L34`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L34)) → fetch(`/images/products/<picture>`) with header `x-envoy-fault-delay-request: 5000` ([`ProductCard.tsx#L37`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L37)) → frontend-proxy Envoy → image-provider.",
+        "cause": "`useNumberFlagValue('imageSlowLoad', 0)` returns 5000 (the `5sec` variant value, [`demo.flagd.json` `imageSlowLoad.variants.5sec`](../../opentelemetry-demo/src/flagd/demo.flagd.json)). ProductCard sets `x-envoy-fault-delay-request: 5000` on every image fetch ([`ProductCard.tsx#L37`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L37)). The frontend-proxy `envoy.filters.http.fault` filter ([`envoy.tmpl.yaml#L67`](../../opentelemetry-demo/src/frontend-proxy/envoy.tmpl.yaml#L67)) honors this header and delays each image response by 5000ms before forwarding to image-provider, so each `<S.Image>` only resolves after that delay."
+      }
+    ],
+    "traces": []
+  }
+}

tasks/d1-i1-imageslowload-on-02-medium_ttd60m_at_off+10m/solution/rubrics/d1-i1-imageSlowLoad-on.json

@@ -0,0 +1,24 @@
+{
+  "incident_time": "2026-04-19T14:01:51.404464+00:00",
+  "feature_flag": "imageSlowLoad",
+  "description": "A feature flag in the frontend `ProductCard` React component added an `x-envoy-fault-delay-request` header (plus `Cache-Control: no-cache`) to every product-image fetch; Envoy honored the fault-injection header and artificially delayed each `GET /images/products/<picture>` response, so product thumbnails took seconds to render.",
+  "mechanism": "The flag is read in [`ProductCard.tsx#L32`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L32): the `ProductCard` React component calls `useNumberFlagValue('imageSlowLoad', 0)` to get the delay value in milliseconds (variants: `0` for off, `5000` for 5 sec, `10000` for 10 sec). When non-zero, the component sets the `x-envoy-fault-delay-request` header to the flag value on every product image fetch ([`ProductCard.tsx#L37`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L37)).\n\nThe image request is sent to `/images/products/<picture>`, which the frontend-proxy Envoy routes to the `image-provider` cluster ([`envoy.tmpl.yaml#L54-L55`](../../opentelemetry-demo/src/frontend-proxy/envoy.tmpl.yaml#L54)). Envoy's `envoy.filters.http.fault` filter is configured with `header_delay: {}` and 100% percentage ([`envoy.tmpl.yaml#L67-L74`](../../opentelemetry-demo/src/frontend-proxy/envoy.tmpl.yaml#L67)), meaning it honors the `x-envoy-fault-delay-request` header and injects the specified delay (in ms) before forwarding the request. Every product card image load is therefore delayed by the flag value (e.g. 5 or 10 seconds), causing the page to render with blank/loading images until the delayed responses arrive.",
+  "symptoms": {
+    "metrics": [],
+    "logs": [],
+    "frontend": [
+      {
+        "description": "Product card thumbnails on the homepage product grid (and the recommendations carousel on product/cart/checkout pages) render with a blank image placeholder for ~5 seconds before the actual thumbnail appears. The page text and layout render immediately; only the images are delayed. Affects every product card on every page load while the flag is on — the failure is silent slowness, not a visible error.",
+        "route": "GET /images/products/<picture>",
+        "deterministic": true,
+        "trigger_condition": "Every page load that renders a `ProductCard` component — homepage product grid (`/`), recommendations carousel on product detail (`/product/<id>`), cart, and checkout pages.",
+        "source_file": "src/frontend/components/ProductCard/ProductCard.tsx",
+        "source_line": 37,
+        "calling_service": "frontend",
+        "call_pattern": "ProductCard.useEffect ([`ProductCard.tsx#L34`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L34)) → fetch(`/images/products/<picture>`) with header `x-envoy-fault-delay-request: 5000` ([`ProductCard.tsx#L37`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L37)) → frontend-proxy Envoy → image-provider.",
+        "cause": "`useNumberFlagValue('imageSlowLoad', 0)` returns 5000 (the `5sec` variant value, [`demo.flagd.json` `imageSlowLoad.variants.5sec`](../../opentelemetry-demo/src/flagd/demo.flagd.json)). ProductCard sets `x-envoy-fault-delay-request: 5000` on every image fetch ([`ProductCard.tsx#L37`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L37)). The frontend-proxy `envoy.filters.http.fault` filter ([`envoy.tmpl.yaml#L67`](../../opentelemetry-demo/src/frontend-proxy/envoy.tmpl.yaml#L67)) honors this header and delays each image response by 5000ms before forwarding to image-provider, so each `<S.Image>` only resolves after that delay."
+      }
+    ],
+    "traces": []
+  }
+}

tasks/d1-i1-imageslowload-on-02-medium_ttd60m_at_off+10m/solution/solve.py

@@ -0,0 +1,298 @@
+#!/usr/bin/env python3
+"""Generate an incident report from a rubric JSON via LLM.
+
+Standalone script designed to run inside a Harbor task container.
+Also importable by ``run_solve.py`` for local batch generation.
+
+Examples::
+
+    # Inside Harbor container (solve.sh calls this):
+    python solve.py --rubric /tests/rubric.json --output /app/report.md
+
+    # With custom model/effort:
+    python solve.py --rubric /tests/rubric.json --output /app/report.md -m openai-gpt-5.4 -e high
+"""
+
+import argparse
+import asyncio
+import json
+import logging
+import os
+from pathlib import Path
+from typing import Any
+
+from check_prediction import async_call_llm_judge, format_rubric
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_MODEL: str | None = None
+DEFAULT_EFFORT = "high"
+
+# Report format from harbor-template/instruction.md.template — sections 1-4.
+REPORT_FORMAT = """\
+Write a structured incident report with four sections: Summary, Timeline, \
+5 Whys, and Remediation. Follow all section-specific rules below.
+
+---
+
+## Section 1: Summary
+
+2-3 sentences describing what happened, when, and the high-level impact. \
+This should be understandable by someone unfamiliar with the system. Focus \
+on what DID happen and the observable impact — mention request failures if \
+they occurred, but do NOT mention the absence of failures or errors as this \
+can be misread and cause confusion. You may name the root cause in a single \
+phrase (e.g. "due to a misconfigured batch job") but do not explain the \
+causal chain — that belongs in the 5 Whys section.
+
+Example: "Between 13:00 and 13:11 UTC on April 2, the order service returned \
+503 errors for 14% of checkout requests, affecting paying users, due to a \
+Redis cache eviction. The full causal chain is detailed in the 5 Whys section \
+below."
+
+---
+
+## Section 2: Timeline
+
+A chronological narrative of ONLY what went wrong, reconstructed from the \
+provided telemetry. Each entry should be a single succinct line. Cover \
+higher-level events — when a change was introduced, when symptoms started, \
+when a change was reverted, when symptoms subsided — not individual error \
+occurrences. The first entry should be the earliest anomaly visible in the \
+provided telemetry; this establishes the incident start time referenced by \
+the Summary and 5 Whys sections.
+
+For each entry:
+- State the time (UTC), the service(s) involved, and what happened
+- Quantify where possible (error rate, duration, number of affected requests)
+- Do NOT include normal/healthy behavior, baseline noise, or things that \
+worked correctly
+
+Example format:
+```
+09:44 UTC — analytics-job deployed with no memory limit set
+14:17 UTC — redis-cache-0 OOMKilled; node memory at 97%
+14:18 UTC — inventory-svc cache misses begin; all requests fall through to Postgres
+14:18 UTC — order-svc goroutine pool exhaustion begins; 503 error rate climbs to 14%
+14:29 UTC — redis-cache-0 rescheduled; error rate returns to baseline
+```
+
+---
+
+## Section 3: 5 Whys
+
+Rules:
+1. Start by stating the problem as a precise, observable symptom — not a \
+cause. Include what failed, when, and impact (error rate, affected users, \
+duration).
+2. Each "why" answer must be grounded in the provided telemetry. Cite only \
+the telemetry types relevant to that step, using the format below for each.
+
+   - Metrics: one sentence describing the baseline value (or typical range), \
+what it changed to, and at what UTC timestamp. Where relevant, include rate \
+of change or duration. Follow with the exact PromQL query that would surface it.
+     Example — "Error rate on order-svc was 0.1% at 14:17 UTC, jumping to \
+14% at 14:18 UTC. PromQL: rate(http_requests_total{service="order-svc",\
+status=~"5.."}[1m])"
+
+   - Traces: the cascade from the highest-level operation down to the deepest \
+failing span, followed by representative trace IDs from the provided data.
+     Example — "checkout request → order-svc goroutine exhaustion → \
+inventory-svc Redis GET timeout. Trace IDs: 4bf92f3577b34da6, a3ce929d0e0e4736"
+
+   - Logs: one sentence with service, endpoint, error, and time range, \
+followed by the exact Lucene query that would retrieve the relevant log lines.
+     Example — "Between 14:18:02 and 14:29:11 UTC, POST /api/checkout \
+returned 503s. Lucene: service:order-svc AND status:503 AND \
+endpoint:\\"/api/checkout\\""
+3. Each "why" targets the previous answer, not the original problem. Drill \
+down one causal chain; do not branch.
+4. Never accept "human error" or "operator mistake" as a terminal answer. \
+Ask why the human was in a position to make that error.
+5. Stop when you reach a cause that is: (a) actionable — something a team \
+can change, or (b) a process or system gap that allowed the failure to \
+propagate. The number of steps is not fixed at 5.
+6. Only include steps that are directly supported by the provided telemetry. \
+If the causal chain cannot be completed with the available evidence, stop \
+and note what additional telemetry would be needed to continue.
+7. After the chain, note any branches you did NOT follow. If the incident \
+has multiple contributing causes that cannot fit a single chain, say so \
+explicitly rather than forcing one.
+
+Output format:
+
+```
+Problem statement:
+[Observable symptom with time, impact, and detection method]
+
+Why 1: [question] → [answer]
+Evidence: [specific signal]
+
+Why 2: [question] → [answer]
+Evidence: [specific signal]
+
+...
+
+Root cause:
+[Single sentence naming the systemic or process failure]
+
+Unexplored branches:
+[Contributing factors visible in telemetry that were not followed, \
+and why they were set aside]
+```
+
+---
+
+## Section 4: Remediation
+
+For each corrective action, identify which step in the causal chain it \
+targets and what class of fix it is:
+
+- **Root cause fix**: eliminates the condition that started the chain
+- **Propagation fix**: limits blast radius if the root cause recurs
+- **Detection fix**: reduces time-to-detect or time-to-mitigate
+
+List actions from root cause outward. Prefer fixes that prevent recurrence \
+over fixes that only improve response.
+
+Output format:
+
+| Action | Targets | Type |
+|--------|---------|------|
+| [What to do] | Why N | Root cause fix / Propagation fix / Detection fix |
+"""
+
+SOLUTION_PROMPT_TEMPLATE = """\
+You are an expert site reliability engineer. You are given a ground-truth \
+rubric describing an incident's root cause, mechanism, and telemetry evidence.
+
+Your task: write an incident report as if you investigated this incident \
+yourself. Use the rubric evidence to populate each section. Do NOT mention \
+the rubric or that you were given ground-truth data — write as though you \
+discovered everything through telemetry analysis.
+
+## Ground-Truth Rubric
+
+{rubric}
+
+## Report Format
+
+{report_format}
+"""
+
+
+def build_solution_prompt(rubric_md: str) -> str:
+    """Build the LLM prompt from a formatted rubric markdown string."""
+    return SOLUTION_PROMPT_TEMPLATE.format(
+        rubric=rubric_md,
+        report_format=REPORT_FORMAT,
+    )
+
+
+async def generate_report(
+    client: Any,
+    rubric_data: dict,
+    model: str | None = DEFAULT_MODEL,
+    effort: str | None = DEFAULT_EFFORT,
+) -> tuple[str, str, list[dict] | None]:
+    """Generate an incident report from rubric JSON.
+
+    If ``model`` is ``None``, the formatted rubric is returned directly with
+    no LLM call. Otherwise the rubric is passed to the LLM to be reformatted
+    into an incident report.
+
+    Returns:
+        A tuple of (report_text, prompt, reasoning_summary). When ``model``
+        is ``None``, ``prompt`` is empty and ``reasoning_summary`` is ``None``.
+
+    """
+    rubric_md = format_rubric(rubric_data)
+    if model is None:
+        return rubric_md, "", None
+    prompt = build_solution_prompt(rubric_md)
+    response_text, reasoning_summary = await async_call_llm_judge(
+        client, prompt, model=model, reasoning_effort=effort
+    )
+    return response_text, prompt, reasoning_summary
+
+
+async def async_main() -> None:
+    """CLI entry point: read rubric, call LLM, write report."""
+    parser = argparse.ArgumentParser(
+        description="Generate an incident report from a rubric JSON via LLM."
+    )
+    parser.add_argument(
+        "--rubric",
+        type=str,
+        default="/tests/rubric.json",
+        help="Path to rubric JSON file.",
+    )
+    parser.add_argument(
+        "--output",
+        type=str,
+        default="/app/report.md",
+        help="Path to write the generated report.",
+    )
+    parser.add_argument(
+        "--model",
+        "-m",
+        type=str,
+        default=DEFAULT_MODEL,
+        help=(
+            "LLM model name. If omitted, the formatted rubric is written "
+            "directly as the report with no LLM call."
+        ),
+    )
+    parser.add_argument(
+        "--effort",
+        "-e",
+        type=str,
+        choices=["low", "medium", "high"],
+        default=DEFAULT_EFFORT,
+        help=f"Reasoning effort level (default: {DEFAULT_EFFORT}).",
+    )
+    args = parser.parse_args()
+
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s - %(levelname)s - %(message)s",
+    )
+
+    rubric_path = Path(args.rubric)
+    output_path = Path(args.output)
+
+    if not rubric_path.is_file():
+        logger.warning(f"Rubric file not found: {rubric_path}; writing empty report")
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        output_path.write_text("")
+        return
+
+    rubric_data = json.loads(rubric_path.read_text())
+    logger.info(
+        f"Loaded rubric: {rubric_data.get('feature_flag', 'unknown')} "
+        f"from {rubric_path}"
+    )
+
+    client: Any = None
+    if args.model is not None:
+        from openai import AsyncOpenAI
+
+        client = AsyncOpenAI(
+            api_key=os.getenv("OPENAI_API_KEY"),
+            base_url=os.getenv("OPENAI_BASE_URL"),
+        )
+
+    report_text, _prompt, reasoning_summary = await generate_report(
+        client, rubric_data, model=args.model, effort=args.effort
+    )
+
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    output_path.write_text(report_text)
+    logger.info(f"Wrote report to {output_path}")
+
+    if reasoning_summary:
+        logger.info(f"Reasoning summary: {reasoning_summary}")
+
+
+if __name__ == "__main__":
+    asyncio.run(async_main())

tasks/d1-i1-imageslowload-on-02-medium_ttd60m_at_off+10m/solution/solve.sh

@@ -0,0 +1,28 @@
+#!/bin/bash
+set -euo pipefail
+
+# ── Wait for the entrypoint to finish setting up the environment ──
+echo "[solve] Waiting for environment to be ready..."
+for i in $(seq 1 180); do
+    [ -f /tmp/env-ready ] && break
+    sleep 1
+done
+if [ ! -f /tmp/env-ready ]; then
+    echo "[solve] ERROR: Environment did not become ready within 180s" >&2
+    exit 1
+fi
+echo "[solve] Environment is ready."
+
+# ── Verify all services are healthy ──
+echo "[solve] Running health checks..."
+source /tmp/env-ports
+/app/check_health.sh || {
+    echo "[solve] ERROR: Health checks failed" >&2
+    exit 1
+}
+
+# ── Generate solution report via LLM ──
+echo "[solve] Installing dependencies..."
+pip install tabulate
+echo "[solve] Generating report..."
+python /solution/solve.py --rubric /solution/rubric.json

tasks/d1-i1-imageslowload-on-02-medium_ttd60m_at_off+10m/tests/check_prediction.py

@@ -0,0 +1,1005 @@
+"""LLM-as-a-judge verifier for Harbor incident-RCA-report tasks.
+
+Supports two modes:
+
+1. **Harbor verifier** (default):
+       python /tests/check_prediction.py
+
+2. **Post-hoc single-trial**:
+       python check_prediction.py --expected expected.json --predictions report.md [--rubric rubric.json]
+
+Falls back to string-match scoring when OPENAI_API_KEY is not set.
+"""
+
+import argparse
+import asyncio
+import json
+import logging
+import os
+import sys
+import traceback
+from pathlib import Path
+from typing import Any
+
+from tabulate import tabulate
+
+logger = logging.getLogger(__name__)
+
+JUDGE_PROMPT_MULTI_HEADER = """\
+You are an expert SRE tasked with judging the quality of an AI-generated incident RCA report.
+
+You are given:
+1. **One or more** ground-truth rubrics. Each describes a plausible root cause, its incident time, mechanism, and symptoms. Several flags may have been active in the same window; the agent is credited if it correctly identifies **any one** of these rubrics.
+2. The SRE agent's incident RCA report.
+
+## SRE Agent's Incident RCA Report
+
+{predictions}
+
+## Ground-Truth Rubrics
+
+{rubrics}
+
+## Evaluation Questions
+
+For **each rubric** in order, answer every question with true or false. Base your answer only on evidence in the agent's report; if the report does not cite the required evidence, answer false. The output must contain one entry per rubric, in the same order, and must preserve cluster order within each rubric exactly as listed.
+
+For each rubric:
+
+- `incident_time_within_10min`: Did the agent's timeline place the incident start within ±10 minutes of this rubric's `incident_time`?
+- `feature_flag_match`: Did the agent identify this rubric's feature flag as a root cause? (The agent may name multiple flags; mark true if this flag is among them.)
+- `mechanism_match`: Did the agent correctly explain this rubric's mechanism — how the flag propagates to the user-visible failure?
+- For each metric/log/trace cluster listed for this rubric: per-cluster match flags as before.
+"""
+
+JUDGE_PROMPT_SCORING_FOOTER = """\
+
+## Overall Score
+
+Score the incident RCA report on a scale of 0 to 3. The agent is credited if it correctly identifies **any one** of the listed rubrics — score against the rubric the agent's report best matches. Scoring is based on content correctness only; do not penalize or reward for formatting, prose style, or structural polish. Materially incorrect or misleading claims count against the score: if the report would otherwise score N but also adds a materially wrong claim (e.g., invents an unrelated additional cause), drop to N-1 (floor at 0). A report that correctly identifies one root cause but introduces a misleading fabrication alongside it therefore scores 2, not 3. When applying this penalty, explicitly identify in your reasoning which specific claim is materially wrong — quote or paraphrase the offending text. Do not apply the penalty without naming the offending claim; missing detail or incomplete explanation does not qualify as a materially wrong claim. Naming several of the listed plausible root causes is **not** a materially wrong claim.
+
+- 0: AI findings are misaligned with every rubric's mechanism and completely miss the root cause
+- 1: AI verifies incident description — the report confirms symptoms described in the task prompt but does not investigate further
+- 2: AI makes correct progress beyond symptoms — the report identifies some of the ground-truth metrics, logs, or traces for at least one rubric and moves toward that root cause, but does not fully identify any single root cause
+- 3: AI nails at least one of the listed root causes — the report correctly identifies it, the mechanism, and the supporting signals
+
+Respond with ONLY a JSON object matching the provided output schema.
+"""
+
+DEFAULT_MODEL = "openai-gpt-5.4"
+
+
+# ---------------------------------------------------------------------------
+# Rubric rendering (JSON -> markdown)
+# ---------------------------------------------------------------------------
+
+
+def _format_log_clusters(clusters: list[dict], lines: list[str]) -> None:
+    """Render log clusters as markdown subsections."""
+    for cluster in clusters:
+        name = cluster.get("name", "Unknown")
+        count = cluster.get("count")
+        suffix = f" ({count} entries)" if count is not None else ""
+        lines.append(f"#### {name}{suffix}")
+        lines.append("")
+
+        description = cluster.get("description", "")
+        if description:
+            lines.append(description)
+            lines.append("")
+
+        cause = cluster.get("cause", "")
+        if cause:
+            lines.append(f"**Cause:** {cause}")
+            lines.append("")
+
+        source = cluster.get("source", "")
+        if source:
+            lines.append(f"**Source:** {source}")
+            lines.append("")
+
+        attrs = cluster.get("representative_attributes", {})
+        if attrs:
+            lines.append("**Representative attributes:**")
+            lines.append("")
+            rows = [[f"`{k}`", f"`{v}`"] for k, v in attrs.items()]
+            lines.append(tabulate(rows, headers=["Field", "Value"], tablefmt="github"))
+            lines.append("")
+
+        docs = cluster.get("log_documents", [])
+        if docs:
+            lines.append("**Log documents:**")
+            lines.append("")
+            rows = [
+                [f"`{d['_index']}`", f"`{d['_id']}`", d["@timestamp"]] for d in docs
+            ]
+            lines.append(
+                tabulate(
+                    rows, headers=["_index", "_id", "@timestamp"], tablefmt="github"
+                )
+            )
+            lines.append("")
+
+
+def _format_trace_clusters(clusters: list[dict], lines: list[str]) -> None:
+    """Render trace clusters as markdown subsections."""
+    for cluster in clusters:
+        name = cluster.get("name", "Unknown")
+        count = cluster.get("count")
+        suffix = f" ({count} traces)" if count is not None else ""
+        lines.append(f"#### {name}{suffix}")
+        lines.append("")
+
+        description = cluster.get("description", "")
+        if description:
+            lines.append(description)
+            lines.append("")
+
+        cause = cluster.get("cause", "")
+        if cause:
+            lines.append(f"**Cause:** {cause}")
+            lines.append("")
+
+        call_chain = cluster.get("call_chain", "")
+        if call_chain:
+            lines.append("**Call chain:**")
+            lines.append("")
+            lines.append("```")
+            lines.append(call_chain)
+            lines.append("```")
+            lines.append("")
+
+        smoking_gun = cluster.get("smoking_gun", [])
+        if smoking_gun:
+            lines.append("**Smoking-gun error messages:**")
+            lines.append("")
+            for msg in smoking_gun:
+                lines.append(f"- {msg}")
+            lines.append("")
+
+        docs = cluster.get("trace_documents", [])
+        if docs:
+            lines.append("**Trace documents:**")
+            lines.append("")
+            headers = ["traceID", "@timestamp"]
+            has_action = any("user_action" in d for d in docs)
+            if has_action:
+                headers.append("user_action")
+            rows = []
+            for d in docs:
+                row = [f"`{d['traceID']}`", d["@timestamp"]]
+                if has_action:
+                    row.append(d.get("user_action", ""))
+                rows.append(row)
+            lines.append(tabulate(rows, headers=headers, tablefmt="github"))
+            lines.append("")
+
+
+_LAYER_DESCRIPTIONS = {
+    "root_cause": "metric closest to the fault injection point",
+    "propagation": "intermediate services reflecting the error through the call chain",
+    "symptom": "user-facing impact visible to end users or clients",
+    "meta": "feature flag counters or internal plumbing",
+    "unknown": "unclassified",
+}
+
+_LAYER_ORDER = ["root_cause", "propagation", "symptom", "meta", "unknown"]
+
+
+def _format_onset(offset: int | None) -> str:
+    """Format an onset offset as '+Xs' or 'N/A'."""
+    if offset is None:
+        return "N/A"
+    return f"+{offset}s"
+
+
+def _format_label_values(labels: dict[str, str]) -> str:
+    """Format label values as a compact comma-separated string."""
+    if not labels:
+        return ""
+    return ", ".join(labels.values())
+
+
+def _earliest_onset(variants: list[dict]) -> int | None:
+    """Return the earliest onset_offset_seconds across variants, or None."""
+    offsets = [
+        v["onset_offset_seconds"]
+        for v in variants
+        if v.get("onset_offset_seconds") is not None
+    ]
+    return min(offsets) if offsets else None
+
+
+def _format_metrics_list(metrics_list: list[dict], lines: list[str]) -> None:
+    """Render metric families grouped by signal layer."""
+    by_layer: dict[str, list[dict]] = {}
+    for fam in metrics_list:
+        by_layer.setdefault(fam.get("signal_layer", "unknown"), []).append(fam)
+
+    for layer in _LAYER_ORDER:
+        layer_families = by_layer.get(layer, [])
+        if not layer_families:
+            continue
+
+        layer_onsets = [_earliest_onset(f["variants"]) for f in layer_families]
+        layer_onsets = [o for o in layer_onsets if o is not None]
+        layer_onset_str = (
+            f" (earliest onset: {_format_onset(min(layer_onsets))})"
+            if layer_onsets
+            else ""
+        )
+
+        display_layer = layer.replace("_", " ").title()
+        desc = _LAYER_DESCRIPTIONS.get(layer, "")
+        lines.append(f"**{display_layer}** — {desc}{layer_onset_str}")
+        lines.append("")
+
+        for fam in layer_families:
+            fam_onset = _earliest_onset(fam["variants"])
+            label_vals = _format_label_values(fam.get("defining_labels", {}))
+            label_part = f" ({label_vals})" if label_vals else ""
+            lines.append(
+                f"#### {fam['metric_family']} family{label_part}"
+                f" — onset: {_format_onset(fam_onset)}"
+            )
+            lines.append("")
+
+            first_desc = (
+                fam["variants"][0].get("description", "") if fam["variants"] else ""
+            )
+            if first_desc:
+                lines.append(first_desc)
+                lines.append("")
+
+            for v in fam["variants"]:
+                v_onset = _format_onset(v.get("onset_offset_seconds"))
+                lines.append(f"- **{v['type']}** (onset: {v_onset})")
+                lines.append(f"  `{v['query']}`")
+                lines.append("")
+
+
+def _format_frontend_issues(issues: list[dict], lines: list[str]) -> None:
+    """Render frontend issues as markdown subsections."""
+    for issue in issues:
+        route = issue.get("route", "Unknown route")
+        lines.append(f"#### {route}")
+        lines.append("")
+
+        description = issue.get("description", "")
+        if description:
+            lines.append(description)
+            lines.append("")
+
+        rows = [
+            ["Deterministic", str(issue.get("deterministic", ""))],
+            ["Trigger condition", issue.get("trigger_condition", "")],
+            ["Calling service", issue.get("calling_service", "")],
+            [
+                "Source",
+                f"`{issue.get('source_file', '')}:{issue.get('source_line', '')}`",
+            ],
+        ]
+        lines.append(tabulate(rows, headers=["Field", "Value"], tablefmt="github"))
+        lines.append("")
+
+        call_pattern = issue.get("call_pattern", "")
+        if call_pattern:
+            lines.append(f"**Call pattern:** {call_pattern}")
+            lines.append("")
+
+        cause = issue.get("cause", "")
+        if cause:
+            lines.append(f"**Cause:** {cause}")
+            lines.append("")
+
+
+def format_rubric(data: dict, include_frontend: bool = False) -> str:
+    """Convert a rubric JSON dict into a consistently formatted markdown string.
+
+    Args:
+        data: The rubric JSON dict.
+        include_frontend: If True, include the ``### Frontend`` section.
+            Defaults to False since frontend symptoms may be noisy for
+            downstream consumers (LLM judge, oracle solutions).
+            TODO(Albert): systematically test the impact of including vs.
+            excluding frontend symptoms on downstream consumers.
+
+    """
+    lines: list[str] = []
+
+    lines.append(f"# {data['feature_flag']}")
+    lines.append("")
+    lines.append(f"**Feature flag:** `{data['feature_flag']}`")
+    lines.append("")
+    lines.append(f"**Description:** {data['description']}")
+    lines.append("")
+    lines.append(f"**Incident time:** {data['incident_time']}")
+    lines.append("")
+
+    lines.append("## Mechanism")
+    lines.append("")
+    lines.append(data["mechanism"])
+    lines.append("")
+
+    interaction = data.get("interaction", "")
+    if interaction:
+        lines.append(f"**Interaction with other feature flags:** {interaction}")
+        lines.append("")
+
+    lines.append("## Evidence")
+    lines.append("")
+
+    gs = data["symptoms"]
+
+    metrics = gs.get("metrics", [])
+    lines.append("### Metrics")
+    lines.append("")
+    if metrics:
+        _format_metrics_list(metrics, lines)
+
+    logs = gs.get("logs", [])
+    lines.append("### Logs")
+    lines.append("")
+    if logs:
+        _format_log_clusters(logs, lines)
+
+    if include_frontend:
+        frontend = gs.get("frontend", [])
+        lines.append("### Frontend")
+        lines.append("")
+        if frontend:
+            _format_frontend_issues(frontend, lines)
+
+    traces = gs.get("traces", [])
+    lines.append("### Traces")
+    lines.append("")
+    if traces:
+        _format_trace_clusters(traces, lines)
+
+    return "\n".join(lines)
+
+
+# ---------------------------------------------------------------------------
+# Judge prompt + output-schema builders
+# ---------------------------------------------------------------------------
+
+
+def _render_checklist(rubric_data: dict) -> str:
+    """Build per-cluster checklist blocks for metrics/logs/traces."""
+    symptoms = rubric_data.get("symptoms", {}) or {}
+    metric_clusters = symptoms.get("metrics", []) or []
+    log_clusters = symptoms.get("logs", []) or []
+    trace_clusters = symptoms.get("traces", []) or []
+
+    blocks: list[str] = []
+
+    if metric_clusters:
+        lines = ["#### Metric clusters"]
+        for i, m in enumerate(metric_clusters):
+            family = m.get("metric_family", "")
+            lines.append(
+                f'- Cluster {i}: `metric_family = "{family}"`'
+                f" — family_match: did the agent cite a query targeting"
+                f" metric_family `{family}` under a Why-step whose causal chain"
+                f" aligns with the rubric?"
+            )
+        blocks.append("\n".join(lines))
+
+    if log_clusters:
+        lines = ["#### Log clusters"]
+        for i, log in enumerate(log_clusters):
+            attrs = log.get("representative_attributes") or {}
+            body = attrs.get("body", "")
+            service_name = attrs.get("resource.service.name", "")
+            lines.append(
+                f"- Cluster {i}:\n"
+                f"  - `resource.service.name`: `{service_name}`\n"
+                f"  - `body`: `{body}`\n"
+                f"  - body_match: did the agent cite log evidence whose body"
+                f" matches the rubric's `body` under a Why-step whose causal"
+                f" chain aligns with the rubric?\n"
+                f"  - service_name_match: did the agent attribute the cited"
+                f" log evidence to the OTel service `{service_name}`"
+                f" (`resource.service.name`)?"
+            )
+        blocks.append("\n".join(lines))
+
+    if trace_clusters:
+        lines = ["#### Trace clusters"]
+        for i, trace in enumerate(trace_clusters):
+            call_chain = trace.get("call_chain", "")
+            smoking_gun = trace.get("smoking_gun", []) or []
+            sg_rendered = "\n".join(f"    - {s}" for s in smoking_gun)
+            lines.append(
+                f"- Cluster {i}:\n"
+                f"  - call_chain: `{call_chain}`\n"
+                f"  - smoking_gun:\n{sg_rendered}\n"
+                f"  - call_chain_match: did the agent cite evidence matching"
+                f" this service-level call chain under a Why-step whose causal"
+                f" chain aligns with the rubric?\n"
+                f"  - smoking_gun_match: did the agent cite at least one of"
+                f" the listed smoking-gun signals?"
+            )
+        blocks.append("\n".join(lines))
+
+    return (
+        "\n\n".join(blocks)
+        if blocks
+        else "(No metric, log, or trace clusters in rubric.)"
+    )
+
+
+def build_judge_prompt(
+    rubrics_data: list[dict],
+    predictions: str,
+) -> str:
+    """Render the judge prompt for one or more ground-truth rubrics.
+
+    The prompt asks the LLM to evaluate the agent's report against **each**
+    rubric independently. The agent is credited if it correctly identifies
+    any one rubric (the overall score reflects the best match).
+    """
+    if not rubrics_data:
+        raise ValueError("build_judge_prompt called with no rubrics")
+
+    rubric_blocks: list[str] = []
+    checklist_blocks: list[str] = []
+    for i, rubric in enumerate(rubrics_data):
+        feature_flag = rubric.get("feature_flag", "")
+        rubric_blocks.append(
+            f"### Rubric {i + 1} of {len(rubrics_data)} — `{feature_flag}`\n\n"
+            + format_rubric(rubric)
+        )
+        checklist_blocks.append(
+            f"### Rubric {i + 1} of {len(rubrics_data)} — `{feature_flag}`\n\n"
+            + _render_checklist(rubric)
+        )
+
+    rubrics_text = "\n\n---\n\n".join(rubric_blocks)
+    checklist_text = "\n\n---\n\n".join(checklist_blocks)
+
+    header = JUDGE_PROMPT_MULTI_HEADER.format(
+        rubrics=rubrics_text,
+        predictions=predictions,
+    )
+    return header + "\n" + checklist_text + "\n" + JUDGE_PROMPT_SCORING_FOOTER
+
+
+_METRIC_ITEM_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        "metric_family": {"type": "string"},
+        "family_match": {"type": "boolean"},
+    },
+    "required": ["metric_family", "family_match"],
+    "additionalProperties": False,
+}
+
+_LOG_ITEM_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        "body_match": {"type": "boolean"},
+        "service_name_match": {"type": "boolean"},
+    },
+    "required": ["body_match", "service_name_match"],
+    "additionalProperties": False,
+}
+
+_TRACE_ITEM_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        "call_chain_match": {"type": "boolean"},
+        "smoking_gun_match": {"type": "boolean"},
+    },
+    "required": ["call_chain_match", "smoking_gun_match"],
+    "additionalProperties": False,
+}
+
+
+_PER_RUBRIC_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        "feature_flag": {"type": "string"},
+        "incident_time_within_10min": {"type": "boolean"},
+        "feature_flag_match": {"type": "boolean"},
+        "mechanism_match": {"type": "boolean"},
+        "symptoms": {
+            "type": "object",
+            "properties": {
+                "metrics": {"type": "array", "items": _METRIC_ITEM_SCHEMA},
+                "logs": {"type": "array", "items": _LOG_ITEM_SCHEMA},
+                "traces": {"type": "array", "items": _TRACE_ITEM_SCHEMA},
+            },
+            "required": ["metrics", "logs", "traces"],
+            "additionalProperties": False,
+        },
+    },
+    "required": [
+        "feature_flag",
+        "incident_time_within_10min",
+        "feature_flag_match",
+        "mechanism_match",
+        "symptoms",
+    ],
+    "additionalProperties": False,
+}
+
+
+def build_judge_output_schema(rubrics_data: list[dict]) -> dict:
+    """Build a strict JSON Schema for the judge output: one verdict per rubric
+    + an overall ``score`` integer. Falls back to a minimal ``{score: int}``
+    schema when no rubrics are supplied (no-incident path).
+
+    Per-rubric cluster-array lengths vary across rubrics; rather than encode
+    a per-element schema (which Structured Outputs doesn't support), we leave
+    the array lengths unconstrained and rely on the prompt instructions to
+    keep cluster order matching.
+    """
+    if not rubrics_data:
+        return {
+            "type": "object",
+            "properties": {"score": {"type": "integer"}},
+            "required": ["score"],
+            "additionalProperties": False,
+        }
+
+    n = len(rubrics_data)
+    return {
+        "type": "object",
+        "properties": {
+            "rubrics": {
+                "type": "array",
+                "minItems": n,
+                "maxItems": n,
+                "items": _PER_RUBRIC_SCHEMA,
+            },
+            "score": {"type": "integer"},
+        },
+        "required": ["rubrics", "score"],
+        "additionalProperties": False,
+    }
+
+
+# ---------------------------------------------------------------------------
+# API call
+# ---------------------------------------------------------------------------
+
+
+async def async_call_llm_judge(
+    client: Any,
+    prompt: str,
+    model: str = DEFAULT_MODEL,
+    reasoning_effort: str | None = None,
+    output_schema: dict | None = None,
+) -> tuple[str, list[dict] | None]:
+    """Call the LLM judge via the OpenAI Responses API (falling back to Chat).
+
+    When ``output_schema`` is provided, uses Structured Outputs (strict JSON
+    Schema) so the returned text is guaranteed to conform to the schema.
+
+    Returns:
+        A tuple of (output_text, reasoning_summaries). reasoning_summaries is
+        None when reasoning_effort is not set.
+
+    """
+    text_format: dict[str, Any] = (
+        {
+            "type": "json_schema",
+            "name": "judge_response",
+            "schema": output_schema,
+            "strict": True,
+        }
+        if output_schema is not None
+        else {"type": "text"}
+    )
+    try:
+        kwargs: dict[str, Any] = {
+            "model": model,
+            "input": prompt,
+            "text": {"format": text_format},
+            "tools": [],
+            "store": True,
+            "max_output_tokens": 16384,
+        }
+        if reasoning_effort is not None:
+            kwargs["reasoning"] = {"effort": reasoning_effort, "summary": "auto"}
+        response = await client.responses.create(**kwargs)
+        reasoning_summaries = None
+        if reasoning_effort is not None:
+            reasoning_summaries = [
+                [
+                    s.model_dump() if hasattr(s, "model_dump") else s
+                    for s in item.summary
+                ]
+                for item in response.output
+                if getattr(item, "type", None) == "reasoning"
+                and getattr(item, "summary", None) is not None
+            ]
+        return response.output_text, reasoning_summaries
+    except Exception as exc:
+        if "404" not in str(exc):
+            raise
+        logger.info(
+            f"Responses API returned 404 for {model}, falling back to Chat Completions"
+        )
+        chat_kwargs: dict[str, Any] = {
+            "model": model,
+            "messages": [{"role": "user", "content": prompt}],
+            "max_tokens": 16384,
+        }
+        if output_schema is not None:
+            chat_kwargs["response_format"] = {
+                "type": "json_schema",
+                "json_schema": {
+                    "name": "judge_response",
+                    "schema": output_schema,
+                    "strict": True,
+                },
+            }
+        if reasoning_effort is not None:
+            chat_kwargs["reasoning_effort"] = reasoning_effort
+        response = await client.chat.completions.create(**chat_kwargs)
+        reasoning_summaries = None
+        if reasoning_effort is not None:
+            reasoning_content = getattr(
+                response.choices[0].message, "reasoning_content", None
+            )
+            if reasoning_content is not None:
+                reasoning_summaries = [{"type": "text", "text": reasoning_content}]
+            else:
+                reasoning_summaries = []
+        return response.choices[0].message.content, reasoning_summaries
+
+
+# ---------------------------------------------------------------------------
+# Parsing + aggregation
+# ---------------------------------------------------------------------------
+
+
+def parse_judge_response(response_text: str) -> dict:
+    """Parse the judge response JSON and range-check ``score``.
+
+    When Structured Outputs are used upstream, the response is already
+    schema-validated; this function only decodes the JSON and enforces the
+    0-3 range for ``score``.
+    """
+    parsed = json.loads(response_text)
+    score = int(parsed["score"])
+    if score < 0 or score > 3:
+        raise ValueError(f"Score {score} out of range [0, 3]")
+    parsed["score"] = score
+    return parsed
+
+
+def _aggregate_one_rubric(verdict: dict) -> dict:
+    """Roll up cluster verdicts for a single per-rubric judge entry."""
+    symptoms = verdict.get("symptoms", {}) or {}
+    metrics = symptoms.get("metrics", []) or []
+    logs = symptoms.get("logs", []) or []
+    traces = symptoms.get("traces", []) or []
+
+    metric_hits = [bool(m.get("family_match")) for m in metrics]
+    log_hits = [
+        bool(l.get("body_match")) and bool(l.get("service_name_match")) for l in logs
+    ]
+    trace_hits = [
+        bool(t.get("call_chain_match")) and bool(t.get("smoking_gun_match"))
+        for t in traces
+    ]
+
+    def _all(hits: list[bool]) -> bool | None:
+        return all(hits) if hits else None
+
+    def _any(hits: list[bool]) -> bool | None:
+        return any(hits) if hits else None
+
+    return {
+        "feature_flag": verdict.get("feature_flag", ""),
+        "incident_time_within_10min": bool(verdict.get("incident_time_within_10min")),
+        "feature_flag_match": bool(verdict.get("feature_flag_match")),
+        "mechanism_match": bool(verdict.get("mechanism_match")),
+        "metrics_all_match": _all(metric_hits),
+        "metrics_any_match": _any(metric_hits),
+        "logs_all_match": _all(log_hits),
+        "logs_any_match": _any(log_hits),
+        "traces_all_match": _all(trace_hits),
+        "traces_any_match": _any(trace_hits),
+    }
+
+
+def aggregate_judge_response(parsed: dict) -> dict:
+    """Aggregate per-rubric, per-cluster verdicts into flat any-of rollups.
+
+    The agent is credited if it matches any one of the listed rubrics.
+    Per-rubric rollups are computed via ``_aggregate_one_rubric``; the
+    task-level rollup is the ``any`` over rubrics for booleans (with ``None``
+    skipped — sections without clusters in any rubric stay ``None``).
+
+    The per-rubric rollups are also returned under ``per_rubric`` for
+    downstream analysis that needs to know which specific rubric matched.
+    """
+    rubrics = parsed.get("rubrics") or []
+    per_rubric = [_aggregate_one_rubric(r) for r in rubrics]
+
+    def _any_skip_none(values: list[bool | None]) -> bool | None:
+        truthy = [v for v in values if v is not None]
+        return any(truthy) if truthy else None
+
+    return {
+        "incident_time_within_10min": _any_skip_none(
+            [r["incident_time_within_10min"] for r in per_rubric]
+        )
+        or False,
+        "feature_flag_match": _any_skip_none(
+            [r["feature_flag_match"] for r in per_rubric]
+        )
+        or False,
+        "mechanism_match": _any_skip_none([r["mechanism_match"] for r in per_rubric])
+        or False,
+        "metrics_all_match": _any_skip_none(
+            [r["metrics_all_match"] for r in per_rubric]
+        ),
+        "metrics_any_match": _any_skip_none(
+            [r["metrics_any_match"] for r in per_rubric]
+        ),
+        "logs_all_match": _any_skip_none([r["logs_all_match"] for r in per_rubric]),
+        "logs_any_match": _any_skip_none([r["logs_any_match"] for r in per_rubric]),
+        "traces_all_match": _any_skip_none([r["traces_all_match"] for r in per_rubric]),
+        "traces_any_match": _any_skip_none([r["traces_any_match"] for r in per_rubric]),
+        "per_rubric": per_rubric,
+        "score": int(parsed["score"]),
+    }
+
+
+def string_match_fallback(expected: dict, predictions: str) -> dict:
+    """Fall back to case-insensitive string search for any plausible root_cause.
+
+    ``expected["events"]`` is a list of ``{"root_cause": <flag>, "event_time": ...}``;
+    the agent's report is credited if any listed root_cause appears in it.
+    Returns a result dict compatible with the judge output format.
+    """
+    events: list[dict] = expected.get("events") or []
+    if not events:
+        # No-incident task: agent should write an empty report.
+        return {"score": 3 if len(predictions.strip()) == 0 else 0}
+    text = predictions.lower()
+    found = any(e["root_cause"].strip().lower() in text for e in events)
+    return {"score": 3 if found else 0}
+
+
+# ---------------------------------------------------------------------------
+# Judge entry point (used by both modes)
+# ---------------------------------------------------------------------------
+
+
+async def judge(
+    client: Any,
+    expected: dict,
+    predictions: str,
+    rubrics_data: list[dict],
+    model: str = DEFAULT_MODEL,
+    reasoning_effort: str | None = None,
+) -> dict:
+    """Run the LLM judge over one or more ground-truth rubrics, or
+    short-circuit for no-incident tasks.
+
+    Returns:
+        A dict with keys: reward, mode, score, and (for LLM judge) model,
+        nested (raw judge response), reasoning_summary, rubric_used,
+        judge_prompt, judge_response_raw. Per-section rollups are derived
+        post-hoc from ``nested`` by formatters via ``aggregate_judge_response``.
+
+    """
+    events: list[dict] = expected.get("events") or []
+    if not events:
+        score = 3 if len(predictions.strip()) == 0 else 0
+        return {
+            "reward": score / 3.0,
+            "mode": "no_incident",
+            "model": model,
+            "score": score,
+        }
+
+    # Short-circuit when the agent emitted an empty report despite an incident.
+    # No LLM call can rescue this; score is a guaranteed 0. We synthesize the
+    # nested response shape (per-rubric all False, matching cluster counts)
+    # so that ``aggregate_judge_response`` produces the expected all-False
+    # rollups at load time.
+    if not predictions.strip():
+        synthetic_per_rubric = []
+        for rubric in rubrics_data:
+            symptoms = rubric.get("symptoms", {}) or {}
+            synthetic_per_rubric.append(
+                {
+                    "feature_flag": rubric.get("feature_flag", ""),
+                    "incident_time_within_10min": False,
+                    "feature_flag_match": False,
+                    "mechanism_match": False,
+                    "symptoms": {
+                        "metrics": [
+                            {
+                                "metric_family": m.get("metric_family", ""),
+                                "family_match": False,
+                            }
+                            for m in (symptoms.get("metrics") or [])
+                        ],
+                        "logs": [
+                            {"body_match": False, "service_name_match": False}
+                            for _ in (symptoms.get("logs") or [])
+                        ],
+                        "traces": [
+                            {"call_chain_match": False, "smoking_gun_match": False}
+                            for _ in (symptoms.get("traces") or [])
+                        ],
+                    },
+                }
+            )
+        return {
+            "mode": "empty_report",
+            "model": model,
+            "score": 0,
+            "reward": 0.0,
+            "rubric_used": bool(rubrics_data),
+            "nested": {"rubrics": synthetic_per_rubric, "score": 0},
+        }
+
+    prompt = build_judge_prompt(rubrics_data, predictions)
+    output_schema = build_judge_output_schema(rubrics_data)
+
+    raw_response, reasoning_summary = await async_call_llm_judge(
+        client,
+        prompt,
+        model=model,
+        reasoning_effort=reasoning_effort,
+        output_schema=output_schema,
+    )
+    parsed = parse_judge_response(raw_response)
+
+    # Per-section rollups are NOT spread into the result — they're a pure
+    # post-hoc derivation from ``nested`` via ``aggregate_judge_response``,
+    # applied by the formatters at load time so schema changes don't require
+    # rewriting saved JSONs.
+    return {
+        "mode": "llm_judge",
+        "model": model,
+        "score": parsed["score"],
+        "reward": parsed["score"] / 3.0,
+        "reasoning_summary": reasoning_summary,
+        "rubric_used": bool(rubrics_data),
+        "judge_prompt": prompt,
+        "judge_response_raw": raw_response,
+        "nested": parsed,
+    }
+
+
+# ---------------------------------------------------------------------------
+# CLI
+# ---------------------------------------------------------------------------
+
+
+async def main() -> None:
+    """Entry point: load expected + predictions, score, write reward/details."""
+    parser = argparse.ArgumentParser(
+        description="LLM-as-a-judge verifier for Harbor incident-RCA-report tasks."
+    )
+    parser.add_argument("--expected", type=str, default="/tests/expected.json")
+    parser.add_argument("--predictions", type=str, default="/app/report.md")
+    parser.add_argument(
+        "--rubrics-dir",
+        type=str,
+        default="/tests/rubrics",
+        help=(
+            "Directory containing one rubric JSON per plausible root cause "
+            "(e.g. /tests/rubrics/<event_id>.json). The judge scores the "
+            "agent against any one of them."
+        ),
+    )
+    parser.add_argument(
+        "--model", type=str, default=DEFAULT_MODEL, help="Judge LLM model name."
+    )
+    parser.add_argument(
+        "--effort",
+        type=str,
+        choices=["low", "medium", "high"],
+        default="high",
+        help="Reasoning effort level for the judge LLM (default: high).",
+    )
+    parser.add_argument(
+        "--mode",
+        type=str,
+        choices=["string_match", "llm_judge"],
+        default="string_match",
+        help="Scoring mode: string_match or llm_judge (default: string_match).",
+    )
+    parser.add_argument("--reward", type=str, default="/logs/verifier/reward.txt")
+    parser.add_argument("--details", type=str, default="/logs/verifier/details.json")
+    args = parser.parse_args()
+
+    expected_path = Path(args.expected)
+    predictions_path = Path(args.predictions)
+    rubrics_dir = Path(args.rubrics_dir)
+    reward_path = Path(args.reward)
+    details_path = Path(args.details)
+
+    try:
+        # Load expected
+        print(f"Loading expected results from {expected_path}...")
+        with expected_path.open() as f:
+            expected = json.load(f)
+
+        # Load predictions (markdown report)
+        print(f"Loading predictions from {predictions_path}...")
+        predictions = predictions_path.read_text()
+
+        # Load rubric JSONs — one per plausible root cause. Order is the
+        # filesystem sort order, which matches the build_harbor_tasks.py
+        # naming convention (event_id stems sort lexicographically).
+        rubrics_data: list[dict] = []
+        if expected.get("events"):
+            if rubrics_dir.is_dir():
+                rubric_paths = sorted(rubrics_dir.glob("*.json"))
+                for p in rubric_paths:
+                    with p.open() as f:
+                        rubrics_data.append(json.load(f))
+                print(f"Loaded {len(rubrics_data)} rubric(s) from {rubrics_dir}")
+            else:
+                print(f"Rubric directory missing: {rubrics_dir}")
+        else:
+            print("No incident events in expected results; skipping rubric load.")
+
+        # Run judge
+        if args.mode == "string_match":
+            em = string_match_fallback(expected, predictions)
+            result = {"reward": em["score"] / 3.0, "mode": "string_match", **em}
+        else:
+            from openai import AsyncOpenAI
+
+            client = AsyncOpenAI(
+                api_key=os.getenv("OPENAI_API_KEY"),
+                base_url=os.getenv("OPENAI_BASE_URL"),
+            )
+            result = await judge(
+                client,
+                expected,
+                predictions,
+                rubrics_data,
+                model=args.model,
+                reasoning_effort=args.effort,
+            )
+
+        # Write reward
+        reward_path.parent.mkdir(parents=True, exist_ok=True)
+        reward_path.write_text(str(result["reward"]))
+
+        # Write details
+        details_path.parent.mkdir(parents=True, exist_ok=True)
+        details_path.write_text(json.dumps(result, indent=2))
+
+        print(f"Score: {result.get('score', 'N/A')}/3 (reward: {result['reward']})")
+        print(f"Mode: {result['mode']}")
+        if result.get("reasoning_summary"):
+            print(f"Reasoning summary: {result['reasoning_summary']}")
+
+        if result["reward"] < 1.0:
+            sys.exit(1)
+
+    except Exception as exc:
+        reward_path.parent.mkdir(parents=True, exist_ok=True)
+        reward_path.write_text("0.0")
+        details_path.parent.mkdir(parents=True, exist_ok=True)
+        details_path.write_text(
+            json.dumps(
+                {
+                    "reward": 0.0,
+                    "error": f"{type(exc).__name__}: {exc}",
+                    "traceback": traceback.format_exc(),
+                },
+                indent=2,
+            )
+        )
+        print(f"Verifier error: {type(exc).__name__}: {exc}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

tasks/d1-i1-imageslowload-on-02-medium_ttd60m_at_off+10m/tests/expected.json

@@ -0,0 +1,9 @@
+{
+  "events": [
+    {
+      "event_id": "d1-i1-imageSlowLoad-on",
+      "root_cause": "imageSlowLoad",
+      "event_time": "2026-04-19T14:01:51.404464+00:00"
+    }
+  ]
+}

tasks/d1-i1-imageslowload-on-02-medium_ttd60m_at_off+10m/tests/rubrics/d1-i1-imageSlowLoad-on.json

@@ -0,0 +1,24 @@
+{
+  "incident_time": "2026-04-19T14:01:51.404464+00:00",
+  "feature_flag": "imageSlowLoad",
+  "description": "A feature flag in the frontend `ProductCard` React component added an `x-envoy-fault-delay-request` header (plus `Cache-Control: no-cache`) to every product-image fetch; Envoy honored the fault-injection header and artificially delayed each `GET /images/products/<picture>` response, so product thumbnails took seconds to render.",
+  "mechanism": "The flag is read in [`ProductCard.tsx#L32`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L32): the `ProductCard` React component calls `useNumberFlagValue('imageSlowLoad', 0)` to get the delay value in milliseconds (variants: `0` for off, `5000` for 5 sec, `10000` for 10 sec). When non-zero, the component sets the `x-envoy-fault-delay-request` header to the flag value on every product image fetch ([`ProductCard.tsx#L37`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L37)).\n\nThe image request is sent to `/images/products/<picture>`, which the frontend-proxy Envoy routes to the `image-provider` cluster ([`envoy.tmpl.yaml#L54-L55`](../../opentelemetry-demo/src/frontend-proxy/envoy.tmpl.yaml#L54)). Envoy's `envoy.filters.http.fault` filter is configured with `header_delay: {}` and 100% percentage ([`envoy.tmpl.yaml#L67-L74`](../../opentelemetry-demo/src/frontend-proxy/envoy.tmpl.yaml#L67)), meaning it honors the `x-envoy-fault-delay-request` header and injects the specified delay (in ms) before forwarding the request. Every product card image load is therefore delayed by the flag value (e.g. 5 or 10 seconds), causing the page to render with blank/loading images until the delayed responses arrive.",
+  "symptoms": {
+    "metrics": [],
+    "logs": [],
+    "frontend": [
+      {
+        "description": "Product card thumbnails on the homepage product grid (and the recommendations carousel on product/cart/checkout pages) render with a blank image placeholder for ~5 seconds before the actual thumbnail appears. The page text and layout render immediately; only the images are delayed. Affects every product card on every page load while the flag is on — the failure is silent slowness, not a visible error.",
+        "route": "GET /images/products/<picture>",
+        "deterministic": true,
+        "trigger_condition": "Every page load that renders a `ProductCard` component — homepage product grid (`/`), recommendations carousel on product detail (`/product/<id>`), cart, and checkout pages.",
+        "source_file": "src/frontend/components/ProductCard/ProductCard.tsx",
+        "source_line": 37,
+        "calling_service": "frontend",
+        "call_pattern": "ProductCard.useEffect ([`ProductCard.tsx#L34`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L34)) → fetch(`/images/products/<picture>`) with header `x-envoy-fault-delay-request: 5000` ([`ProductCard.tsx#L37`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L37)) → frontend-proxy Envoy → image-provider.",
+        "cause": "`useNumberFlagValue('imageSlowLoad', 0)` returns 5000 (the `5sec` variant value, [`demo.flagd.json` `imageSlowLoad.variants.5sec`](../../opentelemetry-demo/src/flagd/demo.flagd.json)). ProductCard sets `x-envoy-fault-delay-request: 5000` on every image fetch ([`ProductCard.tsx#L37`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L37)). The frontend-proxy `envoy.filters.http.fault` filter ([`envoy.tmpl.yaml#L67`](../../opentelemetry-demo/src/frontend-proxy/envoy.tmpl.yaml#L67)) honors this header and delays each image response by 5000ms before forwarding to image-provider, so each `<S.Image>` only resolves after that delay."
+      }
+    ],
+    "traces": []
+  }
+}

tasks/d1-i1-imageslowload-on-02-medium_ttd60m_at_off+10m/tests/test.sh

@@ -0,0 +1,19 @@
+#!/bin/bash
+set -euo pipefail
+
+set +e
+python /tests/check_prediction.py 2>&1 | tee /logs/verifier/log.txt
+status=${PIPESTATUS[0]}
+set -e
+
+# Preserve agent predictions even on verifier failure (Harbor deletes containers).
+if [[ -f /app/report.md ]]; then
+  mkdir -p /logs/verifier
+  cp /app/report.md /logs/verifier/report.md 2>/dev/null || true
+fi
+
+if [[ -f /app/task_meta.json ]]; then
+  cp /app/task_meta.json /logs/verifier/task_meta.json 2>/dev/null || true
+fi
+
+exit $status

tasks/d1-i1-imageslowload-on-02-medium_ttd60m_range30m_off+10m/environment/Dockerfile

@@ -0,0 +1 @@
+FROM ag2435/sre-otel-snapshot:{code_tag}

tasks/d1-i1-imageslowload-on-02-medium_ttd60m_range30m_off+10m/environment/docker-compose.yaml

@@ -0,0 +1,21 @@
+services:
+  main:
+    build:
+      context: ${CONTEXT_DIR}
+      pull: true
+    image: ${MAIN_IMAGE_NAME}
+    command: [ "sh", "-c", "sleep infinity" ]
+    privileged: true
+    environment:
+      - TEST_DIR=${TEST_DIR}
+      - CONTEXT_DIR=${CONTEXT_DIR}
+    volumes:
+      - /var/run/docker.sock:/var/run/docker.sock
+      - ${CONTEXT_DIR}:${CONTEXT_DIR}
+      - ${HOST_VERIFIER_LOGS_PATH}:${ENV_VERIFIER_LOGS_PATH}
+      - ${HOST_AGENT_LOGS_PATH}:${ENV_AGENT_LOGS_PATH}
+    deploy:
+      resources:
+        limits:
+          cpus: ${CPUS}
+          memory: ${MEMORY}

tasks/d1-i1-imageslowload-on-02-medium_ttd60m_range30m_off+10m/solution/check_prediction.py

@@ -0,0 +1,1005 @@
+"""LLM-as-a-judge verifier for Harbor incident-RCA-report tasks.
+
+Supports two modes:
+
+1. **Harbor verifier** (default):
+       python /tests/check_prediction.py
+
+2. **Post-hoc single-trial**:
+       python check_prediction.py --expected expected.json --predictions report.md [--rubric rubric.json]
+
+Falls back to string-match scoring when OPENAI_API_KEY is not set.
+"""
+
+import argparse
+import asyncio
+import json
+import logging
+import os
+import sys
+import traceback
+from pathlib import Path
+from typing import Any
+
+from tabulate import tabulate
+
+logger = logging.getLogger(__name__)
+
+JUDGE_PROMPT_MULTI_HEADER = """\
+You are an expert SRE tasked with judging the quality of an AI-generated incident RCA report.
+
+You are given:
+1. **One or more** ground-truth rubrics. Each describes a plausible root cause, its incident time, mechanism, and symptoms. Several flags may have been active in the same window; the agent is credited if it correctly identifies **any one** of these rubrics.
+2. The SRE agent's incident RCA report.
+
+## SRE Agent's Incident RCA Report
+
+{predictions}
+
+## Ground-Truth Rubrics
+
+{rubrics}
+
+## Evaluation Questions
+
+For **each rubric** in order, answer every question with true or false. Base your answer only on evidence in the agent's report; if the report does not cite the required evidence, answer false. The output must contain one entry per rubric, in the same order, and must preserve cluster order within each rubric exactly as listed.
+
+For each rubric:
+
+- `incident_time_within_10min`: Did the agent's timeline place the incident start within ±10 minutes of this rubric's `incident_time`?
+- `feature_flag_match`: Did the agent identify this rubric's feature flag as a root cause? (The agent may name multiple flags; mark true if this flag is among them.)
+- `mechanism_match`: Did the agent correctly explain this rubric's mechanism — how the flag propagates to the user-visible failure?
+- For each metric/log/trace cluster listed for this rubric: per-cluster match flags as before.
+"""
+
+JUDGE_PROMPT_SCORING_FOOTER = """\
+
+## Overall Score
+
+Score the incident RCA report on a scale of 0 to 3. The agent is credited if it correctly identifies **any one** of the listed rubrics — score against the rubric the agent's report best matches. Scoring is based on content correctness only; do not penalize or reward for formatting, prose style, or structural polish. Materially incorrect or misleading claims count against the score: if the report would otherwise score N but also adds a materially wrong claim (e.g., invents an unrelated additional cause), drop to N-1 (floor at 0). A report that correctly identifies one root cause but introduces a misleading fabrication alongside it therefore scores 2, not 3. When applying this penalty, explicitly identify in your reasoning which specific claim is materially wrong — quote or paraphrase the offending text. Do not apply the penalty without naming the offending claim; missing detail or incomplete explanation does not qualify as a materially wrong claim. Naming several of the listed plausible root causes is **not** a materially wrong claim.
+
+- 0: AI findings are misaligned with every rubric's mechanism and completely miss the root cause
+- 1: AI verifies incident description — the report confirms symptoms described in the task prompt but does not investigate further
+- 2: AI makes correct progress beyond symptoms — the report identifies some of the ground-truth metrics, logs, or traces for at least one rubric and moves toward that root cause, but does not fully identify any single root cause
+- 3: AI nails at least one of the listed root causes — the report correctly identifies it, the mechanism, and the supporting signals
+
+Respond with ONLY a JSON object matching the provided output schema.
+"""
+
+DEFAULT_MODEL = "openai-gpt-5.4"
+
+
+# ---------------------------------------------------------------------------
+# Rubric rendering (JSON -> markdown)
+# ---------------------------------------------------------------------------
+
+
+def _format_log_clusters(clusters: list[dict], lines: list[str]) -> None:
+    """Render log clusters as markdown subsections."""
+    for cluster in clusters:
+        name = cluster.get("name", "Unknown")
+        count = cluster.get("count")
+        suffix = f" ({count} entries)" if count is not None else ""
+        lines.append(f"#### {name}{suffix}")
+        lines.append("")
+
+        description = cluster.get("description", "")
+        if description:
+            lines.append(description)
+            lines.append("")
+
+        cause = cluster.get("cause", "")
+        if cause:
+            lines.append(f"**Cause:** {cause}")
+            lines.append("")
+
+        source = cluster.get("source", "")
+        if source:
+            lines.append(f"**Source:** {source}")
+            lines.append("")
+
+        attrs = cluster.get("representative_attributes", {})
+        if attrs:
+            lines.append("**Representative attributes:**")
+            lines.append("")
+            rows = [[f"`{k}`", f"`{v}`"] for k, v in attrs.items()]
+            lines.append(tabulate(rows, headers=["Field", "Value"], tablefmt="github"))
+            lines.append("")
+
+        docs = cluster.get("log_documents", [])
+        if docs:
+            lines.append("**Log documents:**")
+            lines.append("")
+            rows = [
+                [f"`{d['_index']}`", f"`{d['_id']}`", d["@timestamp"]] for d in docs
+            ]
+            lines.append(
+                tabulate(
+                    rows, headers=["_index", "_id", "@timestamp"], tablefmt="github"
+                )
+            )
+            lines.append("")
+
+
+def _format_trace_clusters(clusters: list[dict], lines: list[str]) -> None:
+    """Render trace clusters as markdown subsections."""
+    for cluster in clusters:
+        name = cluster.get("name", "Unknown")
+        count = cluster.get("count")
+        suffix = f" ({count} traces)" if count is not None else ""
+        lines.append(f"#### {name}{suffix}")
+        lines.append("")
+
+        description = cluster.get("description", "")
+        if description:
+            lines.append(description)
+            lines.append("")
+
+        cause = cluster.get("cause", "")
+        if cause:
+            lines.append(f"**Cause:** {cause}")
+            lines.append("")
+
+        call_chain = cluster.get("call_chain", "")
+        if call_chain:
+            lines.append("**Call chain:**")
+            lines.append("")
+            lines.append("```")
+            lines.append(call_chain)
+            lines.append("```")
+            lines.append("")
+
+        smoking_gun = cluster.get("smoking_gun", [])
+        if smoking_gun:
+            lines.append("**Smoking-gun error messages:**")
+            lines.append("")
+            for msg in smoking_gun:
+                lines.append(f"- {msg}")
+            lines.append("")
+
+        docs = cluster.get("trace_documents", [])
+        if docs:
+            lines.append("**Trace documents:**")
+            lines.append("")
+            headers = ["traceID", "@timestamp"]
+            has_action = any("user_action" in d for d in docs)
+            if has_action:
+                headers.append("user_action")
+            rows = []
+            for d in docs:
+                row = [f"`{d['traceID']}`", d["@timestamp"]]
+                if has_action:
+                    row.append(d.get("user_action", ""))
+                rows.append(row)
+            lines.append(tabulate(rows, headers=headers, tablefmt="github"))
+            lines.append("")
+
+
+_LAYER_DESCRIPTIONS = {
+    "root_cause": "metric closest to the fault injection point",
+    "propagation": "intermediate services reflecting the error through the call chain",
+    "symptom": "user-facing impact visible to end users or clients",
+    "meta": "feature flag counters or internal plumbing",
+    "unknown": "unclassified",
+}
+
+_LAYER_ORDER = ["root_cause", "propagation", "symptom", "meta", "unknown"]
+
+
+def _format_onset(offset: int | None) -> str:
+    """Format an onset offset as '+Xs' or 'N/A'."""
+    if offset is None:
+        return "N/A"
+    return f"+{offset}s"
+
+
+def _format_label_values(labels: dict[str, str]) -> str:
+    """Format label values as a compact comma-separated string."""
+    if not labels:
+        return ""
+    return ", ".join(labels.values())
+
+
+def _earliest_onset(variants: list[dict]) -> int | None:
+    """Return the earliest onset_offset_seconds across variants, or None."""
+    offsets = [
+        v["onset_offset_seconds"]
+        for v in variants
+        if v.get("onset_offset_seconds") is not None
+    ]
+    return min(offsets) if offsets else None
+
+
+def _format_metrics_list(metrics_list: list[dict], lines: list[str]) -> None:
+    """Render metric families grouped by signal layer."""
+    by_layer: dict[str, list[dict]] = {}
+    for fam in metrics_list:
+        by_layer.setdefault(fam.get("signal_layer", "unknown"), []).append(fam)
+
+    for layer in _LAYER_ORDER:
+        layer_families = by_layer.get(layer, [])
+        if not layer_families:
+            continue
+
+        layer_onsets = [_earliest_onset(f["variants"]) for f in layer_families]
+        layer_onsets = [o for o in layer_onsets if o is not None]
+        layer_onset_str = (
+            f" (earliest onset: {_format_onset(min(layer_onsets))})"
+            if layer_onsets
+            else ""
+        )
+
+        display_layer = layer.replace("_", " ").title()
+        desc = _LAYER_DESCRIPTIONS.get(layer, "")
+        lines.append(f"**{display_layer}** — {desc}{layer_onset_str}")
+        lines.append("")
+
+        for fam in layer_families:
+            fam_onset = _earliest_onset(fam["variants"])
+            label_vals = _format_label_values(fam.get("defining_labels", {}))
+            label_part = f" ({label_vals})" if label_vals else ""
+            lines.append(
+                f"#### {fam['metric_family']} family{label_part}"
+                f" — onset: {_format_onset(fam_onset)}"
+            )
+            lines.append("")
+
+            first_desc = (
+                fam["variants"][0].get("description", "") if fam["variants"] else ""
+            )
+            if first_desc:
+                lines.append(first_desc)
+                lines.append("")
+
+            for v in fam["variants"]:
+                v_onset = _format_onset(v.get("onset_offset_seconds"))
+                lines.append(f"- **{v['type']}** (onset: {v_onset})")
+                lines.append(f"  `{v['query']}`")
+                lines.append("")
+
+
+def _format_frontend_issues(issues: list[dict], lines: list[str]) -> None:
+    """Render frontend issues as markdown subsections."""
+    for issue in issues:
+        route = issue.get("route", "Unknown route")
+        lines.append(f"#### {route}")
+        lines.append("")
+
+        description = issue.get("description", "")
+        if description:
+            lines.append(description)
+            lines.append("")
+
+        rows = [
+            ["Deterministic", str(issue.get("deterministic", ""))],
+            ["Trigger condition", issue.get("trigger_condition", "")],
+            ["Calling service", issue.get("calling_service", "")],
+            [
+                "Source",
+                f"`{issue.get('source_file', '')}:{issue.get('source_line', '')}`",
+            ],
+        ]
+        lines.append(tabulate(rows, headers=["Field", "Value"], tablefmt="github"))
+        lines.append("")
+
+        call_pattern = issue.get("call_pattern", "")
+        if call_pattern:
+            lines.append(f"**Call pattern:** {call_pattern}")
+            lines.append("")
+
+        cause = issue.get("cause", "")
+        if cause:
+            lines.append(f"**Cause:** {cause}")
+            lines.append("")
+
+
+def format_rubric(data: dict, include_frontend: bool = False) -> str:
+    """Convert a rubric JSON dict into a consistently formatted markdown string.
+
+    Args:
+        data: The rubric JSON dict.
+        include_frontend: If True, include the ``### Frontend`` section.
+            Defaults to False since frontend symptoms may be noisy for
+            downstream consumers (LLM judge, oracle solutions).
+            TODO(Albert): systematically test the impact of including vs.
+            excluding frontend symptoms on downstream consumers.
+
+    """
+    lines: list[str] = []
+
+    lines.append(f"# {data['feature_flag']}")
+    lines.append("")
+    lines.append(f"**Feature flag:** `{data['feature_flag']}`")
+    lines.append("")
+    lines.append(f"**Description:** {data['description']}")
+    lines.append("")
+    lines.append(f"**Incident time:** {data['incident_time']}")
+    lines.append("")
+
+    lines.append("## Mechanism")
+    lines.append("")
+    lines.append(data["mechanism"])
+    lines.append("")
+
+    interaction = data.get("interaction", "")
+    if interaction:
+        lines.append(f"**Interaction with other feature flags:** {interaction}")
+        lines.append("")
+
+    lines.append("## Evidence")
+    lines.append("")
+
+    gs = data["symptoms"]
+
+    metrics = gs.get("metrics", [])
+    lines.append("### Metrics")
+    lines.append("")
+    if metrics:
+        _format_metrics_list(metrics, lines)
+
+    logs = gs.get("logs", [])
+    lines.append("### Logs")
+    lines.append("")
+    if logs:
+        _format_log_clusters(logs, lines)
+
+    if include_frontend:
+        frontend = gs.get("frontend", [])
+        lines.append("### Frontend")
+        lines.append("")
+        if frontend:
+            _format_frontend_issues(frontend, lines)
+
+    traces = gs.get("traces", [])
+    lines.append("### Traces")
+    lines.append("")
+    if traces:
+        _format_trace_clusters(traces, lines)
+
+    return "\n".join(lines)
+
+
+# ---------------------------------------------------------------------------
+# Judge prompt + output-schema builders
+# ---------------------------------------------------------------------------
+
+
+def _render_checklist(rubric_data: dict) -> str:
+    """Build per-cluster checklist blocks for metrics/logs/traces."""
+    symptoms = rubric_data.get("symptoms", {}) or {}
+    metric_clusters = symptoms.get("metrics", []) or []
+    log_clusters = symptoms.get("logs", []) or []
+    trace_clusters = symptoms.get("traces", []) or []
+
+    blocks: list[str] = []
+
+    if metric_clusters:
+        lines = ["#### Metric clusters"]
+        for i, m in enumerate(metric_clusters):
+            family = m.get("metric_family", "")
+            lines.append(
+                f'- Cluster {i}: `metric_family = "{family}"`'
+                f" — family_match: did the agent cite a query targeting"
+                f" metric_family `{family}` under a Why-step whose causal chain"
+                f" aligns with the rubric?"
+            )
+        blocks.append("\n".join(lines))
+
+    if log_clusters:
+        lines = ["#### Log clusters"]
+        for i, log in enumerate(log_clusters):
+            attrs = log.get("representative_attributes") or {}
+            body = attrs.get("body", "")
+            service_name = attrs.get("resource.service.name", "")
+            lines.append(
+                f"- Cluster {i}:\n"
+                f"  - `resource.service.name`: `{service_name}`\n"
+                f"  - `body`: `{body}`\n"
+                f"  - body_match: did the agent cite log evidence whose body"
+                f" matches the rubric's `body` under a Why-step whose causal"
+                f" chain aligns with the rubric?\n"
+                f"  - service_name_match: did the agent attribute the cited"
+                f" log evidence to the OTel service `{service_name}`"
+                f" (`resource.service.name`)?"
+            )
+        blocks.append("\n".join(lines))
+
+    if trace_clusters:
+        lines = ["#### Trace clusters"]
+        for i, trace in enumerate(trace_clusters):
+            call_chain = trace.get("call_chain", "")
+            smoking_gun = trace.get("smoking_gun", []) or []
+            sg_rendered = "\n".join(f"    - {s}" for s in smoking_gun)
+            lines.append(
+                f"- Cluster {i}:\n"
+                f"  - call_chain: `{call_chain}`\n"
+                f"  - smoking_gun:\n{sg_rendered}\n"
+                f"  - call_chain_match: did the agent cite evidence matching"
+                f" this service-level call chain under a Why-step whose causal"
+                f" chain aligns with the rubric?\n"
+                f"  - smoking_gun_match: did the agent cite at least one of"
+                f" the listed smoking-gun signals?"
+            )
+        blocks.append("\n".join(lines))
+
+    return (
+        "\n\n".join(blocks)
+        if blocks
+        else "(No metric, log, or trace clusters in rubric.)"
+    )
+
+
+def build_judge_prompt(
+    rubrics_data: list[dict],
+    predictions: str,
+) -> str:
+    """Render the judge prompt for one or more ground-truth rubrics.
+
+    The prompt asks the LLM to evaluate the agent's report against **each**
+    rubric independently. The agent is credited if it correctly identifies
+    any one rubric (the overall score reflects the best match).
+    """
+    if not rubrics_data:
+        raise ValueError("build_judge_prompt called with no rubrics")
+
+    rubric_blocks: list[str] = []
+    checklist_blocks: list[str] = []
+    for i, rubric in enumerate(rubrics_data):
+        feature_flag = rubric.get("feature_flag", "")
+        rubric_blocks.append(
+            f"### Rubric {i + 1} of {len(rubrics_data)} — `{feature_flag}`\n\n"
+            + format_rubric(rubric)
+        )
+        checklist_blocks.append(
+            f"### Rubric {i + 1} of {len(rubrics_data)} — `{feature_flag}`\n\n"
+            + _render_checklist(rubric)
+        )
+
+    rubrics_text = "\n\n---\n\n".join(rubric_blocks)
+    checklist_text = "\n\n---\n\n".join(checklist_blocks)
+
+    header = JUDGE_PROMPT_MULTI_HEADER.format(
+        rubrics=rubrics_text,
+        predictions=predictions,
+    )
+    return header + "\n" + checklist_text + "\n" + JUDGE_PROMPT_SCORING_FOOTER
+
+
+_METRIC_ITEM_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        "metric_family": {"type": "string"},
+        "family_match": {"type": "boolean"},
+    },
+    "required": ["metric_family", "family_match"],
+    "additionalProperties": False,
+}
+
+_LOG_ITEM_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        "body_match": {"type": "boolean"},
+        "service_name_match": {"type": "boolean"},
+    },
+    "required": ["body_match", "service_name_match"],
+    "additionalProperties": False,
+}
+
+_TRACE_ITEM_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        "call_chain_match": {"type": "boolean"},
+        "smoking_gun_match": {"type": "boolean"},
+    },
+    "required": ["call_chain_match", "smoking_gun_match"],
+    "additionalProperties": False,
+}
+
+
+_PER_RUBRIC_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        "feature_flag": {"type": "string"},
+        "incident_time_within_10min": {"type": "boolean"},
+        "feature_flag_match": {"type": "boolean"},
+        "mechanism_match": {"type": "boolean"},
+        "symptoms": {
+            "type": "object",
+            "properties": {
+                "metrics": {"type": "array", "items": _METRIC_ITEM_SCHEMA},
+                "logs": {"type": "array", "items": _LOG_ITEM_SCHEMA},
+                "traces": {"type": "array", "items": _TRACE_ITEM_SCHEMA},
+            },
+            "required": ["metrics", "logs", "traces"],
+            "additionalProperties": False,
+        },
+    },
+    "required": [
+        "feature_flag",
+        "incident_time_within_10min",
+        "feature_flag_match",
+        "mechanism_match",
+        "symptoms",
+    ],
+    "additionalProperties": False,
+}
+
+
+def build_judge_output_schema(rubrics_data: list[dict]) -> dict:
+    """Build a strict JSON Schema for the judge output: one verdict per rubric
+    + an overall ``score`` integer. Falls back to a minimal ``{score: int}``
+    schema when no rubrics are supplied (no-incident path).
+
+    Per-rubric cluster-array lengths vary across rubrics; rather than encode
+    a per-element schema (which Structured Outputs doesn't support), we leave
+    the array lengths unconstrained and rely on the prompt instructions to
+    keep cluster order matching.
+    """
+    if not rubrics_data:
+        return {
+            "type": "object",
+            "properties": {"score": {"type": "integer"}},
+            "required": ["score"],
+            "additionalProperties": False,
+        }
+
+    n = len(rubrics_data)
+    return {
+        "type": "object",
+        "properties": {
+            "rubrics": {
+                "type": "array",
+                "minItems": n,
+                "maxItems": n,
+                "items": _PER_RUBRIC_SCHEMA,
+            },
+            "score": {"type": "integer"},
+        },
+        "required": ["rubrics", "score"],
+        "additionalProperties": False,
+    }
+
+
+# ---------------------------------------------------------------------------
+# API call
+# ---------------------------------------------------------------------------
+
+
+async def async_call_llm_judge(
+    client: Any,
+    prompt: str,
+    model: str = DEFAULT_MODEL,
+    reasoning_effort: str | None = None,
+    output_schema: dict | None = None,
+) -> tuple[str, list[dict] | None]:
+    """Call the LLM judge via the OpenAI Responses API (falling back to Chat).
+
+    When ``output_schema`` is provided, uses Structured Outputs (strict JSON
+    Schema) so the returned text is guaranteed to conform to the schema.
+
+    Returns:
+        A tuple of (output_text, reasoning_summaries). reasoning_summaries is
+        None when reasoning_effort is not set.
+
+    """
+    text_format: dict[str, Any] = (
+        {
+            "type": "json_schema",
+            "name": "judge_response",
+            "schema": output_schema,
+            "strict": True,
+        }
+        if output_schema is not None
+        else {"type": "text"}
+    )
+    try:
+        kwargs: dict[str, Any] = {
+            "model": model,
+            "input": prompt,
+            "text": {"format": text_format},
+            "tools": [],
+            "store": True,
+            "max_output_tokens": 16384,
+        }
+        if reasoning_effort is not None:
+            kwargs["reasoning"] = {"effort": reasoning_effort, "summary": "auto"}
+        response = await client.responses.create(**kwargs)
+        reasoning_summaries = None
+        if reasoning_effort is not None:
+            reasoning_summaries = [
+                [
+                    s.model_dump() if hasattr(s, "model_dump") else s
+                    for s in item.summary
+                ]
+                for item in response.output
+                if getattr(item, "type", None) == "reasoning"
+                and getattr(item, "summary", None) is not None
+            ]
+        return response.output_text, reasoning_summaries
+    except Exception as exc:
+        if "404" not in str(exc):
+            raise
+        logger.info(
+            f"Responses API returned 404 for {model}, falling back to Chat Completions"
+        )
+        chat_kwargs: dict[str, Any] = {
+            "model": model,
+            "messages": [{"role": "user", "content": prompt}],
+            "max_tokens": 16384,
+        }
+        if output_schema is not None:
+            chat_kwargs["response_format"] = {
+                "type": "json_schema",
+                "json_schema": {
+                    "name": "judge_response",
+                    "schema": output_schema,
+                    "strict": True,
+                },
+            }
+        if reasoning_effort is not None:
+            chat_kwargs["reasoning_effort"] = reasoning_effort
+        response = await client.chat.completions.create(**chat_kwargs)
+        reasoning_summaries = None
+        if reasoning_effort is not None:
+            reasoning_content = getattr(
+                response.choices[0].message, "reasoning_content", None
+            )
+            if reasoning_content is not None:
+                reasoning_summaries = [{"type": "text", "text": reasoning_content}]
+            else:
+                reasoning_summaries = []
+        return response.choices[0].message.content, reasoning_summaries
+
+
+# ---------------------------------------------------------------------------
+# Parsing + aggregation
+# ---------------------------------------------------------------------------
+
+
+def parse_judge_response(response_text: str) -> dict:
+    """Parse the judge response JSON and range-check ``score``.
+
+    When Structured Outputs are used upstream, the response is already
+    schema-validated; this function only decodes the JSON and enforces the
+    0-3 range for ``score``.
+    """
+    parsed = json.loads(response_text)
+    score = int(parsed["score"])
+    if score < 0 or score > 3:
+        raise ValueError(f"Score {score} out of range [0, 3]")
+    parsed["score"] = score
+    return parsed
+
+
+def _aggregate_one_rubric(verdict: dict) -> dict:
+    """Roll up cluster verdicts for a single per-rubric judge entry."""
+    symptoms = verdict.get("symptoms", {}) or {}
+    metrics = symptoms.get("metrics", []) or []
+    logs = symptoms.get("logs", []) or []
+    traces = symptoms.get("traces", []) or []
+
+    metric_hits = [bool(m.get("family_match")) for m in metrics]
+    log_hits = [
+        bool(l.get("body_match")) and bool(l.get("service_name_match")) for l in logs
+    ]
+    trace_hits = [
+        bool(t.get("call_chain_match")) and bool(t.get("smoking_gun_match"))
+        for t in traces
+    ]
+
+    def _all(hits: list[bool]) -> bool | None:
+        return all(hits) if hits else None
+
+    def _any(hits: list[bool]) -> bool | None:
+        return any(hits) if hits else None
+
+    return {
+        "feature_flag": verdict.get("feature_flag", ""),
+        "incident_time_within_10min": bool(verdict.get("incident_time_within_10min")),
+        "feature_flag_match": bool(verdict.get("feature_flag_match")),
+        "mechanism_match": bool(verdict.get("mechanism_match")),
+        "metrics_all_match": _all(metric_hits),
+        "metrics_any_match": _any(metric_hits),
+        "logs_all_match": _all(log_hits),
+        "logs_any_match": _any(log_hits),
+        "traces_all_match": _all(trace_hits),
+        "traces_any_match": _any(trace_hits),
+    }
+
+
+def aggregate_judge_response(parsed: dict) -> dict:
+    """Aggregate per-rubric, per-cluster verdicts into flat any-of rollups.
+
+    The agent is credited if it matches any one of the listed rubrics.
+    Per-rubric rollups are computed via ``_aggregate_one_rubric``; the
+    task-level rollup is the ``any`` over rubrics for booleans (with ``None``
+    skipped — sections without clusters in any rubric stay ``None``).
+
+    The per-rubric rollups are also returned under ``per_rubric`` for
+    downstream analysis that needs to know which specific rubric matched.
+    """
+    rubrics = parsed.get("rubrics") or []
+    per_rubric = [_aggregate_one_rubric(r) for r in rubrics]
+
+    def _any_skip_none(values: list[bool | None]) -> bool | None:
+        truthy = [v for v in values if v is not None]
+        return any(truthy) if truthy else None
+
+    return {
+        "incident_time_within_10min": _any_skip_none(
+            [r["incident_time_within_10min"] for r in per_rubric]
+        )
+        or False,
+        "feature_flag_match": _any_skip_none(
+            [r["feature_flag_match"] for r in per_rubric]
+        )
+        or False,
+        "mechanism_match": _any_skip_none([r["mechanism_match"] for r in per_rubric])
+        or False,
+        "metrics_all_match": _any_skip_none(
+            [r["metrics_all_match"] for r in per_rubric]
+        ),
+        "metrics_any_match": _any_skip_none(
+            [r["metrics_any_match"] for r in per_rubric]
+        ),
+        "logs_all_match": _any_skip_none([r["logs_all_match"] for r in per_rubric]),
+        "logs_any_match": _any_skip_none([r["logs_any_match"] for r in per_rubric]),
+        "traces_all_match": _any_skip_none([r["traces_all_match"] for r in per_rubric]),
+        "traces_any_match": _any_skip_none([r["traces_any_match"] for r in per_rubric]),
+        "per_rubric": per_rubric,
+        "score": int(parsed["score"]),
+    }
+
+
+def string_match_fallback(expected: dict, predictions: str) -> dict:
+    """Fall back to case-insensitive string search for any plausible root_cause.
+
+    ``expected["events"]`` is a list of ``{"root_cause": <flag>, "event_time": ...}``;
+    the agent's report is credited if any listed root_cause appears in it.
+    Returns a result dict compatible with the judge output format.
+    """
+    events: list[dict] = expected.get("events") or []
+    if not events:
+        # No-incident task: agent should write an empty report.
+        return {"score": 3 if len(predictions.strip()) == 0 else 0}
+    text = predictions.lower()
+    found = any(e["root_cause"].strip().lower() in text for e in events)
+    return {"score": 3 if found else 0}
+
+
+# ---------------------------------------------------------------------------
+# Judge entry point (used by both modes)
+# ---------------------------------------------------------------------------
+
+
+async def judge(
+    client: Any,
+    expected: dict,
+    predictions: str,
+    rubrics_data: list[dict],
+    model: str = DEFAULT_MODEL,
+    reasoning_effort: str | None = None,
+) -> dict:
+    """Run the LLM judge over one or more ground-truth rubrics, or
+    short-circuit for no-incident tasks.
+
+    Returns:
+        A dict with keys: reward, mode, score, and (for LLM judge) model,
+        nested (raw judge response), reasoning_summary, rubric_used,
+        judge_prompt, judge_response_raw. Per-section rollups are derived
+        post-hoc from ``nested`` by formatters via ``aggregate_judge_response``.
+
+    """
+    events: list[dict] = expected.get("events") or []
+    if not events:
+        score = 3 if len(predictions.strip()) == 0 else 0
+        return {
+            "reward": score / 3.0,
+            "mode": "no_incident",
+            "model": model,
+            "score": score,
+        }
+
+    # Short-circuit when the agent emitted an empty report despite an incident.
+    # No LLM call can rescue this; score is a guaranteed 0. We synthesize the
+    # nested response shape (per-rubric all False, matching cluster counts)
+    # so that ``aggregate_judge_response`` produces the expected all-False
+    # rollups at load time.
+    if not predictions.strip():
+        synthetic_per_rubric = []
+        for rubric in rubrics_data:
+            symptoms = rubric.get("symptoms", {}) or {}
+            synthetic_per_rubric.append(
+                {
+                    "feature_flag": rubric.get("feature_flag", ""),
+                    "incident_time_within_10min": False,
+                    "feature_flag_match": False,
+                    "mechanism_match": False,
+                    "symptoms": {
+                        "metrics": [
+                            {
+                                "metric_family": m.get("metric_family", ""),
+                                "family_match": False,
+                            }
+                            for m in (symptoms.get("metrics") or [])
+                        ],
+                        "logs": [
+                            {"body_match": False, "service_name_match": False}
+                            for _ in (symptoms.get("logs") or [])
+                        ],
+                        "traces": [
+                            {"call_chain_match": False, "smoking_gun_match": False}
+                            for _ in (symptoms.get("traces") or [])
+                        ],
+                    },
+                }
+            )
+        return {
+            "mode": "empty_report",
+            "model": model,
+            "score": 0,
+            "reward": 0.0,
+            "rubric_used": bool(rubrics_data),
+            "nested": {"rubrics": synthetic_per_rubric, "score": 0},
+        }
+
+    prompt = build_judge_prompt(rubrics_data, predictions)
+    output_schema = build_judge_output_schema(rubrics_data)
+
+    raw_response, reasoning_summary = await async_call_llm_judge(
+        client,
+        prompt,
+        model=model,
+        reasoning_effort=reasoning_effort,
+        output_schema=output_schema,
+    )
+    parsed = parse_judge_response(raw_response)
+
+    # Per-section rollups are NOT spread into the result — they're a pure
+    # post-hoc derivation from ``nested`` via ``aggregate_judge_response``,
+    # applied by the formatters at load time so schema changes don't require
+    # rewriting saved JSONs.
+    return {
+        "mode": "llm_judge",
+        "model": model,
+        "score": parsed["score"],
+        "reward": parsed["score"] / 3.0,
+        "reasoning_summary": reasoning_summary,
+        "rubric_used": bool(rubrics_data),
+        "judge_prompt": prompt,
+        "judge_response_raw": raw_response,
+        "nested": parsed,
+    }
+
+
+# ---------------------------------------------------------------------------
+# CLI
+# ---------------------------------------------------------------------------
+
+
+async def main() -> None:
+    """Entry point: load expected + predictions, score, write reward/details."""
+    parser = argparse.ArgumentParser(
+        description="LLM-as-a-judge verifier for Harbor incident-RCA-report tasks."
+    )
+    parser.add_argument("--expected", type=str, default="/tests/expected.json")
+    parser.add_argument("--predictions", type=str, default="/app/report.md")
+    parser.add_argument(
+        "--rubrics-dir",
+        type=str,
+        default="/tests/rubrics",
+        help=(
+            "Directory containing one rubric JSON per plausible root cause "
+            "(e.g. /tests/rubrics/<event_id>.json). The judge scores the "
+            "agent against any one of them."
+        ),
+    )
+    parser.add_argument(
+        "--model", type=str, default=DEFAULT_MODEL, help="Judge LLM model name."
+    )
+    parser.add_argument(
+        "--effort",
+        type=str,
+        choices=["low", "medium", "high"],
+        default="high",
+        help="Reasoning effort level for the judge LLM (default: high).",
+    )
+    parser.add_argument(
+        "--mode",
+        type=str,
+        choices=["string_match", "llm_judge"],
+        default="string_match",
+        help="Scoring mode: string_match or llm_judge (default: string_match).",
+    )
+    parser.add_argument("--reward", type=str, default="/logs/verifier/reward.txt")
+    parser.add_argument("--details", type=str, default="/logs/verifier/details.json")
+    args = parser.parse_args()
+
+    expected_path = Path(args.expected)
+    predictions_path = Path(args.predictions)
+    rubrics_dir = Path(args.rubrics_dir)
+    reward_path = Path(args.reward)
+    details_path = Path(args.details)
+
+    try:
+        # Load expected
+        print(f"Loading expected results from {expected_path}...")
+        with expected_path.open() as f:
+            expected = json.load(f)
+
+        # Load predictions (markdown report)
+        print(f"Loading predictions from {predictions_path}...")
+        predictions = predictions_path.read_text()
+
+        # Load rubric JSONs — one per plausible root cause. Order is the
+        # filesystem sort order, which matches the build_harbor_tasks.py
+        # naming convention (event_id stems sort lexicographically).
+        rubrics_data: list[dict] = []
+        if expected.get("events"):
+            if rubrics_dir.is_dir():
+                rubric_paths = sorted(rubrics_dir.glob("*.json"))
+                for p in rubric_paths:
+                    with p.open() as f:
+                        rubrics_data.append(json.load(f))
+                print(f"Loaded {len(rubrics_data)} rubric(s) from {rubrics_dir}")
+            else:
+                print(f"Rubric directory missing: {rubrics_dir}")
+        else:
+            print("No incident events in expected results; skipping rubric load.")
+
+        # Run judge
+        if args.mode == "string_match":
+            em = string_match_fallback(expected, predictions)
+            result = {"reward": em["score"] / 3.0, "mode": "string_match", **em}
+        else:
+            from openai import AsyncOpenAI
+
+            client = AsyncOpenAI(
+                api_key=os.getenv("OPENAI_API_KEY"),
+                base_url=os.getenv("OPENAI_BASE_URL"),
+            )
+            result = await judge(
+                client,
+                expected,
+                predictions,
+                rubrics_data,
+                model=args.model,
+                reasoning_effort=args.effort,
+            )
+
+        # Write reward
+        reward_path.parent.mkdir(parents=True, exist_ok=True)
+        reward_path.write_text(str(result["reward"]))
+
+        # Write details
+        details_path.parent.mkdir(parents=True, exist_ok=True)
+        details_path.write_text(json.dumps(result, indent=2))
+
+        print(f"Score: {result.get('score', 'N/A')}/3 (reward: {result['reward']})")
+        print(f"Mode: {result['mode']}")
+        if result.get("reasoning_summary"):
+            print(f"Reasoning summary: {result['reasoning_summary']}")
+
+        if result["reward"] < 1.0:
+            sys.exit(1)
+
+    except Exception as exc:
+        reward_path.parent.mkdir(parents=True, exist_ok=True)
+        reward_path.write_text("0.0")
+        details_path.parent.mkdir(parents=True, exist_ok=True)
+        details_path.write_text(
+            json.dumps(
+                {
+                    "reward": 0.0,
+                    "error": f"{type(exc).__name__}: {exc}",
+                    "traceback": traceback.format_exc(),
+                },
+                indent=2,
+            )
+        )
+        print(f"Verifier error: {type(exc).__name__}: {exc}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

tasks/d1-i1-imageslowload-on-02-medium_ttd60m_range30m_off+10m/solution/rubric.json

@@ -0,0 +1,24 @@
+{
+  "incident_time": "2026-04-19T14:01:51.404464+00:00",
+  "feature_flag": "imageSlowLoad",
+  "description": "A feature flag in the frontend `ProductCard` React component added an `x-envoy-fault-delay-request` header (plus `Cache-Control: no-cache`) to every product-image fetch; Envoy honored the fault-injection header and artificially delayed each `GET /images/products/<picture>` response, so product thumbnails took seconds to render.",
+  "mechanism": "The flag is read in [`ProductCard.tsx#L32`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L32): the `ProductCard` React component calls `useNumberFlagValue('imageSlowLoad', 0)` to get the delay value in milliseconds (variants: `0` for off, `5000` for 5 sec, `10000` for 10 sec). When non-zero, the component sets the `x-envoy-fault-delay-request` header to the flag value on every product image fetch ([`ProductCard.tsx#L37`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L37)).\n\nThe image request is sent to `/images/products/<picture>`, which the frontend-proxy Envoy routes to the `image-provider` cluster ([`envoy.tmpl.yaml#L54-L55`](../../opentelemetry-demo/src/frontend-proxy/envoy.tmpl.yaml#L54)). Envoy's `envoy.filters.http.fault` filter is configured with `header_delay: {}` and 100% percentage ([`envoy.tmpl.yaml#L67-L74`](../../opentelemetry-demo/src/frontend-proxy/envoy.tmpl.yaml#L67)), meaning it honors the `x-envoy-fault-delay-request` header and injects the specified delay (in ms) before forwarding the request. Every product card image load is therefore delayed by the flag value (e.g. 5 or 10 seconds), causing the page to render with blank/loading images until the delayed responses arrive.",
+  "symptoms": {
+    "metrics": [],
+    "logs": [],
+    "frontend": [
+      {
+        "description": "Product card thumbnails on the homepage product grid (and the recommendations carousel on product/cart/checkout pages) render with a blank image placeholder for ~5 seconds before the actual thumbnail appears. The page text and layout render immediately; only the images are delayed. Affects every product card on every page load while the flag is on — the failure is silent slowness, not a visible error.",
+        "route": "GET /images/products/<picture>",
+        "deterministic": true,
+        "trigger_condition": "Every page load that renders a `ProductCard` component — homepage product grid (`/`), recommendations carousel on product detail (`/product/<id>`), cart, and checkout pages.",
+        "source_file": "src/frontend/components/ProductCard/ProductCard.tsx",
+        "source_line": 37,
+        "calling_service": "frontend",
+        "call_pattern": "ProductCard.useEffect ([`ProductCard.tsx#L34`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L34)) → fetch(`/images/products/<picture>`) with header `x-envoy-fault-delay-request: 5000` ([`ProductCard.tsx#L37`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L37)) → frontend-proxy Envoy → image-provider.",
+        "cause": "`useNumberFlagValue('imageSlowLoad', 0)` returns 5000 (the `5sec` variant value, [`demo.flagd.json` `imageSlowLoad.variants.5sec`](../../opentelemetry-demo/src/flagd/demo.flagd.json)). ProductCard sets `x-envoy-fault-delay-request: 5000` on every image fetch ([`ProductCard.tsx#L37`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L37)). The frontend-proxy `envoy.filters.http.fault` filter ([`envoy.tmpl.yaml#L67`](../../opentelemetry-demo/src/frontend-proxy/envoy.tmpl.yaml#L67)) honors this header and delays each image response by 5000ms before forwarding to image-provider, so each `<S.Image>` only resolves after that delay."
+      }
+    ],
+    "traces": []
+  }
+}

tasks/d1-i1-imageslowload-on-02-medium_ttd60m_range30m_off+10m/solution/rubrics/d1-i1-imageSlowLoad-on.json

@@ -0,0 +1,24 @@
+{
+  "incident_time": "2026-04-19T14:01:51.404464+00:00",
+  "feature_flag": "imageSlowLoad",
+  "description": "A feature flag in the frontend `ProductCard` React component added an `x-envoy-fault-delay-request` header (plus `Cache-Control: no-cache`) to every product-image fetch; Envoy honored the fault-injection header and artificially delayed each `GET /images/products/<picture>` response, so product thumbnails took seconds to render.",
+  "mechanism": "The flag is read in [`ProductCard.tsx#L32`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L32): the `ProductCard` React component calls `useNumberFlagValue('imageSlowLoad', 0)` to get the delay value in milliseconds (variants: `0` for off, `5000` for 5 sec, `10000` for 10 sec). When non-zero, the component sets the `x-envoy-fault-delay-request` header to the flag value on every product image fetch ([`ProductCard.tsx#L37`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L37)).\n\nThe image request is sent to `/images/products/<picture>`, which the frontend-proxy Envoy routes to the `image-provider` cluster ([`envoy.tmpl.yaml#L54-L55`](../../opentelemetry-demo/src/frontend-proxy/envoy.tmpl.yaml#L54)). Envoy's `envoy.filters.http.fault` filter is configured with `header_delay: {}` and 100% percentage ([`envoy.tmpl.yaml#L67-L74`](../../opentelemetry-demo/src/frontend-proxy/envoy.tmpl.yaml#L67)), meaning it honors the `x-envoy-fault-delay-request` header and injects the specified delay (in ms) before forwarding the request. Every product card image load is therefore delayed by the flag value (e.g. 5 or 10 seconds), causing the page to render with blank/loading images until the delayed responses arrive.",
+  "symptoms": {
+    "metrics": [],
+    "logs": [],
+    "frontend": [
+      {
+        "description": "Product card thumbnails on the homepage product grid (and the recommendations carousel on product/cart/checkout pages) render with a blank image placeholder for ~5 seconds before the actual thumbnail appears. The page text and layout render immediately; only the images are delayed. Affects every product card on every page load while the flag is on — the failure is silent slowness, not a visible error.",
+        "route": "GET /images/products/<picture>",
+        "deterministic": true,
+        "trigger_condition": "Every page load that renders a `ProductCard` component — homepage product grid (`/`), recommendations carousel on product detail (`/product/<id>`), cart, and checkout pages.",
+        "source_file": "src/frontend/components/ProductCard/ProductCard.tsx",
+        "source_line": 37,
+        "calling_service": "frontend",
+        "call_pattern": "ProductCard.useEffect ([`ProductCard.tsx#L34`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L34)) → fetch(`/images/products/<picture>`) with header `x-envoy-fault-delay-request: 5000` ([`ProductCard.tsx#L37`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L37)) → frontend-proxy Envoy → image-provider.",
+        "cause": "`useNumberFlagValue('imageSlowLoad', 0)` returns 5000 (the `5sec` variant value, [`demo.flagd.json` `imageSlowLoad.variants.5sec`](../../opentelemetry-demo/src/flagd/demo.flagd.json)). ProductCard sets `x-envoy-fault-delay-request: 5000` on every image fetch ([`ProductCard.tsx#L37`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L37)). The frontend-proxy `envoy.filters.http.fault` filter ([`envoy.tmpl.yaml#L67`](../../opentelemetry-demo/src/frontend-proxy/envoy.tmpl.yaml#L67)) honors this header and delays each image response by 5000ms before forwarding to image-provider, so each `<S.Image>` only resolves after that delay."
+      }
+    ],
+    "traces": []
+  }
+}

tasks/d1-i1-imageslowload-on-02-medium_ttd60m_range30m_off+10m/solution/solve.py

@@ -0,0 +1,298 @@
+#!/usr/bin/env python3
+"""Generate an incident report from a rubric JSON via LLM.
+
+Standalone script designed to run inside a Harbor task container.
+Also importable by ``run_solve.py`` for local batch generation.
+
+Examples::
+
+    # Inside Harbor container (solve.sh calls this):
+    python solve.py --rubric /tests/rubric.json --output /app/report.md
+
+    # With custom model/effort:
+    python solve.py --rubric /tests/rubric.json --output /app/report.md -m openai-gpt-5.4 -e high
+"""
+
+import argparse
+import asyncio
+import json
+import logging
+import os
+from pathlib import Path
+from typing import Any
+
+from check_prediction import async_call_llm_judge, format_rubric
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_MODEL: str | None = None
+DEFAULT_EFFORT = "high"
+
+# Report format from harbor-template/instruction.md.template — sections 1-4.
+REPORT_FORMAT = """\
+Write a structured incident report with four sections: Summary, Timeline, \
+5 Whys, and Remediation. Follow all section-specific rules below.
+
+---
+
+## Section 1: Summary
+
+2-3 sentences describing what happened, when, and the high-level impact. \
+This should be understandable by someone unfamiliar with the system. Focus \
+on what DID happen and the observable impact — mention request failures if \
+they occurred, but do NOT mention the absence of failures or errors as this \
+can be misread and cause confusion. You may name the root cause in a single \
+phrase (e.g. "due to a misconfigured batch job") but do not explain the \
+causal chain — that belongs in the 5 Whys section.
+
+Example: "Between 13:00 and 13:11 UTC on April 2, the order service returned \
+503 errors for 14% of checkout requests, affecting paying users, due to a \
+Redis cache eviction. The full causal chain is detailed in the 5 Whys section \
+below."
+
+---
+
+## Section 2: Timeline
+
+A chronological narrative of ONLY what went wrong, reconstructed from the \
+provided telemetry. Each entry should be a single succinct line. Cover \
+higher-level events — when a change was introduced, when symptoms started, \
+when a change was reverted, when symptoms subsided — not individual error \
+occurrences. The first entry should be the earliest anomaly visible in the \
+provided telemetry; this establishes the incident start time referenced by \
+the Summary and 5 Whys sections.
+
+For each entry:
+- State the time (UTC), the service(s) involved, and what happened
+- Quantify where possible (error rate, duration, number of affected requests)
+- Do NOT include normal/healthy behavior, baseline noise, or things that \
+worked correctly
+
+Example format:
+```
+09:44 UTC — analytics-job deployed with no memory limit set
+14:17 UTC — redis-cache-0 OOMKilled; node memory at 97%
+14:18 UTC — inventory-svc cache misses begin; all requests fall through to Postgres
+14:18 UTC — order-svc goroutine pool exhaustion begins; 503 error rate climbs to 14%
+14:29 UTC — redis-cache-0 rescheduled; error rate returns to baseline
+```
+
+---
+
+## Section 3: 5 Whys
+
+Rules:
+1. Start by stating the problem as a precise, observable symptom — not a \
+cause. Include what failed, when, and impact (error rate, affected users, \
+duration).
+2. Each "why" answer must be grounded in the provided telemetry. Cite only \
+the telemetry types relevant to that step, using the format below for each.
+
+   - Metrics: one sentence describing the baseline value (or typical range), \
+what it changed to, and at what UTC timestamp. Where relevant, include rate \
+of change or duration. Follow with the exact PromQL query that would surface it.
+     Example — "Error rate on order-svc was 0.1% at 14:17 UTC, jumping to \
+14% at 14:18 UTC. PromQL: rate(http_requests_total{service="order-svc",\
+status=~"5.."}[1m])"
+
+   - Traces: the cascade from the highest-level operation down to the deepest \
+failing span, followed by representative trace IDs from the provided data.
+     Example — "checkout request → order-svc goroutine exhaustion → \
+inventory-svc Redis GET timeout. Trace IDs: 4bf92f3577b34da6, a3ce929d0e0e4736"
+
+   - Logs: one sentence with service, endpoint, error, and time range, \
+followed by the exact Lucene query that would retrieve the relevant log lines.
+     Example — "Between 14:18:02 and 14:29:11 UTC, POST /api/checkout \
+returned 503s. Lucene: service:order-svc AND status:503 AND \
+endpoint:\\"/api/checkout\\""
+3. Each "why" targets the previous answer, not the original problem. Drill \
+down one causal chain; do not branch.
+4. Never accept "human error" or "operator mistake" as a terminal answer. \
+Ask why the human was in a position to make that error.
+5. Stop when you reach a cause that is: (a) actionable — something a team \
+can change, or (b) a process or system gap that allowed the failure to \
+propagate. The number of steps is not fixed at 5.
+6. Only include steps that are directly supported by the provided telemetry. \
+If the causal chain cannot be completed with the available evidence, stop \
+and note what additional telemetry would be needed to continue.
+7. After the chain, note any branches you did NOT follow. If the incident \
+has multiple contributing causes that cannot fit a single chain, say so \
+explicitly rather than forcing one.
+
+Output format:
+
+```
+Problem statement:
+[Observable symptom with time, impact, and detection method]
+
+Why 1: [question] → [answer]
+Evidence: [specific signal]
+
+Why 2: [question] → [answer]
+Evidence: [specific signal]
+
+...
+
+Root cause:
+[Single sentence naming the systemic or process failure]
+
+Unexplored branches:
+[Contributing factors visible in telemetry that were not followed, \
+and why they were set aside]
+```
+
+---
+
+## Section 4: Remediation
+
+For each corrective action, identify which step in the causal chain it \
+targets and what class of fix it is:
+
+- **Root cause fix**: eliminates the condition that started the chain
+- **Propagation fix**: limits blast radius if the root cause recurs
+- **Detection fix**: reduces time-to-detect or time-to-mitigate
+
+List actions from root cause outward. Prefer fixes that prevent recurrence \
+over fixes that only improve response.
+
+Output format:
+
+| Action | Targets | Type |
+|--------|---------|------|
+| [What to do] | Why N | Root cause fix / Propagation fix / Detection fix |
+"""
+
+SOLUTION_PROMPT_TEMPLATE = """\
+You are an expert site reliability engineer. You are given a ground-truth \
+rubric describing an incident's root cause, mechanism, and telemetry evidence.
+
+Your task: write an incident report as if you investigated this incident \
+yourself. Use the rubric evidence to populate each section. Do NOT mention \
+the rubric or that you were given ground-truth data — write as though you \
+discovered everything through telemetry analysis.
+
+## Ground-Truth Rubric
+
+{rubric}
+
+## Report Format
+
+{report_format}
+"""
+
+
+def build_solution_prompt(rubric_md: str) -> str:
+    """Build the LLM prompt from a formatted rubric markdown string."""
+    return SOLUTION_PROMPT_TEMPLATE.format(
+        rubric=rubric_md,
+        report_format=REPORT_FORMAT,
+    )
+
+
+async def generate_report(
+    client: Any,
+    rubric_data: dict,
+    model: str | None = DEFAULT_MODEL,
+    effort: str | None = DEFAULT_EFFORT,
+) -> tuple[str, str, list[dict] | None]:
+    """Generate an incident report from rubric JSON.
+
+    If ``model`` is ``None``, the formatted rubric is returned directly with
+    no LLM call. Otherwise the rubric is passed to the LLM to be reformatted
+    into an incident report.
+
+    Returns:
+        A tuple of (report_text, prompt, reasoning_summary). When ``model``
+        is ``None``, ``prompt`` is empty and ``reasoning_summary`` is ``None``.
+
+    """
+    rubric_md = format_rubric(rubric_data)
+    if model is None:
+        return rubric_md, "", None
+    prompt = build_solution_prompt(rubric_md)
+    response_text, reasoning_summary = await async_call_llm_judge(
+        client, prompt, model=model, reasoning_effort=effort
+    )
+    return response_text, prompt, reasoning_summary
+
+
+async def async_main() -> None:
+    """CLI entry point: read rubric, call LLM, write report."""
+    parser = argparse.ArgumentParser(
+        description="Generate an incident report from a rubric JSON via LLM."
+    )
+    parser.add_argument(
+        "--rubric",
+        type=str,
+        default="/tests/rubric.json",
+        help="Path to rubric JSON file.",
+    )
+    parser.add_argument(
+        "--output",
+        type=str,
+        default="/app/report.md",
+        help="Path to write the generated report.",
+    )
+    parser.add_argument(
+        "--model",
+        "-m",
+        type=str,
+        default=DEFAULT_MODEL,
+        help=(
+            "LLM model name. If omitted, the formatted rubric is written "
+            "directly as the report with no LLM call."
+        ),
+    )
+    parser.add_argument(
+        "--effort",
+        "-e",
+        type=str,
+        choices=["low", "medium", "high"],
+        default=DEFAULT_EFFORT,
+        help=f"Reasoning effort level (default: {DEFAULT_EFFORT}).",
+    )
+    args = parser.parse_args()
+
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s - %(levelname)s - %(message)s",
+    )
+
+    rubric_path = Path(args.rubric)
+    output_path = Path(args.output)
+
+    if not rubric_path.is_file():
+        logger.warning(f"Rubric file not found: {rubric_path}; writing empty report")
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        output_path.write_text("")
+        return
+
+    rubric_data = json.loads(rubric_path.read_text())
+    logger.info(
+        f"Loaded rubric: {rubric_data.get('feature_flag', 'unknown')} "
+        f"from {rubric_path}"
+    )
+
+    client: Any = None
+    if args.model is not None:
+        from openai import AsyncOpenAI
+
+        client = AsyncOpenAI(
+            api_key=os.getenv("OPENAI_API_KEY"),
+            base_url=os.getenv("OPENAI_BASE_URL"),
+        )
+
+    report_text, _prompt, reasoning_summary = await generate_report(
+        client, rubric_data, model=args.model, effort=args.effort
+    )
+
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    output_path.write_text(report_text)
+    logger.info(f"Wrote report to {output_path}")
+
+    if reasoning_summary:
+        logger.info(f"Reasoning summary: {reasoning_summary}")
+
+
+if __name__ == "__main__":
+    asyncio.run(async_main())

tasks/d1-i1-imageslowload-on-02-medium_ttd60m_range30m_off+10m/solution/solve.sh

@@ -0,0 +1,28 @@
+#!/bin/bash
+set -euo pipefail
+
+# ── Wait for the entrypoint to finish setting up the environment ──
+echo "[solve] Waiting for environment to be ready..."
+for i in $(seq 1 180); do
+    [ -f /tmp/env-ready ] && break
+    sleep 1
+done
+if [ ! -f /tmp/env-ready ]; then
+    echo "[solve] ERROR: Environment did not become ready within 180s" >&2
+    exit 1
+fi
+echo "[solve] Environment is ready."
+
+# ── Verify all services are healthy ──
+echo "[solve] Running health checks..."
+source /tmp/env-ports
+/app/check_health.sh || {
+    echo "[solve] ERROR: Health checks failed" >&2
+    exit 1
+}
+
+# ── Generate solution report via LLM ──
+echo "[solve] Installing dependencies..."
+pip install tabulate
+echo "[solve] Generating report..."
+python /solution/solve.py --rubric /solution/rubric.json

tasks/d1-i1-imageslowload-on-02-medium_ttd60m_range30m_off+10m/tests/check_prediction.py

@@ -0,0 +1,1005 @@
+"""LLM-as-a-judge verifier for Harbor incident-RCA-report tasks.
+
+Supports two modes:
+
+1. **Harbor verifier** (default):
+       python /tests/check_prediction.py
+
+2. **Post-hoc single-trial**:
+       python check_prediction.py --expected expected.json --predictions report.md [--rubric rubric.json]
+
+Falls back to string-match scoring when OPENAI_API_KEY is not set.
+"""
+
+import argparse
+import asyncio
+import json
+import logging
+import os
+import sys
+import traceback
+from pathlib import Path
+from typing import Any
+
+from tabulate import tabulate
+
+logger = logging.getLogger(__name__)
+
+JUDGE_PROMPT_MULTI_HEADER = """\
+You are an expert SRE tasked with judging the quality of an AI-generated incident RCA report.
+
+You are given:
+1. **One or more** ground-truth rubrics. Each describes a plausible root cause, its incident time, mechanism, and symptoms. Several flags may have been active in the same window; the agent is credited if it correctly identifies **any one** of these rubrics.
+2. The SRE agent's incident RCA report.
+
+## SRE Agent's Incident RCA Report
+
+{predictions}
+
+## Ground-Truth Rubrics
+
+{rubrics}
+
+## Evaluation Questions
+
+For **each rubric** in order, answer every question with true or false. Base your answer only on evidence in the agent's report; if the report does not cite the required evidence, answer false. The output must contain one entry per rubric, in the same order, and must preserve cluster order within each rubric exactly as listed.
+
+For each rubric:
+
+- `incident_time_within_10min`: Did the agent's timeline place the incident start within ±10 minutes of this rubric's `incident_time`?
+- `feature_flag_match`: Did the agent identify this rubric's feature flag as a root cause? (The agent may name multiple flags; mark true if this flag is among them.)
+- `mechanism_match`: Did the agent correctly explain this rubric's mechanism — how the flag propagates to the user-visible failure?
+- For each metric/log/trace cluster listed for this rubric: per-cluster match flags as before.
+"""
+
+JUDGE_PROMPT_SCORING_FOOTER = """\
+
+## Overall Score
+
+Score the incident RCA report on a scale of 0 to 3. The agent is credited if it correctly identifies **any one** of the listed rubrics — score against the rubric the agent's report best matches. Scoring is based on content correctness only; do not penalize or reward for formatting, prose style, or structural polish. Materially incorrect or misleading claims count against the score: if the report would otherwise score N but also adds a materially wrong claim (e.g., invents an unrelated additional cause), drop to N-1 (floor at 0). A report that correctly identifies one root cause but introduces a misleading fabrication alongside it therefore scores 2, not 3. When applying this penalty, explicitly identify in your reasoning which specific claim is materially wrong — quote or paraphrase the offending text. Do not apply the penalty without naming the offending claim; missing detail or incomplete explanation does not qualify as a materially wrong claim. Naming several of the listed plausible root causes is **not** a materially wrong claim.
+
+- 0: AI findings are misaligned with every rubric's mechanism and completely miss the root cause
+- 1: AI verifies incident description — the report confirms symptoms described in the task prompt but does not investigate further
+- 2: AI makes correct progress beyond symptoms — the report identifies some of the ground-truth metrics, logs, or traces for at least one rubric and moves toward that root cause, but does not fully identify any single root cause
+- 3: AI nails at least one of the listed root causes — the report correctly identifies it, the mechanism, and the supporting signals
+
+Respond with ONLY a JSON object matching the provided output schema.
+"""
+
+DEFAULT_MODEL = "openai-gpt-5.4"
+
+
+# ---------------------------------------------------------------------------
+# Rubric rendering (JSON -> markdown)
+# ---------------------------------------------------------------------------
+
+
+def _format_log_clusters(clusters: list[dict], lines: list[str]) -> None:
+    """Render log clusters as markdown subsections."""
+    for cluster in clusters:
+        name = cluster.get("name", "Unknown")
+        count = cluster.get("count")
+        suffix = f" ({count} entries)" if count is not None else ""
+        lines.append(f"#### {name}{suffix}")
+        lines.append("")
+
+        description = cluster.get("description", "")
+        if description:
+            lines.append(description)
+            lines.append("")
+
+        cause = cluster.get("cause", "")
+        if cause:
+            lines.append(f"**Cause:** {cause}")
+            lines.append("")
+
+        source = cluster.get("source", "")
+        if source:
+            lines.append(f"**Source:** {source}")
+            lines.append("")
+
+        attrs = cluster.get("representative_attributes", {})
+        if attrs:
+            lines.append("**Representative attributes:**")
+            lines.append("")
+            rows = [[f"`{k}`", f"`{v}`"] for k, v in attrs.items()]
+            lines.append(tabulate(rows, headers=["Field", "Value"], tablefmt="github"))
+            lines.append("")
+
+        docs = cluster.get("log_documents", [])
+        if docs:
+            lines.append("**Log documents:**")
+            lines.append("")
+            rows = [
+                [f"`{d['_index']}`", f"`{d['_id']}`", d["@timestamp"]] for d in docs
+            ]
+            lines.append(
+                tabulate(
+                    rows, headers=["_index", "_id", "@timestamp"], tablefmt="github"
+                )
+            )
+            lines.append("")
+
+
+def _format_trace_clusters(clusters: list[dict], lines: list[str]) -> None:
+    """Render trace clusters as markdown subsections."""
+    for cluster in clusters:
+        name = cluster.get("name", "Unknown")
+        count = cluster.get("count")
+        suffix = f" ({count} traces)" if count is not None else ""
+        lines.append(f"#### {name}{suffix}")
+        lines.append("")
+
+        description = cluster.get("description", "")
+        if description:
+            lines.append(description)
+            lines.append("")
+
+        cause = cluster.get("cause", "")
+        if cause:
+            lines.append(f"**Cause:** {cause}")
+            lines.append("")
+
+        call_chain = cluster.get("call_chain", "")
+        if call_chain:
+            lines.append("**Call chain:**")
+            lines.append("")
+            lines.append("```")
+            lines.append(call_chain)
+            lines.append("```")
+            lines.append("")
+
+        smoking_gun = cluster.get("smoking_gun", [])
+        if smoking_gun:
+            lines.append("**Smoking-gun error messages:**")
+            lines.append("")
+            for msg in smoking_gun:
+                lines.append(f"- {msg}")
+            lines.append("")
+
+        docs = cluster.get("trace_documents", [])
+        if docs:
+            lines.append("**Trace documents:**")
+            lines.append("")
+            headers = ["traceID", "@timestamp"]
+            has_action = any("user_action" in d for d in docs)
+            if has_action:
+                headers.append("user_action")
+            rows = []
+            for d in docs:
+                row = [f"`{d['traceID']}`", d["@timestamp"]]
+                if has_action:
+                    row.append(d.get("user_action", ""))
+                rows.append(row)
+            lines.append(tabulate(rows, headers=headers, tablefmt="github"))
+            lines.append("")
+
+
+_LAYER_DESCRIPTIONS = {
+    "root_cause": "metric closest to the fault injection point",
+    "propagation": "intermediate services reflecting the error through the call chain",
+    "symptom": "user-facing impact visible to end users or clients",
+    "meta": "feature flag counters or internal plumbing",
+    "unknown": "unclassified",
+}
+
+_LAYER_ORDER = ["root_cause", "propagation", "symptom", "meta", "unknown"]
+
+
+def _format_onset(offset: int | None) -> str:
+    """Format an onset offset as '+Xs' or 'N/A'."""
+    if offset is None:
+        return "N/A"
+    return f"+{offset}s"
+
+
+def _format_label_values(labels: dict[str, str]) -> str:
+    """Format label values as a compact comma-separated string."""
+    if not labels:
+        return ""
+    return ", ".join(labels.values())
+
+
+def _earliest_onset(variants: list[dict]) -> int | None:
+    """Return the earliest onset_offset_seconds across variants, or None."""
+    offsets = [
+        v["onset_offset_seconds"]
+        for v in variants
+        if v.get("onset_offset_seconds") is not None
+    ]
+    return min(offsets) if offsets else None
+
+
+def _format_metrics_list(metrics_list: list[dict], lines: list[str]) -> None:
+    """Render metric families grouped by signal layer."""
+    by_layer: dict[str, list[dict]] = {}
+    for fam in metrics_list:
+        by_layer.setdefault(fam.get("signal_layer", "unknown"), []).append(fam)
+
+    for layer in _LAYER_ORDER:
+        layer_families = by_layer.get(layer, [])
+        if not layer_families:
+            continue
+
+        layer_onsets = [_earliest_onset(f["variants"]) for f in layer_families]
+        layer_onsets = [o for o in layer_onsets if o is not None]
+        layer_onset_str = (
+            f" (earliest onset: {_format_onset(min(layer_onsets))})"
+            if layer_onsets
+            else ""
+        )
+
+        display_layer = layer.replace("_", " ").title()
+        desc = _LAYER_DESCRIPTIONS.get(layer, "")
+        lines.append(f"**{display_layer}** — {desc}{layer_onset_str}")
+        lines.append("")
+
+        for fam in layer_families:
+            fam_onset = _earliest_onset(fam["variants"])
+            label_vals = _format_label_values(fam.get("defining_labels", {}))
+            label_part = f" ({label_vals})" if label_vals else ""
+            lines.append(
+                f"#### {fam['metric_family']} family{label_part}"
+                f" — onset: {_format_onset(fam_onset)}"
+            )
+            lines.append("")
+
+            first_desc = (
+                fam["variants"][0].get("description", "") if fam["variants"] else ""
+            )
+            if first_desc:
+                lines.append(first_desc)
+                lines.append("")
+
+            for v in fam["variants"]:
+                v_onset = _format_onset(v.get("onset_offset_seconds"))
+                lines.append(f"- **{v['type']}** (onset: {v_onset})")
+                lines.append(f"  `{v['query']}`")
+                lines.append("")
+
+
+def _format_frontend_issues(issues: list[dict], lines: list[str]) -> None:
+    """Render frontend issues as markdown subsections."""
+    for issue in issues:
+        route = issue.get("route", "Unknown route")
+        lines.append(f"#### {route}")
+        lines.append("")
+
+        description = issue.get("description", "")
+        if description:
+            lines.append(description)
+            lines.append("")
+
+        rows = [
+            ["Deterministic", str(issue.get("deterministic", ""))],
+            ["Trigger condition", issue.get("trigger_condition", "")],
+            ["Calling service", issue.get("calling_service", "")],
+            [
+                "Source",
+                f"`{issue.get('source_file', '')}:{issue.get('source_line', '')}`",
+            ],
+        ]
+        lines.append(tabulate(rows, headers=["Field", "Value"], tablefmt="github"))
+        lines.append("")
+
+        call_pattern = issue.get("call_pattern", "")
+        if call_pattern:
+            lines.append(f"**Call pattern:** {call_pattern}")
+            lines.append("")
+
+        cause = issue.get("cause", "")
+        if cause:
+            lines.append(f"**Cause:** {cause}")
+            lines.append("")
+
+
+def format_rubric(data: dict, include_frontend: bool = False) -> str:
+    """Convert a rubric JSON dict into a consistently formatted markdown string.
+
+    Args:
+        data: The rubric JSON dict.
+        include_frontend: If True, include the ``### Frontend`` section.
+            Defaults to False since frontend symptoms may be noisy for
+            downstream consumers (LLM judge, oracle solutions).
+            TODO(Albert): systematically test the impact of including vs.
+            excluding frontend symptoms on downstream consumers.
+
+    """
+    lines: list[str] = []
+
+    lines.append(f"# {data['feature_flag']}")
+    lines.append("")
+    lines.append(f"**Feature flag:** `{data['feature_flag']}`")
+    lines.append("")
+    lines.append(f"**Description:** {data['description']}")
+    lines.append("")
+    lines.append(f"**Incident time:** {data['incident_time']}")
+    lines.append("")
+
+    lines.append("## Mechanism")
+    lines.append("")
+    lines.append(data["mechanism"])
+    lines.append("")
+
+    interaction = data.get("interaction", "")
+    if interaction:
+        lines.append(f"**Interaction with other feature flags:** {interaction}")
+        lines.append("")
+
+    lines.append("## Evidence")
+    lines.append("")
+
+    gs = data["symptoms"]
+
+    metrics = gs.get("metrics", [])
+    lines.append("### Metrics")
+    lines.append("")
+    if metrics:
+        _format_metrics_list(metrics, lines)
+
+    logs = gs.get("logs", [])
+    lines.append("### Logs")
+    lines.append("")
+    if logs:
+        _format_log_clusters(logs, lines)
+
+    if include_frontend:
+        frontend = gs.get("frontend", [])
+        lines.append("### Frontend")
+        lines.append("")
+        if frontend:
+            _format_frontend_issues(frontend, lines)
+
+    traces = gs.get("traces", [])
+    lines.append("### Traces")
+    lines.append("")
+    if traces:
+        _format_trace_clusters(traces, lines)
+
+    return "\n".join(lines)
+
+
+# ---------------------------------------------------------------------------
+# Judge prompt + output-schema builders
+# ---------------------------------------------------------------------------
+
+
+def _render_checklist(rubric_data: dict) -> str:
+    """Build per-cluster checklist blocks for metrics/logs/traces."""
+    symptoms = rubric_data.get("symptoms", {}) or {}
+    metric_clusters = symptoms.get("metrics", []) or []
+    log_clusters = symptoms.get("logs", []) or []
+    trace_clusters = symptoms.get("traces", []) or []
+
+    blocks: list[str] = []
+
+    if metric_clusters:
+        lines = ["#### Metric clusters"]
+        for i, m in enumerate(metric_clusters):
+            family = m.get("metric_family", "")
+            lines.append(
+                f'- Cluster {i}: `metric_family = "{family}"`'
+                f" — family_match: did the agent cite a query targeting"
+                f" metric_family `{family}` under a Why-step whose causal chain"
+                f" aligns with the rubric?"
+            )
+        blocks.append("\n".join(lines))
+
+    if log_clusters:
+        lines = ["#### Log clusters"]
+        for i, log in enumerate(log_clusters):
+            attrs = log.get("representative_attributes") or {}
+            body = attrs.get("body", "")
+            service_name = attrs.get("resource.service.name", "")
+            lines.append(
+                f"- Cluster {i}:\n"
+                f"  - `resource.service.name`: `{service_name}`\n"
+                f"  - `body`: `{body}`\n"
+                f"  - body_match: did the agent cite log evidence whose body"
+                f" matches the rubric's `body` under a Why-step whose causal"
+                f" chain aligns with the rubric?\n"
+                f"  - service_name_match: did the agent attribute the cited"
+                f" log evidence to the OTel service `{service_name}`"
+                f" (`resource.service.name`)?"
+            )
+        blocks.append("\n".join(lines))
+
+    if trace_clusters:
+        lines = ["#### Trace clusters"]
+        for i, trace in enumerate(trace_clusters):
+            call_chain = trace.get("call_chain", "")
+            smoking_gun = trace.get("smoking_gun", []) or []
+            sg_rendered = "\n".join(f"    - {s}" for s in smoking_gun)
+            lines.append(
+                f"- Cluster {i}:\n"
+                f"  - call_chain: `{call_chain}`\n"
+                f"  - smoking_gun:\n{sg_rendered}\n"
+                f"  - call_chain_match: did the agent cite evidence matching"
+                f" this service-level call chain under a Why-step whose causal"
+                f" chain aligns with the rubric?\n"
+                f"  - smoking_gun_match: did the agent cite at least one of"
+                f" the listed smoking-gun signals?"
+            )
+        blocks.append("\n".join(lines))
+
+    return (
+        "\n\n".join(blocks)
+        if blocks
+        else "(No metric, log, or trace clusters in rubric.)"
+    )
+
+
+def build_judge_prompt(
+    rubrics_data: list[dict],
+    predictions: str,
+) -> str:
+    """Render the judge prompt for one or more ground-truth rubrics.
+
+    The prompt asks the LLM to evaluate the agent's report against **each**
+    rubric independently. The agent is credited if it correctly identifies
+    any one rubric (the overall score reflects the best match).
+    """
+    if not rubrics_data:
+        raise ValueError("build_judge_prompt called with no rubrics")
+
+    rubric_blocks: list[str] = []
+    checklist_blocks: list[str] = []
+    for i, rubric in enumerate(rubrics_data):
+        feature_flag = rubric.get("feature_flag", "")
+        rubric_blocks.append(
+            f"### Rubric {i + 1} of {len(rubrics_data)} — `{feature_flag}`\n\n"
+            + format_rubric(rubric)
+        )
+        checklist_blocks.append(
+            f"### Rubric {i + 1} of {len(rubrics_data)} — `{feature_flag}`\n\n"
+            + _render_checklist(rubric)
+        )
+
+    rubrics_text = "\n\n---\n\n".join(rubric_blocks)
+    checklist_text = "\n\n---\n\n".join(checklist_blocks)
+
+    header = JUDGE_PROMPT_MULTI_HEADER.format(
+        rubrics=rubrics_text,
+        predictions=predictions,
+    )
+    return header + "\n" + checklist_text + "\n" + JUDGE_PROMPT_SCORING_FOOTER
+
+
+_METRIC_ITEM_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        "metric_family": {"type": "string"},
+        "family_match": {"type": "boolean"},
+    },
+    "required": ["metric_family", "family_match"],
+    "additionalProperties": False,
+}
+
+_LOG_ITEM_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        "body_match": {"type": "boolean"},
+        "service_name_match": {"type": "boolean"},
+    },
+    "required": ["body_match", "service_name_match"],
+    "additionalProperties": False,
+}
+
+_TRACE_ITEM_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        "call_chain_match": {"type": "boolean"},
+        "smoking_gun_match": {"type": "boolean"},
+    },
+    "required": ["call_chain_match", "smoking_gun_match"],
+    "additionalProperties": False,
+}
+
+
+_PER_RUBRIC_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        "feature_flag": {"type": "string"},
+        "incident_time_within_10min": {"type": "boolean"},
+        "feature_flag_match": {"type": "boolean"},
+        "mechanism_match": {"type": "boolean"},
+        "symptoms": {
+            "type": "object",
+            "properties": {
+                "metrics": {"type": "array", "items": _METRIC_ITEM_SCHEMA},
+                "logs": {"type": "array", "items": _LOG_ITEM_SCHEMA},
+                "traces": {"type": "array", "items": _TRACE_ITEM_SCHEMA},
+            },
+            "required": ["metrics", "logs", "traces"],
+            "additionalProperties": False,
+        },
+    },
+    "required": [
+        "feature_flag",
+        "incident_time_within_10min",
+        "feature_flag_match",
+        "mechanism_match",
+        "symptoms",
+    ],
+    "additionalProperties": False,
+}
+
+
+def build_judge_output_schema(rubrics_data: list[dict]) -> dict:
+    """Build a strict JSON Schema for the judge output: one verdict per rubric
+    + an overall ``score`` integer. Falls back to a minimal ``{score: int}``
+    schema when no rubrics are supplied (no-incident path).
+
+    Per-rubric cluster-array lengths vary across rubrics; rather than encode
+    a per-element schema (which Structured Outputs doesn't support), we leave
+    the array lengths unconstrained and rely on the prompt instructions to
+    keep cluster order matching.
+    """
+    if not rubrics_data:
+        return {
+            "type": "object",
+            "properties": {"score": {"type": "integer"}},
+            "required": ["score"],
+            "additionalProperties": False,
+        }
+
+    n = len(rubrics_data)
+    return {
+        "type": "object",
+        "properties": {
+            "rubrics": {
+                "type": "array",
+                "minItems": n,
+                "maxItems": n,
+                "items": _PER_RUBRIC_SCHEMA,
+            },
+            "score": {"type": "integer"},
+        },
+        "required": ["rubrics", "score"],
+        "additionalProperties": False,
+    }
+
+
+# ---------------------------------------------------------------------------
+# API call
+# ---------------------------------------------------------------------------
+
+
+async def async_call_llm_judge(
+    client: Any,
+    prompt: str,
+    model: str = DEFAULT_MODEL,
+    reasoning_effort: str | None = None,
+    output_schema: dict | None = None,
+) -> tuple[str, list[dict] | None]:
+    """Call the LLM judge via the OpenAI Responses API (falling back to Chat).
+
+    When ``output_schema`` is provided, uses Structured Outputs (strict JSON
+    Schema) so the returned text is guaranteed to conform to the schema.
+
+    Returns:
+        A tuple of (output_text, reasoning_summaries). reasoning_summaries is
+        None when reasoning_effort is not set.
+
+    """
+    text_format: dict[str, Any] = (
+        {
+            "type": "json_schema",
+            "name": "judge_response",
+            "schema": output_schema,
+            "strict": True,
+        }
+        if output_schema is not None
+        else {"type": "text"}
+    )
+    try:
+        kwargs: dict[str, Any] = {
+            "model": model,
+            "input": prompt,
+            "text": {"format": text_format},
+            "tools": [],
+            "store": True,
+            "max_output_tokens": 16384,
+        }
+        if reasoning_effort is not None:
+            kwargs["reasoning"] = {"effort": reasoning_effort, "summary": "auto"}
+        response = await client.responses.create(**kwargs)
+        reasoning_summaries = None
+        if reasoning_effort is not None:
+            reasoning_summaries = [
+                [
+                    s.model_dump() if hasattr(s, "model_dump") else s
+                    for s in item.summary
+                ]
+                for item in response.output
+                if getattr(item, "type", None) == "reasoning"
+                and getattr(item, "summary", None) is not None
+            ]
+        return response.output_text, reasoning_summaries
+    except Exception as exc:
+        if "404" not in str(exc):
+            raise
+        logger.info(
+            f"Responses API returned 404 for {model}, falling back to Chat Completions"
+        )
+        chat_kwargs: dict[str, Any] = {
+            "model": model,
+            "messages": [{"role": "user", "content": prompt}],
+            "max_tokens": 16384,
+        }
+        if output_schema is not None:
+            chat_kwargs["response_format"] = {
+                "type": "json_schema",
+                "json_schema": {
+                    "name": "judge_response",
+                    "schema": output_schema,
+                    "strict": True,
+                },
+            }
+        if reasoning_effort is not None:
+            chat_kwargs["reasoning_effort"] = reasoning_effort
+        response = await client.chat.completions.create(**chat_kwargs)
+        reasoning_summaries = None
+        if reasoning_effort is not None:
+            reasoning_content = getattr(
+                response.choices[0].message, "reasoning_content", None
+            )
+            if reasoning_content is not None:
+                reasoning_summaries = [{"type": "text", "text": reasoning_content}]
+            else:
+                reasoning_summaries = []
+        return response.choices[0].message.content, reasoning_summaries
+
+
+# ---------------------------------------------------------------------------
+# Parsing + aggregation
+# ---------------------------------------------------------------------------
+
+
+def parse_judge_response(response_text: str) -> dict:
+    """Parse the judge response JSON and range-check ``score``.
+
+    When Structured Outputs are used upstream, the response is already
+    schema-validated; this function only decodes the JSON and enforces the
+    0-3 range for ``score``.
+    """
+    parsed = json.loads(response_text)
+    score = int(parsed["score"])
+    if score < 0 or score > 3:
+        raise ValueError(f"Score {score} out of range [0, 3]")
+    parsed["score"] = score
+    return parsed
+
+
+def _aggregate_one_rubric(verdict: dict) -> dict:
+    """Roll up cluster verdicts for a single per-rubric judge entry."""
+    symptoms = verdict.get("symptoms", {}) or {}
+    metrics = symptoms.get("metrics", []) or []
+    logs = symptoms.get("logs", []) or []
+    traces = symptoms.get("traces", []) or []
+
+    metric_hits = [bool(m.get("family_match")) for m in metrics]
+    log_hits = [
+        bool(l.get("body_match")) and bool(l.get("service_name_match")) for l in logs
+    ]
+    trace_hits = [
+        bool(t.get("call_chain_match")) and bool(t.get("smoking_gun_match"))
+        for t in traces
+    ]
+
+    def _all(hits: list[bool]) -> bool | None:
+        return all(hits) if hits else None
+
+    def _any(hits: list[bool]) -> bool | None:
+        return any(hits) if hits else None
+
+    return {
+        "feature_flag": verdict.get("feature_flag", ""),
+        "incident_time_within_10min": bool(verdict.get("incident_time_within_10min")),
+        "feature_flag_match": bool(verdict.get("feature_flag_match")),
+        "mechanism_match": bool(verdict.get("mechanism_match")),
+        "metrics_all_match": _all(metric_hits),
+        "metrics_any_match": _any(metric_hits),
+        "logs_all_match": _all(log_hits),
+        "logs_any_match": _any(log_hits),
+        "traces_all_match": _all(trace_hits),
+        "traces_any_match": _any(trace_hits),
+    }
+
+
+def aggregate_judge_response(parsed: dict) -> dict:
+    """Aggregate per-rubric, per-cluster verdicts into flat any-of rollups.
+
+    The agent is credited if it matches any one of the listed rubrics.
+    Per-rubric rollups are computed via ``_aggregate_one_rubric``; the
+    task-level rollup is the ``any`` over rubrics for booleans (with ``None``
+    skipped — sections without clusters in any rubric stay ``None``).
+
+    The per-rubric rollups are also returned under ``per_rubric`` for
+    downstream analysis that needs to know which specific rubric matched.
+    """
+    rubrics = parsed.get("rubrics") or []
+    per_rubric = [_aggregate_one_rubric(r) for r in rubrics]
+
+    def _any_skip_none(values: list[bool | None]) -> bool | None:
+        truthy = [v for v in values if v is not None]
+        return any(truthy) if truthy else None
+
+    return {
+        "incident_time_within_10min": _any_skip_none(
+            [r["incident_time_within_10min"] for r in per_rubric]
+        )
+        or False,
+        "feature_flag_match": _any_skip_none(
+            [r["feature_flag_match"] for r in per_rubric]
+        )
+        or False,
+        "mechanism_match": _any_skip_none([r["mechanism_match"] for r in per_rubric])
+        or False,
+        "metrics_all_match": _any_skip_none(
+            [r["metrics_all_match"] for r in per_rubric]
+        ),
+        "metrics_any_match": _any_skip_none(
+            [r["metrics_any_match"] for r in per_rubric]
+        ),
+        "logs_all_match": _any_skip_none([r["logs_all_match"] for r in per_rubric]),
+        "logs_any_match": _any_skip_none([r["logs_any_match"] for r in per_rubric]),
+        "traces_all_match": _any_skip_none([r["traces_all_match"] for r in per_rubric]),
+        "traces_any_match": _any_skip_none([r["traces_any_match"] for r in per_rubric]),
+        "per_rubric": per_rubric,
+        "score": int(parsed["score"]),
+    }
+
+
+def string_match_fallback(expected: dict, predictions: str) -> dict:
+    """Fall back to case-insensitive string search for any plausible root_cause.
+
+    ``expected["events"]`` is a list of ``{"root_cause": <flag>, "event_time": ...}``;
+    the agent's report is credited if any listed root_cause appears in it.
+    Returns a result dict compatible with the judge output format.
+    """
+    events: list[dict] = expected.get("events") or []
+    if not events:
+        # No-incident task: agent should write an empty report.
+        return {"score": 3 if len(predictions.strip()) == 0 else 0}
+    text = predictions.lower()
+    found = any(e["root_cause"].strip().lower() in text for e in events)
+    return {"score": 3 if found else 0}
+
+
+# ---------------------------------------------------------------------------
+# Judge entry point (used by both modes)
+# ---------------------------------------------------------------------------
+
+
+async def judge(
+    client: Any,
+    expected: dict,
+    predictions: str,
+    rubrics_data: list[dict],
+    model: str = DEFAULT_MODEL,
+    reasoning_effort: str | None = None,
+) -> dict:
+    """Run the LLM judge over one or more ground-truth rubrics, or
+    short-circuit for no-incident tasks.
+
+    Returns:
+        A dict with keys: reward, mode, score, and (for LLM judge) model,
+        nested (raw judge response), reasoning_summary, rubric_used,
+        judge_prompt, judge_response_raw. Per-section rollups are derived
+        post-hoc from ``nested`` by formatters via ``aggregate_judge_response``.
+
+    """
+    events: list[dict] = expected.get("events") or []
+    if not events:
+        score = 3 if len(predictions.strip()) == 0 else 0
+        return {
+            "reward": score / 3.0,
+            "mode": "no_incident",
+            "model": model,
+            "score": score,
+        }
+
+    # Short-circuit when the agent emitted an empty report despite an incident.
+    # No LLM call can rescue this; score is a guaranteed 0. We synthesize the
+    # nested response shape (per-rubric all False, matching cluster counts)
+    # so that ``aggregate_judge_response`` produces the expected all-False
+    # rollups at load time.
+    if not predictions.strip():
+        synthetic_per_rubric = []
+        for rubric in rubrics_data:
+            symptoms = rubric.get("symptoms", {}) or {}
+            synthetic_per_rubric.append(
+                {
+                    "feature_flag": rubric.get("feature_flag", ""),
+                    "incident_time_within_10min": False,
+                    "feature_flag_match": False,
+                    "mechanism_match": False,
+                    "symptoms": {
+                        "metrics": [
+                            {
+                                "metric_family": m.get("metric_family", ""),
+                                "family_match": False,
+                            }
+                            for m in (symptoms.get("metrics") or [])
+                        ],
+                        "logs": [
+                            {"body_match": False, "service_name_match": False}
+                            for _ in (symptoms.get("logs") or [])
+                        ],
+                        "traces": [
+                            {"call_chain_match": False, "smoking_gun_match": False}
+                            for _ in (symptoms.get("traces") or [])
+                        ],
+                    },
+                }
+            )
+        return {
+            "mode": "empty_report",
+            "model": model,
+            "score": 0,
+            "reward": 0.0,
+            "rubric_used": bool(rubrics_data),
+            "nested": {"rubrics": synthetic_per_rubric, "score": 0},
+        }
+
+    prompt = build_judge_prompt(rubrics_data, predictions)
+    output_schema = build_judge_output_schema(rubrics_data)
+
+    raw_response, reasoning_summary = await async_call_llm_judge(
+        client,
+        prompt,
+        model=model,
+        reasoning_effort=reasoning_effort,
+        output_schema=output_schema,
+    )
+    parsed = parse_judge_response(raw_response)
+
+    # Per-section rollups are NOT spread into the result — they're a pure
+    # post-hoc derivation from ``nested`` via ``aggregate_judge_response``,
+    # applied by the formatters at load time so schema changes don't require
+    # rewriting saved JSONs.
+    return {
+        "mode": "llm_judge",
+        "model": model,
+        "score": parsed["score"],
+        "reward": parsed["score"] / 3.0,
+        "reasoning_summary": reasoning_summary,
+        "rubric_used": bool(rubrics_data),
+        "judge_prompt": prompt,
+        "judge_response_raw": raw_response,
+        "nested": parsed,
+    }
+
+
+# ---------------------------------------------------------------------------
+# CLI
+# ---------------------------------------------------------------------------
+
+
+async def main() -> None:
+    """Entry point: load expected + predictions, score, write reward/details."""
+    parser = argparse.ArgumentParser(
+        description="LLM-as-a-judge verifier for Harbor incident-RCA-report tasks."
+    )
+    parser.add_argument("--expected", type=str, default="/tests/expected.json")
+    parser.add_argument("--predictions", type=str, default="/app/report.md")
+    parser.add_argument(
+        "--rubrics-dir",
+        type=str,
+        default="/tests/rubrics",
+        help=(
+            "Directory containing one rubric JSON per plausible root cause "
+            "(e.g. /tests/rubrics/<event_id>.json). The judge scores the "
+            "agent against any one of them."
+        ),
+    )
+    parser.add_argument(
+        "--model", type=str, default=DEFAULT_MODEL, help="Judge LLM model name."
+    )
+    parser.add_argument(
+        "--effort",
+        type=str,
+        choices=["low", "medium", "high"],
+        default="high",
+        help="Reasoning effort level for the judge LLM (default: high).",
+    )
+    parser.add_argument(
+        "--mode",
+        type=str,
+        choices=["string_match", "llm_judge"],
+        default="string_match",
+        help="Scoring mode: string_match or llm_judge (default: string_match).",
+    )
+    parser.add_argument("--reward", type=str, default="/logs/verifier/reward.txt")
+    parser.add_argument("--details", type=str, default="/logs/verifier/details.json")
+    args = parser.parse_args()
+
+    expected_path = Path(args.expected)
+    predictions_path = Path(args.predictions)
+    rubrics_dir = Path(args.rubrics_dir)
+    reward_path = Path(args.reward)
+    details_path = Path(args.details)
+
+    try:
+        # Load expected
+        print(f"Loading expected results from {expected_path}...")
+        with expected_path.open() as f:
+            expected = json.load(f)
+
+        # Load predictions (markdown report)
+        print(f"Loading predictions from {predictions_path}...")
+        predictions = predictions_path.read_text()
+
+        # Load rubric JSONs — one per plausible root cause. Order is the
+        # filesystem sort order, which matches the build_harbor_tasks.py
+        # naming convention (event_id stems sort lexicographically).
+        rubrics_data: list[dict] = []
+        if expected.get("events"):
+            if rubrics_dir.is_dir():
+                rubric_paths = sorted(rubrics_dir.glob("*.json"))
+                for p in rubric_paths:
+                    with p.open() as f:
+                        rubrics_data.append(json.load(f))
+                print(f"Loaded {len(rubrics_data)} rubric(s) from {rubrics_dir}")
+            else:
+                print(f"Rubric directory missing: {rubrics_dir}")
+        else:
+            print("No incident events in expected results; skipping rubric load.")
+
+        # Run judge
+        if args.mode == "string_match":
+            em = string_match_fallback(expected, predictions)
+            result = {"reward": em["score"] / 3.0, "mode": "string_match", **em}
+        else:
+            from openai import AsyncOpenAI
+
+            client = AsyncOpenAI(
+                api_key=os.getenv("OPENAI_API_KEY"),
+                base_url=os.getenv("OPENAI_BASE_URL"),
+            )
+            result = await judge(
+                client,
+                expected,
+                predictions,
+                rubrics_data,
+                model=args.model,
+                reasoning_effort=args.effort,
+            )
+
+        # Write reward
+        reward_path.parent.mkdir(parents=True, exist_ok=True)
+        reward_path.write_text(str(result["reward"]))
+
+        # Write details
+        details_path.parent.mkdir(parents=True, exist_ok=True)
+        details_path.write_text(json.dumps(result, indent=2))
+
+        print(f"Score: {result.get('score', 'N/A')}/3 (reward: {result['reward']})")
+        print(f"Mode: {result['mode']}")
+        if result.get("reasoning_summary"):
+            print(f"Reasoning summary: {result['reasoning_summary']}")
+
+        if result["reward"] < 1.0:
+            sys.exit(1)
+
+    except Exception as exc:
+        reward_path.parent.mkdir(parents=True, exist_ok=True)
+        reward_path.write_text("0.0")
+        details_path.parent.mkdir(parents=True, exist_ok=True)
+        details_path.write_text(
+            json.dumps(
+                {
+                    "reward": 0.0,
+                    "error": f"{type(exc).__name__}: {exc}",
+                    "traceback": traceback.format_exc(),
+                },
+                indent=2,
+            )
+        )
+        print(f"Verifier error: {type(exc).__name__}: {exc}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

tasks/d1-i1-imageslowload-on-02-medium_ttd60m_range30m_off+10m/tests/expected.json

@@ -0,0 +1,9 @@
+{
+  "events": [
+    {
+      "event_id": "d1-i1-imageSlowLoad-on",
+      "root_cause": "imageSlowLoad",
+      "event_time": "2026-04-19T14:01:51.404464+00:00"
+    }
+  ]
+}

tasks/d1-i1-imageslowload-on-02-medium_ttd60m_range30m_off+10m/tests/rubrics/d1-i1-imageSlowLoad-on.json

@@ -0,0 +1,24 @@
+{
+  "incident_time": "2026-04-19T14:01:51.404464+00:00",
+  "feature_flag": "imageSlowLoad",
+  "description": "A feature flag in the frontend `ProductCard` React component added an `x-envoy-fault-delay-request` header (plus `Cache-Control: no-cache`) to every product-image fetch; Envoy honored the fault-injection header and artificially delayed each `GET /images/products/<picture>` response, so product thumbnails took seconds to render.",
+  "mechanism": "The flag is read in [`ProductCard.tsx#L32`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L32): the `ProductCard` React component calls `useNumberFlagValue('imageSlowLoad', 0)` to get the delay value in milliseconds (variants: `0` for off, `5000` for 5 sec, `10000` for 10 sec). When non-zero, the component sets the `x-envoy-fault-delay-request` header to the flag value on every product image fetch ([`ProductCard.tsx#L37`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L37)).\n\nThe image request is sent to `/images/products/<picture>`, which the frontend-proxy Envoy routes to the `image-provider` cluster ([`envoy.tmpl.yaml#L54-L55`](../../opentelemetry-demo/src/frontend-proxy/envoy.tmpl.yaml#L54)). Envoy's `envoy.filters.http.fault` filter is configured with `header_delay: {}` and 100% percentage ([`envoy.tmpl.yaml#L67-L74`](../../opentelemetry-demo/src/frontend-proxy/envoy.tmpl.yaml#L67)), meaning it honors the `x-envoy-fault-delay-request` header and injects the specified delay (in ms) before forwarding the request. Every product card image load is therefore delayed by the flag value (e.g. 5 or 10 seconds), causing the page to render with blank/loading images until the delayed responses arrive.",
+  "symptoms": {
+    "metrics": [],
+    "logs": [],
+    "frontend": [
+      {
+        "description": "Product card thumbnails on the homepage product grid (and the recommendations carousel on product/cart/checkout pages) render with a blank image placeholder for ~5 seconds before the actual thumbnail appears. The page text and layout render immediately; only the images are delayed. Affects every product card on every page load while the flag is on — the failure is silent slowness, not a visible error.",
+        "route": "GET /images/products/<picture>",
+        "deterministic": true,
+        "trigger_condition": "Every page load that renders a `ProductCard` component — homepage product grid (`/`), recommendations carousel on product detail (`/product/<id>`), cart, and checkout pages.",
+        "source_file": "src/frontend/components/ProductCard/ProductCard.tsx",
+        "source_line": 37,
+        "calling_service": "frontend",
+        "call_pattern": "ProductCard.useEffect ([`ProductCard.tsx#L34`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L34)) → fetch(`/images/products/<picture>`) with header `x-envoy-fault-delay-request: 5000` ([`ProductCard.tsx#L37`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L37)) → frontend-proxy Envoy → image-provider.",
+        "cause": "`useNumberFlagValue('imageSlowLoad', 0)` returns 5000 (the `5sec` variant value, [`demo.flagd.json` `imageSlowLoad.variants.5sec`](../../opentelemetry-demo/src/flagd/demo.flagd.json)). ProductCard sets `x-envoy-fault-delay-request: 5000` on every image fetch ([`ProductCard.tsx#L37`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L37)). The frontend-proxy `envoy.filters.http.fault` filter ([`envoy.tmpl.yaml#L67`](../../opentelemetry-demo/src/frontend-proxy/envoy.tmpl.yaml#L67)) honors this header and delays each image response by 5000ms before forwarding to image-provider, so each `<S.Image>` only resolves after that delay."
+      }
+    ],
+    "traces": []
+  }
+}

tasks/d1-i1-imageslowload-on-02-medium_ttd60m_range30m_off+10m/tests/test.sh

@@ -0,0 +1,19 @@
+#!/bin/bash
+set -euo pipefail
+
+set +e
+python /tests/check_prediction.py 2>&1 | tee /logs/verifier/log.txt
+status=${PIPESTATUS[0]}
+set -e
+
+# Preserve agent predictions even on verifier failure (Harbor deletes containers).
+if [[ -f /app/report.md ]]; then
+  mkdir -p /logs/verifier
+  cp /app/report.md /logs/verifier/report.md 2>/dev/null || true
+fi
+
+if [[ -f /app/task_meta.json ]]; then
+  cp /app/task_meta.json /logs/verifier/task_meta.json 2>/dev/null || true
+fi
+
+exit $status

tasks/d1-i1-imageslowload-on-univ00-universal_ttd60m_at_off+10m/environment/Dockerfile

@@ -0,0 +1 @@
+FROM ag2435/sre-otel-snapshot:{code_tag}

tasks/d1-i1-imageslowload-on-univ00-universal_ttd60m_at_off+10m/environment/docker-compose.yaml

@@ -0,0 +1,21 @@
+services:
+  main:
+    build:
+      context: ${CONTEXT_DIR}
+      pull: true
+    image: ${MAIN_IMAGE_NAME}
+    command: [ "sh", "-c", "sleep infinity" ]
+    privileged: true
+    environment:
+      - TEST_DIR=${TEST_DIR}
+      - CONTEXT_DIR=${CONTEXT_DIR}
+    volumes:
+      - /var/run/docker.sock:/var/run/docker.sock
+      - ${CONTEXT_DIR}:${CONTEXT_DIR}
+      - ${HOST_VERIFIER_LOGS_PATH}:${ENV_VERIFIER_LOGS_PATH}
+      - ${HOST_AGENT_LOGS_PATH}:${ENV_AGENT_LOGS_PATH}
+    deploy:
+      resources:
+        limits:
+          cpus: ${CPUS}
+          memory: ${MEMORY}

tasks/d1-i1-imageslowload-on-univ00-universal_ttd60m_at_off+10m/solution/check_prediction.py

@@ -0,0 +1,1005 @@
+"""LLM-as-a-judge verifier for Harbor incident-RCA-report tasks.
+
+Supports two modes:
+
+1. **Harbor verifier** (default):
+       python /tests/check_prediction.py
+
+2. **Post-hoc single-trial**:
+       python check_prediction.py --expected expected.json --predictions report.md [--rubric rubric.json]
+
+Falls back to string-match scoring when OPENAI_API_KEY is not set.
+"""
+
+import argparse
+import asyncio
+import json
+import logging
+import os
+import sys
+import traceback
+from pathlib import Path
+from typing import Any
+
+from tabulate import tabulate
+
+logger = logging.getLogger(__name__)
+
+JUDGE_PROMPT_MULTI_HEADER = """\
+You are an expert SRE tasked with judging the quality of an AI-generated incident RCA report.
+
+You are given:
+1. **One or more** ground-truth rubrics. Each describes a plausible root cause, its incident time, mechanism, and symptoms. Several flags may have been active in the same window; the agent is credited if it correctly identifies **any one** of these rubrics.
+2. The SRE agent's incident RCA report.
+
+## SRE Agent's Incident RCA Report
+
+{predictions}
+
+## Ground-Truth Rubrics
+
+{rubrics}
+
+## Evaluation Questions
+
+For **each rubric** in order, answer every question with true or false. Base your answer only on evidence in the agent's report; if the report does not cite the required evidence, answer false. The output must contain one entry per rubric, in the same order, and must preserve cluster order within each rubric exactly as listed.
+
+For each rubric:
+
+- `incident_time_within_10min`: Did the agent's timeline place the incident start within ±10 minutes of this rubric's `incident_time`?
+- `feature_flag_match`: Did the agent identify this rubric's feature flag as a root cause? (The agent may name multiple flags; mark true if this flag is among them.)
+- `mechanism_match`: Did the agent correctly explain this rubric's mechanism — how the flag propagates to the user-visible failure?
+- For each metric/log/trace cluster listed for this rubric: per-cluster match flags as before.
+"""
+
+JUDGE_PROMPT_SCORING_FOOTER = """\
+
+## Overall Score
+
+Score the incident RCA report on a scale of 0 to 3. The agent is credited if it correctly identifies **any one** of the listed rubrics — score against the rubric the agent's report best matches. Scoring is based on content correctness only; do not penalize or reward for formatting, prose style, or structural polish. Materially incorrect or misleading claims count against the score: if the report would otherwise score N but also adds a materially wrong claim (e.g., invents an unrelated additional cause), drop to N-1 (floor at 0). A report that correctly identifies one root cause but introduces a misleading fabrication alongside it therefore scores 2, not 3. When applying this penalty, explicitly identify in your reasoning which specific claim is materially wrong — quote or paraphrase the offending text. Do not apply the penalty without naming the offending claim; missing detail or incomplete explanation does not qualify as a materially wrong claim. Naming several of the listed plausible root causes is **not** a materially wrong claim.
+
+- 0: AI findings are misaligned with every rubric's mechanism and completely miss the root cause
+- 1: AI verifies incident description — the report confirms symptoms described in the task prompt but does not investigate further
+- 2: AI makes correct progress beyond symptoms — the report identifies some of the ground-truth metrics, logs, or traces for at least one rubric and moves toward that root cause, but does not fully identify any single root cause
+- 3: AI nails at least one of the listed root causes — the report correctly identifies it, the mechanism, and the supporting signals
+
+Respond with ONLY a JSON object matching the provided output schema.
+"""
+
+DEFAULT_MODEL = "openai-gpt-5.4"
+
+
+# ---------------------------------------------------------------------------
+# Rubric rendering (JSON -> markdown)
+# ---------------------------------------------------------------------------
+
+
+def _format_log_clusters(clusters: list[dict], lines: list[str]) -> None:
+    """Render log clusters as markdown subsections."""
+    for cluster in clusters:
+        name = cluster.get("name", "Unknown")
+        count = cluster.get("count")
+        suffix = f" ({count} entries)" if count is not None else ""
+        lines.append(f"#### {name}{suffix}")
+        lines.append("")
+
+        description = cluster.get("description", "")
+        if description:
+            lines.append(description)
+            lines.append("")
+
+        cause = cluster.get("cause", "")
+        if cause:
+            lines.append(f"**Cause:** {cause}")
+            lines.append("")
+
+        source = cluster.get("source", "")
+        if source:
+            lines.append(f"**Source:** {source}")
+            lines.append("")
+
+        attrs = cluster.get("representative_attributes", {})
+        if attrs:
+            lines.append("**Representative attributes:**")
+            lines.append("")
+            rows = [[f"`{k}`", f"`{v}`"] for k, v in attrs.items()]
+            lines.append(tabulate(rows, headers=["Field", "Value"], tablefmt="github"))
+            lines.append("")
+
+        docs = cluster.get("log_documents", [])
+        if docs:
+            lines.append("**Log documents:**")
+            lines.append("")
+            rows = [
+                [f"`{d['_index']}`", f"`{d['_id']}`", d["@timestamp"]] for d in docs
+            ]
+            lines.append(
+                tabulate(
+                    rows, headers=["_index", "_id", "@timestamp"], tablefmt="github"
+                )
+            )
+            lines.append("")
+
+
+def _format_trace_clusters(clusters: list[dict], lines: list[str]) -> None:
+    """Render trace clusters as markdown subsections."""
+    for cluster in clusters:
+        name = cluster.get("name", "Unknown")
+        count = cluster.get("count")
+        suffix = f" ({count} traces)" if count is not None else ""
+        lines.append(f"#### {name}{suffix}")
+        lines.append("")
+
+        description = cluster.get("description", "")
+        if description:
+            lines.append(description)
+            lines.append("")
+
+        cause = cluster.get("cause", "")
+        if cause:
+            lines.append(f"**Cause:** {cause}")
+            lines.append("")
+
+        call_chain = cluster.get("call_chain", "")
+        if call_chain:
+            lines.append("**Call chain:**")
+            lines.append("")
+            lines.append("```")
+            lines.append(call_chain)
+            lines.append("```")
+            lines.append("")
+
+        smoking_gun = cluster.get("smoking_gun", [])
+        if smoking_gun:
+            lines.append("**Smoking-gun error messages:**")
+            lines.append("")
+            for msg in smoking_gun:
+                lines.append(f"- {msg}")
+            lines.append("")
+
+        docs = cluster.get("trace_documents", [])
+        if docs:
+            lines.append("**Trace documents:**")
+            lines.append("")
+            headers = ["traceID", "@timestamp"]
+            has_action = any("user_action" in d for d in docs)
+            if has_action:
+                headers.append("user_action")
+            rows = []
+            for d in docs:
+                row = [f"`{d['traceID']}`", d["@timestamp"]]
+                if has_action:
+                    row.append(d.get("user_action", ""))
+                rows.append(row)
+            lines.append(tabulate(rows, headers=headers, tablefmt="github"))
+            lines.append("")
+
+
+_LAYER_DESCRIPTIONS = {
+    "root_cause": "metric closest to the fault injection point",
+    "propagation": "intermediate services reflecting the error through the call chain",
+    "symptom": "user-facing impact visible to end users or clients",
+    "meta": "feature flag counters or internal plumbing",
+    "unknown": "unclassified",
+}
+
+_LAYER_ORDER = ["root_cause", "propagation", "symptom", "meta", "unknown"]
+
+
+def _format_onset(offset: int | None) -> str:
+    """Format an onset offset as '+Xs' or 'N/A'."""
+    if offset is None:
+        return "N/A"
+    return f"+{offset}s"
+
+
+def _format_label_values(labels: dict[str, str]) -> str:
+    """Format label values as a compact comma-separated string."""
+    if not labels:
+        return ""
+    return ", ".join(labels.values())
+
+
+def _earliest_onset(variants: list[dict]) -> int | None:
+    """Return the earliest onset_offset_seconds across variants, or None."""
+    offsets = [
+        v["onset_offset_seconds"]
+        for v in variants
+        if v.get("onset_offset_seconds") is not None
+    ]
+    return min(offsets) if offsets else None
+
+
+def _format_metrics_list(metrics_list: list[dict], lines: list[str]) -> None:
+    """Render metric families grouped by signal layer."""
+    by_layer: dict[str, list[dict]] = {}
+    for fam in metrics_list:
+        by_layer.setdefault(fam.get("signal_layer", "unknown"), []).append(fam)
+
+    for layer in _LAYER_ORDER:
+        layer_families = by_layer.get(layer, [])
+        if not layer_families:
+            continue
+
+        layer_onsets = [_earliest_onset(f["variants"]) for f in layer_families]
+        layer_onsets = [o for o in layer_onsets if o is not None]
+        layer_onset_str = (
+            f" (earliest onset: {_format_onset(min(layer_onsets))})"
+            if layer_onsets
+            else ""
+        )
+
+        display_layer = layer.replace("_", " ").title()
+        desc = _LAYER_DESCRIPTIONS.get(layer, "")
+        lines.append(f"**{display_layer}** — {desc}{layer_onset_str}")
+        lines.append("")
+
+        for fam in layer_families:
+            fam_onset = _earliest_onset(fam["variants"])
+            label_vals = _format_label_values(fam.get("defining_labels", {}))
+            label_part = f" ({label_vals})" if label_vals else ""
+            lines.append(
+                f"#### {fam['metric_family']} family{label_part}"
+                f" — onset: {_format_onset(fam_onset)}"
+            )
+            lines.append("")
+
+            first_desc = (
+                fam["variants"][0].get("description", "") if fam["variants"] else ""
+            )
+            if first_desc:
+                lines.append(first_desc)
+                lines.append("")
+
+            for v in fam["variants"]:
+                v_onset = _format_onset(v.get("onset_offset_seconds"))
+                lines.append(f"- **{v['type']}** (onset: {v_onset})")
+                lines.append(f"  `{v['query']}`")
+                lines.append("")
+
+
+def _format_frontend_issues(issues: list[dict], lines: list[str]) -> None:
+    """Render frontend issues as markdown subsections."""
+    for issue in issues:
+        route = issue.get("route", "Unknown route")
+        lines.append(f"#### {route}")
+        lines.append("")
+
+        description = issue.get("description", "")
+        if description:
+            lines.append(description)
+            lines.append("")
+
+        rows = [
+            ["Deterministic", str(issue.get("deterministic", ""))],
+            ["Trigger condition", issue.get("trigger_condition", "")],
+            ["Calling service", issue.get("calling_service", "")],
+            [
+                "Source",
+                f"`{issue.get('source_file', '')}:{issue.get('source_line', '')}`",
+            ],
+        ]
+        lines.append(tabulate(rows, headers=["Field", "Value"], tablefmt="github"))
+        lines.append("")
+
+        call_pattern = issue.get("call_pattern", "")
+        if call_pattern:
+            lines.append(f"**Call pattern:** {call_pattern}")
+            lines.append("")
+
+        cause = issue.get("cause", "")
+        if cause:
+            lines.append(f"**Cause:** {cause}")
+            lines.append("")
+
+
+def format_rubric(data: dict, include_frontend: bool = False) -> str:
+    """Convert a rubric JSON dict into a consistently formatted markdown string.
+
+    Args:
+        data: The rubric JSON dict.
+        include_frontend: If True, include the ``### Frontend`` section.
+            Defaults to False since frontend symptoms may be noisy for
+            downstream consumers (LLM judge, oracle solutions).
+            TODO(Albert): systematically test the impact of including vs.
+            excluding frontend symptoms on downstream consumers.
+
+    """
+    lines: list[str] = []
+
+    lines.append(f"# {data['feature_flag']}")
+    lines.append("")
+    lines.append(f"**Feature flag:** `{data['feature_flag']}`")
+    lines.append("")
+    lines.append(f"**Description:** {data['description']}")
+    lines.append("")
+    lines.append(f"**Incident time:** {data['incident_time']}")
+    lines.append("")
+
+    lines.append("## Mechanism")
+    lines.append("")
+    lines.append(data["mechanism"])
+    lines.append("")
+
+    interaction = data.get("interaction", "")
+    if interaction:
+        lines.append(f"**Interaction with other feature flags:** {interaction}")
+        lines.append("")
+
+    lines.append("## Evidence")
+    lines.append("")
+
+    gs = data["symptoms"]
+
+    metrics = gs.get("metrics", [])
+    lines.append("### Metrics")
+    lines.append("")
+    if metrics:
+        _format_metrics_list(metrics, lines)
+
+    logs = gs.get("logs", [])
+    lines.append("### Logs")
+    lines.append("")
+    if logs:
+        _format_log_clusters(logs, lines)
+
+    if include_frontend:
+        frontend = gs.get("frontend", [])
+        lines.append("### Frontend")
+        lines.append("")
+        if frontend:
+            _format_frontend_issues(frontend, lines)
+
+    traces = gs.get("traces", [])
+    lines.append("### Traces")
+    lines.append("")
+    if traces:
+        _format_trace_clusters(traces, lines)
+
+    return "\n".join(lines)
+
+
+# ---------------------------------------------------------------------------
+# Judge prompt + output-schema builders
+# ---------------------------------------------------------------------------
+
+
+def _render_checklist(rubric_data: dict) -> str:
+    """Build per-cluster checklist blocks for metrics/logs/traces."""
+    symptoms = rubric_data.get("symptoms", {}) or {}
+    metric_clusters = symptoms.get("metrics", []) or []
+    log_clusters = symptoms.get("logs", []) or []
+    trace_clusters = symptoms.get("traces", []) or []
+
+    blocks: list[str] = []
+
+    if metric_clusters:
+        lines = ["#### Metric clusters"]
+        for i, m in enumerate(metric_clusters):
+            family = m.get("metric_family", "")
+            lines.append(
+                f'- Cluster {i}: `metric_family = "{family}"`'
+                f" — family_match: did the agent cite a query targeting"
+                f" metric_family `{family}` under a Why-step whose causal chain"
+                f" aligns with the rubric?"
+            )
+        blocks.append("\n".join(lines))
+
+    if log_clusters:
+        lines = ["#### Log clusters"]
+        for i, log in enumerate(log_clusters):
+            attrs = log.get("representative_attributes") or {}
+            body = attrs.get("body", "")
+            service_name = attrs.get("resource.service.name", "")
+            lines.append(
+                f"- Cluster {i}:\n"
+                f"  - `resource.service.name`: `{service_name}`\n"
+                f"  - `body`: `{body}`\n"
+                f"  - body_match: did the agent cite log evidence whose body"
+                f" matches the rubric's `body` under a Why-step whose causal"
+                f" chain aligns with the rubric?\n"
+                f"  - service_name_match: did the agent attribute the cited"
+                f" log evidence to the OTel service `{service_name}`"
+                f" (`resource.service.name`)?"
+            )
+        blocks.append("\n".join(lines))
+
+    if trace_clusters:
+        lines = ["#### Trace clusters"]
+        for i, trace in enumerate(trace_clusters):
+            call_chain = trace.get("call_chain", "")
+            smoking_gun = trace.get("smoking_gun", []) or []
+            sg_rendered = "\n".join(f"    - {s}" for s in smoking_gun)
+            lines.append(
+                f"- Cluster {i}:\n"
+                f"  - call_chain: `{call_chain}`\n"
+                f"  - smoking_gun:\n{sg_rendered}\n"
+                f"  - call_chain_match: did the agent cite evidence matching"
+                f" this service-level call chain under a Why-step whose causal"
+                f" chain aligns with the rubric?\n"
+                f"  - smoking_gun_match: did the agent cite at least one of"
+                f" the listed smoking-gun signals?"
+            )
+        blocks.append("\n".join(lines))
+
+    return (
+        "\n\n".join(blocks)
+        if blocks
+        else "(No metric, log, or trace clusters in rubric.)"
+    )
+
+
+def build_judge_prompt(
+    rubrics_data: list[dict],
+    predictions: str,
+) -> str:
+    """Render the judge prompt for one or more ground-truth rubrics.
+
+    The prompt asks the LLM to evaluate the agent's report against **each**
+    rubric independently. The agent is credited if it correctly identifies
+    any one rubric (the overall score reflects the best match).
+    """
+    if not rubrics_data:
+        raise ValueError("build_judge_prompt called with no rubrics")
+
+    rubric_blocks: list[str] = []
+    checklist_blocks: list[str] = []
+    for i, rubric in enumerate(rubrics_data):
+        feature_flag = rubric.get("feature_flag", "")
+        rubric_blocks.append(
+            f"### Rubric {i + 1} of {len(rubrics_data)} — `{feature_flag}`\n\n"
+            + format_rubric(rubric)
+        )
+        checklist_blocks.append(
+            f"### Rubric {i + 1} of {len(rubrics_data)} — `{feature_flag}`\n\n"
+            + _render_checklist(rubric)
+        )
+
+    rubrics_text = "\n\n---\n\n".join(rubric_blocks)
+    checklist_text = "\n\n---\n\n".join(checklist_blocks)
+
+    header = JUDGE_PROMPT_MULTI_HEADER.format(
+        rubrics=rubrics_text,
+        predictions=predictions,
+    )
+    return header + "\n" + checklist_text + "\n" + JUDGE_PROMPT_SCORING_FOOTER
+
+
+_METRIC_ITEM_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        "metric_family": {"type": "string"},
+        "family_match": {"type": "boolean"},
+    },
+    "required": ["metric_family", "family_match"],
+    "additionalProperties": False,
+}
+
+_LOG_ITEM_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        "body_match": {"type": "boolean"},
+        "service_name_match": {"type": "boolean"},
+    },
+    "required": ["body_match", "service_name_match"],
+    "additionalProperties": False,
+}
+
+_TRACE_ITEM_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        "call_chain_match": {"type": "boolean"},
+        "smoking_gun_match": {"type": "boolean"},
+    },
+    "required": ["call_chain_match", "smoking_gun_match"],
+    "additionalProperties": False,
+}
+
+
+_PER_RUBRIC_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        "feature_flag": {"type": "string"},
+        "incident_time_within_10min": {"type": "boolean"},
+        "feature_flag_match": {"type": "boolean"},
+        "mechanism_match": {"type": "boolean"},
+        "symptoms": {
+            "type": "object",
+            "properties": {
+                "metrics": {"type": "array", "items": _METRIC_ITEM_SCHEMA},
+                "logs": {"type": "array", "items": _LOG_ITEM_SCHEMA},
+                "traces": {"type": "array", "items": _TRACE_ITEM_SCHEMA},
+            },
+            "required": ["metrics", "logs", "traces"],
+            "additionalProperties": False,
+        },
+    },
+    "required": [
+        "feature_flag",
+        "incident_time_within_10min",
+        "feature_flag_match",
+        "mechanism_match",
+        "symptoms",
+    ],
+    "additionalProperties": False,
+}
+
+
+def build_judge_output_schema(rubrics_data: list[dict]) -> dict:
+    """Build a strict JSON Schema for the judge output: one verdict per rubric
+    + an overall ``score`` integer. Falls back to a minimal ``{score: int}``
+    schema when no rubrics are supplied (no-incident path).
+
+    Per-rubric cluster-array lengths vary across rubrics; rather than encode
+    a per-element schema (which Structured Outputs doesn't support), we leave
+    the array lengths unconstrained and rely on the prompt instructions to
+    keep cluster order matching.
+    """
+    if not rubrics_data:
+        return {
+            "type": "object",
+            "properties": {"score": {"type": "integer"}},
+            "required": ["score"],
+            "additionalProperties": False,
+        }
+
+    n = len(rubrics_data)
+    return {
+        "type": "object",
+        "properties": {
+            "rubrics": {
+                "type": "array",
+                "minItems": n,
+                "maxItems": n,
+                "items": _PER_RUBRIC_SCHEMA,
+            },
+            "score": {"type": "integer"},
+        },
+        "required": ["rubrics", "score"],
+        "additionalProperties": False,
+    }
+
+
+# ---------------------------------------------------------------------------
+# API call
+# ---------------------------------------------------------------------------
+
+
+async def async_call_llm_judge(
+    client: Any,
+    prompt: str,
+    model: str = DEFAULT_MODEL,
+    reasoning_effort: str | None = None,
+    output_schema: dict | None = None,
+) -> tuple[str, list[dict] | None]:
+    """Call the LLM judge via the OpenAI Responses API (falling back to Chat).
+
+    When ``output_schema`` is provided, uses Structured Outputs (strict JSON
+    Schema) so the returned text is guaranteed to conform to the schema.
+
+    Returns:
+        A tuple of (output_text, reasoning_summaries). reasoning_summaries is
+        None when reasoning_effort is not set.
+
+    """
+    text_format: dict[str, Any] = (
+        {
+            "type": "json_schema",
+            "name": "judge_response",
+            "schema": output_schema,
+            "strict": True,
+        }
+        if output_schema is not None
+        else {"type": "text"}
+    )
+    try:
+        kwargs: dict[str, Any] = {
+            "model": model,
+            "input": prompt,
+            "text": {"format": text_format},
+            "tools": [],
+            "store": True,
+            "max_output_tokens": 16384,
+        }
+        if reasoning_effort is not None:
+            kwargs["reasoning"] = {"effort": reasoning_effort, "summary": "auto"}
+        response = await client.responses.create(**kwargs)
+        reasoning_summaries = None
+        if reasoning_effort is not None:
+            reasoning_summaries = [
+                [
+                    s.model_dump() if hasattr(s, "model_dump") else s
+                    for s in item.summary
+                ]
+                for item in response.output
+                if getattr(item, "type", None) == "reasoning"
+                and getattr(item, "summary", None) is not None
+            ]
+        return response.output_text, reasoning_summaries
+    except Exception as exc:
+        if "404" not in str(exc):
+            raise
+        logger.info(
+            f"Responses API returned 404 for {model}, falling back to Chat Completions"
+        )
+        chat_kwargs: dict[str, Any] = {
+            "model": model,
+            "messages": [{"role": "user", "content": prompt}],
+            "max_tokens": 16384,
+        }
+        if output_schema is not None:
+            chat_kwargs["response_format"] = {
+                "type": "json_schema",
+                "json_schema": {
+                    "name": "judge_response",
+                    "schema": output_schema,
+                    "strict": True,
+                },
+            }
+        if reasoning_effort is not None:
+            chat_kwargs["reasoning_effort"] = reasoning_effort
+        response = await client.chat.completions.create(**chat_kwargs)
+        reasoning_summaries = None
+        if reasoning_effort is not None:
+            reasoning_content = getattr(
+                response.choices[0].message, "reasoning_content", None
+            )
+            if reasoning_content is not None:
+                reasoning_summaries = [{"type": "text", "text": reasoning_content}]
+            else:
+                reasoning_summaries = []
+        return response.choices[0].message.content, reasoning_summaries
+
+
+# ---------------------------------------------------------------------------
+# Parsing + aggregation
+# ---------------------------------------------------------------------------
+
+
+def parse_judge_response(response_text: str) -> dict:
+    """Parse the judge response JSON and range-check ``score``.
+
+    When Structured Outputs are used upstream, the response is already
+    schema-validated; this function only decodes the JSON and enforces the
+    0-3 range for ``score``.
+    """
+    parsed = json.loads(response_text)
+    score = int(parsed["score"])
+    if score < 0 or score > 3:
+        raise ValueError(f"Score {score} out of range [0, 3]")
+    parsed["score"] = score
+    return parsed
+
+
+def _aggregate_one_rubric(verdict: dict) -> dict:
+    """Roll up cluster verdicts for a single per-rubric judge entry."""
+    symptoms = verdict.get("symptoms", {}) or {}
+    metrics = symptoms.get("metrics", []) or []
+    logs = symptoms.get("logs", []) or []
+    traces = symptoms.get("traces", []) or []
+
+    metric_hits = [bool(m.get("family_match")) for m in metrics]
+    log_hits = [
+        bool(l.get("body_match")) and bool(l.get("service_name_match")) for l in logs
+    ]
+    trace_hits = [
+        bool(t.get("call_chain_match")) and bool(t.get("smoking_gun_match"))
+        for t in traces
+    ]
+
+    def _all(hits: list[bool]) -> bool | None:
+        return all(hits) if hits else None
+
+    def _any(hits: list[bool]) -> bool | None:
+        return any(hits) if hits else None
+
+    return {
+        "feature_flag": verdict.get("feature_flag", ""),
+        "incident_time_within_10min": bool(verdict.get("incident_time_within_10min")),
+        "feature_flag_match": bool(verdict.get("feature_flag_match")),
+        "mechanism_match": bool(verdict.get("mechanism_match")),
+        "metrics_all_match": _all(metric_hits),
+        "metrics_any_match": _any(metric_hits),
+        "logs_all_match": _all(log_hits),
+        "logs_any_match": _any(log_hits),
+        "traces_all_match": _all(trace_hits),
+        "traces_any_match": _any(trace_hits),
+    }
+
+
+def aggregate_judge_response(parsed: dict) -> dict:
+    """Aggregate per-rubric, per-cluster verdicts into flat any-of rollups.
+
+    The agent is credited if it matches any one of the listed rubrics.
+    Per-rubric rollups are computed via ``_aggregate_one_rubric``; the
+    task-level rollup is the ``any`` over rubrics for booleans (with ``None``
+    skipped — sections without clusters in any rubric stay ``None``).
+
+    The per-rubric rollups are also returned under ``per_rubric`` for
+    downstream analysis that needs to know which specific rubric matched.
+    """
+    rubrics = parsed.get("rubrics") or []
+    per_rubric = [_aggregate_one_rubric(r) for r in rubrics]
+
+    def _any_skip_none(values: list[bool | None]) -> bool | None:
+        truthy = [v for v in values if v is not None]
+        return any(truthy) if truthy else None
+
+    return {
+        "incident_time_within_10min": _any_skip_none(
+            [r["incident_time_within_10min"] for r in per_rubric]
+        )
+        or False,
+        "feature_flag_match": _any_skip_none(
+            [r["feature_flag_match"] for r in per_rubric]
+        )
+        or False,
+        "mechanism_match": _any_skip_none([r["mechanism_match"] for r in per_rubric])
+        or False,
+        "metrics_all_match": _any_skip_none(
+            [r["metrics_all_match"] for r in per_rubric]
+        ),
+        "metrics_any_match": _any_skip_none(
+            [r["metrics_any_match"] for r in per_rubric]
+        ),
+        "logs_all_match": _any_skip_none([r["logs_all_match"] for r in per_rubric]),
+        "logs_any_match": _any_skip_none([r["logs_any_match"] for r in per_rubric]),
+        "traces_all_match": _any_skip_none([r["traces_all_match"] for r in per_rubric]),
+        "traces_any_match": _any_skip_none([r["traces_any_match"] for r in per_rubric]),
+        "per_rubric": per_rubric,
+        "score": int(parsed["score"]),
+    }
+
+
+def string_match_fallback(expected: dict, predictions: str) -> dict:
+    """Fall back to case-insensitive string search for any plausible root_cause.
+
+    ``expected["events"]`` is a list of ``{"root_cause": <flag>, "event_time": ...}``;
+    the agent's report is credited if any listed root_cause appears in it.
+    Returns a result dict compatible with the judge output format.
+    """
+    events: list[dict] = expected.get("events") or []
+    if not events:
+        # No-incident task: agent should write an empty report.
+        return {"score": 3 if len(predictions.strip()) == 0 else 0}
+    text = predictions.lower()
+    found = any(e["root_cause"].strip().lower() in text for e in events)
+    return {"score": 3 if found else 0}
+
+
+# ---------------------------------------------------------------------------
+# Judge entry point (used by both modes)
+# ---------------------------------------------------------------------------
+
+
+async def judge(
+    client: Any,
+    expected: dict,
+    predictions: str,
+    rubrics_data: list[dict],
+    model: str = DEFAULT_MODEL,
+    reasoning_effort: str | None = None,
+) -> dict:
+    """Run the LLM judge over one or more ground-truth rubrics, or
+    short-circuit for no-incident tasks.
+
+    Returns:
+        A dict with keys: reward, mode, score, and (for LLM judge) model,
+        nested (raw judge response), reasoning_summary, rubric_used,
+        judge_prompt, judge_response_raw. Per-section rollups are derived
+        post-hoc from ``nested`` by formatters via ``aggregate_judge_response``.
+
+    """
+    events: list[dict] = expected.get("events") or []
+    if not events:
+        score = 3 if len(predictions.strip()) == 0 else 0
+        return {
+            "reward": score / 3.0,
+            "mode": "no_incident",
+            "model": model,
+            "score": score,
+        }
+
+    # Short-circuit when the agent emitted an empty report despite an incident.
+    # No LLM call can rescue this; score is a guaranteed 0. We synthesize the
+    # nested response shape (per-rubric all False, matching cluster counts)
+    # so that ``aggregate_judge_response`` produces the expected all-False
+    # rollups at load time.
+    if not predictions.strip():
+        synthetic_per_rubric = []
+        for rubric in rubrics_data:
+            symptoms = rubric.get("symptoms", {}) or {}
+            synthetic_per_rubric.append(
+                {
+                    "feature_flag": rubric.get("feature_flag", ""),
+                    "incident_time_within_10min": False,
+                    "feature_flag_match": False,
+                    "mechanism_match": False,
+                    "symptoms": {
+                        "metrics": [
+                            {
+                                "metric_family": m.get("metric_family", ""),
+                                "family_match": False,
+                            }
+                            for m in (symptoms.get("metrics") or [])
+                        ],
+                        "logs": [
+                            {"body_match": False, "service_name_match": False}
+                            for _ in (symptoms.get("logs") or [])
+                        ],
+                        "traces": [
+                            {"call_chain_match": False, "smoking_gun_match": False}
+                            for _ in (symptoms.get("traces") or [])
+                        ],
+                    },
+                }
+            )
+        return {
+            "mode": "empty_report",
+            "model": model,
+            "score": 0,
+            "reward": 0.0,
+            "rubric_used": bool(rubrics_data),
+            "nested": {"rubrics": synthetic_per_rubric, "score": 0},
+        }
+
+    prompt = build_judge_prompt(rubrics_data, predictions)
+    output_schema = build_judge_output_schema(rubrics_data)
+
+    raw_response, reasoning_summary = await async_call_llm_judge(
+        client,
+        prompt,
+        model=model,
+        reasoning_effort=reasoning_effort,
+        output_schema=output_schema,
+    )
+    parsed = parse_judge_response(raw_response)
+
+    # Per-section rollups are NOT spread into the result — they're a pure
+    # post-hoc derivation from ``nested`` via ``aggregate_judge_response``,
+    # applied by the formatters at load time so schema changes don't require
+    # rewriting saved JSONs.
+    return {
+        "mode": "llm_judge",
+        "model": model,
+        "score": parsed["score"],
+        "reward": parsed["score"] / 3.0,
+        "reasoning_summary": reasoning_summary,
+        "rubric_used": bool(rubrics_data),
+        "judge_prompt": prompt,
+        "judge_response_raw": raw_response,
+        "nested": parsed,
+    }
+
+
+# ---------------------------------------------------------------------------
+# CLI
+# ---------------------------------------------------------------------------
+
+
+async def main() -> None:
+    """Entry point: load expected + predictions, score, write reward/details."""
+    parser = argparse.ArgumentParser(
+        description="LLM-as-a-judge verifier for Harbor incident-RCA-report tasks."
+    )
+    parser.add_argument("--expected", type=str, default="/tests/expected.json")
+    parser.add_argument("--predictions", type=str, default="/app/report.md")
+    parser.add_argument(
+        "--rubrics-dir",
+        type=str,
+        default="/tests/rubrics",
+        help=(
+            "Directory containing one rubric JSON per plausible root cause "
+            "(e.g. /tests/rubrics/<event_id>.json). The judge scores the "
+            "agent against any one of them."
+        ),
+    )
+    parser.add_argument(
+        "--model", type=str, default=DEFAULT_MODEL, help="Judge LLM model name."
+    )
+    parser.add_argument(
+        "--effort",
+        type=str,
+        choices=["low", "medium", "high"],
+        default="high",
+        help="Reasoning effort level for the judge LLM (default: high).",
+    )
+    parser.add_argument(
+        "--mode",
+        type=str,
+        choices=["string_match", "llm_judge"],
+        default="string_match",
+        help="Scoring mode: string_match or llm_judge (default: string_match).",
+    )
+    parser.add_argument("--reward", type=str, default="/logs/verifier/reward.txt")
+    parser.add_argument("--details", type=str, default="/logs/verifier/details.json")
+    args = parser.parse_args()
+
+    expected_path = Path(args.expected)
+    predictions_path = Path(args.predictions)
+    rubrics_dir = Path(args.rubrics_dir)
+    reward_path = Path(args.reward)
+    details_path = Path(args.details)
+
+    try:
+        # Load expected
+        print(f"Loading expected results from {expected_path}...")
+        with expected_path.open() as f:
+            expected = json.load(f)
+
+        # Load predictions (markdown report)
+        print(f"Loading predictions from {predictions_path}...")
+        predictions = predictions_path.read_text()
+
+        # Load rubric JSONs — one per plausible root cause. Order is the
+        # filesystem sort order, which matches the build_harbor_tasks.py
+        # naming convention (event_id stems sort lexicographically).
+        rubrics_data: list[dict] = []
+        if expected.get("events"):
+            if rubrics_dir.is_dir():
+                rubric_paths = sorted(rubrics_dir.glob("*.json"))
+                for p in rubric_paths:
+                    with p.open() as f:
+                        rubrics_data.append(json.load(f))
+                print(f"Loaded {len(rubrics_data)} rubric(s) from {rubrics_dir}")
+            else:
+                print(f"Rubric directory missing: {rubrics_dir}")
+        else:
+            print("No incident events in expected results; skipping rubric load.")
+
+        # Run judge
+        if args.mode == "string_match":
+            em = string_match_fallback(expected, predictions)
+            result = {"reward": em["score"] / 3.0, "mode": "string_match", **em}
+        else:
+            from openai import AsyncOpenAI
+
+            client = AsyncOpenAI(
+                api_key=os.getenv("OPENAI_API_KEY"),
+                base_url=os.getenv("OPENAI_BASE_URL"),
+            )
+            result = await judge(
+                client,
+                expected,
+                predictions,
+                rubrics_data,
+                model=args.model,
+                reasoning_effort=args.effort,
+            )
+
+        # Write reward
+        reward_path.parent.mkdir(parents=True, exist_ok=True)
+        reward_path.write_text(str(result["reward"]))
+
+        # Write details
+        details_path.parent.mkdir(parents=True, exist_ok=True)
+        details_path.write_text(json.dumps(result, indent=2))
+
+        print(f"Score: {result.get('score', 'N/A')}/3 (reward: {result['reward']})")
+        print(f"Mode: {result['mode']}")
+        if result.get("reasoning_summary"):
+            print(f"Reasoning summary: {result['reasoning_summary']}")
+
+        if result["reward"] < 1.0:
+            sys.exit(1)
+
+    except Exception as exc:
+        reward_path.parent.mkdir(parents=True, exist_ok=True)
+        reward_path.write_text("0.0")
+        details_path.parent.mkdir(parents=True, exist_ok=True)
+        details_path.write_text(
+            json.dumps(
+                {
+                    "reward": 0.0,
+                    "error": f"{type(exc).__name__}: {exc}",
+                    "traceback": traceback.format_exc(),
+                },
+                indent=2,
+            )
+        )
+        print(f"Verifier error: {type(exc).__name__}: {exc}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

tasks/d1-i1-imageslowload-on-univ00-universal_ttd60m_at_off+10m/solution/rubric.json

@@ -0,0 +1,24 @@
+{
+  "incident_time": "2026-04-19T14:01:51.404464+00:00",
+  "feature_flag": "imageSlowLoad",
+  "description": "A feature flag in the frontend `ProductCard` React component added an `x-envoy-fault-delay-request` header (plus `Cache-Control: no-cache`) to every product-image fetch; Envoy honored the fault-injection header and artificially delayed each `GET /images/products/<picture>` response, so product thumbnails took seconds to render.",
+  "mechanism": "The flag is read in [`ProductCard.tsx#L32`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L32): the `ProductCard` React component calls `useNumberFlagValue('imageSlowLoad', 0)` to get the delay value in milliseconds (variants: `0` for off, `5000` for 5 sec, `10000` for 10 sec). When non-zero, the component sets the `x-envoy-fault-delay-request` header to the flag value on every product image fetch ([`ProductCard.tsx#L37`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L37)).\n\nThe image request is sent to `/images/products/<picture>`, which the frontend-proxy Envoy routes to the `image-provider` cluster ([`envoy.tmpl.yaml#L54-L55`](../../opentelemetry-demo/src/frontend-proxy/envoy.tmpl.yaml#L54)). Envoy's `envoy.filters.http.fault` filter is configured with `header_delay: {}` and 100% percentage ([`envoy.tmpl.yaml#L67-L74`](../../opentelemetry-demo/src/frontend-proxy/envoy.tmpl.yaml#L67)), meaning it honors the `x-envoy-fault-delay-request` header and injects the specified delay (in ms) before forwarding the request. Every product card image load is therefore delayed by the flag value (e.g. 5 or 10 seconds), causing the page to render with blank/loading images until the delayed responses arrive.",
+  "symptoms": {
+    "metrics": [],
+    "logs": [],
+    "frontend": [
+      {
+        "description": "Product card thumbnails on the homepage product grid (and the recommendations carousel on product/cart/checkout pages) render with a blank image placeholder for ~5 seconds before the actual thumbnail appears. The page text and layout render immediately; only the images are delayed. Affects every product card on every page load while the flag is on — the failure is silent slowness, not a visible error.",
+        "route": "GET /images/products/<picture>",
+        "deterministic": true,
+        "trigger_condition": "Every page load that renders a `ProductCard` component — homepage product grid (`/`), recommendations carousel on product detail (`/product/<id>`), cart, and checkout pages.",
+        "source_file": "src/frontend/components/ProductCard/ProductCard.tsx",
+        "source_line": 37,
+        "calling_service": "frontend",
+        "call_pattern": "ProductCard.useEffect ([`ProductCard.tsx#L34`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L34)) → fetch(`/images/products/<picture>`) with header `x-envoy-fault-delay-request: 5000` ([`ProductCard.tsx#L37`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L37)) → frontend-proxy Envoy → image-provider.",
+        "cause": "`useNumberFlagValue('imageSlowLoad', 0)` returns 5000 (the `5sec` variant value, [`demo.flagd.json` `imageSlowLoad.variants.5sec`](../../opentelemetry-demo/src/flagd/demo.flagd.json)). ProductCard sets `x-envoy-fault-delay-request: 5000` on every image fetch ([`ProductCard.tsx#L37`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L37)). The frontend-proxy `envoy.filters.http.fault` filter ([`envoy.tmpl.yaml#L67`](../../opentelemetry-demo/src/frontend-proxy/envoy.tmpl.yaml#L67)) honors this header and delays each image response by 5000ms before forwarding to image-provider, so each `<S.Image>` only resolves after that delay."
+      }
+    ],
+    "traces": []
+  }
+}

tasks/d1-i1-imageslowload-on-univ00-universal_ttd60m_at_off+10m/solution/rubrics/d1-i1-imageSlowLoad-on.json

@@ -0,0 +1,24 @@
+{
+  "incident_time": "2026-04-19T14:01:51.404464+00:00",
+  "feature_flag": "imageSlowLoad",
+  "description": "A feature flag in the frontend `ProductCard` React component added an `x-envoy-fault-delay-request` header (plus `Cache-Control: no-cache`) to every product-image fetch; Envoy honored the fault-injection header and artificially delayed each `GET /images/products/<picture>` response, so product thumbnails took seconds to render.",
+  "mechanism": "The flag is read in [`ProductCard.tsx#L32`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L32): the `ProductCard` React component calls `useNumberFlagValue('imageSlowLoad', 0)` to get the delay value in milliseconds (variants: `0` for off, `5000` for 5 sec, `10000` for 10 sec). When non-zero, the component sets the `x-envoy-fault-delay-request` header to the flag value on every product image fetch ([`ProductCard.tsx#L37`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L37)).\n\nThe image request is sent to `/images/products/<picture>`, which the frontend-proxy Envoy routes to the `image-provider` cluster ([`envoy.tmpl.yaml#L54-L55`](../../opentelemetry-demo/src/frontend-proxy/envoy.tmpl.yaml#L54)). Envoy's `envoy.filters.http.fault` filter is configured with `header_delay: {}` and 100% percentage ([`envoy.tmpl.yaml#L67-L74`](../../opentelemetry-demo/src/frontend-proxy/envoy.tmpl.yaml#L67)), meaning it honors the `x-envoy-fault-delay-request` header and injects the specified delay (in ms) before forwarding the request. Every product card image load is therefore delayed by the flag value (e.g. 5 or 10 seconds), causing the page to render with blank/loading images until the delayed responses arrive.",
+  "symptoms": {
+    "metrics": [],
+    "logs": [],
+    "frontend": [
+      {
+        "description": "Product card thumbnails on the homepage product grid (and the recommendations carousel on product/cart/checkout pages) render with a blank image placeholder for ~5 seconds before the actual thumbnail appears. The page text and layout render immediately; only the images are delayed. Affects every product card on every page load while the flag is on — the failure is silent slowness, not a visible error.",
+        "route": "GET /images/products/<picture>",
+        "deterministic": true,
+        "trigger_condition": "Every page load that renders a `ProductCard` component — homepage product grid (`/`), recommendations carousel on product detail (`/product/<id>`), cart, and checkout pages.",
+        "source_file": "src/frontend/components/ProductCard/ProductCard.tsx",
+        "source_line": 37,
+        "calling_service": "frontend",
+        "call_pattern": "ProductCard.useEffect ([`ProductCard.tsx#L34`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L34)) → fetch(`/images/products/<picture>`) with header `x-envoy-fault-delay-request: 5000` ([`ProductCard.tsx#L37`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L37)) → frontend-proxy Envoy → image-provider.",
+        "cause": "`useNumberFlagValue('imageSlowLoad', 0)` returns 5000 (the `5sec` variant value, [`demo.flagd.json` `imageSlowLoad.variants.5sec`](../../opentelemetry-demo/src/flagd/demo.flagd.json)). ProductCard sets `x-envoy-fault-delay-request: 5000` on every image fetch ([`ProductCard.tsx#L37`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L37)). The frontend-proxy `envoy.filters.http.fault` filter ([`envoy.tmpl.yaml#L67`](../../opentelemetry-demo/src/frontend-proxy/envoy.tmpl.yaml#L67)) honors this header and delays each image response by 5000ms before forwarding to image-provider, so each `<S.Image>` only resolves after that delay."
+      }
+    ],
+    "traces": []
+  }
+}

tasks/d1-i1-imageslowload-on-univ00-universal_ttd60m_at_off+10m/solution/solve.py

@@ -0,0 +1,298 @@
+#!/usr/bin/env python3
+"""Generate an incident report from a rubric JSON via LLM.
+
+Standalone script designed to run inside a Harbor task container.
+Also importable by ``run_solve.py`` for local batch generation.
+
+Examples::
+
+    # Inside Harbor container (solve.sh calls this):
+    python solve.py --rubric /tests/rubric.json --output /app/report.md
+
+    # With custom model/effort:
+    python solve.py --rubric /tests/rubric.json --output /app/report.md -m openai-gpt-5.4 -e high
+"""
+
+import argparse
+import asyncio
+import json
+import logging
+import os
+from pathlib import Path
+from typing import Any
+
+from check_prediction import async_call_llm_judge, format_rubric
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_MODEL: str | None = None
+DEFAULT_EFFORT = "high"
+
+# Report format from harbor-template/instruction.md.template — sections 1-4.
+REPORT_FORMAT = """\
+Write a structured incident report with four sections: Summary, Timeline, \
+5 Whys, and Remediation. Follow all section-specific rules below.
+
+---
+
+## Section 1: Summary
+
+2-3 sentences describing what happened, when, and the high-level impact. \
+This should be understandable by someone unfamiliar with the system. Focus \
+on what DID happen and the observable impact — mention request failures if \
+they occurred, but do NOT mention the absence of failures or errors as this \
+can be misread and cause confusion. You may name the root cause in a single \
+phrase (e.g. "due to a misconfigured batch job") but do not explain the \
+causal chain — that belongs in the 5 Whys section.
+
+Example: "Between 13:00 and 13:11 UTC on April 2, the order service returned \
+503 errors for 14% of checkout requests, affecting paying users, due to a \
+Redis cache eviction. The full causal chain is detailed in the 5 Whys section \
+below."
+
+---
+
+## Section 2: Timeline
+
+A chronological narrative of ONLY what went wrong, reconstructed from the \
+provided telemetry. Each entry should be a single succinct line. Cover \
+higher-level events — when a change was introduced, when symptoms started, \
+when a change was reverted, when symptoms subsided — not individual error \
+occurrences. The first entry should be the earliest anomaly visible in the \
+provided telemetry; this establishes the incident start time referenced by \
+the Summary and 5 Whys sections.
+
+For each entry:
+- State the time (UTC), the service(s) involved, and what happened
+- Quantify where possible (error rate, duration, number of affected requests)
+- Do NOT include normal/healthy behavior, baseline noise, or things that \
+worked correctly
+
+Example format:
+```
+09:44 UTC — analytics-job deployed with no memory limit set
+14:17 UTC — redis-cache-0 OOMKilled; node memory at 97%
+14:18 UTC — inventory-svc cache misses begin; all requests fall through to Postgres
+14:18 UTC — order-svc goroutine pool exhaustion begins; 503 error rate climbs to 14%
+14:29 UTC — redis-cache-0 rescheduled; error rate returns to baseline
+```
+
+---
+
+## Section 3: 5 Whys
+
+Rules:
+1. Start by stating the problem as a precise, observable symptom — not a \
+cause. Include what failed, when, and impact (error rate, affected users, \
+duration).
+2. Each "why" answer must be grounded in the provided telemetry. Cite only \
+the telemetry types relevant to that step, using the format below for each.
+
+   - Metrics: one sentence describing the baseline value (or typical range), \
+what it changed to, and at what UTC timestamp. Where relevant, include rate \
+of change or duration. Follow with the exact PromQL query that would surface it.
+     Example — "Error rate on order-svc was 0.1% at 14:17 UTC, jumping to \
+14% at 14:18 UTC. PromQL: rate(http_requests_total{service="order-svc",\
+status=~"5.."}[1m])"
+
+   - Traces: the cascade from the highest-level operation down to the deepest \
+failing span, followed by representative trace IDs from the provided data.
+     Example — "checkout request → order-svc goroutine exhaustion → \
+inventory-svc Redis GET timeout. Trace IDs: 4bf92f3577b34da6, a3ce929d0e0e4736"
+
+   - Logs: one sentence with service, endpoint, error, and time range, \
+followed by the exact Lucene query that would retrieve the relevant log lines.
+     Example — "Between 14:18:02 and 14:29:11 UTC, POST /api/checkout \
+returned 503s. Lucene: service:order-svc AND status:503 AND \
+endpoint:\\"/api/checkout\\""
+3. Each "why" targets the previous answer, not the original problem. Drill \
+down one causal chain; do not branch.
+4. Never accept "human error" or "operator mistake" as a terminal answer. \
+Ask why the human was in a position to make that error.
+5. Stop when you reach a cause that is: (a) actionable — something a team \
+can change, or (b) a process or system gap that allowed the failure to \
+propagate. The number of steps is not fixed at 5.
+6. Only include steps that are directly supported by the provided telemetry. \
+If the causal chain cannot be completed with the available evidence, stop \
+and note what additional telemetry would be needed to continue.
+7. After the chain, note any branches you did NOT follow. If the incident \
+has multiple contributing causes that cannot fit a single chain, say so \
+explicitly rather than forcing one.
+
+Output format:
+
+```
+Problem statement:
+[Observable symptom with time, impact, and detection method]
+
+Why 1: [question] → [answer]
+Evidence: [specific signal]
+
+Why 2: [question] → [answer]
+Evidence: [specific signal]
+
+...
+
+Root cause:
+[Single sentence naming the systemic or process failure]
+
+Unexplored branches:
+[Contributing factors visible in telemetry that were not followed, \
+and why they were set aside]
+```
+
+---
+
+## Section 4: Remediation
+
+For each corrective action, identify which step in the causal chain it \
+targets and what class of fix it is:
+
+- **Root cause fix**: eliminates the condition that started the chain
+- **Propagation fix**: limits blast radius if the root cause recurs
+- **Detection fix**: reduces time-to-detect or time-to-mitigate
+
+List actions from root cause outward. Prefer fixes that prevent recurrence \
+over fixes that only improve response.
+
+Output format:
+
+| Action | Targets | Type |
+|--------|---------|------|
+| [What to do] | Why N | Root cause fix / Propagation fix / Detection fix |
+"""
+
+SOLUTION_PROMPT_TEMPLATE = """\
+You are an expert site reliability engineer. You are given a ground-truth \
+rubric describing an incident's root cause, mechanism, and telemetry evidence.
+
+Your task: write an incident report as if you investigated this incident \
+yourself. Use the rubric evidence to populate each section. Do NOT mention \
+the rubric or that you were given ground-truth data — write as though you \
+discovered everything through telemetry analysis.
+
+## Ground-Truth Rubric
+
+{rubric}
+
+## Report Format
+
+{report_format}
+"""
+
+
+def build_solution_prompt(rubric_md: str) -> str:
+    """Build the LLM prompt from a formatted rubric markdown string."""
+    return SOLUTION_PROMPT_TEMPLATE.format(
+        rubric=rubric_md,
+        report_format=REPORT_FORMAT,
+    )
+
+
+async def generate_report(
+    client: Any,
+    rubric_data: dict,
+    model: str | None = DEFAULT_MODEL,
+    effort: str | None = DEFAULT_EFFORT,
+) -> tuple[str, str, list[dict] | None]:
+    """Generate an incident report from rubric JSON.
+
+    If ``model`` is ``None``, the formatted rubric is returned directly with
+    no LLM call. Otherwise the rubric is passed to the LLM to be reformatted
+    into an incident report.
+
+    Returns:
+        A tuple of (report_text, prompt, reasoning_summary). When ``model``
+        is ``None``, ``prompt`` is empty and ``reasoning_summary`` is ``None``.
+
+    """
+    rubric_md = format_rubric(rubric_data)
+    if model is None:
+        return rubric_md, "", None
+    prompt = build_solution_prompt(rubric_md)
+    response_text, reasoning_summary = await async_call_llm_judge(
+        client, prompt, model=model, reasoning_effort=effort
+    )
+    return response_text, prompt, reasoning_summary
+
+
+async def async_main() -> None:
+    """CLI entry point: read rubric, call LLM, write report."""
+    parser = argparse.ArgumentParser(
+        description="Generate an incident report from a rubric JSON via LLM."
+    )
+    parser.add_argument(
+        "--rubric",
+        type=str,
+        default="/tests/rubric.json",
+        help="Path to rubric JSON file.",
+    )
+    parser.add_argument(
+        "--output",
+        type=str,
+        default="/app/report.md",
+        help="Path to write the generated report.",
+    )
+    parser.add_argument(
+        "--model",
+        "-m",
+        type=str,
+        default=DEFAULT_MODEL,
+        help=(
+            "LLM model name. If omitted, the formatted rubric is written "
+            "directly as the report with no LLM call."
+        ),
+    )
+    parser.add_argument(
+        "--effort",
+        "-e",
+        type=str,
+        choices=["low", "medium", "high"],
+        default=DEFAULT_EFFORT,
+        help=f"Reasoning effort level (default: {DEFAULT_EFFORT}).",
+    )
+    args = parser.parse_args()
+
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s - %(levelname)s - %(message)s",
+    )
+
+    rubric_path = Path(args.rubric)
+    output_path = Path(args.output)
+
+    if not rubric_path.is_file():
+        logger.warning(f"Rubric file not found: {rubric_path}; writing empty report")
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        output_path.write_text("")
+        return
+
+    rubric_data = json.loads(rubric_path.read_text())
+    logger.info(
+        f"Loaded rubric: {rubric_data.get('feature_flag', 'unknown')} "
+        f"from {rubric_path}"
+    )
+
+    client: Any = None
+    if args.model is not None:
+        from openai import AsyncOpenAI
+
+        client = AsyncOpenAI(
+            api_key=os.getenv("OPENAI_API_KEY"),
+            base_url=os.getenv("OPENAI_BASE_URL"),
+        )
+
+    report_text, _prompt, reasoning_summary = await generate_report(
+        client, rubric_data, model=args.model, effort=args.effort
+    )
+
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    output_path.write_text(report_text)
+    logger.info(f"Wrote report to {output_path}")
+
+    if reasoning_summary:
+        logger.info(f"Reasoning summary: {reasoning_summary}")
+
+
+if __name__ == "__main__":
+    asyncio.run(async_main())

tasks/d1-i1-imageslowload-on-univ00-universal_ttd60m_at_off+10m/solution/solve.sh

@@ -0,0 +1,28 @@
+#!/bin/bash
+set -euo pipefail
+
+# ── Wait for the entrypoint to finish setting up the environment ──
+echo "[solve] Waiting for environment to be ready..."
+for i in $(seq 1 180); do
+    [ -f /tmp/env-ready ] && break
+    sleep 1
+done
+if [ ! -f /tmp/env-ready ]; then
+    echo "[solve] ERROR: Environment did not become ready within 180s" >&2
+    exit 1
+fi
+echo "[solve] Environment is ready."
+
+# ── Verify all services are healthy ──
+echo "[solve] Running health checks..."
+source /tmp/env-ports
+/app/check_health.sh || {
+    echo "[solve] ERROR: Health checks failed" >&2
+    exit 1
+}
+
+# ── Generate solution report via LLM ──
+echo "[solve] Installing dependencies..."
+pip install tabulate
+echo "[solve] Generating report..."
+python /solution/solve.py --rubric /solution/rubric.json

tasks/d1-i1-imageslowload-on-univ00-universal_ttd60m_at_off+10m/tests/check_prediction.py

@@ -0,0 +1,1005 @@
+"""LLM-as-a-judge verifier for Harbor incident-RCA-report tasks.
+
+Supports two modes:
+
+1. **Harbor verifier** (default):
+       python /tests/check_prediction.py
+
+2. **Post-hoc single-trial**:
+       python check_prediction.py --expected expected.json --predictions report.md [--rubric rubric.json]
+
+Falls back to string-match scoring when OPENAI_API_KEY is not set.
+"""
+
+import argparse
+import asyncio
+import json
+import logging
+import os
+import sys
+import traceback
+from pathlib import Path
+from typing import Any
+
+from tabulate import tabulate
+
+logger = logging.getLogger(__name__)
+
+JUDGE_PROMPT_MULTI_HEADER = """\
+You are an expert SRE tasked with judging the quality of an AI-generated incident RCA report.
+
+You are given:
+1. **One or more** ground-truth rubrics. Each describes a plausible root cause, its incident time, mechanism, and symptoms. Several flags may have been active in the same window; the agent is credited if it correctly identifies **any one** of these rubrics.
+2. The SRE agent's incident RCA report.
+
+## SRE Agent's Incident RCA Report
+
+{predictions}
+
+## Ground-Truth Rubrics
+
+{rubrics}
+
+## Evaluation Questions
+
+For **each rubric** in order, answer every question with true or false. Base your answer only on evidence in the agent's report; if the report does not cite the required evidence, answer false. The output must contain one entry per rubric, in the same order, and must preserve cluster order within each rubric exactly as listed.
+
+For each rubric:
+
+- `incident_time_within_10min`: Did the agent's timeline place the incident start within ±10 minutes of this rubric's `incident_time`?
+- `feature_flag_match`: Did the agent identify this rubric's feature flag as a root cause? (The agent may name multiple flags; mark true if this flag is among them.)
+- `mechanism_match`: Did the agent correctly explain this rubric's mechanism — how the flag propagates to the user-visible failure?
+- For each metric/log/trace cluster listed for this rubric: per-cluster match flags as before.
+"""
+
+JUDGE_PROMPT_SCORING_FOOTER = """\
+
+## Overall Score
+
+Score the incident RCA report on a scale of 0 to 3. The agent is credited if it correctly identifies **any one** of the listed rubrics — score against the rubric the agent's report best matches. Scoring is based on content correctness only; do not penalize or reward for formatting, prose style, or structural polish. Materially incorrect or misleading claims count against the score: if the report would otherwise score N but also adds a materially wrong claim (e.g., invents an unrelated additional cause), drop to N-1 (floor at 0). A report that correctly identifies one root cause but introduces a misleading fabrication alongside it therefore scores 2, not 3. When applying this penalty, explicitly identify in your reasoning which specific claim is materially wrong — quote or paraphrase the offending text. Do not apply the penalty without naming the offending claim; missing detail or incomplete explanation does not qualify as a materially wrong claim. Naming several of the listed plausible root causes is **not** a materially wrong claim.
+
+- 0: AI findings are misaligned with every rubric's mechanism and completely miss the root cause
+- 1: AI verifies incident description — the report confirms symptoms described in the task prompt but does not investigate further
+- 2: AI makes correct progress beyond symptoms — the report identifies some of the ground-truth metrics, logs, or traces for at least one rubric and moves toward that root cause, but does not fully identify any single root cause
+- 3: AI nails at least one of the listed root causes — the report correctly identifies it, the mechanism, and the supporting signals
+
+Respond with ONLY a JSON object matching the provided output schema.
+"""
+
+DEFAULT_MODEL = "openai-gpt-5.4"
+
+
+# ---------------------------------------------------------------------------
+# Rubric rendering (JSON -> markdown)
+# ---------------------------------------------------------------------------
+
+
+def _format_log_clusters(clusters: list[dict], lines: list[str]) -> None:
+    """Render log clusters as markdown subsections."""
+    for cluster in clusters:
+        name = cluster.get("name", "Unknown")
+        count = cluster.get("count")
+        suffix = f" ({count} entries)" if count is not None else ""
+        lines.append(f"#### {name}{suffix}")
+        lines.append("")
+
+        description = cluster.get("description", "")
+        if description:
+            lines.append(description)
+            lines.append("")
+
+        cause = cluster.get("cause", "")
+        if cause:
+            lines.append(f"**Cause:** {cause}")
+            lines.append("")
+
+        source = cluster.get("source", "")
+        if source:
+            lines.append(f"**Source:** {source}")
+            lines.append("")
+
+        attrs = cluster.get("representative_attributes", {})
+        if attrs:
+            lines.append("**Representative attributes:**")
+            lines.append("")
+            rows = [[f"`{k}`", f"`{v}`"] for k, v in attrs.items()]
+            lines.append(tabulate(rows, headers=["Field", "Value"], tablefmt="github"))
+            lines.append("")
+
+        docs = cluster.get("log_documents", [])
+        if docs:
+            lines.append("**Log documents:**")
+            lines.append("")
+            rows = [
+                [f"`{d['_index']}`", f"`{d['_id']}`", d["@timestamp"]] for d in docs
+            ]
+            lines.append(
+                tabulate(
+                    rows, headers=["_index", "_id", "@timestamp"], tablefmt="github"
+                )
+            )
+            lines.append("")
+
+
+def _format_trace_clusters(clusters: list[dict], lines: list[str]) -> None:
+    """Render trace clusters as markdown subsections."""
+    for cluster in clusters:
+        name = cluster.get("name", "Unknown")
+        count = cluster.get("count")
+        suffix = f" ({count} traces)" if count is not None else ""
+        lines.append(f"#### {name}{suffix}")
+        lines.append("")
+
+        description = cluster.get("description", "")
+        if description:
+            lines.append(description)
+            lines.append("")
+
+        cause = cluster.get("cause", "")
+        if cause:
+            lines.append(f"**Cause:** {cause}")
+            lines.append("")
+
+        call_chain = cluster.get("call_chain", "")
+        if call_chain:
+            lines.append("**Call chain:**")
+            lines.append("")
+            lines.append("```")
+            lines.append(call_chain)
+            lines.append("```")
+            lines.append("")
+
+        smoking_gun = cluster.get("smoking_gun", [])
+        if smoking_gun:
+            lines.append("**Smoking-gun error messages:**")
+            lines.append("")
+            for msg in smoking_gun:
+                lines.append(f"- {msg}")
+            lines.append("")
+
+        docs = cluster.get("trace_documents", [])
+        if docs:
+            lines.append("**Trace documents:**")
+            lines.append("")
+            headers = ["traceID", "@timestamp"]
+            has_action = any("user_action" in d for d in docs)
+            if has_action:
+                headers.append("user_action")
+            rows = []
+            for d in docs:
+                row = [f"`{d['traceID']}`", d["@timestamp"]]
+                if has_action:
+                    row.append(d.get("user_action", ""))
+                rows.append(row)
+            lines.append(tabulate(rows, headers=headers, tablefmt="github"))
+            lines.append("")
+
+
+_LAYER_DESCRIPTIONS = {
+    "root_cause": "metric closest to the fault injection point",
+    "propagation": "intermediate services reflecting the error through the call chain",
+    "symptom": "user-facing impact visible to end users or clients",
+    "meta": "feature flag counters or internal plumbing",
+    "unknown": "unclassified",
+}
+
+_LAYER_ORDER = ["root_cause", "propagation", "symptom", "meta", "unknown"]
+
+
+def _format_onset(offset: int | None) -> str:
+    """Format an onset offset as '+Xs' or 'N/A'."""
+    if offset is None:
+        return "N/A"
+    return f"+{offset}s"
+
+
+def _format_label_values(labels: dict[str, str]) -> str:
+    """Format label values as a compact comma-separated string."""
+    if not labels:
+        return ""
+    return ", ".join(labels.values())
+
+
+def _earliest_onset(variants: list[dict]) -> int | None:
+    """Return the earliest onset_offset_seconds across variants, or None."""
+    offsets = [
+        v["onset_offset_seconds"]
+        for v in variants
+        if v.get("onset_offset_seconds") is not None
+    ]
+    return min(offsets) if offsets else None
+
+
+def _format_metrics_list(metrics_list: list[dict], lines: list[str]) -> None:
+    """Render metric families grouped by signal layer."""
+    by_layer: dict[str, list[dict]] = {}
+    for fam in metrics_list:
+        by_layer.setdefault(fam.get("signal_layer", "unknown"), []).append(fam)
+
+    for layer in _LAYER_ORDER:
+        layer_families = by_layer.get(layer, [])
+        if not layer_families:
+            continue
+
+        layer_onsets = [_earliest_onset(f["variants"]) for f in layer_families]
+        layer_onsets = [o for o in layer_onsets if o is not None]
+        layer_onset_str = (
+            f" (earliest onset: {_format_onset(min(layer_onsets))})"
+            if layer_onsets
+            else ""
+        )
+
+        display_layer = layer.replace("_", " ").title()
+        desc = _LAYER_DESCRIPTIONS.get(layer, "")
+        lines.append(f"**{display_layer}** — {desc}{layer_onset_str}")
+        lines.append("")
+
+        for fam in layer_families:
+            fam_onset = _earliest_onset(fam["variants"])
+            label_vals = _format_label_values(fam.get("defining_labels", {}))
+            label_part = f" ({label_vals})" if label_vals else ""
+            lines.append(
+                f"#### {fam['metric_family']} family{label_part}"
+                f" — onset: {_format_onset(fam_onset)}"
+            )
+            lines.append("")
+
+            first_desc = (
+                fam["variants"][0].get("description", "") if fam["variants"] else ""
+            )
+            if first_desc:
+                lines.append(first_desc)
+                lines.append("")
+
+            for v in fam["variants"]:
+                v_onset = _format_onset(v.get("onset_offset_seconds"))
+                lines.append(f"- **{v['type']}** (onset: {v_onset})")
+                lines.append(f"  `{v['query']}`")
+                lines.append("")
+
+
+def _format_frontend_issues(issues: list[dict], lines: list[str]) -> None:
+    """Render frontend issues as markdown subsections."""
+    for issue in issues:
+        route = issue.get("route", "Unknown route")
+        lines.append(f"#### {route}")
+        lines.append("")
+
+        description = issue.get("description", "")
+        if description:
+            lines.append(description)
+            lines.append("")
+
+        rows = [
+            ["Deterministic", str(issue.get("deterministic", ""))],
+            ["Trigger condition", issue.get("trigger_condition", "")],
+            ["Calling service", issue.get("calling_service", "")],
+            [
+                "Source",
+                f"`{issue.get('source_file', '')}:{issue.get('source_line', '')}`",
+            ],
+        ]
+        lines.append(tabulate(rows, headers=["Field", "Value"], tablefmt="github"))
+        lines.append("")
+
+        call_pattern = issue.get("call_pattern", "")
+        if call_pattern:
+            lines.append(f"**Call pattern:** {call_pattern}")
+            lines.append("")
+
+        cause = issue.get("cause", "")
+        if cause:
+            lines.append(f"**Cause:** {cause}")
+            lines.append("")
+
+
+def format_rubric(data: dict, include_frontend: bool = False) -> str:
+    """Convert a rubric JSON dict into a consistently formatted markdown string.
+
+    Args:
+        data: The rubric JSON dict.
+        include_frontend: If True, include the ``### Frontend`` section.
+            Defaults to False since frontend symptoms may be noisy for
+            downstream consumers (LLM judge, oracle solutions).
+            TODO(Albert): systematically test the impact of including vs.
+            excluding frontend symptoms on downstream consumers.
+
+    """
+    lines: list[str] = []
+
+    lines.append(f"# {data['feature_flag']}")
+    lines.append("")
+    lines.append(f"**Feature flag:** `{data['feature_flag']}`")
+    lines.append("")
+    lines.append(f"**Description:** {data['description']}")
+    lines.append("")
+    lines.append(f"**Incident time:** {data['incident_time']}")
+    lines.append("")
+
+    lines.append("## Mechanism")
+    lines.append("")
+    lines.append(data["mechanism"])
+    lines.append("")
+
+    interaction = data.get("interaction", "")
+    if interaction:
+        lines.append(f"**Interaction with other feature flags:** {interaction}")
+        lines.append("")
+
+    lines.append("## Evidence")
+    lines.append("")
+
+    gs = data["symptoms"]
+
+    metrics = gs.get("metrics", [])
+    lines.append("### Metrics")
+    lines.append("")
+    if metrics:
+        _format_metrics_list(metrics, lines)
+
+    logs = gs.get("logs", [])
+    lines.append("### Logs")
+    lines.append("")
+    if logs:
+        _format_log_clusters(logs, lines)
+
+    if include_frontend:
+        frontend = gs.get("frontend", [])
+        lines.append("### Frontend")
+        lines.append("")
+        if frontend:
+            _format_frontend_issues(frontend, lines)
+
+    traces = gs.get("traces", [])
+    lines.append("### Traces")
+    lines.append("")
+    if traces:
+        _format_trace_clusters(traces, lines)
+
+    return "\n".join(lines)
+
+
+# ---------------------------------------------------------------------------
+# Judge prompt + output-schema builders
+# ---------------------------------------------------------------------------
+
+
+def _render_checklist(rubric_data: dict) -> str:
+    """Build per-cluster checklist blocks for metrics/logs/traces."""
+    symptoms = rubric_data.get("symptoms", {}) or {}
+    metric_clusters = symptoms.get("metrics", []) or []
+    log_clusters = symptoms.get("logs", []) or []
+    trace_clusters = symptoms.get("traces", []) or []
+
+    blocks: list[str] = []
+
+    if metric_clusters:
+        lines = ["#### Metric clusters"]
+        for i, m in enumerate(metric_clusters):
+            family = m.get("metric_family", "")
+            lines.append(
+                f'- Cluster {i}: `metric_family = "{family}"`'
+                f" — family_match: did the agent cite a query targeting"
+                f" metric_family `{family}` under a Why-step whose causal chain"
+                f" aligns with the rubric?"
+            )
+        blocks.append("\n".join(lines))
+
+    if log_clusters:
+        lines = ["#### Log clusters"]
+        for i, log in enumerate(log_clusters):
+            attrs = log.get("representative_attributes") or {}
+            body = attrs.get("body", "")
+            service_name = attrs.get("resource.service.name", "")
+            lines.append(
+                f"- Cluster {i}:\n"
+                f"  - `resource.service.name`: `{service_name}`\n"
+                f"  - `body`: `{body}`\n"
+                f"  - body_match: did the agent cite log evidence whose body"
+                f" matches the rubric's `body` under a Why-step whose causal"
+                f" chain aligns with the rubric?\n"
+                f"  - service_name_match: did the agent attribute the cited"
+                f" log evidence to the OTel service `{service_name}`"
+                f" (`resource.service.name`)?"
+            )
+        blocks.append("\n".join(lines))
+
+    if trace_clusters:
+        lines = ["#### Trace clusters"]
+        for i, trace in enumerate(trace_clusters):
+            call_chain = trace.get("call_chain", "")
+            smoking_gun = trace.get("smoking_gun", []) or []
+            sg_rendered = "\n".join(f"    - {s}" for s in smoking_gun)
+            lines.append(
+                f"- Cluster {i}:\n"
+                f"  - call_chain: `{call_chain}`\n"
+                f"  - smoking_gun:\n{sg_rendered}\n"
+                f"  - call_chain_match: did the agent cite evidence matching"
+                f" this service-level call chain under a Why-step whose causal"
+                f" chain aligns with the rubric?\n"
+                f"  - smoking_gun_match: did the agent cite at least one of"
+                f" the listed smoking-gun signals?"
+            )
+        blocks.append("\n".join(lines))
+
+    return (
+        "\n\n".join(blocks)
+        if blocks
+        else "(No metric, log, or trace clusters in rubric.)"
+    )
+
+
+def build_judge_prompt(
+    rubrics_data: list[dict],
+    predictions: str,
+) -> str:
+    """Render the judge prompt for one or more ground-truth rubrics.
+
+    The prompt asks the LLM to evaluate the agent's report against **each**
+    rubric independently. The agent is credited if it correctly identifies
+    any one rubric (the overall score reflects the best match).
+    """
+    if not rubrics_data:
+        raise ValueError("build_judge_prompt called with no rubrics")
+
+    rubric_blocks: list[str] = []
+    checklist_blocks: list[str] = []
+    for i, rubric in enumerate(rubrics_data):
+        feature_flag = rubric.get("feature_flag", "")
+        rubric_blocks.append(
+            f"### Rubric {i + 1} of {len(rubrics_data)} — `{feature_flag}`\n\n"
+            + format_rubric(rubric)
+        )
+        checklist_blocks.append(
+            f"### Rubric {i + 1} of {len(rubrics_data)} — `{feature_flag}`\n\n"
+            + _render_checklist(rubric)
+        )
+
+    rubrics_text = "\n\n---\n\n".join(rubric_blocks)
+    checklist_text = "\n\n---\n\n".join(checklist_blocks)
+
+    header = JUDGE_PROMPT_MULTI_HEADER.format(
+        rubrics=rubrics_text,
+        predictions=predictions,
+    )
+    return header + "\n" + checklist_text + "\n" + JUDGE_PROMPT_SCORING_FOOTER
+
+
+_METRIC_ITEM_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        "metric_family": {"type": "string"},
+        "family_match": {"type": "boolean"},
+    },
+    "required": ["metric_family", "family_match"],
+    "additionalProperties": False,
+}
+
+_LOG_ITEM_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        "body_match": {"type": "boolean"},
+        "service_name_match": {"type": "boolean"},
+    },
+    "required": ["body_match", "service_name_match"],
+    "additionalProperties": False,
+}
+
+_TRACE_ITEM_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        "call_chain_match": {"type": "boolean"},
+        "smoking_gun_match": {"type": "boolean"},
+    },
+    "required": ["call_chain_match", "smoking_gun_match"],
+    "additionalProperties": False,
+}
+
+
+_PER_RUBRIC_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        "feature_flag": {"type": "string"},
+        "incident_time_within_10min": {"type": "boolean"},
+        "feature_flag_match": {"type": "boolean"},
+        "mechanism_match": {"type": "boolean"},
+        "symptoms": {
+            "type": "object",
+            "properties": {
+                "metrics": {"type": "array", "items": _METRIC_ITEM_SCHEMA},
+                "logs": {"type": "array", "items": _LOG_ITEM_SCHEMA},
+                "traces": {"type": "array", "items": _TRACE_ITEM_SCHEMA},
+            },
+            "required": ["metrics", "logs", "traces"],
+            "additionalProperties": False,
+        },
+    },
+    "required": [
+        "feature_flag",
+        "incident_time_within_10min",
+        "feature_flag_match",
+        "mechanism_match",
+        "symptoms",
+    ],
+    "additionalProperties": False,
+}
+
+
+def build_judge_output_schema(rubrics_data: list[dict]) -> dict:
+    """Build a strict JSON Schema for the judge output: one verdict per rubric
+    + an overall ``score`` integer. Falls back to a minimal ``{score: int}``
+    schema when no rubrics are supplied (no-incident path).
+
+    Per-rubric cluster-array lengths vary across rubrics; rather than encode
+    a per-element schema (which Structured Outputs doesn't support), we leave
+    the array lengths unconstrained and rely on the prompt instructions to
+    keep cluster order matching.
+    """
+    if not rubrics_data:
+        return {
+            "type": "object",
+            "properties": {"score": {"type": "integer"}},
+            "required": ["score"],
+            "additionalProperties": False,
+        }
+
+    n = len(rubrics_data)
+    return {
+        "type": "object",
+        "properties": {
+            "rubrics": {
+                "type": "array",
+                "minItems": n,
+                "maxItems": n,
+                "items": _PER_RUBRIC_SCHEMA,
+            },
+            "score": {"type": "integer"},
+        },
+        "required": ["rubrics", "score"],
+        "additionalProperties": False,
+    }
+
+
+# ---------------------------------------------------------------------------
+# API call
+# ---------------------------------------------------------------------------
+
+
+async def async_call_llm_judge(
+    client: Any,
+    prompt: str,
+    model: str = DEFAULT_MODEL,
+    reasoning_effort: str | None = None,
+    output_schema: dict | None = None,
+) -> tuple[str, list[dict] | None]:
+    """Call the LLM judge via the OpenAI Responses API (falling back to Chat).
+
+    When ``output_schema`` is provided, uses Structured Outputs (strict JSON
+    Schema) so the returned text is guaranteed to conform to the schema.
+
+    Returns:
+        A tuple of (output_text, reasoning_summaries). reasoning_summaries is
+        None when reasoning_effort is not set.
+
+    """
+    text_format: dict[str, Any] = (
+        {
+            "type": "json_schema",
+            "name": "judge_response",
+            "schema": output_schema,
+            "strict": True,
+        }
+        if output_schema is not None
+        else {"type": "text"}
+    )
+    try:
+        kwargs: dict[str, Any] = {
+            "model": model,
+            "input": prompt,
+            "text": {"format": text_format},
+            "tools": [],
+            "store": True,
+            "max_output_tokens": 16384,
+        }
+        if reasoning_effort is not None:
+            kwargs["reasoning"] = {"effort": reasoning_effort, "summary": "auto"}
+        response = await client.responses.create(**kwargs)
+        reasoning_summaries = None
+        if reasoning_effort is not None:
+            reasoning_summaries = [
+                [
+                    s.model_dump() if hasattr(s, "model_dump") else s
+                    for s in item.summary
+                ]
+                for item in response.output
+                if getattr(item, "type", None) == "reasoning"
+                and getattr(item, "summary", None) is not None
+            ]
+        return response.output_text, reasoning_summaries
+    except Exception as exc:
+        if "404" not in str(exc):
+            raise
+        logger.info(
+            f"Responses API returned 404 for {model}, falling back to Chat Completions"
+        )
+        chat_kwargs: dict[str, Any] = {
+            "model": model,
+            "messages": [{"role": "user", "content": prompt}],
+            "max_tokens": 16384,
+        }
+        if output_schema is not None:
+            chat_kwargs["response_format"] = {
+                "type": "json_schema",
+                "json_schema": {
+                    "name": "judge_response",
+                    "schema": output_schema,
+                    "strict": True,
+                },
+            }
+        if reasoning_effort is not None:
+            chat_kwargs["reasoning_effort"] = reasoning_effort
+        response = await client.chat.completions.create(**chat_kwargs)
+        reasoning_summaries = None
+        if reasoning_effort is not None:
+            reasoning_content = getattr(
+                response.choices[0].message, "reasoning_content", None
+            )
+            if reasoning_content is not None:
+                reasoning_summaries = [{"type": "text", "text": reasoning_content}]
+            else:
+                reasoning_summaries = []
+        return response.choices[0].message.content, reasoning_summaries
+
+
+# ---------------------------------------------------------------------------
+# Parsing + aggregation
+# ---------------------------------------------------------------------------
+
+
+def parse_judge_response(response_text: str) -> dict:
+    """Parse the judge response JSON and range-check ``score``.
+
+    When Structured Outputs are used upstream, the response is already
+    schema-validated; this function only decodes the JSON and enforces the
+    0-3 range for ``score``.
+    """
+    parsed = json.loads(response_text)
+    score = int(parsed["score"])
+    if score < 0 or score > 3:
+        raise ValueError(f"Score {score} out of range [0, 3]")
+    parsed["score"] = score
+    return parsed
+
+
+def _aggregate_one_rubric(verdict: dict) -> dict:
+    """Roll up cluster verdicts for a single per-rubric judge entry."""
+    symptoms = verdict.get("symptoms", {}) or {}
+    metrics = symptoms.get("metrics", []) or []
+    logs = symptoms.get("logs", []) or []
+    traces = symptoms.get("traces", []) or []
+
+    metric_hits = [bool(m.get("family_match")) for m in metrics]
+    log_hits = [
+        bool(l.get("body_match")) and bool(l.get("service_name_match")) for l in logs
+    ]
+    trace_hits = [
+        bool(t.get("call_chain_match")) and bool(t.get("smoking_gun_match"))
+        for t in traces
+    ]
+
+    def _all(hits: list[bool]) -> bool | None:
+        return all(hits) if hits else None
+
+    def _any(hits: list[bool]) -> bool | None:
+        return any(hits) if hits else None
+
+    return {
+        "feature_flag": verdict.get("feature_flag", ""),
+        "incident_time_within_10min": bool(verdict.get("incident_time_within_10min")),
+        "feature_flag_match": bool(verdict.get("feature_flag_match")),
+        "mechanism_match": bool(verdict.get("mechanism_match")),
+        "metrics_all_match": _all(metric_hits),
+        "metrics_any_match": _any(metric_hits),
+        "logs_all_match": _all(log_hits),
+        "logs_any_match": _any(log_hits),
+        "traces_all_match": _all(trace_hits),
+        "traces_any_match": _any(trace_hits),
+    }
+
+
+def aggregate_judge_response(parsed: dict) -> dict:
+    """Aggregate per-rubric, per-cluster verdicts into flat any-of rollups.
+
+    The agent is credited if it matches any one of the listed rubrics.
+    Per-rubric rollups are computed via ``_aggregate_one_rubric``; the
+    task-level rollup is the ``any`` over rubrics for booleans (with ``None``
+    skipped — sections without clusters in any rubric stay ``None``).
+
+    The per-rubric rollups are also returned under ``per_rubric`` for
+    downstream analysis that needs to know which specific rubric matched.
+    """
+    rubrics = parsed.get("rubrics") or []
+    per_rubric = [_aggregate_one_rubric(r) for r in rubrics]
+
+    def _any_skip_none(values: list[bool | None]) -> bool | None:
+        truthy = [v for v in values if v is not None]
+        return any(truthy) if truthy else None
+
+    return {
+        "incident_time_within_10min": _any_skip_none(
+            [r["incident_time_within_10min"] for r in per_rubric]
+        )
+        or False,
+        "feature_flag_match": _any_skip_none(
+            [r["feature_flag_match"] for r in per_rubric]
+        )
+        or False,
+        "mechanism_match": _any_skip_none([r["mechanism_match"] for r in per_rubric])
+        or False,
+        "metrics_all_match": _any_skip_none(
+            [r["metrics_all_match"] for r in per_rubric]
+        ),
+        "metrics_any_match": _any_skip_none(
+            [r["metrics_any_match"] for r in per_rubric]
+        ),
+        "logs_all_match": _any_skip_none([r["logs_all_match"] for r in per_rubric]),
+        "logs_any_match": _any_skip_none([r["logs_any_match"] for r in per_rubric]),
+        "traces_all_match": _any_skip_none([r["traces_all_match"] for r in per_rubric]),
+        "traces_any_match": _any_skip_none([r["traces_any_match"] for r in per_rubric]),
+        "per_rubric": per_rubric,
+        "score": int(parsed["score"]),
+    }
+
+
+def string_match_fallback(expected: dict, predictions: str) -> dict:
+    """Fall back to case-insensitive string search for any plausible root_cause.
+
+    ``expected["events"]`` is a list of ``{"root_cause": <flag>, "event_time": ...}``;
+    the agent's report is credited if any listed root_cause appears in it.
+    Returns a result dict compatible with the judge output format.
+    """
+    events: list[dict] = expected.get("events") or []
+    if not events:
+        # No-incident task: agent should write an empty report.
+        return {"score": 3 if len(predictions.strip()) == 0 else 0}
+    text = predictions.lower()
+    found = any(e["root_cause"].strip().lower() in text for e in events)
+    return {"score": 3 if found else 0}
+
+
+# ---------------------------------------------------------------------------
+# Judge entry point (used by both modes)
+# ---------------------------------------------------------------------------
+
+
+async def judge(
+    client: Any,
+    expected: dict,
+    predictions: str,
+    rubrics_data: list[dict],
+    model: str = DEFAULT_MODEL,
+    reasoning_effort: str | None = None,
+) -> dict:
+    """Run the LLM judge over one or more ground-truth rubrics, or
+    short-circuit for no-incident tasks.
+
+    Returns:
+        A dict with keys: reward, mode, score, and (for LLM judge) model,
+        nested (raw judge response), reasoning_summary, rubric_used,
+        judge_prompt, judge_response_raw. Per-section rollups are derived
+        post-hoc from ``nested`` by formatters via ``aggregate_judge_response``.
+
+    """
+    events: list[dict] = expected.get("events") or []
+    if not events:
+        score = 3 if len(predictions.strip()) == 0 else 0
+        return {
+            "reward": score / 3.0,
+            "mode": "no_incident",
+            "model": model,
+            "score": score,
+        }
+
+    # Short-circuit when the agent emitted an empty report despite an incident.
+    # No LLM call can rescue this; score is a guaranteed 0. We synthesize the
+    # nested response shape (per-rubric all False, matching cluster counts)
+    # so that ``aggregate_judge_response`` produces the expected all-False
+    # rollups at load time.
+    if not predictions.strip():
+        synthetic_per_rubric = []
+        for rubric in rubrics_data:
+            symptoms = rubric.get("symptoms", {}) or {}
+            synthetic_per_rubric.append(
+                {
+                    "feature_flag": rubric.get("feature_flag", ""),
+                    "incident_time_within_10min": False,
+                    "feature_flag_match": False,
+                    "mechanism_match": False,
+                    "symptoms": {
+                        "metrics": [
+                            {
+                                "metric_family": m.get("metric_family", ""),
+                                "family_match": False,
+                            }
+                            for m in (symptoms.get("metrics") or [])
+                        ],
+                        "logs": [
+                            {"body_match": False, "service_name_match": False}
+                            for _ in (symptoms.get("logs") or [])
+                        ],
+                        "traces": [
+                            {"call_chain_match": False, "smoking_gun_match": False}
+                            for _ in (symptoms.get("traces") or [])
+                        ],
+                    },
+                }
+            )
+        return {
+            "mode": "empty_report",
+            "model": model,
+            "score": 0,
+            "reward": 0.0,
+            "rubric_used": bool(rubrics_data),
+            "nested": {"rubrics": synthetic_per_rubric, "score": 0},
+        }
+
+    prompt = build_judge_prompt(rubrics_data, predictions)
+    output_schema = build_judge_output_schema(rubrics_data)
+
+    raw_response, reasoning_summary = await async_call_llm_judge(
+        client,
+        prompt,
+        model=model,
+        reasoning_effort=reasoning_effort,
+        output_schema=output_schema,
+    )
+    parsed = parse_judge_response(raw_response)
+
+    # Per-section rollups are NOT spread into the result — they're a pure
+    # post-hoc derivation from ``nested`` via ``aggregate_judge_response``,
+    # applied by the formatters at load time so schema changes don't require
+    # rewriting saved JSONs.
+    return {
+        "mode": "llm_judge",
+        "model": model,
+        "score": parsed["score"],
+        "reward": parsed["score"] / 3.0,
+        "reasoning_summary": reasoning_summary,
+        "rubric_used": bool(rubrics_data),
+        "judge_prompt": prompt,
+        "judge_response_raw": raw_response,
+        "nested": parsed,
+    }
+
+
+# ---------------------------------------------------------------------------
+# CLI
+# ---------------------------------------------------------------------------
+
+
+async def main() -> None:
+    """Entry point: load expected + predictions, score, write reward/details."""
+    parser = argparse.ArgumentParser(
+        description="LLM-as-a-judge verifier for Harbor incident-RCA-report tasks."
+    )
+    parser.add_argument("--expected", type=str, default="/tests/expected.json")
+    parser.add_argument("--predictions", type=str, default="/app/report.md")
+    parser.add_argument(
+        "--rubrics-dir",
+        type=str,
+        default="/tests/rubrics",
+        help=(
+            "Directory containing one rubric JSON per plausible root cause "
+            "(e.g. /tests/rubrics/<event_id>.json). The judge scores the "
+            "agent against any one of them."
+        ),
+    )
+    parser.add_argument(
+        "--model", type=str, default=DEFAULT_MODEL, help="Judge LLM model name."
+    )
+    parser.add_argument(
+        "--effort",
+        type=str,
+        choices=["low", "medium", "high"],
+        default="high",
+        help="Reasoning effort level for the judge LLM (default: high).",
+    )
+    parser.add_argument(
+        "--mode",
+        type=str,
+        choices=["string_match", "llm_judge"],
+        default="string_match",
+        help="Scoring mode: string_match or llm_judge (default: string_match).",
+    )
+    parser.add_argument("--reward", type=str, default="/logs/verifier/reward.txt")
+    parser.add_argument("--details", type=str, default="/logs/verifier/details.json")
+    args = parser.parse_args()
+
+    expected_path = Path(args.expected)
+    predictions_path = Path(args.predictions)
+    rubrics_dir = Path(args.rubrics_dir)
+    reward_path = Path(args.reward)
+    details_path = Path(args.details)
+
+    try:
+        # Load expected
+        print(f"Loading expected results from {expected_path}...")
+        with expected_path.open() as f:
+            expected = json.load(f)
+
+        # Load predictions (markdown report)
+        print(f"Loading predictions from {predictions_path}...")
+        predictions = predictions_path.read_text()
+
+        # Load rubric JSONs — one per plausible root cause. Order is the
+        # filesystem sort order, which matches the build_harbor_tasks.py
+        # naming convention (event_id stems sort lexicographically).
+        rubrics_data: list[dict] = []
+        if expected.get("events"):
+            if rubrics_dir.is_dir():
+                rubric_paths = sorted(rubrics_dir.glob("*.json"))
+                for p in rubric_paths:
+                    with p.open() as f:
+                        rubrics_data.append(json.load(f))
+                print(f"Loaded {len(rubrics_data)} rubric(s) from {rubrics_dir}")
+            else:
+                print(f"Rubric directory missing: {rubrics_dir}")
+        else:
+            print("No incident events in expected results; skipping rubric load.")
+
+        # Run judge
+        if args.mode == "string_match":
+            em = string_match_fallback(expected, predictions)
+            result = {"reward": em["score"] / 3.0, "mode": "string_match", **em}
+        else:
+            from openai import AsyncOpenAI
+
+            client = AsyncOpenAI(
+                api_key=os.getenv("OPENAI_API_KEY"),
+                base_url=os.getenv("OPENAI_BASE_URL"),
+            )
+            result = await judge(
+                client,
+                expected,
+                predictions,
+                rubrics_data,
+                model=args.model,
+                reasoning_effort=args.effort,
+            )
+
+        # Write reward
+        reward_path.parent.mkdir(parents=True, exist_ok=True)
+        reward_path.write_text(str(result["reward"]))
+
+        # Write details
+        details_path.parent.mkdir(parents=True, exist_ok=True)
+        details_path.write_text(json.dumps(result, indent=2))
+
+        print(f"Score: {result.get('score', 'N/A')}/3 (reward: {result['reward']})")
+        print(f"Mode: {result['mode']}")
+        if result.get("reasoning_summary"):
+            print(f"Reasoning summary: {result['reasoning_summary']}")
+
+        if result["reward"] < 1.0:
+            sys.exit(1)
+
+    except Exception as exc:
+        reward_path.parent.mkdir(parents=True, exist_ok=True)
+        reward_path.write_text("0.0")
+        details_path.parent.mkdir(parents=True, exist_ok=True)
+        details_path.write_text(
+            json.dumps(
+                {
+                    "reward": 0.0,
+                    "error": f"{type(exc).__name__}: {exc}",
+                    "traceback": traceback.format_exc(),
+                },
+                indent=2,
+            )
+        )
+        print(f"Verifier error: {type(exc).__name__}: {exc}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

tasks/d1-i1-imageslowload-on-univ00-universal_ttd60m_at_off+10m/tests/expected.json

@@ -0,0 +1,9 @@
+{
+  "events": [
+    {
+      "event_id": "d1-i1-imageSlowLoad-on",
+      "root_cause": "imageSlowLoad",
+      "event_time": "2026-04-19T14:01:51.404464+00:00"
+    }
+  ]
+}

tasks/d1-i1-imageslowload-on-univ00-universal_ttd60m_at_off+10m/tests/rubrics/d1-i1-imageSlowLoad-on.json

@@ -0,0 +1,24 @@
+{
+  "incident_time": "2026-04-19T14:01:51.404464+00:00",
+  "feature_flag": "imageSlowLoad",
+  "description": "A feature flag in the frontend `ProductCard` React component added an `x-envoy-fault-delay-request` header (plus `Cache-Control: no-cache`) to every product-image fetch; Envoy honored the fault-injection header and artificially delayed each `GET /images/products/<picture>` response, so product thumbnails took seconds to render.",
+  "mechanism": "The flag is read in [`ProductCard.tsx#L32`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L32): the `ProductCard` React component calls `useNumberFlagValue('imageSlowLoad', 0)` to get the delay value in milliseconds (variants: `0` for off, `5000` for 5 sec, `10000` for 10 sec). When non-zero, the component sets the `x-envoy-fault-delay-request` header to the flag value on every product image fetch ([`ProductCard.tsx#L37`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L37)).\n\nThe image request is sent to `/images/products/<picture>`, which the frontend-proxy Envoy routes to the `image-provider` cluster ([`envoy.tmpl.yaml#L54-L55`](../../opentelemetry-demo/src/frontend-proxy/envoy.tmpl.yaml#L54)). Envoy's `envoy.filters.http.fault` filter is configured with `header_delay: {}` and 100% percentage ([`envoy.tmpl.yaml#L67-L74`](../../opentelemetry-demo/src/frontend-proxy/envoy.tmpl.yaml#L67)), meaning it honors the `x-envoy-fault-delay-request` header and injects the specified delay (in ms) before forwarding the request. Every product card image load is therefore delayed by the flag value (e.g. 5 or 10 seconds), causing the page to render with blank/loading images until the delayed responses arrive.",
+  "symptoms": {
+    "metrics": [],
+    "logs": [],
+    "frontend": [
+      {
+        "description": "Product card thumbnails on the homepage product grid (and the recommendations carousel on product/cart/checkout pages) render with a blank image placeholder for ~5 seconds before the actual thumbnail appears. The page text and layout render immediately; only the images are delayed. Affects every product card on every page load while the flag is on — the failure is silent slowness, not a visible error.",
+        "route": "GET /images/products/<picture>",
+        "deterministic": true,
+        "trigger_condition": "Every page load that renders a `ProductCard` component — homepage product grid (`/`), recommendations carousel on product detail (`/product/<id>`), cart, and checkout pages.",
+        "source_file": "src/frontend/components/ProductCard/ProductCard.tsx",
+        "source_line": 37,
+        "calling_service": "frontend",
+        "call_pattern": "ProductCard.useEffect ([`ProductCard.tsx#L34`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L34)) → fetch(`/images/products/<picture>`) with header `x-envoy-fault-delay-request: 5000` ([`ProductCard.tsx#L37`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L37)) → frontend-proxy Envoy → image-provider.",
+        "cause": "`useNumberFlagValue('imageSlowLoad', 0)` returns 5000 (the `5sec` variant value, [`demo.flagd.json` `imageSlowLoad.variants.5sec`](../../opentelemetry-demo/src/flagd/demo.flagd.json)). ProductCard sets `x-envoy-fault-delay-request: 5000` on every image fetch ([`ProductCard.tsx#L37`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L37)). The frontend-proxy `envoy.filters.http.fault` filter ([`envoy.tmpl.yaml#L67`](../../opentelemetry-demo/src/frontend-proxy/envoy.tmpl.yaml#L67)) honors this header and delays each image response by 5000ms before forwarding to image-provider, so each `<S.Image>` only resolves after that delay."
+      }
+    ],
+    "traces": []
+  }
+}

tasks/d1-i1-imageslowload-on-univ00-universal_ttd60m_at_off+10m/tests/test.sh

@@ -0,0 +1,19 @@
+#!/bin/bash
+set -euo pipefail
+
+set +e
+python /tests/check_prediction.py 2>&1 | tee /logs/verifier/log.txt
+status=${PIPESTATUS[0]}
+set -e
+
+# Preserve agent predictions even on verifier failure (Harbor deletes containers).
+if [[ -f /app/report.md ]]; then
+  mkdir -p /logs/verifier
+  cp /app/report.md /logs/verifier/report.md 2>/dev/null || true
+fi
+
+if [[ -f /app/task_meta.json ]]; then
+  cp /app/task_meta.json /logs/verifier/task_meta.json 2>/dev/null || true
+fi
+
+exit $status

tasks/d1-n1-loadgeneratorfloodhomepage-on-00-hard_ttd480m_range30m_off+10m/environment/Dockerfile

@@ -0,0 +1 @@
+FROM ag2435/sre-otel-snapshot:{code_tag}

tasks/d1-n1-loadgeneratorfloodhomepage-on-00-hard_ttd480m_range30m_off+10m/environment/docker-compose.yaml

@@ -0,0 +1,21 @@
+services:
+  main:
+    build:
+      context: ${CONTEXT_DIR}
+      pull: true
+    image: ${MAIN_IMAGE_NAME}
+    command: [ "sh", "-c", "sleep infinity" ]
+    privileged: true
+    environment:
+      - TEST_DIR=${TEST_DIR}
+      - CONTEXT_DIR=${CONTEXT_DIR}
+    volumes:
+      - /var/run/docker.sock:/var/run/docker.sock
+      - ${CONTEXT_DIR}:${CONTEXT_DIR}
+      - ${HOST_VERIFIER_LOGS_PATH}:${ENV_VERIFIER_LOGS_PATH}
+      - ${HOST_AGENT_LOGS_PATH}:${ENV_AGENT_LOGS_PATH}
+    deploy:
+      resources:
+        limits:
+          cpus: ${CPUS}
+          memory: ${MEMORY}

tasks/d1-n1-loadgeneratorfloodhomepage-on-00-hard_ttd480m_range30m_off+10m/solution/check_prediction.py

@@ -0,0 +1,1005 @@
+"""LLM-as-a-judge verifier for Harbor incident-RCA-report tasks.
+
+Supports two modes:
+
+1. **Harbor verifier** (default):
+       python /tests/check_prediction.py
+
+2. **Post-hoc single-trial**:
+       python check_prediction.py --expected expected.json --predictions report.md [--rubric rubric.json]
+
+Falls back to string-match scoring when OPENAI_API_KEY is not set.
+"""
+
+import argparse
+import asyncio
+import json
+import logging
+import os
+import sys
+import traceback
+from pathlib import Path
+from typing import Any
+
+from tabulate import tabulate
+
+logger = logging.getLogger(__name__)
+
+JUDGE_PROMPT_MULTI_HEADER = """\
+You are an expert SRE tasked with judging the quality of an AI-generated incident RCA report.
+
+You are given:
+1. **One or more** ground-truth rubrics. Each describes a plausible root cause, its incident time, mechanism, and symptoms. Several flags may have been active in the same window; the agent is credited if it correctly identifies **any one** of these rubrics.
+2. The SRE agent's incident RCA report.
+
+## SRE Agent's Incident RCA Report
+
+{predictions}
+
+## Ground-Truth Rubrics
+
+{rubrics}
+
+## Evaluation Questions
+
+For **each rubric** in order, answer every question with true or false. Base your answer only on evidence in the agent's report; if the report does not cite the required evidence, answer false. The output must contain one entry per rubric, in the same order, and must preserve cluster order within each rubric exactly as listed.
+
+For each rubric:
+
+- `incident_time_within_10min`: Did the agent's timeline place the incident start within ±10 minutes of this rubric's `incident_time`?
+- `feature_flag_match`: Did the agent identify this rubric's feature flag as a root cause? (The agent may name multiple flags; mark true if this flag is among them.)
+- `mechanism_match`: Did the agent correctly explain this rubric's mechanism — how the flag propagates to the user-visible failure?
+- For each metric/log/trace cluster listed for this rubric: per-cluster match flags as before.
+"""
+
+JUDGE_PROMPT_SCORING_FOOTER = """\
+
+## Overall Score
+
+Score the incident RCA report on a scale of 0 to 3. The agent is credited if it correctly identifies **any one** of the listed rubrics — score against the rubric the agent's report best matches. Scoring is based on content correctness only; do not penalize or reward for formatting, prose style, or structural polish. Materially incorrect or misleading claims count against the score: if the report would otherwise score N but also adds a materially wrong claim (e.g., invents an unrelated additional cause), drop to N-1 (floor at 0). A report that correctly identifies one root cause but introduces a misleading fabrication alongside it therefore scores 2, not 3. When applying this penalty, explicitly identify in your reasoning which specific claim is materially wrong — quote or paraphrase the offending text. Do not apply the penalty without naming the offending claim; missing detail or incomplete explanation does not qualify as a materially wrong claim. Naming several of the listed plausible root causes is **not** a materially wrong claim.
+
+- 0: AI findings are misaligned with every rubric's mechanism and completely miss the root cause
+- 1: AI verifies incident description — the report confirms symptoms described in the task prompt but does not investigate further
+- 2: AI makes correct progress beyond symptoms — the report identifies some of the ground-truth metrics, logs, or traces for at least one rubric and moves toward that root cause, but does not fully identify any single root cause
+- 3: AI nails at least one of the listed root causes — the report correctly identifies it, the mechanism, and the supporting signals
+
+Respond with ONLY a JSON object matching the provided output schema.
+"""
+
+DEFAULT_MODEL = "openai-gpt-5.4"
+
+
+# ---------------------------------------------------------------------------
+# Rubric rendering (JSON -> markdown)
+# ---------------------------------------------------------------------------
+
+
+def _format_log_clusters(clusters: list[dict], lines: list[str]) -> None:
+    """Render log clusters as markdown subsections."""
+    for cluster in clusters:
+        name = cluster.get("name", "Unknown")
+        count = cluster.get("count")
+        suffix = f" ({count} entries)" if count is not None else ""
+        lines.append(f"#### {name}{suffix}")
+        lines.append("")
+
+        description = cluster.get("description", "")
+        if description:
+            lines.append(description)
+            lines.append("")
+
+        cause = cluster.get("cause", "")
+        if cause:
+            lines.append(f"**Cause:** {cause}")
+            lines.append("")
+
+        source = cluster.get("source", "")
+        if source:
+            lines.append(f"**Source:** {source}")
+            lines.append("")
+
+        attrs = cluster.get("representative_attributes", {})
+        if attrs:
+            lines.append("**Representative attributes:**")
+            lines.append("")
+            rows = [[f"`{k}`", f"`{v}`"] for k, v in attrs.items()]
+            lines.append(tabulate(rows, headers=["Field", "Value"], tablefmt="github"))
+            lines.append("")
+
+        docs = cluster.get("log_documents", [])
+        if docs:
+            lines.append("**Log documents:**")
+            lines.append("")
+            rows = [
+                [f"`{d['_index']}`", f"`{d['_id']}`", d["@timestamp"]] for d in docs
+            ]
+            lines.append(
+                tabulate(
+                    rows, headers=["_index", "_id", "@timestamp"], tablefmt="github"
+                )
+            )
+            lines.append("")
+
+
+def _format_trace_clusters(clusters: list[dict], lines: list[str]) -> None:
+    """Render trace clusters as markdown subsections."""
+    for cluster in clusters:
+        name = cluster.get("name", "Unknown")
+        count = cluster.get("count")
+        suffix = f" ({count} traces)" if count is not None else ""
+        lines.append(f"#### {name}{suffix}")
+        lines.append("")
+
+        description = cluster.get("description", "")
+        if description:
+            lines.append(description)
+            lines.append("")
+
+        cause = cluster.get("cause", "")
+        if cause:
+            lines.append(f"**Cause:** {cause}")
+            lines.append("")
+
+        call_chain = cluster.get("call_chain", "")
+        if call_chain:
+            lines.append("**Call chain:**")
+            lines.append("")
+            lines.append("```")
+            lines.append(call_chain)
+            lines.append("```")
+            lines.append("")
+
+        smoking_gun = cluster.get("smoking_gun", [])
+        if smoking_gun:
+            lines.append("**Smoking-gun error messages:**")
+            lines.append("")
+            for msg in smoking_gun:
+                lines.append(f"- {msg}")
+            lines.append("")
+
+        docs = cluster.get("trace_documents", [])
+        if docs:
+            lines.append("**Trace documents:**")
+            lines.append("")
+            headers = ["traceID", "@timestamp"]
+            has_action = any("user_action" in d for d in docs)
+            if has_action:
+                headers.append("user_action")
+            rows = []
+            for d in docs:
+                row = [f"`{d['traceID']}`", d["@timestamp"]]
+                if has_action:
+                    row.append(d.get("user_action", ""))
+                rows.append(row)
+            lines.append(tabulate(rows, headers=headers, tablefmt="github"))
+            lines.append("")
+
+
+_LAYER_DESCRIPTIONS = {
+    "root_cause": "metric closest to the fault injection point",
+    "propagation": "intermediate services reflecting the error through the call chain",
+    "symptom": "user-facing impact visible to end users or clients",
+    "meta": "feature flag counters or internal plumbing",
+    "unknown": "unclassified",
+}
+
+_LAYER_ORDER = ["root_cause", "propagation", "symptom", "meta", "unknown"]
+
+
+def _format_onset(offset: int | None) -> str:
+    """Format an onset offset as '+Xs' or 'N/A'."""
+    if offset is None:
+        return "N/A"
+    return f"+{offset}s"
+
+
+def _format_label_values(labels: dict[str, str]) -> str:
+    """Format label values as a compact comma-separated string."""
+    if not labels:
+        return ""
+    return ", ".join(labels.values())
+
+
+def _earliest_onset(variants: list[dict]) -> int | None:
+    """Return the earliest onset_offset_seconds across variants, or None."""
+    offsets = [
+        v["onset_offset_seconds"]
+        for v in variants
+        if v.get("onset_offset_seconds") is not None
+    ]
+    return min(offsets) if offsets else None
+
+
+def _format_metrics_list(metrics_list: list[dict], lines: list[str]) -> None:
+    """Render metric families grouped by signal layer."""
+    by_layer: dict[str, list[dict]] = {}
+    for fam in metrics_list:
+        by_layer.setdefault(fam.get("signal_layer", "unknown"), []).append(fam)
+
+    for layer in _LAYER_ORDER:
+        layer_families = by_layer.get(layer, [])
+        if not layer_families:
+            continue
+
+        layer_onsets = [_earliest_onset(f["variants"]) for f in layer_families]
+        layer_onsets = [o for o in layer_onsets if o is not None]
+        layer_onset_str = (
+            f" (earliest onset: {_format_onset(min(layer_onsets))})"
+            if layer_onsets
+            else ""
+        )
+
+        display_layer = layer.replace("_", " ").title()
+        desc = _LAYER_DESCRIPTIONS.get(layer, "")
+        lines.append(f"**{display_layer}** — {desc}{layer_onset_str}")
+        lines.append("")
+
+        for fam in layer_families:
+            fam_onset = _earliest_onset(fam["variants"])
+            label_vals = _format_label_values(fam.get("defining_labels", {}))
+            label_part = f" ({label_vals})" if label_vals else ""
+            lines.append(
+                f"#### {fam['metric_family']} family{label_part}"
+                f" — onset: {_format_onset(fam_onset)}"
+            )
+            lines.append("")
+
+            first_desc = (
+                fam["variants"][0].get("description", "") if fam["variants"] else ""
+            )
+            if first_desc:
+                lines.append(first_desc)
+                lines.append("")
+
+            for v in fam["variants"]:
+                v_onset = _format_onset(v.get("onset_offset_seconds"))
+                lines.append(f"- **{v['type']}** (onset: {v_onset})")
+                lines.append(f"  `{v['query']}`")
+                lines.append("")
+
+
+def _format_frontend_issues(issues: list[dict], lines: list[str]) -> None:
+    """Render frontend issues as markdown subsections."""
+    for issue in issues:
+        route = issue.get("route", "Unknown route")
+        lines.append(f"#### {route}")
+        lines.append("")
+
+        description = issue.get("description", "")
+        if description:
+            lines.append(description)
+            lines.append("")
+
+        rows = [
+            ["Deterministic", str(issue.get("deterministic", ""))],
+            ["Trigger condition", issue.get("trigger_condition", "")],
+            ["Calling service", issue.get("calling_service", "")],
+            [
+                "Source",
+                f"`{issue.get('source_file', '')}:{issue.get('source_line', '')}`",
+            ],
+        ]
+        lines.append(tabulate(rows, headers=["Field", "Value"], tablefmt="github"))
+        lines.append("")
+
+        call_pattern = issue.get("call_pattern", "")
+        if call_pattern:
+            lines.append(f"**Call pattern:** {call_pattern}")
+            lines.append("")
+
+        cause = issue.get("cause", "")
+        if cause:
+            lines.append(f"**Cause:** {cause}")
+            lines.append("")
+
+
+def format_rubric(data: dict, include_frontend: bool = False) -> str:
+    """Convert a rubric JSON dict into a consistently formatted markdown string.
+
+    Args:
+        data: The rubric JSON dict.
+        include_frontend: If True, include the ``### Frontend`` section.
+            Defaults to False since frontend symptoms may be noisy for
+            downstream consumers (LLM judge, oracle solutions).
+            TODO(Albert): systematically test the impact of including vs.
+            excluding frontend symptoms on downstream consumers.
+
+    """
+    lines: list[str] = []
+
+    lines.append(f"# {data['feature_flag']}")
+    lines.append("")
+    lines.append(f"**Feature flag:** `{data['feature_flag']}`")
+    lines.append("")
+    lines.append(f"**Description:** {data['description']}")
+    lines.append("")
+    lines.append(f"**Incident time:** {data['incident_time']}")
+    lines.append("")
+
+    lines.append("## Mechanism")
+    lines.append("")
+    lines.append(data["mechanism"])
+    lines.append("")
+
+    interaction = data.get("interaction", "")
+    if interaction:
+        lines.append(f"**Interaction with other feature flags:** {interaction}")
+        lines.append("")
+
+    lines.append("## Evidence")
+    lines.append("")
+
+    gs = data["symptoms"]
+
+    metrics = gs.get("metrics", [])
+    lines.append("### Metrics")
+    lines.append("")
+    if metrics:
+        _format_metrics_list(metrics, lines)
+
+    logs = gs.get("logs", [])
+    lines.append("### Logs")
+    lines.append("")
+    if logs:
+        _format_log_clusters(logs, lines)
+
+    if include_frontend:
+        frontend = gs.get("frontend", [])
+        lines.append("### Frontend")
+        lines.append("")
+        if frontend:
+            _format_frontend_issues(frontend, lines)
+
+    traces = gs.get("traces", [])
+    lines.append("### Traces")
+    lines.append("")
+    if traces:
+        _format_trace_clusters(traces, lines)
+
+    return "\n".join(lines)
+
+
+# ---------------------------------------------------------------------------
+# Judge prompt + output-schema builders
+# ---------------------------------------------------------------------------
+
+
+def _render_checklist(rubric_data: dict) -> str:
+    """Build per-cluster checklist blocks for metrics/logs/traces."""
+    symptoms = rubric_data.get("symptoms", {}) or {}
+    metric_clusters = symptoms.get("metrics", []) or []
+    log_clusters = symptoms.get("logs", []) or []
+    trace_clusters = symptoms.get("traces", []) or []
+
+    blocks: list[str] = []
+
+    if metric_clusters:
+        lines = ["#### Metric clusters"]
+        for i, m in enumerate(metric_clusters):
+            family = m.get("metric_family", "")
+            lines.append(
+                f'- Cluster {i}: `metric_family = "{family}"`'
+                f" — family_match: did the agent cite a query targeting"
+                f" metric_family `{family}` under a Why-step whose causal chain"
+                f" aligns with the rubric?"
+            )
+        blocks.append("\n".join(lines))
+
+    if log_clusters:
+        lines = ["#### Log clusters"]
+        for i, log in enumerate(log_clusters):
+            attrs = log.get("representative_attributes") or {}
+            body = attrs.get("body", "")
+            service_name = attrs.get("resource.service.name", "")
+            lines.append(
+                f"- Cluster {i}:\n"
+                f"  - `resource.service.name`: `{service_name}`\n"
+                f"  - `body`: `{body}`\n"
+                f"  - body_match: did the agent cite log evidence whose body"
+                f" matches the rubric's `body` under a Why-step whose causal"
+                f" chain aligns with the rubric?\n"
+                f"  - service_name_match: did the agent attribute the cited"
+                f" log evidence to the OTel service `{service_name}`"
+                f" (`resource.service.name`)?"
+            )
+        blocks.append("\n".join(lines))
+
+    if trace_clusters:
+        lines = ["#### Trace clusters"]
+        for i, trace in enumerate(trace_clusters):
+            call_chain = trace.get("call_chain", "")
+            smoking_gun = trace.get("smoking_gun", []) or []
+            sg_rendered = "\n".join(f"    - {s}" for s in smoking_gun)
+            lines.append(
+                f"- Cluster {i}:\n"
+                f"  - call_chain: `{call_chain}`\n"
+                f"  - smoking_gun:\n{sg_rendered}\n"
+                f"  - call_chain_match: did the agent cite evidence matching"
+                f" this service-level call chain under a Why-step whose causal"
+                f" chain aligns with the rubric?\n"
+                f"  - smoking_gun_match: did the agent cite at least one of"
+                f" the listed smoking-gun signals?"
+            )
+        blocks.append("\n".join(lines))
+
+    return (
+        "\n\n".join(blocks)
+        if blocks
+        else "(No metric, log, or trace clusters in rubric.)"
+    )
+
+
+def build_judge_prompt(
+    rubrics_data: list[dict],
+    predictions: str,
+) -> str:
+    """Render the judge prompt for one or more ground-truth rubrics.
+
+    The prompt asks the LLM to evaluate the agent's report against **each**
+    rubric independently. The agent is credited if it correctly identifies
+    any one rubric (the overall score reflects the best match).
+    """
+    if not rubrics_data:
+        raise ValueError("build_judge_prompt called with no rubrics")
+
+    rubric_blocks: list[str] = []
+    checklist_blocks: list[str] = []
+    for i, rubric in enumerate(rubrics_data):
+        feature_flag = rubric.get("feature_flag", "")
+        rubric_blocks.append(
+            f"### Rubric {i + 1} of {len(rubrics_data)} — `{feature_flag}`\n\n"
+            + format_rubric(rubric)
+        )
+        checklist_blocks.append(
+            f"### Rubric {i + 1} of {len(rubrics_data)} — `{feature_flag}`\n\n"
+            + _render_checklist(rubric)
+        )
+
+    rubrics_text = "\n\n---\n\n".join(rubric_blocks)
+    checklist_text = "\n\n---\n\n".join(checklist_blocks)
+
+    header = JUDGE_PROMPT_MULTI_HEADER.format(
+        rubrics=rubrics_text,
+        predictions=predictions,
+    )
+    return header + "\n" + checklist_text + "\n" + JUDGE_PROMPT_SCORING_FOOTER
+
+
+_METRIC_ITEM_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        "metric_family": {"type": "string"},
+        "family_match": {"type": "boolean"},
+    },
+    "required": ["metric_family", "family_match"],
+    "additionalProperties": False,
+}
+
+_LOG_ITEM_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        "body_match": {"type": "boolean"},
+        "service_name_match": {"type": "boolean"},
+    },
+    "required": ["body_match", "service_name_match"],
+    "additionalProperties": False,
+}
+
+_TRACE_ITEM_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        "call_chain_match": {"type": "boolean"},
+        "smoking_gun_match": {"type": "boolean"},
+    },
+    "required": ["call_chain_match", "smoking_gun_match"],
+    "additionalProperties": False,
+}
+
+
+_PER_RUBRIC_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        "feature_flag": {"type": "string"},
+        "incident_time_within_10min": {"type": "boolean"},
+        "feature_flag_match": {"type": "boolean"},
+        "mechanism_match": {"type": "boolean"},
+        "symptoms": {
+            "type": "object",
+            "properties": {
+                "metrics": {"type": "array", "items": _METRIC_ITEM_SCHEMA},
+                "logs": {"type": "array", "items": _LOG_ITEM_SCHEMA},
+                "traces": {"type": "array", "items": _TRACE_ITEM_SCHEMA},
+            },
+            "required": ["metrics", "logs", "traces"],
+            "additionalProperties": False,
+        },
+    },
+    "required": [
+        "feature_flag",
+        "incident_time_within_10min",
+        "feature_flag_match",
+        "mechanism_match",
+        "symptoms",
+    ],
+    "additionalProperties": False,
+}
+
+
+def build_judge_output_schema(rubrics_data: list[dict]) -> dict:
+    """Build a strict JSON Schema for the judge output: one verdict per rubric
+    + an overall ``score`` integer. Falls back to a minimal ``{score: int}``
+    schema when no rubrics are supplied (no-incident path).
+
+    Per-rubric cluster-array lengths vary across rubrics; rather than encode
+    a per-element schema (which Structured Outputs doesn't support), we leave
+    the array lengths unconstrained and rely on the prompt instructions to
+    keep cluster order matching.
+    """
+    if not rubrics_data:
+        return {
+            "type": "object",
+            "properties": {"score": {"type": "integer"}},
+            "required": ["score"],
+            "additionalProperties": False,
+        }
+
+    n = len(rubrics_data)
+    return {
+        "type": "object",
+        "properties": {
+            "rubrics": {
+                "type": "array",
+                "minItems": n,
+                "maxItems": n,
+                "items": _PER_RUBRIC_SCHEMA,
+            },
+            "score": {"type": "integer"},
+        },
+        "required": ["rubrics", "score"],
+        "additionalProperties": False,
+    }
+
+
+# ---------------------------------------------------------------------------
+# API call
+# ---------------------------------------------------------------------------
+
+
+async def async_call_llm_judge(
+    client: Any,
+    prompt: str,
+    model: str = DEFAULT_MODEL,
+    reasoning_effort: str | None = None,
+    output_schema: dict | None = None,
+) -> tuple[str, list[dict] | None]:
+    """Call the LLM judge via the OpenAI Responses API (falling back to Chat).
+
+    When ``output_schema`` is provided, uses Structured Outputs (strict JSON
+    Schema) so the returned text is guaranteed to conform to the schema.
+
+    Returns:
+        A tuple of (output_text, reasoning_summaries). reasoning_summaries is
+        None when reasoning_effort is not set.
+
+    """
+    text_format: dict[str, Any] = (
+        {
+            "type": "json_schema",
+            "name": "judge_response",
+            "schema": output_schema,
+            "strict": True,
+        }
+        if output_schema is not None
+        else {"type": "text"}
+    )
+    try:
+        kwargs: dict[str, Any] = {
+            "model": model,
+            "input": prompt,
+            "text": {"format": text_format},
+            "tools": [],
+            "store": True,
+            "max_output_tokens": 16384,
+        }
+        if reasoning_effort is not None:
+            kwargs["reasoning"] = {"effort": reasoning_effort, "summary": "auto"}
+        response = await client.responses.create(**kwargs)
+        reasoning_summaries = None
+        if reasoning_effort is not None:
+            reasoning_summaries = [
+                [
+                    s.model_dump() if hasattr(s, "model_dump") else s
+                    for s in item.summary
+                ]
+                for item in response.output
+                if getattr(item, "type", None) == "reasoning"
+                and getattr(item, "summary", None) is not None
+            ]
+        return response.output_text, reasoning_summaries
+    except Exception as exc:
+        if "404" not in str(exc):
+            raise
+        logger.info(
+            f"Responses API returned 404 for {model}, falling back to Chat Completions"
+        )
+        chat_kwargs: dict[str, Any] = {
+            "model": model,
+            "messages": [{"role": "user", "content": prompt}],
+            "max_tokens": 16384,
+        }
+        if output_schema is not None:
+            chat_kwargs["response_format"] = {
+                "type": "json_schema",
+                "json_schema": {
+                    "name": "judge_response",
+                    "schema": output_schema,
+                    "strict": True,
+                },
+            }
+        if reasoning_effort is not None:
+            chat_kwargs["reasoning_effort"] = reasoning_effort
+        response = await client.chat.completions.create(**chat_kwargs)
+        reasoning_summaries = None
+        if reasoning_effort is not None:
+            reasoning_content = getattr(
+                response.choices[0].message, "reasoning_content", None
+            )
+            if reasoning_content is not None:
+                reasoning_summaries = [{"type": "text", "text": reasoning_content}]
+            else:
+                reasoning_summaries = []
+        return response.choices[0].message.content, reasoning_summaries
+
+
+# ---------------------------------------------------------------------------
+# Parsing + aggregation
+# ---------------------------------------------------------------------------
+
+
+def parse_judge_response(response_text: str) -> dict:
+    """Parse the judge response JSON and range-check ``score``.
+
+    When Structured Outputs are used upstream, the response is already
+    schema-validated; this function only decodes the JSON and enforces the
+    0-3 range for ``score``.
+    """
+    parsed = json.loads(response_text)
+    score = int(parsed["score"])
+    if score < 0 or score > 3:
+        raise ValueError(f"Score {score} out of range [0, 3]")
+    parsed["score"] = score
+    return parsed
+
+
+def _aggregate_one_rubric(verdict: dict) -> dict:
+    """Roll up cluster verdicts for a single per-rubric judge entry."""
+    symptoms = verdict.get("symptoms", {}) or {}
+    metrics = symptoms.get("metrics", []) or []
+    logs = symptoms.get("logs", []) or []
+    traces = symptoms.get("traces", []) or []
+
+    metric_hits = [bool(m.get("family_match")) for m in metrics]
+    log_hits = [
+        bool(l.get("body_match")) and bool(l.get("service_name_match")) for l in logs
+    ]
+    trace_hits = [
+        bool(t.get("call_chain_match")) and bool(t.get("smoking_gun_match"))
+        for t in traces
+    ]
+
+    def _all(hits: list[bool]) -> bool | None:
+        return all(hits) if hits else None
+
+    def _any(hits: list[bool]) -> bool | None:
+        return any(hits) if hits else None
+
+    return {
+        "feature_flag": verdict.get("feature_flag", ""),
+        "incident_time_within_10min": bool(verdict.get("incident_time_within_10min")),
+        "feature_flag_match": bool(verdict.get("feature_flag_match")),
+        "mechanism_match": bool(verdict.get("mechanism_match")),
+        "metrics_all_match": _all(metric_hits),
+        "metrics_any_match": _any(metric_hits),
+        "logs_all_match": _all(log_hits),
+        "logs_any_match": _any(log_hits),
+        "traces_all_match": _all(trace_hits),
+        "traces_any_match": _any(trace_hits),
+    }
+
+
+def aggregate_judge_response(parsed: dict) -> dict:
+    """Aggregate per-rubric, per-cluster verdicts into flat any-of rollups.
+
+    The agent is credited if it matches any one of the listed rubrics.
+    Per-rubric rollups are computed via ``_aggregate_one_rubric``; the
+    task-level rollup is the ``any`` over rubrics for booleans (with ``None``
+    skipped — sections without clusters in any rubric stay ``None``).
+
+    The per-rubric rollups are also returned under ``per_rubric`` for
+    downstream analysis that needs to know which specific rubric matched.
+    """
+    rubrics = parsed.get("rubrics") or []
+    per_rubric = [_aggregate_one_rubric(r) for r in rubrics]
+
+    def _any_skip_none(values: list[bool | None]) -> bool | None:
+        truthy = [v for v in values if v is not None]
+        return any(truthy) if truthy else None
+
+    return {
+        "incident_time_within_10min": _any_skip_none(
+            [r["incident_time_within_10min"] for r in per_rubric]
+        )
+        or False,
+        "feature_flag_match": _any_skip_none(
+            [r["feature_flag_match"] for r in per_rubric]
+        )
+        or False,
+        "mechanism_match": _any_skip_none([r["mechanism_match"] for r in per_rubric])
+        or False,
+        "metrics_all_match": _any_skip_none(
+            [r["metrics_all_match"] for r in per_rubric]
+        ),
+        "metrics_any_match": _any_skip_none(
+            [r["metrics_any_match"] for r in per_rubric]
+        ),
+        "logs_all_match": _any_skip_none([r["logs_all_match"] for r in per_rubric]),
+        "logs_any_match": _any_skip_none([r["logs_any_match"] for r in per_rubric]),
+        "traces_all_match": _any_skip_none([r["traces_all_match"] for r in per_rubric]),
+        "traces_any_match": _any_skip_none([r["traces_any_match"] for r in per_rubric]),
+        "per_rubric": per_rubric,
+        "score": int(parsed["score"]),
+    }
+
+
+def string_match_fallback(expected: dict, predictions: str) -> dict:
+    """Fall back to case-insensitive string search for any plausible root_cause.
+
+    ``expected["events"]`` is a list of ``{"root_cause": <flag>, "event_time": ...}``;
+    the agent's report is credited if any listed root_cause appears in it.
+    Returns a result dict compatible with the judge output format.
+    """
+    events: list[dict] = expected.get("events") or []
+    if not events:
+        # No-incident task: agent should write an empty report.
+        return {"score": 3 if len(predictions.strip()) == 0 else 0}
+    text = predictions.lower()
+    found = any(e["root_cause"].strip().lower() in text for e in events)
+    return {"score": 3 if found else 0}
+
+
+# ---------------------------------------------------------------------------
+# Judge entry point (used by both modes)
+# ---------------------------------------------------------------------------
+
+
+async def judge(
+    client: Any,
+    expected: dict,
+    predictions: str,
+    rubrics_data: list[dict],
+    model: str = DEFAULT_MODEL,
+    reasoning_effort: str | None = None,
+) -> dict:
+    """Run the LLM judge over one or more ground-truth rubrics, or
+    short-circuit for no-incident tasks.
+
+    Returns:
+        A dict with keys: reward, mode, score, and (for LLM judge) model,
+        nested (raw judge response), reasoning_summary, rubric_used,
+        judge_prompt, judge_response_raw. Per-section rollups are derived
+        post-hoc from ``nested`` by formatters via ``aggregate_judge_response``.
+
+    """
+    events: list[dict] = expected.get("events") or []
+    if not events:
+        score = 3 if len(predictions.strip()) == 0 else 0
+        return {
+            "reward": score / 3.0,
+            "mode": "no_incident",
+            "model": model,
+            "score": score,
+        }
+
+    # Short-circuit when the agent emitted an empty report despite an incident.
+    # No LLM call can rescue this; score is a guaranteed 0. We synthesize the
+    # nested response shape (per-rubric all False, matching cluster counts)
+    # so that ``aggregate_judge_response`` produces the expected all-False
+    # rollups at load time.
+    if not predictions.strip():
+        synthetic_per_rubric = []
+        for rubric in rubrics_data:
+            symptoms = rubric.get("symptoms", {}) or {}
+            synthetic_per_rubric.append(
+                {
+                    "feature_flag": rubric.get("feature_flag", ""),
+                    "incident_time_within_10min": False,
+                    "feature_flag_match": False,
+                    "mechanism_match": False,
+                    "symptoms": {
+                        "metrics": [
+                            {
+                                "metric_family": m.get("metric_family", ""),
+                                "family_match": False,
+                            }
+                            for m in (symptoms.get("metrics") or [])
+                        ],
+                        "logs": [
+                            {"body_match": False, "service_name_match": False}
+                            for _ in (symptoms.get("logs") or [])
+                        ],
+                        "traces": [
+                            {"call_chain_match": False, "smoking_gun_match": False}
+                            for _ in (symptoms.get("traces") or [])
+                        ],
+                    },
+                }
+            )
+        return {
+            "mode": "empty_report",
+            "model": model,
+            "score": 0,
+            "reward": 0.0,
+            "rubric_used": bool(rubrics_data),
+            "nested": {"rubrics": synthetic_per_rubric, "score": 0},
+        }
+
+    prompt = build_judge_prompt(rubrics_data, predictions)
+    output_schema = build_judge_output_schema(rubrics_data)
+
+    raw_response, reasoning_summary = await async_call_llm_judge(
+        client,
+        prompt,
+        model=model,
+        reasoning_effort=reasoning_effort,
+        output_schema=output_schema,
+    )
+    parsed = parse_judge_response(raw_response)
+
+    # Per-section rollups are NOT spread into the result — they're a pure
+    # post-hoc derivation from ``nested`` via ``aggregate_judge_response``,
+    # applied by the formatters at load time so schema changes don't require
+    # rewriting saved JSONs.
+    return {
+        "mode": "llm_judge",
+        "model": model,
+        "score": parsed["score"],
+        "reward": parsed["score"] / 3.0,
+        "reasoning_summary": reasoning_summary,
+        "rubric_used": bool(rubrics_data),
+        "judge_prompt": prompt,
+        "judge_response_raw": raw_response,
+        "nested": parsed,
+    }
+
+
+# ---------------------------------------------------------------------------
+# CLI
+# ---------------------------------------------------------------------------
+
+
+async def main() -> None:
+    """Entry point: load expected + predictions, score, write reward/details."""
+    parser = argparse.ArgumentParser(
+        description="LLM-as-a-judge verifier for Harbor incident-RCA-report tasks."
+    )
+    parser.add_argument("--expected", type=str, default="/tests/expected.json")
+    parser.add_argument("--predictions", type=str, default="/app/report.md")
+    parser.add_argument(
+        "--rubrics-dir",
+        type=str,
+        default="/tests/rubrics",
+        help=(
+            "Directory containing one rubric JSON per plausible root cause "
+            "(e.g. /tests/rubrics/<event_id>.json). The judge scores the "
+            "agent against any one of them."
+        ),
+    )
+    parser.add_argument(
+        "--model", type=str, default=DEFAULT_MODEL, help="Judge LLM model name."
+    )
+    parser.add_argument(
+        "--effort",
+        type=str,
+        choices=["low", "medium", "high"],
+        default="high",
+        help="Reasoning effort level for the judge LLM (default: high).",
+    )
+    parser.add_argument(
+        "--mode",
+        type=str,
+        choices=["string_match", "llm_judge"],
+        default="string_match",
+        help="Scoring mode: string_match or llm_judge (default: string_match).",
+    )
+    parser.add_argument("--reward", type=str, default="/logs/verifier/reward.txt")
+    parser.add_argument("--details", type=str, default="/logs/verifier/details.json")
+    args = parser.parse_args()
+
+    expected_path = Path(args.expected)
+    predictions_path = Path(args.predictions)
+    rubrics_dir = Path(args.rubrics_dir)
+    reward_path = Path(args.reward)
+    details_path = Path(args.details)
+
+    try:
+        # Load expected
+        print(f"Loading expected results from {expected_path}...")
+        with expected_path.open() as f:
+            expected = json.load(f)
+
+        # Load predictions (markdown report)
+        print(f"Loading predictions from {predictions_path}...")
+        predictions = predictions_path.read_text()
+
+        # Load rubric JSONs — one per plausible root cause. Order is the
+        # filesystem sort order, which matches the build_harbor_tasks.py
+        # naming convention (event_id stems sort lexicographically).
+        rubrics_data: list[dict] = []
+        if expected.get("events"):
+            if rubrics_dir.is_dir():
+                rubric_paths = sorted(rubrics_dir.glob("*.json"))
+                for p in rubric_paths:
+                    with p.open() as f:
+                        rubrics_data.append(json.load(f))
+                print(f"Loaded {len(rubrics_data)} rubric(s) from {rubrics_dir}")
+            else:
+                print(f"Rubric directory missing: {rubrics_dir}")
+        else:
+            print("No incident events in expected results; skipping rubric load.")
+
+        # Run judge
+        if args.mode == "string_match":
+            em = string_match_fallback(expected, predictions)
+            result = {"reward": em["score"] / 3.0, "mode": "string_match", **em}
+        else:
+            from openai import AsyncOpenAI
+
+            client = AsyncOpenAI(
+                api_key=os.getenv("OPENAI_API_KEY"),
+                base_url=os.getenv("OPENAI_BASE_URL"),
+            )
+            result = await judge(
+                client,
+                expected,
+                predictions,
+                rubrics_data,
+                model=args.model,
+                reasoning_effort=args.effort,
+            )
+
+        # Write reward
+        reward_path.parent.mkdir(parents=True, exist_ok=True)
+        reward_path.write_text(str(result["reward"]))
+
+        # Write details
+        details_path.parent.mkdir(parents=True, exist_ok=True)
+        details_path.write_text(json.dumps(result, indent=2))
+
+        print(f"Score: {result.get('score', 'N/A')}/3 (reward: {result['reward']})")
+        print(f"Mode: {result['mode']}")
+        if result.get("reasoning_summary"):
+            print(f"Reasoning summary: {result['reasoning_summary']}")
+
+        if result["reward"] < 1.0:
+            sys.exit(1)
+
+    except Exception as exc:
+        reward_path.parent.mkdir(parents=True, exist_ok=True)
+        reward_path.write_text("0.0")
+        details_path.parent.mkdir(parents=True, exist_ok=True)
+        details_path.write_text(
+            json.dumps(
+                {
+                    "reward": 0.0,
+                    "error": f"{type(exc).__name__}: {exc}",
+                    "traceback": traceback.format_exc(),
+                },
+                indent=2,
+            )
+        )
+        print(f"Verifier error: {type(exc).__name__}: {exc}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

tasks/d1-n1-loadgeneratorfloodhomepage-on-00-hard_ttd480m_range30m_off+10m/solution/rubric.json

@@ -0,0 +1,24 @@
+{
+  "incident_time": "2026-04-19T14:01:51.404464+00:00",
+  "feature_flag": "imageSlowLoad",
+  "description": "A feature flag in the frontend `ProductCard` React component added an `x-envoy-fault-delay-request` header (plus `Cache-Control: no-cache`) to every product-image fetch; Envoy honored the fault-injection header and artificially delayed each `GET /images/products/<picture>` response, so product thumbnails took seconds to render.",
+  "mechanism": "The flag is read in [`ProductCard.tsx#L32`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L32): the `ProductCard` React component calls `useNumberFlagValue('imageSlowLoad', 0)` to get the delay value in milliseconds (variants: `0` for off, `5000` for 5 sec, `10000` for 10 sec). When non-zero, the component sets the `x-envoy-fault-delay-request` header to the flag value on every product image fetch ([`ProductCard.tsx#L37`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L37)).\n\nThe image request is sent to `/images/products/<picture>`, which the frontend-proxy Envoy routes to the `image-provider` cluster ([`envoy.tmpl.yaml#L54-L55`](../../opentelemetry-demo/src/frontend-proxy/envoy.tmpl.yaml#L54)). Envoy's `envoy.filters.http.fault` filter is configured with `header_delay: {}` and 100% percentage ([`envoy.tmpl.yaml#L67-L74`](../../opentelemetry-demo/src/frontend-proxy/envoy.tmpl.yaml#L67)), meaning it honors the `x-envoy-fault-delay-request` header and injects the specified delay (in ms) before forwarding the request. Every product card image load is therefore delayed by the flag value (e.g. 5 or 10 seconds), causing the page to render with blank/loading images until the delayed responses arrive.",
+  "symptoms": {
+    "metrics": [],
+    "logs": [],
+    "frontend": [
+      {
+        "description": "Product card thumbnails on the homepage product grid (and the recommendations carousel on product/cart/checkout pages) render with a blank image placeholder for ~5 seconds before the actual thumbnail appears. The page text and layout render immediately; only the images are delayed. Affects every product card on every page load while the flag is on — the failure is silent slowness, not a visible error.",
+        "route": "GET /images/products/<picture>",
+        "deterministic": true,
+        "trigger_condition": "Every page load that renders a `ProductCard` component — homepage product grid (`/`), recommendations carousel on product detail (`/product/<id>`), cart, and checkout pages.",
+        "source_file": "src/frontend/components/ProductCard/ProductCard.tsx",
+        "source_line": 37,
+        "calling_service": "frontend",
+        "call_pattern": "ProductCard.useEffect ([`ProductCard.tsx#L34`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L34)) → fetch(`/images/products/<picture>`) with header `x-envoy-fault-delay-request: 5000` ([`ProductCard.tsx#L37`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L37)) → frontend-proxy Envoy → image-provider.",
+        "cause": "`useNumberFlagValue('imageSlowLoad', 0)` returns 5000 (the `5sec` variant value, [`demo.flagd.json` `imageSlowLoad.variants.5sec`](../../opentelemetry-demo/src/flagd/demo.flagd.json)). ProductCard sets `x-envoy-fault-delay-request: 5000` on every image fetch ([`ProductCard.tsx#L37`](../../opentelemetry-demo/src/frontend/components/ProductCard/ProductCard.tsx#L37)). The frontend-proxy `envoy.filters.http.fault` filter ([`envoy.tmpl.yaml#L67`](../../opentelemetry-demo/src/frontend-proxy/envoy.tmpl.yaml#L67)) honors this header and delays each image response by 5000ms before forwarding to image-provider, so each `<S.Image>` only resolves after that delay."
+      }
+    ],
+    "traces": []
+  }
+}