@capagents/forgeqe 1.2.1 → 1.3.1

package/src/tokenomics/ledger.ts

@@ -0,0 +1,287 @@
+import { AsyncLocalStorage } from "node:async_hooks"
+import { randomUUID } from "node:crypto"
+import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs"
+import os from "node:os"
+import path from "node:path"
+
+import { forgeqeHome } from "../tools.ts"
+import type { Usage } from "../types.ts"
+import { costOf, recordUsage, type Price, type Role } from "../usage.ts"
+
+/**
+ * The usage ledger: one record per model call, by every agent, kept in ~/.forgeqe/usage/YYYY-MM.jsonl so the
+ * Tokenomics report can say where tokens went: by agent, job, task, purpose, model, user and machine, over time.
+ * A record holds counts, times and names only, never prompt or response text. FORGEQE_USAGE=off keeps nothing on
+ * disk (the meter in usage.ts still counts); FORGEQE_USAGE_DIR moves the files.
+ */
+
+export type Trigger = "tui" | "cli" | "mcp" | "ci" | "monitor" | "schedule"
+
+/** What a call was for, from the tools it asked for: no tools is the model thinking or answering. */
+export type Purpose = "reasoning" | "planning" | "search" | "file read" | "edit" | "shell" | "browser" | "integration" | "delegation" | "unattributed"
+
+/** What ForgeQE was doing when the call was made. Set with withUsageScope; inner scopes add to outer ones. */
+export type UsageScope = {
+  /** The kind of work: "browser test", "heal", "write tests", "pr review", "eval", … */
+  job?: string
+  /** The piece of it: a session title, a case, a heal attempt. */
+  task?: string
+  runId?: string
+  caseId?: string
+  attempt?: number
+}
+
+export type CallRecord = {
+  v: 1
+  id: string
+  /** When the call finished (ISO). */
+  ts: string
+  ms?: number
+  agent: Role
+  job: string
+  task?: string
+  purpose: Purpose
+  /** The tools this call asked for, by name, in order, without repeats. */
+  tools?: string[]
+  runId?: string
+  caseId?: string
+  attempt?: number
+  step?: number
+  /** The agent runtime's session, or the engine's run. */
+  session?: string
+  provider?: string
+  model: string
+  /** Every prompt token, cached ones included (as Usage). */
+  input: number
+  cached?: number
+  cacheWrite?: number
+  /** Completion tokens, reasoning included. */
+  output: number
+  reasoning?: number
+  amount?: number
+  currency?: string
+  /** No price was known for the model: amount is missing. */
+  unpriced?: boolean
+  /** Part of the price is derived, or cached input was priced at the full rate. */
+  estimate?: boolean
+  outcome: "ok" | "error" | "cancelled"
+  user: string
+  machine: string
+  trigger: Trigger
+  /** One ForgeQE process: tells apart calls from two shells running at once. */
+  proc: string
+}
+
+const scopes = new AsyncLocalStorage<UsageScope>()
+
+/** Run `fn` with `scope` added to the current one, for every model call made inside it (awaited work included). */
+export function withUsageScope<T>(scope: UsageScope, fn: () => T): T {
+  return scopes.run({ ...scopes.getStore(), ...scope }, fn)
+}
+
+export function currentUsageScope(): UsageScope {
+  return { ...scopes.getStore() }
+}
+
+let trigger: Trigger | null = null
+
+/** How this process was started; CI is told from the environment. Child processes (the MCP server) inherit it. */
+export function setUsageTrigger(t: Trigger): void {
+  trigger = t
+  process.env.FORGEQE_TRIGGER ||= t
+}
+
+function triggerNow(): Trigger {
+  const env = process.env.FORGEQE_TRIGGER as Trigger | undefined
+  if (env) return env
+  if (process.env.CI || process.env.TF_BUILD || process.env.GITHUB_ACTIONS || process.env.GITLAB_CI) return "ci"
+  return trigger || "cli"
+}
+
+function who(): { user: string; machine: string } {
+  let user = process.env.USER || process.env.USERNAME || ""
+  try {
+    user = os.userInfo().username || user
+  } catch {}
+  return { user: user || "unknown", machine: os.hostname() || "unknown" }
+}
+
+const PROC = randomUUID().slice(0, 8)
+
+const PURPOSES: [RegExp, Purpose][] = [
+  [/^(edit|write|patch|multiedit|apply_patch)$/i, "edit"],
+  [/(^|_)(browser_run|run_test|run_test_cases|page_memory)$/i, "browser"],
+  [/^bash$/i, "shell"],
+  [/^(grep|glob|codesearch|websearch|webfetch)$|(^|_)(find_test_cases|query_api|read_confluence|search|find|rag)/i, "search"],
+  [/^(read|list|ls)$/i, "file read"],
+  [/^task$/i, "delegation"],
+  [/^(todowrite|todoread)$/i, "planning"],
+]
+
+/** What a call was for, from its tools: the first matching kind in PURPOSES' order wins; other tools are integrations. */
+export function purposeOf(tools: string[] | undefined): Purpose {
+  const named = (tools || []).filter((t) => t && t !== "StructuredOutput")
+  if (!named.length) return "reasoning"
+  for (const [re, purpose] of PURPOSES) if (named.some((t) => re.test(t))) return purpose
+  return named.some((t) => t === "skill") ? "file read" : "integration"
+}
+
+/** What a call made without a scope was most likely part of, by the agent that made it. */
+const DEFAULT_JOB: Record<Role, string> = {
+  "ForgeQE's agent": "chat",
+  "browser agent": "browser test",
+  Scribe: "write tests",
+  reviewer: "review",
+  judge: "eval",
+  refiner: "refine",
+  "root-cause analyst": "defect rca",
+}
+
+export function usageDir(): string {
+  return process.env.FORGEQE_USAGE_DIR || path.join(forgeqeHome(), "usage")
+}
+
+const keeping = () => !/^(0|off|false|no)$/i.test(process.env.FORGEQE_USAGE || "")
+
+const monthFile = (d: Date) => path.join(usageDir(), `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}.jsonl`)
+
+/** This process's calls, oldest first (at most MAX_KEPT). */
+const calls: CallRecord[] = []
+const MAX_KEPT = 50_000
+const listeners = new Set<(c: CallRecord) => void>()
+
+/** Called with every call recorded in this process; returns the unsubscribe. */
+export function onCall(listener: (c: CallRecord) => void): () => void {
+  listeners.add(listener)
+  return () => listeners.delete(listener)
+}
+
+export type CallInput = {
+  agent: Role
+  usage: Usage
+  price: Price | undefined
+  model: string
+  provider?: string
+  ms?: number
+  tools?: string[]
+  purpose?: Purpose
+  reasoning?: number
+  session?: string
+  step?: number
+  /** The task when the scope names none (the agent runtime's session title). */
+  task?: string
+  outcome?: CallRecord["outcome"]
+  /** A cost the caller already knows (the agent runtime's own), used when `price` is unknown. */
+  knownCost?: { amount: number; currency: string }
+}
+
+/**
+ * Record one model call: counted in the meter by its agent, kept in this process's list, and appended to the
+ * month's ledger file. Never throws: a ledger that cannot be written loses the record, never the run.
+ */
+export function recordCall(c: CallInput): CallRecord | null {
+  if (!c.usage.input && !c.usage.output) return null
+  recordUsage(c.agent, c.usage, c.price)
+  const scope = scopes.getStore() || {}
+  const cost = costOf(c.usage, c.price)
+  const fallback = !cost && c.knownCost && c.knownCost.amount > 0 ? c.knownCost : undefined
+  const now = new Date()
+  const tools = c.tools?.length ? [...new Set(c.tools)] : undefined
+  const rec: CallRecord = {
+    v: 1,
+    id: randomUUID(),
+    ts: now.toISOString(),
+    ...(c.ms !== undefined ? { ms: Math.max(0, Math.round(c.ms)) } : {}),
+    agent: c.agent,
+    job: scope.job || DEFAULT_JOB[c.agent] || "other",
+    ...(scope.task || c.task ? { task: scope.task || c.task } : {}),
+    purpose: c.purpose || purposeOf(tools),
+    ...(tools ? { tools } : {}),
+    ...(scope.runId ? { runId: scope.runId } : {}),
+    ...(scope.caseId ? { caseId: scope.caseId } : {}),
+    ...(scope.attempt ? { attempt: scope.attempt } : {}),
+    ...(c.step !== undefined ? { step: c.step } : {}),
+    ...(c.session ? { session: c.session } : {}),
+    ...(c.provider ? { provider: c.provider } : {}),
+    model: c.model || "unknown",
+    input: c.usage.input,
+    ...(c.usage.cached ? { cached: c.usage.cached } : {}),
+    ...(c.usage.cacheWrite ? { cacheWrite: c.usage.cacheWrite } : {}),
+    output: c.usage.output,
+    ...(c.reasoning ? { reasoning: c.reasoning } : {}),
+    ...(cost ? { amount: cost.amount, currency: cost.currency } : fallback ? { amount: fallback.amount, currency: fallback.currency, estimate: true } : { unpriced: true }),
+    ...(cost && (cost.estimate || cost.cachedAtFullRate) ? { estimate: true } : {}),
+    outcome: c.outcome || "ok",
+    ...who(),
+    trigger: triggerNow(),
+    proc: PROC,
+  }
+  calls.push(rec)
+  if (calls.length > MAX_KEPT) calls.splice(0, calls.length - MAX_KEPT)
+  if (keeping()) {
+    try {
+      mkdirSync(usageDir(), { recursive: true })
+      appendFileSync(monthFile(now), JSON.stringify(rec) + "\n")
+    } catch {}
+  }
+  for (const l of listeners) {
+    try {
+      l(rec)
+    } catch {}
+  }
+  return rec
+}
+
+/** This process's calls, filtered. */
+export function sessionCalls(filter?: (c: CallRecord) => boolean): CallRecord[] {
+  return filter ? calls.filter(filter) : [...calls]
+}
+
+/** The calls of one run (a browser run's folder name), in this process. */
+export function runCalls(runId: string): CallRecord[] {
+  return calls.filter((c) => c.runId === runId)
+}
+
+/** usage.json in a run's folder: that run's calls, for its report. Returns the file, or null when it made none. */
+export function writeRunUsage(dir: string): string | null {
+  const mine = runCalls(path.basename(dir))
+  if (!mine.length) return null
+  const file = path.join(dir, "usage.json")
+  writeFileSync(file, JSON.stringify({ v: 1, calls: mine }, null, 2))
+  return file
+}
+
+/** Every call in the ledger files from `since` (inclusive) to `until` (exclusive), oldest first. Bad lines are skipped. */
+export function readLedger(opts: { since?: Date; until?: Date; dir?: string } = {}): CallRecord[] {
+  const dir = opts.dir || usageDir()
+  if (!existsSync(dir)) return []
+  const since = opts.since?.getTime() ?? -Infinity
+  const until = opts.until?.getTime() ?? Infinity
+  const first = opts.since ? `${opts.since.getFullYear()}-${String(opts.since.getMonth() + 1).padStart(2, "0")}` : ""
+  const out: CallRecord[] = []
+  for (const f of readdirSync(dir).filter((f) => /^\d{4}-\d{2}\.jsonl$/.test(f)).sort()) {
+    if (first && f.slice(0, 7) < first) continue
+    let text = ""
+    try {
+      text = readFileSync(path.join(dir, f), "utf8")
+    } catch {
+      continue
+    }
+    for (const line of text.split("\n")) {
+      if (!line.trim()) continue
+      try {
+        const c = JSON.parse(line) as CallRecord
+        const t = Date.parse(c.ts)
+        if (c.v === 1 && t >= since && t < until) out.push(c)
+      } catch {}
+    }
+  }
+  return out.sort((a, b) => a.ts.localeCompare(b.ts))
+}
+
+/** Tests: forget this process's calls and listeners. */
+export function resetLedger(): void {
+  calls.length = 0
+  listeners.clear()
+  trigger = null
+}

