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

package/dist/chunk-AXXCPAP6.js

@@ -0,0 +1,203 @@
+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 {
+  buildSite,
+  catalogRecords,
+  openChanges
+} from "./chunk-5FEOD73Z.js";
+import {
+  doctorChecks
+} from "./chunk-S2FBBX7D.js";
+import {
+  readProbes,
+  whatRunsWhere
+} from "./chunk-V5PKHHQQ.js";
+import {
+  baseClonePath,
+  loadRepos
+} from "./chunk-KJPMEAI4.js";
+import {
+  CatalogBaseline,
+  DEFAULT_RUNTIME,
+  WORKSPACE_SCHEMA_VERSION,
+  catalogDirOf,
+  inputsDirOf,
+  loadOrgPack,
+  orgPackDirOf,
+  require_dist
+} from "./chunk-S2A7YC3Q.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/baseline-commands.js
+var import_yaml = __toESM(require_dist(), 1);
+import { readdir, readFile, stat, writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+var BASELINE_FILE = "baseline.yaml";
+async function readBaseline(root) {
+  try {
+    const r = CatalogBaseline.safeParse((0, import_yaml.parse)(await readFile(join(catalogDirOf(root), BASELINE_FILE), "utf8")));
+    return r.success ? r.data : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function countFiles(dir) {
+  try {
+    const all = await readdir(dir, { recursive: true, withFileTypes: true });
+    return all.filter((e) => e.isFile()).length;
+  } catch {
+    return 0;
+  }
+}
+async function setupSteps(root, o = {}) {
+  const clonedOf = async (repos2) => (await Promise.all(repos2.map((r) => stat(join(baseClonePath(root, r.id), ".git")).then(() => true, () => false)))).filter(Boolean).length;
+  const [doctor, op, repos, records, inputs, baseline, probes] = await Promise.all([
+    o.doctor ?? doctorChecks(root),
+    loadOrgPack(orgPackDirOf(root)),
+    loadRepos(root).catch(() => []),
+    catalogRecords(root),
+    countFiles(inputsDirOf(root)),
+    readBaseline(root),
+    readProbes(root).then((p) => p.results)
+  ]);
+  const failing = doctor.filter((c) => c.status === "fail");
+  const cloned = await clonedOf(repos);
+  const generated = records.filter((r) => r.evidence.some((e) => e.source !== "manual")).length;
+  const wikis = op.sources.wikis.length;
+  const steps = [
+    {
+      id: "machine",
+      label: "This machine has what Atticus needs",
+      done: failing.length === 0,
+      detail: failing.length ? `to fix: ${failing.map((c) => c.label).join(", ")}` : `${doctor.filter((c) => c.status === "warn").length} to look at`,
+      fix: failing.length ? `Run atticus doctor: ${failing.map((c) => c.fix ?? c.label).join(" ")}` : "Run atticus doctor for the details."
+    },
+    {
+      id: "org-pack",
+      label: "The org pack's files are valid",
+      done: op.problems.length === 0,
+      detail: op.problems.length ? `${op.problems.length} problem${op.problems.length === 1 ? "" : "s"}` : "no problems in its files",
+      fix: "Run atticus orgpack validate and fix each problem it names (each says the file and field)."
+    },
+    {
+      // A new metarepo's org pack is valid as atticus init wrote it, but nobody owns it yet.
+      id: "org-pack-owner",
+      label: "The org pack has an owner",
+      done: !!op.pack?.owner && op.pack.owner !== "unassigned",
+      detail: op.pack?.owner && op.pack.owner !== "unassigned" ? op.pack.owner : "unassigned",
+      fix: "Set owner in org-pack/pack.yaml to the person who looks after the org pack (normally the platform lead), and commit it through a pull request."
+    },
+    {
+      // ADR 0121 item 6: how AI runs here is a choice, not the default left by accident.
+      id: "ai",
+      label: "Choose how AI runs here",
+      // runtime.yaml's version alone (1 from an older init, ADR 0121 addendum) isn't a choice.
+      done: JSON.stringify({ ...op.runtime, schemaVersion: DEFAULT_RUNTIME.schemaVersion }) !== JSON.stringify(DEFAULT_RUNTIME),
+      detail: whatRunsWhere(op.runtime, { probes }),
+      fix: "Choose the assistants, the modes and the model provider on Set up \u203A AI in the app (or in org-pack/runtime.yaml), and commit it through a pull request. As atticus init wrote it, steps are handed to Copilot, which needs nothing more.",
+      optional: true
+    },
+    {
+      id: "repos",
+      label: "Repos are listed",
+      done: repos.length > 0,
+      detail: `${repos.length} repo${repos.length === 1 ? "" : "s"} in the manifests`,
+      fix: "Run atticus repos discover <folder> (or --org <org>) and add what it proposes to repos.manifest.yaml."
+    },
+    {
+      id: "clones",
+      label: "Repos are cloned here",
+      done: repos.length > 0 && cloned === repos.length,
+      detail: `${cloned} of ${repos.length} cloned`,
+      fix: "Run atticus workspace sync (or Sync repos on the Scans screen); it clones what's missing."
+    },
+    {
+      // ADR 0124: your assistant reads each repo and writes its facts; Atticus checks every one
+      // against its line and puts them in the catalog. The id stays: the app keys on it.
+      id: "scan",
+      label: "Every repo is read and verified",
+      done: generated > 0,
+      detail: `${records.length} record${records.length === 1 ? "" : "s"} in the catalog`,
+      fix: "Read each repo: /atticus-map <repo> in your assistant (or atticus map <repo>), then atticus verify <repo> --write. Verify checks every fact against the line it cites and runs no model."
+    },
+    {
+      id: "knowledge",
+      label: "Existing knowledge is added",
+      done: inputs > 0 || wikis > 0,
+      detail: `${inputs} file${inputs === 1 ? "" : "s"} in inputs/, ${wikis} wiki source${wikis === 1 ? "" : "s"}`,
+      fix: "Drop diagrams, partner specs and exports into inputs/ (atticus intake add <files>), and add wikis to sources.yaml (atticus sources add).",
+      optional: true
+    },
+    {
+      id: "baseline",
+      label: "The catalog is accepted",
+      done: !!baseline,
+      detail: baseline ? `accepted by ${baseline.acceptedBy} on ${baseline.acceptedAt.slice(0, 10)}` : "not yet",
+      fix: "Walk the ecosystem map with the architect, then accept it: atticus baseline (or Accept the catalog on Home), and commit catalog/baseline.yaml through a pull request."
+    }
+  ];
+  return { steps, baselined: !!baseline };
+}
+async function setupCommand(root, o, io) {
+  const s = await setupSteps(root);
+  const open = s.steps.filter((x) => !x.done && !x.optional);
+  if (o.json)
+    io.out(JSON.stringify(s, null, 2));
+  else {
+    for (const x of s.steps) {
+      io.out(`${x.done ? "[x]" : "[ ]"} ${x.label}: ${x.detail}${x.optional ? " (optional)" : ""}`);
+      if (!x.done && x.fix)
+        io.out(`    ${x.fix}`);
+    }
+    io.out(open.length ? `${open.length} step${open.length === 1 ? "" : "s"} to go.` : "Setup is done: the catalog is accepted.");
+  }
+  return open.length ? 1 : 0;
+}
+async function baselineCommand(root, o, io) {
+  if (!o.by) {
+    io.err("Usage: atticus baseline [--by <you>] [--note <text>] [--site <dir>]");
+    return 2;
+  }
+  const records = await catalogRecords(root, io);
+  if (records.length === 0) {
+    io.err("The catalog is empty: read the repos first (atticus map <repo>, then atticus verify <repo> --write), then walk the map and accept it.");
+    return 1;
+  }
+  const kinds = {};
+  for (const r of records)
+    kinds[r.kind] = (kinds[r.kind] ?? 0) + 1;
+  const systems = records.filter((r) => r.kind === "System").map((r) => r.id).sort();
+  const b = CatalogBaseline.parse({
+    schemaVersion: WORKSPACE_SCHEMA_VERSION,
+    acceptedBy: o.by,
+    acceptedAt: o.now ?? (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z"),
+    kinds: Object.fromEntries(Object.entries(kinds).sort(([a], [b2]) => a.localeCompare(b2))),
+    systems,
+    ...o.note ? { note: o.note } : {}
+  });
+  await writeFile(join(catalogDirOf(root), BASELINE_FILE), (0, import_yaml.stringify)(b), "utf8");
+  io.out(`Accepted the catalog as the baseline as ${o.by}: ${records.length} records in ${Object.keys(kinds).length} kinds, ${systems.length} systems. Wrote catalog/${BASELINE_FILE}; commit it with the catalog and open a pull request, whose merge makes it the baseline on main.`);
+  if (o.site) {
+    const dir = resolve(o.site);
+    const s = await buildSite(records, dir, {
+      title: "Catalog",
+      builtAt: b.acceptedAt.slice(0, 10),
+      changes: await openChanges(root)
+    });
+    io.out(`Wrote the read-only catalog site to ${dir} (${s.systems.length} systems).`);
+  }
+  return 0;
+}
+
+export {
+  BASELINE_FILE,
+  readBaseline,
+  setupSteps,
+  setupCommand,
+  baselineCommand
+};

package/dist/chunk-AY3QXYMB.js

@@ -0,0 +1,41 @@
+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 {
+  MIGRATIONS,
+  STAMP_FILE,
+  readStamp,
+  upgradeCheck,
+  upgradeCommand
+} from "./chunk-72TXNLOC.js";
+import "./chunk-IQFTZ37C.js";
+import "./chunk-V5PKHHQQ.js";
+import "./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 "./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-JPGCERE2.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 {
+  MIGRATIONS,
+  STAMP_FILE,
+  readStamp,
+  upgradeCheck,
+  upgradeCommand
+};

package/dist/chunk-B2OKWJIU.js

@@ -0,0 +1,143 @@
+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 {
+  readRound,
+  reviewedGates,
+  roundsOf
+} from "./chunk-7UFQZXZA.js";
+import {
+  changeStore,
+  liveHandoff
+} from "./chunk-56YQ6ROQ.js";
+import {
+  createAdapters
+} from "./chunk-7JUKDRSZ.js";
+import {
+  loadOrgPack,
+  orgPackDirOf
+} from "./chunk-S2A7YC3Q.js";
+
+// packages/cli/dist/digest-commands.js
+var norm = (s) => s.toLowerCase().replace(/^@/, "");
+async function buildDigest(root, user) {
+  const revise = [];
+  const blocking = [];
+  const changes = await changeStore(root).list().catch(() => []);
+  const me = norm(user);
+  for (const c of changes.sort((a, b) => a.id.localeCompare(b.id))) {
+    const h = liveHandoff(c);
+    if (h?.state === "changes-requested" && norm(h.by) === me)
+      revise.push({
+        change: c.id,
+        title: c.title,
+        phase: h.phase,
+        pr: h.pr.url,
+        openedAt: h.openedAt
+      });
+  }
+  for (const c of changes.sort((a, b) => a.id.localeCompare(b.id))) {
+    if (c.state === "archived")
+      continue;
+    const mine = norm(c.createdBy) === me || Object.values(c.owners ?? {}).some((hs) => hs.some((h) => norm(h) === me));
+    if (!mine)
+      continue;
+    let open = 0;
+    for (const gate of await reviewedGates(root, c.id)) {
+      const rounds = await roundsOf(root, c.id, gate);
+      if (!rounds.length)
+        continue;
+      const round = await readRound(root, c.id, gate, rounds.at(-1));
+      open += round.findings.filter((f) => f.finding.state === "open" && f.finding.severity === "blocking").length;
+    }
+    if (open)
+      blocking.push({ change: c.id, open });
+  }
+  const lines = [];
+  if (revise.length) {
+    lines.push(`${revise.length} hand-off${revise.length === 1 ? "" : "s"} to revise:`);
+    for (const w of revise)
+      lines.push(`- ${w.change} (${w.phase}): ${w.pr}`);
+  }
+  if (blocking.length) {
+    lines.push("Blocking findings on changes you are on:");
+    for (const b of blocking)
+      lines.push(`- ${b.change}: ${b.open} open`);
+  }
+  if (!lines.length)
+    lines.push("Nothing waits on you.");
+  const { readMe } = await import("./chunk-ZMAINWBW.js");
+  const { watchLine } = await import("./chunk-QKRNMBJO.js");
+  const watching = [];
+  for (const c of (await readMe(root)).watch)
+    watching.push(await watchLine(root, c));
+  if (watching.length)
+    lines.push("Changes you watch:", ...watching.map((w) => `- ${w}`));
+  const n = revise.length + blocking.length;
+  return {
+    title: !n ? "Atticus: nothing waits on you" : n === 1 ? "Atticus: 1 thing waits on you" : `Atticus: ${n} things wait on you`,
+    body: lines.join("\n"),
+    lines,
+    revise,
+    blocking,
+    watching
+  };
+}
+async function digestCommand(root, o, io, deps = {}) {
+  if (!o.as) {
+    io.err("Usage: atticus digest [--as <you>] [--channel <c>] [--send] [--json]");
+    return 2;
+  }
+  const d = await buildDigest(root, o.as);
+  let sent;
+  let notSent;
+  if (o.send) {
+    let notify = deps.notify;
+    if (!notify) {
+      const op = await loadOrgPack(orgPackDirOf(root));
+      const cfg = op.runtime.adapters.notify;
+      if (!cfg)
+        notSent = "No notify adapter is set in org-pack/runtime.yaml (adapters.notify).";
+      else if (cfg.type === "manual")
+        notSent = "Notifications are manual here, so the digest is shown instead of sent.";
+      else
+        try {
+          notify = createAdapters({ adapters: { notify: cfg } }).notify;
+        } catch (e) {
+          notSent = e.message;
+        }
+    }
+    if (notify) {
+      const channel = o.channel ?? `@${o.as}`;
+      try {
+        const r = await notify.send({ channel, title: d.title, body: d.body, mentions: [o.as] }, {
+          by: o.as,
+          at: deps.now ?? (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z"),
+          ref: `digest:${o.as}`
+        });
+        sent = { id: r.id, channel };
+      } catch (e) {
+        notSent = `The notify adapter refused: ${e.message}`;
+      }
+    }
+  }
+  if (o.json)
+    io.out(JSON.stringify({ ...d, ...sent ? { sent } : {}, ...notSent ? { notSent } : {} }, null, 2));
+  else {
+    io.out(d.title);
+    for (const l of d.lines)
+      io.out(l);
+    if (sent)
+      io.out(`Sent to ${sent.channel} (${sent.id}).`);
+    if (notSent)
+      io.err(notSent);
+  }
+  return o.send && !sent ? 1 : 0;
+}
+
+export {
+  buildDigest,
+  digestCommand
+};

package/dist/chunk-B632FH3I.js

@@ -0,0 +1,251 @@
+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 {
+  isCritic
+} from "./chunk-4Q3NN7VF.js";
+import {
+  lensRunOf
+} from "./chunk-7UFQZXZA.js";
+import {
+  CONTEXT_TOOLS
+} from "./chunk-T6AIP7H5.js";
+import {
+  HandoffRuntime,
+  TOOL_LIMITS,
+  modelEnvOf,
+  stepClassOf
+} from "./chunk-CNUKCS2T.js";
+import {
+  changesRelOf,
+  listQuestions,
+  loadOrgPack,
+  orgPackDirOf,
+  runsDirOf,
+  runsRelOf,
+  stepModelsOf
+} from "./chunk-S2A7YC3Q.js";
+
+// packages/cli/dist/handoff-flag.js
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+var isStage = (group, command) => group === "change" && (command === "feature" || command === "architecture" || command === "small") || group === "plan" && command === "stories";
+async function runStates(root) {
+  const out = /* @__PURE__ */ new Map();
+  const dir = runsDirOf(root);
+  for (const change of await readdir(dir).catch(() => []))
+    for (const id of await readdir(join(dir, change)).catch(() => [])) {
+      const text = await readFile(join(dir, change, id, "run.json"), "utf8").catch(() => "");
+      if (!text)
+        continue;
+      try {
+        const run = JSON.parse(text);
+        out.set(`${change}/${id}`, { key: `${run.state}:${run.attempt}`, run });
+      } catch {
+      }
+    }
+  return out;
+}
+var OWN_MODES = /* @__PURE__ */ new Set(["model", "headless-claude-code"]);
+function modeOf(argv) {
+  const at = argv.findIndex((a) => a === "--mode" || a.startsWith("--mode="));
+  if (at < 0)
+    return "hand-off";
+  const m = argv[at].includes("=") ? argv[at].split("=")[1] : argv[at + 1] ?? "";
+  return OWN_MODES.has(m) ? m : "hand-off";
+}
+function stepArgs(argv) {
+  const out = [];
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--handoff" || a === "--json")
+      continue;
+    if (a === "--mode" || a === "--resume") {
+      i++;
+      continue;
+    }
+    if (a.startsWith("--mode=") || a.startsWith("--resume=") || a.startsWith("--handoff="))
+      continue;
+    out.push(a);
+  }
+  return out;
+}
+var shell = (a) => /^[\w./:@=+-]+$/.test(a) ? a : a.includes('"') ? JSON.stringify(a) : `"${a}"`;
+async function handoffStep(root, argv, io, dispatch) {
+  const args = stepArgs(argv);
+  const resumeAt = argv.findIndex((a) => a === "--resume" || a.startsWith("--resume="));
+  const resume = resumeAt < 0 ? [] : argv[resumeAt].includes("=") ? [argv[resumeAt]] : argv.slice(resumeAt, resumeAt + 2);
+  const json = argv.includes("--json");
+  const before = await runStates(root);
+  const asked = json ? await openQuestions(root) : /* @__PURE__ */ new Map();
+  const out = [];
+  const err = [];
+  const facts = [];
+  let code;
+  try {
+    code = await dispatch([...args, ...resume, "--mode", modeOf(argv)], {
+      out: (l) => out.push(l),
+      err: (l) => err.push(l),
+      report: (f) => facts.push(f)
+    });
+  } catch (e) {
+    if (!json)
+      throw e;
+    err.push(e.message.split("\n")[0]);
+    code = 3;
+  }
+  const after = await runStates(root);
+  const byStart = (a, b) => a.startedAt.localeCompare(b.startedAt) || a.runId.localeCompare(b.runId);
+  const critic = isCritic(args[0], args[1]);
+  const stage = isStage(args[0], args[1]);
+  const queue = critic || stage;
+  const changeArg = critic ? args[1] : stage ? args[2] : void 0;
+  const ofChange = (x) => !changeArg || changeArg.startsWith("-") || x.request.change === changeArg;
+  const waiting = [...after].filter(([path, s]) => s.run.state === "waiting" && before.get(path)?.key !== s.key).map(([, s]) => s.run).filter(ofChange).sort(byStart);
+  const resumed = resume.length ? resume.join("=").split("=").at(-1) : void 0;
+  const resumedRun = [...after.values()].find((s) => s.run.runId === resumed)?.run;
+  const named = facts.map((f) => "handoff" in f ? f.handoff.runId : void 0).filter((x) => !!x).at(-1);
+  const namedRun = named ? [...after.values()].find((s) => s.run.runId === named)?.run : void 0;
+  const still = resumedRun && (resumedRun.state === "waiting" || resumedRun.state === "failed" && namedRun?.runId === resumedRun.runId) ? resumedRun : void 0;
+  const next = queue && resumedRun && !still ? [...after.values()].map((s) => s.run).filter((x) => x.state === "waiting" && x.runId !== resumedRun.runId && x.request.change === resumedRun.request.change && x.startedAt >= resumedRun.startedAt && (critic || !!lensRunOf(x.request))).sort(byStart)[0] : void 0;
+  const waitedOn = !resume.length && namedRun && before.get(`${namedRun.request.change}/${namedRun.runId}`) ? namedRun : void 0;
+  const offered = namedRun && ["waiting", "failed"].includes(namedRun.state) ? namedRun : void 0;
+  const run = offered ?? (queue ? waiting[0] : waiting.at(-1)) ?? still ?? next ?? waitedOn ?? void 0;
+  const pagesLeft = facts.map((f) => "pagesLeft" in f ? f.pagesLeft : void 0).filter((x) => x !== void 0).at(-1);
+  const stillOffered = !!run && (run === still || run === waitedOn);
+  if (json)
+    return printJson(root, argv, args, {
+      run,
+      still: stillOffered,
+      code,
+      out,
+      err,
+      asked,
+      ...pagesLeft !== void 0 ? { pagesLeft } : {}
+    }, io);
+  if (!run) {
+    for (const l of out)
+      io.out(l);
+    for (const l of err)
+      io.err(l);
+    return code;
+  }
+  for (const l of err)
+    io.err(l);
+  if (stillOffered)
+    io.out(`Run ${run.runId} is still waiting for its result file.`);
+  const runsRel = runsRelOf(root);
+  io.out(`Prompt: ${HandoffRuntime.promptRel(run, runsRel)}`);
+  io.out(`Result file: ${HandoffRuntime.outputRel(run, changesRelOf(root), runsRel)}`);
+  const expects = await expectedModel(root, run, process.env);
+  if (expects)
+    io.out(expectedLine(expects));
+  io.out("When the result file is written, run:");
+  io.out(`  atticus handoff done ${run.runId}${rootArg(argv)}`);
+  io.out(`  atticus ${[...args, "--handoff", "--resume", run.runId].map(shell).join(" ")}`);
+  return 0;
+}
+async function openQuestions(root) {
+  const r = await listQuestions(root, { state: "open" });
+  return new Map(r.questions.map((q) => [q.id, `${q.askedBy.at}:${q.alsoAskedBy?.length ?? 0}:${q.rerun}`]));
+}
+var questionOut = (q) => ({
+  id: q.id,
+  repo: q.repo,
+  question: q.question,
+  options: q.options,
+  evidence: q.evidence,
+  answer: `atticus questions answer ${q.id}`
+});
+async function printJson(root, argv, args, s, io) {
+  const { run } = s;
+  if (run) {
+    const runsRel = runsRelOf(root);
+    const doneArgs = ["handoff", "done", run.runId, ...rootArgv(argv)];
+    const resumeArgs = [...args, "--handoff", "--json", "--resume", run.runId];
+    const lens = lensRunOf(run.request);
+    const stepClass = run.stepClass ?? stepClassOf(run.request);
+    const orgModel = (await orgModels(root))[stepClass];
+    io.out(JSON.stringify({
+      state: "handoff",
+      runId: run.runId,
+      // ADR 0115: one of the critic's AI lenses, reviewing what the step wrote.
+      ...lens ? { lens } : {},
+      stepClass,
+      ...orgModel ? { orgModel } : {},
+      root,
+      ...s.still ? { stillWaiting: true } : {},
+      promptFile: HandoffRuntime.promptRel(run, runsRel),
+      resultFile: HandoffRuntime.outputRel(run, changesRelOf(root), runsRel),
+      doneCommand: `atticus ${doneArgs.map(shell).join(" ")}`,
+      doneArgs,
+      resumeCommand: `atticus ${resumeArgs.map(shell).join(" ")}`,
+      resumeArgs,
+      // ADR 0107 addendum: the read-only tools the model may call. A tool call runs as
+      // atticus <callArgs> <tool> --input <json> --round <n> --json <runArgs>, kept in the run.
+      tools: {
+        definitions: CONTEXT_TOOLS,
+        limits: TOOL_LIMITS,
+        callArgs: ["context", "call"],
+        runArgs: ["--run", run.runId, ...rootArgv(argv)]
+      },
+      messages: s.out,
+      // ADR 0115 addendum (2026-10-26): what the step said was wrong with an answer it read,
+      // so a tool that runs the loop shows it instead of re-sending the same prompt silently.
+      ...s.err.length ? { errors: s.err } : {}
+    }, null, 2));
+    return 0;
+  }
+  const text = [...s.out, ...s.err].join("\n");
+  const open = (await listQuestions(root, { state: "open" })).questions;
+  const questions = open.filter((q) => {
+    const was = s.asked.get(q.id);
+    return was === void 0 || was !== `${q.askedBy.at}:${q.alsoAskedBy?.length ?? 0}:${q.rerun}` || text.includes(q.id);
+  });
+  const state = questions.length ? "question" : s.code === 0 ? "done" : s.code === 1 ? "stopped" : "failed";
+  io.out(JSON.stringify({
+    state,
+    exitCode: s.code,
+    root,
+    messages: s.out,
+    errors: s.err,
+    questions: questions.map(questionOut),
+    // A batched scan's pages left for the next batch, as data (never read from its words).
+    ...s.pagesLeft !== void 0 ? { pagesLeft: s.pagesLeft } : {}
+  }, null, 2));
+  return s.code;
+}
+async function orgModels(root) {
+  return stepModelsOf(await loadOrgPack(orgPackDirOf(root)).then((op) => op.runtime).catch(() => void 0));
+}
+async function expectedModel(root, run, env) {
+  const stepClass = run.stepClass ?? stepClassOf(run.request);
+  const set = env[modelEnvOf(stepClass)]?.trim();
+  if (set && set !== "atticus")
+    return { stepClass, model: set, from: "setting" };
+  const org = (await orgModels(root))[stepClass];
+  return org ? { stepClass, model: org, from: "runtime.yaml" } : void 0;
+}
+var expectedLine = (e) => `Model: this is a ${e.stepClass} step, which runs on ${e.model} (${e.from === "setting" ? "your setting" : `runtime.yaml models.${e.stepClass}`}). Pick it in your assistant's model picker before you send the prompt.`;
+function rootArgv(argv) {
+  const i = argv.indexOf("--root");
+  if (i >= 0 && argv[i + 1])
+    return ["--root", argv[i + 1]];
+  const eq = argv.find((a) => a.startsWith("--root="));
+  return eq ? [eq] : [];
+}
+function rootArg(argv) {
+  const i = argv.indexOf("--root");
+  if (i >= 0 && argv[i + 1])
+    return ` --root ${shell(argv[i + 1])}`;
+  const eq = argv.find((a) => a.startsWith("--root="));
+  return eq ? ` ${shell(eq)}` : "";
+}
+
+export {
+  handoffStep,
+  expectedModel,
+  expectedLine
+};

package/dist/chunk-BLW4SXCU.js

@@ -0,0 +1,38 @@
+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 {
+  completeCriticLens,
+  critic,
+  criticStats,
+  findingAction,
+  findings,
+  statusLine
+} from "./chunk-RZUZ4RJJ.js";
+import "./chunk-VOGCSYOI.js";
+import "./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-KJPMEAI4.js";
+import "./chunk-GQ4N4WKF.js";
+import "./chunk-CNUKCS2T.js";
+import "./chunk-S2A7YC3Q.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+export {
+  completeCriticLens,
+  critic,
+  criticStats,
+  findingAction,
+  findings,
+  statusLine
+};