rovecode 0.3.2

package/src/design/direction.ts

@@ -0,0 +1,190 @@
+/** 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

@@ -0,0 +1,157 @@
+/** 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

@@ -0,0 +1,150 @@
+/** 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();