package/src/tui/App.tsx

@@ -17,7 +17,10 @@ import { HELP, parseCommand } from "../commands.ts"
 import { loadConfig, selectProfile, type AppConfig, type BrowserProvider } from "../config.ts"
 import { TOOLS, type AskQuestion, type ToolEvent } from "../mcp/tools.ts"
 import type { executeRun } from "../run.ts"
-import { bundleLogs } from "../sessionLog.ts"
+import { bundleLogs, logEvent } from "../sessionLog.ts"
+import { openRegistry, registryMode, type Plan, type Registry } from "../registry/index.ts"
+import { resolveRequest, resolveTarget } from "../registry/resolve.ts"
+import { runChecks, tier0Reply, type RunSummary } from "../registry/tier0.ts"
 import { findSkill, loadSkills } from "../skills/registry.ts"
 import { skillDetail, skillsOverview } from "../skills/view.ts"
 import { counts } from "../suite/report.ts"
@@ -45,6 +48,8 @@ import { CONTEXT_LIMIT } from "../code/runtime.ts"
 import { readKnowledge } from "../knowledge.ts"
 import { externalMcp } from "../mcp/external.ts"
 import { meterSince } from "../usage.ts"
+import { setUsageTrigger } from "../tokenomics/ledger.ts"
+import { watchBudgets } from "../tokenomics/budget.ts"
 import {
   ACTIVITY_FILTERS,
   ActivityPanel,
@@ -1162,6 +1167,81 @@ export function App({ options }: { options: TuiOptions }) {
     }
   }
 
