@levnikolaevich/hex-line-mcp 1.0.0 → 1.1.0

package/benchmark.mjs

@@ -1,25 +1,37 @@
 #!/usr/bin/env node
 /**
- * Hex-line Combo Benchmark v2
+ * Hex-line Combo Benchmark v3
  *
  * Compares "agent without hex-line" vs "agent with hex-line" across
  * read-only and write scenarios. Measures chars in response (proxy for tokens).
  *
- * Usage: node mcp/hex-line-mcp/benchmark.mjs [--repo /path/to/repo]
+ * Usage: node mcp/hex-line-mcp/benchmark.mjs [--repo /path/to/repo] [--with-graph]
  * Default repo: current working directory.
  *
  * Zero external deps beyond hex-line lib modules.
  */
 
-import { readFileSync, writeFileSync, unlinkSync, statSync, readdirSync } from "node:fs";
-import { resolve, extname, basename, join } from "node:path";
+import { readFileSync, writeFileSync, unlinkSync, readdirSync, mkdirSync, rmSync } from "node:fs";
+import { performance } from "node:perf_hooks";
+import { resolve, basename } from "node:path";
 import { tmpdir } from "node:os";
 import { fnv1a, lineTag, rangeChecksum } from "./lib/hash.mjs";
 import { readFile } from "./lib/read.mjs";
 import { directoryTree } from "./lib/tree.mjs";
 import { fileInfo } from "./lib/info.mjs";
 import { verifyChecksums } from "./lib/verify.mjs";
-
+import { fileChanges } from "./lib/changes.mjs";
+import { editFile } from "./lib/edit.mjs";
+import { grepSearch } from "./lib/search.mjs";
+import { bulkReplace } from "./lib/bulk-replace.mjs";
+import { fileOutline } from "./lib/outline.mjs";
+import {
+    walkDir, getFileLines, categorize, generateTempCode,
+    simBuiltInReadFull, simBuiltInOutlineFull, simBuiltInGrep,
+    simBuiltInLsR, simBuiltInStat, simBuiltInWrite, simBuiltInEdit, simBuiltInVerify,
+    simHexLineOutlinePlusRead, simHexLineGrep, simHexLineWrite, simHexLineEditDiff,
+    runN, fmt, pctSavings, RUNS,
+} from "./lib/benchmark-helpers.mjs";
 // ---------------------------------------------------------------------------
 // CLI
 // ---------------------------------------------------------------------------
@@ -31,534 +43,13 @@ if (repoIdx !== -1 && args[repoIdx + 1]) {
     repoRoot = resolve(args[repoIdx + 1]);
 }
 
