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

package/dist/chunk-PBS3OFNN.js

@@ -0,0 +1,113 @@
+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 {
+  loadCatalog
+} from "./chunk-2UIQBDJO.js";
+import {
+  buildStub,
+  checkStub,
+  startStub,
+  stubFromCatalog,
+  stubHandler
+} from "./chunk-65NYPGRC.js";
+import {
+  table
+} from "./chunk-VOGCSYOI.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-KJPMEAI4.js";
+import "./chunk-GQ4N4WKF.js";
+import "./chunk-CNUKCS2T.js";
+import "./chunk-S2A7YC3Q.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/stub-commands.js
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+var EXAMPLES = /* @__PURE__ */ new Set(["example", "examples", "schema-example", "schema-default"]);
+async function readStub(path, io) {
+  let text;
+  try {
+    text = await readFile(path, "utf8");
+  } catch {
+    io.err(`Can't read ${path}`);
+    return 2;
+  }
+  try {
+    return buildStub(text);
+  } catch (e) {
+    io.err(e.message);
+    return 1;
+  }
+}
+async function stubServe(root, specOrId, o, io, listen = startStub) {
+  const port = o.port ?? 4010;
+  if (!Number.isInteger(port) || port < 0 || port > 65535) {
+    io.err(`--port must be a whole number from 0 to 65535.`);
+    return 2;
+  }
+  let stub;
+  if (o.catalog) {
+    const { records, generated } = await loadCatalog(root, io);
+    if (generated === 0) {
+      io.err("The catalog is empty: read the repos first (atticus map <repo>, then atticus verify <repo> --write).");
+      return 1;
+    }
+    try {
+      stub = stubFromCatalog(records, specOrId);
+    } catch (e) {
+      io.err(e.message);
+      return 1;
+    }
+  } else {
+    const r = await readStub(resolve(root, specOrId), io);
+    if (typeof r === "number")
+      return r;
+    stub = r;
+  }
+  for (const w of stub.warnings)
+    io.err(`warning: ${w}`);
+  if (stub.routes.length === 0) {
+    io.err(`${stub.title} has no operations to serve.`);
+    return 1;
+  }
+  const server = await listen(stubHandler(stub), { port, host: o.host ?? "127.0.0.1" });
+  const n = stub.routes.length;
+  io.out(`Serving ${stub.title} at ${server.url} (${n} operation${n === 1 ? "" : "s"}).`);
+  for (const l of table(["METHOD", "PATH", "ANSWERS"], stub.routes.map((r) => [r.method, r.path, `${r.status} (${r.example})`])))
+    io.out(`  ${l}`);
+  if (stub.basePaths.length > 0)
+    io.out(`Paths also work under ${stub.basePaths.join(", ")}.`);
+  io.out("Ask for another documented response with X-Stub-Status: <code>. Stop with Ctrl+C.");
+  return 0;
+}
+async function stubCheck(specPath, io) {
+  const r = await readStub(resolve(specPath), io);
+  if (typeof r === "number")
+    return r;
+  for (const w of r.warnings)
+    io.err(`warning: ${w}`);
+  const rows = checkStub(r);
+  for (const l of table(["METHOD", "PATH", "STATUS", "EXAMPLE"], rows.map((x) => [x.method, x.path, String(x.status), x.example])))
+    io.out(l);
+  const generated = rows.filter((x) => x.example === "generated").length;
+  const withExamples = rows.filter((x) => EXAMPLES.has(x.example)).length;
+  if (generated === 0) {
+    io.out(`All ${rows.length} operation${rows.length === 1 ? " has" : "s have"} an example or no body (${withExamples} with examples).`);
+    return 0;
+  }
+  io.out(`${generated} of ${rows.length} operation${rows.length === 1 ? "" : "s"} ${generated === 1 ? "has" : "have"} no example: the stub builds ${generated === 1 ? "that body" : "those bodies"} from the schema. Add examples to control what it returns.`);
+  return 1;
+}
+export {
+  stubCheck,
+  stubServe
+};

package/dist/chunk-PFT3VTS4.js

