@stalfh233/omc-cli 0.0.0-stage → 0.4.0

package/dist/bench/instrument.js

@@ -0,0 +1,87 @@
+import { Buffer } from "node:buffer";
+export class WireTap {
+    records = [];
+    wrap(http) {
+        return {
+            request: async (input) => {
+                const response = await http.request(input);
+                if (process.env.OMC_BENCH_TRACE)
+                    console.error(`[trace] ${input.method ?? "GET"} ${input.path} q=${JSON.stringify(input.query ?? {})} b=${input.body ? JSON.stringify(input.body).slice(0, 120) : ""}`);
+                this.records.push({
+                    path: input.path,
+                    method: input.method,
+                    status: response.status,
+                    responseBytes: Buffer.byteLength(JSON.stringify(response.body) ?? "null"),
+                });
+                return response;
+            },
+        };
+    }
+    total() {
+        return this.records.length;
+    }
+    duplicateCalls() {
+        // Extra calls to a path already hit before (second-and-later occurrences).
+        const seen = new Set();
+        let duplicates = 0;
+        for (const record of this.records) {
+            if (seen.has(record.path))
+                duplicates += 1;
+            else
+                seen.add(record.path);
+        }
+        return duplicates;
+    }
+    pathStats() {
+        const byPath = new Map();
+        for (const record of this.records) {
+            const entry = byPath.get(record.path) ?? { count: 0, responseBytes: 0 };
+            entry.count += 1;
+            entry.responseBytes += record.responseBytes;
+            byPath.set(record.path, entry);
+        }
+        return [...byPath.entries()]
+            .map(([path, entry]) => ({ path, count: entry.count, responseBytes: entry.responseBytes }))
+            .sort((a, b) => b.count - a.count || a.path.localeCompare(b.path));
+    }
+}
+export class ToolTap {
+    records = [];
+    /** Wrap a registry so every handler invocation is counted. */
+    wrapRegistry(registry) {
+        return registry.map((tool) => ({
+            ...tool,
+            handler: async (ctx, args, self) => {
+                const started = performance.now();
+                const result = (await tool.handler(ctx, args, self));
+                const record = {
+                    tool: tool.name,
+                    status: String(result?.status ?? "ok"),
+                    ok: result?.status === undefined || result.status === "ok",
+                    durationMs: performance.now() - started,
+                    responseBytes: Buffer.byteLength(JSON.stringify(result) ?? "null"),
+                };
+                this.records.push(record);
+                return result;
+            },
+        }));
+    }
+    responseBytesTotal() {
+        return this.records.reduce((sum, record) => sum + record.responseBytes, 0);
+    }
+}
+/** The tools-list payload size for a registry (name + description + inputSchema, JSON serialized). */
+export function toolsListBytes(registry) {
+    const payload = {
+        tools: registry.map((tool) => ({
+            name: tool.name,
+            description: tool.description,
+            inputSchema: {
+                type: "object",
+                properties: Object.fromEntries(Object.entries(tool.inputSchema).map(([key, schema]) => [key, { description: schema.description }])),
+            },
+        })),
+    };
+    return Buffer.byteLength(JSON.stringify(payload));
+}
+//# sourceMappingURL=instrument.js.map

package/dist/bench/intent-face-eval.js