+  /**
+   * Tier 0 (docs/COST_ARCHITECTURE.md): a passed run, run again as recorded through the same browser_run the agent
+   * calls (an existing test first, then page memory), with no agent; the reply is written from the result.
+   */
+  const runKnown = async (plan: Plan, cfg: AppConfig, reg: Registry, request: string) => {
+    const controller = begin("Running it again as recorded…", request)
+    testsRef.current = { on: sessionSetup(cfg, options.repo).writeTests, why: "the session was started with --no-code" }
+    const t0 = Date.now()
+    let finalStatus = "fail"
+    let out: RunSummary = {}
+    try {
+      const task = Boolean(plan.lastRunDir && existsSync(path.join(plan.lastRunDir, "task.json")))
+      const args = { goal: plan.goal, purpose: task ? "task" : "test", ...(plan.startUrl ? { start_url: plan.startUrl } : {}) }
+      const raw = (await TOOLS[0].run(args, { ...toolContext(false, controller.signal), config: cfg, cwd: process.cwd() })) as RunSummary & { passed?: RunSummary }
+      out = raw.passed || raw
+      out = { ...out, ...runChecks(out.run_dir) }
+      finalStatus = out.status === "passed" ? "done" : out.status === "stopped" ? "stopped" : "fail"
+      const reply = tier0Reply(plan, out)
+      pushLine({ kind: "reply", text: reply.text, outcome: reply.outcome })
+    } catch (err) {
+      finalStatus = controller.signal.aborted ? "stopped" : "fail"
+      if (!controller.signal.aborted) push("err", `Running it again failed: ${(err as Error).message}`)
+    } finally {
+      try {
+        reg.log({ request, mode: "on", decision: "tier0", planId: plan.id, tier: 0, outcome: out.status || finalStatus, tokensIn: out.tokens || 0, ms: Date.now() - t0, ...(out.run_dir ? { runDir: out.run_dir } : {}) })
+      } catch {}
+      reg.close()
+      pushProduced()
+      finish(finalStatus)
+    }
+  }
+
+  /**
+   * The registry's decision on a request (docs/COST_ARCHITECTURE.md). off: nothing, today's path. shadow: recorded
+   * only, today's path. on: a Tier 0 match runs here and true is returned; anything else goes to the agent as before.
+   * Any registry error also means today's path.
+   */
+  const routeKnown = (text: string, cfg: AppConfig): boolean => {
+    const mode = registryMode(cfg)
+    if (mode === "off") return false
+    const reg = openRegistry(cfg)
+    if (!reg) return false
+    try {
+      const d = resolveRequest(reg, text)
+      const decision = d.tier === 0 ? "tier0" : d.why
+      logEvent("registry.decision", { mode, decision, plan: d.plan?.id })
+      if (mode === "on" && d.tier === 0) {
+        void runKnown(d.plan, cfg, reg, text)
+        return true
+      }
+      reg.log({ request: text, mode: mode === "on" ? "on" : "shadow", decision, ...(d.plan ? { planId: d.plan.id } : {}), ...(d.tier === 0 ? { tier: 0 } : {}) })
+    } catch {}
+    reg.close()
+    return false
+  }
+
+  /** /rerun: an explicit request to run a passed run again as recorded, whatever registry.mode says. */
+  const rerunCommand = (target: string) => {
+    const cfg = configRef.current
+    if (!cfg) return push("err", "Config failed to load.")
+    if (abortRef.current) return push("err", "ForgeQE is busy. Press esc to stop it.")
+    const reg = openRegistry(cfg)
+    if (!reg) return push("err", "The run registry could not be opened, so /rerun cannot look the run up. Ask ForgeQE to run it again instead.")
+    let d: ReturnType<typeof resolveTarget>
+    try {
+      d = resolveTarget(reg, target, true)
+    } catch (err) {
+      reg.close()
+      return push("err", `The run registry could not be read: ${(err as Error).message}. Ask ForgeQE to run it again instead.`)
+    }
+    if (d.tier === 0) return void runKnown(d.plan, cfg, reg, `/rerun ${target}`)
+    reg.close()
+    push("err", d.plan ? `Not run again as recorded: ${d.why} (${d.plan.goal}). Ask ForgeQE to look into it, or to run it again.` : `Nothing to run again: ${d.why} for "${target}". /rerun takes last, a run folder, or a goal word for word.`)
+  }
+
   const askAgent = async (text: string, cfg: AppConfig) => {
     const controller = begin("Thinking…", text)
     const meterStart = meterSnapshot()
@@ -1232,7 +1312,7 @@ export function App({ options }: { options: TuiOptions }) {
     }
     const why = options.brain ? null : brainUnavailable(cfg)
     if (why) void runDirect(text, cfg, why)
-    else void askAgent(text, cfg)
+    else if (!routeKnown(text, cfg)) void askAgent(text, cfg)
   }
 
   /** Reads forgeqe.yaml and llms.json again (after /init wrote them), keeping the session going. */
