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

package/dist/chunk-26DBAGOP.js

@@ -0,0 +1,315 @@
+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 "./chunk-NIYB5K5B.js";
+import {
+  loadCatalog
+} from "./chunk-BUWSOQLU.js";
+import {
+  repoFor
+} from "./chunk-LDIARP6F.js";
+import {
+  askHosts
+} from "./chunk-XR5DD5DQ.js";
+import "./chunk-XKJRPVJO.js";
+import {
+  estateFlow,
+  estateStepKey,
+  fieldLineage,
+  joinEstate
+} from "./chunk-IILZ7J3L.js";
+import "./chunk-TEBBD4XH.js";
+import "./chunk-XPWSNKF3.js";
+import "./chunk-WIMOJMAK.js";
+import "./chunk-5V5BJACL.js";
+import "./chunk-GVFUEGGM.js";
+import "./chunk-YVCOQ5TZ.js";
+import "./chunk-XNRPCI23.js";
+import "./chunk-XZJE6WIT.js";
+import {
+  fsRepo
+} from "./chunk-FMRMTI7W.js";
+import "./chunk-BKFGGJKA.js";
+import {
+  listQuestions,
+  loadOrgPack,
+  orgPackDirOf,
+  questionId,
+  raiseQuestions,
+  readEstateJoins,
+  readRepoSpec,
+  slugify,
+  specRepos,
+  specsRelOf,
+  templateRef,
+  writeEstateJoins
+} from "./chunk-JMOLB347.js";
+import "./chunk-MMB2OHUY.js";
+import "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/estate-commands.js
+var plural = (n, one, many = `${one}s`) => `${n} ${n === 1 ? one : many}`;
+var HOW = {
+  interface: "through the Interface",
+  endpoint: "to the entry point it names",
+  path: "by method and path"
+};
+var REASON = {
+  "no-target": "no target",
+  "no-flow": "no flow",
+  "no-citation": "no citation",
+  "family-mismatch": "a wrong family"
+};
+var ESTATE_TARGETS_STEP = "estate-targets";
+var ESTATE_TARGETS_NONE = "None of these";
+function estateAskDraft(a) {
+  return {
+    question: `Which component answers ${a.what}, which ${a.caller} calls?`,
+    options: [
+      ...a.candidates.map((c) => ({
+        label: c,
+        means: `${c} answers ${a.what}`,
+        changes: `The call-out joins ${c}'s flow at the next atticus estate join`
+      })),
+      {
+        label: ESTATE_TARGETS_NONE,
+        means: "None of these components answers it",
+        changes: "The call-out stays unjoined, and this isn't asked again"
+      }
+    ],
+    evidence: a.from.evidence ? [a.from.evidence] : [],
+    scope: "repo"
+  };
+}
+function estateAskId(a) {
+  const d = estateAskDraft(a);
+  return questionId({
+    step: ESTATE_TARGETS_STEP,
+    repo: a.from.repo,
+    question: d.question,
+    evidence: d.evidence
+  });
+}
+async function readSpecs(root, io, templates) {
+  const out = [];
+  for (const repo of await specRepos(root)) {
+    const s = await readRepoSpec(root, repo, { cacheRoot: root });
+    for (const p of s.problems)
+      io.err(`${p.file}: ${p.message}`);
+    if (s.flows.length)
+      out.push({ repo, flows: s.flows });
+    if (templates && s.header?.template)
+      templates[repo] = s.header.template;
+  }
+  return out;
+}
+async function specTemplates(root, refs) {
+  const op = await loadOrgPack(orgPackDirOf(root)).catch(() => void 0);
+  const out = {};
+  for (const [repo, ref] of Object.entries(refs)) {
+    const t = op?.specTemplates.find((x) => templateRef(x) === ref);
+    if (t)
+      out[repo] = t;
+  }
+  return out;
+}
+async function estateJoin(root, o, io) {
+  const refs = {};
+  const specs = await readSpecs(root, io, refs);
+  if (specs.length === 0) {
+    io.err(`There are no repo specs in ${specsRelOf(root)}/ yet. Draft them first: atticus spec draft <repo>.`);
+    return 2;
+  }
+  const { records } = await loadCatalog(root, { out: () => {
+  }, err: (l) => io.err(l) });
+  const templates = await specTemplates(root, refs);
+  const clones = /* @__PURE__ */ new Map();
+  const unchecked = /* @__PURE__ */ new Set();
+  const cited = async (repo, path, line) => {
+    if (!clones.has(repo)) {
+      const r2 = await repoFor(root, repo);
+      clones.set(repo, r2 ? { dir: r2.dir, lines: /* @__PURE__ */ new Map() } : null);
+      if (!r2)
+        unchecked.add(repo);
+    }
+    const c = clones.get(repo);
+    if (!c)
+      return true;
+    if (!c.lines.has(path)) {
+      const t = await fsRepo(repo, c.dir, "0".repeat(40)).readText(path).catch(() => void 0);
+      c.lines.set(path, t === void 0 ? 0 : t.replace(/\r\n?/g, "\n").replace(/\n$/, "").split("\n").length);
+    }
+    return line >= 1 && line <= c.lines.get(path);
+  };
+  const first = await joinEstate({ specs, records, cited, templates });
+  const askedBefore = new Map((await listQuestions(root, { step: ESTATE_TARGETS_STEP })).questions.map((q) => [q.id, q]));
+  const targets = {};
+  for (const a of first.asks) {
+    const q = askedBefore.get(estateAskId(a));
+    if (q?.state !== "answered" || !q.answer)
+      continue;
+    const label = q.answer.option !== void 0 ? q.options[q.answer.option - 1]?.label : q.answer.text;
+    if (label && label !== ESTATE_TARGETS_NONE)
+      targets[estateStepKey(a.from.flow, a.from.step)] = slugify(label);
+  }
+  const r = Object.keys(targets).length ? await joinEstate({ specs, records, cited, templates, targets }) : first;
+  const at = (o.now ?? /* @__PURE__ */ new Date()).toISOString();
+  const asked = [];
+  for (const a of r.asks) {
+    if (!a.from.evidence)
+      continue;
+    const before = askedBefore.get(estateAskId(a));
+    if (before) {
+      if (before.state === "open")
+        asked.push({ q: before, raised: false });
+      continue;
+    }
+    const raised = await raiseQuestions(root, [estateAskDraft(a)], {
+      step: ESTATE_TARGETS_STEP,
+      repo: a.from.repo,
+      command: "atticus estate join",
+      rerun: "atticus estate join",
+      at
+    });
+    const q = raised.of[0];
+    if (q?.state === "open")
+      asked.push({ q, raised: raised.raised.some((x) => x.id === q.id) });
+  }
+  const inferred = new Set(r.inferred.map((x) => estateStepKey(x.from.flow, x.from.step)));
+  const file = {
+    schemaVersion: 1,
+    joinedAt: (o.now ?? /* @__PURE__ */ new Date()).toISOString(),
+    repos: specs.map((s) => s.repo),
+    joins: r.joins,
+    unmatched: r.unmatched
+  };
+  const rel = await writeEstateJoins(root, file);
+  const hosts = await askHosts(root, records, {
+    command: "atticus estate join",
+    ...o.now ? { now: o.now } : {}
+  });
+  if (o.json) {
+    io.out(JSON.stringify({
+      ...file,
+      file: rel,
+      unchecked: [...unchecked].sort(),
+      inferred: r.inferred,
+      asks: r.asks,
+      questions: [...hosts.raised, ...hosts.open, ...asked.map((x) => x.q)].map((q) => q.id)
+    }, null, 2));
+    return 0;
+  }
+  const total = r.joins.length + r.unmatched.length;
+  io.out(`Joined ${r.joins.length} of ${plural(total, "call-out")} across ${plural(specs.length, "repo")} (${file.repos.join(", ")}); written to ${rel}.`);
+  for (const j of r.joins)
+    io.out(`  ${j.from.flow} step ${j.from.step} \u2192 ${j.to.flow} (${HOW[j.how]}${j.interface ? ` ${j.interface}` : ""}${inferred.has(estateStepKey(j.from.flow, j.from.step)) ? ", inferred" : ""})`);
+  if (r.unmatched.length) {
+    io.out(`${plural(r.unmatched.length, "call-out")} ${r.unmatched.length === 1 ? "isn't" : "aren't"} joined:`);
+    for (const u of r.unmatched)
+      io.out(`  ${u.from.flow} step ${u.from.step} (${REASON[u.reason]}): ${u.message}`);
+  }
+  if (unchecked.size)
+    io.out(`Cited lines of ${[...unchecked].sort().join(", ")} weren't checked: there is no clone of ${unchecked.size === 1 ? "it" : "them"} here.`);
+  if (r.inferred.length)
+    io.out(`${plural(r.inferred.length, "join is", "joins are")} inferred: ${r.inferred.length === 1 ? "its" : "their"} step names a target that isn't a component in the catalog (a relative call's guessed name, or none), so ${r.inferred.length === 1 ? "it" : "each"} joined the only entry point that serves its method and path, the caller's own repo first. When the repo is next read, a relative call leaves \`to\` out or names the component that serves it.`);
+  for (const { q, raised } of asked)
+    io.out(raised ? `Two or more components answer a call-out: asked ${q.id}: ${q.question} Answer it: atticus questions answer ${q.id} --option <n>, then atticus estate join.` : `Still open: ${q.question} Answer it: atticus questions answer ${q.id} --option <n>, then atticus estate join.`);
+  for (const l of hosts.lines)
+    io.out(l);
+  io.out("Next: atticus estate flow <flow-id> follows a flow across repos.");
+  return 0;
+}
+async function loadJoined(root, flowId, depth, io) {
+  const joins = await readEstateJoins(root);
+  if (!joins) {
+    io.err(`There is no ${specsRelOf(root)}/estate.yaml yet. Join the repos' flows first: atticus estate join.`);
+    return void 0;
+  }
+  const f = estateFlow({
+    flow: flowId,
+    specs: await readSpecs(root, io),
+    joins,
+    ...depth !== void 0 ? { depth } : {}
+  });
+  if (!f)
+    io.err(`There is no flow ${flowId} in ${specsRelOf(root)}/.`);
+  return f;
+}
+var cite = (s) => {
+  const e = s.step.evidence[0];
+  return e?.path ? `  [${e.repo ?? s.repo}:${e.path}${e.line !== void 0 ? `:${e.line}` : ""}]` : "";
+};
+var list = (xs) => xs.length ? xs.join(", ") : "nothing named";
+function render(f, indent, out) {
+  for (const s of f.steps) {
+    out.push(`${indent}${s.n} ${s.step.kind}: ${s.step.what}${cite(s)}`);
+    const c = s.call;
+    if (!c)
+      continue;
+    const pad = `${indent}  `;
+    if (c.join) {
+      const callee = c.callee?.flow;
+      out.push(`${pad}\u2192 ${c.join.to.flow}${callee ? `: ${callee.name}` : ""} (${c.join.to.repo}), ${HOW[c.join.how]}${c.join.interface ? ` ${c.join.interface}` : ""}`);
+      const x = c.crossing;
+      out.push(`${pad}  sends ${list(x.sends)}; the callee takes ${list(x.receives)}; returns ${list(x.returns)}`);
+      for (const m of x.objects)
+        out.push(`${pad}  ${m.sent} carries the callee's ${m.fields.join(", ")}`);
+      if (x.unused.length)
+        out.push(`${pad}  sent but not used by the callee: ${x.unused.join(", ")}`);
+      if (c.callee)
+        render(c.callee, pad, out);
+      else if (c.stopped === "cycle")
+        out.push(`${pad}  (not followed: ${c.join.to.flow} is already on the path)`);
+      else if (c.stopped === "depth")
+        out.push(`${pad}  (not followed: the depth limit; raise --depth)`);
+    } else if (c.unmatched)
+      out.push(`${pad}\u2717 not joined (${REASON[c.unmatched.reason]}): ${c.unmatched.message}`);
+    else
+      out.push(`${pad}\u2717 not joined yet: the specs changed since atticus estate join ran`);
+  }
+}
+async function estateFlowCommand(root, flowId, o, io) {
+  const f = await loadJoined(root, flowId, o.depth, io);
+  if (!f)
+    return 2;
+  if (o.json) {
+    io.out(JSON.stringify(f, null, 2));
+    return 0;
+  }
+  const t = f.flow.trigger;
+  const e = t.evidence[0];
+  const out = [
+    `${f.flow.id}: ${f.flow.name} (${f.repo})`,
+    `Trigger (${t.kind}): ${t.what}${e?.path ? `  [${e.repo ?? f.repo}:${e.path}${e.line !== void 0 ? `:${e.line}` : ""}]` : ""}`
+  ];
+  render(f, "", out);
+  for (const l of out)
+    io.out(l);
+  return 0;
+}
+async function estateLineage(root, flowId, field, o, io) {
+  const f = await loadJoined(root, flowId, o.depth, io);
+  if (!f)
+    return 2;
+  const l = fieldLineage(f, field);
+  if (o.json) {
+    io.out(JSON.stringify(l, null, 2));
+    return l.stored ? 0 : 1;
+  }
+  io.out(`${field} along ${flowId}:`);
+  for (const k of l.links)
+    io.out(`  ${k.n} ${k.kind}, ${k.as} ${k.field}: ${k.what}${k.evidence ? `  [${k.evidence}]` : ""}`);
+  io.out(l.stored ? `${field} is stored in ${l.stored.table}.${l.stored.column}.` : `The chain breaks: ${l.breaks.message}`);
+  return l.stored ? 0 : 1;
+}
+export {
+  ESTATE_TARGETS_NONE,
+  ESTATE_TARGETS_STEP,
+  estateAskDraft,
+  estateAskId,
+  estateFlowCommand,
+  estateJoin,
+  estateLineage
+};

