issue-flow 0.12.0 → 0.13.0

package/dist/bench-SA3BOME5.js

@@ -0,0 +1,906 @@
+#!/usr/bin/env node
+import {
+  summarizePhaseTiming
+} from "./chunk-37N2RJW2.js";
+import {
+  runAcceptance
+} from "./chunk-HEF2RMKN.js";
+import {
+  evaluateCeilings,
+  spendFromCost
+} from "./chunk-ARFVHC2F.js";
+import "./chunk-3XLCNVMD.js";
+import "./chunk-QCXPNSEL.js";
+import {
+  ensureHarnessVersion,
+  setIssuesCliOverrides
+} from "./chunk-CNBYCMSU.js";
+import {
+  resetStorageResolutionCache,
+  resolveIssuePaths
+} from "./chunk-HQAHNIAR.js";
+import {
+  createInitialSnapshot,
+  printError,
+  printInfo,
+  printWarning,
+  reduceSessionEvent
+} from "./chunk-IYV6KNVF.js";
+import {
+  redactSecrets
+} from "./chunk-6FDFRNXZ.js";
+import "./chunk-P3LRUNC6.js";
+import {
+  loadTaskPlan
+} from "./chunk-DIG5XKQQ.js";
+import {
+  sessionSnapshotSchema
+} from "./chunk-NEZZ6KDR.js";
+import "./chunk-L6HSKTQE.js";
+import "./chunk-TVN2JVOF.js";
+import {
+  GLOBAL_ROOT_ENV,
+  ISSUES_DIR_NAME,
+  getGlobalRoot
+} from "./chunk-TX5WIVYP.js";
+import {
+  run
+} from "./chunk-KQHB7ZT3.js";
+import "./chunk-7Z4Y3VKM.js";
+import "./chunk-XEYH6ZZI.js";
+
+// src/commands/bench.ts
+import { mkdir as mkdir3, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname2 } from "path";
+import { createInterface } from "readline";
+
+// src/benchmark/corpus.ts
+var TASK_CLASSES = ["trivial", "small", "medium", "analysis"];
+var CORPUS = [
+  {
+    id: "trivial",
+    title: "Change one constant and its comment",
+    fixture: "1\u20132 files, no test change",
+    verification: "none",
+    strategy: "direct"
+  },
+  {
+    id: "small",
+    title: "Fix a failing assertion in an existing test",
+    fixture: "correction against tests that already exist",
+    verification: "existing-tests",
+    strategy: "pipeline"
+  },
+  {
+    id: "medium",
+    title: "Add a function, tests and a README note",
+    fixture: "implementation plus tests plus documentation",
+    verification: "tests-and-docs",
+    strategy: "pipeline"
+  },
+  {
+    id: "analysis",
+    title: "Read the tree and write a short report",
+    fixture: "read-only artifact, no implementation",
+    verification: "artifact-only",
+    strategy: "direct"
+  }
+];
+
+// src/benchmark/live.ts
+function assertLiveBenchAllowed(env = process.env) {
+  if (env.VITEST && env.ISSUE_FLOW_E2E_BENCH !== "1") {
+    throw new Error(
+      "issue-flow bench --mode real does not run under npm test. Set ISSUE_FLOW_E2E_BENCH=1 for a deliberate live campaign."
+    );
+  }
+}
+function createLiveRepeatRunner(deps) {
+  return async (input) => {
+    assertLiveBenchAllowed();
+    const previousHome = process.env[GLOBAL_ROOT_ENV];
+    const previousCwd = process.cwd();
+    process.env[GLOBAL_ROOT_ENV] = input.campaignHome;
+    resetStorageResolutionCache();
+    setIssuesCliOverrides({ preferredProvider: "local" });
+    process.chdir(input.fixture.root);
+    const started = performance.now();
+    try {
+      await deps.runPipeline(input.fixture.issueRef);
+      const paths = await resolveIssuePaths(input.fixture.issueRef, {
+        projectRoot: input.fixture.root
+      });
+      const plan = await loadTaskPlan(paths.tasksFile);
+      const records = plan.executions ?? [];
+      const acceptance = await runAcceptance({
+        cwd: input.fixture.root,
+        issueDir: paths.issueDir,
+        declared: input.fixture.expectedVerification,
+        executionId: records.at(-1)?.id ?? null,
+        skipReviewer: input.arm !== "L2",
+        explicit: input.arm === "L2"
+      });
+      const wall = performance.now() - started;
+      const harness = records.reduce((sum, record) => sum + (record.durationMs ?? 0), 0);
+      const reported = records.flatMap(
+        (record) => record.cost.status === "reported" ? [record.cost.amount] : []
+      );
+      const cost = reported.length > 0 ? {
+        status: "reported",
+        amount: reported.reduce((sum, amount) => sum + amount, 0),
+        currency: "USD"
+      } : { status: "unknown", reason: "not_reported" };
+      return {
+        records,
+        verdict: acceptance.verdict,
+        taskDurationMs: wall,
+        harnessExecutionMs: harness,
+        orchestrationOverheadMs: Math.max(0, wall - harness),
+        attemptCount: records.reduce((max, record) => Math.max(max, record.attempt), 0) || 1,
+        cost
+      };
+    } finally {
+      process.chdir(previousCwd);
+      if (previousHome === void 0) delete process.env[GLOBAL_ROOT_ENV];
+      else process.env[GLOBAL_ROOT_ENV] = previousHome;
+      resetStorageResolutionCache();
+      setIssuesCliOverrides({});
+    }
+  };
+}
+
+// src/benchmark/real.ts
+import { mkdir as mkdir2 } from "fs/promises";
+import { join as join2 } from "path";
+
+// src/benchmark/fixtures/materialize.ts
+import { mkdir, mkdtemp, rm, writeFile } from "fs/promises";
+import { tmpdir } from "os";
+import { dirname, join } from "path";
+
+// src/benchmark/fixtures/templates.ts
+function withSeed(content, seed) {
+  return `${content}
+// fixture-seed:${seed}
+`;
+}
+function templateFor(task, seed) {
+  switch (task) {
+    case "trivial":
+      return {
+        files: {
+          "src/answer.js": withSeed(
+            [
+              "/** The answer to life, the universe and everything. */",
+              "export const ANSWER = 41;"
+            ].join("\n"),
+            seed
+          )
+        },
+        issueTitle: "Change one constant and its comment",
+        issueBody: [
+          "Change `ANSWER` in `src/answer.js` from 41 to 42.",
+          "Update the comment so it no longer claims the wrong value.",
+          "Do not add tests."
+        ].join("\n"),
+        expectedVerification: []
+      };
+    case "small":
+      return {
+        files: {
+          "src/sum.js": withSeed("export function sum(a, b) {\n  return a - b;\n}\n", seed),
+          "src/sum.test.js": [
+            "import { sum } from './sum.js';",
+            "import assert from 'node:assert/strict';",
+            "assert.equal(sum(2, 2), 4);",
+            ""
+          ].join("\n"),
+          "package.json": `${JSON.stringify({ name: "bench-small", type: "module", scripts: { test: "node src/sum.test.js" } }, null, 2)}
+`
+        },
+        issueTitle: "Fix a failing assertion in an existing test",
+        issueBody: [
+          "`src/sum.test.js` fails because `sum` subtracts instead of adding.",
+          "Fix `src/sum.js` so `node src/sum.test.js` exits 0.",
+          "Do not change the test."
+        ].join("\n"),
+        expectedVerification: [{ id: "existing-tests", run: "node src/sum.test.js", fatal: true }]
+      };
+    case "medium":
+      return {
+        files: {
+          "src/greet.js": withSeed("// greet(name) is not implemented yet.\n", seed),
+          "src/greet.test.js": [
+            "import { greet } from './greet.js';",
+            "import assert from 'node:assert/strict';",
+            "assert.equal(greet('Ada'), 'Hello, Ada');",
+            ""
+          ].join("\n"),
+          "README.md": ["# bench-medium", "", "A tiny library.", ""].join("\n"),
+          "package.json": `${JSON.stringify({ name: "bench-medium", type: "module", scripts: { test: "node src/greet.test.js" } }, null, 2)}
+`
+        },
+        issueTitle: "Add a function, tests and a README note",
+        issueBody: [
+          "Implement `greet(name)` in `src/greet.js` so it returns Hello, <name>.",
+          "Keep `src/greet.test.js` as the contract.",
+          "Add an `## API` section to `README.md` documenting `greet`."
+        ].join("\n"),
+        expectedVerification: [
+          { id: "tests", run: "node src/greet.test.js", fatal: true },
+          { id: "docs", expectFiles: ["README.md"], fatal: true }
+        ]
+      };
+    case "analysis":
+      return {
+        files: {
+          "src/alpha.js": withSeed("export const ALPHA = 1;\n", seed),
+          "src/beta.js": withSeed(
+            "import { ALPHA } from './alpha.js';\nexport const BETA = ALPHA + 1;\n",
+            seed
+          ),
+          "src/gamma.js": withSeed(
+            "import { BETA } from './beta.js';\nexport const GAMMA = BETA + 1;\n",
+            seed
+          )
+        },
+        issueTitle: "Read the tree and write a short report",
+        issueBody: [
+          "Read `src/` and write `report.md` describing the module graph.",
+          "Do not change the source files."
+        ].join("\n"),
+        expectedVerification: [{ id: "artifact", expectFiles: ["report.md"], fatal: true }]
+      };
+    default: {
+      const _exhaustive = task;
+      throw new Error(`Unknown corpus class: ${_exhaustive}`);
+    }
+  }
+}
+
+// src/benchmark/fixtures/materialize.ts
+var GIT_IDENT = ["-c", "user.name=issue-flow-bench", "-c", "user.email=bench@issue-flow.test"];
+async function git(cwd, args) {
+  const result = await run("git", args, { cwd });
+  if (result.exitCode !== 0) {
+    throw new Error(
+      `git ${args.join(" ")} failed (${result.exitCode}): ${result.stderr || result.stdout}`
+    );
+  }
+}
+async function writeTree(root, files) {
+  for (const [relative, content] of Object.entries(files)) {
+    const path = join(root, relative);
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, content, "utf-8");
+  }
+}
+async function writeLocalIssue(root, title, body) {
+  const issueDir = join(root, ISSUES_DIR_NAME, "1");
+  await mkdir(issueDir, { recursive: true });
+  await writeFile(join(issueDir, "issue.md"), `# ${title}
+
+${body.trim()}
+`, "utf-8");
+  await writeFile(
+    join(issueDir, "metadata.json"),
+    `${JSON.stringify(
+      {
+        schemaVersion: 1,
+        id: "1",
+        number: 1,
+        source: "local",
+        title,
+        labels: ["bench"],
+        state: "open",
+        createdAt: "2026-08-30T00:00:00.000Z",
+        updatedAt: "2026-08-30T00:00:00.000Z",
+        contentHash: "sha256:fixture"
+      },
+      null,
+      2
+    )}
+`,
+    "utf-8"
+  );
+}
+async function materialize(task, seed) {
+  const root = await mkdtemp(join(tmpdir(), `issue-flow-bench-${task.id}-${seed}-`));
+  const template = templateFor(task.id, seed);
+  await writeTree(root, template.files);
+  await writeLocalIssue(root, template.issueTitle, template.issueBody);
+  await git(root, ["-c", "init.templateDir=", "init"]);
+  await git(root, ["add", "."]);
+  await git(root, [...GIT_IDENT, "commit", "-m", `fixture ${task.id} seed=${seed}`]);
+  return {
+    root,
+    issueRef: "1",
+    expectedVerification: template.expectedVerification,
+    seed,
+    task: task.id,
+    async dispose() {
+      await rm(root, { recursive: true, force: true });
+    }
+  };
+}
+function corpusTask(id) {
+  const task = CORPUS.find((entry) => entry.id === id);
+  if (!task) throw new Error(`Unknown corpus class: ${id}`);
+  return task;
+}
+
+// src/benchmark/stats.ts
+function percentile(values, p) {
+  const sorted = [...values].sort((a, b) => a - b);
+  if (sorted.length === 0) return 0;
+  const index = Math.min(sorted.length - 1, Math.ceil(p / 100 * sorted.length) - 1);
+  return sorted[index] ?? 0;
+}
+function p50(values) {
+  return percentile(values, 50);
+}
+function p95(values) {
+  return percentile(values, 95);
+}
+
+// src/benchmark/tuple.ts
+var TUPLE_FIELDS = [
+  "task",
+  "harness",
+  "harnessVersion",
+  "model",
+  "modelVersion",
+  "effort",
+  "verification",
+  "strategy",
+  "settingSourcesPinned",
+  "strictMcpConfig",
+  "fallbackModelPassed"
+];
+var ComparabilityError = class extends Error {
+  field;
+  left;
+  right;
+  constructor(field, left, right) {
+    super(`ComparabilityTuple.${field} differs: ${String(left)} vs ${String(right)}`);
+    this.name = "ComparabilityError";
+    this.field = field;
+    this.left = left;
+    this.right = right;
+  }
+};
+function assertComparable(left, right, options = {}) {
+  const ignored = new Set(options.ignore ?? []);
+  for (const field of TUPLE_FIELDS) {
+    if (ignored.has(field)) continue;
+    if (left[field] !== right[field]) {
+      throw new ComparabilityError(field, left[field], right[field]);
+    }
+  }
+}
+function isRowInvalid(tuple) {
+  return tuple.fallbackModelPassed || !tuple.settingSourcesPinned;
+}
+async function collectHarnessVersion(provider) {
+  const version = await ensureHarnessVersion(provider);
+  return version ?? "unknown";
+}
+function tupleAxisForArm(arm) {
+  if (arm === "strict-mcp") return "strictMcpConfig";
+  return null;
+}
+
+// src/benchmark/real.ts
+function campaignHome(campaignId, env) {
+  return join2(getGlobalRoot({ env }), "bench", campaignId);
+}
+function combineCost(records) {
+  let reported = 0;
+  let estimated = 0;
+  let unknown = 0;
+  for (const record of records) {
+    if (record.cost.status === "reported") reported += record.cost.amount;
+    else if (record.cost.status === "estimated") estimated += record.cost.amount;
+    else unknown += 1;
+  }
+  if (reported > 0) return { status: "reported", amount: reported, currency: "USD" };
+  if (estimated > 0) {
+    return {
+      status: "estimated",
+      amount: estimated,
+      currency: "USD",
+      pricing: {
+        tableVersion: "bench",
+        modelKey: "aggregated",
+        inputPerMillion: 0,
+        outputPerMillion: 0,
+        capturedAt: (/* @__PURE__ */ new Date(0)).toISOString()
+      }
+    };
+  }
+  return { status: "unknown", reason: unknown > 0 ? "not_reported" : "not_reported" };
+}
+function summarizeCell(cell) {
+  const durations = cell.repeats.map((repeat) => repeat.taskDurationMs);
+  const harness = cell.repeats.map((repeat) => repeat.harnessExecutionMs);
+  const overhead = cell.repeats.map((repeat) => repeat.orchestrationOverheadMs);
+  const accepted = cell.repeats.map((repeat) => repeat.timeToAcceptedResultMs).filter((value) => value !== null);
+  const reported = cell.repeats.map((repeat) => repeat.cost.status === "reported" ? repeat.cost.amount : null).filter((value) => value !== null);
+  const verdicts = { passed: 0, failed: 0, unverified: 0 };
+  let unknownRepeats = 0;
+  let estimatedRepeats = 0;
+  for (const repeat of cell.repeats) {
+    verdicts[repeat.verdict] += 1;
+    if (repeat.cost.status === "unknown") unknownRepeats += 1;
+    if (repeat.cost.status === "estimated") estimatedRepeats += 1;
+  }
+  return {
+    n: cell.repeats.length,
+    taskDurationMs: { p50: p50(durations), p95: p95(durations), n: durations.length },
+    harnessExecutionMs: { p50: p50(harness), p95: p95(harness), n: harness.length },
+    orchestrationOverheadMs: { p50: p50(overhead), p95: p95(overhead), n: overhead.length },
+    timeToAcceptedResultMs: {
+      p50: accepted.length === 0 ? null : p50(accepted),
+      p95: accepted.length === 0 ? null : p95(accepted),
+      n: accepted.length
+    },
+    cost: {
+      reportedP50: reported.length === 0 ? null : p50(reported),
+      reportedP95: reported.length === 0 ? null : p95(reported),
+      unknownRepeats,
+      estimatedRepeats
+    },
+    verdicts
+  };
+}
+function tupleForArm(task, arm, base) {
+  return {
+    task,
+    harness: base.harness,
+    harnessVersion: base.harnessVersion,
+    model: base.model,
+    modelVersion: base.modelVersion,
+    effort: base.effort,
+    verification: base.verification,
+    strategy: base.strategy,
+    settingSourcesPinned: base.settingSourcesPinned,
+    strictMcpConfig: arm === "strict-mcp" ? true : base.strictMcpConfig ?? false,
+    fallbackModelPassed: base.fallbackModelPassed ?? false
+  };
+}
+function declaredIgnore(arms) {
+  const fields = /* @__PURE__ */ new Set();
+  for (const arm of arms) {
+    const axis = tupleAxisForArm(arm);
+    if (axis) fields.add(axis);
+  }
+  return [...fields];
+}
+async function runRealCorpus(options) {
+  const tasks = options.tasks ?? CORPUS.map((entry) => entry.id);
+  const campaignId = options.campaignId ?? `campaign-${Date.now()}`;
+  const home = campaignHome(campaignId, options.env);
+  await mkdir2(home, { recursive: true });
+  const cells = /* @__PURE__ */ new Map();
+  const ignore = declaredIgnore(options.arms);
+  const now = options.now ?? Date.now;
+  const started = now();
+  let reportedUsd = 0;
+  let knownCost = "unknown";
+  let stop = { reason: "completed" };
+  const schedule = [];
+  for (let seed = 0; seed < options.repeats; seed += 1) {
+    for (const arm of options.arms) {
+      for (const task of tasks) {
+        schedule.push({ task, arm, seed });
+      }
+    }
+  }
+  for (const step of schedule) {
+    const task = corpusTask(step.task);
+    const tuple = tupleForArm(step.task, step.arm, {
+      ...options.tupleBase,
+      verification: task.verification,
+      strategy: task.strategy
+    });
+    const key = `${step.task}:${step.arm}`;
+    const existing = cells.get(key);
+    if (existing) {
+      assertComparable(existing.tuple, tuple, { ignore });
+    } else {
+      for (const cell of cells.values()) {
+        if (cell.task !== step.task) continue;
+        assertComparable(cell.tuple, tuple, { ignore });
+      }
+      cells.set(key, { task: step.task, tuple, arm: step.arm, repeats: [] });
+    }
+    const fixture = await materialize(task, step.seed);
+    try {
+      const outcome = await options.runner({
+        fixture,
+        arm: step.arm,
+        tuple,
+        campaignHome: home
+      });
+      const cost = outcome.cost.status !== void 0 ? outcome.cost : combineCost(outcome.records);
+      const spent = spendFromCost(cost);
+      if (spent.costStatus === "reported") {
+        reportedUsd += spent.reportedUsd;
+        knownCost = "reported";
+      }
+      const cell = cells.get(key);
+      if (!cell) throw new Error(`missing cell ${key}`);
+      cell.repeats.push({
+        seed: step.seed,
+        taskDurationMs: outcome.taskDurationMs,
+        harnessExecutionMs: outcome.harnessExecutionMs,
+        orchestrationOverheadMs: outcome.orchestrationOverheadMs,
+        timeToAcceptedResultMs: outcome.verdict === "passed" ? outcome.taskDurationMs : null,
+        verdict: outcome.verdict,
+        cost,
+        attemptCount: outcome.attemptCount,
+        executionIds: outcome.records.map((record) => record.id),
+        invalid: isRowInvalid(tuple)
+      });
+    } finally {
+      await fixture.dispose();
+    }
+    const ceiling = evaluateCeilings({
+      ceilings: {
+        maxCostUsdPerIssue: options.maxCostUsd ?? null,
+        maxDurationMsPerIssue: options.maxDurationMs ?? null,
+        maxExecutionsPerIssue: null,
+        onCeiling: "block"
+      },
+      spent: {
+        reportedUsd,
+        costStatus: knownCost,
+        durationMs: now() - started,
+        executions: [...cells.values()].reduce((sum, cell) => sum + cell.repeats.length, 0)
+      }
+    });
+    if (!ceiling.ok) {
+      stop = {
+        reason: ceiling.stopReason === "max_attempts" ? "max_duration" : ceiling.stopReason,
+        spent: ceiling.numbers.spent,
+        ceiling: ceiling.numbers.ceiling,
+        partial: true
+      };
+      break;
+    }
+  }
+  return { id: campaignId, home, cells: [...cells.values()], stop };
+}
+
+// src/benchmark/report.ts
+import { hostname } from "os";
+function formatMs(value) {
+  return value === null ? "\u2014" : `${Math.round(value)}`;
+}
+function formatUsd(value) {
+  return value === null ? "\u2014" : `$${value.toFixed(2)}`;
+}
+function tupleLine(tuple) {
+  return [
+    tuple.task,
+    tuple.harness,
+    tuple.harnessVersion,
+    tuple.model,
+    tuple.modelVersion ?? "\u2014",
+    tuple.effort,
+    tuple.verification,
+    tuple.strategy,
+    tuple.settingSourcesPinned ? "setting-sources:pinned" : "setting-sources:unpinned",
+    tuple.strictMcpConfig ? "strict-mcp" : "mcp:default",
+    tuple.fallbackModelPassed ? "INVALID:fallback-model" : "fallback:none"
+  ].join(" \xD7 ");
+}
+function verdictCounts(summary) {
+  return `passed=${summary.verdicts.passed} failed=${summary.verdicts.failed} unverified=${summary.verdicts.unverified}`;
+}
+function scrubPaths(text) {
+  const home = getGlobalRoot();
+  return text.split(home).join("<issue-flow-home>");
+}
+function renderCampaignMarkdown(campaign, subject) {
+  const lines = [
+    `# Harness campaign \u2014 ${subject}`,
+    "",
+    `> **Research document.** Campaign \`${campaign.id}\`.`,
+    `> Machine: \`${hostname()}\`. Node ${process.version}.`,
+    campaign.stop.reason === "completed" ? "> Status: complete." : `> Status: **partial** \u2014 stopped on \`${campaign.stop.reason}\` (spent ${campaign.stop.spent}, ceiling ${campaign.stop.ceiling}). Results below are the repeats that finished; they are not a silently truncated table.`,
+    "",
+    "`time-to-accepted-result` is null when the verdict is not `passed`. Cost `unknown` is never summed as zero.",
+    "",
+    "## Cells",
+    "",
+    "| Task | Arm | n | duration p50/p95 (ms) | harness p50/p95 | overhead p50/p95 | accepted p50/p95 | cost p50/p95 | verdicts | invalid |",
+    "|---|---|---:|---|---|---|---|---|---|---|"
+  ];
+  for (const cell of campaign.cells) {
+    const summary = summarizeCell(cell);
+    const invalid = cell.repeats.some((repeat) => repeat.invalid);
+    lines.push(
+      `| ${cell.task} | ${cell.arm} | ${summary.n} | ${formatMs(summary.taskDurationMs.p50)} / ${formatMs(summary.taskDurationMs.p95)} | ${formatMs(summary.harnessExecutionMs.p50)} / ${formatMs(summary.harnessExecutionMs.p95)} | ${formatMs(summary.orchestrationOverheadMs.p50)} / ${formatMs(summary.orchestrationOverheadMs.p95)} | ${formatMs(summary.timeToAcceptedResultMs.p50)} / ${formatMs(summary.timeToAcceptedResultMs.p95)} | ${formatUsd(summary.cost.reportedP50)} / ${formatUsd(summary.cost.reportedP95)} | ${verdictCounts(summary)} | ${invalid ? "yes" : "no"} |`
+    );
+  }
+  lines.push("", "## Comparability tuples", "");
+  for (const cell of campaign.cells) {
+    lines.push(`- **${cell.task} / ${cell.arm}**: \`${tupleLine(cell.tuple)}\``);
+  }
+  lines.push("");
+  return redactSecrets(scrubPaths(lines.join("\n")));
+}
+
+// src/benchmark/synthetic.ts
+function scriptedEvents() {
+  return [
+    {
+      type: "session:start",
+      at: "2026-08-30T03:00:00.000Z",
+      sessionId: "bench",
+      issueNumber: 79,
+      phases: ["prd", "execute"]
+    },
+    { type: "phase:start", at: "2026-08-30T03:00:01.000Z", phase: "prd" },
+    {
+      type: "phase:end",
+      at: "2026-08-30T03:00:02.000Z",
+      phase: "prd",
+      success: true,
+      harnessExecutionMs: 800,
+      orchestrationOverheadMs: 200
+    },
+    { type: "phase:start", at: "2026-08-30T03:00:02.000Z", phase: "execute" },
+    {
+      type: "phase:end",
+      at: "2026-08-30T03:00:03.000Z",
+      phase: "execute",
+      success: true,
+      harnessExecutionMs: 900,
+      orchestrationOverheadMs: 100,
+      attemptCount: 1
+    },
+    { type: "session:end", at: "2026-08-30T03:00:03.000Z", status: "completed" }
+  ];
+}
+function reduceScriptedRun() {
+  let snap = createInitialSnapshot();
+  for (const event of scriptedEvents()) {
+    snap = reduceSessionEvent(snap, event);
+  }
+  return snap;
+}
+function mockedRecord(durationMs) {
+  return {
+    id: "synthetic",
+    sessionId: "bench",
+    purpose: "execute",
+    attempt: 1,
+    trigger: "initial",
+    triggerReason: null,
+    agent: {
+      harness: "mocked",
+      provider: null,
+      model: { requested: null, resolved: null, source: "unavailable" },
+      providerSessionId: null
+    },
+    startedAt: "2026-08-30T03:00:00.000Z",
+    finishedAt: "2026-08-30T03:00:01.000Z",
+    durationMs,
+    cliDurationMs: Math.max(0, durationMs - 5),
+    harnessStartupMs: 5,
+    ttftMs: null,
+    usage: { source: "unavailable" },
+    cost: { status: "unknown", reason: "not_reported" },
+    status: "completed",
+    failure: null
+  };
+}
+function runSyntheticCorpus() {
+  return CORPUS.map((task) => {
+    const harnessMs = 1e3;
+    const orchestrateStart = performance.now();
+    const snap = reduceScriptedRun();
+    sessionSnapshotSchema.parse(snap);
+    const orchestrationMs = performance.now() - orchestrateStart;
+    const timing = summarizePhaseTiming(
+      [mockedRecord(harnessMs)],
+      "execute",
+      harnessMs + orchestrationMs
+    );
+    return {
+      task: task.id,
+      mode: "synthetic",
+      harness: "mocked",
+      model: "none",
+      effort: "none",
+      verification: task.verification,
+      strategy: task.strategy,
+      taskDurationMs: harnessMs + orchestrationMs,
+      harnessExecutionDurationMs: timing.harnessExecutionMs ?? harnessMs,
+      orchestrationOverheadMs: timing.orchestrationOverheadMs ?? orchestrationMs,
+      timeToFirstOutputMs: timing.ttftMs,
+      attemptCount: timing.attemptCount ?? 1,
+      retryDurationMs: timing.retryDurationMs ?? 0,
+      // no retries in the mocked record
+      verdict: "unverified"
+    };
+  });
+}
+
+// src/commands/bench.ts
+var BASELINE_COST_P50_USD = {
+  trivial: 0.2,
+  small: 3.17,
+  medium: 6.08,
+  analysis: 1.86
+};
+var BenchConfirmationError = class extends Error {
+  exitCode = 1;
+  constructor(message) {
+    super(message);
+    this.name = "BenchConfirmationError";
+  }
+};
+function estimateCampaignUsd(tasks, arms, repeats) {
+  const perRepeat = tasks.reduce((sum, task) => sum + BASELINE_COST_P50_USD[task], 0);
+  return perRepeat * arms * repeats;
+}
+function isInteractiveByDefault() {
+  const ci = process.env.CI;
+  const inCi = ci !== void 0 && ci !== "" && ci !== "0" && ci.toLowerCase() !== "false";
+  return Boolean(process.stdin.isTTY) && Boolean(process.stdout.isTTY) && !inCi;
+}
+async function confirmRealCampaign(estimate, options = {}) {
+  printInfo(
+    `Real campaign: ${estimate.cells} cells \xD7 ${estimate.repeats} repeats \u2248 $${estimate.usd.toFixed(2)} (p50 of the #79 baseline).`
+  );
+  if (estimate.maxCost !== void 0) {
+    printInfo(`Cost ceiling: $${estimate.maxCost.toFixed(2)}.`);
+  }
+  if (estimate.maxDuration !== void 0) {
+    printInfo(`Duration ceiling: ${estimate.maxDuration}ms.`);
+  }
+  if (options.yes === true) {
+    printInfo("--yes: starting the campaign.");
+    return;
+  }
+  const interactive = options.interactive ?? isInteractiveByDefault();
+  if (!interactive) {
+    throw new BenchConfirmationError(
+      "A real campaign spends money and the terminal is not interactive. Re-run with --yes."
+    );
+  }
+  const stdin = options.stdin ?? process.stdin;
+  const stdout = options.stdout ?? process.stdout;
+  const rl = createInterface({ input: stdin, output: stdout });
+  try {
+    const answer = await new Promise((resolve) => {
+      rl.question("Proceed with a paid campaign? [y/N] ", resolve);
+    });
+    if (!/^\s*y(es)?\s*$/i.test(answer)) {
+      throw new BenchConfirmationError("Cancelled: the campaign was not confirmed.");
+    }
+  } finally {
+    rl.close();
+  }
+}
+function parseTasks(values) {
+  if (values === void 0 || values.length === 0) return [...TASK_CLASSES];
+  const tasks = [];
+  for (const value of values) {
+    if (!TASK_CLASSES.includes(value)) {
+      throw new BenchConfirmationError(
+        `Unknown task class '${value}'. Must be one of: ${TASK_CLASSES.join(", ")}.`
+      );
+    }
+    if (!tasks.includes(value)) tasks.push(value);
+  }
+  return tasks;
+}
+function printSynthetic() {
+  const rows = runSyntheticCorpus();
+  printInfo("Synthetic corpus (orchestration only; harness is a number).");
+  for (const row of rows) {
+    printInfo(
+      `${row.task}  duration=${row.taskDurationMs.toFixed(1)}ms  overhead=${row.orchestrationOverheadMs.toFixed(1)}ms  verdict=${row.verdict}`
+    );
+  }
+}
+async function runBench(options = {}) {
+  const mode = options.mode ?? "synthetic";
+  if (mode !== "synthetic" && mode !== "real") {
+    printError(`Unknown bench mode '${mode}'. Use synthetic or real.`);
+    return 1;
+  }
+  if (mode === "synthetic") {
+    printSynthetic();
+    return 0;
+  }
+  if (options.repo !== void 0) {
+    printWarning(
+      "--repo is an investigation escape: the row is not publishable. A disposable fixture is the only source of a comparable line."
+    );
+  }
+  let tasks;
+  try {
+    tasks = parseTasks(options.task);
+  } catch (error) {
+    printError(error instanceof Error ? error.message : String(error));
+    return 1;
+  }
+  const arms = options.arm !== void 0 && options.arm.length > 0 ? options.arm : ["baseline"];
+  const repeats = options.repeats ?? 5;
+  const usd = estimateCampaignUsd(tasks, arms.length, repeats);
+  try {
+    await confirmRealCampaign(
+      {
+        cells: tasks.length * arms.length,
+        repeats,
+        usd,
+        ...options.maxCost === void 0 ? {} : { maxCost: options.maxCost },
+        ...options.maxDuration === void 0 ? {} : { maxDuration: options.maxDuration }
+      },
+      options
+    );
+  } catch (error) {
+    if (error instanceof BenchConfirmationError) {
+      printError(error.message);
+      return error.exitCode;
+    }
+    throw error;
+  }
+  const harnessVersion = options.harnessVersion ?? await collectHarnessVersion("claude");
+  const runner = options.runner ?? createLiveRepeatRunner({
+    runPipeline: options.runPipeline ?? (async (issue) => {
+      const { runPipeline } = await import("./run-YU4TR62R.js");
+      return runPipeline(issue, "auto", void 0, true, false, { yes: true, only: true });
+    })
+  });
+  const campaign = await runRealCorpus({
+    tasks,
+    arms,
+    repeats,
+    tupleBase: {
+      harness: "claude",
+      harnessVersion,
+      model: "default",
+      modelVersion: null,
+      effort: "default",
+      verification: "none",
+      strategy: "pipeline",
+      settingSourcesPinned: true,
+      fallbackModelPassed: false
+    },
+    ...options.maxCost === void 0 ? {} : { maxCostUsd: options.maxCost },
+    ...options.maxDuration === void 0 ? {} : { maxDurationMs: options.maxDuration },
+    runner
+  });
+  if (campaign.stop.reason !== "completed") {
+    printWarning(
+      `Campaign stopped on ${campaign.stop.reason} (spent ${campaign.stop.spent}, ceiling ${campaign.stop.ceiling}). Report is partial.`
+    );
+  }
+  const markdown = renderCampaignMarkdown(campaign, arms.join("-vs-"));
+  if (options.out) {
+    await mkdir3(dirname2(options.out), { recursive: true });
+    await writeFile2(options.out, markdown, "utf-8");
+    printInfo(`Wrote ${options.out}`);
+  } else {
+    (options.stdout ?? process.stdout).write(markdown);
+  }
+  if (options.json === true) {
+    (options.stdout ?? process.stdout).write(`${JSON.stringify(campaign, null, 2)}
+`);
+  }
+  return campaign.stop.reason === "completed" ? 0 : 2;
+}
+export {
+  BASELINE_COST_P50_USD,
+  BenchConfirmationError,
+  confirmRealCampaign,
+  estimateCampaignUsd,
+  runBench
+};
+//# sourceMappingURL=bench-SA3BOME5.js.map