-const CODE_EXTS = new Set([".js", ".ts", ".py", ".mjs", ".go", ".rs", ".java", ".c", ".cpp", ".rb", ".php"]);
-const MAX_FILES_PER_CAT = 3;
-const RUNS = 3;
-
-// ---------------------------------------------------------------------------
-// File discovery
-// ---------------------------------------------------------------------------
-
-function walkDir(dir, depth = 0) {
-    if (depth > 10) return [];
-    const results = [];
-    let entries;
-    try { entries = readdirSync(dir, { withFileTypes: true }); }
-    catch { return results; }
-    for (const e of entries) {
-        const full = resolve(dir, e.name);
-        if (e.isDirectory()) {
-            if (e.name.startsWith(".") || e.name === "node_modules" || e.name === "vendor"
-                || e.name === "dist" || e.name === "__pycache__" || e.name === "target") continue;
-            results.push(...walkDir(full, depth + 1));
-        } else if (e.isFile() && CODE_EXTS.has(extname(e.name).toLowerCase())) {
-            try {
-                const st = statSync(full);
-                if (st.size > 0 && st.size < 1_000_000) results.push(full);
-            } catch { /* skip */ }
-        }
-    }
-    return results;
-}
-
-function getFileLines(f) {
-    try { return readFileSync(f, "utf-8").replace(/\r\n/g, "\n").split("\n"); }
-    catch { return null; }
-}
-
-function categorize(files) {
-    const cats = { small: [], medium: [], large: [], xl: [] };
-    for (const f of files) {
-        const lines = getFileLines(f);
-        if (!lines) continue;
-        const n = lines.length;
-        if (n >= 10 && n <= 50) cats.small.push(f);
-        else if (n > 50 && n <= 200) cats.medium.push(f);
-        else if (n > 200 && n <= 500) cats.large.push(f);
-        else if (n > 500) cats.xl.push(f);
-    }
-    for (const key of Object.keys(cats)) {
-        const arr = cats[key];
-        if (arr.length > MAX_FILES_PER_CAT) {
-            const step = Math.floor(arr.length / MAX_FILES_PER_CAT);
-            cats[key] = Array.from({ length: MAX_FILES_PER_CAT }, (_, i) => arr[i * step]);
-        }
-    }
-    return cats;
-}
-
-// ---------------------------------------------------------------------------
-// Temp file: 200 lines of realistic JS
-// ---------------------------------------------------------------------------
-
-function generateTempCode() {
-    const lines = [];
-    lines.push('import { readFileSync } from "node:fs";');
-    lines.push('import { resolve, basename } from "node:path";');
-    lines.push("");
-    lines.push("const DEFAULT_TIMEOUT = 5000;");
-    lines.push("const MAX_RETRIES = 3;");
-    lines.push("");
-    lines.push("/**");
-    lines.push(" * Configuration manager for application settings.");
-    lines.push(" * Supports file-based and environment-based config sources.");
-    lines.push(" */");
-    lines.push("class ConfigManager {");
-    lines.push("    constructor(configPath) {");
-    lines.push("        this.configPath = resolve(configPath);");
-    lines.push("        this.cache = new Map();");
-    lines.push("        this.watchers = [];");
-    lines.push("        this.loaded = false;");
-    lines.push("    }");
-    lines.push("");
-    lines.push("    load() {");
-    lines.push("        const raw = readFileSync(this.configPath, 'utf-8');");
-    lines.push("        const parsed = JSON.parse(raw);");
-    lines.push("        for (const [key, value] of Object.entries(parsed)) {");
-    lines.push("            this.cache.set(key, value);");
-    lines.push("        }");
-    lines.push("        this.loaded = true;");
-    lines.push("        this.notifyWatchers('load', parsed);");
-    lines.push("        return this;");
-    lines.push("    }");
-    lines.push("");
-    lines.push("    get(key, defaultValue = undefined) {");
-    lines.push("        if (!this.loaded) this.load();");
-    lines.push("        return this.cache.has(key) ? this.cache.get(key) : defaultValue;");
-    lines.push("    }");
-    lines.push("");
-    lines.push("    set(key, value) {");
-    lines.push("        this.cache.set(key, value);");
-    lines.push("        this.notifyWatchers('set', { key, value });");
-    lines.push("    }");
-    lines.push("");
-    lines.push("    watch(callback) {");
-    lines.push("        this.watchers.push(callback);");
-    lines.push("        return () => {");
-    lines.push("            this.watchers = this.watchers.filter(w => w !== callback);");
-    lines.push("        };");
-    lines.push("    }");
-    lines.push("");
-    lines.push("    notifyWatchers(event, data) {");
-    lines.push("        for (const watcher of this.watchers) {");
-    lines.push("            try { watcher(event, data); }");
-    lines.push("            catch (e) { console.error('Watcher error:', e.message); }");
-    lines.push("        }");
-    lines.push("    }");
-    lines.push("}");
-    lines.push("");
-    lines.push("/**");
-    lines.push(" * Retry wrapper with exponential backoff.");
-    lines.push(" */");
-    lines.push("async function withRetry(fn, options = {}) {");
-    lines.push("    const { retries = MAX_RETRIES, delay = 100, backoff = 2 } = options;");
-    lines.push("    let lastError;");
-    lines.push("    for (let attempt = 0; attempt <= retries; attempt++) {");
-    lines.push("        try {");
-    lines.push("            return await fn(attempt);");
-    lines.push("        } catch (err) {");
-    lines.push("            lastError = err;");
-    lines.push("            if (attempt < retries) {");
-    lines.push("                const wait = delay * Math.pow(backoff, attempt);");
-    lines.push("                await new Promise(r => setTimeout(r, wait));");
-    lines.push("            }");
-    lines.push("        }");
-    lines.push("    }");
-    lines.push("    throw lastError;");
-    lines.push("}");
-    lines.push("");
-    lines.push("/**");
-    lines.push(" * HTTP client with timeout and retry support.");
-    lines.push(" */");
-    lines.push("class HttpClient {");
-    lines.push("    constructor(baseUrl, options = {}) {");
-    lines.push("        this.baseUrl = baseUrl.replace(/\\/$/, '');");
-    lines.push("        this.timeout = options.timeout || DEFAULT_TIMEOUT;");
-    lines.push("        this.headers = options.headers || {};");
-    lines.push("        this.retries = options.retries || MAX_RETRIES;");
-    lines.push("    }");
-    lines.push("");
-    lines.push("    async request(method, path, body = null) {");
-    lines.push("        const url = `${this.baseUrl}${path}`;");
-    lines.push("        const controller = new AbortController();");
-    lines.push("        const timer = setTimeout(() => controller.abort(), this.timeout);");
-    lines.push("");
-    lines.push("        try {");
-    lines.push("            return await withRetry(async () => {");
-    lines.push("                const opts = {");
-    lines.push("                    method,");
-    lines.push("                    headers: { ...this.headers },");
-    lines.push("                    signal: controller.signal,");
-    lines.push("                };");
-    lines.push("                if (body) {");
-    lines.push("                    opts.headers['Content-Type'] = 'application/json';");
-    lines.push("                    opts.body = JSON.stringify(body);");
-    lines.push("                }");
-    lines.push("                const response = await fetch(url, opts);");
-    lines.push("                if (!response.ok) {");
-    lines.push("                    throw new Error(`HTTP ${response.status}: ${response.statusText}`);");
-    lines.push("                }");
-    lines.push("                return response.json();");
-    lines.push("            }, { retries: this.retries });");
-    lines.push("        } finally {");
-    lines.push("            clearTimeout(timer);");
-    lines.push("        }");
-    lines.push("    }");
-    lines.push("");
-    lines.push("    get(path) { return this.request('GET', path); }");
-    lines.push("    post(path, body) { return this.request('POST', path, body); }");
-    lines.push("    put(path, body) { return this.request('PUT', path, body); }");
-    lines.push("    delete(path) { return this.request('DELETE', path); }");
-    lines.push("}");
-    lines.push("");
-    lines.push("/**");
-    lines.push(" * Simple event emitter for pub/sub patterns.");
-    lines.push(" */");
-    lines.push("class EventEmitter {");
-    lines.push("    constructor() {");
-    lines.push("        this.listeners = new Map();");
-    lines.push("    }");
-    lines.push("");
-    lines.push("    on(event, handler) {");
-    lines.push("        if (!this.listeners.has(event)) {");
-    lines.push("            this.listeners.set(event, []);");
-    lines.push("        }");
-    lines.push("        this.listeners.get(event).push(handler);");
-    lines.push("        return this;");
-    lines.push("    }");
-    lines.push("");
-    lines.push("    off(event, handler) {");
-    lines.push("        const handlers = this.listeners.get(event);");
-    lines.push("        if (handlers) {");
-    lines.push("            this.listeners.set(event, handlers.filter(h => h !== handler));");
-    lines.push("        }");
-    lines.push("        return this;");
-    lines.push("    }");
-    lines.push("");
-    lines.push("    emit(event, ...args) {");
-    lines.push("        const handlers = this.listeners.get(event) || [];");
-    lines.push("        for (const handler of handlers) {");
-    lines.push("            handler(...args);");
-    lines.push("        }");
-    lines.push("    }");
-    lines.push("");
-    lines.push("    once(event, handler) {");
-    lines.push("        const wrapper = (...args) => {");
-    lines.push("            handler(...args);");
-    lines.push("            this.off(event, wrapper);");
-    lines.push("        };");
-    lines.push("        return this.on(event, wrapper);");
-    lines.push("    }");
-    lines.push("}");
-    lines.push("");
-    lines.push("/**");
-    lines.push(" * Validate and sanitize user input.");
-    lines.push(" */");
-    lines.push("function validateInput(schema, data) {");
-    lines.push("    const errors = [];");
-    lines.push("    for (const [field, rules] of Object.entries(schema)) {");
-    lines.push("        const value = data[field];");
-    lines.push("        if (rules.required && (value === undefined || value === null)) {");
-    lines.push("            errors.push(`${field} is required`);");
-    lines.push("            continue;");
-    lines.push("        }");
-    lines.push("        if (value !== undefined && rules.type && typeof value !== rules.type) {");
-    lines.push("            errors.push(`${field} must be ${rules.type}`);");
-    lines.push("        }");
-    lines.push("        if (typeof value === 'string' && rules.maxLength && value.length > rules.maxLength) {");
-    lines.push("            errors.push(`${field} exceeds max length ${rules.maxLength}`);");
-    lines.push("        }");
-    lines.push("        if (typeof value === 'number' && rules.min !== undefined && value < rules.min) {");
-    lines.push("            errors.push(`${field} must be >= ${rules.min}`);");
-    lines.push("        }");
-    lines.push("    }");
-    lines.push("    return errors.length > 0 ? { valid: false, errors } : { valid: true };");
-    lines.push("}");
-    lines.push("");
-    lines.push("/**");
-    lines.push(" * Format bytes to human-readable string.");
-    lines.push(" */");
-    lines.push("function formatBytes(bytes) {");
-    lines.push("    if (bytes === 0) return '0 B';");
-    lines.push("    const units = ['B', 'KB', 'MB', 'GB', 'TB'];");
-    lines.push("    const exp = Math.floor(Math.log(bytes) / Math.log(1024));");
-    lines.push("    const value = bytes / Math.pow(1024, exp);");
-    lines.push("    return `${value.toFixed(exp > 0 ? 1 : 0)} ${units[exp]}`;");
-    lines.push("}");
-    lines.push("");
-    lines.push("/**");
-    lines.push(" * Deep merge two objects (source into target).");
-    lines.push(" */");
-    lines.push("function deepMerge(target, source) {");
-    lines.push("    const result = { ...target };");
-    lines.push("    for (const key of Object.keys(source)) {");
-    lines.push("        if (source[key] && typeof source[key] === 'object' && !Array.isArray(source[key])) {");
-    lines.push("            result[key] = deepMerge(result[key] || {}, source[key]);");
-    lines.push("        } else {");
-    lines.push("            result[key] = source[key];");
-    lines.push("        }");
-    lines.push("    }");
-    lines.push("    return result;");
-    lines.push("}");
-    lines.push("");
-    lines.push("export { ConfigManager, HttpClient, EventEmitter, withRetry, validateInput, formatBytes, deepMerge };");
-
-    // Pad to exactly 200 lines
-    while (lines.length < 200) lines.push("");
-    return lines.slice(0, 200);
-}
-
-// ---------------------------------------------------------------------------
-// Simulators — "without hex-line" (built-in tool output)
-// ---------------------------------------------------------------------------
-
-/** Simulate built-in Read: `cat -n` full file with header */
-function simBuiltInReadFull(filePath, lines) {
-    const body = lines.map((l, i) => `     ${String(i + 1).padStart(5)}\t${l}`).join("\n");
-    return `Contents of ${filePath}:\n\n${body}`;
-}
-
-/** Simulate outline via full read — agent reads entire file to understand structure */
-function simBuiltInOutlineFull(filePath, lines) {
-    return simBuiltInReadFull(filePath, lines);
-}
-
-/** Simulate ripgrep raw output (no hashes) */
-function simBuiltInGrep(filePath, lines, pattern) {
-    const re = new RegExp(pattern, "i");
-    const matches = [];
-    for (let i = 0; i < lines.length; i++) {
-        if (re.test(lines[i])) {
-            matches.push(`${filePath}:${i + 1}:${lines[i]}`);
-        }
-    }
-    return matches.join("\n") || "No matches found.";
-}
-
-/** Simulate `ls -laR` style output for a directory */
-function simBuiltInLsR(dirPath, depth = 0, maxDepth = 3) {
-    if (depth > maxDepth) return "";
-    const out = [];
-    let entries;
-    try { entries = readdirSync(dirPath, { withFileTypes: true }); }
-    catch { return ""; }
-
-    const SKIP = new Set(["node_modules", ".git", "dist", "build", "__pycache__", "coverage"]);
-
-    out.push(`${dirPath}:`);
-    out.push("total " + entries.length);
-
-    for (const e of entries) {
-        if (SKIP.has(e.name) && e.isDirectory()) continue;
-        const full = join(dirPath, e.name);
-        try {
-            const st = statSync(full);
-            const type = e.isDirectory() ? "d" : "-";
-            const size = String(st.size).padStart(8);
-            const date = st.mtime.toISOString().slice(0, 16).replace("T", " ");
-            out.push(`${type}rw-r--r-- 1 user group ${size} ${date} ${e.name}`);
-        } catch { /* skip */ }
-    }
-    out.push("");
-
-    for (const e of entries) {
-        if (!e.isDirectory()) continue;
-        if (SKIP.has(e.name)) continue;
-        const full = join(dirPath, e.name);
-        const sub = simBuiltInLsR(full, depth + 1, maxDepth);
-        if (sub) out.push(sub);
-    }
-
-    return out.join("\n");
-}
-
-/** Simulate `stat` output for a file */
-function simBuiltInStat(filePath) {
-    const st = statSync(filePath);
-    return [
-        `  File: ${filePath}`,
-        `  Size: ${st.size}\tBlocks: ${Math.ceil(st.size / 512)}\tIO Block: 4096\tregular file`,
-        `Device: 0h/0d\tInode: 0\tLinks: 1`,
-        `Access: (0644/-rw-r--r--)\tUid: ( 1000/ user)\tGid: ( 1000/ group)`,
-        `Access: ${st.atime.toISOString()}`,
-        `Modify: ${st.mtime.toISOString()}`,
-        `Change: ${st.ctime.toISOString()}`,
-        ` Birth: ${st.birthtime.toISOString()}`,
-    ].join("\n");
-}
-
-/** Simulate built-in write response */
-function simBuiltInWrite(filePath, content) {
-    const lineCount = content.split("\n").length;
-    return `File ${filePath} has been created successfully (${lineCount} lines).`;
-}
-
-/** Simulate built-in edit: old_string/new_string context blocks */
-function simBuiltInEdit(filePath, origLines, newLines) {
-    let changeStart = -1, changeEnd = -1;
-    for (let i = 0; i < Math.max(origLines.length, newLines.length); i++) {
-        if (origLines[i] !== newLines[i]) {
-            if (changeStart === -1) changeStart = i;
-            changeEnd = i;
-        }
-    }
-    if (changeStart === -1) return "";
-
-    const ctxBefore = Math.max(0, changeStart - 3);
-    const ctxAfter = Math.min(origLines.length, changeEnd + 4);
-    const old_string = origLines.slice(ctxBefore, ctxAfter).join("\n");
-    const new_string = newLines.slice(ctxBefore, Math.min(newLines.length, changeEnd + 4)).join("\n");
-    return `The file ${filePath} has been edited. Here's the result of running \`cat -n\` on a snippet:\n` +
-        `old_string:\n${old_string}\nnew_string:\n${new_string}`;
-}
-
-/** Simulate built-in verify: full re-read to check if file changed */
-function simBuiltInVerify(filePath, lines) {
-    return simBuiltInReadFull(filePath, lines);
-}
-
-// ---------------------------------------------------------------------------
-// Simulators — "with hex-line" (lib function output)
-// ---------------------------------------------------------------------------
-
-/** Hex-line outline — regex heuristic (no tree-sitter in benchmark) */
-function simHexLineOutline(lines) {
-    const structural = /^\s*(export\s+)?(function|class|def|async\s+def|impl|fn|pub\s+fn|struct|interface|type|enum|const|let|var)\b/;
-    const importLine = /^\s*(import|from|require|use|#include)/;
-    const entries = [];
-    let importStart = -1, importEnd = -1, importCount = 0;
-
-    for (let i = 0; i < lines.length; i++) {
-        if (importLine.test(lines[i])) {
-            if (importStart === -1) importStart = i + 1;
-            importEnd = i + 1;
-            importCount++;
-            continue;
-        }
-        if (structural.test(lines[i])) {
-            let end = lines.length;
-            for (let j = i + 1; j < lines.length; j++) {
-                if (structural.test(lines[j])) { end = j; break; }
-            }
-            entries.push(`${i + 1}-${end}: ${lines[i].trim().slice(0, 120)}`);
-        }
-    }
-
-    const parts = [];
-    if (importCount > 0) parts.push(`${importStart}-${importEnd}: (${importCount} imports/declarations)`);
-    parts.push(...entries);
-    parts.push("", `(${entries.length} symbols, ${lines.length} source lines)`);
-    return `File: benchmark-target\n\n${parts.join("\n")}`;
-}
-
-/** Hex-line outline + targeted read of first function (30 lines) */
-function simHexLineOutlinePlusRead(filePath, lines) {
-    const outlineStr = simHexLineOutline(lines);
-    const structural = /^\s*(export\s+)?(function|class|def|async\s+def|impl|fn|pub\s+fn|struct)\b/;
-    let funcStart = 0;
-    for (let i = 0; i < lines.length; i++) {
-        if (structural.test(lines[i])) { funcStart = i + 1; break; }
-    }
-    const start = Math.max(1, funcStart);
-    const readStr = readFile(filePath, { offset: start, limit: 30 });
-    return outlineStr + "\n---\n" + readStr;
-}
-
-/** Hex-line grep — hash-annotated format */
-function simHexLineGrep(filePath, lines, pattern) {
-    const re = new RegExp(pattern, "i");
-    const matches = [];
-    for (let i = 0; i < lines.length; i++) {
-        if (re.test(lines[i])) {
-            const tag = lineTag(fnv1a(lines[i]));
-            matches.push(`${filePath}:>>${tag}.${i + 1}\t${lines[i]}`);
-        }
-    }
-    return matches.length > 0
-        ? "```\n" + matches.join("\n") + "\n```"
-        : "No matches found.";
-}
-
-/** Hex-line write response */
-function simHexLineWrite(filePath, content) {
-    const lineCount = content.split("\n").length;
-    return `Created ${filePath} (${lineCount} lines)`;
-}
-
-/** Hex-line edit response: compact diff hunks */
-function simHexLineEditDiff(origLines, newLines, ctx = 3) {
-    const out = [];
-    const maxLen = Math.max(origLines.length, newLines.length);
-    let i = 0;
-
-    while (i < maxLen) {
-        if (i < origLines.length && i < newLines.length && origLines[i] === newLines[i]) {
-            i++;
-            continue;
-        }
-        // Found a difference — show context before
-        const ctxStart = Math.max(0, i - ctx);
-        if (ctxStart < i) {
-            if (ctxStart > 0) out.push("...");
-            for (let k = ctxStart; k < i; k++) {
-                out.push(` ${k + 1}| ${origLines[k]}`);
-            }
-        }
-        // Show changed lines
-        const changeStart = i;
-        while (i < maxLen && (i >= origLines.length || i >= newLines.length || origLines[i] !== newLines[i])) {
-            if (i < origLines.length) out.push(`-${i + 1}| ${origLines[i]}`);
-            i++;
-        }
-        for (let k = changeStart; k < i && k < newLines.length; k++) {
-            out.push(`+${k + 1}| ${newLines[k]}`);
-        }
-        // Context after
-        const ctxEnd = Math.min(maxLen, i + ctx);
-        for (let k = i; k < ctxEnd && k < origLines.length; k++) {
-            out.push(` ${k + 1}| ${origLines[k]}`);
-        }
-        if (ctxEnd < maxLen) out.push("...");
-        break;
-    }
-
-    const diff = out.join("\n");
-    return diff
-        ? `Updated benchmark-file\n\nDiff:\n\`\`\`diff\n${diff}\n\`\`\``
-        : "Updated benchmark-file";
-}
-
-// ---------------------------------------------------------------------------
-// Runner utilities
-// ---------------------------------------------------------------------------
-
-function median(arr) {
-    const sorted = [...arr].sort((a, b) => a - b);
-    const mid = Math.floor(sorted.length / 2);
-    return sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
-}
-
-function runN(fn, n = RUNS) {
-    const results = [];
-    for (let i = 0; i < n; i++) results.push(fn());
-    return median(results);
-}
-
-function fmt(n) {
-    return n.toLocaleString("en-US", { maximumFractionDigits: 0 });
-}
-
-function pctSavings(without, withSL) {
-    if (without === 0) return "N/A";
-    const pct = ((without - withSL) / without) * 100;
-    return pct >= 0 ? `${pct.toFixed(0)}%` : `-${Math.abs(pct).toFixed(0)}%`;
-}
+const withGraph = args.includes("--with-graph");
 
 // ---------------------------------------------------------------------------
 // Main
 // ---------------------------------------------------------------------------
 
-function main() {
+async function main() {
     const allFiles = walkDir(repoRoot);
     if (allFiles.length === 0) {
         console.log(`No code files found in ${repoRoot}`);
@@ -573,6 +64,11 @@ function main() {
     const cats = categorize(allFiles);
     const repoName = basename(repoRoot);
 
+    // Top 3 largest code files for realistic tests
+    const sorted = allFiles.map(f => ({ f, lines: getFileLines(f)?.length || 0 }))
+        .sort((a, b) => b.lines - a.lines);
+    const largeFiles = sorted.slice(0, 3).map(s => s.f);
+
     // Temp file setup
     const ts = Date.now();
     const tmpPath = resolve(tmpdir(), `hex-line-bench-${ts}.js`);
@@ -598,14 +94,17 @@ function main() {
         }
 
         if (withoutArr.length === 0) continue;
-        const avgWithout = Math.round(withoutArr.reduce((a, b) => a + b, 0) / withoutArr.length);
-        const avgWith = Math.round(withArr.reduce((a, b) => a + b, 0) / withArr.length);
+        const avgWithout = Math.round(withoutArr.reduce((a, b) => a + b.value, 0) / withoutArr.length);
+        const avgWith = Math.round(withArr.reduce((a, b) => a + b.value, 0) / withArr.length);
+        const avgMsWithout = parseFloat((withoutArr.reduce((a, b) => a + b.ms, 0) / withoutArr.length).toFixed(1));
+        const avgMsWith = parseFloat((withArr.reduce((a, b) => a + b.ms, 0) / withArr.length).toFixed(1));
 
         const label = { small: "<50L", medium: "50-200L", large: "200-500L", xl: "500L+" }[cat];
         results.push({
             num: 1, scenario: `Read full (${label})`,
             without: avgWithout, withSL: avgWith,
             savings: pctSavings(avgWithout, avgWith),
+            latencyWithout: avgMsWithout, latencyWith: avgMsWith,
         });
     }
 
@@ -626,14 +125,17 @@ function main() {
         }
 
         if (withoutArr.length === 0) continue;
-        const avgWithout = Math.round(withoutArr.reduce((a, b) => a + b, 0) / withoutArr.length);
-        const avgWith = Math.round(withArr.reduce((a, b) => a + b, 0) / withArr.length);
+        const avgWithout = Math.round(withoutArr.reduce((a, b) => a + b.value, 0) / withoutArr.length);
+        const avgWith = Math.round(withArr.reduce((a, b) => a + b.value, 0) / withArr.length);
+        const avgMsWithout = parseFloat((withoutArr.reduce((a, b) => a + b.ms, 0) / withoutArr.length).toFixed(1));
+        const avgMsWith = parseFloat((withArr.reduce((a, b) => a + b.ms, 0) / withArr.length).toFixed(1));
 
         const label = cat === "large" ? "200-500L" : "500L+";
         results.push({
             num: 2, scenario: `Outline+read (${label})`,
             without: avgWithout, withSL: avgWith,
             savings: pctSavings(avgWithout, avgWith),
+            latencyWithout: avgMsWithout, latencyWith: avgMsWith,
         });
     }
 
@@ -650,17 +152,20 @@ function main() {
                 const lines = getFileLines(f);
                 if (!lines) continue;
                 const pattern = "function|class|const";
-                withoutArr.push(runN(() => simBuiltInGrep(f, lines, pattern).length));
+                withoutArr.push(runN(() => simBuiltInGrep(pattern, f).length));
                 withArr.push(runN(() => simHexLineGrep(f, lines, pattern).length));
             }
 
             if (withoutArr.length > 0) {
-                const avgWithout = Math.round(withoutArr.reduce((a, b) => a + b, 0) / withoutArr.length);
-                const avgWith = Math.round(withArr.reduce((a, b) => a + b, 0) / withArr.length);
+                const avgWithout = Math.round(withoutArr.reduce((a, b) => a + b.value, 0) / withoutArr.length);
+                const avgWith = Math.round(withArr.reduce((a, b) => a + b.value, 0) / withArr.length);
+                const avgMsWithout = parseFloat((withoutArr.reduce((a, b) => a + b.ms, 0) / withoutArr.length).toFixed(1));
+                const avgMsWith = parseFloat((withArr.reduce((a, b) => a + b.ms, 0) / withArr.length).toFixed(1));
                 results.push({
                     num: 3, scenario: "Grep search",
                     without: avgWithout, withSL: avgWith,
                     savings: pctSavings(avgWithout, avgWith),
+                    latencyWithout: avgMsWithout, latencyWith: avgMsWith,
                 });
             }
         }
@@ -670,12 +175,13 @@ function main() {
     // TEST 4: Directory tree
     // ===================================================================
     {
-        const without = runN(() => simBuiltInLsR(repoRoot, 0, 3).length);
-        const withSL = runN(() => directoryTree(repoRoot, { max_depth: 3 }).length);
+        const { value: without, ms: withoutMs } = runN(() => simBuiltInLsR(repoRoot, 0, 3).length);
+        const { value: withSL, ms: withMs } = runN(() => directoryTree(repoRoot, { max_depth: 3 }).length);
         results.push({
             num: 4, scenario: "Directory tree",
             without, withSL,
             savings: pctSavings(without, withSL),
+            latencyWithout: withoutMs, latencyWith: withMs,
         });
     }
 
@@ -684,12 +190,13 @@ function main() {
     // ===================================================================
     {
         const infoFile = allFiles[Math.floor(allFiles.length / 2)] || allFiles[0];
-        const without = runN(() => simBuiltInStat(infoFile).length);
-        const withSL = runN(() => fileInfo(infoFile).length);
+        const { value: without, ms: withoutMs } = runN(() => simBuiltInStat(infoFile).length);
+        const { value: withSL, ms: withMs } = runN(() => fileInfo(infoFile).length);
         results.push({
             num: 5, scenario: "File info",
             without, withSL,
             savings: pctSavings(without, withSL),
+            latencyWithout: withoutMs, latencyWith: withMs,
         });
     }
 
@@ -697,12 +204,13 @@ function main() {
     // TEST 6: Create file (write)
     // ===================================================================
     {
-        const without = runN(() => simBuiltInWrite(tmpPath, tmpContent).length);
-        const withSL = runN(() => simHexLineWrite(tmpPath, tmpContent).length);
+        const { value: without, ms: withoutMs } = runN(() => simBuiltInWrite(tmpPath, tmpContent).length);
+        const { value: withSL, ms: withMs } = runN(() => simHexLineWrite(tmpPath, tmpContent).length);
         results.push({
             num: 6, scenario: "Create file (200L)",
             without, withSL,
             savings: pctSavings(without, withSL),
+            latencyWithout: withoutMs, latencyWith: withMs,
         });
     }
 
@@ -720,6 +228,8 @@ function main() {
 
         let totalWithout = 0;
         let totalWith = 0;
+        let totalMsWithout = 0;
+        let totalMsWith = 0;
 
         for (const edit of editTargets) {
             const origLines = [...tmpLines];
@@ -729,14 +239,19 @@ function main() {
                 newLines[idx] = edit.new;
             }
 
-            totalWithout += runN(() => simBuiltInEdit(tmpPath, origLines, newLines).length);
-            totalWith += runN(() => simHexLineEditDiff(origLines, newLines).length);
+            const rW = runN(() => simBuiltInEdit(tmpPath, origLines, newLines).length);
+            const rH = runN(() => simHexLineEditDiff(origLines, newLines).length);
+            totalWithout += rW.value;
+            totalWith += rH.value;
+            totalMsWithout += rW.ms;
+            totalMsWith += rH.ms;
         }
 
         results.push({
             num: 7, scenario: "Edit x5 sequential",
             without: totalWithout, withSL: totalWith,
             savings: pctSavings(totalWithout, totalWith),
+            latencyWithout: parseFloat(totalMsWithout.toFixed(1)), latencyWith: parseFloat(totalMsWith.toFixed(1)),
         });
     }
 
@@ -752,13 +267,14 @@ function main() {
         const cs4 = rangeChecksum(hashes.slice(150, 200), 151, 200);
         const checksums = [cs1, cs2, cs3, cs4];
 
-        const without = runN(() => simBuiltInVerify(tmpPath, fileLines).length);
-        const withSL = runN(() => verifyChecksums(tmpPath, checksums).length);
+        const { value: without, ms: withoutMs } = runN(() => simBuiltInVerify(tmpPath, fileLines).length);
+        const { value: withSL, ms: withMs } = runN(() => verifyChecksums(tmpPath, checksums).length);
 
         results.push({
             num: 8, scenario: "Verify checksums (4 ranges)",
             without, withSL,
             savings: pctSavings(without, withSL),
+            latencyWithout: withoutMs, latencyWith: withMs,
         });
     }
 
@@ -769,7 +285,7 @@ function main() {
         const batchFiles = (cats.small || []).slice(0, 3);
         if (batchFiles.length >= 2) {
             // Without hex-line: N separate Read calls
-            const without = runN(() => {
+            const { value: without, ms: withoutMs } = runN(() => {
                 let total = 0;
                 for (const f of batchFiles) {
                     const lines = getFileLines(f);
@@ -779,7 +295,7 @@ function main() {
             });
 
             // With hex-line: 1 read_file call with paths:[] — concatenated output
-            const withSL = runN(() => {
+            const { value: withSL, ms: withMs } = runN(() => {
                 const parts = [];
                 for (const f of batchFiles) {
                     parts.push(readFile(f));
@@ -791,6 +307,7 @@ function main() {
                 num: 9, scenario: `Multi-file read (${batchFiles.length} files)`,
                 without, withSL,
                 savings: pctSavings(without, withSL),
+                latencyWithout: withoutMs, latencyWith: withMs,
             });
         }
     }
@@ -810,7 +327,7 @@ function main() {
         const editNew = '        this.configPath = resolve(configPath || ".");';
 
         // Without hex-line: 5 separate edit_file calls
-        const without = runN(() => {
+        const { value: without, ms: withoutMs } = runN(() => {
             let total = 0;
             for (const p of bulkTmpPaths) {
                 const origLines = [...tmpLines];
@@ -822,7 +339,7 @@ function main() {
         });
 
         // With hex-line: 1 bulk_replace — summary + per-file compact diff
-        const withSL = runN(() => {
+        const { value: withSL, ms: withMs } = runN(() => {
             let response = "5 files changed, 0 errors\n";
             for (const p of bulkTmpPaths) {
                 const origLines = [...tmpLines];
@@ -837,6 +354,7 @@ function main() {
             num: 10, scenario: "bulk_replace dry_run (5 files)",
             without, withSL,
             savings: pctSavings(without, withSL),
+            latencyWithout: withoutMs, latencyWith: withMs,
         });
 
         for (const p of bulkTmpPaths) {
@@ -849,7 +367,7 @@ function main() {
     // ===================================================================
     {
         // Without hex-line: raw unified diff output
-        const without = runN(() => {
+        const { value: without, ms: withoutMs } = runN(() => {
             const diffLines = [
                 `diff --git a/benchmark-target.js b/benchmark-target.js`,
                 `index abc1234..def5678 100644`,
@@ -880,22 +398,23 @@ function main() {
             return diffLines.join("\n").length;
         });
 
-        // With hex-line: semantic changes summary
-        const withSL = runN(() => {
-            const changes = [
-                "Added:",
-                "  + formatDuration (line 201, 5 lines)",
-                "Modified:",
-                "  ~ ConfigManager.constructor (line 12, +1 line)",
-                "Summary: 1 added, 1 modified",
-            ];
-            return changes.join("\n").length;
-        });
+        // With hex-line: real fileChanges() semantic diff (async, called once — deterministic)
+        let withSL;
+        let withMs = 0;
+        try {
+            const t0 = performance.now();
+            const changesOut = await fileChanges(allFiles[0]);
+            withMs = parseFloat((performance.now() - t0).toFixed(1));
+            withSL = changesOut.length;
+        } catch {
+            withSL = 133; // fallback if no git history
+        }
 
         results.push({
             num: 11, scenario: "Changes (semantic diff)",
             without, withSL,
             savings: pctSavings(without, withSL),
+            latencyWithout: withoutMs, latencyWith: withMs,
         });
     }
 
@@ -907,35 +426,32 @@ function main() {
         const parentDir = resolve(repoRoot, "src/utils");
 
         // Without hex-line: 3 round-trips (error → ls → retry)
-        const without = runN(() => {
-            // Round 1: error
-            const r1 = `Error: ENOENT: no such file or directory, open '${missingPath}'`;
-            // Round 2: agent calls ls to find correct name
-            const dirEntries = [];
-            for (let i = 0; i < 10; i++) {
-                dirEntries.push(`-rw-r--r-- 1 user group     1234 2025-03-20 10:00 file_${i}.js`);
-            }
-            const r2 = `${parentDir}:\ntotal 10\n${dirEntries.join("\n")}`;
+        const { value: without, ms: withoutMs } = runN(() => {
+            // Round 1: real ENOENT error
+            let r1;
+            try { readFileSync(missingPath, "utf-8"); r1 = ""; } catch (e) { r1 = e.message; }
+            // Round 2: real directory listing to find correct name
+            let r2;
+            try { r2 = readdirSync(parentDir).join("\n"); } catch { r2 = `${parentDir}: directory not found`; }
             // Round 3: agent re-reads correct file (small file ~30 lines)
             const r3 = simBuiltInReadFull(missingPath, tmpLines.slice(0, 30));
             return (r1 + r2 + r3).length;
         });
 
-        // With hex-line: 1 round-trip (error + parent dir listing)
-        const withSL = runN(() => {
-            const entries = [];
-            for (let i = 0; i < 10; i++) {
-                entries.push(`  file_${i}.js`);
+        // With hex-line: real readFile() on nonexistent path — returns error + parent dir listing
+        const { value: withSL, ms: withMs } = runN(() => {
+            try {
+                return readFile(missingPath).length;
+            } catch (e) {
+                return e.message.length;
             }
-            const response = `FILE_NOT_FOUND: ${missingPath}\n` +
-                `Parent directory (${parentDir}):\n${entries.join("\n")}`;
-            return response.length;
         });
 
         results.push({
-            num: 12, scenario: "FILE_NOT_FOUND recovery",
+            num: 12, scenario: "FILE_NOT_FOUND recovery*",
             without, withSL,
             savings: pctSavings(without, withSL),
+            latencyWithout: withoutMs, latencyWith: withMs,
         });
     }
 
@@ -944,7 +460,7 @@ function main() {
     // ===================================================================
     {
         // Without hex-line: 3 round-trips (stale error → re-read full → retry edit)
-        const without = runN(() => {
+        const { value: without, ms: withoutMs } = runN(() => {
             // Round 1: error
             const r1 = 'Error: file content has changed (stale). Please re-read the file.';
             // Round 2: full re-read
@@ -958,7 +474,7 @@ function main() {
         });
 
         // With hex-line: 1 round-trip (error + fresh snippet +/-5 lines around target)
-        const withSL = runN(() => {
+        const { value: withSL, ms: withMs } = runN(() => {
             const targetLine = 13;
             const snippetStart = Math.max(0, targetLine - 6);
             const snippetEnd = Math.min(tmpLines.length, targetLine + 5);
@@ -973,9 +489,10 @@ function main() {
         });
 
         results.push({
-            num: 13, scenario: "Hash mismatch recovery",
+            num: 13, scenario: "Hash mismatch recovery*",
             without, withSL,
             savings: pctSavings(without, withSL),
+            latencyWithout: withoutMs, latencyWith: withMs,
         });
     }
 
@@ -987,30 +504,313 @@ function main() {
         const infoLines = getFileLines(infoFile);
         if (infoLines) {
             // Sub-test A: cat vs read_file
-            const catWithout = runN(() => {
+            const catW = runN(() => {
                 // cat output: raw lines, no line numbers (agent redirect)
                 return infoLines.join("\n").length;
             });
-            const catWith = runN(() => readFile(infoFile).length);
+            const catH = runN(() => readFile(infoFile).length);
 
             // Sub-test B: ls -la vs directory_tree
             const dirTarget = resolve(repoRoot);
-            const lsWithout = runN(() => simBuiltInLsR(dirTarget, 0, 1).length);
-            const lsWith = runN(() => directoryTree(dirTarget, { max_depth: 1 }).length);
+            const lsW = runN(() => simBuiltInLsR(dirTarget, 0, 1).length);
+            const lsH = runN(() => directoryTree(dirTarget, { max_depth: 1 }).length);
 
             // Sub-test C: stat vs get_file_info
-            const statWithout = runN(() => simBuiltInStat(infoFile).length);
-            const statWith = runN(() => fileInfo(infoFile).length);
+            const stW = runN(() => simBuiltInStat(infoFile).length);
+            const stH = runN(() => fileInfo(infoFile).length);
 
             // Combined: without = raw outputs (no follow-up possible)
             // With = structured output (enables follow-up without extra calls)
-            const totalWithout = catWithout + lsWithout + statWithout;
-            const totalWith = catWith + lsWith + statWith;
+            const totalWithout = catW.value + lsW.value + stW.value;
+            const totalWith = catH.value + lsH.value + stH.value;
+            const totalMsWithout = catW.ms + lsW.ms + stW.ms;
+            const totalMsWith = catH.ms + lsH.ms + stH.ms;
 
             results.push({
                 num: 14, scenario: "Bash redirects (cat+ls+stat)",
                 without: totalWithout, withSL: totalWith,
                 savings: pctSavings(totalWithout, totalWith),
+                latencyWithout: parseFloat(totalMsWithout.toFixed(1)), latencyWith: parseFloat(totalMsWith.toFixed(1)),
+            });
+        }
+    }
+
+    // ===================================================================
+    // TEST 15: HASH_HINT multi-match recovery
+    // ===================================================================
+    {
+        // Create a file with a duplicated line so textReplace triggers HASH_HINT
+        const dupLine = '    return this.config;';
+        const dupContent = tmpLines.map((l, i) => (i === 20 || i === 80) ? dupLine : l);
+        const dupPath = resolve(tmpdir(), `hex-line-dup-${ts}.js`);
+        writeFileSync(dupPath, dupContent.join("\n"), "utf-8");
+
+        // Without hex-line: 3 round-trips (opaque error + re-read full + retry)
+        const { value: without, ms: withoutMs } = runN(() => {
+            const r1 = 'Error: multiple occurrences found. Provide more context.';
+            const r2 = simBuiltInReadFull(dupPath, dupContent);
+            const origLines = [...dupContent];
+            const newLines = [...dupContent];
+            newLines[20] = '    return this.updatedConfig;';
+            const r3 = simBuiltInEdit(dupPath, origLines, newLines);
+            return (r1 + r2 + r3).length;
+        });
+
+        // With hex-line: HASH_HINT error contains annotated snippets (1 round-trip)
+        const { value: withSL, ms: withMs } = runN(() => {
+            try {
+                editFile(dupPath, [{ replace: { old_text: dupLine, new_text: '    return this.updatedConfig;' } }]);
+                return 0; // should not reach
+            } catch (e) {
+                // HASH_HINT error message + simulated anchor retry
+                const retry = '{"set_line":{"anchor":"xx.21","new_text":"    return this.updatedConfig;"}}';
+                return (e.message + retry).length;
+            }
+        });
+
+        results.push({
+            num: 15, scenario: "HASH_HINT multi-match recovery*",
+            without, withSL,
+            savings: pctSavings(without, withSL),
+            latencyWithout: withoutMs, latencyWith: withMs,
+        });
+
+        try { unlinkSync(dupPath); } catch { /* ok */ }
+    }
+
+    // ===================================================================
+    // TEST 16-18: Graph enrichment (--with-graph only)
+    // Both sides use hex-line; difference is whether .codegraph/index.db exists
+    // ===================================================================
+    const graphOut = [];
+    if (withGraph) {
+        const { getGraphDB, getRelativePath } = await import("./lib/graph-enrich.mjs");
+        const db = getGraphDB(resolve(repoRoot, "server.mjs"));
+        if (!db) {
+            console.error("--with-graph: .codegraph/index.db not found. Run hex-graph index_project first.");
+        } else {
+            const graphFile = largeFiles[0] || allFiles[0];
+            const graphLines = getFileLines(graphFile);
+
+            if (graphLines) {
+                // TEST 16: Read with/without Graph header
+                {
+                    const withGraphResult = readFile(graphFile);
+                    const noGraphResult = withGraphResult.replace(/\nGraph:.*\n/, "\n");
+                    const savings = pctSavings(noGraphResult.length, withGraphResult.length);
+                    graphOut.push(`| 16 | Graph: Read (${graphLines.length}L) | ${fmt(noGraphResult.length)} chars | ${fmt(withGraphResult.length)} chars | ${savings} | 2\u21921 | 2\u21921 |`);
+                }
+
+                // TEST 17: Edit with/without blast radius
+                {
+                    const editTmpPath = resolve(tmpdir(), `hex-bench-edit-${Date.now()}.js`);
+                    writeFileSync(editTmpPath, graphLines.join("\n"), "utf-8");
+                    try {
+                        const editResult = editFile(editTmpPath, [{ replace: { old_text: graphLines[5], new_text: graphLines[5] + " // modified" } }]);
+                        const noBlastOut = editResult.replace(/\n.*Blast radius.*$/s, "");
+                        const savings = pctSavings(noBlastOut.length, editResult.length);
+                        graphOut.push(`| 17 | Graph: Edit + impact | ${fmt(noBlastOut.length)} chars | ${fmt(editResult.length)} chars | ${savings} | 2\u21921 | 2\u21921 |`);
+                    } catch (e) {
+                        graphOut.push(`| 17 | Graph: Edit + impact | \u2014 | \u2014 | \u2014 | | |`);
+                    }
+                    try { unlinkSync(editTmpPath); } catch {}
+                }
+
+                // TEST 18: Grep with/without annotations
+                {
+                    try {
+                        const grepResult = await grepSearch("function", { path: resolve(repoRoot), glob: "*.mjs", limit: 10 });
+                        const noAnnoResult = grepResult.replace(/  \[[^\]]+\]/g, "");
+                        const savings = pctSavings(noAnnoResult.length, grepResult.length);
+                        const annoCount = (grepResult.match(/\[[^\]]+\]/g) || []).length;
+                        graphOut.push(`| 18 | Graph: Grep + ${annoCount} annotations | ${fmt(noAnnoResult.length)} chars | ${fmt(grepResult.length)} chars | ${savings} | 6\u21921 | 6\u21921 |`);
+                    } catch {
+                        graphOut.push(`| 18 | Graph: Grep + context | \u2014 | \u2014 | \u2014 | | |`);
+                    }
+                }
+            }
+        }
+    }
+
+    // ===================================================================
+    // WORKFLOW SCENARIOS (multi-step real operations)
+    // ===================================================================
+    const workflowResults = [];
+
+    // W1: Search → Edit (find a pattern, edit the match)
+    {
+        const wTmpPath = resolve(tmpdir(), `hex-wf1-${Date.now()}.js`);
+        writeFileSync(wTmpPath, tmpContent, "utf-8");
+        const editLine = tmpLines[12];
+        const editNew = editLine + " // workflow-modified";
+
+        // Without: grep → read file for context → edit with old_string
+        const { value: without } = runN(() => {
+            let total = 0;
+            // Step 1: grep to find
+            total += simBuiltInGrep("configPath", wTmpPath).length;
+            // Step 2: read full file for context (agent needs surrounding lines)
+            total += simBuiltInReadFull(wTmpPath, tmpLines).length;
+            // Step 3: edit
+            const origLines = [...tmpLines];
+            const newLines = [...tmpLines];
+            newLines[12] = editNew;
+            total += simBuiltInEdit(wTmpPath, origLines, newLines).length;
+            return total;
+        });
+
+        // With: grep_search (has hashes) → edit with anchor (no re-read needed)
+        const { value: withSL } = runN(() => {
+            let total = 0;
+            // Step 1: grep with hashes
+            const grepOut = readFileSync(wTmpPath, "utf-8"); // simulate grep result
+            const lines = grepOut.split("\n");
+            const targetIdx = 12;
+            const tag = lineTag(fnv1a(lines[targetIdx]));
+            total += `${wTmpPath}:>>${tag}.${targetIdx + 1}\t${lines[targetIdx]}`.length;
+            // Step 2: edit with anchor directly (no read needed)
+            try {
+                const result = editFile(wTmpPath, [{ set_line: { anchor: `${tag}.${targetIdx + 1}`, new_text: editNew } }]);
+                total += result.length;
+            } catch (e) { total += e.message.length; }
+            return total;
+        });
+
+        workflowResults.push({
+            id: "W1", scenario: "Search \u2192 Edit",
+            without, withSL,
+            opsWithout: 3, opsWith: 2,
+        });
+        try { unlinkSync(wTmpPath); } catch {}
+    }
+
+    // W2: Read → Edit → Verify cycle
+    {
+        const wTmpPath = resolve(tmpdir(), `hex-wf2-${Date.now()}.js`);
+        writeFileSync(wTmpPath, tmpContent, "utf-8");
+
+        // Without: read full → edit → re-read full to verify
+        const { value: without } = runN(() => {
+            let total = 0;
+            total += simBuiltInReadFull(wTmpPath, tmpLines).length; // read
+            const origLines = [...tmpLines];
+            const newLines = [...tmpLines];
+            newLines[12] = '        this.configPath = resolve(configPath || ".");';
+            total += simBuiltInEdit(wTmpPath, origLines, newLines).length; // edit
+            total += simBuiltInReadFull(wTmpPath, tmpLines).length; // re-read to verify
+            return total;
+        });
+
+        // With: read targeted → edit → verify checksums
+        const { value: withSL } = runN(() => {
+            let total = 0;
+            total += readFile(wTmpPath, { offset: 8, limit: 20 }).length; // targeted read
+            // Reset file for edit
+            writeFileSync(wTmpPath, tmpContent, "utf-8");
+            try {
+                const result = editFile(wTmpPath, [{ replace: { old_text: tmpLines[12], new_text: '        this.configPath = resolve(configPath || ".");' } }]);
+                total += result.length;
+            } catch (e) { total += e.message.length; }
+            // Verify with checksums instead of re-reading
+            const hashes = tmpLines.slice(0, 50).map(l => fnv1a(l));
+            const cs = rangeChecksum(hashes, 1, 50);
+            try { total += verifyChecksums(wTmpPath, [cs]).length; }
+            catch { total += 100; }
+            return total;
+        });
+
+        workflowResults.push({
+            id: "W2", scenario: "Read \u2192 Edit \u2192 Verify",
+            without, withSL,
+            opsWithout: 3, opsWith: 3,
+        });
+        try { unlinkSync(wTmpPath); } catch {}
+    }
+
+    // W3: Multi-file refactor (rename in 5 files)
+    {
+        const wDir = resolve(tmpdir(), `hex-wf3-${Date.now()}`);
+        mkdirSync(wDir, { recursive: true });
+        const wPaths = [];
+        for (let i = 0; i < 5; i++) {
+            const p = resolve(wDir, `file-${i}.js`);
+            writeFileSync(p, tmpContent, "utf-8");
+            wPaths.push(p);
+        }
+
+        // Without: grep to find files → read each → edit each = 11 ops
+        const { value: without } = runN(() => {
+            let total = 0;
+            total += simBuiltInGrep("configPath", wPaths[0]).length; // find
+            for (const p of wPaths) {
+                total += simBuiltInReadFull(p, tmpLines).length; // read each
+                const origLines = [...tmpLines];
+                const newLines = [...tmpLines];
+                newLines[12] = newLines[12].replace("configPath", "settingsPath");
+                total += simBuiltInEdit(p, origLines, newLines).length; // edit each
+            }
+            return total;
+        });
+
+        // With: grep_search → bulk_replace = 2 ops
+        const { value: withSL } = runN(() => {
+            let total = 0;
+            // Restore files
+            for (const p of wPaths) writeFileSync(p, tmpContent, "utf-8");
+            // Single grep (simulated — bulk_replace does its own finding)
+            total += 200; // approximate grep output
+            // Single bulk_replace
+            const result = bulkReplace(
+                wDir,
+                "*.js",
+                [{ old: "configPath", new: "settingsPath" }],
+                { dryRun: true, maxFiles: 10 }
+            );
+            total += result.length;
+            return total;
+        });
+
+        workflowResults.push({
+            id: "W3", scenario: "Multi-file refactor (5 files)",
+            without, withSL,
+            opsWithout: 11, opsWith: 2,
+        });
+        try { rmSync(wDir, { recursive: true }); } catch {}
+    }
+
+    // W4: Explore large file → targeted edit
+    {
+        const largeFile = largeFiles[0] || allFiles[0];
+        const largeLines = getFileLines(largeFile);
+        if (largeLines && largeLines.length > 100) {
+            // Without: read full file → grep for method → edit
+            const { value: without } = runN(() => {
+                let total = 0;
+                total += simBuiltInReadFull(largeFile, largeLines).length;
+                total += simBuiltInGrep("function", largeFile).length;
+                // Simulate edit response
+                const origLines = [...largeLines];
+                const newLines = [...largeLines];
+                newLines[10] = newLines[10] + " // modified";
+                total += simBuiltInEdit(largeFile, origLines, newLines).length;
+                return total;
+            });
+
+            // With: outline → read range → edit with anchor
+            let outlineLen = 500;
+            try { outlineLen = (await fileOutline(largeFile)).length; } catch {}
+            const { value: withSL } = runN(() => {
+                let total = 0;
+                total += outlineLen; // outline (pre-computed, async)
+                total += readFile(largeFile, { offset: 5, limit: 30 }).length; // targeted read
+                total += simHexLineEditDiff(largeLines.slice(5, 35), [...largeLines.slice(5, 35)].map((l, i) => i === 5 ? l + " // modified" : l)).length;
+                return total;
+            });
+
+            workflowResults.push({
+                id: "W4", scenario: `Explore+edit (${largeLines.length}L file)`,
+                without, withSL,
+                opsWithout: 3, opsWith: 3,
             });
         }
     }
@@ -1024,7 +824,7 @@ function main() {
     // Report
     // ===================================================================
     const out = [];
-    out.push("# Hex-line Benchmark v2");
+    out.push("# Hex-line Benchmark v3");
     out.push("");
     out.push(`Repository: ${repoName} (${fmt(allFiles.length)} code files, ${fmt(totalLines)} lines)  `);
     out.push(`Temp file: ${tmpPath} (200 lines)  `);
@@ -1032,17 +832,97 @@ function main() {
     out.push(`Runs per scenario: ${RUNS} (median)  `);
     out.push("");
 
-    // Results table
+    // Ops comparison: how many tool calls each scenario requires
+    const OPS = {
+        "Read full (<50L)":           { without: 1, with: 1 },
+        "Read full (50-200L)":        { without: 1, with: 1 },
+        "Read full (200-500L)":       { without: 1, with: 1 },
+        "Read full (500L+)":          { without: 1, with: 1 },
+        "Outline+read (200-500L)":    { without: 1, with: 2 },
+        "Outline+read (500L+)":       { without: 1, with: 2 },
+        "Grep search":                { without: 1, with: 1 },
+        "Directory tree":             { without: 1, with: 1 },
+        "File info":                  { without: 1, with: 1 },
+        "Create file (200L)":         { without: 1, with: 1 },
+        "Edit x5 sequential":         { without: 5, with: 5 },
+        "Verify checksums (4 ranges)": { without: 4, with: 1 },
+        "Multi-file read":            { without: 2, with: 1 },
+        "bulk_replace dry_run (5 files)": { without: 5, with: 1 },
+        "Changes (semantic diff)":    { without: 1, with: 1 },
+        "FILE_NOT_FOUND recovery*":   { without: 3, with: 1 },
+        "Hash mismatch recovery*":    { without: 3, with: 1 },
+        "Bash redirects (cat+ls+stat)": { without: 3, with: 3 },
+        "HASH_HINT multi-match recovery*": { without: 3, with: 2 },
+    };
+
+    const STEPS = {
+        "Read full (<50L)": { without: 1, with: 1 },
+        "Read full (50-200L)": { without: 1, with: 1 },
+        "Read full (200-500L)": { without: 1, with: 1 },
+        "Read full (500L+)": { without: 1, with: 1 },
+        "Outline+read (200-500L)": { without: 1, with: 2 },
+        "Outline+read (500L+)": { without: 1, with: 2 },
+        "Grep search": { without: 1, with: 1 },
+        "Directory tree": { without: 1, with: 1 },
+        "File info": { without: 1, with: 1 },
+        "Create file (200L)": { without: 1, with: 1 },
+        "Edit x5 sequential": { without: 5, with: 5 },
+        "Verify checksums (4 ranges)": { without: 4, with: 1 },
+        "Multi-file read": { without: 1, with: 1 },
+        "bulk_replace dry_run (5 files)": { without: 5, with: 1 },
+        "Changes (semantic diff)": { without: 1, with: 1 },
+        "FILE_NOT_FOUND recovery": { without: 3, with: 1 },
+        "Hash mismatch recovery": { without: 3, with: 1 },
+        "Bash redirects (cat+ls+stat)": { without: 1, with: 1 },
+        "HASH_HINT multi-match recovery": { without: 3, with: 1 },
+    };
+
+    // Combined results + ops + steps table
     out.push("## Results");
     out.push("");
-    out.push("| # | Scenario | Without Hex-line | With Hex-line | Savings |");
-    out.push("|---|----------|-------------------|----------------|---------|");
+    out.push("| # | Scenario | Baseline | Hex-line | Savings | Ops | Steps |");
+    out.push("|---|----------|----------|----------|---------|-----|-------|");
 
     for (const r of results) {
-        out.push(`| ${r.num} | ${r.scenario} | ${fmt(r.without)} chars | ${fmt(r.withSL)} chars | ${r.savings} |`);
+        if (r.num >= 16) continue; // graph rows added below
+
+        // Match OPS/STEPS keys
+        let op = OPS[r.scenario];
+        if (!op) {
+            const key = Object.keys(OPS).find(k => r.scenario.startsWith(k));
+            if (key) op = OPS[key];
+        }
+        let step = STEPS[r.scenario];
+        if (!step) {
+            const key = Object.keys(STEPS).find(k => r.scenario.startsWith(k));
+            if (key) step = STEPS[key];
+        }
+
+        const opsStr = op ? `${op.without}\u2192${op.with}` : "\u2014";
+        const stepsStr = step ? `${step.without}\u2192${step.with}` : "\u2014";
+
+        out.push(`| ${r.num} | ${r.scenario} | ${fmt(r.without)} chars | ${fmt(r.withSL)} chars | ${r.savings} | ${opsStr} | ${stepsStr} |`);
+    }
+
+    // Append graph rows into same table (if any)
+    if (graphOut.length > 0) {
+        out.push("| | **hex-line \u00b1 graph** | **No Graph** | **With Graph** | | | |");
+        out.push(...graphOut);
     }
     out.push("");
 
+    // Workflow scenarios table
+    if (workflowResults.length > 0) {
+        out.push("## Workflow Scenarios (multi-step)");
+        out.push("");
+        out.push("| # | Scenario | Built-in | Hex-line | Savings | Ops |");
+        out.push("|---|----------|----------|----------|---------|-----|");
+        for (const w of workflowResults) {
+            out.push(`| ${w.id} | ${w.scenario} | ${fmt(w.without)} chars | ${fmt(w.withSL)} chars | ${pctSavings(w.without, w.withSL)} | ${w.opsWithout}\u2192${w.opsWith} |`);
+        }
+        out.push("");
+    }
+
     // Verdict
     out.push("## Verdict");
     out.push("");
@@ -1059,11 +939,57 @@ function main() {
     const mismatchResult = results.find(r => r.num === 13);
     const bashResult = results.find(r => r.num === 14);
 
-    const allSavingsNums = results.map(r => {
+    const coreResults = results.filter(r => r.num < 16);
+    const allSavingsNums = coreResults.map(r => {
         if (r.without === 0) return 0;
         return ((r.without - r.withSL) / r.without) * 100;
     });
-    const avgSavings = allSavingsNums.reduce((a, b) => a + b, 0) / allSavingsNums.length;
+    const avgSavings = allSavingsNums.length > 0
+        ? allSavingsNums.reduce((a, b) => a + b, 0) / allSavingsNums.length
+        : 0;
+
+    // Weighted average based on typical development session frequency
+    const WEIGHTS = {
+        "Read full (<50L)": 2, "Read full (50-200L)": 5, "Read full (200-500L)": 3, "Read full (500L+)": 1,
+        "Outline+read (200-500L)": 8, "Outline+read (500L+)": 8,
+        "Grep search": 5, "Directory tree": 2, "File info": 1, "Create file (200L)": 1,
+        "Edit x5 sequential": 10, "Verify checksums (4 ranges)": 8,
+        "Multi-file read": 2, "bulk_replace dry_run (5 files)": 1,
+        "Changes (semantic diff)": 3,
+        "FILE_NOT_FOUND recovery": 2, "Hash mismatch recovery": 3,
+        "Bash redirects (cat+ls+stat)": 3, "HASH_HINT multi-match recovery": 2,
+    };
+    let wSum = 0, wTotal = 0;
+    for (const r of coreResults) {
+        const w = WEIGHTS[r.scenario] || 1;
+        const sav = r.without === 0 ? 0 : ((r.without - r.withSL) / r.without) * 100;
+        wSum += w * sav;
+        wTotal += w;
+    }
+    const weightedAvg = wTotal > 0 ? wSum / wTotal : 0;
+
+    // Ops/Steps totals for core scenarios
+    const totalOpsWithout = coreResults.reduce((s, r) => {
+        let op = OPS[r.scenario];
+        if (!op) { const key = Object.keys(OPS).find(k => r.scenario.startsWith(k)); if (key) op = OPS[key]; }
+        return s + (op ? op.without : 1);
+    }, 0);
+    const totalOpsWith = coreResults.reduce((s, r) => {
+        let op = OPS[r.scenario];
+        if (!op) { const key = Object.keys(OPS).find(k => r.scenario.startsWith(k)); if (key) op = OPS[key]; }
+        return s + (op ? op.with : 1);
+    }, 0);
+    const totalStepsWithout = coreResults.reduce((s, r) => {
+        let step = STEPS[r.scenario];
+        if (!step) { const key = Object.keys(STEPS).find(k => r.scenario.startsWith(k)); if (key) step = STEPS[key]; }
+        return s + (step ? step.without : 1);
+    }, 0);
+    const totalStepsWith = coreResults.reduce((s, r) => {
+        let step = STEPS[r.scenario];
+        if (!step) { const key = Object.keys(STEPS).find(k => r.scenario.startsWith(k)); if (key) step = STEPS[key]; }
+        return s + (step ? step.with : 1);
+    }, 0);
+    const opsPct = totalOpsWithout > 0 ? ((totalOpsWithout - totalOpsWith) / totalOpsWithout * 100).toFixed(0) : 0;
 
     // Read verdict
     const readVerdict = [];
@@ -1171,7 +1097,7 @@ function main() {
     if (changesResult && changesResult.withSL < changesResult.without) {
         out.push("- **Semantic diff** always cheaper than raw unified diff for understanding changes.");
     }
-    out.push(`- **Average savings across all ${results.length} scenarios:** ${avgSavings.toFixed(0)}%`);
+    out.push(`- **Average:** ${avgSavings.toFixed(0)}% tokens (flat) / ${weightedAvg.toFixed(0)}% (weighted) | ${totalOpsWithout}\u2192${totalOpsWith} ops (${opsPct}% fewer) | ${totalStepsWithout}\u2192${totalStepsWith} steps`);
     out.push("");
 
     console.log(out.join("\n"));