@monster-orange/den 0.4.7 → 0.4.8

package/src/shared/usage/report.ts

@@ -0,0 +1,283 @@
+/**
+ * The usage report (den#6, ported from the agent-usage report): per agent,
+ * its tokens and its outcome, joined on the agent record's resumeToken; and
+ * per week, the numbers to move, diffed against the last report.
+ *
+ * An agent session is "attributed" when its transcripts were found and
+ * counted (tokens) and its outcome is known (at least its wall-clock). The
+ * share of attributed sessions is the scorecard metric: before this, no
+ * agent's tokens or outcome were joined to it (~0).
+ *
+ * Everything is read and written on this machine; nothing is sent.
+ */
+import type {
+  AgentOutcome,
+  AgentRecord,
+  AgentUsage,
+} from "../agents/records.js";
+import { sourceFor, type UsageSource } from "./sources.js";
+import type { TranscriptStats } from "./transcript.js";
+
+export interface AgentUsageRow {
+  agent: string;
+  workspace: string;
+  persona: string;
+  runtime: string;
+  /** No source reads its runtime, or it has no resume token. */
+  why?: string;
+  /** How many transcripts were found (its own and its subagents'). */
+  transcripts: number;
+  usage?: AgentUsage;
+  outcome?: AgentOutcome;
+  attributed: boolean;
+}
+
+/** The sum of transcripts' counts, as the record keeps them. */
+export function sumUsage(stats: readonly TranscriptStats[]): AgentUsage {
+  const u: AgentUsage = {
+    calls: 0,
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    compactions: 0,
+  };
+  for (const s of stats) {
+    u.calls += s.calls;
+    u.input += s.tokens.input;
+    u.output += s.tokens.output;
+    u.cacheRead += s.tokens.cacheRead;
+    u.cacheWrite += s.tokens.cacheWrite;
+    u.compactions += s.compactions;
+  }
+  return u;
+}
+
+/** An agent's outcome from its transcripts and its record. */
+export function outcomeOf(
+  rec: AgentRecord,
+  stats: readonly TranscriptStats[],
+): AgentOutcome {
+  const own = stats.filter((s) => !s.subagent);
+  const all = own.length ? own : stats;
+  const firsts = all
+    .map((s) => s.first)
+    .filter((x): x is number => x !== undefined);
+  const lasts = all
+    .map((s) => s.last)
+    .filter((x): x is number => x !== undefined);
+  const out: AgentOutcome = {};
+  if (firsts.length && lasts.length)
+    out.wallClockMs = Math.max(...lasts) - Math.min(...firsts);
+  else {
+    const start = Date.parse(rec.startedAt);
+    const end = Date.parse(
+      rec.stoppedAt ?? rec.endedAt ?? rec.interruptedAt ?? "",
+    );
+    if (Number.isFinite(start) && Number.isFinite(end) && end >= start)
+      out.wallClockMs = end - start;
+  }
+  const pr = [...all].reverse().find((s) => s.prOpened)?.prOpened;
+  if (pr) out.prOpened = pr;
+  if (all.some((s) => s.prMerged)) out.prMerged = true;
+  // The last test run: of the transcript that ended last and ran tests.
+  const tested = all
+    .filter((s) => s.testsGreen !== undefined)
+    .sort((a, b) => (a.last ?? 0) - (b.last ?? 0));
+  if (tested.length) out.testsGreen = tested[tested.length - 1].testsGreen;
+  return out;
+}
+
+/**
+ * Each record's usage and outcome, from its runtime's transcripts (by its
+ * resumeToken). `source` picks the reader (default: the one for its runtime).
+ */
+export async function agentUsage(
+  records: readonly AgentRecord[],
+  opts: {
+    env?: NodeJS.ProcessEnv;
+    source?: (runtime: string) => UsageSource | undefined;
+  } = {},
+): Promise<AgentUsageRow[]> {
+  const pick = opts.source ?? sourceFor;
+  const rows: AgentUsageRow[] = [];
+  for (const rec of records) {
+    const base = {
+      agent: rec.id,
+      workspace: rec.workspace,
+      persona: rec.persona,
+      runtime: rec.runtime,
+    };
+    const src = pick(rec.runtime);
+    if (!src) {
+      rows.push({
+        ...base,
+        why: `no usage source reads ${rec.runtime}`,
+        transcripts: 0,
+        attributed: false,
+      });
+      continue;
+    }
+    if (!rec.resumeToken) {
+      rows.push({
+        ...base,
+        why: "no conversation id to join on",
+        transcripts: 0,
+        attributed: false,
+      });
+      continue;
+    }
+    const files = src.agentFiles(rec.resumeToken, opts.env);
+    const stats = await Promise.all(files.map((f) => src.mine(f)));
+    if (!stats.length) {
+      rows.push({
+        ...base,
+        why: "no transcript found",
+        transcripts: 0,
+        attributed: false,
+      });
+      continue;
+    }
+    const usage = sumUsage(stats);
+    const outcome = outcomeOf(rec, stats);
+    rows.push({
+      ...base,
+      transcripts: files.length,
+      usage,
+      outcome,
+      attributed: usage.calls > 0 && outcome.wallClockMs !== undefined,
+    });
+  }
+  return rows;
+}
+
+/** The share of agent sessions attributed, in percent (0 with none). */
+export function attributedPct(rows: readonly AgentUsageRow[]): number {
+  if (!rows.length) return 0;
+  return Math.round(
+    (100 * rows.filter((r) => r.attributed).length) / rows.length,
+  );
+}
+
+/** The week's numbers (lower is better for all but calls, output, prompts). */
+export interface UsageMetrics {
+  calls: number;
+  cache_read_B: number;
+  output_M: number;
+  avg_context_k_main: number;
+  top15_share_pct: number;
+  reread_share_pct: number;
+  compactions: number;
+  polls: number;
+  denials: number;
+  tool_error_pct: number;
+  prompts: number;
+  correction_pct: number;
+  subagent_opus_pct: number;
+  /** den#6: the share of agent sessions with attributed tokens and outcome. */
+  attributed_pct?: number;
+}
+
+const round = (n: number, d = 0) => {
+  const f = 10 ** d;
+  return Math.round(n * f) / f;
+};
+
+export function weeklyMetrics(
+  stats: readonly TranscriptStats[],
+  agents?: readonly AgentUsageRow[],
+): UsageMetrics {
+  const sum = (
+    xs: readonly TranscriptStats[],
+    f: (s: TranscriptStats) => number,
+  ) => xs.reduce((a, s) => a + f(s), 0);
+  const calls = sum(stats, (s) => s.calls);
+  const reads = sum(stats, (s) => s.tokens.cacheRead);
+  const writes = sum(stats, (s) => s.tokens.cacheWrite);
+  const out = sum(stats, (s) => s.tokens.output);
+  const main = stats.filter((s) => !s.subagent);
+  const mainCalls = sum(main, (s) => s.calls);
+  const top15 = [...main]
+    .sort((a, b) => b.tokens.cacheRead - a.tokens.cacheRead)
+    .slice(0, 15);
+  const tools = sum(stats, (s) =>
+    Object.values(s.tools).reduce((a, b) => a + b, 0),
+  );
+  const errors = sum(stats, (s) =>
+    Object.values(s.toolErrors).reduce((a, b) => a + b, 0),
+  );
+  let subTotal = 0;
+  let subOpus = 0;
+  for (const s of stats)
+    if (s.subagent)
+      for (const [m, n] of Object.entries(s.models)) {
+        subTotal += n;
+        if (m.includes("opus")) subOpus += n;
+      }
+  const prompts = sum(stats, (s) => s.prompts);
+  const m: UsageMetrics = {
+    calls,
+    cache_read_B: round(reads / 1e9, 2),
+    output_M: round(out / 1e6, 1),
+    avg_context_k_main: round(
+      sum(main, (s) => s.tokens.cacheRead) / Math.max(1, mainCalls) / 1e3,
+    ),
+    top15_share_pct: round(
+      (100 * sum(top15, (s) => s.tokens.cacheRead)) / Math.max(1, reads),
+    ),
+    // The usual price ratios: a cache read a tenth of input, a write 1.25x, output 5x.
+    reread_share_pct: round(
+      (100 * reads * 0.1) / Math.max(1, reads * 0.1 + writes * 1.25 + out * 5),
+    ),
+    compactions: sum(stats, (s) => s.compactions),
+    polls: sum(stats, (s) => s.polls),
+    denials: sum(stats, (s) => s.denials),
+    tool_error_pct: round((100 * errors) / Math.max(1, tools), 1),
+    prompts,
+    correction_pct: round(
+      (100 * sum(stats, (s) => s.corrections)) / Math.max(1, prompts),
+      1,
+    ),
+    subagent_opus_pct: round((100 * subOpus) / Math.max(1, subTotal)),
+  };
+  if (agents) m.attributed_pct = attributedPct(agents);
+  return m;
+}
+
+/** Higher is better for these; context only for calls, output and prompts. */
+const BETTER_HIGH = new Set(["attributed_pct"]);
+const CONTEXT = new Set(["calls", "output_M", "prompts"]);
+
+/** The report as markdown: this week, last week, and the change. */
+export function renderReport(
+  m: UsageMetrics,
+  date: string,
+  prev?: { date: string; metrics: Partial<UsageMetrics> },
+): string {
+  const lines = [`# Agent usage, week to ${date}`, ""];
+  if (prev) lines.push(`Compared with ${prev.date}.`, "");
+  lines.push(
+    "| Metric | This week | Last | Change |",
+    "| --- | --- | --- | --- |",
+  );
+  for (const [k, v] of Object.entries(m) as [keyof UsageMetrics, number][]) {
+    const p = prev?.metrics[k];
+    let change = "";
+    if (typeof p === "number" && p) {
+      const d = round(v - p, 2);
+      const mark =
+        !d || CONTEXT.has(k)
+          ? ""
+          : (BETTER_HIGH.has(k) ? d > 0 : d < 0)
+            ? "better"
+            : "worse";
+      change = `${d > 0 ? "+" : ""}${d} ${mark}`.trim();
+    }
+    lines.push(`| ${k} | ${v} | ${p ?? ""} | ${change} |`);
+  }
+  lines.push(
+    "",
+    "Read from this machine's transcripts; nothing was sent anywhere.",
+  );
+  return lines.join("\n") + "\n";
+}

