@maycombhq/atticus 2.0.0-beta.10 → 2.0.0-beta.12

package/dist/chunk-5OACMWWI.js

@@ -0,0 +1,886 @@
+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 {
+  mapCommand,
+  mapStateOf
+} from "./chunk-7TEQF64E.js";
+import {
+  factsRepos,
+  verifyCommand
+} from "./chunk-BTOGAUWX.js";
+import {
+  plannedTopUp,
+  recordRulesNow,
+  ruleSetsOfFiles
+} from "./chunk-QY7RGTUP.js";
+import "./chunk-ZS47PQ3O.js";
+import {
+  estateFreshness
+} from "./chunk-I2PNEG3M.js";
+import {
+  onboardingQueue
+} from "./chunk-SK5OYWIY.js";
+import "./chunk-3CFBU2O6.js";
+import "./chunk-HJUEQERG.js";
+import "./chunk-B6X5PJSA.js";
+import {
+  checkoutOf,
+  conventionsAt,
+  excludesOf,
+  headOf,
+  loadReadPlan,
+  readPlanProgress
+} from "./chunk-P76AW3PA.js";
+import "./chunk-7VNEDDCC.js";
+import "./chunk-6S27MUQQ.js";
+import "./chunk-EU7VTBAI.js";
+import "./chunk-NCONDPHH.js";
+import {
+  isMetarepo,
+  notMetarepo
+} from "./chunk-3G4YI4ZU.js";
+import {
+  assistantTier,
+  readProbes,
+  rulesLacking
+} from "./chunk-GHSVJNVL.js";
+import "./chunk-VOGCSYOI.js";
+import {
+  estateRepos,
+  productionRepos
+} from "./chunk-22GLUHGE.js";
+import "./chunk-QR65C3DV.js";
+import {
+  dirSource,
+  sameCommit,
+  sessionTokensFor
+} from "./chunk-MLAACAES.js";
+import "./chunk-HY2VVVFZ.js";
+import "./chunk-PJRMMWU4.js";
+import "./chunk-34NWVIBC.js";
+import "./chunk-TWHZU36X.js";
+import "./chunk-ARLH2ZMD.js";
+import "./chunk-RA64IK43.js";
+import "./chunk-MRLCNXXR.js";
+import {
+  currentPromptLimit
+} from "./chunk-CQD26SMZ.js";
+import {
+  factsDirOf,
+  factsRelOf,
+  headFromFiles,
+  listQuestions,
+  loadOrgPack,
+  orgPackDirOf,
+  parseFacts,
+  require_dist
+} from "./chunk-U25OX22K.js";
+import {
+  ensureLocalIgnore,
+  writeFileAtomic
+} from "./chunk-MMB2OHUY.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/map-all.js
+var import_yaml = __toESM(require_dist(), 1);
+import { existsSync } from "node:fs";
+import { readFile, stat } from "node:fs/promises";
+import { join } from "node:path";
+var MAP_ALL_STATE_REL = ".atticus/map-all/state.json";
+var statePath = (root) => join(root, ".atticus", "map-all", "state.json");
+var REMIND_MS = 10 * 6e4;
+var IDLE_MINUTES = 15;
+var POLL_MS = 3e3;
+var RETRIES = 3;
+var plural = (n, one, many = `${one}s`) => `${n} ${n === 1 ? one : many}`;
+var tokensText = (n) => n.toLocaleString("en-US");
+var firstLine = (e) => String(e?.message ?? e).split("\n")[0];
+async function readMapAllState(root) {
+  const text = await readFile(statePath(root), "utf8").catch(() => void 0);
+  if (!text)
+    return void 0;
+  try {
+    const s = JSON.parse(text);
+    return s.schemaVersion === 1 && s.repos && typeof s.repos === "object" ? s : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function saveState(root, s, now) {
+  s.updatedAt = new Date(now).toISOString().replace(/\.\d{3}Z$/, "Z");
+  await ensureLocalIgnore(root);
+  await writeFileAtomic(statePath(root), `${JSON.stringify(s, null, 2)}
+`);
+}
+function modelModeAllowed(op) {
+  const rt = op.runtime;
+  return rt.ai !== "off" && rt.modes.allowed.includes("model") && !!rt.adapters.model && rt.adapters.model.type !== "mock";
+}
+async function limitFor(root, op, given) {
+  const flag = given ?? currentPromptLimit();
+  if (flag !== void 0)
+    return { limit: flag, from: "flag" };
+  const maxInput = op.runtime.adapters.model?.settings.maxInput;
+  if (typeof maxInput === "number")
+    return { limit: maxInput, from: "runtime.yaml" };
+  const tier = assistantTier(op.runtime, { probes: (await readProbes(root)).results });
+  if (tier.maxTokensFrom === "probe" && tier.maxTokens !== void 0)
+    return { limit: tier.maxTokens, from: "probe" };
+  return void 0;
+}
+function captured() {
+  const lines = [];
+  const errs = [];
+  return { lines, errs, out: (l) => lines.push(l), err: (l) => errs.push(l) };
+}
+function jsonOf(lines) {
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const l = lines[i].trimStart();
+    if (!l.startsWith("{"))
+      continue;
+    try {
+      return JSON.parse(lines.slice(i).join("\n"));
+    } catch {
+      try {
+        return JSON.parse(l);
+      } catch {
+        continue;
+      }
+    }
+  }
+  return void 0;
+}
+async function commitOf(root, repo, f) {
+  if (f?.head)
+    return f.head;
+  const dir = await checkoutOf(root, repo).catch(() => void 0);
+  if (!dir || !existsSync(dir))
+    return void 0;
+  return await headFromFiles(dir) ?? await headOf(dir);
+}
+async function partsOf(root, repo, commit, limit, git) {
+  const io = captured();
+  const code = await mapCommand(root, repo, { estimate: true, json: true, commit, maxTokens: limit }, io, git ? { git } : {});
+  const r = code === 0 ? jsonOf(io.lines) : void 0;
+  if (!r)
+    return io.errs[0] ?? `atticus map ${repo} --estimate didn't plan it`;
+  const planned = r.parts.parts;
+  const batches = r.batches ?? void 0;
+  if (!planned.length)
+    return {
+      parts: [{ part: 1, total: 1, paths: [], files: r.files, tokens: r.tokens }],
+      total: 1,
+      tokens: r.tokens,
+      ...batches !== void 0 ? { batches } : {}
+    };
+  const states = r.parts.plan?.parts ?? [];
+  const parts = planned.map((p, i) => ({ part: i + 1, total: planned.length, ...p })).filter((p) => states.find((s) => s.part === p.part)?.state !== "done");
+  return {
+    parts,
+    total: planned.length,
+    tokens: parts.reduce((n, p) => n + p.tokens, 0),
+    ...batches !== void 0 ? { batches } : {}
+  };
+}
+async function rulesPartsOf(root, repo, commit, limit, o = {}) {
+  const dir = await checkoutOf(root, repo).catch(() => void 0);
+  if (!dir)
+    return "no clone to read: atticus workspace sync clones it";
+  const p = await plannedTopUp(root, repo, {
+    commit,
+    source: dirSource(dir),
+    exclude: await excludesOf(root, repo),
+    conventions: await conventionsAt(root),
+    session: sessionTokensFor(limit),
+    ...o.save ? {} : { dryRun: true }
+  });
+  if ("error" in p)
+    return p.error;
+  const sessions = p.topUp?.sessions ?? [];
+  const parts = sessions.map((x, i) => ({
+    part: i + 1,
+    total: sessions.length,
+    paths: x.paths,
+    files: x.files,
+    tokens: x.tokens,
+    done: !!x.done
+  })).filter((x) => !x.done).map(({ done: _d, ...x }) => x);
+  return { parts, total: sessions.length, sets: ruleSetsOfFiles(sessions) };
+}
+async function planEstate(root, op, o, c, state) {
+  const all = estateRepos(op).map((r) => r.id);
+  const production = new Set(productionRepos(op).map((r) => r.id));
+  if (o.repos) {
+    const unknown = o.repos.filter((r) => !all.includes(r));
+    if (unknown.length)
+      return `No repo ${unknown.join(", ")} in the manifests (org-pack/profiles/*/repos.manifest.yaml).`;
+  }
+  const ids = o.repos ? all.filter((r) => o.repos.includes(r)) : all;
+  const fresh = await estateFreshness(root, { repos: ids, ...c.git ? { git: c.git } : {} });
+  const byId = new Map(fresh.repos.map((r) => [r.repo, r]));
+  const skipped = [];
+  const todo = [];
+  for (const repo of ids) {
+    const f = byId.get(repo);
+    const commit = await commitOf(root, repo, f);
+    if (!commit || f?.state === "no-checkout") {
+      skipped.push({ repo, why: "no clone to read: atticus workspace sync clones it" });
+      continue;
+    }
+    const state2 = f?.state ?? "not-read";
+    if (o.gaps) {
+      if (state2 === "not-read")
+        skipped.push({ repo, why: "not read yet: the gaps pass follows a read" });
+      else if (state2 === "stale" || state2 === "unknown-commit")
+        skipped.push({
+          repo,
+          why: "its clone moved past its facts: atticus map --all --stale reads what changed first"
+        });
+      else if (isDone(repo, commit))
+        skipped.push({ repo, why: "its gaps pass is done at this commit" });
+      else
+        todo.push({ repo, kind: "gaps", commit, why: "the second pass on what its read left" });
+      continue;
+    }
+    if (state2 === "stale" || state2 === "unknown-commit") {
+      todo.push({
+        repo,
+        kind: "reread",
+        commit,
+        why: state2 === "stale" ? `its clone moved past its facts: ${plural(f.reread, "fact")} to read again, ${plural(f.toRead, "file")} to read` : "the clone lacks the commit its facts were read at: read whole again",
+        started: true
+      });
+      continue;
+    }
+    if (state2 === "rules-changed") {
+      const progress = await readPlanProgress(root, repo, { commit });
+      todo.push(progress && !progress.stale && progress.next ? {
+        repo,
+        kind: "read",
+        commit,
+        why: `its read is under way: ${progress.done} of ${progress.total} parts read`,
+        started: true
+      } : { repo, kind: "rules", commit, why: "", started: true });
+      continue;
+    }
+    if (state2 === "moved") {
+      todo.push({
+        repo,
+        kind: "carry",
+        commit,
+        why: "its clone moved, but nothing its facts cite changed: verify carries them",
+        started: true
+      });
+      continue;
+    }
+    if (o.stale) {
+      skipped.push({
+        repo,
+        why: state2 === "fresh" ? "fresh" : "not read yet (atticus map --all reads it)"
+      });
+      continue;
+    }
+    if (state2 === "fresh") {
+      const progress = await readPlanProgress(root, repo, { commit });
+      if (progress && !progress.stale && progress.next) {
+        todo.push({
+          repo,
+          kind: "read",
+          commit,
+          why: `its read is under way: ${progress.done} of ${progress.total} parts read`,
+          started: true
+        });
+      } else
+        skipped.push({ repo, why: "read and fresh" });
+      continue;
+    }
+    todo.push({ repo, kind: "read", commit, why: "not read yet" });
+  }
+  const prod = todo.filter((t) => production.has(t.repo));
+  const q = await onboardingQueue(root, prod.map((t) => ({ repo: t.repo, ...t.started ? { started: true } : {} })));
+  const ordered = [
+    ...q.queue.map((x) => prod.find((t) => t.repo === x.repo)),
+    ...todo.filter((t) => !production.has(t.repo))
+  ];
+  const items = [];
+  for (const t of ordered) {
+    const base = {
+      repo: t.repo,
+      kind: t.kind,
+      commit: t.commit,
+      why: t.why,
+      ...production.has(t.repo) ? {} : { prototype: true }
+    };
+    if (t.kind === "carry") {
+      items.push({ ...base, parts: [], total: 0, tokens: 0 });
+      continue;
+    }
+    if (t.kind === "rules") {
+      const p2 = await rulesPartsOf(root, t.repo, t.commit, c.limit);
+      if (typeof p2 === "string") {
+        skipped.push({ repo: t.repo, why: p2 });
+        continue;
+      }
+      items.push({
+        ...base,
+        why: p2.sets.length ? `read before these reading rules: ${p2.sets.join(", ")}` : "read before the reading rules there are now, but no file of it is one they apply to: recorded as read under them",
+        sets: p2.sets,
+        parts: p2.parts,
+        total: p2.total,
+        tokens: p2.parts.reduce((n, x) => n + x.tokens, 0)
+      });
+      continue;
+    }
+    if (t.kind === "gaps") {
+      items.push({
+        ...base,
+        parts: [{ part: 1, total: 1, paths: [], files: 0, tokens: 0 }],
+        total: 1,
+        tokens: 0
+      });
+      continue;
+    }
+    const p = await partsOf(root, t.repo, t.commit, c.limit, c.git);
+    if (typeof p === "string") {
+      skipped.push({ repo: t.repo, why: p });
+      continue;
+    }
+    if (c.mode === "model" && p.batches === void 0) {
+      skipped.push({
+        repo: t.repo,
+        why: `a model of ${c.limit} tokens leaves too little room for its files beside the instructions`
+      });
+      continue;
+    }
+    if (!p.parts.length) {
+      skipped.push({ repo: t.repo, why: "every part of its read plan is read" });
+      continue;
+    }
+    items.push({ ...base, ...p });
+  }
+  return { limit: c.limit, limitFrom: c.limitFrom, mode: c.mode, items, skipped };
+  function isDone(repo, commit) {
+    const r = state?.repos[repo];
+    return !!r?.done && r.kind === "gaps" && sameCommit(r.commit, commit);
+  }
+}
+function planLines(plan) {
+  const out = [];
+  const reading = plan.items.filter((i) => i.kind !== "carry");
+  const parts = reading.reduce((n, i) => n + i.parts.length, 0);
+  const planned = reading.reduce((n, i) => n + Math.max(i.total, i.parts.length), 0);
+  const tokens = reading.reduce((n, i) => n + i.tokens, 0);
+  out.push(`The estate at ${tokensText(plan.limit)} tokens a prompt (${plan.limitFrom === "flag" ? "--max-tokens" : plan.limitFrom === "probe" ? "the limit atticus probe measured" : "runtime.yaml's maxInput"}), ${plan.mode === "model" ? "read by runtime.yaml's model, unattended" : "read by Copilot Chat in agent mode: you paste one line per part"}:`);
+  plan.items.forEach((i, n) => {
+    const head = `  ${n + 1}. ${i.repo}${i.prototype ? " (prototype: read, never joined)" : ""}`;
+    if (i.kind === "carry" || i.kind === "rules" && !i.parts.length)
+      return out.push(`${head}: ${i.why}.`);
+    if (i.kind === "rules")
+      out.push(`${head}: top-up for the reading rules added since it was read (${(i.sets ?? []).join(", ")}); ${plural(i.parts.length, "part")}${i.parts.length < i.total ? ` of ${i.total}` : ""}, about ${tokensText(i.tokens)} tokens.`);
+    if (i.kind === "rules") {
+      if (i.total > 1)
+        for (const p of i.parts)
+          out.push(`     part ${p.part} of ${p.total} (about ${tokensText(p.tokens)} tokens, ${plural(p.files, "file")}): ${p.paths.join(", ")}`);
+      return;
+    }
+    if (i.kind === "gaps")
+      return out.push(`${head}: ${i.why}, planned when it starts.`);
+    out.push(`${head}: ${i.kind === "reread" ? "re-read" : "read"}, ${i.why}; ${plural(i.parts.length, "part")}${i.parts.length < i.total ? ` of ${i.total}` : ""}, about ${tokensText(i.tokens)} tokens${plan.mode === "model" && i.batches !== void 0 ? `, ${plural(i.batches, "prompt")}` : ""}.`);
+    if (i.total > 1)
+      for (const p of i.parts)
+        out.push(`     part ${p.part} of ${p.total} (about ${tokensText(p.tokens)} tokens, ${plural(p.files, "file")}): ${p.paths.join(", ")}`);
+  });
+  for (const s of plan.skipped)
+    out.push(`  - ${s.repo}: skipped, ${s.why}.`);
+  out.push(plan.items.length ? `In all: ${plural(plan.items.length, "repo")}, ${plural(parts, "part")} to read${planned > parts ? ` (of ${planned} planned; ${planned - parts} ${planned - parts === 1 ? "is" : "are"} read already)` : ""}, about ${tokensText(tokens)} tokens (estimated from the source, not metered). Then atticus verify --all --write joins the estate once.` : "Nothing to read: every repo is read and fresh, or skipped as said.");
+  return out;
+}
+var mtime = async (p) => (await stat(p).catch(() => void 0))?.mtimeMs;
+async function snapOf(root, repo) {
+  const dir = factsDirOf(root);
+  const [facts, reviewed, verify] = await Promise.all([
+    mtime(join(dir, `${repo}.jsonl`)),
+    mtime(join(dir, `${repo}.reviewed.jsonl`)),
+    mtime(join(dir, `${repo}.verify.yaml`))
+  ]);
+  return {
+    ...facts !== void 0 ? { facts } : {},
+    ...reviewed !== void 0 ? { reviewed } : {},
+    ...verify !== void 0 ? { verify } : {}
+  };
+}
+var sameSnap = (a, b) => a.facts === b.facts && a.reviewed === b.reviewed && a.verify === b.verify;
+async function factsAt(root, repo, commit) {
+  const text = await readFile(join(factsDirOf(root), `${repo}.jsonl`), "utf8").catch(() => "");
+  if (!text.trim())
+    return 0;
+  const p = parseFacts(text);
+  return p.ok ? p.facts.filter((f) => sameCommit(f.commit, commit)).length : 0;
+}
+async function settled(root, repo, commit, s, since) {
+  if (s.verify === void 0 || s.verify === since.verify)
+    return false;
+  if (s.verify < (s.facts ?? 0) || s.verify < (s.reviewed ?? 0))
+    return false;
+  const text = await readFile(join(factsDirOf(root), `${repo}.verify.yaml`), "utf8").catch(() => "");
+  try {
+    const v = (0, import_yaml.parse)(text) ?? {};
+    return v.rejected === 0 && (!v.commit || sameCommit(v.commit, commit));
+  } catch {
+    return false;
+  }
+}
+async function covered(root, item, part, first, now) {
+  if (item.kind === "rules") {
+    const plan = await loadReadPlan(root, item.repo);
+    if (!plan?.topUp)
+      return rulesLacking(plan?.rules).length === 0;
+    return !!plan.topUp.sessions[part.part - 1]?.done;
+  }
+  if (item.total > 1) {
+    const p = await readPlanProgress(root, item.repo);
+    return p?.parts.find((x) => x.part === part.part)?.state === "done";
+  }
+  const moved = now.facts !== first.facts || now.reviewed !== first.reviewed;
+  if (item.kind === "read")
+    return moved || now.reviewed !== void 0 || await factsAt(root, item.repo, item.commit) > 0;
+  return moved;
+}
+var CapReached = class extends Error {
+};
+function capped(inner, o, spent) {
+  const over = () => o.maxParts !== void 0 && spent.prompts >= o.maxParts || o.budgetTokens !== void 0 && spent.tokens >= o.budgetTokens;
+  const estimated = /* @__PURE__ */ new Map();
+  return {
+    kind: inner.kind,
+    prepare: async (r) => {
+      if (over())
+        throw new CapReached();
+      spent.prompts++;
+      const run = await inner.prepare(r);
+      const est = r.pack.manifest.totalTokens;
+      estimated.set(run.runId, est);
+      spent.tokens += est;
+      return run;
+    },
+    run: async (id, signal) => {
+      const run = await inner.run(id, signal);
+      const u = run.usage;
+      if (u)
+        spent.tokens += u.inputTokens + u.outputTokens - (estimated.get(id) ?? 0);
+      estimated.delete(id);
+      return run;
+    },
+    result: (id) => inner.result(id)
+  };
+}
+async function mapAllCommand(root, o, io, deps = {}) {
+  if (!isMetarepo(root)) {
+    io.err(notMetarepo(root));
+    return 2;
+  }
+  const clock = deps.clock ?? {
+    now: () => Date.now(),
+    sleep: (ms) => new Promise((r) => setTimeout(r, ms))
+  };
+  const op = await loadOrgPack(orgPackDirOf(root));
+  const lim = await limitFor(root, op, o.maxTokens);
+  if (!lim) {
+    io.err("Atticus doesn't know your model's limit, and a part planned too big overflows the reader: pass --max-tokens <n> (the context window of the model Copilot Chat uses, in tokens), or set maxInput under adapters.model in runtime.yaml.");
+    return 2;
+  }
+  const limit = lim.limit;
+  const allowed = modelModeAllowed(op);
+  const mode = o.mode ?? (allowed ? "model" : "copilot");
+  if (mode === "model" && !allowed && !deps.runtime) {
+    io.err("runtime.yaml doesn't allow model mode with a provider here: map the estate through Copilot (atticus map --all without --mode model).");
+    return 2;
+  }
+  if (mode === "model" && o.gaps) {
+    io.err("The gaps pass is a session for an assistant that opens files: run atticus map --all --gaps --mode hand-off and paste each line into Copilot Chat.");
+    return 2;
+  }
+  let state = await readMapAllState(root);
+  if (state && (state.gaps !== !!o.gaps || state.mode !== mode))
+    state = void 0;
+  const plan = await planEstate(root, op, o, { limit: lim.limit, limitFrom: lim.from, mode, ...deps.git ? { git: deps.git } : {} }, state);
+  if (typeof plan === "string") {
+    io.err(plan);
+    return 2;
+  }
+  if (o.dryRun) {
+    if (o.json)
+      io.out(JSON.stringify(plan, null, 2));
+    else
+      for (const l of planLines(plan))
+        io.out(l);
+    return 0;
+  }
+  for (const l of planLines(plan))
+    io.out(l);
+  const st = state ?? {
+    schemaVersion: 1,
+    updatedAt: "",
+    mode,
+    gaps: !!o.gaps,
+    repos: {}
+  };
+  const save = () => saveState(root, st, clock.now());
+  await save();
+  const totals = {
+    parts: 0,
+    repos: /* @__PURE__ */ new Set(),
+    rejected: /* @__PURE__ */ new Map(),
+    added: 0,
+    removed: 0,
+    ends: [],
+    spent: { prompts: 0, tokens: 0 }
+  };
+  const stopped = () => deps.signal?.aborted === true;
+  const repoState = (item) => {
+    const r = st.repos[item.repo];
+    if (r && sameCommit(r.commit, item.commit) && r.kind === item.kind)
+      return r;
+    return st.repos[item.repo] = { commit: item.commit, kind: item.kind, parts: {} };
+  };
+  const partState = (item, part) => repoState(item).parts[String(part)] ??= { retries: 0 };
+  const verifyStep = async (item) => {
+    const c = captured();
+    await verifyCommand(root, item.repo, { commit: item.commit, write: true, json: true }, c);
+    const v = jsonOf(c.lines);
+    if (!v) {
+      io.out(`${item.repo}: verify didn't run: ${c.errs[0] ?? "no report"}`);
+      return void 0;
+    }
+    const links = v.written?.links;
+    totals.rejected.set(item.repo, v.rejected);
+    if (links) {
+      totals.added += links.added.length;
+      totals.removed += links.removed.length;
+    }
+    io.out(`${item.repo}: ${plural(v.accepted, "fact")} kept, ${v.rejected} rejected; coverage ${Math.round(v.coverage.ratio * 100)}% (${v.coverage.unknown.length} files no fact cites yet)${links ? `; links +${links.added.length} -${links.removed.length}` : ""}; ${plural(v.questions?.open ?? 0, "question")} open. ${v.rejected ? `Nothing written to the catalog until the rejected facts are fixed (${factsRelOf(root)}/${item.repo}.rejected.jsonl).` : v.written ? "Written to the catalog." : ""}`.trimEnd());
+    return v;
+  };
+  let quit = false;
+  let capHit = false;
+  let runtime;
+  const items = plan.items;
+  for (const [n, item] of items.entries()) {
+    if (quit || stopped())
+      break;
+    const where = `repo ${n + 1} of ${items.length}`;
+    if (item.kind === "rules" && !item.parts.length) {
+      io.out("");
+      io.out(`===== ${item.repo} (${where}): ${item.why} =====`);
+      await recordRulesNow(root, item.repo, item.commit);
+      repoState(item).done = true;
+      totals.repos.add(item.repo);
+      await save();
+      continue;
+    }
+    if (item.kind === "carry") {
+      io.out("");
+      io.out(`===== ${item.repo} (${where}): ${item.why} =====`);
+      const v = await verifyStep(item);
+      if (v && !v.rejected) {
+        repoState(item).done = true;
+        totals.repos.add(item.repo);
+      }
+      await save();
+      continue;
+    }
+    if (mode === "model") {
+      runtime ??= deps.runtime ?? await deps.makeRuntime?.();
+      if (!runtime) {
+        io.err("No model runtime: model mode needs runtime.yaml's provider.");
+        return 2;
+      }
+      const r = await modelRead(item, where, capped(runtime, o, totals.spent));
+      if (r === "cap") {
+        capHit = true;
+        break;
+      }
+      continue;
+    }
+    for (const part of item.parts) {
+      if (quit || stopped())
+        break;
+      const end = await copilotPart(item, part, where);
+      if (end === "quit") {
+        quit = true;
+        break;
+      }
+    }
+  }
+  const interrupted = quit || stopped() || capHit;
+  if (interrupted) {
+    io.out("");
+    io.out(capHit ? `Stopped at the cap (${o.maxParts !== void 0 ? `--max-parts ${o.maxParts}` : ""}${o.maxParts !== void 0 && o.budgetTokens !== void 0 ? ", " : ""}${o.budgetTokens !== void 0 ? `--budget-tokens ${o.budgetTokens}` : ""}): ${plural(totals.spent.prompts, "prompt")} run. atticus map --all carries on from here.` : "Stopped. Where the estate stands is saved: atticus map --all carries on from here.");
+  } else if (totals.parts || totals.repos.size) {
+    io.out("");
+    io.out("Joining the estate: atticus verify --all --write.");
+    const repos = await factsRepos(root);
+    let passed = 0;
+    for (const repo of repos) {
+      const c = captured();
+      const code = await verifyCommand(root, repo, { write: true, json: true }, c);
+      const v = jsonOf(c.lines);
+      if (code === 0)
+        passed++;
+      if (v?.written?.links) {
+        totals.added += v.written.links.added.length;
+        totals.removed += v.written.links.removed.length;
+      }
+      if (v)
+        totals.rejected.set(repo, v.rejected);
+    }
+    io.out(`Verified ${plural(repos.length, "repo")}: ${passed} passed${repos.length - passed ? `, ${repos.length - passed} with something to fix` : ""}.`);
+  }
+  await save();
+  await summary(interrupted);
+  return 0;
+  async function copilotPart(item, part, where) {
+    const ps = partState(item, part.part);
+    const nth = item.parts.indexOf(part) + 1;
+    const label = item.total > 1 ? `part ${part.part} of ${item.total}${item.parts.length < item.total && nth > 0 ? `, ${nth} of the ${item.parts.length} to read` : ""}` : "one session";
+    const progress = item.total > 1 ? await readPlanProgress(root, item.repo) : void 0;
+    const first0 = item.kind === "rules" ? await rulesLine(item) : item.kind === "gaps" ? await gapsLine(item) : ps.retries > 0 || progress?.next && progress.next.part !== part.part ? await restLine(item, part) ?? `/atticus-map ${item.repo}` : `/atticus-map ${item.repo}`;
+    if (first0 === void 0) {
+      io.out(`${item.repo}: no gaps left; nothing to read.`);
+      return finishPart(item, part, ps);
+    }
+    if (first0 === "done")
+      return finishPart(item, part, ps);
+    let line = first0;
+    await block(item, part, label, where, line, ps.retries);
+    let first = await snapOf(root, item.repo);
+    let since = first;
+    let prev = first;
+    let lastChange = clock.now();
+    let lastRemind = clock.now();
+    const started = clock.now();
+    let stuckSaid = false;
+    const idleMs = (o.idleMinutes ?? IDLE_MINUTES) * 6e4;
+    for (; ; ) {
+      if (stopped()) {
+        ps.state = "incomplete";
+        await save();
+        return "quit";
+      }
+      const typed = deps.input?.take()?.trim().toLowerCase();
+      if (typed === "q") {
+        ps.state = "incomplete";
+        await save();
+        return "quit";
+      }
+      if (typed === "s") {
+        io.out(`Skipped ${item.repo} ${label}.`);
+        ps.state = "skipped";
+        await save();
+        totals.ends.push(endOf(item, part, "skipped"));
+        return "skipped";
+      }
+      if (typed === "r") {
+        const again = await retry(item, part, label, where);
+        if (again === "done")
+          return finishPart(item, part, ps);
+        first = await snapOf(root, item.repo);
+        since = first;
+        prev = first;
+        lastChange = clock.now();
+        stuckSaid = false;
+        continue;
+      }
+      const now = await snapOf(root, item.repo);
+      if (!sameSnap(now, prev)) {
+        lastChange = clock.now();
+        stuckSaid = false;
+        prev = now;
+      }
+      if (await settled(root, item.repo, item.commit, now, since) && await covered(root, item, part, first, now)) {
+        const v = await verifyStep(item);
+        if (v && !v.rejected && await covered(root, item, part, first, await snapOf(root, item.repo)))
+          return finishPart(item, part, ps);
+        io.out(`Not done yet: ${v?.rejected ? `${plural(v.rejected, "fact")} rejected for the reader to fix` : "the part isn't accounted for in the facts yet"}. Still waiting (s + Enter skips, r + Enter gives the prompt again for what's left).`);
+        since = await snapOf(root, item.repo);
+        prev = since;
+      }
+      if (!stuckSaid && clock.now() - lastChange >= idleMs) {
+        io.out(`Copilot seems to have stopped on ${item.repo} ${item.total > 1 ? `part ${part.part}` : "(its one session)"}. r + Enter: verify what it wrote and give the prompt again for what's left, in a NEW chat; s: skip; q: stop.`);
+        stuckSaid = true;
+      }
+      if (clock.now() - lastRemind >= (deps.remindMs ?? REMIND_MS)) {
+        io.out(`Still waiting on ${item.repo} ${label} (${Math.round((clock.now() - started) / 6e4)} minutes). The line to paste: ${line}  (s + Enter skips, r + Enter retries what's left, q + Enter stops)`);
+        lastRemind = clock.now();
+      }
+      await clock.sleep(deps.pollMs ?? POLL_MS);
+    }
+    async function retry(item2, part2, label2, where2) {
+      ps.retries++;
+      await save();
+      const rest = item2.kind === "rules" ? await rulesLine(item2) : item2.kind === "gaps" ? await gapsLine(item2) : await restLine(item2, part2);
+      if (rest === "done" || rest === void 0 && item2.kind === "gaps")
+        return "done";
+      line = rest ?? `/atticus-map ${item2.repo}`;
+      await block(item2, part2, label2, where2, line, ps.retries);
+      if (ps.retries >= RETRIES) {
+        const smaller = Math.max(8e3, Math.floor(limit / 2 / 1e3) * 1e3);
+        io.out(`${item2.repo} ${label2} has been given again ${plural(ps.retries, "time")}: a smaller limit plans it in smaller parts, each a shorter chat. Stop (q), then atticus map --all --repos ${item2.repo} --max-tokens ${smaller}.`);
+      }
+      return "again";
+    }
+  }
+  async function finishPart(item, part, ps) {
+    ps.state = "done";
+    if (item.kind === "gaps" || part.part === item.total)
+      repoState(item).done = true;
+    totals.parts++;
+    totals.repos.add(item.repo);
+    await save();
+    return "done";
+  }
+  async function restLine(item, part) {
+    if (!existsSync(join(factsDirOf(root), `${item.repo}.jsonl`)))
+      return void 0;
+    const v = await verifyStep(item);
+    if (!v)
+      return void 0;
+    const parted = item.total > 1;
+    const c = captured();
+    const code = await mapCommand(root, item.repo, {
+      gaps: true,
+      json: true,
+      commit: item.commit,
+      maxTokens: limit,
+      ...parted ? { part: part.part } : {}
+    }, c, deps.git ? { git: deps.git } : {});
+    const g = code === 0 ? jsonOf(c.lines) : void 0;
+    if (!g)
+      return void 0;
+    if (!g.sessions.length && !v.rejected)
+      return "done";
+    return `/atticus-map ${item.repo}${parted ? ` --part ${part.part}` : ""} --gaps`;
+  }
+  async function rulesLine(item) {
+    const p = await rulesPartsOf(root, item.repo, item.commit, limit, { save: true });
+    if (typeof p === "string" || !p.parts.length)
+      return "done";
+    return `/atticus-map ${item.repo} --rules`;
+  }
+  async function gapsLine(item) {
+    const plain = captured();
+    await verifyCommand(root, item.repo, { commit: item.commit, json: true }, plain);
+    const c = captured();
+    const code = await mapCommand(root, item.repo, { gaps: true, json: true, commit: item.commit, maxTokens: limit }, c, deps.git ? { git: deps.git } : {});
+    const g = code === 0 ? jsonOf(c.lines) : void 0;
+    if (!g) {
+      io.out(`${item.repo}: the gaps pass couldn't be planned: ${c.errs[0] ?? "no plan"}`);
+      return void 0;
+    }
+    return g.sessions.length ? `/atticus-map ${item.repo} --gaps` : void 0;
+  }
+  async function block(item, part, label, where, line, retries) {
+    io.out("");
+    io.out(`===== ${item.repo}, ${item.kind === "gaps" ? "the gaps pass" : item.kind === "rules" ? `the rules top-up${item.total > 1 ? `, ${label}` : ""}` : label} (${where})${retries ? `, given again (${retries})` : ""} =====`);
+    io.out(`In a NEW Copilot Chat (agent mode), run: ${line}`);
+    if (item.kind === "rules")
+      io.out(`That chat reads ${plural(part.files, "file")} again for the reading rules added since (${(item.sets ?? []).join(", ")}): ${part.paths.join(", ")} (about ${tokensText(part.tokens)} tokens).`);
+    else if (item.total > 1 && !line.includes("--gaps"))
+      io.out(`That chat reads part ${part.part}: ${part.paths.join(", ")} (about ${tokensText(part.tokens)} tokens); the estimate it runs names it.`);
+    else if (line.includes("--part"))
+      io.out(`That chat reads only what is left of part ${part.part}, as the prompt it writes lists.`);
+    const copied = await (deps.clipboard ?? (async () => false))(line);
+    io.out(copied ? "The line is on your clipboard." : "Copy the line above (no clipboard tool here).");
+    io.out("Waiting for the facts it writes. s + Enter skips this part, r + Enter verifies what is there and gives the line again for what's left, q + Enter (or Ctrl+C) stops; atticus map --all carries on.");
+  }
+  async function modelRead(item, where, rt) {
+    io.out("");
+    io.out(item.kind === "rules" ? `===== ${item.repo} (${where}): topping up on the model for the reading rules added since it was read (${(item.sets ?? []).join(", ")}) =====` : `===== ${item.repo} (${where}): ${item.kind === "reread" ? "re-reading what changed" : "reading"} on the model, ${plural(item.batches ?? 0, "prompt")} =====`);
+    for (let attempt = 1; attempt <= RETRIES; attempt++) {
+      if (stopped())
+        return "failed";
+      const before = await mapStateOf(root, item.repo);
+      const resume = !!before && !before.done && sameCommit(before.commit, item.commit);
+      let error;
+      try {
+        await mapCommand(root, item.repo, {
+          commit: item.commit,
+          maxTokens: limit,
+          ...item.kind === "rules" ? { rules: true } : {},
+          ...resume ? { next: true } : before && !before.done ? { force: true } : {}
+        }, io, { runtime: rt, ...deps.git ? { git: deps.git } : {} });
+      } catch (e) {
+        if (e instanceof CapReached) {
+          await save();
+          return "cap";
+        }
+        error = firstLine(e);
+      }
+      const after = await mapStateOf(root, item.repo);
+      const unfinished = !!after && !after.done && sameCommit(after.commit, item.commit);
+      if (!error && !unfinished) {
+        await verifyStep(item);
+        const ps = partState(item, 1);
+        return finishPart(item, item.parts[0] ?? { part: 1, total: 1, paths: [], files: 0, tokens: 0 }, ps);
+      }
+      if (attempt < RETRIES) {
+        const wait = (deps.backoffMs ?? 5e3) * 2 ** (attempt - 1);
+        io.out(`${item.repo}: the model's read stopped (${error ?? "a prompt got no answer"}); trying what is left again in ${Math.round(wait / 1e3)}s (try ${attempt + 1} of ${RETRIES}).`);
+        await clock.sleep(wait);
+      } else {
+        io.out(`${item.repo}: the model's read failed ${RETRIES} times (${error ?? "a prompt got no answer"}); moving on.`);
+      }
+    }
+    partState(item, 1).state = "failed";
+    totals.ends.push({
+      repo: item.repo,
+      end: "failed",
+      command: `atticus map --all --repos ${item.repo}`
+    });
+    await save();
+    return "failed";
+  }
+  function endOf(item, part, end) {
+    return {
+      repo: item.repo,
+      ...item.total > 1 ? { part: part.part, total: item.total } : {},
+      end,
+      command: `atticus map --all --repos ${item.repo}${o.gaps ? " --gaps" : ""} (or /atticus-map ${item.repo}${o.gaps ? " --gaps" : ""} in a new chat)`
+    };
+  }
+  async function summary(interrupted2) {
+    for (const item of items)
+      for (const part of item.kind === "carry" ? [] : item.parts) {
+        const s = st.repos[item.repo]?.parts[String(part.part)];
+        if (s?.state === "done" || totals.ends.some((e) => e.repo === item.repo && (e.part ?? 1) === part.part))
+          continue;
+        if (mode === "model" && totals.ends.some((e) => e.repo === item.repo))
+          continue;
+        totals.ends.push(endOf(item, part, "incomplete"));
+      }
+    const open = (await listQuestions(root, { state: "open" }).catch(() => ({ questions: [] }))).questions.length;
+    const rejected = [...totals.rejected.values()].reduce((n, x) => n + x, 0);
+    io.out("");
+    io.out(`${interrupted2 ? "So far" : "Done"}: ${plural(totals.repos.size, "repo")} read, ${plural(totals.parts, "part")}${mode === "model" ? ` (${plural(totals.spent.prompts, "prompt")})` : ""}; ${plural(rejected, "fact")} rejected; links +${totals.added} -${totals.removed}; ${plural(open, "question")} open.`);
+    const left = totals.ends.filter((e) => e.end !== "done");
+    if (left.length) {
+      io.out("Not finished:");
+      for (const e of left)
+        io.out(`  ${e.repo}${e.part ? ` part ${e.part} of ${e.total}` : ""}: ${e.end}; ${e.command}`);
+    }
+    io.out("Next: atticus questions list --mine (answer what the code couldn't settle), then atticus estate fresh.");
+  }
+}
+export {
+  MAP_ALL_STATE_REL,
+  limitFor,
+  mapAllCommand,
+  modelModeAllowed,
+  planEstate,
+  readMapAllState
+};