rovecode 0.3.2 → 0.4.0-beta.2

package/src/design/direction.ts

@@ -1,190 +0,0 @@
-/** The project's chosen design direction, recorded once and then honoured.
- *
- *  Berkay's standing rule is "Tasarimda varsayilan yok" — no carried-over palette, no safe font,
- *  no direction picked by the tool. So rovecode ships NO default look. What it ships is a protocol:
- *  before the first UI is written, the agent proposes distinct directions, the HUMAN picks one, and
- *  the choice is written here. Every later piece of UI in the project is measured against it.
- *
- *  Why persist it at all: without a record the second screen drifts from the first, and "consistent"
- *  degrades into "whatever the model remembered". With it, design_audit can report DEVIATION (a font
- *  that is not the chosen font) rather than only taste, which is the part a machine can actually judge.
- *
- *  The file is <cwd>/.rovecode/design.json. It is deliberately per-project and never global: a global
- *  design file would be exactly the "carried over from the last job" default the rule forbids. */
-
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-
-export const DESIGN_FILE = "design.json";
-
-/** How corners read. Recorded because "no radius anywhere" is a finding UNLESS it was the choice. */
-export type Corners = "sharp" | "soft" | "round";
-/** How the page is composed. Recorded because centred-everything is a finding UNLESS it was the choice. */
-export type Layout = "centered" | "left" | "asymmetric" | "grid";
-/** How tightly the page is packed. Recorded because "airy" and "tight" want opposite spacing scales,
- *  and a model with no record of which regresses to the mode on every screen. */
-export type Density = "tight" | "regular" | "airy";
-
-export interface DesignDirection {
-  /** short name of the direction, as it was presented to the human ("lacivert band + beyaz govde") */
-  name: string;
-  /** one line: why this direction suits this product */
-  rationale?: string;
-  /** the palette as chosen — free-form keys so a direction is not forced into a fixed slot set */
-  palette?: Record<string, string>;
-  /** typefaces as chosen, by ROLE: `display`, `text`, and any role the direction needs (`label`,
-   *  `mono`, …). Free-form keys on purpose: a chart-style direction has condensed map labels as a
-   *  first-class role, and every face named here is exempt from the cliché-font check. */
-  typeface?: Record<string, string>;
-  corners?: Corners;
-  layout?: Layout;
-
-  /* The axes below were added on docs/design-slop-research.md §6.3. The argument for them is not that
-   * the auditor needs more fields: it is that an unspecified requirement is inferred correctly only
-   * 41.1% of the time and underspecified prompts are twice as likely to fail when conditions change
-   * (Yang et al., arXiv:2505.13360). Every axis this file leaves blank regresses to the training mode
-   * on EVERY call, which is where a second screen drifts from the first. All optional: a direction that
-   * says nothing about motion is a direction that has not decided about motion, not an invalid one. */
-
-  /** the page's blocks in order, as the human chose them ("hero, proof, problems, pricing, faq") */
-  sectionOrder?: string[];
-  /** the hero pattern by name, so "is this the hero we chose" becomes answerable */
-  heroPattern?: string;
-  /** the type scale as chosen, in px or rem steps — the count and the gaps, not a ratio */
-  typeScale?: number[];
-  /** how tightly the page is packed */
-  density?: Density;
-  /** the motion rule in the human's words ("one entrance per section, no loops") */
-  motion?: string;
-  /** the copy register ("technical, names and numbers, no marketing verbs") */
-  copyRegister?: string;
-
-  /** anything the audit cannot infer: imagery, what to avoid in THIS project */
-  notes?: string;
-  /** ISO date the human chose it */
-  chosenAt?: string;
-
-  /* Headless runs. `ask_user` needs a human on the other end; in a one-shot `rovecode run` there is
-   * none, so an agent that must ship a page either stalls or — measured, 2026-09-04 — picks a
-   * direction itself and records it as though a human had chosen. The second is worse than the first:
-   * it launders the agent's taste into the one file whose whole job is to hold the HUMAN's choice, and
-   * every later screen is then measured against a default nobody picked. So the record carries who
-   * chose. A provisional direction is honoured exactly like a chosen one while it stands — the point
-   * is not to weaken it, only to stop it from silently becoming permanent. */
-
-  /** true when no human could answer and the agent built to one direction to get unblocked */
-  provisional?: boolean;
-  /** who chose it. Absent means a human did (every record written before this field existed). */
-  chosenBy?: "human" | "agent";
-  /** the directions NOT built, by name — what the next interactive session offers instead */
-  alternatives?: string[];
-}
-
-export function designPath(cwd: string): string {
-  return join(cwd, ".rovecode", DESIGN_FILE);
-}
-
-const str = (v: unknown): string | undefined => (typeof v === "string" && v.trim().length > 0 ? v.trim() : undefined);
-
-const CORNERS: readonly string[] = ["sharp", "soft", "round"];
-const LAYOUTS: readonly string[] = ["centered", "left", "asymmetric", "grid"];
-const DENSITIES: readonly string[] = ["tight", "regular", "airy"];
-
-/** Parse a raw record into a direction, dropping anything malformed rather than throwing: a
- *  hand-edited design.json with one bad field must not take the whole run down. Returns null when
- *  there is no usable direction at all (no name). */
-export function parseDirection(raw: unknown): DesignDirection | null {
-  if (typeof raw !== "object" || raw === null) return null;
-  const r = raw as Record<string, unknown>;
-  const name = str(r["name"]);
-  if (name === undefined) return null;
-  const out: DesignDirection = { name };
-  const rationale = str(r["rationale"]); if (rationale !== undefined) out.rationale = rationale;
-  const notes = str(r["notes"]); if (notes !== undefined) out.notes = notes;
-  const chosenAt = str(r["chosenAt"]); if (chosenAt !== undefined) out.chosenAt = chosenAt;
-  const corners = str(r["corners"])?.toLowerCase();
-  if (corners !== undefined && CORNERS.includes(corners)) out.corners = corners as Corners;
-  const layout = str(r["layout"])?.toLowerCase();
-  if (layout !== undefined && LAYOUTS.includes(layout)) out.layout = layout as Layout;
-  if (typeof r["palette"] === "object" && r["palette"] !== null) {
-    const pal: Record<string, string> = {};
-    for (const [k, v] of Object.entries(r["palette"] as Record<string, unknown>)) {
-      const s = str(v); if (s !== undefined) pal[k] = s;
-    }
-    if (Object.keys(pal).length > 0) out.palette = pal;
-  }
-  if (typeof r["typeface"] === "object" && r["typeface"] !== null) {
-    const tf: Record<string, string> = {};
-    for (const [k, v] of Object.entries(r["typeface"] as Record<string, unknown>)) {
-      const s = str(v); if (s !== undefined) tf[k] = s;
-    }
-    if (Object.keys(tf).length > 0) out.typeface = tf;
-  }
-  // the §6.3 axes. Same discipline as everything above: a malformed field is dropped, never thrown on,
-  // so one bad hand-edit costs that axis and not the run.
-  if (r["provisional"] === true) out.provisional = true;
-  const chosenBy = str(r["chosenBy"])?.toLowerCase();
-  if (chosenBy === "human" || chosenBy === "agent") out.chosenBy = chosenBy;
-  if (Array.isArray(r["alternatives"])) {
-    const alts = r["alternatives"].map(str).filter((x): x is string => x !== undefined);
-    if (alts.length > 0) out.alternatives = alts;
-  }
-  const heroPattern = str(r["heroPattern"]); if (heroPattern !== undefined) out.heroPattern = heroPattern;
-  const motion = str(r["motion"]); if (motion !== undefined) out.motion = motion;
-  const copyRegister = str(r["copyRegister"]); if (copyRegister !== undefined) out.copyRegister = copyRegister;
-  const density = str(r["density"])?.toLowerCase();
-  if (density !== undefined && DENSITIES.includes(density)) out.density = density as Density;
-  if (Array.isArray(r["sectionOrder"])) {
-    const secs = r["sectionOrder"].map(str).filter((s): s is string => s !== undefined);
-    if (secs.length > 0) out.sectionOrder = secs;
-  }
-  if (Array.isArray(r["typeScale"])) {
-    const steps = r["typeScale"].filter((n): n is number => typeof n === "number" && Number.isFinite(n) && n > 0);
-    if (steps.length > 0) out.typeScale = steps;
-  }
-  return out;
-}
-
-/** The recorded direction, or null when this project has not chosen one yet. Never throws. */
-export function loadDirection(cwd: string): DesignDirection | null {
-  const p = designPath(cwd);
-  if (!existsSync(p)) return null;
-  try { return parseDirection(JSON.parse(readFileSync(p, "utf8"))); } catch { return null; }
-}
-
-/** Write the direction the human chose. Returns the path written. */
-export function saveDirection(cwd: string, d: DesignDirection): string {
-  const p = designPath(cwd);
-  mkdirSync(dirname(p), { recursive: true });
-  const body: DesignDirection = { ...d, chosenAt: d.chosenAt ?? new Date().toISOString().slice(0, 10) };
-  writeFileSync(p, JSON.stringify(body, null, 2) + "\n");
-  return p;
-}
-
-/** The direction as prompt text — what the agent must stay faithful to. Empty string when none. */
-export function renderDirection(d: DesignDirection | null): string {
-  if (d === null) return "";
-  const lines: string[] = d.provisional === true
-    ? [`PROVISIONAL direction: ${d.name}${d.chosenAt ? ` (recorded ${d.chosenAt})` : ""} — chosen by the agent, no human was available.`,
-       "Build to it, but ask the human once before the next screen: this is the one decision that is theirs."]
-    : [`Chosen direction: ${d.name}${d.chosenAt ? ` (chosen ${d.chosenAt})` : ""}`];
-  if (d.rationale !== undefined) lines.push(`Why: ${d.rationale}`);
-  if (d.palette !== undefined) lines.push(`Palette: ${Object.entries(d.palette).map(([k, v]) => `${k} ${v}`).join(", ")}`);
-  if (d.typeface !== undefined) {
-    const roles = Object.entries(d.typeface);
-    const faces = new Set(roles.map(([, f]) => f));
-    // one face everywhere reads as one name; otherwise each role names its face
-    lines.push(`Typefaces: ${faces.size === 1 ? roles[0]![1] : roles.map(([role, f]) => `${f} for ${role}`).join(", ")}`);
-  }
-  if (d.corners !== undefined) lines.push(`Corners: ${d.corners}`);
-  if (d.layout !== undefined) lines.push(`Composition: ${d.layout}`);
-  if (d.density !== undefined) lines.push(`Density: ${d.density}`);
-  if (d.sectionOrder !== undefined) lines.push(`Section order: ${d.sectionOrder.join(" -> ")}`);
-  if (d.heroPattern !== undefined) lines.push(`Hero: ${d.heroPattern}`);
-  if (d.typeScale !== undefined) lines.push(`Type scale: ${d.typeScale.join(", ")}`);
-  if (d.motion !== undefined) lines.push(`Motion: ${d.motion}`);
-  if (d.copyRegister !== undefined) lines.push(`Copy register: ${d.copyRegister}`);
-  if (d.notes !== undefined) lines.push(`Notes: ${d.notes}`);
-  if (d.alternatives !== undefined) lines.push(`Not built: ${d.alternatives.join(", ")}`);
-  return lines.join("\n");
-}

