speedpatrol 0.1.0 → 0.1.2

package/dist/bin.js

@@ -332,6 +332,9 @@ async function loadConfig(cwd) {
   const dir = findConfigDir(cwd);
   if (!dir)
     throw new ConfigError(`No ${CONFIG_DIR}/${CONFIG_FILE} here or above. Run \`speedpatrol init\`.`);
+  return loadConfigDir(dir);
+}
+async function loadConfigDir(dir) {
   const file = join(dir, CONFIG_FILE);
   let raw;
   try {
@@ -996,22 +999,22 @@ function compareSamples(base, head, better, thresholds) {
   const excludesZero = ci[0] > 0 || ci[1] < 0;
   const significant = p < thresholds.alpha && excludesZero;
   const large = Math.abs(deltaPct) >= thresholds.relative && Math.abs(deltaAbs) >= thresholds.absolute;
-  let verdict;
+  let verdict2;
   if (significant && large) {
     const worse = better === "lower" ? deltaAbs > 0 : deltaAbs < 0;
-    verdict = worse ? "regression" : "improvement";
+    verdict2 = worse ? "regression" : "improvement";
   } else if (!significant && Math.max(bs.cv, hs.cv) > thresholds.maxCv && large) {
-    verdict = "noisy";
+    verdict2 = "noisy";
   } else {
-    verdict = "unchanged";
+    verdict2 = "unchanged";
   }
-  return { deltaPct, deltaAbs, ci, pValue: p, verdict, ...significant && !large ? { underThreshold: true } : {} };
+  return { deltaPct, deltaAbs, ci, pValue: p, verdict: verdict2, ...significant && !large ? { underThreshold: true } : {} };
 }
 var SEVERITY = { regression: 4, noisy: 3, improvement: 2, unchanged: 1, missing: 0 };
 function worstVerdict(verdicts) {
   if (verdicts.length === 0)
     return "missing";
-  return verdicts.reduce((worst, verdict) => SEVERITY[verdict] > SEVERITY[worst] ? verdict : worst);
+  return verdicts.reduce((worst, verdict2) => SEVERITY[verdict2] > SEVERITY[worst] ? verdict2 : worst);
 }
 function poolResults(runs) {
   const pooled = /* @__PURE__ */ new Map();
@@ -1131,8 +1134,8 @@ var VERDICT_ICON = {
   missing: "\u26AB"
 };
 function row(metric) {
-  const verdict = metric.underThreshold ? `${metric.verdict} (under threshold)` : metric.verdict;
-  return `| ${VERDICT_ICON[metric.verdict]} ${verdict} | \`${metric.benchmark}\` | ${metric.metric} | ${formatValue(metric.base?.median, metric.unit)} | ${formatValue(metric.head?.median, metric.unit)} | ${formatPct(metric.deltaPct)} | ${formatPct(metric.ci[0])} to ${formatPct(metric.ci[1])} | ${metric.pValue < 1e-3 ? "<0.001" : metric.pValue.toFixed(3)} |`;
+  const verdict2 = metric.underThreshold ? `${metric.verdict} (under threshold)` : metric.verdict;
+  return `| ${VERDICT_ICON[metric.verdict]} ${verdict2} | \`${metric.benchmark}\` | ${metric.metric} | ${formatValue(metric.base?.median, metric.unit)} | ${formatValue(metric.head?.median, metric.unit)} | ${formatPct(metric.deltaPct)} | ${formatPct(metric.ci[0])} to ${formatPct(metric.ci[1])} | ${metric.pValue < 1e-3 ? "<0.001" : metric.pValue.toFixed(3)} |`;
 }
 function comparisonMarkdown(comparison, options = {}) {
   const shown = comparison.metrics.filter((metric) => options.all || metric.primary || metric.verdict === "regression" || metric.verdict === "improvement");
@@ -2314,12 +2317,13 @@ async function callTool(tools, name, input, budget) {
 async function serveTools(tools, options = {}) {
   const budget = { calls: 0, max: options.maxCalls ?? Number.POSITIVE_INFINITY };
   const running = /* @__PURE__ */ new Map();
+  const lane = { tail: Promise.resolve() };
   const http = createServer((request, response) => {
     if (request.url !== "/mcp") {
       response.writeHead(404).end();
       return;
     }
-    void handle(request, response, tools, options, budget, running).catch((error) => {
+    void handle(request, response, tools, options, budget, running, lane).catch((error) => {
       if (!response.headersSent)
         response.writeHead(500).end(String(error));
     });
@@ -2342,7 +2346,7 @@ async function serveTools(tools, options = {}) {
     }
   };
 }
-async function handle(request, response, tools, options, budget, running) {
+async function handle(request, response, tools, options, budget, running, lane) {
   const server = new Server({ name: "speedpatrol", version: "0.0.0" }, { capabilities: { tools: {} } });
   server.setRequestHandler(ListToolsRequestSchema, async () => ({
     tools: tools.map((tool2) => ({
@@ -2360,7 +2364,10 @@ async function handle(request, response, tools, options, budget, running) {
       const result2 = await joined;
       return { content: [{ type: "text", text: result2.text }], isError: result2.isError ?? false };
     }
-    const pending = callTool(tools, call.params.name, input, budget);
+    const exclusive = tools.find((item) => item.name === call.params.name)?.exclusive ?? false;
+    const pending = exclusive ? lane.tail.then(() => callTool(tools, call.params.name, input, budget)) : callTool(tools, call.params.name, input, budget);
+    if (exclusive)
+      lane.tail = pending;
     running.set(key, pending);
     const result = await pending.finally(() => running.delete(key));
     options.onCall?.(call.params.name, input, result, Date.now() - started);
@@ -2459,8 +2466,13 @@ ${task.prompt}`;
       const child = spawn2("/bin/sh", ["-c", command], {
         cwd: task.workdir,
         // measure_change runs for minutes; Claude Code's default MCP tool
-        // timeout abandons it and the agent calls it again over the first.
-        env: { MCP_TOOL_TIMEOUT: String(task.timeoutMs), ...process.env },
+        // timeout abandons it and the agent calls it again over the first. It also
+        // aborts any call silent for 300 s (an A/B, or a call queued behind one).
+        env: {
+          MCP_TOOL_TIMEOUT: String(task.timeoutMs),
+          CLAUDE_CODE_MCP_TOOL_IDLE_TIMEOUT: String(task.timeoutMs),
+          ...process.env
+        },
         detached: true,
         stdio: ["pipe", "pipe", "pipe"]
       });
@@ -2708,12 +2720,13 @@ import { readFile as readFile4, writeFile as writeFile5 } from "node:fs/promises
 import { join as join8 } from "node:path";
 
 // ../agents/dist/tools/schema.js
-function tool(name, description, fields, required, run) {
+function tool(name, description, fields, required, run, options = {}) {
   return {
     name,
     description,
     inputSchema: { type: "object", properties: fields, required, additionalProperties: false },
-    run
+    run,
+    ...options
   };
 }
 function str(input, key) {
@@ -2906,7 +2919,7 @@ function measureCommitTool(loaded, store, log2) {
       text: comparisonMarkdown(comparison),
       summary: `${head.sha.slice(0, 8)} vs ${base.sha.slice(0, 8)}: ${comparison.verdict}.`
     };
-  });
+  }, { exclusive: true });
 }
 
 // ../agents/dist/tools/repo.js
@@ -3138,7 +3151,7 @@ async function runOptimizer(options) {
           log: log2
         });
         return { text: comparisonMarkdown(comparison), summary: `Measured: ${comparison.verdict}.` };
-      }),
+      }, { exclusive: true }),
       tool("git_diff", "Your changes so far.", {}, [], async () => ({
         text: await tryGit(worktree, ["diff", "HEAD"]) || "No changes yet."
       })),
@@ -3310,8 +3323,8 @@ async function markFixed(store, run, loaded) {
     const now = run.results.find((r) => r.benchmark === regression.benchmark)?.metrics[regression.metric];
     if (!before || !now)
       continue;
-    const { verdict } = compareSamples(before.values, now.values, now.better, loaded.config.thresholds);
-    if (verdict === "regression" || verdict === "noisy")
+    const { verdict: verdict2 } = compareSamples(before.values, now.values, now.better, loaded.config.thresholds);
+    if (verdict2 === "regression" || verdict2 === "noisy")
       continue;
     const updated = {
       ...regression,
@@ -3510,7 +3523,227 @@ import { fileURLToPath } from "node:url";
 import { existsSync as existsSync8 } from "node:fs";
 import { readFile as readFile7 } from "node:fs/promises";
 import { join as join9 } from "node:path";
+
+// ../dashboard/dist/summary.js
+var OPEN = /* @__PURE__ */ new Set(["open", "filed"]);
+var isOpen = (regression) => OPEN.has(regression.status);
+var plural = (count, word, many = `${word}s`) => `${count} ${count === 1 ? word : many}`;
+var byStart = (a, b) => a.startedAt.localeCompare(b.startedAt);
+function projectSummary(input) {
+  const { config, runs, baselines, comparisons, regressions, experiments } = input;
+  const configError = "error" in config ? config.error : void 0;
+  const defined = "error" in config ? void 0 : config.benchmarks;
+  const newest = baselines.at(-1);
+  const measuredIds = new Set(newest?.results.map((result) => result.benchmark) ?? []);
+  const unmeasured = (defined ?? []).filter((benchmark) => !measuredIds.has(benchmark.id)).map((item) => item.id);
+  const withErrors = (newest?.results ?? []).filter((result) => result.errors.length).map((item) => item.benchmark);
+  const critical = defined ? defined.filter((benchmark) => benchmark.critical).length : newest?.results.filter((result) => result.critical).length ?? 0;
+  const open = regressions.filter(isOpen);
+  const byStatus = { open: 0, filed: 0, dismissed: 0, fixed: 0 };
+  for (const regression of regressions)
+    byStatus[regression.status]++;
+  const experimentCount = (...statuses) => experiments.filter((experiment) => statuses.includes(experiment.status)).length;
+  const waiting = experiments.filter((experiment) => experiment.status === "improved");
+  const lastRun = pickLastRun(runs, comparisons);
+  const machine = newest?.machine ?? runs.find((run) => run.id === lastRun?.id)?.machine;
+  const attention = [];
+  if (configError) {
+    attention.push({
+      tone: "fail",
+      title: "The config does not load",
+      detail: configError,
+      command: "npx speedpatrol doctor"
+    });
+  }
+  if (lastRun?.failed) {
+    attention.push({
+      tone: "fail",
+      title: "The last run failed",
+      detail: lastRun.failed,
+      href: "#/runs",
+      command: "npx speedpatrol run"
+    });
+  }
+  for (const regression of open)
+    attention.push(regressionItem(regression));
+  if (unmeasured.length) {
+    attention.push({
+      tone: "warn",
+      title: `${plural(unmeasured.length, "benchmark has", "benchmarks have")} no baseline`,
+      detail: `The newest baseline does not measure ${unmeasured.join(", ")}.`,
+      href: "#/benchmarks",
+      command: "npx speedpatrol run"
+    });
+  }
+  if (withErrors.length) {
+    attention.push({
+      tone: "warn",
+      title: `${plural(withErrors.length, "benchmark")} had errors in the last baseline`,
+      detail: `Some iterations of ${withErrors.join(", ")} failed. Their medians use fewer samples.`,
+      href: "#/benchmarks"
+    });
+  }
+  for (const experiment of waiting) {
+    attention.push({
+      tone: "warn",
+      title: `A speed-up of ${experiment.target.benchmark} waits to be published`,
+      detail: experiment.summary ?? experiment.hypothesis ?? `The A/B run confirmed it on ${experiment.branch}.`,
+      href: `#/experiments/${encodeURIComponent(experiment.id)}`,
+      command: "npx speedpatrol publish"
+    });
+  }
+  for (const role of input.stoppedAgents) {
+    attention.push({
+      tone: "warn",
+      title: `The ${role} stopped`,
+      detail: "Its status says that it works, but its process is gone. Start the patrol again.",
+      href: "#/activity",
+      command: "npx speedpatrol"
+    });
+  }
+  return {
+    name: input.name,
+    ...machine ? { machine } : {},
+    ...configError ? { configError } : {},
+    verdict: verdict({
+      configError,
+      lastRun,
+      open,
+      baselines: baselines.length,
+      comparisons: comparisons.length,
+      warnings: attention.filter((item) => item.tone === "warn"),
+      measured: measuredIds.size
+    }),
+    benchmarks: {
+      ...defined ? { defined: defined.length } : {},
+      measured: measuredIds.size,
+      critical,
+      regressed: new Set(open.map((regression) => regression.benchmark)).size,
+      withErrors,
+      unmeasured
+    },
+    regressions: { open: open.length, byStatus, total: regressions.length },
+    experiments: {
+      active: experimentCount("proposed", "measuring"),
+      waiting: waiting.length,
+      published: experimentCount("published"),
+      rejected: experimentCount("rejected", "failed"),
+      total: experiments.length
+    },
+    runs: {
+      total: runs.length,
+      baselines: baselines.length,
+      failed: runs.filter((run) => run.failed).length,
+      comparisons: comparisons.length
+    },
+    ...lastRun ? { lastRun } : {},
+    attention,
+    ...baselines.length ? {} : { next: nextStep(defined?.length ?? 0) }
+  };
+}
+function pickLastRun(runs, comparisons) {
+  const sorted = [...runs].sort(byStart);
+  const run = sorted.filter((item) => item.purpose === "baseline").at(-1) ?? sorted.at(-1);
+  if (!run)
+    return void 0;
+  const comparison = [...comparisons].sort((a, b) => b.createdAt.localeCompare(a.createdAt)).find((item) => item.head.runs.includes(run.id));
+  return {
+    id: run.id,
+    purpose: run.purpose,
+    sha: run.source.sha,
+    ...run.source.subject ? { subject: run.source.subject } : {},
+    ...run.source.branch ? { branch: run.source.branch } : {},
+    startedAt: run.startedAt,
+    finishedAt: run.finishedAt,
+    ...run.failed ? { failed: run.failed } : {},
+    benchmarks: run.results.length,
+    ...comparison ? { comparison: { id: comparison.id, verdict: comparison.verdict } } : {}
+  };
+}
+function nextStep(defined) {
+  if (!defined) {
+    return {
+      why: "The project has no benchmarks yet. The scout finds the critical paths and writes them.",
+      command: "npx speedpatrol scout"
+    };
+  }
+  return {
+    why: `The config has ${plural(defined, "benchmark")}, but no baseline. A run on a clean commit records one.`,
+    command: "npx speedpatrol run"
+  };
+}
+function regressionItem(regression) {
+  const href = `#/regressions/${encodeURIComponent(regression.id)}`;
+  const title = regression.title || `${regression.benchmark} ${regression.metric} got slower`;
+  if (regression.status === "open" && !regression.analysis) {
+    return {
+      tone: "fail",
+      title,
+      detail: "Confirmed. The analyst did not explain it yet.",
+      href,
+      command: `npx speedpatrol analyze ${regression.id}`
+    };
+  }
+  if (!regression.issueUrl) {
+    return {
+      tone: "fail",
+      title,
+      detail: "Explained. No issue is open for it yet.",
+      href,
+      command: "npx speedpatrol publish"
+    };
+  }
+  return {
+    tone: "fail",
+    title,
+    detail: "Filed. The patrol closes it when a baseline is back within the thresholds.",
+    href
+  };
+}
+function verdict(facts) {
+  if (facts.configError)
+    return { tone: "fail", text: "Config error", detail: "Speedpatrol cannot read the config." };
+  if (!facts.lastRun) {
+    return { tone: "info", text: "Not measured yet", detail: "No run is recorded for this project." };
+  }
+  if (facts.lastRun.failed) {
+    return { tone: "fail", text: "Last run failed", detail: "The newest numbers are older than the last run." };
+  }
+  if (facts.open.length) {
+    return {
+      tone: "fail",
+      text: facts.open.length === 1 ? "1 open regression" : `${facts.open.length} open regressions`,
+      detail: `Slower: ${[...new Set(facts.open.map((item) => item.benchmark))].join(", ")}.`
+    };
+  }
+  if (!facts.baselines) {
+    return { tone: "info", text: "No baseline yet", detail: "A run on a clean commit records the first baseline." };
+  }
+  const [warning] = facts.warnings;
+  if (warning) {
+    return {
+      tone: "warn",
+      text: facts.warnings.length === 1 ? "One item needs you" : `${facts.warnings.length} items need you`,
+      detail: warning.title
+    };
+  }
+  if (facts.baselines <= 1 && !facts.comparisons) {
+    return {
+      tone: "info",
+      text: "First baseline recorded",
+      detail: "Speedpatrol compares the next commit with it."
+    };
+  }
+  return {
+    tone: "pass",
+    text: "No open regressions",
+    detail: `${plural(facts.measured, "benchmark")} measured on the last baseline.`
+  };
+}
+
+// ../dashboard/dist/data.js
 var ROLES = ["scout", "analyst", "optimizer", "runner", "patrol"];
+var PROBLEM_ORDER = ["regression", "errors", "unmeasured", "stale", void 0];
 function pidAlive(pid) {
   try {
     process.kill(pid, 0);
@@ -3585,40 +3818,40 @@ var DashboardData = class {
     const runs = await Promise.all(ordered.map((entry) => this.store.getRun(entry.runId)));
     return { machine, runs: runs.filter((run) => run !== void 0 && !run.failed) };
   }
-  async overview() {
-    const [project, agents, runs, baselines, regressions, experiments, comparisons, patrol2] = await Promise.all([
+  /** The benchmarks of the config, or the error that stops the load. */
+  async config() {
+    try {
+      const { benchmarks } = await loadConfigDir(this.configDir);
+      return { benchmarks: benchmarks.map(({ id: id2, critical, kind }) => ({ id: id2, critical, kind })) };
+    } catch (error) {
+      return { error: error instanceof Error ? error.message : String(error) };
+    }
+  }
+  async summary() {
+    const [name, config, agents, runs, baselines, comparisons, regressions, experiments] = await Promise.all([
       this.projectName(),
+      this.config(),
       this.agents(),
       this.store.listRuns(),
       this.baselineRuns(),
-      this.store.listRegressions(),
-      this.store.listExperiments(),
       this.store.listComparisons(),
-      this.store.patrolState()
+      this.store.listRegressions(),
+      this.store.listExperiments()
     ]);
-    const latest = baselines.runs.at(-1) ?? runs.sort((a, b) => a.startedAt.localeCompare(b.startedAt)).at(-1);
-    return {
-      project: { name: project },
-      latest: latest ? {
-        runId: latest.id,
-        purpose: latest.purpose,
-        sha: latest.source.sha,
-        subject: latest.source.subject,
-        branch: latest.source.branch,
-        startedAt: latest.startedAt,
-        machine: latest.machine,
-        benchmarks: latest.results.length
-      } : null,
-      counts: {
-        runs: runs.length,
-        baselines: baselines.runs.length,
-        comparisons: comparisons.length,
-        openRegressions: regressions.filter((item) => item.status === "open" || item.status === "filed").length,
-        improvedExperiments: experiments.filter((item) => item.status === "improved" || item.status === "published").length
-      },
-      agents,
-      patrol: patrol2
-    };
+    return projectSummary({
+      name,
+      config,
+      runs,
+      baselines: baselines.runs,
+      comparisons,
+      regressions,
+      experiments,
+      stoppedAgents: agents.filter((agent) => agent.state === "stopped").map((agent) => agent.role)
+    });
+  }
+  async agentsAndPatrol() {
+    const [agents, patrol2] = await Promise.all([this.agents(), this.store.patrolState()]);
+    return { agents, patrol: patrol2 };
   }
   /** The comparison of exactly these two commits, newest first. */
   stepComparison(comparisons, base, head) {
@@ -3627,7 +3860,12 @@ var DashboardData = class {
     return newestFirst(comparisons).find((comparison) => comparison.base.sha === base.source.sha && comparison.head.sha === head.source.sha);
   }
   async benchmarks() {
-    const [{ machine, runs }, comparisons] = await Promise.all([this.baselineRuns(), this.store.listComparisons()]);
+    const [{ machine, runs }, comparisons, regressions, config] = await Promise.all([
+      this.baselineRuns(),
+      this.store.listComparisons(),
+      this.store.listRegressions(),
+      this.config()
+    ]);
     const latestRun = runs.at(-1);
     const step = this.stepComparison(comparisons, runs.at(-2), latestRun);
     const rows = /* @__PURE__ */ new Map();
@@ -3641,9 +3879,10 @@ var DashboardData = class {
           primary: result.primary,
           unit: series?.unit ?? "ms",
           better: series?.better ?? "lower",
+          errors: 0,
           series: []
         };
-        Object.assign(row2, { kind: result.kind, critical: result.critical });
+        Object.assign(row2, { kind: result.kind, critical: result.critical, errors: result.errors.length });
         if (series && result.primary === row2.primary)
           row2.series.push(point(run, series.summary));
         if (series && result.primary !== row2.primary) {
@@ -3653,15 +3892,44 @@ var DashboardData = class {
         rows.set(result.benchmark, row2);
       }
     }
+    for (const defined of "benchmarks" in config ? config.benchmarks : []) {
+      if (rows.has(defined.id))
+        continue;
+      rows.set(defined.id, {
+        id: defined.id,
+        kind: defined.kind,
+        critical: defined.critical,
+        primary: "",
+        unit: "ms",
+        better: "lower",
+        errors: 0,
+        series: []
+      });
+    }
+    const open = newestFirst(regressions.filter(isOpen));
     for (const row2 of rows.values()) {
       const latest = row2.series.at(-1);
       const previous = row2.series.at(-2);
+      const inLatest = latestRun?.results.some((result) => result.benchmark === row2.id) ?? false;
       row2.latest = latest?.runId === latestRun?.id ? latest : void 0;
       if (row2.latest && previous)
         row2.deltaPct = row2.latest.median / previous.median - 1;
       row2.verdict = step?.metrics.find((metric) => metric.benchmark === row2.id && metric.metric === row2.primary)?.verdict;
+      if (!inLatest)
+        row2.errors = 0;
+      const regression = open.find((item) => item.benchmark === row2.id);
+      if (regression) {
+        row2.regression = {
+          id: regression.id,
+          status: regression.status,
+          deltaPct: regression.deltaPct,
+          metric: regression.metric,
+          badSha: regression.badSha
+        };
+      }
+      row2.problem = regression ? "regression" : row2.errors ? "errors" : !row2.series.length ? "unmeasured" : !inLatest ? "stale" : void 0;
     }
-    const benchmarks = [...rows.values()].sort((a, b) => Number(b.critical) - Number(a.critical) || a.id.localeCompare(b.id));
+    const benchmarks = [...rows.values()].sort((a, b) => PROBLEM_ORDER.indexOf(a.problem) - PROBLEM_ORDER.indexOf(b.problem) || Number(b.critical) - Number(a.critical) || a.id.localeCompare(b.id));
     return { machine, benchmarks };
   }
   async benchmark(id2) {
@@ -3713,20 +3981,37 @@ var DashboardData = class {
     };
   }
   async runs() {
-    const runs = await this.store.listRuns();
-    return runs.sort((a, b) => b.startedAt.localeCompare(a.startedAt)).map((run) => ({
-      id: run.id,
-      purpose: run.purpose,
-      startedAt: run.startedAt,
-      finishedAt: run.finishedAt,
-      sha: run.source.sha,
-      subject: run.source.subject,
-      branch: run.source.branch,
-      dirty: run.source.dirty,
-      machine: run.machine.fingerprint,
-      benchmarks: run.results.length,
-      failed: run.failed
-    }));
+    const [runs, comparisons] = await Promise.all([this.store.listRuns(), this.store.listComparisons()]);
+    const first = /* @__PURE__ */ new Map();
+    for (const run of [...runs].sort((a, b) => a.startedAt.localeCompare(b.startedAt))) {
+      if (run.purpose === "baseline" && !run.failed && !first.has(run.machine.fingerprint)) {
+        first.set(run.machine.fingerprint, run.id);
+      }
+    }
+    const byHead = /* @__PURE__ */ new Map();
+    for (const comparison of newestFirst(comparisons).reverse()) {
+      for (const runId of comparison.head.runs)
+        byHead.set(runId, comparison);
+    }
+    return runs.sort((a, b) => b.startedAt.localeCompare(a.startedAt)).map((run) => {
+      const comparison = byHead.get(run.id);
+      return {
+        id: run.id,
+        purpose: run.purpose,
+        startedAt: run.startedAt,
+        finishedAt: run.finishedAt,
+        sha: run.source.sha,
+        subject: run.source.subject,
+        branch: run.source.branch,
+        dirty: run.source.dirty,
+        machine: run.machine.fingerprint,
+        benchmarks: run.results.length,
+        errors: run.results.filter((result) => result.errors.length).length,
+        failed: run.failed,
+        first: first.get(run.machine.fingerprint) === run.id,
+        comparison: comparison ? { id: comparison.id, verdict: comparison.verdict, mode: comparison.mode } : void 0
+      };
+    });
   }
   async comparisons() {
     const comparisons = newestFirst(await this.store.listComparisons());
@@ -3753,16 +4038,14 @@ var DashboardData = class {
     return newestFirst(await this.store.listExperiments());
   }
   async sessions() {
-    const ids = await this.store.sessions();
+    const [ids, agents] = await Promise.all([this.store.sessions(), this.agents()]);
+    const live = new Set(agents.filter((agent) => agent.state === "running").map((agent) => agent.sessionId));
     const views = await Promise.all(ids.map(async (id2) => sessionView(id2, await this.store.events(id2))));
+    for (const view of views)
+      if (view.state === "running" && !live.has(view.id))
+        view.state = "stopped";
     return views.sort((a, b) => (b.lastAt ?? "").localeCompare(a.lastAt ?? ""));
   }
-  /** The newest events across the most recent sessions, newest first. */
-  async activity(limit) {
-    const sessions = (await this.sessions()).slice(0, 10);
-    const events = (await Promise.all(sessions.map((session) => this.store.events(session.id)))).flat();
-    return events.sort((a, b) => b.at.localeCompare(a.at)).slice(0, limit);
-  }
 };
 function hotspotsOf(run, result) {
   return {
@@ -3776,13 +4059,19 @@ function sessionView(id2, events) {
   const first = events[0];
   const last = events.at(-1);
   if (!first || !last)
-    return { id: id2, events: 0, state: "empty" };
+    return { id: id2, events: 0, toolCalls: 0, errors: 0, state: "empty" };
+  const cost = events.reduce((sum, event) => sum + (event.costUsd ?? 0), 0);
   return {
     id: id2,
     role: first.role,
+    goal: events.find((event) => event.kind === "start")?.summary,
     startedAt: first.at,
     lastAt: last.at,
+    durationMs: Date.parse(last.at) - Date.parse(first.at),
     events: events.length,
+    toolCalls: events.filter((event) => event.kind === "tool-call").length,
+    errors: events.filter((event) => event.kind === "error").length,
+    ...cost ? { costUsd: cost } : {},
     last: last.summary,
     state: last.kind === "error" ? "failed" : last.kind === "finish" ? "done" : "running"
   };
@@ -3844,7 +4133,6 @@ async function handle2(req, res, data) {
   if (req.method !== "GET" && req.method !== "HEAD")
     throw new HttpError(405, "read-only");
   const raw = (req.url ?? "/").split("?")[0];
-  const query = new URL(req.url ?? "/", "http://localhost").searchParams;
   const parts = raw.split("/").slice(1);
   if (parts[0] !== "api")
     return serveUi(res, raw);
@@ -3852,8 +4140,10 @@ async function handle2(req, res, data) {
   if (rest.length)
     throw new HttpError(404, "not found");
   switch (resource) {
-    case "overview":
-      return json(res, await data.overview());
+    case "summary":
+      return json(res, await data.summary());
+    case "agents":
+      return json(res, await data.agentsAndPatrol());
     case "benchmarks":
       return json(res, key ? found(await data.benchmark(id(key)), "benchmark") : await data.benchmarks());
     case "runs":
@@ -3870,10 +4160,6 @@ async function handle2(req, res, data) {
       if (sub !== "events")
         throw new HttpError(404, "not found");
       return json(res, await data.store.events(id(key)));
-    case "activity": {
-      const limit = Number(query.get("limit") ?? 60);
-      return json(res, await data.activity(Number.isFinite(limit) ? Math.max(1, Math.min(500, limit)) : 60));
-    }
     default:
       throw new HttpError(404, "not found");
   }
@@ -4239,7 +4525,7 @@ Docs: https://github.com/agent-labs-dev/speedpatrol`;
 // ../cli/dist/bin.js
 function version2() {
   if (true)
-    return "0.1.0";
+    return "0.1.2";
   try {
     const here = dirname3(fileURLToPath2(import.meta.url));
     return JSON.parse(readFileSync2(join11(here, "../../speedpatrol/package.json"), "utf8")).version;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "speedpatrol",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "A team of AI agents that measures your app's critical paths on every commit, catches regressions, and proposes speed-ups.",
   "license": "Apache-2.0",
   "type": "module",