@@ -0,0 +1,214 @@
+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 {
+  table
+} from "./chunk-VOGCSYOI.js";
+import {
+  findNeeds,
+  markNeed,
+  readNeeds
+} from "./chunk-VPTTCYOC.js";
+import "./chunk-L6SGQIR3.js";
+import "./chunk-7UFQZXZA.js";
+import "./chunk-56YQ6ROQ.js";
+import "./chunk-4AK7IBVP.js";
+import "./chunk-7JUKDRSZ.js";
+import "./chunk-OLWFG75W.js";
+import {
+  readKnowledge
+} from "./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 {
+  changesDirOf,
+  changesRelOf,
+  loadOrgPack,
+  orgPackDirOf
+} from "./chunk-S2A7YC3Q.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/needs-commands.js
+import { readdir } from "node:fs/promises";
+var plural = (n, w) => `${n} ${w}${n === 1 ? "" : "s"}`;
+var stamp = (d) => d.toISOString().replace(/\.\d{3}Z$/, "Z");
+var forWords = (t) => t === "change" ? "the change" : t.replace(":", " ");
+async function changeNeeds(root, change, o, deps, io) {
+  let runtime = deps.runtime;
+  if (!runtime)
+    try {
+      runtime = (await runtimeForCli(root, o.mode ? { mode: o.mode } : {})).runtime;
+    } catch (e) {
+      if (e instanceof RuntimeConfigError) {
+        io.err(e.message);
+        return 2;
+      }
+      throw e;
+    }
+  const k = await readKnowledge(root, { cacheRoot: root });
+  if (!k.items.length) {
+    io.err("There are no knowledge items to check the change against yet. Run atticus sources sync, then atticus knowledge scan.");
+    return 2;
+  }
+  const op = await loadOrgPack(orgPackDirOf(root));
+  const r = await findNeeds(root, change, {
+    runtime,
+    orgPack: op,
+    ...deps.now ? { now: deps.now } : {},
+    ...o.resume ? { resume: o.resume } : {},
+    maxAttempts: o.attempts ?? 3,
+    ...o.context ? { context: o.context } : {}
+  }).catch((e) => {
+    io.err(e.message);
+    return void 0;
+  });
+  if (!r)
+    return 2;
+  if (o.json) {
+    io.out(JSON.stringify(r, null, 2));
+    return r.status === "failed" ? 1 : 0;
+  }
+  if (r.status === "waiting") {
+    io.out(`Handed the change's needs to your assistant (run ${r.runId}). When it is done: atticus handoff done ${r.runId}, then atticus change needs ${change} --resume ${r.runId}`);
+    return 0;
+  }
+  if (r.status === "failed") {
+    io.err(`No answer passed the checks after ${plural(r.attempts.length, "attempt")}: ${r.attempts.at(-1)?.problems.join("; ") ?? "no run"}. Nothing was written.`);
+    return 1;
+  }
+  for (const l of contextLines(r.context))
+    io.out(l);
+  const f = r.file;
+  const open = f.needs.filter((n) => n.status === "open");
+  io.out(`${change} needs ${plural(f.needs.length, "thing")} from the organisation (${open.length} open), each checked against the change's own words.`);
+  for (const n of f.needs)
+    io.out(`  ${line(n)}`);
+  io.out(`Written to ${changesRelOf(root)}/${change}/needs.yaml and needs.md. Mark each with atticus needs done or atticus needs skip.`);
+  return 0;
+}
+function line(n) {
+  const box = n.status === "open" ? "[ ]" : n.status === "done" ? "[x]" : "[-]";
+  return `${box} ${n.title} (${n.kind}, for ${forWords(n.for)})${n.leadTime ? `, ${n.leadTime}` : ""}${n.handledBy ? `, ${n.handledBy}` : ""}`;
+}
+async function changeIds(root) {
+  return (await readdir(changesDirOf(root), { withFileTypes: true }).catch(() => [])).filter((e) => e.isDirectory() && e.name !== "archive").map((e) => e.name).sort();
+}
+async function needsList(root, o, io) {
+  const k = await readKnowledge(root, { cacheRoot: root });
+  const rows = [];
+  for (const c of o.change ? [o.change] : await changeIds(root)) {
+    const f = await readNeeds(root, c);
+    for (const n of f?.needs ?? [])
+      if (o.all || n.status === "open") {
+        const rv = k.reviews[n.item];
+        rows.push({
+          ...n,
+          change: c,
+          ...rv && (rv.state === "verified" || rv.state === "corrected") ? { verified: rv.by } : {}
+        });
+      }
+  }
+  if (o.json) {
+    io.out(JSON.stringify(rows, null, 2));
+    return 0;
+  }
+  if (!rows.length) {
+    io.out(o.change ? `${o.change} has no ${o.all ? "" : "open "}needs. atticus change needs ${o.change} finds them.` : "No change has an open need.");
+    return 0;
+  }
+  for (const l of table(["CHANGE", "NEED", "KIND", "FOR", "LEAD TIME", "HANDLED BY", "STATE"], rows.map((n) => [
+    n.change,
+    `${n.item}${n.verified ? " \u2713" : ""}`,
+    n.kind,
+    forWords(n.for),
+    n.leadTime ?? "",
+    n.handledBy ?? "",
+    n.status
+  ])))
+    io.out(l);
+  if (rows.some((n) => n.verified))
+    io.out("\u2713 a person verified the knowledge item it comes from");
+  return 0;
+}
+async function needsCli(root, positionals, values, io, who, deps = {}) {
+  const [group, command, a, b] = positionals;
+  const str = (v) => typeof v === "string" && v.trim() ? v : void 0;
+  const json = values.json === true;
+  if (group === "change" && command === "needs") {
+    if (!a) {
+      io.err("Usage: atticus change needs <change> [--mode m] [--resume run] [--attempts 3]");
+      return 2;
+    }
+    const attempts = Number(str(values.attempts) ?? "3");
+    if (!Number.isInteger(attempts) || attempts < 1 || attempts > 10) {
+      io.err("--attempts is a whole number from 1 to 10.");
+      return 2;
+    }
+    const flags = contextFlags(values);
+    if ("error" in flags) {
+      io.err(flags.error);
+      return 2;
+    }
+    return changeNeeds(root, a, {
+      attempts,
+      json,
+      context: flags.context,
+      ...str(values.resume) ? { resume: str(values.resume) } : {},
+      ...str(values.mode) ? { mode: str(values.mode) } : {}
+    }, deps, io);
+  }
+  if (group !== "needs")
+    return void 0;
+  if (command === "done" || command === "skip" || command === "reopen") {
+    if (!a || !b) {
+      io.err(`Usage: atticus needs ${command} <change> <item> [--for target]${command === "skip" ? " --note why" : " [--note text]"}`);
+      return 2;
+    }
+    const r = await markNeed(root, a, b, {
+      status: command === "done" ? "done" : command === "skip" ? "not-needed" : "open",
+      by: who(),
+      at: stamp(deps.now ?? /* @__PURE__ */ new Date()),
+      ...str(values.note) ? { note: str(values.note) } : {},
+      ...str(values.for) ? { for: str(values.for) } : {}
+    });
+    if ("error" in r) {
+      io.err(r.error);
+      return 2;
+    }
+    if (json)
+      io.out(JSON.stringify(r.need, null, 2));
+    else
+      io.out(`${r.need.title} (${forWords(r.need.for)}) is ${r.need.status === "not-needed" ? "not needed" : r.need.status} for ${a}${r.need.by && r.need.status !== "open" ? `, by ${r.need.by}` : ""}. Commit ${changesRelOf(root)}/${a}/needs.yaml with the change.`);
+    return 0;
+  }
+  if (command && command !== "list") {
+    io.err("Usage: atticus needs [--change id] [--all] | needs done|skip|reopen <change> <item>");
+    return 2;
+  }
+  return needsList(root, {
+    json,
+    all: values.all === true,
+    ...str(values.change) ? { change: str(values.change) } : {}
+  }, io);
+}
+export {
+  changeNeeds,
+  needsCli,
+  needsList
+};