package/src/design/rules.ts

@@ -1,157 +0,0 @@
-/** The design section of the system prompt (cli/runtime.ts buildDef appends it after the base prompt
- *  and any model profile).
- *
- *  What this section deliberately does NOT contain: a palette, a typeface, a layout, or any other
- *  "good default". Berkay's standing rule is "Tasarimda varsayilan yok" — every project decides colour,
- *  type and layout again, nothing carries over from the last job. A built-in default look would be the
- *  exact failure being complained about: it would make every rovecode site resemble every other one.
- *
- *  So the section carries two things a default cannot give you:
- *    1. A PROTOCOL. Before the first interface in a project, propose distinct directions and let the
- *       human choose; record the choice; hold to it afterwards. Asked once per project, not per task
- *       (the record in .rovecode/design.json is what makes "once" possible).
- *    2. A BAN LIST, drawn from what Berkay actually pointed at: amber accents, the reflex hero,
- *       unrelated typefaces, hairlines everywhere, everything square, everything centred.
- *
- *  The ban list is phrased as "these are the defaults you fall into", not as "these are forbidden
- *  forever" — a project that deliberately chooses sharp corners records that, and design_audit stops
- *  reporting it. A rule with no escape hatch gets ignored wholesale.
- *
- *  Pinned by test/unit/design-rules.test.ts: no palette or font is prescribed, every complaint is
- *  covered, and the text names the two tools. */
-
-import { loadDirection, renderDirection } from "./direction.ts";
-
-/** The always-on part: the protocol and the ban list. Contains no colour, font or layout choice. */
-export const DESIGN_RULES: string = [
-  "# Interface design",
-  "",
-  "This applies whenever you build or change a user interface — a page, a screen, a component, a theme.",
-  "",
-  "## Decide the direction with the human, once per project",
-  "",
-  "There is no default look. Colour, typeface and layout are decided per project and nothing carries",
-  "over from another project.",
-  "",
-  "This question is about NEW work: a page, screen or component that is not on the screen yet. A change",
-  "to something that already exists is not this question. \"Make the background black\", \"add a shadow to",
-  "the text\", \"make this bigger\", a new state on an existing screen, a colour swapped on an existing",
-  "button: do it, now, in the direction the existing code already shows, and do not stop at a proposal,",
-  "whether or not this project has a recorded direction. The test is simple: if the person could point at",
-  "the thing on the screen, it exists and you change it; if they could not, it is new and the direction is",
-  "decided first. When the change would contradict a recorded direction, make the change and say so in one",
-  "line, so the human can decide whether the direction moves.",
-  "",
-  "- If this project has no recorded direction and you are about to write NEW UI, stop and propose THREE",
-  "  directions first. For each: the palette (as hex), the typefaces, how it composes the page, and the",
-  "  specific fact about THIS product that justifies it.",
-  "- Three directions are distinct only if they disagree on ALL FOUR of these axes; if two agree on the",
-  "  second or third they will converge however different their prose sounds, because those two decide",
-  "  the structure:",
-  "    1. what the first screen is MADE OF (real output? prose? an instrument? an image?)",
-  "    2. what carries HIERARCHY (type scale? density? monospace rhythm? boxes? colour?)",
-  "    3. what COLOUR is FOR (functional only? near-absent with one accent? state semantics? mood?)",
-  "    4. what counts as PROOF (real runs? tables and footnotes? live numbers? testimony?)",
-  "  Asking yourself once for three ideas tends to return one idea three times; derive each direction",
-  "  from a different source of form instead, then check the four axes.",
-  "- Worked example for a developer tool, as an example and not a menu — the right sources of form for a",
-  "  payments product or a magazine are different, and if you cannot name the product fact that justifies",
-  "  an anchor, it is the wrong anchor for this project:",
-  "    A. ITS OWN OUTPUT — the page is made of what the tool produces: a real transcript or diff as the",
-  "       first screen, hierarchy from monospace rhythm, colour functional only (add/remove, exit status),",
-  "       proof = actual runs. Forbids itself stock illustration and invented copy. Even here the first",
-  "       screen still SAYS what the product is, in one visible line above or beside the output — a",
-  "       caption, not a hero. A transcript a stranger cannot name is a demo, not a page, and an",
-  "       sr-only h1 is not that line: it has to be visible.",
-  "    B. THE MANUAL — a technical document that happens to be a web page: a stated claim in a long",
-  "       measure plus a spec table, hierarchy from type scale and space alone, colour nearly absent",
-  "       with one accent, proof = tables and versioned facts. Forbids itself cards, the headline-plus-",
-  "       two-buttons pair, the three-column feature grid.",
-  "    C. THE INSTRUMENT — a dense panel a professional reads at a glance: a live status surface first,",
-  "       hierarchy from density contrast and a visible grid, colour carrying state (ok/warn/fail),",
-  "       proof = numbers in place. Forbids itself marketing whitespace and decorative motion.",
-  "- The anchor fixes the organising idea and the structure, NOT the palette or the mode: the seed colour",
-  "  and light/dark are chosen independently of it. \"Terminal\" is not a licence for dark-plus-green;",
-  "  that would be a default smuggled in through the back door.",
-  "- Let the human choose. Do not build while the question is open, and do not pick for them.",
-  "- Keep each option LABEL to 60 characters or less — a letter and the direction's name (\"A. Its own",
-  "  output\"). The four axes, the palette and the rationale go in the question body, not the label:",
-  "  ask_user truncates a long option and the human then chooses between three cut-off phrases.",
-  "- WHEN NOTHING CAN ASK A HUMAN (a headless `rovecode run`, no terminal): do not stall, and do not",
-  "  quietly promote your own pick to a decision. Build ONE direction and record it as provisional —",
-  "  `design_direction set` with `provisional: true` and the other two names in `alternatives`. Then say",
-  "  so in your final summary: which one you built, which two you did not, and that the choice is still",
-  "  theirs. The next interactive session asks the question once before writing more UI.",
-  "- Once they choose, record it with the `design_direction` tool. That is what makes this a",
-  "  once-per-project question instead of a once-per-task one.",
-  "- When a direction is already recorded, do NOT re-ask. Build to it. Propose a change only if the",
-  "  work genuinely cannot be done within it, and say why. The one exception: a direction recorded as",
-  "  PROVISIONAL was chosen by an agent, not a human — ask once, in the first interactive session that",
-  "  touches UI, before building more; then record the answer with `provisional` dropped.",
-  "",
-  "## The defaults to climb out of",
-  "",
-  "These are what generated interfaces look like when nobody decided anything. Recognise them in your",
-  "own output:",
-  "",
-  "- Amber, orange and gold as the accent. It is the reflex accent; choose one that belongs to the product.",
-  "- A full-viewport hero with a big headline and two buttons, on a page that had no reason for one.",
-  "  A hero costs the reader an entire screen — spend it only on an image or an idea that earns it.",
-  "- Typefaces with no relationship to the product: Inter, Roboto, Poppins, Montserrat and the rest of",
-  "  the set that arrives when no one picked. What matters is the face you LOAD — an import, an",
-  "  @font-face, a fonts URL — because that is where the decision is; a system stack sitting behind your",
-  "  chosen face is a fallback, not a choice, and neither is a face merely named in prose. Pick the face",
-  "  you load for a reason you can state. And if you name a face in CSS, LOAD it — a link, an @import,",
-  "  an @font-face or a framework font import — or drop the name: a named-but-unloaded face renders as",
-  "  its fallback, so the page does not look the way the code says it does. That is no decision at all,",
-  "  and `design_audit` reports it as `font-named-not-loaded`.",
-  "- Hairlines everywhere: a border around every card, a rule between every row. Separation reads better",
-  "  from spacing, weight, size and background than from drawn lines.",
-  "- Everything square. Corner treatment is a decision; make it once, deliberately, either way.",
-  "- Everything centred. Centring every block removes the alignment edge the eye follows down the page",
-  "  and flattens the hierarchy — most content wants an edge to sit against.",
-  "- Every fact at the same size in one long column. Decide what is most important and let the layout",
-  "  say so; a page where everything shouts says nothing.",
-  "- The purple-to-blue gradient, and the generic three-column feature grid under a centred heading.",
-  "",
-  "## Check yourself",
-  "",
-  "After writing UI, or changing how an existing screen looks (the black background, the shadow, the",
-  "bigger heading included), run `design_audit` on the source you touched — the PAGE",
-  "file together with the components it imports, not one component alone. Hairline density and centring",
-  "are properties of a page, and \"no rounded corner anywhere\" is a property of a project, so a",
-  "single-component run cannot see them. Run it on source, never on a fetched page: a built page measures",
-  "the framework's output.",
-  "",
-  "It separates two things. A SLOP finding means nothing here records a decision — it disappears the",
-  "moment the human chooses and you record it, and it is not a claim that the pattern is ugly. A",
-  "DEVIATION means the code contradicts what this project already chose, which is the half worth acting",
-  "on. Fix what it finds, or say plainly why a finding is wrong for this project: it reports evidence,",
-  "not verdicts, and it can be overruled.",
-  "",
-  "The audit measures patterns, not promises, so it cannot check the half of the direction that is",
-  "prose. Do that part yourself: re-read the `notes` and `rationale` recorded in design.json and take",
-  "each claim to the page one at a time. \"No stock imagery\", \"numbers in place, no adjectives\",",
-  "\"one entrance per section\" — either the page does it or it does not, and a clean audit says",
-  "nothing about any of them.",
-].join("\n");
-
-/** The prompt section for a project: the rules, plus either the recorded direction or the instruction
- *  to establish one. Read at buildDef (once per run start), like the model profile, so the system
- *  prefix stays byte-stable within a run for the prompt cache. */
-export function designPromptSection(cwd: string): string {
-  const direction = loadDirection(cwd);
-  if (direction === null) {
-    return `${DESIGN_RULES}\n\n## This project\n\nNo design direction is recorded yet (.rovecode/design.json). The next interface work in this project starts with the proposal above.`;
-  }
-  // A provisional direction is built to exactly like a chosen one, but the heading must not tell the
-  // model "do not re-ask" about the one question that is still open. renderDirection carries the rest.
-  const heading = direction.provisional === true
-    ? "## This project's direction — PROVISIONAL: build to this, and ask once before more UI"
-    : "## This project's direction — build to this, do not re-ask";
-  return `${DESIGN_RULES}
-
-${heading}
-
-${renderDirection(direction)}`;
-}

