@maycombhq/atticus 2.0.0-beta.2 → 2.0.0-beta.22

package/dist/chunk-RUVFXE2L.js

@@ -1,666 +0,0 @@
-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 {
-  partOfWords,
-  readPlanProgress,
-  readPlanRelOf
-} from "./chunk-FQXYPF7E.js";
-import {
-  onboardingView
-} from "./chunk-EBEW3XXQ.js";
-import {
-  isMetarepo,
-  notMetarepo
-} from "./chunk-3G4YI4ZU.js";
-import {
-  readChangeTasks
-} from "./chunk-OT2O76OS.js";
-import {
-  ASSISTANT_FORMATS,
-  probedAssistant,
-  readProbes,
-  whatRunsWhere
-} from "./chunk-IPKHE5D6.js";
-import {
-  metarepoOpenSpec,
-  openspecProgress,
-  readNeeds
-} from "./chunk-CKSITVS4.js";
-import {
-  readChangeFiles
-} from "./chunk-3HI6Z55Y.js";
-import {
-  changeStore,
-  loadChangePolicy,
-  stageCompletion
-} from "./chunk-XY3P7JW7.js";
-import {
-  readKnowledge,
-  snapshotDates,
-  workingDays
-} from "./chunk-L24C55VN.js";
-import {
-  stepClassOfNextStep
-} from "./chunk-CNUKCS2T.js";
-import {
-  ScanVerifyProposal,
-  changesDirOf,
-  factsDirOf,
-  fastPathOf,
-  listQuestions,
-  loadOrgPack,
-  orgPackDirOf,
-  proposalsDirOf,
-  readRepoSpec,
-  readSpecFindings,
-  require_dist,
-  stepModelsOf
-} from "./chunk-S2A7YC3Q.js";
-import {
-  __toESM
-} from "./chunk-TV45EUGM.js";
-
-// packages/cli/dist/next-commands.js
-var import_yaml = __toESM(require_dist(), 1);
-import { existsSync } from "node:fs";
-import { readdir, readFile } from "node:fs/promises";
-import { join } from "node:path";
-var METAREPO = "metarepo";
-var DRAFTING = ["feature", "architecture", "stories"];
-var draftingAt = (s) => DRAFTING.indexOf(s);
-var canMoveOn = (state) => {
-  const at = draftingAt(stageOf(state));
-  return at >= 0 && at < DRAFTING.length - 1;
-};
-var STALE_DAYS = 14;
-var plural = (n, one, many = `${one}s`) => `${n} ${n === 1 ? one : many}`;
-async function verifyState(root, repo) {
-  const text = await readFile(join(proposalsDirOf(root), "scan", `${repo}.yaml`), "utf8").catch(() => void 0);
-  if (text === void 0)
-    return "none";
-  const p = ScanVerifyProposal.safeParse((0, import_yaml.parse)(text));
-  if (!p.success)
-    return "none";
-  const s = p.data.settings;
-  const entries = s.exclude.length + s.prefixes.length + s.clients.length;
-  if (entries > 0 && (!p.data.accepted || p.data.accepted.at < p.data.at))
-    return "accept";
-  return "done";
-}
-async function readNextState(root) {
-  const view = await onboardingView(root);
-  const problems = [...view.problems];
-  const repos = [];
-  for (const r of view.repos) {
-    const spec = await readRepoSpec(root, r.id, { cacheRoot: root });
-    problems.push(...spec.problems);
-    const findings = await readSpecFindings(root, r.id);
-    const plan = await readPlanProgress(root, r.id);
-    repos.push({
-      id: r.id,
-      cloned: r.cloned,
-      settings: r.scanSettings.present,
-      scanned: r.lastScan !== null,
-      verify: await verifyState(root, r.id),
-      flows: spec.flows.length,
-      checked: !!findings && findings.draftedAt === spec.header?.drafted?.at,
-      findings: findings?.findings.filter((f) => !f.question).length ?? 0,
-      described: !r.description ? "none" : r.description.trust === "suggested" ? "draft" : "said",
-      ...spec.header?.template.startsWith("facts@") ? { facts: true } : {},
-      ...existsSync(join(factsDirOf(root), `${r.id}.jsonl`)) ? { read: true } : {},
-      ...plan ? {
-        readPlan: {
-          total: plan.total,
-          done: plan.done,
-          ...plan.next ? { next: { part: plan.next.part, paths: plan.next.paths } } : {},
-          file: readPlanRelOf(root, r.id)
-        }
-      } : {}
-    });
-  }
-  const open = await listQuestions(root, { state: "open" });
-  problems.push(...open.problems);
-  const changeIds = new Set(await changeStore(root).list().then((cs) => cs.map((c) => c.id), () => []));
-  const changeQuestions = {};
-  for (const q of open.questions)
-    if (changeIds.has(q.repo))
-      (changeQuestions[q.repo] ??= []).push(q.id);
-  const knowledge = await readKnowledge(root, { cacheRoot: root });
-  const sources = [];
-  for (const w of view.sources.wikis) {
-    const newest = (await snapshotDates(root, w.id))[0];
-    sources.push({
-      id: w.id,
-      snapshot: !!newest,
-      scanned: !!newest && !!knowledge.report?.snapshots.some((s) => s.source === w.id && s.date === newest),
-      ...newest ? { age: Math.floor((Date.now() - Date.parse(`${newest}T00:00:00Z`)) / 864e5) } : {}
-    });
-  }
-  const orgPack = await loadOrgPack(orgPackDirOf(root)).catch((e) => e);
-  let orgpack;
-  try {
-    if (orgPack instanceof Error)
-      throw orgPack;
-    const op = orgPack;
-    const names = new Set(op.profiles.flatMap((p) => (p.profile?.systems ?? []).flatMap((x) => [x.name, ...x.aliases])).map((n) => n.toLowerCase()));
-    const missing = knowledge.items.filter((i) => (i.kind === "Product" && i.productKind === "product" || i.kind === "Party" && i.partyKind === "vendor" && !!i.quote) && ![i.name, ...i.aliases].some((n) => names.has(n.toLowerCase()))).length;
-    let draft;
-    for (const f of await readdir(join(proposalsDirOf(root), "orgpack")).catch(() => []))
-      if (f.endsWith(".yaml")) {
-        const d = (0, import_yaml.parse)(await readFile(join(proposalsDirOf(root), "orgpack", f), "utf8"));
-        if (d?.platform && d.proposals?.length)
-          draft = { platform: d.platform, proposals: d.proposals.length };
-      }
-    if (missing || draft)
-      orgpack = { missing, ...draft ? { draft } : {} };
-  } catch (e) {
-    problems.push({ file: "org-pack", message: e.message.split("\n")[0] });
-  }
-  const changes = [];
-  let unverifiedNeeds = 0;
-  let active;
-  const types = orgPack instanceof Error ? [] : orgPack.changeTypes.types;
-  const { policy } = await loadChangePolicy(orgPackDirOf(root));
-  const os = metarepoOpenSpec(root);
-  try {
-    for (const c of await changeStore(root).list()) {
-      const files = await readChangeFiles(join(changesDirOf(root), c.id)).catch(() => void 0);
-      const stagesDone = (await stageCompletion({ root, policy }, c)).filter((s) => s.state === "done").map((s) => s.stage);
-      const needs = await readNeeds(root, c.id);
-      const open2 = needs?.needs.filter((n) => n.status === "open") ?? [];
-      unverifiedNeeds += open2.filter((n) => {
-        const r = knowledge.reviews[n.item];
-        return r?.state !== "verified" && r?.state !== "corrected";
-      }).length;
-      const longest = open2.map((n) => ({
-        n,
-        // The lead time as the knowledge scan read it (ADR 0117); a need with none sorts last.
-        days: n.leadTimeDays ? workingDays(n.leadTimeDays) : 0
-      })).sort((a, b) => b.days - a.days)[0];
-      const progress = os && canMoveOn(c.state) ? await openspecProgress(os, c.id).catch(() => void 0) : void 0;
-      const busy = await stageInProgress(root, c.id);
-      if (busy && stageOf(c.state) !== "done" && (!active || busy > active.at))
-        active = { id: c.id, at: busy };
-      changes.push({
-        id: c.id,
-        state: c.state,
-        tasks: files ? readChangeTasks(files).map((t) => ({ id: t.id, repo: t.repo, done: t.done })) : [],
-        feature: existsSync(join(changesDirOf(root), c.id, "feature.yaml")),
-        ...stagesDone.length ? { stagesDone } : {},
-        ...progress?.next ? { openspecStage: progress.next } : {},
-        ...await isFast(root, c, types) ? {
-          fast: true,
-          .../^state: done$/m.test(await readFile(join(changesDirOf(root), c.id, "stage", "small.yaml"), "utf8").catch(() => "")) ? { fastDone: true } : {}
-        } : {},
-        ...needs ? {
-          needs: {
-            open: open2.length,
-            ...longest?.days ? { longest: `${longest.n.title}, ${longest.n.leadTime}` } : {}
-          }
-        } : {}
-      });
-    }
-  } catch (e) {
-    problems.push({ file: "openspec/changes", message: e.message.split("\n")[0] });
-  }
-  return {
-    repos,
-    catalogRecords: view.catalog.records,
-    openQuestions: open.questions.map((q) => q.id),
-    ...Object.keys(changeQuestions).length ? { changeQuestions } : {},
-    ...active ? { active: active.id } : {},
-    sources,
-    changes,
-    problems,
-    ...orgpack ? { orgpack } : {},
-    ...unverifiedNeeds ? { unverifiedNeeds } : {}
-  };
-}
-var UNDER_WAY = /* @__PURE__ */ new Set(["drafting", "waiting", "questions", "stopped"]);
-async function stageInProgress(root, change) {
-  const dir = join(changesDirOf(root), change, "stage");
-  let newest;
-  for (const f of (await readdir(dir).catch(() => [])).filter((x) => x.endsWith(".yaml"))) {
-    const loop = await readFile(join(dir, f), "utf8").then((t) => {
-      try {
-        return (0, import_yaml.parse)(t);
-      } catch {
-        return null;
-      }
-    }, () => null);
-    const at = typeof loop?.updatedAt === "string" ? loop.updatedAt : "";
-    if (typeof loop?.state === "string" && UNDER_WAY.has(loop.state) && (!newest || at > newest))
-      newest = at || "0";
-  }
-  return newest;
-}
-async function isFast(root, c, types) {
-  const type = types.find((t) => t.id === c.type);
-  if (!type || type.size !== "small" && !type.smallWhenBriefSays)
-    return false;
-  const brief = await readFile(join(changesDirOf(root), c.id, "brief.md"), "utf8").catch(() => "");
-  return fastPathOf(type, brief).fast;
-}
-function stageOf(state) {
-  switch (state) {
-    case "draft":
-    case "define":
-    case "returned":
-      return "feature";
-    case "design":
-      return "architecture";
-    case "plan":
-      return "stories";
-    case "build":
-    case "qa":
-      return "tasks";
-    case "released":
-    case "archived":
-      return "done";
-    default:
-      return "release";
-  }
-}
-function changeSteps(c) {
-  const stage = stageSteps(c);
-  const id = c.id;
-  const done = stageOf(c.state) === "done";
-  const find = c.feature && !c.needs && !done ? [
-    {
-      step: "needs",
-      command: `atticus change needs ${id}`,
-      slash: `/atticus-needs ${id}`,
-      where: METAREPO,
-      why: `${id} is placed on the estate: your assistant says what it needs from the organisation (requests and processes to raise, standards to follow, teams to involve), and Atticus checks each against the change's own words (ADR 0101).`,
-      change: id
-    }
-  ] : [];
-  const raise = c.needs?.open && !done ? [
-    {
-      step: "raise-needs",
-      command: `atticus needs --change ${id}`,
-      where: METAREPO,
-      why: `${plural(c.needs.open, "need")} of ${id} ${c.needs.open === 1 ? "is" : "are"} open${c.needs.longest ? ` (the longest: ${c.needs.longest})` : ""}. Raise each, then record it with atticus needs done ${id} <item>.`,
-      change: id,
-      person: true
-    }
-  ] : [];
-  return [...find, ...stage, ...raise];
-}
-function stageSteps(c) {
-  const id = c.id;
-  const byState = stageOf(c.state);
-  const at = draftingAt;
-  const stage = c.openspecStage && at(byState) >= 0 && at(c.openspecStage) > at(byState) ? c.openspecStage : byState;
-  if (c.fast && (stage === "feature" || stage === "architecture" || stage === "stories"))
-    return c.fastDone ? [
-      {
-        step: "small-handoff",
-        command: `atticus change handoff ${id} --approve`,
-        where: METAREPO,
-        why: `${id}'s one step is done and nothing blocks it: a person opens its pull request, and merging it approves the plan (ADR 0113).`,
-        change: id,
-        person: true
-      }
-    ] : [
-      {
-        step: "small",
-        command: `atticus change small ${id}`,
-        slash: `/atticus-small ${id}`,
-        where: METAREPO,
-        why: `${id} is a small change: your assistant places it, writes its target flows and words its stories in one step, and Atticus runs every stage's checks and the critic at its gate (ADR 0113). Then a person approves its one pull request.`,
-        change: id
-      }
-    ];
-  if ((stage === "feature" || stage === "architecture" || stage === "stories") && c.stagesDone?.includes(stage)) {
-    const later = c.stagesDone.slice(c.stagesDone.indexOf(stage) + 1);
-    const gate = c.state === "returned" ? "define" : c.state;
-    return [
-      {
-        step: "handoff",
-        command: `atticus change handoff ${id} --approve`,
-        where: METAREPO,
-        why: `${id}'s ${stage} stage is done${later.length ? ` (and ${later.join(" and ")} ran ahead)` : ""}, but the change is still in ${c.state}: a person raises its ${gate} hand-off PR, and merging it approves the ${gate} gate and moves it on (ADR 0073).`,
-        change: id,
-        person: true
-      }
-    ];
-  }
-  switch (stage) {
-    case "feature":
-      return [
-        {
-          step: "feature",
-          command: `atticus change feature ${id}`,
-          slash: `/atticus-feature ${id}`,
-          where: METAREPO,
-          why: `${id} is at the feature stage: your assistant places it on the estate's flows and features, and Atticus checks and criticises every draft until nothing blocks (ADR 0087).`,
-          change: id
-        }
-      ];
-    case "architecture":
-      return [
-        {
-          step: "architecture",
-          command: `atticus change architecture ${id}`,
-          slash: `/atticus-architecture ${id}`,
-          where: METAREPO,
-          why: `${id} is at the architecture stage: your assistant writes its target flows, and Atticus checks and criticises every draft until nothing blocks (ADR 0087).`,
-          change: id
-        }
-      ];
-    case "stories":
-      return [
-        {
-          step: "stories",
-          command: `atticus plan stories ${id}`,
-          slash: `/atticus-stories ${id}`,
-          where: METAREPO,
-          why: `${id} has an approved design: write its stories and tasks.`,
-          change: id
-        }
-      ];
-    case "tasks": {
-      const t = c.tasks.find((x) => !x.done);
-      if (!t)
-        return [
-          {
-            step: "tasks",
-            command: `atticus change status ${id}`,
-            where: METAREPO,
-            why: `Every task of ${id} is ticked; the status says what is left before release.`,
-            change: id
-          }
-        ];
-      return [
-        {
-          step: "task",
-          command: `atticus task run ${id} ${t.id}`,
-          slash: `/atticus-task ${id} ${t.id}`,
-          where: METAREPO,
-          why: `Task ${t.id} of ${id} in ${t.repo} is the first one not done. /atticus-task gives your assistant its context (atticus task context ${id} ${t.id}): the story, the criteria, the step with today's code and the files to change (ADR 0113).`,
-          repo: t.repo,
-          change: id
-        }
-      ];
-    }
-    case "release":
-      return [
-        {
-          step: "release",
-          command: `atticus change status ${id}`,
-          slash: `/atticus-release ${id}`,
-          where: METAREPO,
-          why: `${id} is on its way to release: check what still blocks it.`,
-          change: id
-        }
-      ];
-    default:
-      return [];
-  }
-}
-function changeAnswer(id, ids) {
-  if (!ids.length)
-    return [];
-  return [
-    {
-      step: "answer",
-      command: "atticus questions list --state open",
-      slash: "/atticus-answer",
-      where: METAREPO,
-      why: `${plural(ids.length, "question")} of ${id} ${ids.length === 1 ? "is" : "are"} waiting for a person: ${ids.join(", ")}. Its stage goes on once ${ids.length === 1 ? "it is" : "they are"} answered.`,
-      person: true,
-      change: id
-    }
-  ];
-}
-function nextSteps(s) {
-  const out = [];
-  const byChange = s.changeQuestions ?? {};
-  const inHand = s.active ? s.changes.find((c) => c.id === s.active) : void 0;
-  if (inHand && stageOf(inHand.state) !== "done")
-    out.push(...changeAnswer(inHand.id, byChange[inHand.id] ?? []), ...changeSteps(inHand));
-  const ofChanges = new Set(Object.values(byChange).flat());
-  const repoQuestions = s.openQuestions.filter((id) => !ofChanges.has(id));
-  if (s.repos.length === 0 && !inHand) {
-    out.push({
-      step: "discover",
-      command: "atticus repos discover <folder>",
-      why: "No repo is listed yet. Propose the manifest from a folder of clones or your Git host's organisation (--org)."
-    });
-    return out;
-  }
-  const notCloned = s.repos.filter((r) => !r.cloned);
-  if (notCloned.length)
-    out.push({
-      step: "sync",
-      command: "atticus workspace sync",
-      why: `${plural(notCloned.length, "repo")} ${notCloned.length === 1 ? "isn't" : "aren't"} cloned yet: ${notCloned.map((r) => r.id).join(", ")}.`
-    });
-  const unread = s.repos.filter((r) => r.cloned && !r.facts && !r.scanned);
-  for (const r of unread)
-    out.push(r.read ? {
-      step: "write",
-      command: `atticus verify ${r.id} --write`,
-      why: `${r.id} is read: atticus verify ${r.id} --write checks its facts against the code, then puts them in the catalog and renders its map.`,
-      repo: r.id
-    } : {
-      step: "map",
-      command: `atticus map ${r.id}`,
-      slash: `/atticus-map ${r.id}`,
-      where: METAREPO,
-      // A-ledger: a repo read in parts says which part comes next, so nobody keeps the list.
-      why: r.readPlan?.next ? `${r.id} is read in ${r.readPlan.total} parts (${r.readPlan.file}): ${partOfWords({ part: r.readPlan.next.part, total: r.readPlan.total })} is next, ${r.readPlan.done === 0 ? "none" : r.readPlan.done} ${r.readPlan.done === 1 ? "is" : "are"} read (${r.readPlan.next.paths.join(", ")}). Your assistant reads the part and writes its facts, each citing its line.` : `${r.id} isn't read yet: your assistant reads it and writes its facts, each citing its line, and atticus verify ${r.id} checks them.`,
-      repo: r.id
-    });
-  const cloned = s.repos.filter((r) => r.cloned && !r.facts && r.scanned);
-  for (const r of cloned.filter((x) => !x.settings))
-    out.push({
-      step: "survey",
-      command: `atticus scan survey ${r.id}`,
-      slash: `/atticus-survey ${r.id}`,
-      where: METAREPO,
-      why: `${r.id} has no scan settings yet: your assistant reads it and drafts them, and Atticus checks each entry against the code.`,
-      repo: r.id
-    });
-  if (cloned.length && s.catalogRecords === 0)
-    out.push({
-      step: "scan",
-      command: "atticus scan",
-      why: "The catalog is empty: scan the repos into it."
-    });
-  const scanned = cloned;
-  for (const r of scanned)
-    if (r.verify === "none")
-      out.push({
-        step: "verify",
-        command: `atticus scan verify ${r.id}`,
-        slash: `/atticus-verify ${r.id}`,
-        where: METAREPO,
-        why: `The last scan of ${r.id} hasn't been verified: your assistant compares the code with what the scan recorded.`,
-        repo: r.id
-      });
-    else if (r.verify === "accept")
-      out.push({
-        step: "accept",
-        command: `atticus scan verify ${r.id} --accept`,
-        why: `The verify of ${r.id} proposes scan settings entries. A person reads the proposal and accepts it.`,
-        person: true,
-        repo: r.id
-      });
-  const undescribed = s.repos.filter((r) => r.described === "none");
-  if (undescribed.length)
-    out.push({
-      step: "describe",
-      command: `atticus repo describe ${undescribed[0].id} --description "what it is"`,
-      why: `${plural(undescribed.length, "repo")} ${undescribed.length === 1 ? "doesn't say" : "don't say"} what ${undescribed.length === 1 ? "it is" : "they are"}: ${undescribed.map((r) => r.id).join(", ")}. One line each is carried into every reading prompt, the join's questions and the views, so an opaque id can be read and placed.`,
-      person: true,
-      ...undescribed.length === 1 ? { repo: undescribed[0].id } : {}
-    });
-  const drafted = s.repos.filter((r) => r.described === "draft");
-  if (drafted.length)
-    out.push({
-      step: "describe-accept",
-      command: `atticus repo describe ${drafted[0].id} --accept`,
-      why: `Your assistant drafted what ${drafted.length === 1 ? "this repo is" : "these repos are"} and nobody has confirmed ${drafted.length === 1 ? "it" : "them"}: ${drafted.map((r) => r.id).join(", ")}. Until a person does, each is shown as unconfirmed everywhere it is used.`,
-      person: true,
-      ...drafted.length === 1 ? { repo: drafted[0].id } : {}
-    });
-  if (repoQuestions.length)
-    out.push({
-      step: "answer",
-      command: "atticus questions list --state open",
-      slash: "/atticus-answer",
-      where: METAREPO,
-      why: `${plural(repoQuestions.length, "question")} ${repoQuestions.length === 1 ? "is" : "are"} waiting for a person: ${repoQuestions.join(", ")}. The steps that asked go on once they are answered.`,
-      person: true
-    });
-  for (const r of scanned) {
-    const slash = { slash: `/atticus-spec ${r.id}`, where: METAREPO, repo: r.id };
-    if (r.flows === 0)
-      out.push({
-        step: "spec",
-        command: `atticus spec draft ${r.id}`,
-        ...slash,
-        why: `${r.id} has no spec yet: your assistant writes its flows, one per trigger, each step cited.`
-      });
-    else if (!r.checked)
-      out.push({
-        step: "spec-check",
-        command: `atticus spec check ${r.id}`,
-        ...slash,
-        why: `The spec of ${r.id} hasn't been checked since its last draft.`
-      });
-    else if (r.findings > 0)
-      out.push({
-        step: "spec",
-        command: `atticus spec draft ${r.id}`,
-        ...slash,
-        why: `The last spec check of ${r.id} found ${plural(r.findings, "problem")}: draft the flagged flows again, then check.`
-      });
-  }
-  for (const k of s.sources)
-    if (!k.snapshot)
-      out.push({
-        step: "sync-source",
-        command: `atticus sources sync --source ${k.id}`,
-        slash: `/atticus-knowledge ${k.id}`,
-        where: METAREPO,
-        why: `The knowledge source ${k.id} has no snapshot yet: copy its pages, then read them into knowledge items.`,
-        source: k.id
-      });
-    else if (!k.scanned)
-      out.push({
-        step: "knowledge",
-        command: `atticus knowledge scan --source ${k.id}`,
-        slash: `/atticus-knowledge ${k.id}`,
-        where: METAREPO,
-        why: `The newest snapshot of ${k.id} hasn't been read into knowledge items yet.`,
-        source: k.id
-      });
-    else if ((k.age ?? 0) > STALE_DAYS)
-      out.push({
-        step: "sync-source",
-        command: `atticus sources sync --source ${k.id}`,
-        slash: `/atticus-knowledge ${k.id}`,
-        where: METAREPO,
-        why: `The newest snapshot of ${k.id} is ${k.age} days old: sync it again, and a rescan reads only the pages that changed (ADR 0101).`,
-        source: k.id
-      });
-  if (s.orgpack?.draft)
-    out.push({
-      step: "accept-orgpack",
-      command: `atticus orgpack accept ${s.orgpack.draft.platform}`,
-      why: `A draft of the ${s.orgpack.draft.platform} profile has ${plural(s.orgpack.draft.proposals, "system")} from the wikis waiting: read it (proposals/orgpack/${s.orgpack.draft.platform}.md) and accept what is right, with --only or --verified-only.`,
-      person: true
-    });
-  else if (s.orgpack?.missing)
-    out.push({
-      step: "orgpack-draft",
-      command: "atticus orgpack draft",
-      why: `The wikis name ${plural(s.orgpack.missing, "product or vendor", "products and vendors")} that no profile has yet: draft them into the org pack, with their aliases and owners.`
-    });
-  if (s.unverifiedNeeds)
-    out.push({
-      step: "verify-knowledge",
-      command: "atticus knowledge list --unverified",
-      why: `${plural(s.unverifiedNeeds, "open need")} of changes ${s.unverifiedNeeds === 1 ? "comes" : "come"} from knowledge items no person has verified: check each against its page (atticus knowledge verify, correct or reject).`,
-      person: true
-    });
-  const inFlight = s.changes.filter((c) => stageOf(c.state) !== "done");
-  for (const c of inFlight)
-    if (c !== inHand)
-      out.push(...changeAnswer(c.id, byChange[c.id] ?? []), ...changeSteps(c));
-  if (!inFlight.length)
-    out.push({
-      step: "new-change",
-      command: 'atticus change new "<title>" --type <type>',
-      why: out.length ? "Then start a change: no change is in flight." : "Everything is onboarded, checked and answered, and no change is in flight. Start one."
-    });
-  return out;
-}
-async function nextCommand(root, o, io) {
-  if (!isMetarepo(root)) {
-    io.err(notMetarepo(root));
-    return 2;
-  }
-  const state = await readNextState(root);
-  const steps = nextSteps(state);
-  const runtime = await loadOrgPack(orgPackDirOf(root)).then((op) => op.runtime).catch(() => void 0);
-  const probes = (await readProbes(root)).results;
-  const probed = runtime ? probedAssistant(runtime, probes) : [...probes].sort((a, b) => b.measured.localeCompare(a.measured))[0]?.assistant;
-  const assistant = probed ?? runtime?.assistants.default ?? "copilot";
-  if (o.json) {
-    const runs = runtime ? whatRunsWhere(runtime, { probes }) : void 0;
-    const modelMode = !!runtime && runtime.ai !== "off" && runtime.modes.allowed.includes("model") && !!runtime.adapters.model && runtime.adapters.model.type !== "mock";
-    const classed = steps.map((x) => {
-      const c = x.person ? void 0 : stepClassOfNextStep(x.step);
-      return c ? { ...x, stepClass: c } : x;
-    });
-    const orgModels = stepModelsOf(runtime);
-    io.out(JSON.stringify({
-      next: classed[0],
-      steps: classed,
-      problems: state.problems,
-      ...runs ? { runs } : {},
-      modelMode,
-      assistant,
-      ...Object.keys(orgModels).length ? { orgModels } : {}
-    }, null, 2));
-    return 0;
-  }
-  for (const p of state.problems)
-    io.err(`Couldn't read ${p.file}: ${p.message}`);
-  const typeIn = ASSISTANT_FORMATS[assistant].typeIn;
-  const slashLine = (x) => x.slash ? `In ${typeIn}${x.where && x.where !== METAREPO ? ` in ${x.where}` : ""}: ${x.slash}` : void 0;
-  if (!o.all) {
-    const n = steps[0];
-    io.out(`Next: ${n.command}`);
-    const sl = slashLine(n);
-    if (sl)
-      io.out(sl);
-    io.out(`Why: ${n.why}`);
-    if (steps.length > 1)
-      io.out(`${plural(steps.length - 1, "more step")} after this one: atticus next --all`);
-    return 0;
-  }
-  steps.forEach((x, i) => {
-    io.out(`${i + 1}. ${x.command}`);
-    const sl = slashLine(x);
-    if (sl)
-      io.out(`   ${sl}`);
-    io.out(`   ${x.why}`);
-  });
-  return 0;
-}
-
-export {
-  canMoveOn,
-  readNextState,
-  changeSteps,
-  nextSteps,
-  nextCommand
-};