package/dist/chunk-PFTA6BZF.js

@@ -0,0 +1,49 @@
+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 {
+  catalogMigrate,
+  completeFeatureNaming,
+  featureLink,
+  featureList,
+  featureMerge,
+  featureName,
+  featureShow,
+  featureSpec,
+  featureSplit,
+  featureSuggestLinks,
+  featureSuggestNames,
+  featureTag
+} from "./chunk-L3BX5ZIB.js";
+import "./chunk-VOGCSYOI.js";
+import "./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-KJPMEAI4.js";
+import "./chunk-GQ4N4WKF.js";
+import "./chunk-CNUKCS2T.js";
+import "./chunk-S2A7YC3Q.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+export {
+  catalogMigrate,
+  completeFeatureNaming,
+  featureLink,
+  featureList,
+  featureMerge,
+  featureName,
+  featureShow,
+  featureSpec,
+  featureSplit,
+  featureSuggestLinks,
+  featureSuggestNames,
+  featureTag
+};

package/dist/chunk-PNN5KLAY.js

@@ -0,0 +1,119 @@
+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 {
+  estimateOf
+} from "./chunk-CHWTETW7.js";
+import {
+  changeMapBody,
+  changeMapOf
+} from "./chunk-GRMR5TRQ.js";
+import "./chunk-RYSCLMU3.js";
+import "./chunk-ZUIAOKXI.js";
+import "./chunk-2UIQBDJO.js";
+import "./chunk-6SCVQZX5.js";
+import "./chunk-65NYPGRC.js";
+import {
+  knowledgeAppliesMarkdown,
+  readKnowledgeApplies
+} from "./chunk-VPTTCYOC.js";
+import "./chunk-L6SGQIR3.js";
+import {
+  readRound,
+  reviewedGates,
+  roundsOf
+} from "./chunk-7UFQZXZA.js";
+import "./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 "./chunk-CNUKCS2T.js";
+import "./chunk-S2A7YC3Q.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/handoff-review.js
+var days = (d) => `${d.p20}\u2013${d.p80} days (most likely ${d.p50})`;
+async function handoffReview(root, change) {
+  const lines = [];
+  lines.push("### What it changes", "");
+  const map = await changeMapOf(root, change).catch(() => void 0);
+  if (map && map.flows > 0) {
+    lines.push("```mermaid", changeMapBody(change, map).mermaid.trimEnd(), "```", "");
+    lines.push(`From ${map.flows} target flow${map.flows === 1 ? "" : "s"} in ${map.source}.`, "");
+  } else
+    lines.push("No target flows yet: the architecture stage writes them.", "");
+  const applies = await readKnowledgeApplies(root, change).catch(() => void 0);
+  if (applies)
+    lines.push(knowledgeAppliesMarkdown(applies).trimEnd(), "");
+  lines.push("### Estimate", "");
+  const est = await estimateOf(root, change).catch(() => void 0);
+  if (est?.effort) {
+    lines.push(days(est.effort), "");
+    for (const d of est.drivers.filter((x) => x.count > 0).slice(0, 5))
+      lines.push(`- ${d.what}: ${d.count}`);
+    if (est.needsClass)
+      lines.push(`- ${est.needsClass} unit${est.needsClass === 1 ? "" : "s"} not sized yet`);
+    lines.push("");
+  } else
+    lines.push(est ? "Not sized yet: the org pack's estimates don't cover these units." : "Not sized yet.", "");
+  lines.push("### Since the last round", "");
+  const reviewed = await reviewedGates(root, change).catch(() => []);
+  const openIds = async (gate, n) => new Set((await readRound(root, change, gate, n)).findings.filter(({ finding: f }) => f.state === "open").map(({ finding: f }) => f.id));
+  const code = (ids) => ids.map((i) => `\`${i}\``).join(", ");
+  let any = false;
+  for (const gate of reviewed) {
+    const rounds = await roundsOf(root, change, gate);
+    if (!rounds.length)
+      continue;
+    any = true;
+    if (rounds.length === 1) {
+      lines.push(`- ${gate} gate: the first round.`);
+      continue;
+    }
+    const [before, now] = [rounds.at(-2), rounds.at(-1)];
+    const [was, is] = [await openIds(gate, before), await openIds(gate, now)];
+    const closed = [...was].filter((i) => !is.has(i)).sort();
+    const added = [...is].filter((i) => !was.has(i)).sort();
+    const still = [...is].filter((i) => was.has(i)).length;
+    lines.push(`- ${gate} gate, round ${now} against round ${before}: ${closed.length} closed${closed.length ? ` (${code(closed)})` : ""}, ${added.length} new${added.length ? ` (${code(added)})` : ""}, ${still} still open.`);
+  }
+  if (!any)
+    lines.push("No gate has been reviewed yet.");
+  lines.push("");
+  lines.push("### Findings still open", "");
+  const gates = await reviewedGates(root, change).catch(() => []);
+  const open = [];
+  for (const gate of gates) {
+    const rounds = await roundsOf(root, change, gate);
+    if (!rounds.length)
+      continue;
+    for (const { finding: f } of (await readRound(root, change, gate, rounds.at(-1))).findings)
+      if (f.state === "open")
+        open.push({ gate, severity: f.severity, summary: f.summary, id: f.id });
+  }
+  if (!gates.length)
+    lines.push("No gate has been reviewed yet.", "");
+  else if (!open.length)
+    lines.push("None open.", "");
+  else {
+    const order = ["blocking", "gap", "risk", "idea"];
+    for (const f of open.sort((a, b) => order.indexOf(a.severity) - order.indexOf(b.severity)))
+      lines.push(`- **${f.severity}** (${f.gate}): ${f.summary} \`${f.id}\``);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+export {
+  handoffReview
+};

package/dist/chunk-PRPPGYZG.js

@@ -0,0 +1,104 @@
+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 {
+  listRuns,
+  runTranscript
+} from "./chunk-DPUYDDQG.js";
+import "./chunk-CNUKCS2T.js";
+import "./chunk-S2A7YC3Q.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/runs-commands.js
+var plural = (n, w) => `${n} ${w}${n === 1 ? "" : "s"}`;
+var when = (iso) => iso.replace("T", " ").slice(0, 16);
+async function runsCli(root, o, io) {
+  const runs = await listRuns(root, {
+    ...o.change ? { change: o.change } : {},
+    ...o.limit ? { limit: o.limit } : {}
+  });
+  if (o.json) {
+    io.out(JSON.stringify({ runs }, null, 2));
+    return 0;
+  }
+  if (!runs.length) {
+    io.out(o.change ? `No model runs for ${o.change} yet.` : "No model runs yet: an AI step makes one.");
+    return 0;
+  }
+  for (const r of runs)
+    io.out([
+      r.runId,
+      r.change,
+      r.agent,
+      // ADR 0121 addendum: the kind of step, and the model that ran it when it is known.
+      ...r.stepClass ? [`${r.stepClass} step${r.model ? ` on ${r.model}` : ""}`] : [],
+      `round ${r.attempt}`,
+      r.state,
+      r.answered ? "answered" : "no answer yet",
+      ...r.handedBack ? [`${plural(r.handedBack, "problem")} handed back`] : [],
+      ...r.toolCalls ? [`${plural(r.toolCalls, "tool call")}`] : [],
+      when(r.startedAt)
+    ].join("  "));
+  return 0;
+}
+async function runShowCli(root, runId, o, io) {
+  const t = await runTranscript(root, runId);
+  if (!t) {
+    io.err(`There is no run ${runId}. atticus runs lists them.`);
+    return 2;
+  }
+  if (o.json) {
+    io.out(JSON.stringify(t, null, 2));
+    return 0;
+  }
+  const r = t.run;
+  io.out(`${r.runId}: ${r.change}, ${r.agent}, round ${r.attempt}, ${r.state} (${r.runtime})`);
+  if (r.stepClass)
+    io.out(`Model: ${r.model ?? "not recorded"}, for a ${r.stepClass} step (the kind of step picks the model).`);
+  io.out(`Prompt: ${r.promptPath}${r.promptTokens ? ` (${r.promptTokens} tokens)` : ""}`);
+  if (t.tools) {
+    const calls = t.tools.calls;
+    io.out(`Tools offered: ${t.tools.offered.join(", ") || "none"}; the model called them ${plural(calls.length, "time")}.`);
+    for (const c of calls) {
+      io.out(`  Round ${c.round}: ${c.name} ${JSON.stringify(c.input)}${c.error ? " (refused)" : ""}, ${plural(c.tokens, "token")} back:`);
+      for (const l of c.output.trimEnd().split("\n"))
+        io.out(`    ${l}`);
+    }
+    if (t.tools.stopped)
+      io.out(`A cap stopped the tools: ${t.tools.stopped}.`);
+  }
+  const ex = t.retrieval?.expansion;
+  if (ex) {
+    io.out(`The model read the input first${ex.run ? ` (run ${ex.run})` : ""}${ex.cached ? " (a kept answer)" : ""}: search terms ${ex.terms.join("; ") || "none"}.`);
+    for (const n of ex.names)
+      io.out(`  ${n.name}: ${n.id ? `the index's ${n.id}` : n.new ? "new in this change" : "nothing in the index"} ("${n.quote}")`);
+    for (const d of ex.dropped)
+      io.out(`  Left out: ${d.name}, ${d.why}.`);
+  }
+  const rr = t.retrieval?.rerank;
+  if (rr)
+    io.out(rr.used ? `The model ordered ${plural(rr.shown, "candidate")}${rr.run ? ` (run ${rr.run})` : ""}${rr.cached ? " (a kept answer)" : ""}: kept ${rr.order.join(", ") || "none"}; judged not needed: ${rr.dropped.join(", ") || "none"}.` : `The model's order of ${plural(rr.shown, "candidate")} named one it wasn't shown, so the engine's order stood.`);
+  if (t.retrieval?.meaning)
+    io.out(`Meaning: ${t.retrieval.meaning}.`);
+  for (const h of t.handedBack) {
+    io.out(`Handed back after round ${h.attempt}:`);
+    for (const p of h.problems)
+      io.out(`  - ${p}`);
+  }
+  if (t.answer === void 0)
+    io.out("Answer: none yet.");
+  else {
+    io.out("Answer:");
+    for (const l of t.answer.trimEnd().split("\n"))
+      io.out(`  ${l}`);
+  }
+  io.out(`Rounds of this step: ${t.rounds.map((x) => `${x.runId} (round ${x.attempt}, ${x.state})`).join(", ")}`);
+  return 0;
+}
+export {
+  runShowCli,
+  runsCli
+};