@@ -0,0 +1,343 @@
+import { spawn } from "node:child_process";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { startFakeHttpServer } from "./fake-http-server.js";
+/**
+ * Intent-face eval (Spec 107 acceptance): the SAME scripted reference-agent
+ * task set as the call-face eval, driven through the declarative face
+ * (intent validate/plan/apply/readback) with `omc call` as the escape
+ * hatch for uncovered capabilities. Metrics are measured with the SAME
+ * accounting (subprocess per invocation, bytes/4 token proxy) so the two
+ * faces compare apples-to-apples against eval/call-face-baseline.json.
+ */
+const packageRoot = fileURLToPath(new URL("../..", import.meta.url));
+const cli = join(packageRoot, "dist", "cli.js");
+function ok(condition, message) {
+    if (!condition)
+        throw new Error(message);
+}
+async function makeAgent(home, metric) {
+    const env = { ...process.env, OMC_CONFIG_HOME: home };
+    const base = {
+        env: env,
+        async run(args) {
+            metric.cliInvocations += 1;
+            if (args[0] === "call")
+                metric.callInvocations += 1;
+            else if (args[0] === "intent")
+                metric.intentInvocations += 1;
+            else
+                metric.discoveryInvocations += 1;
+            const argsJson = args.find((token) => token.startsWith("{"));
+            metric.requestBytes += argsJson ? Buffer.byteLength(argsJson) : args.filter((token) => !token.startsWith("--")).join(" ").length;
+            return await new Promise((resolveRun, rejectRun) => {
+                const child = spawn(process.execPath, [cli, ...args], { cwd: home, env, stdio: ["pipe", "pipe", "pipe"] });
+                let stdout = "";
+                let stderr = "";
+                child.stdout.on("data", (chunk) => (stdout += chunk.toString("utf8")));
+                child.stderr.on("data", (chunk) => (stderr += chunk.toString("utf8")));
+                child.on("error", rejectRun);
+                child.on("close", (code) => {
+                    metric.responseBytes += Buffer.byteLength(stdout);
+                    let envelope;
+                    try {
+                        envelope = JSON.parse(stdout);
+                    }
+                    catch (error) {
+                        rejectRun(new Error(`stdout is not a single JSON envelope (${String(code)}): ${stdout.slice(0, 200)}\nstderr=${stderr.slice(0, 200)} ${error.message}`));
+                        return;
+                    }
+                    if (code === 13)
+                        metric.expectedApprovalExits += 1;
+                    else if (code !== 0)
+                        metric.errorExits += 1;
+                    resolveRun({ code, envelope });
+                });
+            });
+        },
+    };
+    const agent = {
+        ...base,
+        async write(args) {
+            const tool = args.__tool;
+            const payload = { ...args };
+            delete payload.__tool;
+            const argsFlag = JSON.stringify(payload);
+            const callArgs = ["call", tool, "--env", "eval", "--args", argsFlag];
+            const executed = await base.run(callArgs);
+            ok(executed.envelope.result?.status === "ok", `execute phase (${tool}): ${JSON.stringify(executed.envelope).slice(0, 260)}`);
+            return executed.envelope.result;
+        },
+        async read(tool, args) {
+            const result = await base.run(["call", tool, "--env", "eval", "--args", JSON.stringify(args)]);
+            ok(result.envelope.ok === true, `read ${tool}: ${JSON.stringify(result.envelope).slice(0, 220)}`);
+            return result.envelope.result;
+        },
+        async discovery(kind, value) {
+            const result = await base.run(value === undefined ? [kind, ...(kind === "commands" ? ["--json"] : [])] : [kind, value]);
+            ok(result.envelope.ok === true, `discovery ${kind}: ${JSON.stringify(result.envelope).slice(0, 220)}`);
+            return result.envelope.result;
+        },
+        writeIntent(name, yaml) {
+            // The agent authors the declarative file itself — its bytes are agent
+            // output, so they count into the token proxy exactly like composed
+            // --args payloads did on the call face.
+            metric.requestBytes += Buffer.byteLength(yaml);
+            const file = join(home, name);
+            writeFileSync(file, yaml);
+            return file;
+        },
+        async intentValidate(file) {
+            const result = await base.run(["intent", "validate", file]);
+            return result.envelope.result;
+        },
+        async intentPlan(file) {
+            // The documented lean route (intent/cli.ts lifecycle): `--plan-out` writes
+            // the byte-identical ~11 KB plan to a file in the config root and returns
+            // only the decision fields (~1 KB). Inlining the plan charged the agent's
+            // window on every later turn; the reference agent must use the cheap face.
+            const planOut = join(home, `plan-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.json`);
+            const result = await base.run(["intent", "plan", file, "--env", "eval", "--plan-out", planOut]);
+            ok(result.envelope.ok === true, `intent plan: ${JSON.stringify(result.envelope).slice(0, 300)}`);
+            return { plan: result.envelope.result, planFile: planOut };
+        },
+        async intentApply(planFile) {
+            const result = await base.run(["intent", "apply", planFile]);
+            return result.envelope.result;
+        },
+        async intentReadback(file) {
+            const result = await base.run(["intent", "readback", file, "--env", "eval"]);
+            ok(result.envelope.ok === true, `intent readback: ${JSON.stringify(result.envelope).slice(0, 300)}`);
+            return result.envelope.result;
+        },
+        counts: () => metric,
+    };
+    return agent;
+}
+function freshHome(url) {
+    const home = mkdtempSync(join(packageRoot, ".intent-face-eval-"));
+    mkdirSync(home, { recursive: true });
+    writeFileSync(join(home, "omc.config.json"), JSON.stringify({ environments: { eval: { baseUrl: url, applicationCode: "test", isDefault: true, writable: true } } }));
+    writeFileSync(join(home, "credentials"), JSON.stringify({ eval: { username: "tester", password: "eval-face-password" } }));
+    return home;
+}
+const LADDER_INTENT = `intentVersion: 1
+models:
+  - code: eval_m1
+    name: 评测建模
+    fields:
+      - code: f_title
+        name: 标题
+        type: SHORT_TEXT
+      - code: f_amount
+        name: 金额
+        type: NUMERICAL
+        options:
+          scale: 3
+      - code: f_when
+        name: 日期
+        type: DATE
+    form:
+      publish: true
+`;
+export const INTENT_FACE_TASKS = [
+    {
+        id: "usable-model-ladder",
+        description: "model + 3 fields + field publish + form draft/publish + verified readback (Spec 107 first slice, via the intent face)",
+        async run(agent) {
+            const inventory = await agent.discovery("commands");
+            ok(inventory.intent?.intentVersion === 1, "commands inventory lacks the intent face block");
+            const file = agent.writeIntent("intent.yaml", LADDER_INTENT);
+            const validated = await agent.intentValidate(file);
+            ok(validated.valid === true, `validate: ${JSON.stringify(validated).slice(0, 220)}`);
+            const { plan, planFile } = await agent.intentPlan(file);
+            ok(plan.changesCount === 7 && plan.riskClass === "lifecycle", `plan changes=${JSON.stringify(plan.changeSummary)}`);
+            const applied = await agent.intentApply(planFile);
+            ok(applied.status === "ok" && applied.applied === 7, `apply: ${JSON.stringify(applied).slice(0, 260)}`);
+            const readback = await agent.intentReadback(file);
+            ok(readback.equivalent === true && readback.differences.length === 0, `readback: ${JSON.stringify(readback.differences).slice(0, 260)}`);
+        },
+    },
+    {
+        id: "rule-backfill-ladder",
+        description: "two models via intent + DYNAMIC backfill rule + enable + trigger row + verified target readback (mixed face: intent + escape hatch)",
+        async run(agent, server) {
+            const modelsIntent = agent.writeIntent("models.yaml", `intentVersion: 1
+models:
+  - code: eval_rs
+    name: 回填源
+  - code: eval_rt
+    name: 回填目标
+`);
+            await agent.intentValidate(modelsIntent);
+            const { plan, planFile } = await agent.intentPlan(modelsIntent);
+            const applied = await agent.intentApply(planFile);
+            ok(applied.status === "ok" && applied.applied === 2, `models apply: ${JSON.stringify(applied).slice(0, 260)}`);
+            // Uncovered capability: the businessrule graph goes through the escape
+            // hatch (omc call) under the same governance.
+            await agent.discovery("contract", "B1-businessrule");
+            server.fake.seedDataRow("eval_rt", { latestPeriod: "" }, "eval_rt_row");
+            await agent.write({
+                __tool: "rule.save",
+                schemaCode: "eval_rs",
+                ruleCode: "Create",
+                name: "回填",
+                nodeGraph: {
+                    nodes: [
+                        { nodeCode: "Start", nodeType: "START" },
+                        {
+                            nodeCode: "UPDATE_1",
+                            nodeType: "UPDATE",
+                            targetObjectCode: "eval_rt",
+                            inputParam: "_input",
+                            filterCondition: { mainConditions: [[{ targetSchemaDataItem: "id", ruleConditionType: "EQ", ruleValueType: "DYNAMIC", currentSchemaDataItem: "project" }]], sheetConditions: [] },
+                            dataActions: [{ targetDataItem: "latestPeriod", ruleValueType: "DYNAMIC", value: "", ruleActionType: "EQUALS", currentDataItemValue: "declarePeriod" }],
+                        },
+                        { nodeCode: "End", nodeType: "END" },
+                    ],
+                    routes: [{ preNode: "Start", postNode: "UPDATE_1" }, { preNode: "UPDATE_1", postNode: "End" }],
+                },
+            });
+            await agent.write({ __tool: "rule.enable", schemaCode: "eval_rs", ruleCode: "Create" });
+            await agent.write({ __tool: "data.save", schemaCode: "eval_rs", formData: { declarePeriod: "202612", project: { id: "eval_rt_row" } } });
+            const target = await agent.read("data.load", { schemaCode: "eval_rt", bizObjectId: "eval_rt_row" });
+            ok(target.data?.latestPeriod === "202612", `backfill=${String(target.data?.latestPeriod)}`);
+        },
+    },
+    {
+        id: "input-error-recovery",
+        description: "bad intent -> validate exit 10 with source location -> fix -> plan/apply -> idempotent re-plan/re-apply with zero duplicate wires",
+        async run(agent, server) {
+            const bad = agent.writeIntent("intent.yaml", `intentVersion: 1
+models:
+  - code: eval_idem
+    name: 幂等模型
+    fields:
+      - code: f_bad
+        name: 坏类型
+        type: HOLOGRAM
+`);
+            const rejected = await agent.run(["intent", "validate", bad]);
+            ok(rejected.code === 10 && rejected.envelope.error?.code === "invalid-input", `expected invalid-input exit 10, got ${String(rejected.code)}`);
+            const first = rejected.envelope.result.errors[0];
+            ok(first.code === "intent-field-type-unknown" && typeof first.line === "number", `located error: ${JSON.stringify(first).slice(0, 200)}`);
+            const fixed = agent.writeIntent("intent.yaml", `intentVersion: 1
+models:
+  - code: eval_idem
+    name: 幂等模型
+    fields:
+      - code: f_bad
+        name: 改正的字段
+        type: SHORT_TEXT
+`);
+            const validated = await agent.intentValidate(fixed);
+            ok(validated.valid === true, `fixed validate: ${JSON.stringify(validated).slice(0, 200)}`);
+            const { plan, planFile } = await agent.intentPlan(fixed);
+            const applied = await agent.intentApply(planFile);
+            ok(applied.status === "ok", `apply: ${JSON.stringify(applied).slice(0, 260)}`);
+            const createWires = server.fake.bodiesFor("/api/api/app/bizmodels/create").length;
+            ok(createWires === 1, `expected exactly one create wire, got ${String(createWires)}`);
+            // Idempotent convergence: re-plan -> zero changes; re-apply -> no-op.
+            const recheck = await agent.intentPlan(fixed);
+            ok(recheck.plan.changesCount === 0, `re-plan changes: ${JSON.stringify(recheck.plan.changeSummary)}`);
+            const reapplied = await agent.intentApply(recheck.planFile);
+            ok(reapplied.status === "ok" && reapplied.applied === 0, `re-apply: ${JSON.stringify(reapplied).slice(0, 260)}`);
+            ok(server.fake.bodiesFor("/api/api/app/bizmodels/create").length === 1, "idempotent re-apply must not send a second create wire");
+            const readback = await agent.intentReadback(fixed);
+            ok(readback.equivalent === true, `readback: ${JSON.stringify(readback.differences).slice(0, 200)}`);
+        },
+    },
+    {
+        id: "read-exploration",
+        description: "discovery-driven read exploration: commands -> describe -> contract -> filtered data.list projection (escape hatch reads)",
+        async run(agent, server) {
+            const inventory = await agent.discovery("commands");
+            const listTool = inventory.tools.find((tool) => tool.name === "data.list");
+            ok(listTool !== undefined, "data.list not discoverable");
+            await agent.discovery("describe", "data.list");
+            server.fake.seedField("eval_ro", "name", 0);
+            server.fake.seedDataRow("eval_ro", { name: "命中", state: "DRAFT" }, "eval_ro_hit");
+            server.fake.seedDataRow("eval_ro", { name: "未命中", state: "DRAFT" }, "eval_ro_miss");
+            await agent.write({ __tool: "listview.configure", schemaCode: "eval_ro", fieldCodes: ["name"] });
+            const listed = await agent.read("data.list", { schemaCode: "eval_ro", filter: { op: "eq", field: "name", value: "命中" } });
+            const items = (listed.items ?? []);
+            ok(items.length === 1 && items[0]?.fields?.name === "命中", `filtered projection wrong: ${JSON.stringify(items).slice(0, 160)}`);
+        },
+    },
+];
+export async function runIntentFaceEvals(options = {}) {
+    const tasks = options.only ? INTENT_FACE_TASKS.filter((task) => task.id === options.only) : INTENT_FACE_TASKS;
+    if (tasks.length === 0)
+        throw new Error(`no intent-face task matches ${options.only}`);
+    const results = [];
+    for (const task of tasks) {
+        const server = await startFakeHttpServer();
+        const home = freshHome(server.url);
+        const metric = { cliInvocations: 0, discoveryInvocations: 0, intentInvocations: 0, callInvocations: 0, approvalRounds: 0, errorExits: 0, expectedApprovalExits: 0, requestBytes: 0, responseBytes: 0 };
+        const startedAt = Date.now();
+        let businessWireCalls = 0;
+        let failure;
+        try {
+            const agent = await makeAgent(home, metric);
+            await task.run(agent, server);
+        }
+        catch (error) {
+            failure = error instanceof Error ? error.message : String(error);
+        }
+        finally {
+            businessWireCalls = server.fake.state.callLog.filter((entry) => !entry.path.startsWith("/user/") && !entry.path.startsWith("/api/public/") && !entry.path.startsWith("/api/api/organization/")).length;
+            await server.close();
+            rmSync(home, { recursive: true, force: true });
+        }
+        results.push({
+            id: task.id,
+            passed: failure === undefined,
+            ...(failure ? { error: failure } : {}),
+            cliInvocations: metric.cliInvocations,
+            discoveryInvocations: metric.discoveryInvocations,
+            intentInvocations: metric.intentInvocations,
+            callInvocations: metric.callInvocations,
+            approvalRounds: metric.approvalRounds,
+            errorExits: metric.errorExits,
+            expectedApprovalExits: metric.expectedApprovalExits,
+            requestBytes: metric.requestBytes,
+            responseBytes: metric.responseBytes,
+            estimatedTokens: Math.round((metric.requestBytes + metric.responseBytes) / 4),
+            businessWireCalls,
+            wallClockMs: Date.now() - startedAt,
+        });
+    }
+    const sum = (pick) => results.reduce((total, entry) => total + pick(entry), 0);
+    return {
+        schema: "omc-intent-face-eval-v1",
+        face: "intent",
+        generatedAt: new Date().toISOString(),
+        tasks: results,
+        aggregate: {
+            tasksTotal: results.length,
+            tasksPassed: results.filter((entry) => entry.passed).length,
+            successRate: results.length === 0 ? 0 : Math.round((results.filter((entry) => entry.passed).length / results.length) * 10000) / 10000,
+            cliInvocations: sum((entry) => entry.cliInvocations),
+            discoveryInvocations: sum((entry) => entry.discoveryInvocations),
+            intentInvocations: sum((entry) => entry.intentInvocations),
+            callInvocations: sum((entry) => entry.callInvocations),
+            approvalRounds: sum((entry) => entry.approvalRounds),
+            errorExits: sum((entry) => entry.errorExits),
+            expectedApprovalExits: sum((entry) => entry.expectedApprovalExits),
+            requestBytes: sum((entry) => entry.requestBytes),
+            responseBytes: sum((entry) => entry.responseBytes),
+            estimatedTokens: sum((entry) => entry.estimatedTokens),
+            businessWireCalls: sum((entry) => entry.businessWireCalls),
+        },
+    };
+}
+export function formatIntentFaceReport(report) {
+    const lines = [
+        `omc intent-face eval — ${report.aggregate.tasksPassed}/${report.aggregate.tasksTotal} tasks passed (successRate=${report.aggregate.successRate})`,
+        ...report.tasks.map((task) => `  ${task.passed ? "PASS" : "FAIL"} ${task.id} — cli=${task.cliInvocations} (intent=${task.intentInvocations}/call=${task.callInvocations}/discovery=${task.discoveryInvocations}) approvals=${task.approvalRounds} errExits=${task.errorExits} wires=${task.businessWireCalls} tokens≈${task.estimatedTokens} ${task.wallClockMs}ms${task.error ? `\n    ${task.error}` : ""}`),
+        `aggregate: cli=${report.aggregate.cliInvocations} (intent=${report.aggregate.intentInvocations}/call=${report.aggregate.callInvocations}/discovery=${report.aggregate.discoveryInvocations}) approvals=${report.aggregate.approvalRounds} errExits=${report.aggregate.errorExits} wires=${report.aggregate.businessWireCalls} tokens≈${report.aggregate.estimatedTokens}`,
+    ];
+    return lines.join("\n");
+}
+//# sourceMappingURL=intent-face-eval.js.map

