@capagents/forgeqe 1.2.0 → 1.3.0

package/src/registry/db.ts

@@ -0,0 +1,249 @@
+import { Database } from "bun:sqlite"
+import { createHash } from "node:crypto"
+import { existsSync, mkdirSync, writeFileSync } from "node:fs"
+import path from "node:path"
+
+/**
+ * The registry: one SQLite file per project that indexes what ForgeQE already knows (runs, and the plans that
+ * repeat them) and logs what each request cost. It is a cache over the run folders and page memory, never the
+ * source of truth: any error opening or reading it means "no registry", and the request takes today's path.
+ * See docs/COST_ARCHITECTURE.md.
+ */
+
+const SCHEMA_VERSION = 1
+
+const SCHEMA = `
+CREATE TABLE IF NOT EXISTS entities (
+  id TEXT PRIMARY KEY, kind TEXT NOT NULL, source TEXT NOT NULL, external_id TEXT, title TEXT,
+  path TEXT, fingerprint TEXT, version TEXT, updated_at TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS entities_kind ON entities(kind);
+CREATE TABLE IF NOT EXISTS aliases (
+  alias TEXT NOT NULL, entity_id TEXT NOT NULL, weight REAL NOT NULL DEFAULT 1, PRIMARY KEY (alias, entity_id)
+);
+CREATE TABLE IF NOT EXISTS plans (
+  id TEXT PRIMARY KEY, entity_id TEXT NOT NULL, intent TEXT NOT NULL, tool TEXT NOT NULL, goal TEXT NOT NULL,
+  start_url TEXT, input_fingerprint TEXT NOT NULL, successes INTEGER NOT NULL DEFAULT 0,
+  failures INTEGER NOT NULL DEFAULT 0, last_outcome TEXT, last_run_dir TEXT, last_success TEXT,
+  first_tokens INTEGER, stale INTEGER NOT NULL DEFAULT 0, last_at TEXT NOT NULL
+);
+CREATE TABLE IF NOT EXISTS runs (
+  id TEXT PRIMARY KEY, request TEXT, mode TEXT NOT NULL, decision TEXT NOT NULL, plan_id TEXT, tier INTEGER,
+  outcome TEXT, tokens_in INTEGER, tokens_out INTEGER, tokens_cached INTEGER, ms INTEGER, run_dir TEXT,
+  started_at TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS runs_started ON runs(started_at);
+`
+
+export type Plan = {
+  id: string
+  entityId: string
+  goal: string
+  startUrl?: string
+  successes: number
+  failures: number
+  lastOutcome?: string
+  lastRunDir?: string
+  lastSuccess?: string
+  /** Input tokens of the run that recorded it: what a rerun is measured against. */
+  firstTokens?: number
+  stale: boolean
+}
+
+/** One request in the cost ledger. `mode` shadow: the decision was only recorded; the request took today's path. */
+export type LedgerRow = {
+  request: string
+  mode: "shadow" | "on"
+  /** "tier0", or why the registry left the request to the agent ("no match", "not passed yet"). */
+  decision: string
+  planId?: string
+  tier?: number
+  outcome?: string
+  tokensIn?: number
+  tokensOut?: number
+  tokensCached?: number
+  ms?: number
+  runDir?: string
+}
+
+/** The text a goal is known by: the same normalisation page memory uses for its goal key (memory.py). */
+export function normGoal(goal: string): string {
+  return goal.trim().toLowerCase().replace(/\s+/g, " ").replace(/[ .!]+$/, "")
+}
+
+export function normUrl(url?: string): string {
+  return (url || "").trim().replace(/\/+$/, "")
+}
+
+/** A plan's identity: what it does and where it starts. Rewording changes it; a new run of the same goal does not. */
+export function planId(goal: string, startUrl?: string): string {
+  return `plan:${createHash("sha256").update(`${normGoal(goal)}|${normUrl(startUrl)}`).digest("hex").slice(0, 16)}`
+}
+
+/** registry.db lives in its own folder beside page memory (.forgeqe/registry), git-ignored by its own .gitignore. */
+export function registryPath(memoryDir: string): string {
+  return path.join(path.dirname(memoryDir), "registry", "registry.db")
+}
+
+export class Registry {
+  private constructor(readonly db: Database) {}
+
+  /** Opens (and creates) the registry; null when it cannot, so callers fall back to today's path. */
+  static open(file: string): Registry | null {
+    try {
+      const dir = path.dirname(file)
+      mkdirSync(dir, { recursive: true })
+      const ignore = path.join(dir, ".gitignore")
+      if (!existsSync(ignore)) writeFileSync(ignore, "*\n")
+      const db = new Database(file, { create: true })
+      // Several ForgeQE processes (the shell, MCP, a monitor) may open it at once.
+      db.exec("PRAGMA busy_timeout = 3000; PRAGMA journal_mode = WAL;")
+      const version = (db.query("PRAGMA user_version").get() as { user_version: number }).user_version
+      if (version > SCHEMA_VERSION) {
+        db.close()
+        return null
+      }
+      db.exec(SCHEMA)
+      if (version < SCHEMA_VERSION) db.exec(`PRAGMA user_version = ${SCHEMA_VERSION}`)
+      return new Registry(db)
+    } catch {
+      return null
+    }
+  }
+
+  close(): void {
+    try {
+      this.db.close()
+    } catch {}
+  }
+
+  hasEntity(id: string): boolean {
+    return Boolean(this.db.query("SELECT 1 FROM entities WHERE id = ?").get(id))
+  }
+
+  upsertEntity(e: { id: string; kind: string; source: string; title?: string; path?: string; fingerprint?: string; externalId?: string }): void {
+    this.db
+      .query(
+        `INSERT INTO entities (id, kind, source, external_id, title, path, fingerprint, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(id) DO UPDATE SET title = excluded.title, path = excluded.path, fingerprint = excluded.fingerprint, updated_at = excluded.updated_at`,
+      )
+      .run(e.id, e.kind, e.source, e.externalId ?? null, e.title ?? null, e.path ?? null, e.fingerprint ?? null, new Date().toISOString())
+  }
+
+  addAlias(alias: string, entityId: string, weight = 1): void {
+    const a = alias.trim().toLowerCase()
+    if (a) this.db.query("INSERT OR IGNORE INTO aliases (alias, entity_id, weight) VALUES (?, ?, ?)").run(a, entityId, weight)
+  }
+
+  /** Counts one run of a plan, creating the plan on its first run. `at`: when the run happened; the latest run sets the outcome. */
+  recordPlanRun(p: { goal: string; startUrl?: string; passed: boolean; runDir: string; at: string; tokens?: number }): string {
+    const id = planId(p.goal, p.startUrl)
+    const outcome = p.passed ? "passed" : "failed"
+    this.db
+      .query(
+        `INSERT INTO plans (id, entity_id, intent, tool, goal, start_url, input_fingerprint, successes, failures, last_outcome, last_run_dir, last_success, first_tokens, last_at)
+         VALUES ($id, $id, 'browser_goal', 'browser_run', $goal, $url, $id, $ok, $bad, $outcome, $dir, $success, $tokens, $at)
+         ON CONFLICT(id) DO UPDATE SET
+           successes = successes + $ok,
+           failures = failures + $bad,
+           last_outcome = CASE WHEN $at >= last_at THEN $outcome ELSE last_outcome END,
+           last_run_dir = CASE WHEN $at >= last_at THEN $dir ELSE last_run_dir END,
+           last_success = CASE WHEN $ok = 1 AND $at > COALESCE(last_success, '') THEN $at ELSE last_success END,
+           first_tokens = COALESCE(first_tokens, $tokens),
+           last_at = MAX(last_at, $at)`,
+      )
+      .run({ $id: id, $goal: p.goal, $url: p.startUrl ?? null, $ok: p.passed ? 1 : 0, $bad: p.passed ? 0 : 1, $outcome: outcome, $dir: p.runDir, $success: p.passed ? p.at : null, $tokens: p.tokens ?? null, $at: p.at })
+    return id
+  }
+
+  plan(id: string): Plan | null {
+    const r = this.db.query("SELECT * FROM plans WHERE id = ?").get(id) as Record<string, unknown> | null
+    return r ? toPlan(r) : null
+  }
+
+  /** Plans whose goal or run folder is known by `alias`, most recently run first. */
+  plansByAlias(alias: string): Plan[] {
+    const rows = this.db
+      .query(
+        `SELECT p.* FROM aliases a JOIN plans p ON p.id = a.entity_id WHERE a.alias = ?
+         UNION SELECT p.* FROM aliases a JOIN entities e ON e.id = a.entity_id JOIN plans p ON p.last_run_dir = e.path WHERE a.alias = ? AND e.kind = 'run'
+         ORDER BY last_at DESC`,
+      )
+      .all(alias.trim().toLowerCase(), alias.trim().toLowerCase()) as Record<string, unknown>[]
+    return rows.map(toPlan)
+  }
+
+  /** The plan of the most recent run, whatever its outcome. */
+  latestPlan(): Plan | null {
+    const r = this.db.query("SELECT * FROM plans ORDER BY last_at DESC LIMIT 1").get() as Record<string, unknown> | null
+    return r ? toPlan(r) : null
+  }
+
+  /** The plan a run folder (or its name) recorded. */
+  planOfRun(run: string): Plan | null {
+    const r = this.db.query("SELECT p.* FROM entities e JOIN plans p ON p.id = e.fingerprint WHERE e.kind = 'run' AND (e.id = ? OR e.path = ?)").get(`run:${path.basename(run)}`, path.resolve(run)) as Record<
+      string,
+      unknown
+    > | null
+    return r ? toPlan(r) : null
+  }
+
+  log(row: LedgerRow): string {
+    const id = `req:${Date.now().toString(36)}${Math.random().toString(36).slice(2, 8)}`
+    this.db
+      .query(
+        `INSERT INTO runs (id, request, mode, decision, plan_id, tier, outcome, tokens_in, tokens_out, tokens_cached, ms, run_dir, started_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      )
+      .run(
+        id,
+        row.request,
+        row.mode,
+        row.decision,
+        row.planId ?? null,
+        row.tier ?? null,
+        row.outcome ?? null,
+        row.tokensIn ?? null,
+        row.tokensOut ?? null,
+        row.tokensCached ?? null,
+        row.ms ?? null,
+        row.runDir ?? null,
+        new Date().toISOString(),
+      )
+    return id
+  }
+
+  ledger(limit = 50): (LedgerRow & { id: string; startedAt: string })[] {
+    const rows = this.db.query("SELECT * FROM runs ORDER BY started_at DESC LIMIT ?").all(limit) as Record<string, unknown>[]
+    return rows.map((r) => ({
+      id: String(r.id),
+      startedAt: String(r.started_at),
+      request: String(r.request ?? ""),
+      mode: r.mode as LedgerRow["mode"],
+      decision: String(r.decision),
+      ...(r.plan_id ? { planId: String(r.plan_id) } : {}),
+      ...(r.tier != null ? { tier: Number(r.tier) } : {}),
+      ...(r.outcome ? { outcome: String(r.outcome) } : {}),
+      ...(r.tokens_in != null ? { tokensIn: Number(r.tokens_in) } : {}),
+      ...(r.tokens_out != null ? { tokensOut: Number(r.tokens_out) } : {}),
+      ...(r.ms != null ? { ms: Number(r.ms) } : {}),
+      ...(r.run_dir ? { runDir: String(r.run_dir) } : {}),
+    }))
+  }
+}
+
+function toPlan(r: Record<string, unknown>): Plan {
+  return {
+    id: String(r.id),
+    entityId: String(r.entity_id),
+    goal: String(r.goal),
+    ...(r.start_url ? { startUrl: String(r.start_url) } : {}),
+    successes: Number(r.successes || 0),
+    failures: Number(r.failures || 0),
+    ...(r.last_outcome ? { lastOutcome: String(r.last_outcome) } : {}),
+    ...(r.last_run_dir ? { lastRunDir: String(r.last_run_dir) } : {}),
+    ...(r.last_success ? { lastSuccess: String(r.last_success) } : {}),
+    ...(r.first_tokens != null ? { firstTokens: Number(r.first_tokens) } : {}),
+    stale: Boolean(r.stale),
+  }
+}

package/src/registry/index.ts

@@ -0,0 +1,72 @@
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs"
+import path from "node:path"
+
+import type { AppConfig } from "../config.ts"
+import { normGoal, Registry, registryPath } from "./db.ts"
+
+export { normGoal, planId, Registry, registryPath, type LedgerRow, type Plan } from "./db.ts"
+
+/** registry.mode in forgeqe.yaml: on by default; off leaves every request to the agent; shadow only records. */
+export type RegistryMode = "off" | "shadow" | "on"
+
+export function registryMode(cfg: Pick<AppConfig, "registry">): RegistryMode {
+  return cfg.registry?.mode || "on"
+}
+
+/** The project's registry with its run folders indexed, or null when it cannot be opened (today's path then). */
+export function openRegistry(cfg: AppConfig): Registry | null {
+  const reg = Registry.open(registryPath(cfg.memory.dir))
+  if (!reg) return null
+  try {
+    indexRuns(reg, cfg.export.outDir)
+  } catch {}
+  return reg
+}
+
+type RunJson = { goal?: string; start_url?: string; outcome?: string; status?: string; success?: boolean; usage?: { input?: number } }
+
+/** A run passed when its record says so: the engine's outcome, or ForgeQE's own status. */
+export function runPassed(run: RunJson): boolean {
+  if (run.outcome) return run.outcome === "passed"
+  if (run.status) return run.status === "passed" || run.status === "complete"
+  return run.success === true
+}
+
+/**
+ * Adds the run folders the registry has not seen: each run, and the plan that repeats it (its goal and start URL).
+ * Reads run.json only; never writes to a run folder. Folders already indexed are skipped, so this is cheap to repeat.
+ */
+export function indexRuns(reg: Registry, outDir: string): number {
+  if (!existsSync(outDir)) return 0
+  let added = 0
+  const names = readdirSync(outDir).sort()
+  reg.db.exec("BEGIN")
+  try {
+    for (const name of names) {
+      const dir = path.join(outDir, name)
+      const file = path.join(dir, "run.json")
+      const id = `run:${name}`
+      if (reg.hasEntity(id) || !existsSync(file)) continue
+      let run: RunJson
+      try {
+        run = JSON.parse(readFileSync(file, "utf8")) as RunJson
+      } catch {
+        continue
+      }
+      const goal = String(run.goal || "").trim()
+      if (!goal) continue
+      const at = statSync(file).mtime.toISOString()
+      const plan = reg.recordPlanRun({ goal, startUrl: run.start_url || undefined, passed: runPassed(run), runDir: dir, at, tokens: run.usage?.input })
+      reg.upsertEntity({ id, kind: "run", source: "reports", title: goal, path: dir, fingerprint: plan })
+      reg.addAlias(name, id)
+      reg.addAlias(normGoal(goal), plan)
+      added++
+    }
+    reg.db.exec("COMMIT")
+  } catch (err) {
+    reg.db.exec("ROLLBACK")
+    throw err
+  }
+  return added
+}
+

package/src/registry/resolve.ts

@@ -0,0 +1,57 @@
+import { normGoal, normUrl, type Plan, type Registry } from "./db.ts"
+
+/**
+ * The resolver: which requests the registry can answer without ForgeQE's agent, using no model at all. It is
+ * deliberately narrow. It claims a request only when it names something already run (the rerun link, /rerun, "run
+ * it again", a run folder, or a goal word for word) and that run passed. Anything it is unsure of goes to the agent.
+ */
+
+export type Decision =
+  /** Tier 0: run the plan as recorded, through browser_run, with no agent. */
+  | { tier: 0; plan: Plan; why: string }
+  /** Left to the agent; `plan` when one matched but cannot run at Tier 0. */
+  | { tier: null; why: string; plan?: Plan }
+
+/** The text of the rerun link on the start screen. */
+const LINK = /^run this goal again:\s*([\s\S]+)$/i
+/** "run it again", "rerun the last test", "repeat 20261014-162859 once more". */
+const AGAIN = /^(?:please\s+)?(?:re-?run|run|repeat)\s+([\s\S]+?)\s+(?:again|once more)[.!]?$/i
+const RERUN = /^(?:please\s+)?re-?run\s+([\s\S]+?)[.!]?$/i
+const BARE = /^(?:please\s+)?(?:re-?run|run (?:it |that )?again|again)[.!]?$/i
+const LAST = /^(?:the\s+)?(?:last|previous|latest)(?:\s+(?:run|test|one|goal))?$|^(?:it|that|this)$/i
+
+/** What the request asks to run again, or null when it is not a request to repeat something. */
+export function rerunTarget(text: string): { target: string; explicit: boolean } | null {
+  const t = text.trim()
+  if (BARE.test(t)) return { target: "last", explicit: true }
+  const m = LINK.exec(t) || AGAIN.exec(t) || RERUN.exec(t)
+  if (m) return { target: m[1]!.trim(), explicit: true }
+  // Not phrased as a rerun: it can still be a known goal, typed or pasted word for word.
+  return { target: t, explicit: false }
+}
+
+/** Decides one request. */
+export function resolveRequest(reg: Registry, text: string): Decision {
+  const r = rerunTarget(text)
+  if (!r) return { tier: null, why: "not a rerun" }
+  return resolveTarget(reg, r.target, r.explicit)
+}
+
+/** `explicit`: the person asked to run it again; otherwise only an exact goal can match. */
+export function resolveTarget(reg: Registry, target: string, explicit = true): Decision {
+  let plan: Plan | null = null
+  if (explicit && (LAST.test(target) || target === "last")) plan = reg.latestPlan()
+  else {
+    if (explicit) plan = reg.planOfRun(target)
+    if (!plan) {
+      const found = reg.plansByAlias(normGoal(target))
+      // The same goal recorded from more than one start page: which one is meant is the agent's call.
+      if (new Set(found.map((p) => normUrl(p.startUrl))).size > 1) return { tier: null, why: "more than one recorded start page for this goal" }
+      plan = found[0] || null
+    }
+  }
+  if (!plan) return { tier: null, why: explicit ? "no recorded run matches" : "not a recorded goal" }
+  if (plan.lastOutcome !== "passed") return { tier: null, why: "its last run did not pass", plan }
+  if (plan.stale) return { tier: null, why: "marked stale", plan }
+  return { tier: 0, plan, why: explicit ? "rerun of a passed run" : "a recorded goal word for word" }
+}

package/src/registry/tier0.ts

@@ -0,0 +1,81 @@
+import { existsSync, readFileSync } from "node:fs"
+import path from "node:path"
+
+import type { Plan } from "./db.ts"
+
+/** What browser_run returns, as far as a Tier 0 reply needs it: a run's summary, or an existing test that passed. */
+export type RunSummary = {
+  status?: string
+  summary?: string
+  run_dir?: string
+  outcome?: string
+  failed_expectations?: { expected?: string; page_shows?: string }[]
+  tokens?: number
+  memory?: { replayed?: number; llm_steps?: number }
+  reused_test?: string
+  test?: string
+  command?: string
+  seconds?: number
+  /** From the run's run.json: recorded checks found on the page again, and how many held. */
+  checked?: number
+  checks_held?: number
+}
+
+/** What a run's page memory says about its checks (run.json), for the reply; nothing when it cannot be read. */
+export function runChecks(runDir?: string): Pick<RunSummary, "checked" | "checks_held"> {
+  try {
+    const file = runDir ? path.join(runDir, "run.json") : ""
+    if (!file || !existsSync(file)) return {}
+    const m = (JSON.parse(readFileSync(file, "utf8")) as { memory?: { checked?: number; checks_held?: number } }).memory
+    return m?.checked ? { checked: Number(m.checked), checks_held: Number(m.checks_held || 0) } : {}
+  } catch {
+    return {}
+  }
+}
+
+/** The reply to a Tier 0 rerun, written from the result: no model is asked to summarise it. */
+export function tier0Reply(plan: Plan, out: RunSummary): { text: string; outcome: "done" | "failed" } {
+  const tokens = out.tokens || 0
+  const share = plan.firstTokens ? ` (${((tokens / plan.firstTokens) * 100).toFixed(tokens && tokens < plan.firstTokens / 100 ? 2 : 0)}% of the ${fmt(plan.firstTokens)} the first run used)` : ""
+  const cost = `Run again as recorded, without ForgeQE's agent · ${tokens ? `${fmt(tokens)} tokens` : "no model tokens"}${share}.`
+  if (out.reused_test) {
+    const which = out.test ? `${out.test} in ${out.reused_test}` : out.reused_test
+    return { text: `Passed: the existing test ${which} ran as it is (${out.command || "its test command"}${out.seconds ? `, ${out.seconds}s` : ""}).\n${cost}`, outcome: "done" }
+  }
+  const n = out.memory?.replayed || 0
+  const llm = out.memory?.llm_steps || 0
+  const replay = n
+    ? ` Replayed ${n} remembered step${n === 1 ? "" : "s"} without the model${llm ? `; the browser agent then took ${llm} step${llm === 1 ? "" : "s"} with it` : ""}.`
+    : llm
+      ? ` The browser agent took ${llm} step${llm === 1 ? "" : "s"} with the model.`
+      : ""
+  const checks = out.checked
+    ? out.checks_held === out.checked
+      ? ` ${out.checked === 1 ? "The recorded check was" : `All ${out.checked} recorded checks were`} found on the page again${llm ? "" : ", so no model was needed to judge it"}.`
+      : ` ${out.checks_held || 0} of ${out.checked} recorded checks found on the page again.`
+    : ""
+  const where = out.run_dir ? `\nReport: ${out.run_dir}` : ""
+  if (out.status === "passed") return { text: `Passed: ${clip(plan.goal)}${replay}${checks}${where}\n${cost}`, outcome: "done" }
+  const failed = out.failed_expectations?.length
+    ? `\n${out.failed_expectations.map((f) => `• Expected ${f.expected || "?"}; the page shows ${f.page_shows || "something else"}`).join("\n")}`
+    : out.summary
+      ? `\n${out.summary}`
+      : ""
+  const verb = out.status === "stopped" ? "Stopped" : out.outcome === "assertion_failed" ? "Failed: an expected result does not hold" : "Failed"
+  return {
+    text: `${verb}: ${clip(plan.goal)}${replay}${checks}${failed}${where}\n${cost}\nIt passed before, so ask ForgeQE to look into it: its agent can replay what still works and find what changed.`,
+    outcome: "failed",
+  }
+}
+
+/** A long goal, cut at a word near 160 characters: the report has all of it. */
+function clip(goal: string, max = 160): string {
+  const g = goal.replace(/\s+/g, " ").trim()
+  if (g.length <= max) return g
+  const cut = g.slice(0, max)
+  return `${cut.slice(0, Math.max(cut.lastIndexOf(" "), max - 20))}…`
+}
+
+function fmt(n: number): string {
+  return n >= 1000 ? `${(n / 1000).toFixed(n >= 100_000 ? 0 : 1)}K` : String(n)
+}

package/src/report/data.ts

@@ -8,6 +8,7 @@ import { DEFECT_HISTORY } from "../cases/defectHistory.ts"
 import { defectTrends, type DefectTrends } from "../cases/predict.ts"
 import type { ReportEnv } from "./html.ts"
 import { addCost } from "../usage.ts"
+import { reportUsage, type UsageData } from "./usage.ts"
 import { FAILURE_ACTION, FAILURE_LABEL } from "../cases/failure.ts"
 
 /** Something that went wrong in the browser during a step: a console error, an uncaught exception, a failed or slow request. */
@@ -113,6 +114,8 @@ export type ReportData = {
   defects?: DefectCluster[]
   /** How the defects of the suites in this folder went over time, when they have a history. */
   defectTrends?: DefectTrends
+  /** Every model call of the report and the ledger's recent days (src/report/usage.ts); unset when there are none. */
+  usage?: UsageData
 }
 
 export type ReportCase = {
@@ -258,6 +261,10 @@ export function buildReportData(p: DataInput, opts: DataOptions = {}): ReportDat
       data.defectTrends = defectTrends(path.dirname(p.dir))
     } catch {}
   }
+  try {
+    const usage = reportUsage({ kind: p.kind, dir: p.dir, startedAt: p.startedAt, runDirs: p.results.map((r) => r.runDir).filter((d): d is string => Boolean(d)), budget: p.env?.budget })
+    if (usage) data.usage = usage
+  } catch {}
   if (p.kind === "suite") {
     data.history = [
       ...earlier.map((s) => historyRun(s.name, s.title, s.startedAt, s.ms, s.results, s.href)),

package/src/report/html.ts

@@ -7,6 +7,7 @@ import { costOf, type CaseResult, type WriteBack } from "../cases/types.ts"
 import type { AppConfig, BrowserConfig } from "../config.ts"
 import type { DefectCluster } from "../cases/defects.ts"
 import { packageVersion } from "../tui/theme.ts"
+import type { BudgetConfig } from "../tokenomics/budget.ts"
 import { buildReportData, type DataOptions } from "./data.ts"
 
 export { readTimeline, type TimelineStep } from "./data.ts"
@@ -23,6 +24,10 @@ export type ReportEnv = {
   branch?: string
   /** Price per million tokens of the browser agent's model, when set in llms.json. */
   price?: { input: number; output: number; currency: string; cachedInput?: number; note?: string; estimate?: boolean }
+  /** budget: in forgeqe.yaml, for the Tokenomics pages. */
+  budget?: BudgetConfig
+  /** The profiles in llms.json that have a price: the models the Tokenomics calculator can price a run at. */
+  profiles?: { name: string; provider: string; model: string; price: NonNullable<ReportEnv["price"]> }[]
 }
 
 export function ciInfo(env = process.env): Pick<ReportEnv, "ci" | "commit" | "branch"> {
@@ -58,10 +63,19 @@ export function reportEnv(
     version: packageVersion(),
     machine: `${os.hostname()} · ${process.platform}`,
     ...(llm.price ? { price: llm.price } : {}),
+    ...(config.budget ? { budget: config.budget } : {}),
+    ...(priced(config).length ? { profiles: priced(config) } : {}),
     ...ciInfo(),
   }
 }
 
+/** Profiles with a price, by name; the key and endpoint stay out of the report. */
+function priced(config: AppConfig): NonNullable<ReportEnv["profiles"]> {
+  return Object.entries(config.profiles || {})
+    .filter(([, p]) => p.price && p.provider !== "mock" && p.provider !== "none")
+    .map(([name, p]) => ({ name, provider: p.provider, model: p.deployment || p.model, price: p.price! }))
+}
+
 export function duration(ms: number): string {
   const s = Math.round(ms / 1000)
   return s < 60 ? `${s}s` : `${Math.floor(s / 60)}m ${String(s % 60).padStart(2, "0")}s`