@agjs/tsforge 0.1.14 → 0.1.16

package/scripts/eval-create.ts

@@ -0,0 +1,48 @@
+// Live "create from scratch" eval against the local Qwen3.6. Not in the suite.
+// Run: bun run packages/core/scripts/eval-create.ts
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { OpenAICompatibleProvider, PROVIDER_DEFAULTS } from "../src/inference";
+import { runTask } from "../src/loop";
+
+// Only the test exists. greet.ts must be CREATED by the model.
+const TESTFILE = `import { test, expect } from "bun:test";
+import { greet } from "./greet";
+test("greets by name", () => {
+  expect(greet("Sam")).toBe("Hello, Sam");
+});
+`;
+
+const provider = new OpenAICompatibleProvider({
+  baseUrl: process.env.TSFORGE_BASE_URL ?? PROVIDER_DEFAULTS.baseUrl,
+  model: process.env.TSFORGE_MODEL ?? PROVIDER_DEFAULTS.model,
+});
+
+const dir = await mkdtemp(join(tmpdir(), "tsforge-eval-create-"));
+
+try {
+  await Bun.write(join(dir, "greet.test.ts"), TESTFILE);
+
+  // The test is declared so the model can SEE the spec; greet.ts is the target.
+  const result = await runTask(
+    {
+      id: "greet",
+      accept: "bun test greet.test.ts",
+      files: ["greet.ts", "greet.test.ts"],
+    },
+    dir,
+    provider
+  );
+
+  console.log("result:", JSON.stringify(result));
+
+  const created = Bun.file(join(dir, "greet.ts"));
+
+  console.log(
+    "greet.ts:\n" +
+      ((await created.exists()) ? await created.text() : "(not created)")
+  );
+} finally {
+  await rm(dir, { recursive: true, force: true });
+}

package/scripts/eval-spec.ts

@@ -0,0 +1,47 @@
+// Live multi-task eval against the local Qwen3.6. Not part of the test suite.
+// Run: bun run packages/core/scripts/eval-spec.ts
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { OpenAICompatibleProvider, PROVIDER_DEFAULTS } from "../src/inference";
+import { runSpec } from "../src/loop";
+import type { ISpec } from "../src/spec";
+
+const FILES: Record<string, string> = {
+  "add.ts": `export function add(a: number, b: number): number {\n  return 0;\n}\n`,
+  "add.test.ts": `import { test, expect } from "bun:test";\nimport { add } from "./add";\ntest("adds", () => { expect(add(2, 3)).toBe(5); });\n`,
+  "mul.ts": `export function mul(a: number, b: number): number {\n  return 0;\n}\n`,
+  "mul.test.ts": `import { test, expect } from "bun:test";\nimport { mul } from "./mul";\ntest("muls", () => { expect(mul(2, 3)).toBe(6); });\n`,
+};
+
+const spec: ISpec = {
+  id: "math",
+  title: "Math helpers",
+  verify: "bun test",
+  tasks: [
+    { id: "add", accept: "bun test add.test.ts", files: ["add.ts"] },
+    { id: "mul", accept: "bun test mul.test.ts", files: ["mul.ts"] },
+  ],
+};
+
+const provider = new OpenAICompatibleProvider({
+  baseUrl: process.env.TSFORGE_BASE_URL ?? PROVIDER_DEFAULTS.baseUrl,
+  model: process.env.TSFORGE_MODEL ?? PROVIDER_DEFAULTS.model,
+});
+
+const dir = await mkdtemp(join(tmpdir(), "tsforge-eval-spec-"));
+
+try {
+  for (const [name, content] of Object.entries(FILES)) {
+    await Bun.write(join(dir, name), content);
+  }
+
+  const result = await runSpec(spec, dir, provider);
+
+  console.log("spec status:", result.status);
+  console.log("tasks:", JSON.stringify(result.results));
+  console.log("add.ts:\n" + (await Bun.file(join(dir, "add.ts")).text()));
+  console.log("mul.ts:\n" + (await Bun.file(join(dir, "mul.ts")).text()));
+} finally {
+  await rm(dir, { recursive: true, force: true });
+}

package/scripts/eval-sum.ts