package/src/shared/usage/sources.ts

@@ -0,0 +1,127 @@
+/**
+ * Usage sources (den#6): plugin kind `usage`, strategy kind `usage`. A
+ * source reads one runtime's own transcripts on this machine: which files
+ * belong to an agent (by the agent record's resumeToken, the runtime's
+ * conversation id), and every file touched in a window (the weekly
+ * report). Den's built-in reads Claude Code's (den-claude); a plugin adds
+ * one for another runtime the same way, by registering here.
+ *
+ * A source reads locally and never sends what it reads anywhere.
+ */
+import * as fs from "fs";
+import * as path from "path";
+import {
+  getStrategy,
+  registerStrategy,
+  strategyIds,
+  type StrategyEntry,
+} from "../strategies/registry.js";
+import { mineTranscript, type TranscriptStats } from "./transcript.js";
+
+export const USAGE_KIND = "usage";
+
+export interface UsageSource {
+  id: string;
+  /** The runtimes whose agents it reads (den-claude). */
+  runtimes: readonly string[];
+  /** Where it reads (for doctor and the report's header). */
+  root(env?: NodeJS.ProcessEnv): string;
+  /** An agent's transcripts: its conversation's file, then its subagents'. */
+  agentFiles(resumeToken: string, env?: NodeJS.ProcessEnv): string[];
+  /** Every transcript changed since `since` (ms since the epoch). */
+  files(since: number, env?: NodeJS.ProcessEnv): string[];
+  mine(file: string, opts?: { since?: number }): Promise<TranscriptStats>;
+}
+
+/** A conversation id as Claude Code names its files: never a path. */
+const TOKEN_RE = /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/;
+
+import { claudeProjectsDir } from "./paths.js";
+export { claudeProjectsDir };
+
+function dirs(p: string): string[] {
+  try {
+    return fs
+      .readdirSync(p, { withFileTypes: true })
+      .filter((e) => e.isDirectory())
+      .map((e) => path.join(p, e.name));
+  } catch {
+    return [];
+  }
+}
+
+function jsonl(p: string): string[] {
+  try {
+    return fs
+      .readdirSync(p, { withFileTypes: true })
+      .filter((e) => e.isFile() && e.name.endsWith(".jsonl"))
+      .map((e) => path.join(p, e.name));
+  } catch {
+    return [];
+  }
+}
+
+/** Claude Code: <projects>/<cwd slug>/<session id>.jsonl, and <session id>/subagents/*.jsonl. */
+export const claudeCodeSource: UsageSource = {
+  id: "claude-code",
+  runtimes: ["den-claude"],
+  root: claudeProjectsDir,
+  agentFiles(token, env) {
+    if (!TOKEN_RE.test(token)) return [];
+    const out: string[] = [];
+    for (const proj of dirs(claudeProjectsDir(env))) {
+      const f = path.join(proj, `${token}.jsonl`);
+      if (fs.existsSync(f)) out.push(f);
+      out.push(...jsonl(path.join(proj, token, "subagents")));
+    }
+    return out;
+  },
+  files(since, env) {
+    const out: string[] = [];
+    const walk = (p: string, depth: number) => {
+      for (const f of jsonl(p)) {
+        try {
+          if (fs.statSync(f).mtimeMs >= since) out.push(f);
+        } catch {
+          /* gone */
+        }
+      }
+      if (depth < 3) for (const d of dirs(p)) walk(d, depth + 1);
+    };
+    walk(claudeProjectsDir(env), 0);
+    return out.sort();
+  },
+  mine: (file, opts) => mineTranscript(file, opts),
+};
+
+/** Register a usage source (Den's built-in, or a `usage` plugin's). */
+export function registerUsageSource(src: UsageSource): void {
+  const entry: StrategyEntry<typeof USAGE_KIND, UsageSource> = {
+    id: src.id,
+    kind: USAGE_KIND,
+    detect(env) {
+      return fs.existsSync(src.root(env))
+        ? { available: true }
+        : { available: false, reason: `no transcripts at ${src.root(env)}` };
+    },
+    capabilities: src,
+  };
+  registerStrategy(entry);
+}
+
+export function usageSources(): UsageSource[] {
+  return strategyIds(USAGE_KIND)
+    .map(
+      (id) =>
+        getStrategy<typeof USAGE_KIND, UsageSource>(USAGE_KIND, id)
+          ?.capabilities,
+    )
+    .filter((s): s is UsageSource => Boolean(s));
+}
+
+/** The source that reads `runtime`'s agents, if any. */
+export function sourceFor(runtime: string): UsageSource | undefined {
+  return usageSources().find((s) => s.runtimes.includes(runtime));
+}
+
+registerUsageSource(claudeCodeSource);

