@maycombhq/atticus 0.0.0-stage → 2.0.0-beta.3

package/dist/chunk-TAVDMUV3.js

@@ -0,0 +1,189 @@
+import { createRequire as __atticusCreateRequire } from "node:module";
+import { fileURLToPath as __atticusFileURLToPath } from "node:url";
+var require = __atticusCreateRequire(import.meta.url);
+var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
+var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
+import {
+  askHosts
+} from "./chunk-4BMDGTED.js";
+import {
+  driftAfterScan
+} from "./chunk-RCU3MPY2.js";
+import {
+  diffCatalogs,
+  diffIsEmpty,
+  readCatalog,
+  scanEstate,
+  writeCatalog
+} from "./chunk-OLWFG75W.js";
+import {
+  loadRepos
+} from "./chunk-KJPMEAI4.js";
+import {
+  catalogDirOf
+} from "./chunk-S2A7YC3Q.js";
+import {
+  LockHeldError,
+  acquireLock
+} from "./chunk-D3PO4DOZ.js";
+
+// packages/cli/dist/scan-commands.js
+import { join } from "node:path";
+function diffLines(d) {
+  if (diffIsEmpty(d))
+    return ["No catalog changes."];
+  const lines = [
+    `${d.added.length} added, ${d.removed.length} removed, ${d.changed.length} changed, ${d.evidenceOnly.length} with new evidence only`,
+    ...d.added.map((r) => `+ ${r.kind}/${r.id}`),
+    ...d.removed.map((r) => `- ${r.kind}/${r.id}`),
+    ...d.changed.map((r) => `~ ${r.kind}/${r.id} (${r.fields.join(", ")})`)
+  ];
+  return lines;
+}
+function driftLine(d) {
+  const head = `Drift check for ${d.change} (${d.state})`;
+  if (d.error)
+    return `${head} couldn't run: ${d.error}`;
+  if (d.round === void 0)
+    return `${head}: no drift.`;
+  const what = `${d.open} open finding${d.open === 1 ? "" : "s"}${d.blocking ? ` (${d.blocking} blocking)` : ""}`;
+  return `${head}: ${what} in review/drift/${d.round}${d.unchanged ? ", nothing new" : ""}.`;
+}
+async function scanCommand(root, o, io) {
+  if (o.repos && o.repos.length > 0) {
+    const known = new Set((await loadRepos(root)).map((r) => r.id));
+    const unknown = o.repos.filter((r) => !known.has(r));
+    if (unknown.length > 0) {
+      io.err(`Not in any repos.manifest.yaml: ${unknown.join(", ")}`);
+      return 2;
+    }
+  }
+  let lock;
+  if (!o.dryRun) {
+    try {
+      lock = await acquireLock(root, "scan", "scan");
+    } catch (e) {
+      if (e instanceof LockHeldError) {
+        io.err(e.message);
+        return 1;
+      }
+      throw e;
+    }
+    if (lock.interrupted)
+      io.err(`The last scan (started ${lock.interrupted.startedAt}) stopped before it finished; this one brings the catalog up to date.`);
+  }
+  try {
+    if (o.ref) {
+      const { scanBranch } = await import("./chunk-EHVTK3UE.js");
+      return await scanBranch(root, o.ref, {
+        ...o.repos ? { repos: o.repos } : {},
+        ...o.full ? { full: true } : {},
+        ...o.json ? { json: true } : {}
+      }, io);
+    }
+    return await scanLocked(root, o, io);
+  } finally {
+    await lock?.release();
+  }
+}
+async function scanLocked(root, o, io) {
+  const out = join(catalogDirOf(root), "generated");
+  const before = await readCatalog(out, { cacheRoot: root });
+  const started = Date.now();
+  const scan = await scanEstate({
+    root,
+    ...o.repos ? { repos: o.repos } : {},
+    ...o.full ? { cache: null } : {}
+  });
+  const diff = diffCatalogs(before.records, scan.records);
+  const write = o.dryRun ? void 0 : await writeCatalog(out, scan.records);
+  const drift = write && !o.noDrift ? await driftAfterScan(root) : [];
+  const hosts = write ? await askHosts(root, scan.records, { command: "atticus scan" }) : { raised: [], open: [], lines: [] };
+  const problems = [
+    ...before.problems.map((p) => ({ source: `catalog/generated/${p.file}`, message: p.message })),
+    ...scan.problems
+  ];
+  const seen = /* @__PURE__ */ new Set();
+  const warnings = scan.repos.flatMap((r) => r.warnings.map((w) => ({ repo: r.repo, ...w })).filter((w) => {
+    const k = `${w.repo}\0${w.path ?? ""}\0${w.message}`;
+    if (seen.has(k))
+      return false;
+    seen.add(k);
+    return true;
+  }));
+  if (o.json) {
+    io.out(JSON.stringify({
+      stats: scan.stats,
+      diff,
+      problems,
+      warnings,
+      coverage: scan.coverage,
+      unmodelled: scan.unmodelled,
+      notes: scan.notes,
+      written: write !== void 0,
+      files: write ?? null,
+      drift,
+      questions: [...hosts.raised, ...hosts.open].map((q) => q.id)
+    }, null, 2));
+  } else {
+    const s = scan.stats;
+    io.out(`Scanned ${s.repos} repos in ${((Date.now() - started) / 1e3).toFixed(1)}s (${s.ranRuns} extractor runs, ${s.cachedRuns} from cache)`);
+    io.out(`${s.records} records: ${s.interfaces} interfaces (${s.verified} verified), ${s.unresolved} loose ends`);
+    const joined = scan.coverage.reduce((n, c) => n + c.joined, 0);
+    const found = joined + scan.coverage.reduce((n, c) => n + c.open, 0);
+    const unread = scan.coverage.reduce((n, c) => n + c.unreadFiles, 0);
+    io.out(`Joined ${joined} of ${found} calls, listeners and endpoints found (${found ? Math.round(joined / found * 100) : 100}%)` + (unread ? `; ${unread} file${unread === 1 ? " uses" : "s use"} a client library with nothing read (atticus scan --warnings)` : ""));
+    for (const c of scan.coverage)
+      for (const r of c.redraft)
+        io.out(`Rule ${r.dialect} on ${c.repo} ${r.why === "tests-fail" ? "fails its own tests, so this scan didn't use it" : "read nothing there"}; have your assistant re-draft it: atticus onboard ${c.repo} --name ${r.dialect} (then onboard accept ${r.dialect} --replace)`);
+    const toOnboard = scan.coverage.filter((c) => c.needsOnboarding);
+    if (toOnboard.length)
+      io.out(`Read nothing from ${toOnboard.length === 1 ? "1 repo" : `${toOnboard.length} repos`} whose files no reader knows: ${toOnboard.map((c) => `${c.repo} (${c.unreadConfig.length} file${c.unreadConfig.length === 1 ? "" : "s"})`).join(", ")}. Have your assistant draft a dialect: atticus onboard ${toOnboard[0].repo}`);
+    for (const f of scan.unmodelled)
+      io.out(`House framework ${f.framework} is imported by ${f.repos.length} repos and no framework model covers it: ${f.repos.join(", ")}. Onboard it: atticus onboard framework ${f.name} --from <its source, JAR or package> --users ${f.repos.join(",")}`);
+    const idle = /* @__PURE__ */ new Map();
+    for (const c of scan.coverage)
+      for (const r of c.redraftFrameworks)
+        idle.set(r.framework, [...idle.get(r.framework) ?? [], c.repo]);
+    for (const [framework, repos] of idle)
+      io.out(`Framework model ${framework} read nothing in ${repos.join(", ")}, which import${repos.length === 1 ? "s" : ""} it; the framework may have changed. Have your assistant re-draft it: atticus onboard framework ${framework} --from <its source, JAR or package> --users ${repos.join(",")} (then onboard accept framework ${framework} --replace)`);
+    for (const l of diffLines(diff))
+      io.out(l);
+    if (write)
+      io.out(`catalog/generated: ${write.written} written, ${write.unchanged} unchanged, ${write.removed} removed`);
+    else
+      io.out("Dry run: nothing written.");
+    for (const d of drift)
+      io.out(driftLine(d));
+    for (const l of hosts.lines)
+      io.out(l);
+    for (const n of scan.notes)
+      io.out(`note: ${n}`);
+    if (o.warnings)
+      for (const w of warnings)
+        io.out(`warning: ${w.repo}: ${w.path ? `${w.path}: ` : ""}${w.message}`);
+    else if (warnings.length)
+      io.out(`${warnings.length} warning${warnings.length === 1 ? "" : "s"}: atticus scan --warnings lists ${warnings.length === 1 ? "it" : "them"}`);
+    for (const p of problems)
+      io.err(`${"repo" in p && p.repo ? `${p.repo}: ` : ""}${p.source}: ${p.message}`);
+  }
+  return problems.length > 0 ? 1 : 0;
+}
+async function catalogDiff(a, b, json, io) {
+  const [x, y] = await Promise.all([readCatalog(a), readCatalog(b)]);
+  for (const p of [...x.problems, ...y.problems])
+    io.err(`${p.file}: ${p.message}`);
+  const d = diffCatalogs(x.records, y.records);
+  if (json)
+    io.out(JSON.stringify(d, null, 2));
+  else
+    for (const l of diffLines(d))
+      io.out(l);
+  return diffIsEmpty(d) && x.problems.length + y.problems.length === 0 ? 0 : 1;
+}
+
+export {
+  diffLines,
+  scanCommand,
+  catalogDiff
+};