package/src/eval/bench.ts

@@ -1,150 +0,0 @@
-/** Cross-harness benchmark: runs equivalent micro-workloads through Rovecode and
- *  comparable harness primitives, measuring wall time, tool calls, success.
- *  Deterministic (scripted providers / direct API use) — no API keys needed. */
-
-import { agentLoop, SteeringQueue } from "../core/loop.ts";
-import { ToolRegistry } from "../core/tools.ts";
-import { SessionStore } from "../core/session.ts";
-import { readTool, editTool, writeTool } from "../coding/hashline.ts";
-import { mockStream, textTurn, toolTurn } from "../providers/stream.ts";
-import type { AgentDefinition, RunConfig, StreamFn, AssistantTurn, Message } from "../core/types.ts";
-import { mkdtempSync, writeFileSync, readFileSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { randomUUID } from "node:crypto";
-
-export interface BenchResult {
-  harness: string;
-  task: string;
-  pass: boolean;
-  durationMs: number;
-  toolCalls: number;
-}
-
-const cfg: RunConfig = {
-  maxTurns: 10, contextBudgetTokens: 400_000, compactionThreshold: 0.8,
-  parallelTools: true,
-  permissionRules: [{ action: "*", resource: "*", effect: "allow" }],
-};
-
-const def: AgentDefinition = { name: "bench", systemPrompt: "bench", tools: ["*"] };
-
-/** Workload: edit N lines across M files using anchored edits. */
-async function benchEditsRovecode(nFiles: number, nEdits: number): Promise<{ pass: boolean; ms: number; calls: number }> {
-  const ws = mkdtempSync(join(tmpdir(), "rovecode-bench-"));
-  for (let i = 0; i < nFiles; i++) {
-    writeFileSync(join(ws, `f${i}.txt`), Array.from({ length: 50 }, (_, j) => `line-${i}-${j}`).join("\n") + "\n");
-  }
-  const store = new SessionStore(mkdtempSync(join(tmpdir(), "rovecode-bench-s-")), randomUUID());
-  const reg = new ToolRegistry();
-  reg.register(readTool, editTool, writeTool);
-  const t0 = Date.now();
-  let calls = 0;
-  // scripted: read each file, then batch edits
-  let fileIdx = 0; let phase: "read" | "edit" | "done" = "read";
-  const stream = mockStreamLike(async () => {
-    if (phase === "read" && fileIdx < nFiles) {
-      const p = join(ws, `f${fileIdx}.txt`);
-      fileIdx++;
-      if (fileIdx >= nFiles) phase = "edit";
-      return toolTurn([{ id: "r" + fileIdx, tool: "read", args: { path: p } }]);
-    }
-    if (phase === "edit") {
-      phase = "done";
-      const edits: { tag: string; anchorLine: number; anchorHash: string; newLines: string[] }[] = [];
-      for (let f = 0; f < nFiles; f++) {
-        const p = join(ws, `f${f}.txt`);
-        const content = readFileSync(p, "utf8");
-        const tag = hashTag(content);
-        const lines = content.split("\n");
-        for (let e = 0; e < nEdits; e++) {
-          const ln = 1 + e * 2; // spread edits
-          if (ln <= lines.length) edits.push({ tag, anchorLine: ln, anchorHash: fnv(lines[ln - 1]!), newLines: [`EDITED-${f}-${e}`] });
-        }
-        return toolTurn(edits.map((ed, i) => ({ id: "e" + i, tool: "edit", args: { path: p, edits: [ed] } })));
-      }
-    }
-    return textTurn("bench complete");
-  });
-  for await (const ev of agentLoop(def, "bench edits", {}, cfg, { stream, registry: reg, store }, new SteeringQueue())) {
-    if (ev.type === "tool_execution_start") calls++;
-  }
-  const ms = Date.now() - t0;
-  const pass = readFileSync(join(ws, "f0.txt"), "utf8").includes("EDITED-0-0");
-  rmSync(ws, { recursive: true, force: true });
-  return { pass, ms, calls };
-}
-
-function mockStreamLike(next: () => Promise<AssistantTurn>): StreamFn {
-  return async function* () {
-    yield { type: "turn" as const, turn: await next() };
-  };
-}
-
-function fnv(line: string): string {
-  const s = line.replace(/\s/g, "");
-  let h = 0x811c9dc5;
-  for (let i = 0; i < s.length; i++) { h ^= s.charCodeAt(i); h = Math.imul(h, 0x01000193) >>> 0; }
-  return h.toString(36).padStart(3, "0").slice(-3);
-}
-function hashTag(content: string): string {
-  return Bun.CryptoHasher ? new Bun.CryptoHasher("sha1").update(content).digest("hex").slice(0, 4) : "0000";
-}
-
-/** Baseline: raw fs operations (no agent) for reference cost. */
-function benchRawFs(nFiles: number, nEdits: number): { pass: boolean; ms: number } {
-  const ws = mkdtempSync(join(tmpdir(), "raw-bench-"));
-  const t0 = Date.now();
-  for (let i = 0; i < nFiles; i++) {
-    writeFileSync(join(ws, `f${i}.txt`), Array.from({ length: 50 }, (_, j) => `line-${i}-${j}`).join("\n") + "\n");
-  }
-  for (let f = 0; f < nFiles; f++) {
-    const p = join(ws, `f${f}.txt`);
-    const lines = readFileSync(p, "utf8").split("\n");
-    for (let e = 0; e < nEdits; e++) {
-      const ln = 1 + e * 2;
-      if (ln <= lines.length) lines[ln - 1] = `EDITED-${f}-${e}`;
-    }
-    writeFileSync(p, lines.join("\n"));
-  }
-  const ms = Date.now() - t0;
-  const pass = readFileSync(join(ws, "f0.txt"), "utf8").includes("EDITED-0-0");
-  rmSync(ws, { recursive: true, force: true });
-  return { pass, ms };
-}
-
-/** Session durability benchmark: append + replay N messages. */
-function benchSessions(n: number): { pass: boolean; ms: number } {
-  const dir = mkdtempSync(join(tmpdir(), "rovecode-sess-bench-"));
-  const t0 = Date.now();
-  const s = new SessionStore(dir, randomUUID());
-  let prev: string | null = null;
-  for (let i = 0; i < n; i++) {
-    const m: Message = { id: randomUUID(), role: "user", parts: [{ kind: "text", text: `msg ${i}` }], parentId: prev, createdAt: Date.now() };
-    s.append(m);
-    prev = m.id;
-  }
-  const count = s.messages().length;
-  const ms = Date.now() - t0;
-  rmSync(dir, { recursive: true, force: true });
-  return { pass: count === n, ms };
-}
-
-export async function runBenchmarks(): Promise<BenchResult[]> {
-  const results: BenchResult[] = [];
-  const edits = await benchEditsRovecode(3, 5);
-  results.push({ harness: "rovecode", task: "edits-3files-5edits", ...edits, durationMs: edits.ms, toolCalls: edits.calls } as unknown as BenchResult);
-  const raw = benchRawFs(3, 5);
-  results.push({ harness: "raw-fs", task: "edits-3files-5edits", pass: raw.pass, durationMs: raw.ms, toolCalls: 0 });
-  const sess = benchSessions(500);
-  results.push({ harness: "rovecode", task: "session-append-replay-500", pass: sess.pass, durationMs: sess.ms, toolCalls: 0 });
-  return results;
-}
-
-async function main(): Promise<void> {
-  const results = await runBenchmarks();
-  for (const r of results) {
-    console.log(`${r.harness.padEnd(8)} ${r.task.padEnd(28)} ${r.pass ? "PASS" : "FAIL"} ${r.durationMs}ms ${r.toolCalls} calls`);
-  }
-}
-if (import.meta.main) void main();