package/dist/chunk-27EDZN52.js

@@ -0,0 +1,115 @@
+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 {
+  changeSteps,
+  readNextState
+} from "./chunk-23VFQHFQ.js";
+import "./chunk-ATNG5VOZ.js";
+import "./chunk-B3QOYE74.js";
+import "./chunk-MKFYQQ5Q.js";
+import "./chunk-HOUUBE74.js";
+import "./chunk-LVBPY2M6.js";
+import "./chunk-EW7MRMD5.js";
+import "./chunk-IA2RKC6I.js";
+import "./chunk-ASKDCMW5.js";
+import "./chunk-LDIARP6F.js";
+import "./chunk-MYKQVS5W.js";
+import "./chunk-EBWIOODZ.js";
+import "./chunk-BA5DTXHQ.js";
+import "./chunk-3G4YI4ZU.js";
+import "./chunk-EI4KQYJ3.js";
+import "./chunk-6RGIM2ZH.js";
+import "./chunk-EV4TEFOD.js";
+import "./chunk-6N2GUZMZ.js";
+import "./chunk-VOGCSYOI.js";
+import "./chunk-T6ESD5KM.js";
+import {
+  changeReport
+} from "./chunk-3LU6YCSQ.js";
+import "./chunk-L7I5PKGD.js";
+import "./chunk-CAN3EBE5.js";
+import "./chunk-IILZ7J3L.js";
+import "./chunk-TEBBD4XH.js";
+import "./chunk-XPWSNKF3.js";
+import "./chunk-WIMOJMAK.js";
+import "./chunk-5V5BJACL.js";
+import "./chunk-GVFUEGGM.js";
+import "./chunk-XNRPCI23.js";
+import {
+  readChangeRepos
+} from "./chunk-XZJE6WIT.js";
+import "./chunk-FMRMTI7W.js";
+import "./chunk-BKFGGJKA.js";
+import {
+  changesDirOf,
+  listQuestions,
+  require_dist
+} from "./chunk-JMOLB347.js";
+import "./chunk-MMB2OHUY.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/cockpit.js
+var import_yaml = __toESM(require_dist(), 1);
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+var STAGES = ["feature", "architecture", "stories"];
+async function stageProgress(dir, stage, open) {
+  const text = await readFile(join(dir, "stage", `${stage}.yaml`), "utf8").catch(() => void 0);
+  if (!text)
+    return { stage, state: "not-started", drafts: 0, rounds: 0, openQuestions: 0, asked: [] };
+  const y = (0, import_yaml.parse)(text) ?? {};
+  const asked = Array.isArray(y.questions) ? y.questions.filter((q) => typeof q === "string") : [];
+  return {
+    stage,
+    state: typeof y.state === "string" ? y.state : "unknown",
+    drafts: typeof y.iteration === "number" ? y.iteration : 0,
+    rounds: Array.isArray(y.critic) ? y.critic.length : 0,
+    openQuestions: asked.filter((q) => open.has(q)).length,
+    /** The open questions it raised. */
+    asked: asked.filter((q) => open.has(q))
+  };
+}
+async function cockpit(root, id) {
+  const report = await changeReport(root, id);
+  const dir = join(changesDirOf(root), id);
+  const { questions } = await listQuestions(root, { state: "open" }).catch(() => ({
+    questions: []
+  }));
+  const open = new Set(questions.map((q) => q.id));
+  const stages = [];
+  for (const s of STAGES)
+    stages.push(await stageProgress(dir, s, open));
+  const ofChange = /* @__PURE__ */ new Set([
+    ...questions.filter((q) => q.repo === id).map((q) => q.id),
+    ...stages.flatMap((s) => s.asked)
+  ]);
+  const state = (await readNextState(root)).changes.find((c) => c.id === id);
+  const next = state ? changeSteps(state)[0] : void 0;
+  const repos = await readChangeRepos(root, id).catch(() => void 0);
+  return {
+    id,
+    state: report.state,
+    ...next ? { next } : {},
+    nextStep: report.nextStep,
+    reasons: report.reasons,
+    risk: { level: report.risk.level, score: report.risk.score },
+    ...report.progress ? { work: report.progress.summary } : {},
+    stages: stages.map(({ asked: _asked, ...rest }) => rest),
+    openQuestions: ofChange.size,
+    repos: (repos?.repos ?? []).map((r) => ({
+      id: r.id,
+      branch: r.branch,
+      base: r.base,
+      ...r.pr?.url ? { pr: r.pr.url } : {}
+    }))
+  };
+}
+export {
+  STAGES,
+  cockpit
+};