package/dist/bench/run.js

@@ -0,0 +1,166 @@
+import { mkdirSync, readFileSync, writeFileSync, existsSync, renameSync } from "node:fs";
+import { flattenMetrics, computeDelta } from "./types.js";
+import { makeBenchHarness } from "./driver.js";
+import { runScenario } from "./scenario.js";
+import { runGoldenEvals } from "./evals.js";
+import { toolsListBytes } from "./instrument.js";
+import { wireReadCacheStats } from "../wire.js";
+/** Where the scoreboard lives; `previous.json` keeps the last run for deltas. */
+export function benchDir(root = process.cwd()) {
+    return `${root}/.omc/bench`.replaceAll("\\\\", "/");
+}
+export async function runBench(options) {
+    // Golden evals always replay against a fresh fake — the intent metric must
+    // stay comparable across scenario modes.
+    const evals = await runGoldenEvals();
+    const harness = makeBenchHarness(options.mode, options.liveEnvironment);
+    let scenarioSteps = [];
+    try {
+        const outcome = await runScenario(harness);
+        scenarioSteps = outcome.steps;
+    }
+    finally {
+        harness.close();
+    }
+    const wallClockMs = scenarioSteps.reduce((sum, step) => sum + step.durationMs, 0);
+    const stepsOk = scenarioSteps.filter((step) => step.ok).length;
+    const assertionsPassed = scenarioSteps.reduce((sum, step) => sum + step.assertionsPassed, 0);
+    const assertionsTotal = scenarioSteps.reduce((sum, step) => sum + step.assertionsPassed + step.assertionsFailed, 0);
+    const responseBytes = scenarioSteps.reduce((sum, step) => sum + step.responseBytes, 0);
+    const listBytes = toolsListBytes(harness.registry);
+    // Repeat readback targets: governed reads cache by target key; a second
+    // identical read returns `unchanged` without a wire call. Wire-layer
+    // design-metadata read-cache hits (ticket 16) carry the same signal.
+    const readbackCacheHits = wireReadCacheStats().hits;
+    const wirePaths = harness.wireTap.pathStats();
+    const dimensions = {
+        speed: {
+            wallClockMs,
+            stepCount: scenarioSteps.length,
+            slowestStepMs: scenarioSteps.reduce((max, step) => Math.max(max, step.durationMs), 0),
+        },
+        efficiency: {
+            wireCalls: harness.wireTap.total(),
+            uniqueWirePaths: wirePaths.length,
+            duplicateWireCalls: harness.wireTap.duplicateCalls(),
+            repeatReadbackTargets: wirePaths.filter((entry) => entry.count > 1 && /query\/list|form\/load|get_draft|get_published|business_rule\/list/.test(entry.path)).length,
+            readbackCacheHits,
+            wirePaths,
+        },
+        quality: {
+            stepsOk,
+            stepsTotal: scenarioSteps.length,
+            assertionsPassed,
+            assertionsTotal,
+            assertionRate: assertionsTotal === 0 ? 0 : assertionsPassed / assertionsTotal,
+        },
+        token: {
+            responseBytes,
+            toolsListBytes: listBytes,
+            estimatedTokens: Math.round((responseBytes + listBytes) / 4),
+        },
+        intent: {
+            cases: evals.total,
+            passed: evals.passed,
+            intentAccuracy: evals.total === 0 ? 0 : evals.passed / evals.total,
+            caseResults: evals.cases,
+        },
+    };
+    let report = {
+        schema: "omc-bench-report-v2",
+        generatedAt: new Date().toISOString(),
+        mode: options.mode,
+        scenario: "customer-project-declaration-v1",
+        steps: scenarioSteps,
+        dimensions,
+        delta: null,
+    };
+    const dir = options.persist === false ? "" : benchDir(options.root);
+    const reportPath = dir ? `${dir}/bench-report.json` : "";
+    let delta = null;
+    if (reportPath && existsSync(reportPath)) {
+        try {
+            const previous = JSON.parse(readFileSync(reportPath, "utf8"));
+            if (previous?.dimensions && previous.mode === report.mode)
+                delta = computeDelta(previous, report);
+        }
+        catch {
+            delta = null;
+        }
+        report = { ...report, delta };
+        mkdirSync(dir, { recursive: true });
+        renameSync(reportPath, `${dir}/previous.json`);
+        writeFileSync(reportPath, `${JSON.stringify(report, null, 2)}\n`);
+    }
+    else if (reportPath) {
+        report = { ...report, delta };
+        mkdirSync(dir, { recursive: true });
+        writeFileSync(reportPath, `${JSON.stringify(report, null, 2)}\n`);
+    }
+    return report;
+}
+/** Human-facing five-dimension table + delta, printed by `omc bench`. */
+export function formatBenchReport(report) {
+    const lines = [];
+    const metrics = flattenMetrics(report.dimensions);
+    lines.push(`omc bench — ${report.mode} @ ${report.generatedAt}`);
+    lines.push("");
+    lines.push("维度       指标                            数值         上次        Δ%      判定");
+    const rows = [];
+    for (const [key, label] of Object.entries(METRIC_LABELS)) {
+        if (metrics[key] === undefined)
+            continue;
+        const delta = report.delta?.[key];
+        const deltaText = delta ? `${delta.changePct >= 0 ? "+" : ""}${delta.changePct.toFixed(1)}` : "—";
+        const verdict = delta ? (delta.verdict === "same" ? "＝" : delta.verdict === "improved" ? "↑" : "↓") : "—";
+        const previousText = delta ? String(delta.previous) : "—";
+        rows.push([key, label, ""]);
+        lines.push(`${label[0]}          ${label.padEnd(30)} ${String(metrics[key]).padStart(10)} ${previousText.padStart(11)} ${deltaText.padStart(8)} ${verdict}`);
+    }
+    void rows;
+    const failedSteps = report.steps.filter((step) => !step.ok);
+    if (failedSteps.length > 0) {
+        lines.push("");
+        lines.push(`失败步骤 (${failedSteps.length}):`);
+        for (const step of failedSteps)
+            lines.push(`  - ${step.id} [${step.tool}] ${step.error ?? ""}`);
+    }
+    const failedAssertions = report.steps.filter((step) => step.assertionsFailed > 0);
+    if (failedAssertions.length > 0) {
+        lines.push("");
+        lines.push("失败断言:");
+        for (const step of failedAssertions)
+            lines.push(`  - ${step.id}: ${step.error ?? ""}`);
+    }
+    const failedCases = report.dimensions.intent.caseResults.filter((entry) => !entry.passed);
+    if (failedCases.length > 0) {
+        lines.push("");
+        lines.push("金轨迹未过:");
+        for (const entry of failedCases)
+            lines.push(`  - ${entry.id}: ${entry.error ?? ""}`);
+    }
+    lines.push("");
+    lines.push(`报告: ${benchDir()}/bench-report.json（上一轮保留在 previous.json）`);
+    return lines.join("\n");
+}
+const METRIC_LABELS = {
+    "speed.wallClockMs": "速度-剧本墙钟ms",
+    "speed.slowestStepMs": "速度-最慢步骤ms",
+    "efficiency.wireCalls": "效率-wire调用总数",
+    "efficiency.uniqueWirePaths": "效率-去重端点数",
+    "efficiency.duplicateWireCalls": "效率-重复wire调用",
+    "efficiency.repeatReadbackTargets": "效率-重复读回目标",
+    "efficiency.readbackCacheHits": "效率-缓存命中",
+    "quality.stepsOk": "质量-通过步骤",
+    "quality.stepsTotal": "质量-步骤总数",
+    "quality.assertionsPassed": "质量-通过断言",
+    "quality.assertionsTotal": "质量-断言总数",
+    "quality.assertionRate": "质量-断言通过率",
+    "token.responseBytes": "token-响应字节",
+    "token.toolsListBytes": "token-tools/list字节",
+    "token.estimatedTokens": "token-估算token",
+    "intent.cases": "意图-金轨迹数",
+    "intent.passed": "意图-通过数",
+    "intent.intentAccuracy": "意图-准确率",
+};
+//# sourceMappingURL=run.js.map