tare-cli 0.2.0__py3-none-any.whl

tare/cliff.py

@@ -0,0 +1,183 @@
+"""Cliff: where did a failed run become lost (epic Cliff).
+
+The original run fails its check. Tails resumed from each capsule show how often the run
+could still have passed from that point. The baseline is a fresh start (step 0). A step
+is high when its tails pass at least half as often as the baseline, low otherwise.
+Bisection narrows the gap between the last high and the first low step; then more tails
+go to that pair until their Wilson intervals separate or the budget runs out. The result
+is a range, not a single step, unless the evidence says more.
+"""
+import math
+from concurrent.futures import ThreadPoolExecutor
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from . import capsule as caps
+from . import usage as usages
+from .journal import Journal
+
+Z = 1.96  # 95 % intervals
+
+
+def wilson(passes: int, n: int) -> tuple[float, float]:
+    if n == 0:
+        return 0.0, 1.0
+    p = passes / n
+    denominator = 1 + Z * Z / n
+    centre = (p + Z * Z / (2 * n)) / denominator
+    half = Z * math.sqrt(p * (1 - p) / n + Z * Z / (4 * n * n)) / denominator
+    return max(0.0, centre - half), min(1.0, centre + half)
+
+
+@dataclass
+class Search:
+    results: dict[int, list[bool]] = field(default_factory=dict)
+    verdict: str = ""
+    cliff: tuple[int, int] | None = None  # (last high step, first low step)
+    separated: bool = False
+    exhausted: bool = False
+    rebounds: list[int] = field(default_factory=list)  # high steps after the first low one
+    spent: int = 0
+
+    def rate(self, step: int) -> float:
+        return sum(self.results[step]) / len(self.results[step])
+
+    def interval(self, step: int) -> tuple[float, float]:
+        return wilson(sum(self.results[step]), len(self.results[step]))
+
+
+def search(probe, last: int, tails: int, budget: int, gap_below: float = 0.2) -> Search:
+    """probe(step, n) runs n tails from a capsule and returns whether each passed."""
+    s = Search()
+
+    def run(step: int, n: int) -> bool:
+        n = min(n, budget - s.spent)
+        if n <= 0:
+            s.exhausted = True
+            return False
+        s.results.setdefault(step, []).extend(probe(step, n))
+        s.spent += n
+        return True
+
+    run(0, tails)
+    # 0/3 still allows a rate of 0.56: sample the baseline until a gap is clear, or it passes once
+    while s.rate(0) == 0 and s.interval(0)[1] >= gap_below and run(0, tails):
+        pass
+    if s.rate(0) == 0:
+        n, hi = len(s.results[0]), s.interval(0)[1]
+        clear = hi < gap_below
+        s.verdict = (f"A fresh start fails too: {n} of {n} failed, so the upper end of the baseline's 95% interval is {hi:.2f}. The task "
+                     "is too hard for the model (a model gap), so there is no cliff to find." if clear else
+                     f"No fresh start passed in {n} tails, so the upper end of the baseline's 95% interval is {hi:.2f}. The budget ran "
+                     "out before a model gap was clear.")
+        return s
+    run(last, tails)
+    unlucky = ("Continued from its last step, the run still passes at least half as often as a fresh start. "
+               "The original run was unlucky, not lost.")
+
+    while True:
+        tau = s.rate(0) / 2
+        probed = sorted(s.results)
+        lows = [step for step in probed if step > 0 and s.rate(step) < tau]
+        if not lows:
+            s.cliff, s.verdict = None, unlucky
+            return s
+        low = min(lows)
+        high = max(step for step in probed if step < low and s.rate(step) >= tau)
+        s.cliff = (high, low)
+        if low - high > 1:
+            if not run((high + low) // 2, tails):
+                break
+            continue
+        if s.interval(high)[0] > s.interval(low)[1]:
+            s.separated = True
+            break
+        if not (run(high, tails) and run(low, tails)):
+            break
+    s.rebounds = [step for step in sorted(s.results) if step > s.cliff[1] and s.rate(step) >= s.rate(0) / 2]
+
+    high, low = s.cliff
+    if low - high > 1:
+        s.verdict = f"Lost somewhere between step {high} and step {low}. The budget ran out before the range narrowed."
+    elif s.separated:
+        s.verdict = f"The run became lost at step {low}."
+    else:
+        s.verdict = (f"Most likely lost at step {low}. The intervals of steps {high} and {low} still overlap, and the "
+                     "budget ran out.")
+    return s
+
+
+def cliff(agent, real, project: Path, prompt: str, check: str, out: Path, *, tails: int = 3, budget: int = 30,
+          jobs: int = 3, claude_args: list[str] | None = None, env: dict[str, str] | None = None,
+          journal: Journal | None = None, gap_below: float = 0.2) -> str:
+    """The whole move: original run, capsules, baseline, search, report. Returns the report."""
+    claude_args = claude_args or []
+    journal = journal or Journal(None)
+    journal("start", kind="cliff", task=prompt, check=check, project=str(project), tails=tails, budget=budget,
+            sides={"a": {"agent": agent.name, "args": claude_args, "dir": ".", "billing": usages.billing(agent, real)}})
+    journal("phase", phase="original run")
+    caps.record(agent, real, project, out, prompt, claude_args, env)
+    passed, detail, spent = caps.check_original(agent, out, check)
+    header = [f"tare cliff · {agent.name} · {project}", f"  task      {prompt}", f"  check     {check}"]
+    steps = caps.capsules(out, agent)
+    journal("original", side="a", passed=passed, detail=detail, steps=[s.tool for s in steps], **spent)
+    if passed:
+        return _write(out, header + [f"  original  passed ({detail}): there is no cliff to find"], journal)
+    header.append(f"  original  failed ({detail}) after {len(steps) - 1} steps")
+    if len(steps) == 1:
+        return _write(out, header + ["  The run made no tool calls, so there is no step to continue from."], journal)
+    journal("phase", phase="tails")
+
+    counts: dict[int, int] = {}
+    events = agent.trail(caps.session_lines(out)).events
+
+    def tail(step: int, i: int) -> caps.Tail:
+        native = step == 0 or agent.native_resume
+        name = f"{step:04d}-{i}"
+        journal("tail", id=name, status="running", step=step, room="a", agent="a", agent_name=agent.name,
+                kind="native" if native else "handoff", dir=f"tails/{name}")
+        if native:
+            result = caps.run_tail(agent, real, out, steps[step], prompt, claude_args, check, i, env)
+        else:
+            result = caps.run_handoff(agent, real, out / "tails" / name, steps[step], events, prompt,
+                                      claude_args, check, env)
+        journal("tail", id=name, status="passed" if result.passed else "failed", detail=result.detail,
+                usage=result.usage, check_usage=result.check_usage)
+        return result
+
+    def probe(step: int, n: int) -> list[bool]:
+        start = counts.get(step, 0)
+        counts[step] = start + n
+        with ThreadPoolExecutor(max_workers=jobs) as pool:
+            return [t.passed for t in pool.map(lambda i: tail(step, i), range(start, start + n))]
+
+    s = search(probe, len(steps) - 1, tails, budget, gap_below)
+    return _write(out, header + report(s, steps, budget), journal)
+
+
+def report(s: Search, steps: list, budget: int) -> list[str]:
+    lines = ["", "  step  what the step did                                      tails  pass  rate  95% interval"]
+    for step in sorted(s.results):
+        lo, hi = s.interval(step)
+        marker = " <" if s.cliff and step == s.cliff[1] else ""
+        lines.append(f"  {step:>4}  {steps[step].tool[:52]:<52}  {len(s.results[step]):>5}  {sum(s.results[step]):>4}"
+                     f"  {s.rate(step):.2f}  {lo:.2f}-{hi:.2f}{marker}")
+    lines += ["", f"  verdict   {s.verdict}"]
+    if s.cliff and s.cliff[1] - s.cliff[0] == 1:
+        step = steps[s.cliff[1]]
+        changed = caps.changed_files(steps[s.cliff[0]].archive, step.archive)
+        lines.append(f"  at step {step.step}: {step.tool}")
+        lines.append(f"  changed   {', '.join(changed[:10]) or 'no files (the conversation changed, not the workspace)'}")
+    if s.cliff:
+        lines.append("  monotone  " + ("yes: no step after the cliff passes again" if not s.rebounds else
+                                       f"no: steps {', '.join(map(str, s.rebounds))} pass again after the cliff"))
+    lines.append(f"  tails     {s.spent} of a budget of {budget}")
+    return lines
+
+
+def _write(out: Path, lines: list[str], journal: Journal) -> str:
+    text = "\n".join(lines + usages.report(out)) + "\n"
+    (out / "report.txt").write_text(text)
+    journal("report", text=text)
+    journal("phase", phase="done")
+    return text

tare/dashboard.html

@@ -0,0 +1,269 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>tare live</title>
+<style>
+:root {
+  --bg: #0e1116; --panel: #161b22; --panel-2: #1c222b; --line: #2a313c; --text: #e6edf3; --muted: #8b96a5;
+  --pass: #3fb950; --fail: #f85149; --run: #d29922; --accent: #79c0ff; --threshold: #a371f7;
+  --mono: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+}
+@media (prefers-color-scheme: light) {
+  :root { --bg: #f6f8fa; --panel: #ffffff; --panel-2: #f0f3f6; --line: #d0d7de; --text: #1f2328; --muted: #59636e;
+          --pass: #1a7f37; --fail: #cf222e; --run: #9a6700; --accent: #0969da; --threshold: #8250df; }
+}
+* { box-sizing: border-box; }
+body { margin: 0; background: var(--bg); color: var(--text); font: 14px/1.45 system-ui, -apple-system, "Segoe UI", sans-serif; }
+main { max-width: 1180px; margin: 0 auto; padding: 20px 16px 60px; }
+header { display: flex; flex-wrap: wrap; align-items: center; gap: 12px; margin-bottom: 16px; }
+h1 { font: 600 22px/1 var(--mono); margin: 0; letter-spacing: .5px; }
+h2 { font-size: 13px; text-transform: uppercase; letter-spacing: .08em; color: var(--muted); margin: 0 0 10px; font-weight: 600; }
+.chip { display: inline-flex; align-items: center; gap: 6px; padding: 3px 10px; border-radius: 999px; background: var(--panel-2);
+        border: 1px solid var(--line); font-size: 12px; white-space: nowrap; }
+.dot { width: 8px; height: 8px; border-radius: 50%; background: var(--muted); display: inline-block; flex: none; }
+.dot.pass { background: var(--pass); } .dot.fail { background: var(--fail); } .dot.run { background: var(--run); animation: pulse 1.2s infinite; }
+@keyframes pulse { 50% { opacity: .35; } }
+.muted { color: var(--muted); }
+.grid { display: grid; gap: 14px; grid-template-columns: repeat(auto-fit, minmax(320px, 1fr)); }
+section.panel { background: var(--panel); border: 1px solid var(--line); border-radius: 10px; padding: 14px 16px; margin-bottom: 14px; }
+.kv { display: grid; grid-template-columns: 90px 1fr; gap: 4px 12px; }
+.kv div:nth-child(odd) { color: var(--muted); }
+code, pre, .mono { font-family: var(--mono); font-size: 12.5px; }
+pre { margin: 0; white-space: pre-wrap; word-break: break-word; }
+.steps { display: flex; flex-wrap: wrap; gap: 4px; margin-top: 8px; }
+.step { min-width: 26px; padding: 2px 6px; border-radius: 6px; background: var(--panel-2); border: 1px solid var(--line);
+        font: 11px var(--mono); text-align: center; }
+.step.cliff { border-color: var(--fail); color: var(--fail); font-weight: 700; }
+table { width: 100%; border-collapse: collapse; }
+th, td { text-align: left; padding: 6px 8px; border-bottom: 1px solid var(--line); vertical-align: top; }
+th { color: var(--muted); font-weight: 500; font-size: 12px; }
+td.num { font-family: var(--mono); white-space: nowrap; }
+.matrix { display: grid; grid-template-columns: 96px 1fr 1fr; gap: 6px; align-items: stretch; margin: 8px 0; }
+.matrix .head { color: var(--muted); font-size: 12px; align-self: end; }
+.cell { background: var(--panel-2); border: 1px solid var(--line); border-radius: 8px; padding: 8px; min-height: 58px; }
+.cell .big { font: 600 18px var(--mono); }
+.dots { display: flex; gap: 3px; flex-wrap: wrap; margin-top: 4px; }
+.effect { font-family: var(--mono); font-size: 12.5px; }
+.bar { height: 6px; border-radius: 3px; background: var(--panel-2); overflow: hidden; margin-top: 6px; }
+.bar > i { display: block; height: 100%; background: var(--accent); }
+.activity { font-family: var(--mono); font-size: 12px; color: var(--muted); overflow-wrap: anywhere; }
+details summary { cursor: pointer; color: var(--muted); }
+svg text { fill: var(--muted); font: 11px var(--mono); }
+.empty { color: var(--muted); font-style: italic; }
+.stale { color: var(--run); }
+</style>
+</head>
+<body>
+<main>
+  <header>
+    <a id="back" href="../../" style="display:none;color:var(--accent);text-decoration:none">← all runs</a>
+    <h1 id="title">tare</h1>
+    <span class="chip" id="phase"><span class="dot"></span><span>connecting</span></span>
+    <span class="chip" id="elapsed"></span>
+    <span class="muted" id="updated"></span>
+  </header>
+  <div id="app"><p class="empty">Waiting for the run to start…</p></div>
+</main>
+<script>
+const $ = (s) => document.querySelector(s);
+const esc = (v) => String(v ?? "").replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" }[c]));
+const pct = (x) => (x == null ? "–" : x.toFixed(2));
+const dur = (s) => { s = Math.max(0, Math.round(s)); const m = Math.floor(s / 60); return m ? `${m}m ${String(s % 60).padStart(2, "0")}s` : `${s}s`; };
+const dot = (status) => `<span class="dot ${status === "passed" ? "pass" : status === "failed" ? "fail" : status === "running" ? "run" : ""}"></span>`;
+
+function recipeCard(s) {
+  const r = s.recipe || {};
+  const sides = Object.entries(s.sides || {}).map(([k, v]) => {
+    const version = r.agents && r.agents[k] ? r.agents[k].version : "";
+    const own = v.prompt ? `<div class="muted">prompt: ${esc(v.prompt)}</div>` : "";
+    return `<div>${s.kind === "calibrate" ? "side" : "agent"} ${esc(k)}</div><div><b>${esc(v.agent)}</b> ${esc((v.args || []).join(" "))} <span class="muted">${esc(version)}</span>${own}</div>`;
+  }).join("");
+  const p = s.params || {};
+  const params = s.kind === "cliff" ? `${esc(p.tails)} tails per step tried · budget ${esc(p.budget)}`
+    : s.kind === "calibrate" ? `${esc(p.tails)} fresh starts per side` : `cuts ${esc((p.cuts || []).join(", "))} · ${esc(p.tails)} tails per cell`;
+  return `<section class="panel"><h2>Recipe</h2><div class="kv">
+    <div>task</div><div>${s.task ? esc(s.task) : `<span class="muted">a prompt per side</span>`}</div>
+    <div>check</div><div>${s.check ? `<code>${esc(s.check)}</code>` : `<span class="muted">none. A run counts as finished when its agent exits 0. Workspaces are kept.</span>`}</div>
+    <div>project</div><div><code>${esc(s.project)}</code> <span class="muted">${esc(r.project_digest ? "fingerprint " + r.project_digest.slice(0, 12) : "")}</span></div>
+    ${sides}
+    <div>settings</div><div>${params}</div>
+    ${r.command ? `<div>repeat</div><div><code>tare rerun ${esc(r.out || "")}</code></div>` : ""}
+  </div></section>`;
+}
+
+function probesCard(s) {
+  if (!s.probes.length) return "";
+  return `<section class="panel"><h2>Probes</h2><div class="grid">${s.probes.map((p) => `
+    <div><span class="chip">${dot(p.zero ? "passed" : "failed")} ${esc(p.agent)} · ${p.zero ? "tare: 0.00" : esc((p.text || "").trim().split("\n").pop())}</span>
+    <details><summary>reading</summary><pre>${esc(p.text)}</pre></details></div>`).join("")}</div></section>`;
+}
+
+function originalsCard(s, cliffStep) {
+  const lanes = Object.entries(s.sides || {}).map(([k, side]) => {
+    const o = s.originals[k];
+    if (!o) return `<div><b>${esc(k)} · ${esc(side.agent)}</b> <span class="muted">waiting</span></div>`;
+    if (o.running) return `<div><span class="chip">${dot("running")} ${esc(k)} · ${esc(side.agent)} · ${o.count} steps so far</span>
+      <div class="activity">${esc(o.activity || "starting…")}</div></div>`;
+    const steps = o.steps.slice(1).map((t, i) => `<span class="step ${cliffStep === i + 1 ? "cliff" : ""}" title="${esc(t)}">${i + 1}</span>`).join("");
+    return `<div><span class="chip">${dot(o.passed ? "passed" : "failed")} ${esc(k)} · ${esc(side.agent)} · ${o.passed ? "passed" : "failed"} after ${o.steps.length - 1} steps</span>
+      <div class="steps">${steps}</div></div>`;
+  }).join("");
+  return `<section class="panel"><h2>Original ${Object.keys(s.sides || {}).length > 1 ? "runs" : "run"}</h2><div class="grid">${lanes}</div></section>`;
+}
+
+function cliffCard(s) {
+  const rows = s.steps || [];
+  if (!rows.length) return "";
+  const o = s.originals.a || {};
+  const last = Math.max(1, (o.steps ? o.steps.length - 1 : 0), ...rows.map((r) => r.step));
+  const base = rows.find((r) => r.step === 0);
+  const theta = base && base.rate != null ? base.rate : null;
+  const W = 760, H = 220, L = 40, R = 14, T = 12, B = 28;
+  const x = (step) => L + (step / last) * (W - L - R), y = (v) => T + (1 - v) * (H - T - B);
+  let svg = `<svg viewBox="0 0 ${W} ${H}" width="100%" style="max-width:${W}px;display:block" role="img" aria-label="pass rate by step">`;
+  for (const v of [0, .5, 1]) svg += `<line x1="${L}" x2="${W - R}" y1="${y(v)}" y2="${y(v)}" stroke="var(--line)"/><text x="6" y="${y(v) + 4}">${v.toFixed(1)}</text>`;
+  if (theta != null) {
+    svg += `<line x1="${L}" x2="${W - R}" y1="${y(theta)}" y2="${y(theta)}" stroke="var(--accent)" stroke-dasharray="2 3"/>`;
+    svg += `<line x1="${L}" x2="${W - R}" y1="${y(theta / 2)}" y2="${y(theta / 2)}" stroke="var(--threshold)" stroke-dasharray="6 4"/>`;
+    svg += `<text x="${L + 6}" y="${y(theta / 2) - 5}">threshold: half the baseline pass rate</text>`;
+  }
+  for (const r of rows) {
+    if (r.rate == null) { svg += `<circle cx="${x(r.step)}" cy="${y(.5)}" r="5" fill="none" stroke="var(--run)"/>`; continue; }
+    const high = theta == null || r.rate >= theta / 2, color = high ? "var(--pass)" : "var(--fail)";
+    svg += `<line x1="${x(r.step)}" x2="${x(r.step)}" y1="${y(r.hi)}" y2="${y(r.lo)}" stroke="${color}" stroke-width="3" opacity=".45"/>`;
+    svg += `<circle cx="${x(r.step)}" cy="${y(r.rate)}" r="5" fill="${color}"/>`;
+    svg += `<text x="${x(r.step) - 4}" y="${H - 8}">${r.step}</text>`;
+  }
+  svg += `</svg>`;
+  const table = rows.map((r) => `<tr><td class="num">${r.step}</td><td>${esc(o.steps ? o.steps[r.step] : "")}</td>
+    <td class="num">${r.passes}/${r.n}${r.running ? ` <span class="muted">+${r.running} running</span>` : ""}</td>
+    <td class="num">${pct(r.rate)}</td><td class="num">${r.n ? `${pct(r.lo)}-${pct(r.hi)}` : "–"}</td></tr>`).join("");
+  return `<section class="panel"><h2>Cliff search</h2>${svg}
+    <table><thead><tr><th>step</th><th>what the step did</th><th>passed / tails</th><th>rate</th><th>95% interval</th></tr></thead><tbody>${table}</tbody></table></section>`;
+}
+
+function effect(e, label) {
+  if (!e) return `<div class="effect muted">${label}: waiting for every cell</div>`;
+  const [v, lo, hi] = e;
+  return `<div class="effect">${label}: <b>${v >= 0 ? "+" : ""}${v.toFixed(2)}</b> <span class="muted">[${lo.toFixed(2)}, ${hi.toFixed(2)}]</span></div>`;
+}
+
+function swapCard(s) {
+  const cuts = s.cells || [];
+  if (!cuts.length) return "";
+  const agentName = (k) => esc((s.sides[k] || {}).agent || k);
+  return `<section class="panel"><h2>Swap</h2><div class="grid">${cuts.map((c) => {
+    const cell = (r, m) => {
+      const v = c.cells[r + m], dots = "<span class='dot pass'></span>".repeat(v.passes) + "<span class='dot fail'></span>".repeat(v.n - v.passes) + "<span class='dot run'></span>".repeat(v.running);
+      return `<div class="cell"><div class="big">${v.passes}/${v.n}</div><div class="dots">${dots}</div></div>`;
+    };
+    const native = Object.entries(c.native).map(([r, v]) => `workspace ${r}, own session: ${v.passes}/${v.n}`).join(" · ");
+    return `<div><b>cut ${c.fraction.toFixed(2)}</b> <span class="muted">workspace a at step ${c.steps.a}, workspace b at step ${c.steps.b}</span>
+      <div class="matrix"><div></div><div class="head">agent a · ${agentName("a")}</div><div class="head">agent b · ${agentName("b")}</div>
+        <div class="head">workspace a</div>${cell("a", "a")}${cell("a", "b")}
+        <div class="head">workspace b</div>${cell("b", "a")}${cell("b", "b")}</div>
+      ${native ? `<div class="muted">${native}</div>` : ""}
+      ${effect(c.state, "state effect (positive: workspace a better)")}${effect(c.model, "model effect (positive: agent a better)")}</div>`;
+  }).join("")}</div></section>`;
+}
+
+function runsCard(s) {
+  const rates = s.rates || {};
+  const rows = Object.entries(s.sides || {}).map(([k, side]) => {
+    const r = rates[k] || { passes: 0, n: 0, running: 0, times: [] };
+    const dots = "<span class='dot pass'></span>".repeat(r.passes) + "<span class='dot fail'></span>".repeat(r.n - r.passes) + "<span class='dot run'></span>".repeat(r.running);
+    const times = [...(r.times || [])].sort((a, b) => a - b);
+    const median = times.length ? times[Math.floor((times.length - 1) / 2)] : null;
+    return `<tr><td class="num">${esc(k)}</td><td><b>${esc(side.agent)}</b> ${esc((side.args || []).join(" "))}<div class="dots">${dots}</div></td>
+      <td class="num">${r.passes}/${r.n}</td><td class="num">${median == null ? "–" : `${dur(median)} (${dur(times[0])} to ${dur(times[times.length - 1])})`}</td></tr>`;
+  }).join("");
+  return `<section class="panel"><h2>Runs · no check</h2><table><thead><tr><th>side</th><th>agent</th><th>finished</th><th>time (median, range)</th></tr></thead><tbody>${rows}</tbody></table></section>`;
+}
+
+function calibrateCard(s) {
+  if (!s.check) return runsCard(s);
+  const rates = s.rates || {};
+  const judged = Object.values(rates).some((r) => (r.scores || []).length);
+  const rows = Object.entries(s.sides || {}).map(([k, side]) => {
+    const r = rates[k] || { passes: 0, n: 0, running: 0 };
+    const dots = "<span class='dot pass'></span>".repeat(r.passes) + "<span class='dot fail'></span>".repeat(r.n - r.passes) + "<span class='dot run'></span>".repeat(r.running);
+    const band = r.n ? `<div class="bar" style="position:relative"><i style="margin-left:${(r.lo * 100).toFixed(1)}%;width:${((r.hi - r.lo) * 100).toFixed(1)}%"></i></div>` : "";
+    const scores = r.scores || [];
+    const strip = scores.length ? `<svg viewBox="0 0 200 22" width="200" height="22" style="display:block">
+        <line x1="0" x2="200" y1="11" y2="11" stroke="var(--line)"/>
+        ${[0, 50, 100].map((v) => `<line x1="${v * 2}" x2="${v * 2}" y1="6" y2="16" stroke="var(--line)"/>`).join("")}
+        ${scores.map((v) => `<circle cx="${v * 2}" cy="11" r="4" fill="var(--accent)" opacity=".75"><title>${v}</title></circle>`).join("")}
+        ${r.mean != null ? `<line x1="${r.mean * 2}" x2="${r.mean * 2}" y1="2" y2="20" stroke="var(--text)" stroke-width="2"/>` : ""}
+      </svg><div class="muted mono">${[...scores].sort((a, b) => a - b).join(" ")} · mean ${r.mean.toFixed(1)}</div>` : `<span class="muted">–</span>`;
+    return `<tr><td class="num">${esc(k)}</td><td><b>${esc(side.agent)}</b> ${esc((side.args || []).join(" "))}<div class="dots">${dots}</div></td>
+      ${judged ? `<td>${strip}</td>` : ""}
+      <td class="num">${r.passes}/${r.n}</td><td class="num">${pct(r.rate)}</td><td class="num" style="min-width:160px">${r.n ? `${pct(r.lo)}-${pct(r.hi)}` : "–"}${band}</td></tr>`;
+  }).join("");
+  const title = judged ? "Judge scores and pass rates" : "Pass rates";
+  return `<section class="panel"><h2>${title}</h2><table><thead><tr><th>side</th><th>agent</th>${judged ? "<th>judge scores (0 to 100, line = mean)</th>" : ""}<th>pass</th><th>rate</th><th>95% interval</th></tr></thead><tbody>${rows}</tbody></table></section>`;
+}
+
+function usageCard(s) {
+  const u = s.usage || {};
+  if (!u.total) return "";
+  const n = (x) => (x >= 1e6 ? `${(x / 1e6).toFixed(2)}M` : x >= 1e3 ? `${(x / 1e3).toFixed(1)}k` : `${x}`);
+  const money = (c) => (c < 10 ? c.toFixed(3) : c.toFixed(2));
+  const cost = (v) => (v.cost_usd == null ? `<span class="muted">unknown</span>`
+    : `${v.estimated ? "about " : ""}$${money(v.cost_usd)}${v.unpriced ? ` <span class="muted">(${v.unpriced} of ${v.runs} runs unknown)</span>` : ""}`
+      + (v.estimated ? `<div class="muted">estimated from ${esc(v.estimated)}</div>` : ""));
+  const row = (name, v) => `<tr><td>${name}</td><td class="num">${v.runs}</td><td class="num">${n(v.input)} <span class="muted">(${n(v.cached)} cached)</span></td>
+    <td class="num">${n(v.output)}</td><td class="num">${cost(v)}</td></tr>`;
+  const rows = Object.entries(u.sides || {}).filter(([, v]) => v.usage)
+    .map(([k, v]) => row(`<b>${esc(k)}</b> ${esc(v.label)}${v.billing === "subscription"
+      ? `<div class="muted">subscription login, so the cost is notional</div>` : ""}`, v.usage)).join("")
+    + (u.check ? row("check (the judge)", u.check) : "") + row("<b>total</b>", u.total);
+  return `<section class="panel"><h2>Usage</h2><table><thead><tr><th></th><th>runs</th><th>tokens in</th><th>tokens out</th><th>cost</th></tr></thead>
+    <tbody>${rows}</tbody></table></section>`;
+}
+
+function tailsCard(s) {
+  const running = s.tails.filter((t) => t.status === "running"), done = s.tails.filter((t) => t.status !== "running");
+  if (!s.tails.length) return "";
+  const fraction = (i) => (s.plan && s.plan[i] ? s.plan[i].fraction.toFixed(2) : i);
+  const where = (t) => s.kind === "cliff" ? `step ${t.step}` : s.kind === "calibrate" ? `side ${t.side} · fresh start`
+    : `cut ${fraction(t.cut)} · workspace ${t.room} · agent ${t.agent}${t.kind === "native" ? " · own session" : ""}`;
+  const row = (t) => `<tr><td>${dot(t.status)}</td><td class="num">${esc(where(t))}</td><td>${esc(t.agent_name)}</td>
+    <td class="num">${dur((t.ended || s.now) - t.started)}</td><td class="activity">${esc(t.status === "running" ? (t.activity || "starting…") : t.detail || t.status)}</td></tr>`;
+  const total = s.kind === "cliff" ? `${done.length} of a budget of ${esc((s.params || {}).budget)}` : `${done.length} done`;
+  return `<section class="panel"><h2>${s.kind === "calibrate" ? "Runs" : "Tails"} · ${running.length} running · ${total}</h2>
+    <table><thead><tr><th></th><th>where</th><th>agent</th><th>time</th><th>doing / result</th></tr></thead>
+    <tbody>${running.map(row).join("")}${done.slice(0, 40).map(row).join("")}</tbody></table></section>`;
+}
+
+function render(s) {
+  $("#title").textContent = s.kind ? `tare ${s.kind}` : "tare";
+  document.title = s.kind ? `tare ${s.kind} · ${s.phase}` : "tare live";
+  const status = s.phase === "done" ? "passed" : "running";
+  $("#phase").innerHTML = `${dot(status)}<span>${esc(s.phase)}</span>`;
+  if (s.started) $("#elapsed").textContent = `${dur((s.phase === "done" ? s.updated : s.now) - s.started)}`;
+  const quiet = s.updated ? s.now - s.updated : 0;
+  $("#updated").innerHTML = s.phase !== "done" && quiet > 300 ? `<span class="stale">no update for ${dur(quiet)}</span>` : "";
+  let cliffStep = null;
+  if (s.report) { const m = s.report.match(/lost at step (\d+)/); if (m) cliffStep = Number(m[1]); }
+  $("#app").innerHTML = (s.kind ? recipeCard(s) : "") + probesCard(s) + (s.kind && s.kind !== "calibrate" ? originalsCard(s, cliffStep) : "")
+    + (s.report ? `<section class="panel"><h2>Report</h2><pre>${esc(s.report)}</pre></section>` : "")
+    + (s.kind === "calibrate" ? calibrateCard(s) : "")
+    + (s.kind === "cliff" ? cliffCard(s) : "") + (s.kind === "swap" ? swapCard(s) : "") + usageCard(s) + tailsCard(s);
+}
+
+async function tick() {
+  try {
+    const r = await fetch("state", { cache: "no-store" });  // relative: under run/<i>/ when tare watch shows several runs
+    render(await r.json());
+  } catch (e) {
+    $("#phase").innerHTML = `${dot("failed")}<span>disconnected</span>`;
+  }
+  setTimeout(tick, 1000);
+}
+if (location.pathname.startsWith("/run/")) $("#back").style.display = "";
+tick();
+</script>
+</body>
+</html>