@capagents/forgeqe 1.2.1 → 1.3.0

package/src/code/find.ts

@@ -382,6 +382,8 @@ export async function runSelection(opts: {
   hide?: string[]
   /** Retries and quarantine; default: one retry, quarantine suggested. */
   flaky?: FlakyConfig
+  /** Extra variables for the tests, such as a remote browser's endpoint. */
+  env?: Record<string, string>
 }): Promise<TestsRun> {
   const sel = opts.selection
   const flakyCfg = opts.flaky || { retries: 1, quarantine: "suggest", flakyAfter: 2 }
@@ -389,7 +391,7 @@ export async function runSelection(opts: {
   mkdirSync(sel.dir, { recursive: true })
   for (const p of sel.results) if (p.startsWith(sel.dir) && existsSync(p) && statSync(p).isFile()) rmSync(p)
   const started = Date.now()
-  const exec = (command: string) => (opts.runTest || runTestCommand)({ command, cwd: sel.repo, timeoutSeconds: opts.timeoutSeconds, signal: opts.signal, hide: opts.hide })
+  const exec = (command: string) => (opts.runTest || runTestCommand)({ command, cwd: sel.repo, timeoutSeconds: opts.timeoutSeconds, signal: opts.signal, hide: opts.hide, ...(opts.env ? { env: opts.env } : {}) })
   const read = (since: number) => {
     const out: TestOutcome[] = []
     for (const f of resultFiles(sel.results, since)) {

package/src/code/graph/graph.ts

@@ -86,8 +86,15 @@ export async function buildGraph(repo: string, opts: { cacheDir?: string } = {})
 /** A member (or top-level function or test) with where it is. */
 export type Located = { file: string; cls?: ClassFacts; member: Member }
 
+const membersOf = new WeakMap<CodeGraph, Located[]>()
+
+/** Every member of the graph; worked out once per graph, which does not change once built. */
 export function allMembers(g: CodeGraph): Located[] {
-  return g.files.flatMap((f) => [...f.classes.flatMap((cls) => cls.members.map((member) => ({ file: f.file, cls, member }))), ...f.functions.map((member) => ({ file: f.file, member }))])
+  const known = membersOf.get(g)
+  if (known) return known
+  const all = g.files.flatMap((f) => [...f.classes.flatMap((cls) => cls.members.map((member) => ({ file: f.file, cls, member }))), ...f.functions.map((member) => ({ file: f.file, member }))])
+  membersOf.set(g, all)
+  return all
 }
 
 export const qualified = (l: Located) => (l.cls ? `${l.cls.name}.${l.member.name}` : l.member.name)
@@ -314,8 +321,21 @@ export function describeMatches(g: CodeGraph, matches: ElementMatch[], max = 3):
 // References
 
 /** The class a receiver names: from the file's declarations, then any file's, then by name (articlePage → WikipediaArticlePage). */
+const receivers = new WeakMap<CodeGraph, Map<string, string | null>>()
+
 function receiverClass(g: CodeGraph, file: FileFacts, receiver: string, classes: Set<string>): string | null {
   if (!receiver) return null
+  // The graph does not change once built: each file's receiver resolves the same way every time it is asked.
+  let cache = receivers.get(g)
+  if (!cache) receivers.set(g, (cache = new Map()))
+  const key = `${file.file}\u0000${receiver}\u0000${classes.size}`
+  if (cache.has(key)) return cache.get(key)!
+  const found = resolveReceiver(g, file, receiver, classes)
+  cache.set(key, found)
+  return found
+}
+
+function resolveReceiver(g: CodeGraph, file: FileFacts, receiver: string, classes: Set<string>): string | null {
   const last = receiver.split(".").pop() || receiver
   if (classes.has(last)) return last
   const bound = file.bindings[receiver] || file.bindings[last]
@@ -331,13 +351,24 @@ function receiverClass(g: CodeGraph, file: FileFacts, receiver: string, classes:
 }
 
 /** The class and its base classes, nearest first. */
+const lineages = new WeakMap<CodeGraph, { byName: Map<string, ClassFacts>; memo: Map<string, string[]> }>()
+
 function lineage(g: CodeGraph, name: string): string[] {
+  let c = lineages.get(g)
+  if (!c) {
+    const byName = new Map<string, ClassFacts>()
+    for (const f of g.files) for (const cls of f.classes) if (!byName.has(cls.name)) byName.set(cls.name, cls)
+    lineages.set(g, (c = { byName, memo: new Map() }))
+  }
+  const known = c.memo.get(name)
+  if (known) return known
   const out: string[] = []
   let cur: string | undefined = name
   while (cur && !out.includes(cur)) {
     out.push(cur)
-    cur = g.files.flatMap((f) => f.classes).find((c) => c.name === cur)?.bases[0]
+    cur = c.byName.get(cur)?.bases[0]
   }
+  c.memo.set(name, out)
   return out
 }
 

package/src/code/loop.ts

@@ -10,6 +10,7 @@ import type { TestCase } from "../cases/types.ts"
 import { buildProfile, profileSection } from "./profile.ts"
 import { LIVE_BROWSER_SERVER, liveBrowser } from "./livebrowser.ts"
 import { additionFacts, buildGraph, classesUsedBy, outlines, type CodeGraph } from "./graph/graph.ts"
+import { breachPrompt, checkOriginal, readOriginal } from "./protect.ts"
 import { CODE_GRAPH_SERVER, codeGraphTools } from "./graph/tools.ts"
 import { localToolServer } from "../mcp/server.ts"
 import type { ToolContext } from "../mcp/tools.ts"
@@ -19,6 +20,7 @@ import { openSession, READ_AGENT, TEST_AGENT, type OpencodeSession, type PromptO
 import { failureContext } from "./slices.ts"
 import { moveToAttention } from "./attention.ts"
 import { recordMapping } from "./traceability.ts"
+import { stepsHash } from "../cases/types.ts"
 import {
   blockedChallengePrompt,
   carryOnPrompt,
@@ -167,6 +169,8 @@ export async function runCodeAgent(opts: {
   // locates it, Scribe gets code_* tools instead of reading whole files, and the reviewer gets what the job duplicated.
   const built = config.code.graph === false ? null : await buildGraph(repo).catch(() => null)
   const graph: CodeGraph | null = built?.files.length ? built : null
+  // The existing test the job works from, as it is now: what Scribe may do to it is checked before each test run.
+  const original = opts.target ? await readOriginal(repo, opts.target) : null
   let handoff = buildHandoff(opts.runDir, config.memory.dir, { knownDefect: opts.knownDefect, graph })
   if (!handoff.success && !opts.knownDefect) throw new Error("The coding agent only takes runs that passed. This run failed.")
   const plural = (n: number, w: string) => `${n} ${w}${n === 1 ? "" : "s"}`
@@ -496,6 +500,17 @@ export async function runCodeAgent(opts: {
       result.reused = report.reused || []
       result.changed = report.changed || []
 
+      if (original && opts.target) {
+        const breach = await checkOriginal(repo, original, opts.target.mode)
+        if (breach) {
+          result.breaches = (result.breaches || 0) + 1
+          emit({ type: "code", kind: "test", ok: false, attempt, text: `${breach.why}: not run; Scribe puts it back (attempt ${attempt}/${allowed})` })
+          attemptLog.push(attemptLine(attempt, "changed the existing test it was asked to keep", breach.lines.slice(0, 3).join(" | "), report.notes))
+          nextTask = breachPrompt(original, breach, opts.target.mode)
+          next = { why: breach.why, fixing: [opts.target.mode === "extend" ? "Put back the existing test's lines exactly; add only the new steps" : "Leave the existing test as it was"] }
+          continue
+        }
+      }
       emit({ type: "code", kind: "info", text: `ForgeQE runs the test: ${report.command}` })
       const run = await runTest({
         command: report.command,
@@ -571,7 +586,7 @@ export async function runCodeAgent(opts: {
           result.status = "passed"
           // What it did with the existing test it was given, for the result card and the agent.
           if (opts.existingTest) result.existing = "updated"
-          else if (opts.target) result.existing = opts.target.mode === "reuse" ? "reused" : opts.target.mode === "update" ? "updated" : "extended"
+          else if (opts.target) result.existing = opts.target.mode === "reuse" ? "reused" : opts.target.mode === "update" ? "updated" : opts.target.mode === "sibling" ? "added_beside" : "extended"
           if (standards.length) {
             result.review = { ...verdict.review, approved: true, standardsLeft: true }
             result.notes = `The test passes and tests the goal. Coding standards still to fix: ${standards.map((i) => `${i.file ? `${i.file}: ` : ""}${i.problem}`).join(" ")}`
@@ -652,6 +667,7 @@ export async function runCodeAgent(opts: {
         ...(result.testName ? { testName: result.testName } : {}),
         ...(result.command ? { command: result.command } : {}),
         ...(opts.knownDefect?.bug ? { bug: opts.knownDefect.bug } : {}),
+        ...(tc.steps?.length ? { stepsHash: stepsHash(tc.steps) } : {}),
       })
     }
     // An unfinished job (not one that can be resumed) leaves no failing test among the tests: it goes to needs-attention.

package/src/code/notes.ts

@@ -98,7 +98,8 @@ function goalWords(goal: string): Set<string> {
 
 /** The website a goal names, if any: the same steps on another site are another flow. */
 function goalHost(goal: string): string {
-  return /https?:\/\/(?:www\.)?([^/\s,)]+)/i.exec(goal)?.[1]?.toLowerCase() || ""
+  // A URL ending a sentence ("Open https://shop.test.") keeps its host without the full stop.
+  return (/https?:\/\/(?:www\.)?([^/\s,)]+)/i.exec(goal)?.[1]?.toLowerCase() || "").replace(/[.:;!?]+$/, "")
 }
 
 /**
@@ -147,5 +148,51 @@ export function findWrittenTest(memoryDir: string, repo: string, goal: string, e
   return best?.test || null
 }
 
+/**
+ * Goals at least this alike may be the same journey, or one a request extends. ForgeQE's agent rewrites the user's
+ * request each time, so the same request scores as low as 0.34 against an earlier wording, while unrelated flows
+ * measured on real goals stay under 0.21. Too loose to decide on its own: ForgeQE's agent compares the goals.
+ */
+export const RELATED_GOAL = 0.25
+/** And they share at least this many content words: two short goals on one site share a word or two by chance. */
+const RELATED_WORDS = 3
+
+function sharedWords(a: string, b: string): number {
+  const y = goalWords(b)
+  let n = 0
+  for (const w of goalWords(a)) if (y.has(w)) n++
+  return n
+}
+
+/**
+ * Earlier tests in this repository whose goals are close to `goal` without being the same flow: candidates to reuse or
+ * extend before the browser explores anything. One per test file, the closest first.
+ */
+export function findRelatedTests(memoryDir: string, repo: string, goal: string, exists: (file: string) => boolean, max = 3): (WrittenTest & { similarity: number })[] {
+  const best = new Map<string, WrittenTest & { similarity: number }>()
+  for (const t of load(memoryDir).repos[repo]?.tests || []) {
+    const similarity = goalSimilarity(t.goal, goal)
+    if (similarity < RELATED_GOAL || sharedWords(t.goal, goal) < RELATED_WORDS || !exists(t.test_file)) continue
+    const had = best.get(t.test_file)
+    if (!had || similarity > had.similarity || (similarity === had.similarity && t.at > had.at)) best.set(t.test_file, { ...t, similarity })
+  }
+  return [...best.values()].sort((a, b) => b.similarity - a.similarity || b.at.localeCompare(a.at)).slice(0, max)
+}
+
+/** Every test earlier jobs wrote in this repository, of any age: their commands show how it runs one test. */
+export function writtenTests(memoryDir: string, repo: string): WrittenTest[] {
+  return load(memoryDir).repos[repo]?.tests || []
+}
+
+/** The earlier test written in this repository to this file (the newest), for a test ForgeQE's agent names. */
+export function writtenTestFor(memoryDir: string, repo: string, testFile: string): WrittenTest | null {
+  const file = testFile.replace(/^\.\//, "")
+  const tests = (load(memoryDir).repos[repo]?.tests || []).filter((t) => t.test_file === file)
+  return tests.sort((a, b) => b.at.localeCompare(a.at))[0] || null
+}
+
 /** Where browser_run leaves the earlier test for a goal that failed, so write_test updates it instead of adding one. */
 export const EXISTING_TEST_FILE = "existing-test.json"
+
+/** Where browser_run leaves the earlier test ForgeQE's agent chose to extend, so write_test extends it. */
+export const EXTEND_TEST_FILE = "extend-test.json"

package/src/code/prompt.ts

@@ -78,7 +78,7 @@ export type ExistingTest = { testFile: string; command: string; output: string;
  * An existing test the job works from, chosen from measured coverage (or by the person): `reuse` it as it is, or
  * `extend` it with only the steps and checks it lacks.
  */
-export type TestTarget = { mode: "reuse" | "extend" | "update"; testFile: string; test: string; line: number; covered: string[]; missing: string[]; why: string }
+export type TestTarget = { mode: "reuse" | "extend" | "update" | "sibling"; testFile: string; test: string; line: number; covered: string[]; missing: string[]; why: string }
 
 function targetSection(t: TestTarget): string[] {
   const list = (items: string[]) => items.map((i) => `- ${i}`)
@@ -91,6 +91,18 @@ function targetSection(t: TestTarget): string[] {
       "",
     ]
   }
+  if (t.mode === "sibling") {
+    return [
+      "## Add a test beside the existing one, do not change it",
+      "",
+      `${t.test} (${t.testFile}:${t.line}) covers the start of this journey (${t.why}). Add one new test method next to it, in the same class, for the flow below: reuse its setup, its helpers, and the page-object methods it calls for the steps the two share, and add only what the flow adds. Leave ${t.test} as it is. Do not create a new test file.`,
+      ...(t.covered.length ? ["", "The steps it already has, to reuse through the same methods:", ...t.covered.map((i) => `- ${i}`)] : []),
+      ...(t.missing.length ? ["", "What the new test adds:", ...t.missing.map((i) => `- ${i}`)] : []),
+      "",
+      "Add page-object members for elements the repository does not locate yet. Do not change what an existing member or method does: other tests use it (code_references shows which).",
+      "",
+    ]
+  }
   if (t.mode === "reuse") {
     return [
       "## The existing test that already covers this flow",
@@ -100,16 +112,24 @@ function targetSection(t: TestTarget): string[] {
       "",
     ]
   }
+  const measured = t.covered.length
+    ? [
+        `ForgeQE's code graph found that ${t.test} (${t.testFile}:${t.line}) already covers most of this flow (${t.why}). Extend that test: add only what it lacks, in the order of the flow, through the same page objects and helpers. Keep every step and assertion it has. Do not create a new test file.`,
+        "",
+        "It already covers:",
+        ...list(t.covered),
+        "",
+        "Add only these:",
+        ...list(t.missing),
+      ]
+    : [
+        `${t.testFile} was chosen to extend (${t.why}): it covers the start of this journey. ForgeQE's code graph could not tell which of the run's steps it already does, so read it, keep every step and assertion it has, and add only the steps and checks of the run it lacks, in the order of the flow, through the same page objects and helpers. Do not create a new test file.`,
+        ...(t.missing.length ? ["", "The run's steps and checks:", ...list(t.missing)] : []),
+      ]
   return [
     "## Extend the existing test, do not write a new one",
     "",
-    `ForgeQE's code graph found that ${t.test} (${t.testFile}:${t.line}) already covers most of this flow (${t.why}). Extend that test: add only what it lacks, in the order of the flow, through the same page objects and helpers. Keep every step and assertion it has. Do not create a new test file.`,
-    "",
-    "It already covers:",
-    ...list(t.covered),
-    "",
-    "Add only these:",
-    ...list(t.missing),
+    ...measured,
     "",
     "When the missing steps start from a different place than the test does, add one test method next to it in the same class, reusing its setup and helpers, instead of a new file.",
     "Add page-object members for elements the repository does not locate yet. Do not change what an existing member or method does: other tests use it (code_references shows which). When one must change, keep its behaviour for those tests and say so in notes.",
@@ -142,13 +162,15 @@ export function firstPrompt(handoff: Handoff, opts: { liveBrowserDir?: string; l
     : ""
   return [
     opts.existing
-      ? `Update the existing test for the flow below so it passes again. When it is updated, give the structured result; ForgeQE then runs it.`
+      ? `Update the existing test so it does the flow below and passes. When it is updated, give the structured result; ForgeQE then runs it.`
       : opts.target?.mode === "reuse"
         ? `An existing test already covers the flow below. Report how to run it; change nothing. ForgeQE then runs it.`
         : opts.target?.mode === "extend"
           ? `Extend the existing test named below with what the flow below adds. When it is extended, give the structured result; ForgeQE then runs it.`
           : opts.target?.mode === "update"
             ? `Update the existing test named below to match the flow below. When it is updated, give the structured result; ForgeQE then runs it.`
+          : opts.target?.mode === "sibling"
+            ? `Add a test for the flow below next to the existing test named below, in its class, reusing its setup and steps. When it is written, give the structured result; ForgeQE then runs it.`
           : `Write a test in this repository for the flow below, reusing the repository's existing test code. When it is written, give the structured result; ForgeQE then runs it.`,
     "",
     ...(opts.existing ? existingSection(opts.existing) : opts.target ? targetSection(opts.target) : []),

package/src/code/protect.ts

@@ -0,0 +1,103 @@
+import { readFileSync } from "node:fs"
+import path from "node:path"
+
+import { parseFile, type FileFacts, type Member } from "./graph/parse.ts"
+import type { TestTarget } from "./prompt.ts"
+
+/**
+ * What a job may do to the existing test it was given, checked in code rather than left to the prompt: extending keeps
+ * every line the test had, in order, and only adds; a test added beside it, or a test reused, leaves it as it was; and
+ * the test keeps its name. A live run showed why: asked to extend, Scribe changed the test's data values to the run's,
+ * and the reviewer approved it.
+ */
+
+/** The existing test as the job found it: its method name and its lines. */
+export type Original = { file: string; test: string; method: string; lines: string[] }
+
+/** A line that is only punctuation says nothing about what the test does: braces, a lone semicolon, a closing paren. */
+const SAYS_NOTHING = /^[{}()[\];,]*$/
+
+const meaningful = (lines: string[]) => lines.map((l) => l.trim()).filter((l) => l && !SAYS_NOTHING.test(l))
+
+function members(facts: FileFacts | null): { cls?: string; m: Member }[] {
+  if (!facts) return []
+  return [...facts.classes.flatMap((c) => c.members.map((m) => ({ cls: c.name, m }))), ...facts.functions.map((m) => ({ m }))]
+}
+
+/** The test's member in a parsed file: by Class.Method, or by its method name or title alone. */
+function find(facts: FileFacts | null, test: string): Member | null {
+  const method = test.split(".").pop() || test
+  const all = members(facts).filter(({ m }) => m.kind === "test" || m.kind === "method")
+  return all.find(({ cls, m }) => `${cls}.${m.name}` === test)?.m || all.find(({ m }) => m.name === method)?.m || null
+}
+
+async function read(repo: string, file: string): Promise<{ text: string; facts: FileFacts | null } | null> {
+  try {
+    const text = readFileSync(path.join(repo, file), "utf8")
+    return { text, facts: await parseFile(file, text) }
+  } catch {
+    return null
+  }
+}
+
+/** The target test's lines before the job starts; null when the file or the test cannot be read. */
+export async function readOriginal(repo: string, target: Pick<TestTarget, "testFile" | "test">): Promise<Original | null> {
+  const got = await read(repo, target.testFile)
+  const m = got && find(got.facts, target.test)
+  if (!got || !m) return null
+  return { file: target.testFile, test: target.test, method: m.name, lines: got.text.split("\n").slice(m.line - 1, m.endLine) }
+}
+
+/** Lines of `before` missing from `after` when `after` must keep them in order (it may add lines between them). */
+export function droppedLines(before: string[], after: string[]): string[] {
+  const keep = meaningful(before)
+  const now = meaningful(after)
+  const dropped: string[] = []
+  let j = 0
+  for (const line of keep) {
+    const at = now.indexOf(line, j)
+    if (at === -1) dropped.push(line)
+    else j = at + 1
+  }
+  return dropped
+}
+
+export type Breach = { why: string; lines: string[] }
+
+/**
+ * How the job broke what its mode allows on the original test, or null when it did not. extend: no line dropped or
+ * changed; sibling and reuse: the test exactly as it was; every mode: the test still there under its name.
+ */
+export async function checkOriginal(repo: string, original: Original, mode: TestTarget["mode"]): Promise<Breach | null> {
+  if (mode === "update") return null
+  const got = await read(repo, original.file)
+  const m = got && find(got.facts, original.method)
+  if (!got || !m) return { why: `the existing test ${original.test} is no longer in ${original.file} under that name`, lines: [] }
+  const now = got.text.split("\n").slice(m.line - 1, m.endLine)
+  if (mode === "extend") {
+    const dropped = droppedLines(original.lines, now)
+    return dropped.length ? { why: `lines of the existing test ${original.test} were changed or removed; extending keeps every line it had and only adds`, lines: dropped } : null
+  }
+  const changed = meaningful(original.lines).join("\n") !== meaningful(now).join("\n")
+  if (!changed) return null
+  const dropped = droppedLines(original.lines, now)
+  return {
+    why: mode === "sibling" ? `the existing test ${original.test} was changed; a test added beside it leaves it as it was` : `the existing test ${original.test} was changed; reusing it changes nothing`,
+    lines: dropped.length ? dropped : meaningful(now).filter((l) => !meaningful(original.lines).includes(l)),
+  }
+}
+
+/** The task for Scribe's next attempt: put the original test back as the mode requires. */
+export function breachPrompt(original: Original, b: Breach, mode: TestTarget["mode"]): string {
+  return [
+    `ForgeQE checked the existing test and stopped before running it: ${b.why}.`,
+    ...(b.lines.length ? ["", mode === "extend" ? "These lines of it are missing or changed; put them back exactly as they were:" : "The test as it was had these lines:", "", "```", ...b.lines.slice(0, 20), "```"] : []),
+    "",
+    mode === "extend"
+      ? `Keep every step, value, and assertion of ${original.test} as it was, and add only the new steps and checks around them. When a value in the run differs from the test's, keep the test's value: the run's data was an example.`
+      : mode === "sibling"
+        ? `Leave ${original.test} as it was, and put the new flow in a new test method beside it in the same class.`
+        : `Leave ${original.test} as it was.`,
+    "Then give the structured result again.",
+  ].join("\n")
+}

package/src/code/review.ts

@@ -133,6 +133,8 @@ export function reviewPrompt(input: ReviewInput, repo?: string): string {
           "",
           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 === "sibling"
+              ? `The job was asked to add a test beside the existing test ${input.target.test} (${input.target.testFile}), in the same class, reusing its setup and the page-object methods for the steps they share. A change to ${input.target.test} itself, a new test file, or the shared steps written again instead of reused, 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.`,

package/src/code/runtime.ts

@@ -9,7 +9,8 @@ import { entraGateway } from "../entra.ts"
 import { missingKey, type LlmProfile } from "../llm.ts"
 import type { CodeEvent, FileAction, PlanItem, Usage } from "../types.ts"
 import { envRefs, withoutNames } from "../childEnv.ts"
-import { addUsage, recordUsage, type Role } from "../usage.ts"
+import { recordCall } from "../tokenomics/ledger.ts"
+import { addUsage, type Role } from "../usage.ts"
 import { linkSkills, type Skill, type SkillAgent } from "../skills/registry.ts"
 import { EXE, githubDigest, installTool, isMusl, toolPath, type Log } from "../tools.ts"
 import { RESULT_SCHEMA, testAgentPrompt, type AgentReport } from "./prompt.ts"
@@ -648,6 +649,14 @@ export async function openSession<R = AgentReport>(opts: {
   const said = new Set<string>()
   /** Tool calls already said to have started, by part id. */
   const startedCalls = new Set<string>()
+  /** Per model call (assistant message): when it started and the tools it asked for, for the usage ledger. */
+  const steps = new Map<string, { started: number; tools: string[]; answered?: number }>()
+  const finished = new Set<string>()
+  const stepOf = (messageID: string) => {
+    let st = steps.get(messageID)
+    if (!st) steps.set(messageID, (st = { started: Date.now(), tools: [] }))
+    return st
+  }
   let idle: (() => void) | null = null
   let sessionError = ""
   // The turn's result comes from events: in agent runtime 1.18 listing a session's messages fails once a prompt used `format`.
@@ -668,6 +677,13 @@ export async function openSession<R = AgentReport>(opts: {
         break
       case "message.part.updated": {
         const part = p.part
+        if (part?.type === "step-start" && part.messageID) stepOf(part.messageID).started = Date.now()
+        if (part?.type === "tool" && part.messageID && part.tool) {
+          const st = stepOf(part.messageID)
+          if (!st.tools.includes(part.tool)) st.tools.push(part.tool)
+          // The model's part of the step ends when it hands over to a tool; the tool's own time is not the model's.
+          st.answered ??= Date.now()
+        }
         // A call is said as soon as it starts, so a long one (an API query, a test run) is visible while it runs.
         if (part?.type === "tool" && part.state?.status === "running" && part.id && !startedCalls.has(part.id) && !QUIET_TOOLS.has(part.tool) && !opts.hideTool?.(part.tool)) {
           startedCalls.add(part.id)
@@ -705,7 +721,8 @@ export async function openSession<R = AgentReport>(opts: {
             turn.text.push(text)
             emit({ type: "code", kind: "say", text: clip(text, 400) })
           }
-        } else if (part?.type === "step-finish" && part.tokens) {
+        } else if (part?.type === "step-finish" && part.tokens && !(part.id && finished.has(part.id))) {
+          if (part.id) finished.add(part.id)
           const t = part.tokens
           const step: Usage = {
             input: (t.input || 0) + (t.cache?.read || 0) + (t.cache?.write || 0),
@@ -714,7 +731,22 @@ export async function openSession<R = AgentReport>(opts: {
             ...(t.cache?.write ? { cacheWrite: t.cache.write } : {}),
           }
           Object.assign(usage, addUsage(usage, step))
-          recordUsage(role, step, price)
+          const st = part.messageID ? steps.get(part.messageID) : undefined
+          if (part.messageID) steps.delete(part.messageID)
+          recordCall({
+            agent: role,
+            usage: step,
+            price,
+            provider: model.providerID,
+            model: model.modelID,
+            session: session.id,
+            ...(opts.title ? { task: opts.title } : {}),
+            ...(st ? { ms: (st.answered ?? Date.now()) - st.started, tools: st.tools } : {}),
+            ...(t.reasoning ? { reasoning: t.reasoning } : {}),
+            outcome: part.reason === "error" ? "error" : "ok",
+            // With code.model the runtime prices the call itself; the profile's price is unknown then.
+            ...(typeof part.cost === "number" && part.cost > 0 ? { knownCost: { amount: part.cost, currency: "USD" } } : {}),
+          })
           emit({ type: "code", kind: "usage", usage: { ...usage }, context: step.input })
         }
         break