@@ -1255,6 +1335,9 @@ export function App({ options }: { options: TuiOptions }) {
       let cfg = loadConfig({ configPath: options.configPath, profile: options.profile })
       if (options.profile) cfg = selectProfile(cfg, options.profile)
       configRef.current = cfg
+      // Budgets only warn: each threshold once, in the conversation, while work goes on.
+      setUsageTrigger("tui")
+      if (cfg.budget) watchBudgets(cfg.budget, (w) => push("sys", w.text, "chat"))
       // A price in llms.json that differs from the model's list price (probably a typo or an old price), said with the
       // first message so the home screen stays as it is.
       const reviewer = cfg.code.reviewProfile ? cfg.profiles[cfg.code.reviewProfile] : undefined
@@ -1410,6 +1493,10 @@ export function App({ options }: { options: TuiOptions }) {
       void runAuth(cmd.action, cmd.system).catch((err) => push("err", (err as Error).message))
       return
     }
+    if (cmd.type === "rerun") {
+      rerunCommand(cmd.target)
+      return
+    }
     if (cmd.type === "unknown") {
       push("err", "Usage: /headed on|off, /details on|off, /profile <name>, /auth [system], /auth logout <system>. /help lists the commands.")
       return

package/src/tui/inspector.tsx

@@ -101,15 +101,7 @@ export function StatusBar(props: {
   const done = props.status === "done"
   const failed = props.status === "fail"
   const color = props.running ? theme.warn : done ? theme.ok : failed ? theme.err : theme.muted
-  const state = props.running
-    ? props.who
-    : done
-      ? "Last request done"
-      : failed
-        ? "Last request failed"
-        : props.status === "stopped"
-          ? "Last request stopped"
-          : "Ready for your next request"
+  const state = props.running ? props.who : done ? "Last request done" : failed ? "Last request failed" : props.status === "stopped" ? "Last request stopped" : "Ready for your next request"
   const bar = props.running && props.progress && props.progress.total > 1 ? props.progress : null
   const cells = 12
   const barText = bar ? ` ${bar.done}/${bar.total}  ` : ""
@@ -183,7 +175,13 @@ export function planLines(s: Inspector): PlanLine[] {
   if (s.progress.items.length && s.plan.length) lines.push({ mark: "─", color: theme.border, text: s.progress.title, textColor: theme.faint })
   for (const i of s.progress.items) {
     const [mark, color] = PROGRESS_MARK[i.status]
-    lines.push({ mark, color, text: i.detail ? `${i.label} — ${i.detail}` : i.label, textColor: i.status === "fail" ? theme.err : i.status === "running" ? theme.text : theme.muted, ...(i.status === "running" ? { live: true } : {}) })
+    lines.push({
+      mark,
+      color,
+      text: i.detail ? `${i.label} — ${i.detail}` : i.label,
+      textColor: i.status === "fail" ? theme.err : i.status === "running" ? theme.text : theme.muted,
+      ...(i.status === "running" ? { live: true } : {}),
+    })
   }
   return lines
 }
@@ -352,17 +350,13 @@ export function nowNext(s: Inspector): { now?: string; next?: string; done: numb
   const at = s.plan.findIndex((p) => p.status === "in_progress")
   const step = [...s.progress.items].reverse().find((i) => i.status === "running")
   const pending = s.plan.find((p, i) => p.status === "pending" && i > at)
-  return {
-    now: at >= 0 ? s.plan[at]!.text : step?.label,
-    next: pending?.text,
-    done: s.plan.filter((p) => p.status === "completed").length,
-    total: s.plan.length,
-  }
+  return { now: at >= 0 ? s.plan[at]!.text : step?.label, next: pending?.text, done: s.plan.filter((p) => p.status === "completed").length, total: s.plan.length }
 }
 
-/** Rows the Now/Next header takes: one for each it has. */
+/** Rows the Now/Next header takes: one for each it has, and a blank row under it before the lines. */
 export function nowNextRows(n: ReturnType<typeof nowNext>): number {
-  return (n.now ? 1 : 0) + (n.next ? 1 : 0)
+  const rows = (n.now ? 1 : 0) + (n.next ? 1 : 0)
+  return rows ? rows + 1 : 0
 }
 
 /** Everything the agents do, newest at the bottom; focused, it scrolls and narrows to errors, steps, or tools. */
@@ -402,22 +396,27 @@ export function ActivityPanel(props: {
           })}
         </box>
       ) : null}
-      {props.now?.now ? (
-        <box style={{ flexDirection: "row", height: 1, flexShrink: 0 }}>
-          <text fg={theme.muted}>{"Now   "}</text>
-          <box style={{ width: 2, flexShrink: 0 }}>
-            <Spinner kind="dots" color={theme.warn} />
-          </box>
-          <text fg={theme.text}>{clip(props.now.now, room)}</text>
+      {props.now?.now || props.now?.next ? (
+        // A blank row under Now/Next keeps the header apart from the lines scrolling beneath it.
+        <box style={{ flexDirection: "column", flexShrink: 0, marginBottom: 1 }}>
+          {props.now?.now ? (
+            <box style={{ flexDirection: "row", height: 1, flexShrink: 0 }}>
+              <text fg={theme.muted}>{"Now   "}</text>
+              <box style={{ width: 2, flexShrink: 0 }}>
+                <Spinner kind="dots" color={theme.warn} />
+              </box>
+              <text fg={theme.text}>{clip(props.now.now, room)}</text>
+            </box>
+          ) : null}
+          {props.now?.next ? (
+            <text style={{ height: 1, flexShrink: 0 }}>
+              <span fg={theme.muted}>{"Next  "}</span>
+              <span fg={theme.faint}>{"○ "}</span>
+              <span fg={theme.muted}>{clip(props.now.next, room)}</span>
+            </text>
+          ) : null}
         </box>
       ) : null}
-      {props.now?.next ? (
-        <text style={{ height: 1, flexShrink: 0 }}>
-          <span fg={theme.muted}>{"Next  "}</span>
-          <span fg={theme.faint}>{"○ "}</span>
-          <span fg={theme.muted}>{clip(props.now.next, room)}</span>
-        </text>
-      ) : null}
       {real(shown) ? (
         <scrollbox ref={props.scrollRef} stickyScroll stickyStart="bottom" style={{ flexGrow: 1 }} focused={false}>
           {shown.map((line, i) => (
@@ -550,9 +549,15 @@ export function InfoStrip(props: { s: Inspector; c: ContextInfo; total: Usage; w
     <box style={{ flexDirection: "row", height: 1, flexShrink: 0, width: props.width, paddingLeft: 1 }}>
       <text>
         {parts.flatMap(([label, value, color], i) => [
-          <span key={`s${i}`} fg={theme.faint}>{i ? "  ·  " : ""}</span>,
-          <span key={`l${i}`} fg={theme.muted}>{label}</span>,
-          <span key={`v${i}`} fg={color}>{value}</span>,
+          <span key={`s${i}`} fg={theme.faint}>
+            {i ? "  ·  " : ""}
+          </span>,
+          <span key={`l${i}`} fg={theme.muted}>
+            {label}
+          </span>,
+          <span key={`v${i}`} fg={color}>
+            {value}
+          </span>,
         ])}
       </text>
     </box>

package/src/types.ts

@@ -29,6 +29,11 @@ export type MemoryInfo = {
   elements: number
   newElements: number
   flow: "saved" | "updated" | null
+  /** Recorded checks found on the page again during the replay, and how many of them held (registry.mode on). */
+  checked?: number
+  checksHeld?: number
+  /** Read-only steps the replay left out. */
+  skippedReads?: number
   /** After a failed run: the steps that worked before it went wrong, saved in resume.json for a retry to replay. */
   resume?: { steps: number; failedAt: number; reason: string; lines: string[]; file?: string }
 }
@@ -118,8 +123,10 @@ 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"
+  /** The job worked from an existing test: ran it as it was, extended it, updated it, or added a test beside it. */
+  existing?: "reused" | "extended" | "updated" | "added_beside"
+  /** Times Scribe changed the existing test it was asked to keep, and was sent back before the test ran. */
+  breaches?: number
 }
 
 /** What an agent did to a file, for the shell's file list. */