@@ -0,0 +1,79 @@
+// Live eval against the local Qwen3.6. Not part of the test suite.
+// Run: bun run packages/core/scripts/eval-sum.ts
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { OpenAICompatibleProvider, PROVIDER_DEFAULTS } from "../src/inference";
+import { runTask } from "../src/loop";
+
+const BROKEN = `export function sum(a: number, b: number): number {
+  return 0; // wrong on purpose
+}
+`;
+const TESTFILE = `import { test, expect } from "bun:test";
+import { sum } from "./sum";
+test("adds", () => { expect(sum(2, 3)).toBe(5); });
+`;
+
+const EDIT_TOOL = {
+  type: "function",
+  function: {
+    name: "edit",
+    description: "Replace an exact, unique snippet in a file.",
+    parameters: {
+      type: "object",
+      properties: {
+        file: { type: "string" },
+        oldString: { type: "string" },
+        newString: { type: "string" },
+      },
+      required: ["file", "oldString", "newString"],
+    },
+  },
+};
+
+const provider = new OpenAICompatibleProvider({
+  baseUrl: process.env.TSFORGE_BASE_URL ?? PROVIDER_DEFAULTS.baseUrl,
+  model: process.env.TSFORGE_MODEL ?? PROVIDER_DEFAULTS.model,
+});
+
+// (1) Diagnostic: WITH full context (file + test), does it emit a valid edit?
+console.log("=== (1) direct call, model given full context ===");
+const diag = await provider.complete(
+  [
+    {
+      role: "system",
+      content:
+        "You are a TypeScript engineer. Fix the bug by emitting an `edit` " +
+        "tool call. oldString must match the file exactly and uniquely.",
+    },
+    {
+      role: "user",
+      content: `File sum.ts:\n${BROKEN}\nTest sum.test.ts:\n${TESTFILE}\nMake the test pass.`,
+    },
+  ],
+  { temperature: 0, tools: [EDIT_TOOL] }
+);
+
+console.log("content:", JSON.stringify(diag.content));
+console.log("toolCalls:", JSON.stringify(diag.toolCalls, null, 2));
+
+// (2) The blind loop: current ModelAgent gets NO file content (only errors).
+console.log("\n=== (2) full loop via ModelAgent (blind to file contents) ===");
+const dir = await mkdtemp(join(tmpdir(), "tsforge-eval-"));
+
+try {
+  await Bun.write(join(dir, "sum.ts"), BROKEN);
+  await Bun.write(join(dir, "sum.test.ts"), TESTFILE);
+
+  const result = await runTask(
+    { id: "sum", accept: "bun test sum.test.ts", files: ["sum.ts"] },
+    dir,
+    provider
+  );
+
+  console.log("result:", JSON.stringify(result));
+  console.log("sum.ts after:\n" + (await Bun.file(join(dir, "sum.ts")).text()));
+} finally {
+  await rm(dir, { recursive: true, force: true });
+}

package/scripts/gen-tests.ts

