Add a benchmark

# my_pkg/echo_suite.py
from clousight_bench import (
    BenchmarkSuite, Evaluator, DatasetHandle, EnvHandle, RawArtifacts,
    Target, DriverContext, Measurement,
)
import json, tempfile
from pathlib import Path


class EchoSuite(BenchmarkSuite):
    suite_id = "echo"                 # == entry-point name == measurement namespace
    suite_version = "echo/v1"         # provenance pin; bump when the dataset/harness changes

    def resolve(self, cfg, assets):   # offline: choose the dataset/subset
        n = int(cfg.get("n", 3))
        return DatasetHandle(version=self.suite_version, digest=f"sha256:echo-{n}", payload={"n": n})

    def prepare(self, target, dataset, driver):   # connect/provision (mock → nothing)
        return EnvHandle({"n": dataset.payload["n"]})

    def run(self, target, env, driver) -> RawArtifacts:
        return self._emit(env.payload["n"])       # real path would call the SUT here

    def mock_artifacts(self, cfg) -> RawArtifacts:  # offline fixture path (CI / mode: mock)
        return self._emit(int(cfg.get("n", 3)))

    def _emit(self, n: int) -> RawArtifacts:
        d = Path(tempfile.mkdtemp())
        rows = [{"id": f"q{i}", "correct": True} for i in range(n)]
        (d / "results.json").write_text(json.dumps(rows))
        return RawArtifacts(dir=d, manifest={"results": {"path": "results.json"}})


class OfficialEchoEvaluator(Evaluator):
    evaluator_id = "official-echo-evaluator"
    official = True                    # emits under the "echo." namespace

    def supports(self, suite_id, product) -> bool:
        return suite_id == "echo"

    def evaluate(self, raw) -> dict[str, Measurement]:
        try:
            rows = json.loads(raw.path("results").read_text())
        except Exception:              # fail-safe: never raise on a missing/corrupt artifact
            return {}
        total = len(rows) or 1
        passed = sum(1 for r in rows if r.get("correct"))
        return {"echo.pass_rate": Measurement(
            value=passed / total, unit="ratio",
            reproducibility_class="deterministic", official=True, sample_count=len(rows),
        )}

# pyproject.toml
[project.entry-points."clousight_bench.benchmark_suites"]
echo = "my_pkg.echo_suite:EchoSuite"

[project.entry-points."clousight_bench.evaluators"]
official-echo-evaluator = "my_pkg.echo_suite:OfficialEchoEvaluator"

pip install -e .          # register the entry points
csbench list             # → suite:echo shows up
csbench conformance --suite echo                         # namespace + official-flag checks
printf 'target:\n  mode: mock\n' > mock.yaml
csbench run --domain agent-runtime --benchmark echo --platform local-sim --config mock.yaml   # ✅

progress.phase(label: str, total: int = 0, *, unit: str = "", reports_progress: bool = True) -> None
progress.advance(n: int = 1, *, label: str = "") -> None
progress.step(name: str, start_ms: float, end_ms: float, *, status: str = "ok", parent: str = "") -> None
progress.sample(key: str, value: float) -> None
progress.log(msg: str, *, level: str = "INFO") -> None
progress.should_cancel() -> bool

def _reported(row: dict[str, Any], start: float, end: float) -> None:
    """One finished query — drawn on the waterfall, sampled, counted.

    Runs between two queries: the row's ``latency_ms`` was already taken,
    and every measurement this path feeds (total runtime, geomean) sums
    per-query intervals, so the gap this occupies is not measured.
    """
    name = f"{self.suite_id}.q{row['query_nr']}"
    progress.step(name, clock.ms(start), clock.ms(end), parent=parent)
    progress.sample(f"{self.suite_id}.latency_ms", float(row["latency_ms"]))
    progress.advance()
    raise_if_cancelled(progress, f"{self.suite_id} query set")

progress.phase("Query set", total=len(query_ids), unit="query")

progress.phase("Throughput Test", total=total_queries, unit="query", reports_progress=False)
tp_start = clock()
doc["throughput"] = run_throughput(..., poll=lambda: progress.check_cancel("throughput test"))
progress.replay_throughput(doc["throughput"], start=tp_start)