package/dist/chunk-2K2ZEJVR.js

@@ -0,0 +1,252 @@
+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 {
+  ANSWERED_BY_SPEC,
+  APPLIES_SPEC,
+  ASKS_CHECK_SPEC,
+  AiOffError,
+  BIGGER_MODEL,
+  BREAKING_SPEC,
+  CLASSIFIED_PERSONAL,
+  COVERS_FIELD_SPEC,
+  DATA_RULE,
+  DEFENCES_VERSION,
+  FLAG_OPEN,
+  HandoffRuntime,
+  HashEmbedder,
+  HeadlessClaudeCodeRuntime,
+  INSTRUCTION_RULES,
+  JUDGE_AGENT,
+  MockModelProvider,
+  MockRuntime,
+  ModelRuntime,
+  NAMES_SECRET_SPEC,
+  OneShotRuntime,
+  PERSONAL_DATA_SPEC,
+  PROMPT_FRAME_TOKENS,
+  PROMPT_MARGIN,
+  PromptTooLong,
+  REACHES_SPEC,
+  RUNTIME_MODES,
+  RecordedEmbedder,
+  ReplayRuntime,
+  RuntimeConfigError,
+  RuntimeError,
+  SAME_QUESTION_SPEC,
+  STATES_VALUE_SPEC,
+  STEP_CLASS_BY_AGENT,
+  TOKEN_FORMATS,
+  TOOLS_RULE,
+  TOOL_LIMITS,
+  ToolError,
+  ToolSession,
+  UNDOES_SPEC,
+  answerJudge,
+  answerProblem,
+  assess,
+  buildContextPack,
+  chatWithTools,
+  checkAllowed,
+  claudeCodeCliRunner,
+  clearModelProviders,
+  collectChild,
+  combine,
+  cosine,
+  createRuntime,
+  currentPromptLimit,
+  decodeBlob,
+  defendSource,
+  dotInt8,
+  escapeDelimiters,
+  estimateTokens,
+  fitBudget,
+  formatOf,
+  guardToolText,
+  hiddenDiagramLabels,
+  hiddenOfficeRuns,
+  hiddenSpans,
+  judge,
+  judgeInstructions,
+  judgeItemsOf,
+  judgeStandIn,
+  judgesDirectly,
+  makeModelProvider,
+  makeRunId,
+  modelEnvOf,
+  modelSourceWords,
+  modelsByClass,
+  namesWord,
+  neutralise,
+  personalItem,
+  posixPath,
+  promptBudget,
+  providerFactoryFor,
+  providerModelOf,
+  pruneRuns,
+  quantize,
+  quarantineItems,
+  quarantineReason,
+  questionJudge,
+  readToolCalls,
+  recordRun,
+  recordToolCalls,
+  recordedJudge,
+  registerModelProvider,
+  registerModelProviderPluginLoader,
+  registerToolSource,
+  registeredModelProviders,
+  resumedAttempt,
+  riskAtLeast,
+  runtimeForCli,
+  screenAbsorbed,
+  screenDiagramXml,
+  screenDocuments,
+  screenHiddenRuns,
+  screenOfficeXml,
+  screenText,
+  settle,
+  sha256,
+  skeleton,
+  stepClassOf,
+  stepClassOfCommand,
+  stepClassOfNextStep,
+  stripInvisible,
+  textSha,
+  toRunSummary,
+  tokenFormatIn,
+  toolStops,
+  transition,
+  vectorFromText,
+  vectorToText,
+  verdictOf,
+  withPromptLimit,
+  wrapData
+} from "./chunk-BKFGGJKA.js";
+import "./chunk-JMOLB347.js";
+import "./chunk-MMB2OHUY.js";
+import "./chunk-TV45EUGM.js";
+export {
+  ANSWERED_BY_SPEC,
+  APPLIES_SPEC,
+  ASKS_CHECK_SPEC,
+  AiOffError,
+  BIGGER_MODEL,
+  BREAKING_SPEC,
+  CLASSIFIED_PERSONAL,
+  COVERS_FIELD_SPEC,
+  DATA_RULE,
+  DEFENCES_VERSION,
+  FLAG_OPEN,
+  HandoffRuntime,
+  HashEmbedder,
+  HeadlessClaudeCodeRuntime,
+  INSTRUCTION_RULES,
+  JUDGE_AGENT,
+  MockModelProvider,
+  MockRuntime,
+  ModelRuntime,
+  NAMES_SECRET_SPEC,
+  OneShotRuntime,
+  PERSONAL_DATA_SPEC,
+  PROMPT_FRAME_TOKENS,
+  PROMPT_MARGIN,
+  PromptTooLong,
+  REACHES_SPEC,
+  RUNTIME_MODES,
+  RecordedEmbedder,
+  ReplayRuntime,
+  RuntimeConfigError,
+  RuntimeError,
+  SAME_QUESTION_SPEC,
+  STATES_VALUE_SPEC,
+  STEP_CLASS_BY_AGENT,
+  TOKEN_FORMATS,
+  TOOLS_RULE,
+  TOOL_LIMITS,
+  ToolError,
+  ToolSession,
+  UNDOES_SPEC,
+  answerJudge,
+  answerProblem,
+  assess,
+  buildContextPack,
+  chatWithTools,
+  checkAllowed,
+  claudeCodeCliRunner,
+  clearModelProviders,
+  collectChild,
+  combine,
+  cosine,
+  createRuntime,
+  currentPromptLimit,
+  decodeBlob,
+  defendSource,
+  dotInt8,
+  escapeDelimiters,
+  estimateTokens,
+  fitBudget,
+  formatOf,
+  guardToolText,
+  hiddenDiagramLabels,
+  hiddenOfficeRuns,
+  hiddenSpans,
+  judge,
+  judgeInstructions,
+  judgeItemsOf,
+  judgeStandIn,
+  judgesDirectly,
+  makeModelProvider,
+  makeRunId,
+  modelEnvOf,
+  modelSourceWords,
+  modelsByClass,
+  namesWord,
+  neutralise,
+  personalItem,
+  posixPath,
+  promptBudget,
+  providerFactoryFor,
+  providerModelOf,
+  pruneRuns,
+  quantize,
+  quarantineItems,
+  quarantineReason,
+  questionJudge,
+  readToolCalls,
+  recordRun,
+  recordToolCalls,
+  recordedJudge,
+  registerModelProvider,
+  registerModelProviderPluginLoader,
+  registerToolSource,
+  registeredModelProviders,
+  resumedAttempt,
+  riskAtLeast,
+  runtimeForCli,
+  screenAbsorbed,
+  screenDiagramXml,
+  screenDocuments,
+  screenHiddenRuns,
+  screenOfficeXml,
+  screenText,
+  settle,
+  sha256,
+  skeleton,
+  stepClassOf,
+  stepClassOfCommand,
+  stepClassOfNextStep,
+  stripInvisible,
+  textSha,
+  toRunSummary,
+  tokenFormatIn,
+  toolStops,
+  transition,
+  vectorFromText,
+  vectorToText,
+  verdictOf,
+  withPromptLimit,
+  wrapData
+};