@@ -0,0 +1,140 @@
+// Prove the UNTESTED-SPEC pipeline against the live local model, end to end:
+//   spec (criteria only, no tests)
+//     → generateTests: model writes a suite + throwing stub, verified RED
+//     → implement loop: model drives the stub to GREEN against its own tests
+// If the gate goes green, an untested spec became working, verified code with no
+// human-written tests and no flagship model — purely local.
+//
+// Run:  TSFORGE_SEED=money bun run packages/core/scripts/gen-tests.ts
+import { mkdir, readdir } from "node:fs/promises";
+import { join } from "node:path";
+import { parseSpec } from "../src/spec";
+import { generateTests } from "../src/spec/generate-tests";
+import { reviewAndFixSuite } from "../src/spec/review-tests";
+import { runSpec } from "../src/loop";
+import { OpenAICompatibleProvider, PROVIDER_DEFAULTS } from "../src/inference";
+import { renderEvent } from "../src/render";
+import type { ILoopEvent } from "../src/loop";
+
+const seed = process.env.TSFORGE_SEED ?? "money";
+const evalsRoot = join(import.meta.dir, "..", "..", "..", "evals");
+const seedDir = join(evalsRoot, seed);
+
+const provider = new OpenAICompatibleProvider({
+  baseUrl: process.env.TSFORGE_BASE_URL ?? PROVIDER_DEFAULTS.baseUrl,
+  model: process.env.TSFORGE_MODEL ?? PROVIDER_DEFAULTS.model,
+  apiKey: process.env.TSFORGE_API_KEY,
+  repetitionPenalty:
+    process.env.TSFORGE_REPETITION_PENALTY === undefined
+      ? undefined
+      : Number(process.env.TSFORGE_REPETITION_PENALTY),
+});
+
+// OFFLINE teacher: vets the generated suite for unsatisfiable / over-strict /
+// ambiguous assertions before it becomes the gate. Point it at a flagship via
+// TSFORGE_JUDGE_URL/MODEL/KEY; with no override it falls back to the local model
+// (so the step still runs, just weaker). Never a runtime dependency.
+const judge = new OpenAICompatibleProvider({
+  baseUrl:
+    process.env.TSFORGE_JUDGE_URL ??
+    process.env.TSFORGE_BASE_URL ??
+    PROVIDER_DEFAULTS.baseUrl,
+  model:
+    process.env.TSFORGE_JUDGE_MODEL ??
+    process.env.TSFORGE_MODEL ??
+    PROVIDER_DEFAULTS.model,
+  apiKey: process.env.TSFORGE_JUDGE_KEY ?? process.env.TSFORGE_API_KEY,
+});
+
+const specText = await Bun.file(join(seedDir, `${seed}.spec.md`)).text();
+const spec = parseSpec(specText);
+const task = spec.tasks[0];
+
+if (task === undefined) {
+  throw new Error(`spec ${seed} has no tasks`);
+}
+
+const implFile = task.files[0];
+const testFile = (task.context ?? []).find((f) => f.endsWith(".test.ts"));
+
+if (implFile === undefined || testFile === undefined) {
+  throw new Error(
+    `spec ${seed} task needs a files: impl and a *.test.ts context`
+  );
+}
+
+// Fresh workdir, copied from the seed EXCEPT the hand-written test — the spec
+// goes in genuinely untested. (The impl isn't in the seed either; the stub
+// generation creates it.)
+const d = new Date();
+const p = (n: number): string => String(n).padStart(2, "0");
+const stamp = `${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}-${p(d.getHours())}${p(d.getMinutes())}${p(d.getSeconds())}`;
+const runId = `gentests-${seed}-${stamp}`;
+const runDir = join(evalsRoot, runId);
+
+await mkdir(runDir, { recursive: true });
+
+for (const file of await readdir(seedDir)) {
+  if (file === testFile) {
+    continue;
+  }
+
+  await Bun.write(join(runDir, file), Bun.file(join(seedDir, file)));
+}
+
+const onEvent = (e: ILoopEvent): void => {
+  process.stdout.write(renderEvent(e, { color: true }));
+};
+
+// Phase 1 — generate tests + stub from criteria, verified RED.
+process.stdout.write(
+  `\n=== phase 1: generate tests for ${seed} → ${testFile} ===\n`
+);
+
+const gen = await generateTests(provider, runDir, {
+  testFile,
+  implFile,
+  goal: spec.title,
+  criteria: specText,
+  maxAttempts: 3,
+  onEvent,
+});
+
+process.stdout.write(
+  `\ntests: ${gen.ok ? "RED & runnable" : "FAILED to produce"} · ${gen.testCount} tests · ${gen.attempts} attempt(s)\n`
+);
+
+if (!gen.ok) {
+  process.stdout.write(`\nstopping: could not generate a real suite.\n`);
+  process.exit(1);
+}
+
+// Phase 1.5 — OFFLINE teacher review: catch unsatisfiable / over-strict /
+// ambiguous assertions before they become the gate. Corrections are re-verified
+// RED (reverted if they break it), so this can only ever hand phase 2 a sound
+// suite.
+process.stdout.write(`\n=== phase 1.5: review generated tests (offline) ===\n`);
+
+const review = await reviewAndFixSuite(judge, runDir, {
+  testFile,
+  implFile,
+  goal: spec.title,
+  criteria: specText,
+  onEvent,
+});
+
+process.stdout.write(
+  `\nreview: ${review.findings.length} finding(s), correction ${review.applied ? "applied" : "not applied"}\n`
+);
+
+// Phase 2 — drive the stub to green against the model's own generated tests.
+process.stdout.write(
+  `\n=== phase 2: implement ${seed} against the generated tests ===\n`
+);
+
+const result = await runSpec(spec, runDir, provider, { onEvent });
+
+process.stdout.write(
+  `\nimplement: ${result.status === "done" ? "GREEN" : "blocked"}\n`
+);
+process.stdout.write(`\nrun dir → ${runDir}\n`);