package/src/shared/usage/transcript.ts

@@ -0,0 +1,262 @@
+/**
+ * One Claude Code transcript, read for what it cost and what it came to
+ * (den#6). Ported from the agent-usage miner: per file, inside a time
+ * window, it counts tokens by kind (once per message id), model calls by
+ * model, tool calls and tool errors, permission denials, polling loops and
+ * their sleeps, compactions, people's prompts and the ones that read as
+ * corrections, and interrupts. It also finds the outcome: a pull request
+ * opened or merged, whether the last test run passed, and the wall-clock
+ * from the first message to the last.
+ *
+ * It reads the file on this machine and keeps counts only: never a
+ * prompt's text, a command's output or a file's contents, and it sends
+ * nothing anywhere (this module imports no network code).
+ */
+import * as fs from "fs";
+import * as readline from "readline";
+
+export interface TokenCounts {
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheWrite: number;
+}
+
+export interface TranscriptStats {
+  file: string;
+  /** Under a session's subagents/ directory. */
+  subagent: boolean;
+  /** Its title (custom, agent name or the runtime's own), when it has one. */
+  title?: string;
+  /** First and last message inside the window (ms since the epoch). */
+  first?: number;
+  last?: number;
+  /** Model calls: assistant messages, once per message id. */
+  calls: number;
+  tokens: TokenCounts;
+  models: Record<string, number>;
+  tools: Record<string, number>;
+  toolErrors: Record<string, number>;
+  denials: number;
+  polls: number;
+  sleepSeconds: number;
+  compactions: number;
+  prompts: number;
+  corrections: number;
+  interrupts: number;
+  agentSpawns: number;
+  /** Time between messages less than 5 minutes apart (seconds). */
+  activeSeconds: number;
+  /** The last pull request URL it opened. */
+  prOpened?: string;
+  prMerged: boolean;
+  /** The last test run's result; undefined when it ran none. */
+  testsGreen?: boolean;
+}
+
+/** A correction, as the miner reads one (emphatic ones; polite ones slip by). */
+const CORRECTION =
+  /\b(wtf|fuck|shit|damn|not what i (said|asked)|that('s| is) wrong|you (missed|forgot|broke)|again\??$|still (not|broken|failing|404)|where (is|the)|why (did|didn't|are|is)|i told you|stop|no,|nope|ugh|boo)\b/i;
+/** A polling loop in a shell command. */
+const POLL = /\bsleep\s+\d|for i in \$\(seq|until |while .*sleep|watch /;
+/** A test run in a shell command. */
+const TEST_RUN =
+  /\b(jest|vitest|pytest|playwright test|go test|cargo test|(npm|pnpm|yarn)( run)? test\w*|make (test|check|gate)\w*)\b/;
+const PR_URL = /https:\/\/github\.com\/[\w.-]+\/[\w.-]+\/pull\/\d+/;
+/** Entries with nothing to count (checked on the line's head, before JSON). */
+const SKIP = [
+  "api-",
+  "file-history",
+  "queue-",
+  "bridge",
+  "last-prompt",
+  "mode",
+  "permission-mode",
+  "tools-used",
+];
+
+function ts(s: unknown): number | undefined {
+  if (typeof s !== "string") return undefined;
+  const t = Date.parse(s);
+  return Number.isFinite(t) ? t : undefined;
+}
+
+function textOf(content: unknown): string {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content))
+    return content
+      .map((c) =>
+        c && typeof c === "object" && (c as { type?: unknown }).type === "text"
+          ? String((c as { text?: unknown }).text ?? "")
+          : "",
+      )
+      .join("\n");
+  return "";
+}
+
+const bump = (m: Record<string, number>, k: string, n = 1) => {
+  m[k] = (m[k] ?? 0) + n;
+};
+
+/** The line's `"type"`, read from its head without parsing it. */
+function headType(line: string): string | null {
+  const m = /^\{\s*"type"\s*:\s*"([^"]+)"/.exec(line.slice(0, 120));
+  return m ? m[1] : null;
+}
+
+/**
+ * Mine `file`. `since`: only messages at or after it count (a session that
+ * runs for weeks contributes its recent calls). Lines it can't parse are
+ * skipped.
+ */
+export async function mineTranscript(
+  file: string,
+  opts: { since?: number } = {},
+): Promise<TranscriptStats> {
+  const r: TranscriptStats = {
+    file,
+    subagent: /[\\/]subagents[\\/]/.test(file),
+    calls: 0,
+    tokens: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    models: {},
+    tools: {},
+    toolErrors: {},
+    denials: 0,
+    polls: 0,
+    sleepSeconds: 0,
+    compactions: 0,
+    prompts: 0,
+    corrections: 0,
+    interrupts: 0,
+    agentSpawns: 0,
+    activeSeconds: 0,
+    prMerged: false,
+  };
+  const seen = new Set<string>();
+  const toolNames = new Map<string, string>();
+  /** Tool-use ids of the commands whose result decides an outcome. */
+  const tests = new Map<string, number>();
+  const merges = new Set<string>();
+  const creates = new Set<string>();
+  let order = 0;
+  let lastTest: { at: number; green: boolean } | undefined;
+  let lastAt: number | undefined;
+  const since = opts.since ?? -Infinity;
+  const lines = readline.createInterface({
+    input: fs.createReadStream(file, { encoding: "utf-8" }),
+    crlfDelay: Infinity,
+  });
+  for await (const line of lines) {
+    const head = headType(line);
+    if (head && SKIP.some((p) => head.startsWith(p))) continue;
+    if (head === "pr-link") {
+      const m = PR_URL.exec(line);
+      if (m) r.prOpened = m[0];
+      continue;
+    }
+    let d: Record<string, unknown>;
+    try {
+      const v: unknown = JSON.parse(line);
+      if (!v || typeof v !== "object" || Array.isArray(v)) continue;
+      d = v as Record<string, unknown>;
+    } catch {
+      continue;
+    }
+    const type = d.type;
+    if (
+      type === "ai-title" ||
+      type === "custom-title" ||
+      type === "agent-name"
+    ) {
+      const t = d.customTitle ?? d.agentName ?? d.aiTitle;
+      if (typeof t === "string" && t) r.title = t.slice(0, 200);
+      continue;
+    }
+    const at = ts(d.timestamp);
+    if (at !== undefined && at < since) continue;
+    if (at !== undefined) {
+      r.first ??= at;
+      r.last = at;
+      if (lastAt !== undefined && at - lastAt > 0 && at - lastAt < 300_000)
+        r.activeSeconds += (at - lastAt) / 1000;
+      lastAt = at;
+    }
+    if (type === "system") {
+      if (String(d.subtype ?? "").includes("compact")) r.compactions++;
+      continue;
+    }
+    const m = (d.message ?? {}) as Record<string, unknown>;
+    if (type === "assistant") {
+      const id = typeof m.id === "string" ? m.id : undefined;
+      if (id && !seen.has(id)) {
+        seen.add(id);
+        r.calls++;
+        const u = (m.usage ?? {}) as Record<string, unknown>;
+        const n = (k: string) =>
+          typeof u[k] === "number" ? (u[k] as number) : 0;
+        r.tokens.input += n("input_tokens");
+        r.tokens.output += n("output_tokens");
+        r.tokens.cacheRead += n("cache_read_input_tokens");
+        r.tokens.cacheWrite += n("cache_creation_input_tokens");
+        bump(r.models, typeof m.model === "string" ? m.model : "?");
+      }
+      for (const c of Array.isArray(m.content) ? m.content : []) {
+        if (!c || typeof c !== "object") continue;
+        const tu = c as Record<string, unknown>;
+        if (tu.type !== "tool_use") continue;
+        const name = typeof tu.name === "string" ? tu.name : "?";
+        const useId = typeof tu.id === "string" ? tu.id : "";
+        toolNames.set(useId, name);
+        bump(r.tools, name);
+        if (name === "Agent" || name === "Task") r.agentSpawns++;
+        if (name !== "Bash") continue;
+        const cmd = String(
+          ((tu.input ?? {}) as Record<string, unknown>).command ?? "",
+        );
+        if (POLL.test(cmd)) r.polls++;
+        for (const s of cmd.matchAll(/\bsleep\s+(\d+)/g))
+          r.sleepSeconds += Number(s[1]);
+        if (TEST_RUN.test(cmd)) tests.set(useId, order++);
+        if (/\bgh pr merge\b/.test(cmd)) merges.add(useId);
+        if (/\bgh pr create\b/.test(cmd)) creates.add(useId);
+      }
+      continue;
+    }
+    if (type !== "user") continue;
+    const content = m.content;
+    if (Array.isArray(content)) {
+      for (const c of content) {
+        if (!c || typeof c !== "object") continue;
+        const tr = c as Record<string, unknown>;
+        if (tr.type !== "tool_result") continue;
+        const useId = typeof tr.tool_use_id === "string" ? tr.tool_use_id : "";
+        const err = tr.is_error === true;
+        if (err) {
+          bump(r.toolErrors, toolNames.get(useId) ?? "?");
+          const low = textOf(tr.content).toLowerCase();
+          if (/doesn't want to proceed|denied|rejected|blocked/.test(low))
+            r.denials++;
+        }
+        const t = tests.get(useId);
+        if (t !== undefined && (!lastTest || t >= lastTest.at))
+          lastTest = { at: t, green: !err };
+        if (merges.has(useId) && !err) r.prMerged = true;
+        if (creates.has(useId) && !err) {
+          const u = PR_URL.exec(textOf(tr.content));
+          if (u) r.prOpened = u[0];
+        }
+      }
+    }
+    if (d.isMeta || d.isSidechain || r.subagent) continue;
+    const text = textOf(content).trim();
+    if (text.includes("[Request interrupted")) {
+      r.interrupts++;
+      continue;
+    }
+    if (!text || text.startsWith("<") || text.startsWith("Caveat:")) continue;
+    r.prompts++;
+    if (CORRECTION.test(text.slice(0, 600))) r.corrections++;
+  }
+  if (lastTest) r.testsGreen = lastTest.green;
+  return r;
+}