@capagents/forgeqe 1.1.9 → 1.2.1

package/src/code/review.ts

@@ -11,6 +11,7 @@ import { loadSkills } from "../skills/registry.ts"
 import type { Price } from "../usage.ts"
 import { prompt } from "../prompts.ts"
 import { domainNotes } from "../domain.ts"
+import type { TestTarget } from "./prompt.ts"
 
 const OUTPUT_CHARS = 4_000
 /** Changed files are shown in the prompt up to these sizes; the reviewer reads the rest itself. */
@@ -78,6 +79,8 @@ export type ReviewInput = {
   outlines?: string
   /** The repository's browser settings files and their values, as ForgeQE read them. */
   settings?: string[]
+  /** The existing test the job was asked to reuse or extend, from measured coverage or the user's choice. */
+  target?: TestTarget
 }
 
 const LIST_MAX = 60
@@ -125,6 +128,16 @@ export function reviewPrompt(input: ReviewInput, repo?: string): string {
     `The handoff it worked from: ${handoff.file}`,
     ...(checks ? ["", "The browser agent's checks, from the handoff:", checks] : []),
     "",
+    ...(input.target
+      ? [
+          "",
+          input.target.mode === "extend"
+            ? `The job was asked to extend the existing test ${input.target.test} (${input.target.testFile}) with only what it lacked: ${input.target.missing.join("; ")}. Adding those steps and checks to that test is the requested change, not a rewrite. A step or assertion of it removed or weakened, those steps duplicated in a new test file, or a shared page-object member changed in a way its other users would notice, is a correctness issue.`
+            : input.target.mode === "update"
+              ? `The user asked to update the existing test ${input.target.test} (${input.target.testFile}) to match this run. Changing its steps, locators, or expected values to match the run is the requested change. Removing an assertion the run still supports, or writing a new test file instead, is a correctness issue.`
+              : `The job was asked to reuse the existing test ${input.target.test} (${input.target.testFile}) as it is, since it already covers the flow. Any change to it, or a new test, is a correctness issue.`,
+        ]
+      : []),
     `Test file: ${report.test_file}`,
     `Command: ${report.command}`,
     input.changes

package/src/mcp/commands.ts

@@ -1,3 +1,7 @@
+import { coverageLines, EXTEND_FROM, measureCoverage, type Candidate } from "../code/coverage.ts"
+import { buildGraph } from "../code/graph/graph.ts"
+import { EXISTING_TEST_FILE } from "../code/notes.ts"
+import type { ExistingTest, TestTarget } from "../code/prompt.ts"
 import { existsSync, readFileSync } from "node:fs"
 import path from "node:path"
 
@@ -27,6 +31,62 @@ const clip = (s: string | undefined, n: number) => {
 }
 
 /** Marks a browser_run that was a task (a lookup in a tool), not a flow to automate; write_test refuses such runs. */
+
+/**
+ * Reuse, extend, or new, from what the repository's tests already cover of the run (code graph and page memory).
+ * The clear cases go ahead and say why; where the evidence fits more than one way, the user picks, seeing each
+ * option's effect. A mode the user gave (through ForgeQE's agent) is followed without asking.
+ */
+export async function chooseTarget(runDir: string, repo: string, args: Record<string, any>, ctx: ToolContext): Promise<{ target?: TestTarget } | { cancelled: true }> {
+  const asked = typeof args.mode === "string" && args.mode !== "auto" ? (args.mode as "new" | "extend" | "reuse" | "update") : null
+  if (asked === "new") return {}
+  const graph = await buildGraph(repo).catch(() => null)
+  if (!graph) return {}
+  const cov = measureCoverage(runDir, graph, ctx.config.memory.dir)
+  const named = args.test_file ? cov.candidates.find((c) => c.file === String(args.test_file).replace(/^\.\//, "")) : undefined
+  let decision = cov.decision
+  if (asked) decision = { mode: asked, ask: false, target: named || cov.candidates[0], why: "the user asked for it" }
+  const lines = coverageLines(cov)
+  const toTarget = (mode: TestTarget["mode"], c: Candidate): TestTarget => ({
+    mode,
+    testFile: c.file,
+    test: c.test,
+    line: c.line,
+    covered: c.covered.map((i) => cov.items[i]!.label),
+    missing: c.missing.map((i) => cov.items[i]!.label),
+    why: `it covers ${c.covered.length} of ${c.covered.length + c.missing.length} steps and checks this run located`,
+  })
+  const say = (title: string, why: string) =>
+    ctx.emit?.({ type: "card", card: { status: "info", title, stats: why, body: lines.length ? ["What the repository's tests already cover of this run:", ...lines] : [] } })
+  if (decision.ask && ctx.ask) {
+    const options = cov.candidates.filter((c) => c.share >= EXTEND_FROM).slice(0, 2).flatMap((c, n) => {
+      const name = `${path.basename(c.file)}`
+      return c.missing.length
+        ? [{ id: `extend:${n}`, label: `Extend ${name} (adds ${c.missing.length})` }]
+        : [{ id: `reuse:${n}`, label: `Reuse ${name} as it is` }]
+    })
+    const answer = await ctx.ask({
+      title: "Existing tests already cover this flow. Which way should Scribe go?",
+      detail: `${decision.why}. Extending keeps the test's steps and adds only what is missing; a new test duplicates what they cover.`,
+      lines,
+      options: [...options, { id: "new", label: "Write a new test" }, { id: "cancel", label: "Cancel" }],
+    })
+    if (!answer || answer === "cancel") return { cancelled: true }
+    if (answer === "new") return {}
+    const [mode, n] = answer.split(":") as ["reuse" | "extend", string]
+    const c = cov.candidates.filter((x) => x.share >= EXTEND_FROM)[Number(n)]!
+    say(mode === "reuse" ? `Reusing ${c.test}` : `Extending ${c.test}`, "the user chose it")
+    return { target: toTarget(mode, c) }
+  }
+  if (decision.mode === "new" || !decision.target) {
+    if (cov.candidates.length) say("Writing a new test", decision.why)
+    return {}
+  }
+  const mode: TestTarget["mode"] = decision.mode === "reuse" ? "reuse" : decision.mode === "update" ? "update" : "extend"
+  say(mode === "reuse" ? `Reusing ${decision.target.test}` : mode === "update" ? `Updating ${decision.target.test}` : `Extending ${decision.target.test}`, decision.why)
+  return { target: toTarget(mode, decision.target) }
+}
+
 export const TASK_FILE = "task.json"
 
 const inCwd = (ctx: ToolContext, p: unknown) => (p ? path.resolve(ctx.cwd, String(p)) : ctx.cwd)
@@ -96,6 +156,13 @@ export const COMMAND_TOOLS: McpTool[] = [
       properties: {
         run_dir: { type: "string", description: "Run folder from browser_run or run_test_cases (default: the latest run)" },
         repo: { type: "string", description: "Repository to write the test in, relative to the working directory (default: the working directory)" },
+        mode: {
+          type: "string",
+          enum: ["auto", "new", "extend", "reuse", "update"],
+          description:
+            "auto (default): ForgeQE measures which existing tests already cover the run, then reuses one that covers it all, extends one that covers most, or writes a new test, and asks the user when that is not clear. new, extend, reuse, update: only when the user said which (\"extend the login test\", \"write a separate test\", \"update it\" after a reused test failed).",
+        },
+        test_file: { type: "string", description: "With mode extend, reuse, or update: the existing test file (from the user, or from an earlier write_test result)" },
       },
     },
     async run(args, ctx) {
@@ -108,6 +175,12 @@ export const COMMAND_TOOLS: McpTool[] = [
       const t0 = Date.now()
       const repo = inCwd(ctx, args.repo)
       const goal = (readJson(path.join(runDir, "run.json")) as { goal?: string } | null)?.goal || ""
+      // browser_run found an earlier test for this flow and it failed: Scribe updates it rather than adding another.
+      const existingTest = readJson(path.join(runDir, EXISTING_TEST_FILE)) as ExistingTest | null
+      // Otherwise: what the repository's tests already cover of this run decides reuse, extend, or new.
+      const chosen = existingTest?.testFile ? { target: undefined } : await chooseTarget(runDir, repo, args, ctx)
+      if ("cancelled" in chosen) return { status: "cancelled", notes: "The user cancelled before Scribe started; nothing was changed." }
+      const target = chosen.target
       ctx.emit?.({ type: "code-start", runDir, repo, goal })
       let r
       try {
@@ -119,6 +192,8 @@ export const COMMAND_TOOLS: McpTool[] = [
           onEvent: (event) => ctx.emit?.({ type: "agent", event }),
           open: ctx.openSession as never,
           runTest: ctx.runTest,
+          ...(existingTest?.testFile ? { existingTest } : {}),
+          ...(target ? { target } : {}),
         })
       } catch (err) {
         ctx.emit?.({ type: "code-done", error: (err as Error).message, ms: Date.now() - t0 })
@@ -136,6 +211,7 @@ export const COMMAND_TOOLS: McpTool[] = [
         notes: r.notes || undefined,
         browsers: r.browsers,
         review: r.review,
+        ...(r.existing ? { existing: r.existing } : {}),
         output: r.status === "passed" ? undefined : clip(r.output, 4000),
       }
     },

package/src/mcp/tools.ts

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync, writeFileSync } from "node:fs"
+import { existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from "node:fs"
 import path from "node:path"
 
 import type { AgentEvent, CodeEvent, CodeResult, ReplayMode, RunResult } from "../types.ts"
@@ -16,6 +16,7 @@ import { buildHandoff } from "../code/handoff.ts"
 import { latestRunDir, runCodeAgent } from "../code/index.ts"
 import type { OpencodeSession } from "../code/runtime.ts"
 import { runTestCommand } from "../code/testrun.ts"
+import { EXISTING_TEST_FILE, findWrittenTest } from "../code/notes.ts"
 import { browserProvider, type AppConfig } from "../config.ts"
 import { clearMemory, memoryFilesFor, memoryFlows, memoryOverview, memoryShow } from "../memory.ts"
 import { executeRun, runDirectory } from "../run.ts"
@@ -329,6 +330,59 @@ function devicesFor(args: Record<string, unknown>, ctx: ToolContext): string[] {
   return [...new Set(devices)]
 }
 
+/**
+ * Runs the test an earlier job wrote for this goal, if there is one. `passed`: the tool's answer, the test having
+ * passed in a browser. `failed`: the test to update, for write_test. Null when there is no such test.
+ */
+async function existingTestFirst(goal: string, runDir: string, ctx: ToolContext): Promise<{ passed?: Record<string, unknown>; failed?: { testFile: string; command: string; output: string; why: string } } | null> {
+  const cfg = ctx.config
+  if (!cfg.memory.enabled) return null
+  let repo = ctx.cwd
+  try {
+    repo = realpathSync(ctx.cwd)
+  } catch {}
+  const known = findWrittenTest(cfg.memory.dir, repo, goal, (f) => existsSync(path.resolve(repo, f)))
+  if (!known) return null
+  const emit = ctx.emit || (() => {})
+  emit({ type: "info", text: `This flow already has a test, ${known.test_file} (written ${known.at.slice(0, 10)}): ForgeQE runs it first` })
+  mkdirSync(runDir, { recursive: true })
+  const run = await (ctx.runTest || runTestCommand)({
+    command: known.command,
+    cwd: repo,
+    timeoutSeconds: cfg.code.testTimeoutSeconds,
+    signal: ctx.signal,
+    hide: privateEnvNames(cfg),
+    save: path.join(runDir, "existing-test"),
+  })
+  if (ctx.signal?.aborted) return null
+  const secs = Math.round(run.ms / 1000)
+  if (run.ok && run.browsers.length) {
+    emit({
+      type: "card",
+      card: {
+        status: "ok",
+        title: "Existing test passed",
+        stats: `${secs}s · no browser run or new test needed`,
+        body: [`Test      ${known.test_file}`, `Command   ${known.command}`, `Browser   ${run.browsers.join(", ")}`, `Written   ${known.at.slice(0, 10)} for the same flow`],
+      },
+    })
+    return {
+      passed: {
+        status: "passed",
+        reused_test: known.test_file,
+        written_for: known.goal,
+        command: known.command,
+        browsers: run.browsers,
+        seconds: secs,
+        note: "An earlier job wrote a test for this flow (written_for) and it passed as it is, in a real browser: no browser run and no new test were needed. If the user's request asks for something written_for does not check, call browser_run again with fresh: true; otherwise say in one or two lines that the existing test passed.",
+      },
+    }
+  }
+  const why = run.ok ? "It exits 0 but opened no browser." : `It fails now (${run.exitCode === null ? "timed out" : `exit ${run.exitCode}`}): the application or the page changed since it was written.`
+  emit({ type: "info", text: `${known.test_file} ${run.ok ? "opened no browser" : "fails now"}: ForgeQE runs the flow in the browser, and Scribe updates that test instead of writing a new one` })
+  return { failed: { testFile: known.test_file, command: known.command, output: run.output, why } }
+}
+
 export const TOOLS: McpTool[] = [
   {
     name: "browser_run",
@@ -362,6 +416,11 @@ export const TOOLS: McpTool[] = [
           description:
             "test: a user flow of the app under test, to verify and turn into an automated test. task: anything else done in a browser, such as looking up or linking work items, checking a relationship, or reading data from a tool; no test is written for it.",
         },
+        fresh: {
+          type: "boolean",
+          description:
+            "true: run in the browser even when an earlier job wrote a test for this goal. Only when the user asks for a new browser run or a new test; by default an existing test is run first and reused when it passes.",
+        },
       },
       required: ["goal", "purpose"],
     },
@@ -378,6 +437,10 @@ export const TOOLS: McpTool[] = [
       if (devices.length > 1) return runGoalOnDevices(goal, url, devices, args, ctx)
       const runDir = runDirectory(ctx.config.export.outDir)
       const emit = ctx.emit || (() => {})
+      // The same flow asked again: an earlier job's test for it runs first. Passing in a browser, it answers the goal
+      // in seconds, with no browser run and no new test; failing, the run goes ahead and Scribe updates that test.
+      const reuse = ctx.writeTests && args.purpose !== "task" && !args.fresh && !resumeFrom && devices.length <= 1 ? await existingTestFirst(goal, runDir, ctx) : null
+      if (reuse?.passed) return reuse.passed
       const t0 = Date.now()
       emit({ type: "run-start", goal, url })
       try {
@@ -406,7 +469,11 @@ export const TOOLS: McpTool[] = [
           return summary
         }
         if (ctx.writeTests && result.status === "complete" && result.driver !== "synthetic") {
-          return { ...summary, next_step: `This session turns passed runs into tests: call write_test with run_dir ${runDir} now, before you reply.` }
+          if (reuse?.failed) writeFileSync(path.join(runDir, EXISTING_TEST_FILE), `${JSON.stringify(reuse.failed, null, 2)}\n`)
+          return {
+            ...summary,
+            next_step: `This session turns passed runs into tests: call write_test with run_dir ${runDir} now, before you reply.${reuse?.failed ? ` It updates the existing test ${reuse.failed.testFile} instead of writing a new one.` : ""}`,
+          }
         }
         return summary
       } catch (err) {

package/src/run.ts

@@ -1,3 +1,4 @@
+import { saveApiSteps } from "./api/fromSteps.ts"
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs"
 import { createRequire } from "node:module"
 import path from "node:path"
@@ -23,6 +24,8 @@ import { knowledgeBlock, readKnowledge, relevantKnowledge } from "./knowledge.ts
 export type ExecuteOptions = {
   config: AppConfig
   goal: string
+  /** The test case the run is for: its API steps are saved as that case's scenario. */
+  caseRef?: { caseId?: string; caseTitle?: string }
   browserProvider?: BrowserProvider
   /** A named device from the provider files (browser_devices); it also picks the provider. */
   browserDevice?: string
@@ -156,6 +159,13 @@ export async function executeRun(opts: ExecuteOptions): Promise<{ result: RunRes
   const withReport = (out: { result: RunResult; files: string[] }) => {
     out.result.cost = costOf(out.result.usage, opts.config.llm.price)
     applyQuality(opts.config, dir, out.result, opts.onEvent)
+    // API steps the run made in the browser's session, kept as a scenario the API tools run again without a browser.
+    try {
+      const api = saveApiSteps(opts.config, dir, opts.caseRef || {})
+      if (api) out.result.api = { id: api.id, dir: api.dir, calls: api.calls }
+    } catch (err) {
+      opts.onEvent?.({ type: "log", level: "warn", text: `API steps not saved as a scenario: ${(err as Error).message}` })
+    }
     logEvent("run.done", { out_dir: dir, status: out.result.status, summary: out.result.summary, usage: out.result.usage, memory: out.result.memory, ...(out.result.skills ? { skills: out.result.skills } : {}) })
     try {
       out.files.push(writeRunReport(dir, out.result, reportEnv(opts.config, { url: startUrl, headed: opts.headed, browser }), t0))

package/src/suite/report.ts

@@ -77,11 +77,28 @@ export function suiteUsage(results: CaseResult[], analysis?: { usage: Usage; cos
   return { usage, cost: priced ? cost : undefined }
 }
 
+/**
+ * The suite's headline, saying what each part did: the cases, and the tests written from them. A suite whose cases
+ * all passed but whose test did not pass is not called failed with "1/1 passed" beside it.
+ */
+export function suiteHeadline(s: Pick<SuiteResult, "results" | "stopped">): { mark: "✓" | "✗" | "■"; title: string; counts: string; ok: boolean } {
+  const c = counts(s.results)
+  const coded = s.results.filter((r) => r.code)
+  const testsOk = coded.filter((r) => r.code!.status === "passed").length
+  const casesOk = c.passed === c.total
+  const testsLine = coded.length ? ` · ${testsOk}/${coded.length} ${coded.length === 1 ? "test" : "tests"} passing` : ""
+  const countsLine = `${c.passed}/${c.total} ${c.total === 1 ? "case" : "cases"} passed${testsLine}`
+  if (s.stopped) return { mark: "■", title: "Suite stopped", counts: countsLine, ok: false }
+  if (!casesOk) return { mark: "✗", title: "Suite failed", counts: countsLine, ok: false }
+  if (testsOk < coded.length) return { mark: "✗", title: `${c.total === 1 ? "Case" : "Cases"} passed, ${coded.length - testsOk === 1 ? "test" : "tests"} not passing`, counts: countsLine, ok: false }
+  return { mark: "✓", title: "Suite passed", counts: countsLine, ok: true }
+}
+
 /** The end-of-suite summary for the terminal. */
 export function formatSuite(s: SuiteResult, cwd = process.cwd()): string {
-  const c = counts(s.results)
   const tokens = s.results.reduce((n, r) => n + r.tokens, 0)
-  const head = `${s.stopped ? "■ Suite stopped" : c.passed === c.total ? "✓ Suite passed" : "✗ Suite failed"} · ${c.passed}/${c.total} passed · ${duration(s.ms)} · ${(tokens / 1000).toFixed(1)}K tokens`
+  const h = suiteHeadline(s)
+  const head = `${h.mark} ${h.title} · ${h.counts} · ${duration(s.ms)} · ${(tokens / 1000).toFixed(1)}K tokens`
   const show = (f: string) => path.relative(cwd, f) || f
   const total = suiteUsage(s.results, s.analysis)
   const lines = [head, ""]
@@ -116,7 +133,8 @@ export function formatSuite(s: SuiteResult, cwd = process.cwd()): string {
 export function markdownSummary(s: SuiteResult): string {
   const c = counts(s.results)
   const cell = (t: string) => t.replace(/\|/g, "\\|").replace(/\s+/g, " ").trim()
-  const head = s.stopped ? "■ Suite stopped" : c.passed === c.total ? "✓ Suite passed" : "✗ Suite failed"
+  const h = suiteHeadline(s)
+  const head = `${h.mark} ${h.title}`
   const rows = s.results.map((r) => {
     const test = r.code ? `${r.code.status}${r.code.testFile ? ` \`${cell(r.code.testFile)}\`` : ""}` : ""
     const steps = r.stepResults?.length && r.case.steps.length ? `${r.stepResults.filter((v) => v.status === "passed").length}/${r.case.steps.length}` : ""
@@ -140,7 +158,7 @@ export function markdownSummary(s: SuiteResult): string {
       ]
     : []
   return [
-    `### ${head} · ${c.passed}/${c.total} passed · ${duration(s.ms)}`,
+    `### ${head} · ${h.counts} · ${duration(s.ms)}`,
     "",
     "| | Case | Title | Steps | Time | Result | Test |",
     "|---|---|---|---|---|---|---|",

package/src/suite/run.ts

@@ -151,6 +151,7 @@ export async function runSuite(opts: SuiteOptions): Promise<SuiteResult> {
         const { result } = await execute({
           config,
           goal: goalFor(original),
+          caseRef: { caseId: original.id, caseTitle: original.title },
           browserProvider: opts.browserProvider,
           browserDevice: device,
           url: tc.startUrl || opts.url,

package/src/summary.ts

@@ -25,6 +25,8 @@ export type RunSummary = {
   usage: string
   /** WCAG rules passed and failed, Core Web Vitals, and whether the budgets held. */
   quality?: string
+  /** The API steps saved as a reusable scenario: "2 calls saved as API scenario 20261013-…" and where. */
+  api?: string
 }
 
 export const STATUS_TITLE: Record<RunStatus, string> = {
@@ -80,6 +82,7 @@ export function buildSummary(opts: {
   failedChecks?: { expected: string; actual: string }[]
   quality?: QualityReport
   budgetExceeded?: string[]
+  api?: { id: string; dir: string; calls: number }
 }): RunSummary {
   const dir = opts.files.length ? path.relative(process.cwd(), path.dirname(opts.files[0])) || "." : ""
   const assertion = opts.outcome === "assertion_failed"
@@ -97,6 +100,7 @@ export function buildSummary(opts: {
     savedFiles: opts.files.map((f) => path.basename(f)),
     usage: opts.usage ? usageLine(opts.usage, opts.cost) : "",
     ...(opts.quality && qualityLine(opts.quality) ? { quality: qualityLine(opts.quality) } : {}),
+    ...(opts.api ? { api: `${opts.api.calls} ${opts.api.calls === 1 ? "call" : "calls"} saved as a reusable API scenario · ${path.relative(process.cwd(), opts.api.dir) || opts.api.dir}/` } : {}),
   }
 }
 
@@ -106,6 +110,7 @@ export function formatSummary(s: RunSummary): string {
   if (s.finalUrl) lines.push(`Ended on  ${s.finalUrl}`)
   if (s.memory) lines.push(`Memory    ${s.memory}`)
   if (s.quality) lines.push(`Quality   ${s.quality}`)
+  if (s.api) lines.push(`API       ${s.api}`)
   if (s.usage) lines.push(`Usage     ${s.usage}`)
   if (s.savedDir) lines.push(`Saved     ${s.savedDir}/  ${s.savedFiles.join(" · ")}`)
   return lines.join("\n")

package/src/tui/App.tsx

@@ -893,6 +893,7 @@ export function App({ options }: { options: TuiOptions }) {
           failedChecks: r?.failedChecks,
           quality: r?.quality,
           budgetExceeded: r?.budgetExceeded,
+          api: r?.api,
           ms: e.ms,
           tokens: r ? r.usage.input + r.usage.output : 0,
           steps: stepRef.current,

package/src/tui/transcript.tsx

@@ -6,7 +6,7 @@ import { createContext, useContext, type ReactNode } from "react"
 
 import type { CodeResult, RunStatus } from "../types.ts"
 import { CARD_MARK, type Card } from "../card.ts"
-import { counts } from "../suite/report.ts"
+import { counts, suiteHeadline } from "../suite/report.ts"
 import { suiteExitCode, type SuiteResult } from "../suite/run.ts"
 import { STATUS_MARK, shortPath, type RunSummary } from "../summary.ts"
 import { BAR } from "./components.tsx"
@@ -192,6 +192,7 @@ export function SummaryCard({ summary }: { summary: RunSummary }) {
         {summary.finalUrl ? detail("Ended on", <span fg={theme.muted}>{summary.finalUrl}</span>) : null}
         {summary.memory ? detail("Memory", <span fg={theme.muted}>{summary.memory}</span>) : null}
         {summary.quality ? detail("Quality", <span fg={theme.muted}>{summary.quality}</span>) : null}
+        {summary.api ? detail("API", <Linked text={summary.api} color={theme.muted} lead={UNDER + 10} />) : null}
         {summary.savedDir ? (
           <text>
             <span fg={theme.faint}>{"Saved     "}</span>
@@ -272,7 +273,7 @@ export function Row({ label, value, color = theme.muted }: { label: string; valu
 export const CASE_MARK = { passed: "✓", failed: "✗", error: "!", stopped: "■" } as const
 
 export function SuiteCard({ suite }: { suite: SuiteResult }) {
-  const c = counts(suite.results)
+  const head = suiteHeadline(suite)
   const ok = !suite.stopped && suiteExitCode(suite) === 0
   const color = suite.stopped ? theme.warn : ok ? theme.ok : theme.err
   const tokens = suite.results.reduce((n, r) => n + r.tokens, 0)
@@ -283,9 +284,9 @@ export function SuiteCard({ suite }: { suite: SuiteResult }) {
       <Marked mark={MARK.item} color={color} gap>
         <text>
           <span fg={theme.text}>
-            <strong>{suite.stopped ? "Suite stopped" : ok ? "Suite passed" : "Suite failed"}</strong>
+            <strong>{head.title}</strong>
           </span>
-          <span fg={theme.faint}>{`  ${c.passed}/${c.total} passed · ${formatDuration(suite.ms)} · ${formatTokens(tokens)} tokens`}</span>
+          <span fg={theme.faint}>{`  ${head.counts} · ${formatDuration(suite.ms)} · ${formatTokens(tokens)} tokens`}</span>
         </text>
       </Marked>
       <Under first>

package/src/types.ts

@@ -59,6 +59,8 @@ export type RunResult = {
   quality?: QualityReport
   /** Budgets this run exceeded: the run counts as failed, though its steps passed. */
   budgetExceeded?: string[]
+  /** The run's API steps, saved as a reusable API scenario: where, and how many calls. */
+  api?: { id: string; dir: string; calls: number }
 }
 
 /** Why a failed step failed, in the browser agent's judgement: see src/cases/failure.ts. */
@@ -116,6 +118,8 @@ export type CodeResult = {
   knownDefect?: boolean
   /** The job did not finish: what it wrote was moved to the needs-attention folder (see src/code/attention.ts). */
   attention?: { dir: string; files: string[]; patch?: string; readme: string }
+  /** The job worked from an existing test: ran it as it was, extended it, or updated it. */
+  existing?: "reused" | "extended" | "updated"
 }
 
 /** What an agent did to a file, for the shell's file list. */