package/scripts/headless-build.ts

@@ -0,0 +1,292 @@
+// Run a from-scratch web build against the LIVE model, NON-interactively — the
+// missing piece for an autonomous improve-the-harness loop. Each run gets its OWN
+// dir under evals/runs/ (node_modules symlinked), runs the staged build with
+// the real web gate, streams progress, and writes a --log-style JSONL so
+// `cli-metrics.ts` can score it (repair turns, tokens, what slipped, salvaged).
+//
+// Run:  bun run packages/core/scripts/headless-build.ts "build a kanban board" [react|vanilla] [dir]
+//   or:  bun run packages/core/scripts/headless-build.ts --app <slug|index> [react|vanilla] [dir]
+//        (--app builds a FIXED benchmark-catalog domain with the full generation spec)
+//   then: bun run packages/core/scripts/cli-metrics.ts
+import {
+  appendFileSync,
+  existsSync,
+  mkdirSync,
+  symlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+import {
+  buildWebFix,
+  buildWebGate,
+  buildWebTypeGate,
+  buildWebTscCheck,
+  installWebDeps,
+  makeFileLinter,
+  scaffoldWeb,
+  webGuidance,
+} from "../src/detect-gate";
+import { OpenAICompatibleProvider, PROVIDER_LIMITS } from "../src/inference";
+import { resolveActiveModel, resolveApiKey } from "../src/models-config";
+import { Session, LOOP_LIMITS, type Reporter } from "../src/loop";
+import { renderEvent } from "../src/render";
+import { logsDir } from "../src/session-store";
+import type { WebFramework } from "../src/web-templates";
+import {
+  BENCHMARK_CATALOG,
+  buildBenchmarkPrompt,
+  findBenchmarkApp,
+} from "./benchmark-catalog";
+
+interface IBuildRequest {
+  /** The full task prompt handed to the model. */
+  readonly prompt: string;
+  /** A short slug for naming the snapshot (the benchmark slug, or "adhoc"). */
+  readonly label: string;
+  /** argv index where [framework] [dir] start (shifts when --app is used). */
+  readonly tailStart: number;
+  /** Declared entities (catalog builds) — the coverage gate enforces each has UI;
+   *  empty for ad-hoc prompts (no enforced entity list). */
+  readonly entities: readonly string[];
+}
+
+/** Resolve the build request from argv: either a benchmark --app or a free prompt. */
+function resolveRequest(): IBuildRequest | undefined {
+  if (process.argv[2] === "--app") {
+    const selector = process.argv[3] ?? "";
+    const app = findBenchmarkApp(selector);
+
+    if (app === undefined) {
+      const list = BENCHMARK_CATALOG.map(
+        (a, i) => `  ${String(i + 1)}. ${a.slug} — ${a.name}`
+      ).join("\n");
+
+      process.stderr.write(
+        `unknown benchmark "${selector}". catalog:\n${list}\n`
+      );
+
+      return undefined;
+    }
+
+    return {
+      prompt: buildBenchmarkPrompt(app),
+      label: app.slug,
+      tailStart: 4,
+      entities: app.entities,
+    };
+  }
+
+  const prompt = process.argv[2];
+
+  if (prompt === undefined || prompt.length === 0) {
+    return undefined;
+  }
+
+  return { prompt, label: "adhoc", tailStart: 3, entities: [] };
+}
+
+/** Tee progress to the terminal, a human-readable agent.log IN THE RUN DIR (so you
+ *  can `tail -f <rundir>/agent.log` right next to the code), and a JSONL log for
+ *  cli-metrics. */
+function makeReporter(logFile: string, agentLog: string): Reporter {
+  return (event) => {
+    process.stdout.write(renderEvent(event, { color: true }));
+    appendFileSync(agentLog, renderEvent(event, { color: false }));
+    appendFileSync(logFile, `${JSON.stringify({ t: Date.now(), ...event })}\n`);
+  };
+}
+
+/** A canonical scaffold whose node_modules we install ONCE and symlink into every
+ *  run dir — so each build gets a fresh isolated directory without a per-run
+ *  `bun install`. Returns the absolute node_modules path to symlink. */
+async function ensureDepsCache(
+  evalsRoot: string,
+  framework: WebFramework
+): Promise<string> {
+  const cacheDir = join(evalsRoot, `.web-cache-${framework}`);
+  const nodeModules = join(cacheDir, "node_modules");
+
+  if (!existsSync(nodeModules)) {
+    await scaffoldWeb(cacheDir, framework);
+    await installWebDeps(cacheDir);
+  }
+
+  return nodeModules;
+}
+
+/**
+ * Plan mode (headless): run the design phase, write the model's build plan to
+ * `plan.md` in the run dir, then proceed to implement — headless never blocks for
+ * approval (interactive plan mode does the human review). The plan.md is the
+ * reviewable artifact: entities, routes, what "done" means, modeling decisions.
+ */
+async function runPlanned(
+  session: Session,
+  prompt: string,
+  framework: WebFramework,
+  dir: string
+): Promise<Awaited<ReturnType<Session["buildStaged"]>>> {
+  const designed = await session.designBuild(
+    prompt,
+    {},
+    buildWebTypeGate(framework).command
+  );
+
+  if (designed.status === "interrupted") {
+    return designed;
+  }
+
+  const plan = await session.generatePlan();
+  const planPath = join(dir, "plan.md");
+
+  writeFileSync(planPath, `${plan}\n`);
+  process.stdout.write(`\n📋 plan → ${planPath}\n`);
+
+  return session.implementBuild("", {});
+}
+
+async function main(): Promise<void> {
+  // `--plan` (plan mode): after the design phase, write the model's build plan to
+  // plan.md and proceed (headless never blocks for approval). Strip it before any
+  // positional-arg logic so it can sit anywhere on the command line.
+  const planMode = process.argv.includes("--plan");
+
+  if (planMode) {
+    process.argv = process.argv.filter((a) => a !== "--plan");
+  }
+
+  const request = resolveRequest();
+
+  if (request === undefined) {
+    process.stderr.write(
+      'usage: headless-build.ts "<prompt>" [react|vanilla] [dir]\n' +
+        "   or: headless-build.ts --app <slug|index> [react|vanilla] [dir]\n"
+    );
+    process.exit(2);
+  }
+
+  const { prompt, label, tailStart, entities } = request;
+  const framework: WebFramework =
+    process.argv[tailStart] === "vanilla" ? "vanilla" : "react";
+  // The model comes from the registry (~/.tsforge/models.json) unless TSFORGE_*
+  // env overrides it — so a catalog run can target a cloud flagship by editing the
+  // registry's `active` (or setting env), no code change.
+  const { entry } = await resolveActiveModel();
+  const model = entry.model;
+  const envWindow = Number(process.env.TSFORGE_CONTEXT_WINDOW);
+  const contextWindow =
+    entry.contextWindow ??
+    (Number.isFinite(envWindow) && envWindow > 0 ? envWindow : 262_144);
+
+  // EACH RUN GETS ITS OWN DIRECTORY: evals/runs/<timestamp>-<label>/ — so you
+  // always know exactly where this build's code is, and prior runs are never
+  // clobbered. Override with the trailing arg. node_modules is symlinked from a
+  // one-time install cache, so a fresh dir doesn't mean a fresh `bun install`.
+  const evalsRoot = join(import.meta.dir, "..", "..", "..", "evals");
+  const stamp = new Date()
+    .toISOString()
+    .replace(/[:T]/g, "-")
+    .replace(/\..+$/, "");
+  const dir =
+    process.argv[tailStart + 1] ?? join(evalsRoot, "runs", `${stamp}-${label}`);
+
+  mkdirSync(dir, { recursive: true });
+  await scaffoldWeb(dir, framework);
+
+  if (!existsSync(join(dir, "node_modules"))) {
+    const cache = await ensureDepsCache(evalsRoot, framework);
+
+    symlinkSync(cache, join(dir, "node_modules"), "dir");
+  }
+
+  const agentLog = join(dir, "agent.log");
+  const logFile = join(logsDir(), `${stamp}-headless.jsonl`);
+
+  mkdirSync(logsDir(), { recursive: true });
+
+  const provider = new OpenAICompatibleProvider({
+    baseUrl: entry.baseUrl,
+    model: entry.model,
+    apiKey: resolveApiKey(entry),
+    maxTokens: entry.maxTokens ?? PROVIDER_LIMITS.maxTokens,
+  });
+
+  const report = makeReporter(logFile, agentLog);
+
+  process.stdout.write(
+    `\n📁 BUILD DIR: ${dir}\n` +
+      `   follow it:  tail -f ${agentLog}\n` +
+      `   ${framework} scaffold ready (deps symlinked)\n\n`
+  );
+  report({
+    kind: "start",
+    task: "session",
+    message: `model ${model} · context window ${contextWindow}`,
+    model,
+    contextWindow,
+  });
+
+  const session = await Session.create({
+    provider,
+    cwd: dir,
+    files: ["**/*"],
+    // For catalog builds, APPEND an entity-coverage check to the gate: the app
+    // cannot go green until every declared entity has real UI (not just types) —
+    // so the model can't satisfice on a subset (4-of-8 entities greened before).
+    accept:
+      entities.length > 0
+        ? `${buildWebGate(framework).command} && bun "${join(import.meta.dir, "coverage-check.ts")}" "${dir}" ${entities
+            .map((e) => JSON.stringify(e))
+            .join(" ")}`
+        : buildWebGate(framework).command,
+    fix: buildWebFix(framework),
+    incrementalCheck: buildWebTscCheck(),
+    // WRITE-TIME LINT: surface the gate's eslint moat rules (no-as, I-prefix,
+    // prefer-template) on each file the instant it's written — tsc can't see them,
+    // so without this they pile up unseen until the gate (a run log showed 12 `as`
+    // casts accumulating that way). cwd = the run dir so vendored ignores resolve.
+    lintFile: makeFileLinter(framework, dir),
+    // Offer the themed-UI-primitives tool so the model generates button/card/input/
+    // etc. (tested, theme-coherent) instead of re-authoring them every build.
+    scaffoldUi: framework === "react",
+    guidance: webGuidance(framework),
+    contextWindow,
+    // ADAPTIVE THINKING (measured ~80% of build time is REPAIR): default thinking
+    // OFF for fast creation; the Session flips it ON automatically while errors are
+    // outstanding (interim/gate RED) so repair CONVERGES instead of oscillating to
+    // the turn cap (which thinking-off-everywhere did). Best of both: fast create +
+    // convergent repair, and no 5-min pre-write spiral (thinking only on repair).
+    enableThinking: false,
+    // A from-scratch multi-domain app needs more than the 40 default. The full
+    // benchmark spec (8+ entities, 40-60 files) needs more still: pm-platform AND
+    // hospital-scheduling hit an 80-turn cap (→ 130). Then the ENTITY-COVERAGE gate
+    // (cycle-31) raised the bar again: the model can no longer satisfice on 4 of 8
+    // entities — it must build ALL of them. A fast flagship (deepseek) hit the 130
+    // phase-2 cap while GENUINELY converging on the full 8 (it had built 7 of 8's
+    // routes, coverage shrinking 4→1). A complete 8-entity app is more than 130
+    // turns of work → 180 so the now-mandatory full build has room to finish.
+    maxTurns: LOOP_LIMITS.webMaxTurns,
+    report,
+  });
+
+  const result = planMode
+    ? await runPlanned(session, prompt, framework, dir)
+    : await session.buildStaged(
+        prompt,
+        {},
+        buildWebTypeGate(framework).command
+      );
+
+  // The run dir IS the persistent, runnable artifact (per-run, never clobbered):
+  // `cd <dir> && bun run dev` (node_modules is symlinked). No separate snapshot.
+  process.stdout.write(
+    `\n[${result.status} · ${result.turns} turn(s)]\n` +
+      `📁 code:      ${dir}\n` +
+      `   agent log: ${agentLog}\n` +
+      `   jsonl:     ${logFile}\n` +
+      "   score it:  bun run packages/core/scripts/cli-metrics.ts\n"
+  );
+  process.exit(result.status === "done" ? 0 : 1);
+}
+
+await main();