package/dist/chunk-TBSQJ6IV.js

@@ -0,0 +1,324 @@
+import { createRequire as __atticusCreateRequire } from "node:module";
+import { fileURLToPath as __atticusFileURLToPath } from "node:url";
+var require = __atticusCreateRequire(import.meta.url);
+var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
+var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
+import {
+  contextFlags,
+  contextLines
+} from "./chunk-R6RY4Q5T.js";
+import {
+  runDesignBench
+} from "./chunk-STUPFGXY.js";
+import "./chunk-RYSCLMU3.js";
+import "./chunk-ZUIAOKXI.js";
+import "./chunk-DPC5Y5DL.js";
+import "./chunk-6SCVQZX5.js";
+import "./chunk-65NYPGRC.js";
+import {
+  TARGET_DIR,
+  architectureStage,
+  checkStageDraft,
+  featureStage,
+  formatDraftProblems,
+  smallStage,
+  stageEnd,
+  stageGate,
+  storiesStage
+} from "./chunk-VPTTCYOC.js";
+import "./chunk-L6SGQIR3.js";
+import {
+  gateStatus,
+  ownerWaitsLine
+} from "./chunk-7UFQZXZA.js";
+import {
+  changeFolder,
+  loadChangeContext
+} from "./chunk-56YQ6ROQ.js";
+import "./chunk-4AK7IBVP.js";
+import "./chunk-7JUKDRSZ.js";
+import "./chunk-OLWFG75W.js";
+import "./chunk-L24C55VN.js";
+import "./chunk-PAMPPUR6.js";
+import "./chunk-23W7VWKR.js";
+import "./chunk-7EKXJZ2Y.js";
+import "./chunk-MC3H7736.js";
+import "./chunk-T6AIP7H5.js";
+import "./chunk-KJPMEAI4.js";
+import "./chunk-GQ4N4WKF.js";
+import {
+  RuntimeConfigError,
+  runtimeForCli
+} from "./chunk-CNUKCS2T.js";
+import {
+  changesRelOf,
+  orgPackDirOf
+} from "./chunk-S2A7YC3Q.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/stage-commands.js
+import { existsSync } from "node:fs";
+import { copyFile, mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+var plural = (n, w) => `${n} ${w}${n === 1 ? "" : "s"}`;
+var str = (v) => typeof v === "string" && v.trim() ? v : void 0;
+async function runtimeOf(root, mode, io) {
+  try {
+    return (await runtimeForCli(root, mode ? { mode } : {})).runtime;
+  } catch (e) {
+    if (e instanceof RuntimeConfigError) {
+      io.err(e.message);
+      return void 0;
+    }
+    throw e;
+  }
+}
+var NAMES = {
+  feature: "feature",
+  architecture: "architecture",
+  stories: "stories",
+  small: "fast path"
+};
+async function stageCheck(root, change, stage, file, io) {
+  const stages = ["feature", "architecture", "stories", "small"];
+  if (!change || !stage || !file || !stages.includes(stage)) {
+    io.err(`Usage: atticus stage check <change> <${stages.join("|")}> <file>, for example: atticus stage check add-fraud-check architecture .runs/add-fraud-check/<run>/architecture-answer.yaml`);
+    return 2;
+  }
+  const text = await readFile(resolve(root, file), "utf8").catch(() => void 0);
+  if (text === void 0) {
+    io.err(`${file} doesn't exist: write the draft there first.`);
+    return 2;
+  }
+  try {
+    const problems = await checkStageDraft(root, change, stage, text);
+    io.out(formatDraftProblems(problems));
+    return problems.length ? 1 : 0;
+  } catch (e) {
+    if (e instanceof Error && ["PlannerError", "ChangeError"].includes(e.name)) {
+      io.err(e.message);
+      return 1;
+    }
+    throw e;
+  }
+}
+var WORDS = {
+  feature: "feature placement",
+  architecture: "target flows",
+  stories: "stories",
+  small: "plan"
+};
+function wroteLines(r) {
+  if (!r.files.length)
+    return [];
+  if (!r.changed)
+    return [`Wrote ${r.files.join(", ")}.`];
+  if (!r.changed.length)
+    return [`Kept ${r.byPerson ? "your" : "the"} ${WORDS[r.stage]}: nothing changed.`];
+  const kept = r.files.filter((f) => !r.changed.includes(f));
+  return [
+    `Wrote ${r.changed.join(", ")}${kept.length ? ` (${kept.join(", ")} ${kept.length === 1 ? "is" : "are"} as it was)` : ""}.`.replace(/are as it was\)/, "are as they were)")
+  ];
+}
+async function ownerLine(root, r) {
+  if (r.state !== "done")
+    return void 0;
+  const gate = stageGate(await loadChangeContext(root), r.stage);
+  if (!gate)
+    return void 0;
+  const s = await gateStatus(root, r.change, gate).catch(() => void 0);
+  return s ? ownerWaitsLine(s, r.change) : void 0;
+}
+function printStage(r, rerun, io, extra = [], owner) {
+  for (const n of r.notes)
+    io.out(n);
+  for (const l of contextLines(r.context))
+    io.out(l);
+  const current = r.findings.filter((f) => f.blocking && !f.question);
+  if (r.state === "waiting") {
+    if (current.length) {
+      io.out(`The last draft went back to your assistant with ${plural(current.length, "finding")}:`);
+      for (const f of current)
+        io.out(`  ${f.message}`);
+    }
+    const w = r.waiting;
+    io.report?.({ handoff: { runId: w.runId, ...w.lens ? { lens: w.lens } : {} } });
+    io.out(w.lens ? `Handed the critic's ${w.lens} lens to your assistant to review the ${NAMES[r.stage]} draft (run ${w.runId}). When it is done, run: atticus handoff done ${w.runId}, then ${rerun} --resume ${w.runId}` : `Handed the ${NAMES[r.stage]} draft to your assistant (run ${w.runId}). When it is done, run: atticus handoff done ${w.runId}, then ${rerun} --resume ${w.runId}`);
+    return 1;
+  }
+  if (r.state === "questions") {
+    for (const l of stageEnd(r, rerun))
+      io.out(l);
+    return 1;
+  }
+  io.out(
+    // B-place: a run that resumes the last draft's review, or finds nothing to draft, drafts none.
+    `The ${NAMES[r.stage]} stage is done after ${plural(r.iteration, "draft")} (${r.drafts ? `${plural(r.drafts, "draft")} this run` : "none drafted this run"}): nothing blocking is open and no question is waiting.`
+  );
+  if (owner)
+    io.out(owner);
+  for (const l of wroteLines(r))
+    io.out(l);
+  for (const l of extra)
+    io.out(l);
+  io.out(`Open the stage's pull request for a person to approve: ${r.pr}`);
+  return 0;
+}
+async function stageCli(root, positionals, values, io, deps = {}) {
+  const [group, command, arg] = positionals;
+  const json = values.json === true;
+  const isStage = group === "change" && (command === "feature" || command === "architecture" || command === "small") || group === "plan" && command === "stories" && !!arg && existsSync(join(changeFolder(root, arg), TARGET_DIR));
+  if (group === "bench" && command === "design")
+    return benchDesign(root, values, io, deps);
+  if (!isStage)
+    return void 0;
+  if (!arg) {
+    io.err(`change ${command} needs a change id, for example: atticus change ${command} add-fraud-check`);
+    return 2;
+  }
+  const flags = contextFlags(values);
+  if ("error" in flags) {
+    io.err(flags.error);
+    return 2;
+  }
+  const runtime = deps.runtime ?? await runtimeOf(root, str(values.mode), io);
+  if (!runtime)
+    return 2;
+  const o = {
+    context: flags.context,
+    runtime,
+    ...deps.criticRuntime !== void 0 ? { criticRuntime: deps.criticRuntime } : {},
+    ...deps.now ? { now: deps.now } : {},
+    ...str(values.resume) ? { resume: str(values.resume) } : {},
+    ...values.force === true ? { force: true } : {}
+  };
+  try {
+    if (command === "feature") {
+      const figma = str(values["from-figma"]);
+      const r2 = await featureStage(root, arg, {
+        ...o,
+        ...figma ? { fromFigma: resolve(figma) } : {}
+      });
+      if (json)
+        return out(io, r2);
+      const a = r2.answer;
+      const extra = a ? [
+        `Touches ${plural(a.features.length, "feature")} and ${plural(a.flows.length, "flow")}; needs ${plural(a.newFlows.length, "new flow")}; ${plural(a.gaps.length, "gap")}; ${plural(a.conflicts.length, "other change")} in flight on the same flows or systems.`,
+        `Next: atticus change architecture ${arg} (or /atticus-architecture ${arg}) once the feature PR is merged.`
+      ] : [];
+      return printStage(r2, `atticus change feature ${arg}`, io, extra, await ownerLine(root, r2));
+    }
+    if (command === "architecture") {
+      const r2 = await architectureStage(root, arg, o);
+      if (json)
+        return out(io, r2);
+      const extra = r2.answer ? [
+        `Target flows: ${r2.answer.flows.map((d) => `${d.flow} (${d.change}, ${plural(d.steps.length, "step")})`).join(", ")}, in ${changesRelOf(root)}/${arg}/${TARGET_DIR}/.`,
+        `Next: atticus plan stories ${arg} (or /atticus-stories ${arg}) once the architecture PR is merged.`
+      ] : [];
+      return printStage(r2, `atticus change architecture ${arg}`, io, extra, await ownerLine(root, r2));
+    }
+    if (command === "small") {
+      const r2 = await smallStage(root, arg, o);
+      if (json)
+        return out(io, r2);
+      const tasks2 = r2.stories.reduce((n, s) => n + s.tasks.length, 0);
+      const extra = r2.answer ? [
+        `Placed on ${plural(r2.answer.flows.length, "flow")}; ${plural(r2.answer.targetFlows.length, "target flow")}; ${r2.stories.length} ${r2.stories.length === 1 ? "story" : "stories"} and ${plural(tasks2, "task")}, from the target flows; ${r2.requests.length} ${r2.requests.length === 1 ? "request or process" : "requests and processes"} suggested in requests.md. A person raises each one.`,
+        `Next: once the pull request is merged, the tasks (atticus task context ${arg} <task>, or /atticus-task ${arg} <task>).`
+      ] : [];
+      return printStage(r2, `atticus change small ${arg}`, io, extra, await ownerLine(root, r2));
+    }
+    const r = await storiesStage(root, arg, o);
+    if (json)
+      return out(io, r);
+    const tasks = r.stories.reduce((n, s) => n + s.tasks.length, 0);
+    return printStage(r, `atticus plan stories ${arg}`, io, [
+      `${r.stories.length} ${r.stories.length === 1 ? "story" : "stories"} and ${plural(tasks, "task")} in ${plural(new Set(r.stories.map((s) => s.repo)).size, "repo")}, from the target flows; ${r.requests.length} ${r.requests.length === 1 ? "request or process" : "requests and processes"} suggested from the knowledge items, in requests.md. A person raises each one.`
+    ], await ownerLine(root, r));
+  } catch (e) {
+    if (e instanceof Error && ["PlannerError", "ChangeError", "ChangeFileError", "RuntimeConfigError"].includes(e.name)) {
+      io.err(e.message);
+      return 1;
+    }
+    throw e;
+  }
+}
+function out(io, r) {
+  io.out(JSON.stringify(r, null, 2));
+  return r.state === "done" ? 0 : 1;
+}
+var defaultCache = () => process.env.LOCALAPPDATA ? join(process.env.LOCALAPPDATA, "atticus", "bench") : join(homedir(), ".cache", "atticus", "bench");
+var pct = (x) => `${Math.round(x * 100)}%`;
+function printDesignScore(s, io) {
+  io.out(`Screens: ${s.screens.found} of ${s.screens.of} found${s.screens.missed.length ? ` (missed: ${s.screens.missed.join(", ")})` : ""}`);
+  io.out(`Fields: ${s.fields.found} of ${s.fields.of} found; precision ${pct(s.fields.precision)}, recall ${pct(s.fields.recall)}${s.fields.extra.length ? `; ${s.fields.extra.length} not in the reference` : ""}`);
+  io.out(`Backing: ${s.backing.correct} of ${s.backing.of} found fields classified right`);
+  for (const w of s.backing.wrong)
+    io.out(`  ${w.figmaId} "${w.label}": ${w.why}`);
+  io.out(`Actions: ${s.actions.found} of ${s.actions.of} found, ${s.actions.mapped} mapped right`);
+  for (const w of s.actions.wrong)
+    io.out(`  ${w.figmaId} "${w.label}": ${w.why}`);
+  io.out(`Gaps: ${s.gaps.found} of ${s.gaps.of} flagged; precision ${pct(s.gaps.precision)} of ${s.gaps.flagged} flagged`);
+  for (const g of s.gaps.missed)
+    io.out(`  missed: ${g}`);
+}
+async function benchDesign(root, values, io, deps) {
+  const bench = resolve(str(values.bench) ?? "bench");
+  if (!existsSync(join(bench, "design", "reference.yaml"))) {
+    io.err(`There is no design bench at ${join(bench, "design")}: run this from the Atticus repo, or give --bench <dir>.`);
+    return 2;
+  }
+  const cache = resolve(str(values.cache) ?? defaultCache());
+  const work = join(cache, "design");
+  const stateFile = join(work, "bench-state.json");
+  const resume = str(values.resume);
+  if (resume) {
+    const state = JSON.parse(await readFile(stateFile, "utf8").catch(() => "{}") || "{}");
+    if (state.runId !== resume) {
+      io.err(`${resume} isn't the run the design bench is waiting for${state.runId ? ` (it waits for ${state.runId})` : ""}.`);
+      return 2;
+    }
+  } else {
+    await mkdir(join(work, "org-pack"), { recursive: true });
+    await copyFile(join(orgPackDirOf(root), "runtime.yaml"), join(work, "org-pack", "runtime.yaml")).catch(() => {
+    });
+  }
+  const runtime = deps.runtime ?? await runtimeOf(work, str(values.mode), io);
+  if (!runtime)
+    return 2;
+  const now = deps.now ?? /* @__PURE__ */ new Date();
+  const r = await runDesignBench({ bench, runtime, now, ...resume ? { resume } : {} });
+  if (r.status === "waiting") {
+    await writeFile(stateFile, `${JSON.stringify({ runId: r.runId })}
+`, "utf8");
+    io.out(`Handed the design to your assistant (run ${r.runId}, in ${work}). When it is done: atticus handoff done ${r.runId} --root ${JSON.stringify(work)}, then atticus bench design --resume ${r.runId}`);
+    return 0;
+  }
+  const results = join(cache, "design-results");
+  await mkdir(results, { recursive: true });
+  const stamp = now.toISOString().replace(/\.\d{3}Z$/, "Z");
+  const file = join(results, `${stamp.replace(/[:.]/g, "-")}.json`);
+  await writeFile(file, `${JSON.stringify({ at: stamp, ...r }, null, 2)}
+`, "utf8");
+  await writeFile(stateFile, "{}\n", "utf8").catch(() => {
+  });
+  if (values.json === true) {
+    io.out(JSON.stringify(r.score, null, 2));
+    return 0;
+  }
+  io.out(`Design bench: ${join(bench, "design")} (${r.read.screens} screens, ${r.read.candidates} fields and actions read; ${plural(r.drafts, "draft")})`);
+  printDesignScore(r.score, io);
+  if (r.problems.length)
+    io.out(`The last draft still had ${plural(r.problems.length, "problem")} the checks found; they are in the results file.`);
+  io.out(`Details: ${file}`);
+  return 0;
+}
+export {
+  printDesignScore,
+  stageCheck,
+  stageCli,
+  wroteLines
+};