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

package/dist/chunk-YF5DZCPN.js

@@ -0,0 +1,1212 @@
+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 {
+  copilotAcpAllowed,
+  copilotAcpByDefault,
+  readWrites
+} from "./chunk-LIJJCBQI.js";
+import {
+  mapCommand,
+  mapStateOf
+} from "./chunk-26Z7OGQW.js";
+import {
+  factsRepos,
+  verifyCommand
+} from "./chunk-LN77DXBM.js";
+import "./chunk-L4CESDPB.js";
+import {
+  plannedTopUp,
+  recordRulesNow,
+  ruleSetsOfFiles
+} from "./chunk-U3NBK4EU.js";
+import "./chunk-455SYIIE.js";
+import {
+  estateFreshness
+} from "./chunk-LWDNKE4X.js";
+import {
+  onboardingQueue
+} from "./chunk-HE3HRDNZ.js";
+import "./chunk-3J5I7ZOU.js";
+import "./chunk-4FOAYLI4.js";
+import "./chunk-GX74YWR7.js";
+import "./chunk-G6IQYM25.js";
+import "./chunk-LPV6T362.js";
+import {
+  rulesLackingAll
+} from "./chunk-GIFMBCTW.js";
+import {
+  loadReadPlan,
+  partUnaccounted,
+  readPlanProgress
+} from "./chunk-MD7KUEJ3.js";
+import {
+  checkoutOf,
+  conventionsAt,
+  excludesOf,
+  headOf
+} from "./chunk-Q46QDDMF.js";
+import "./chunk-TGVVUKTG.js";
+import "./chunk-TQ4TG57V.js";
+import {
+  isMetarepo,
+  notMetarepo
+} from "./chunk-3G4YI4ZU.js";
+import {
+  ASSISTANT_FORMATS,
+  assistantTier,
+  readProbes
+} from "./chunk-3AQ2R5NL.js";
+import "./chunk-VOGCSYOI.js";
+import {
+  estateRepos,
+  productionRepos
+} from "./chunk-4SLBCEPD.js";
+import "./chunk-64AADMTW.js";
+import {
+  dirSource,
+  sameCommit,
+  sessionTokensFor
+} from "./chunk-JYMIB5XY.js";
+import "./chunk-CPK7QSBG.js";
+import "./chunk-YO2PKTXT.js";
+import "./chunk-TWQRPM76.js";
+import "./chunk-VUVGX5L2.js";
+import "./chunk-API5TOUB.js";
+import "./chunk-XOL3GFW2.js";
+import {
+  AcpSetupError,
+  AcpSignInError,
+  currentPromptLimit
+} from "./chunk-QHJJMZLX.js";
+import "./chunk-7AB6OWTV.js";
+import {
+  factsDirOf,
+  factsRelOf,
+  headFromFiles,
+  listQuestions,
+  loadOrgPack,
+  orgPackDirOf,
+  parseFacts,
+  require_dist
+} from "./chunk-PAINMSID.js";
+import {
+  ensureLocalIgnore,
+  writeFileAtomic
+} from "./chunk-ODMBPDDV.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 = 30;
+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 mapReader(root) {
+  const op = await loadOrgPack(orgPackDirOf(root));
+  const tier = assistantTier(op.runtime, { probes: (await readProbes(root)).results });
+  const name = tier.assistant ? ASSISTANT_FORMATS[tier.assistant].name : "no assistant";
+  const paste = tier.tier !== "off" && (tier.assistant === "copilot" || tier.tier !== 1);
+  return { name, loop: paste && isMetarepo(root) };
+}
+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;
+}
+async function gapsTextAt(root, repo) {
+  return readFile(join(factsDirOf(root), `${repo}.gaps.md`), "utf8").catch(() => "");
+}
+var MAX_GAPS_SESSIONS = 40;
+function preparedLine(repo, prompt) {
+  return `Read ${prompt} and do exactly what it says. Atticus has prepared it: run no other atticus command (not assistant-files, not map). When the facts are written, run \`atticus verify ${repo}\` by itself, with no pipe or redirection; if you can't run commands here, just stop when the facts are written: Atticus verifies them.`;
+}
+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, models, force) {
+  const io = captured();
+  const code = await mapCommand(root, repo, { estimate: true, json: true, commit, maxTokens: limit, ...models ? { models } : {} }, 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.read?.files ?? r.files,
+          tokens: r.read?.tokens ?? r.tokens
+        }
+      ],
+      total: 1,
+      tokens: r.read?.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) => force ? !force.done.has(p.part) : 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 },
+    ...o.models ? { models: o.models } : {}
+  });
+  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), given: p.lacking };
+}
+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.force) {
+      todo.push({
+        repo,
+        kind: "read",
+        commit,
+        why: state2 === "not-read" ? "--force: read whole" : "--force: read whole again, the facts on file kept as already kept",
+        ...state2 === "not-read" ? {} : { started: true },
+        force: true
+      });
+      continue;
+    }
+    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 },
+      ...t.force ? { force: 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, {
+        ...o.models ? { models: o.models } : {}
+      });
+      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,
+        given: p2.given,
+        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, o.models, t.force ? { done: forcedDone(t.repo, t.commit) } : void 0);
+    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 forcedDone(repo, commit) {
+    const r = state?.repos[repo];
+    if (!r?.force || !sameCommit(r.commit, commit))
+      return /* @__PURE__ */ new Set();
+    return new Set(Object.entries(r.parts).filter(([, p]) => p.state === "done").map(([n]) => Number(n)));
+  }
+  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" : plan.mode === "copilot-acp" ? "read by GitHub Copilot through its Agent Client Protocol, unattended: one new session per part" : "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 writtenOf(root, repo) {
+  const dir = factsDirOf(root);
+  const facts = await readFile(join(dir, `${repo}.jsonl`), "utf8").catch(() => "");
+  const p = facts.trim() ? parseFacts(facts) : void 0;
+  const ids = (p?.ok ? p.facts : []).map((f) => {
+    const c = f.cite;
+    return `${f.id}|${c?.file ?? ""}:${c?.line ?? ""}`;
+  });
+  const reviewed = (await readFile(join(dir, `${repo}.reviewed.jsonl`), "utf8").catch(() => "")).split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+  return JSON.stringify([[...new Set(ids)].sort(), reviewed]);
+}
+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, unknown, wrote) {
+  const moved = now.facts !== first.facts || now.reviewed !== first.reviewed;
+  if (item.force) {
+    if (!(wrote ?? moved))
+      return false;
+    return item.total <= 1 || !!unknown && !leftOf(part, unknown).length;
+  }
+  if (item.kind === "rules") {
+    const plan = await loadReadPlan(root, item.repo);
+    if (!plan?.topUp)
+      return (await rulesLackingAll(root, item.repo, plan?.rules)).length === 0;
+    return !!plan.topUp.sessions[part.part - 1]?.done;
+  }
+  if (item.total > 1) {
+    const p = await readPlanProgress(root, item.repo);
+    const s = p?.parts.find((x) => x.part === part.part);
+    if (s?.state === "done")
+      return true;
+    return !!s && !!unknown && !partUnaccounted(s, unknown).length;
+  }
+  if (item.kind === "read")
+    return moved || now.reviewed !== void 0 || await factsAt(root, item.repo, item.commit) > 0;
+  return moved;
+}
+var leftOf = (part, unknown) => partUnaccounted({ paths: part.paths, left: [] }, unknown);
+function unaccountedWords(left, shown = 5) {
+  return left.map((u) => {
+    if (!u.files.length)
+      return `${u.glob} (no fact cites a line of it yet)`;
+    const dir = u.glob.replace(/\/?\*\*?$/, "");
+    const rel = u.files.map((f) => u.glob.includes("*") && dir && f.startsWith(`${dir}/`) ? f.slice(dir.length + 1) : f);
+    const more = rel.length > shown ? `, and ${rel.length - shown} more` : "";
+    return `${u.glob} (${plural(u.files.length, "file")}: ${rel.slice(0, shown).join(", ")}${more})`;
+  }).join("; ");
+}
+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 ?? (copilotAcpByDefault(op) ? "copilot-acp" : allowed ? "model" : "copilot");
+  if (mode === "copilot-acp" && !copilotAcpAllowed(op) && !deps.acp) {
+    io.err("runtime.yaml doesn't allow copilot-acp here (schemaVersion 3, copilot-acp in modes.allowed and copilot in assistants.allowed): map the estate through Copilot Chat (atticus map --all without --mode copilot-acp), or ask for it in a pull request (ADR 0171).");
+    return 2;
+  }
+  const stateMode = mode === "model" ? "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 (o.force && (o.gaps || o.stale)) {
+    io.err("--force reads the repos whole again; it doesn't go with --stale or --gaps.");
+    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 !== stateMode))
+    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 emit = (e) => {
+    try {
+      deps.onEvent?.(e);
+    } catch {
+    }
+  };
+  emit({
+    type: "plan",
+    repos: plan.items.map((i) => ({ repo: i.repo, kind: i.kind, parts: i.parts.length }))
+  });
+  const st = state ?? {
+    schemaVersion: 1,
+    updatedAt: "",
+    mode: stateMode,
+    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 && !!r.force === !!item.force)
+      return r;
+    return st.repos[item.repo] = {
+      commit: item.commit,
+      kind: item.kind,
+      parts: {},
+      ...item.force ? { force: true } : {}
+    };
+  };
+  const resumeAs = o.resumeAs ?? `atticus map --all${o.repos ? ` --repos ${o.repos.join(",")}` : ""}${o.stale ? " --stale" : ""}${o.gaps ? " --gaps" : ""}${o.force ? " --force" : ""}${o.models ? ` --models ${o.models}` : ""}${lim.from === "flag" ? ` --max-tokens ${limit}` : ""}${o.idleMinutes ? ` --idle ${o.idleMinutes}` : ""}`;
+  let idleStop = false;
+  const partState = (item, part) => repoState(item).parts[String(part)] ??= { retries: 0 };
+  const verifyStep = async (item) => {
+    const c = captured();
+    try {
+      await verifyCommand(root, item.repo, { commit: item.commit, write: true, json: true }, c);
+    } catch (e) {
+      io.out(`${item.repo}: verify stopped: ${firstLine(e)}. Moving on; ${resumeAs} tries it again.`);
+      return void 0;
+    }
+    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;
+    }
+    emit({
+      type: "verify",
+      repo: item.repo,
+      kept: v.accepted,
+      rejected: v.rejected,
+      coverage: v.coverage.ratio,
+      open: v.questions?.open ?? 0
+    });
+    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 signIn = 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}`;
+    emit({ type: "repo", repo: item.repo, index: n + 1, total: items.length, why: item.why });
+    if (item.kind === "rules" && !item.parts.length) {
+      io.out("");
+      io.out(`===== ${item.repo} (${where}): ${item.why} =====`);
+      await recordRulesNow(root, item.repo, item.commit, item.given ?? []);
+      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;
+    }
+    if (mode === "copilot-acp") {
+      for (const part of item.parts) {
+        if (quit || stopped() || capHit)
+          break;
+        const end = await acpPart(item, part, where);
+        if (end === "quit")
+          quit = true;
+        if (end === "cap")
+          capHit = true;
+      }
+      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) {
+    if (!idleStop) {
+      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, mode === "copilot-acp" ? "session" : "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 signIn ? 1 : 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 named = item.total > 1 ? `part ${part.part} of ${item.total}` : "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) : item.force ? forceLine(item, part) : ps.retries > 0 || progress?.next && progress.next.part !== part.part ? await restLine(item, part) ?? `/atticus-map ${item.repo}${item.total > 1 ? ` --part ${part.part}` : ""}` : `/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 base = item.force ? await writtenOf(root, item.repo) : "";
+    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();
+    const idleMinutes = o.idleMinutes ?? IDLE_MINUTES;
+    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);
+        if (item.force)
+          base = await writtenOf(root, item.repo);
+        first = await snapOf(root, item.repo);
+        since = first;
+        prev = first;
+        lastChange = clock.now();
+        continue;
+      }
+      const now = await snapOf(root, item.repo);
+      if (!sameSnap(now, prev)) {
+        lastChange = clock.now();
+        prev = now;
+      }
+      if (await settled(root, item.repo, item.commit, now, since)) {
+        const wrote = item.force ? await writtenOf(root, item.repo) !== base : void 0;
+        const v = await verifyStep(item);
+        const after = await snapOf(root, item.repo);
+        if (v && !v.rejected && await covered(root, item, part, first, after, v.coverage.unknown, wrote)) {
+          const was = item.kind === "gaps" ? await gapsTextAt(root, item.repo) : void 0;
+          if (item.kind === "gaps" && await gapsLine(item) !== void 0 && await gapsTextAt(root, item.repo) !== was) {
+            io.out(`${item.repo}: that gaps session is verified; more gaps are left, for a NEW chat.`);
+            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();
+            continue;
+          }
+          return finishPart(item, part, ps);
+        }
+        if (v?.rejected)
+          io.out(`Not done yet: ${plural(v.rejected, "fact")} rejected for the reader to fix. Still waiting (s + Enter skips, r + Enter gives the prompt again for what's left).`);
+        else if (v && item.total > 1 && item.kind !== "rules") {
+          const left = await leftNow(item, part, v.coverage.unknown);
+          io.out(left.length ? `Still not covered in ${item.repo} ${named}: ${unaccountedWords(left)}. ${item.force ? `r + Enter gives the line again (${line}); ` : `r + Enter gives a NEW chat only what is left of the part: these files, and any line verify lists as skipped under it (/atticus-map ${item.repo} --part ${part.part} --gaps); `}s + Enter skips the part; q + Enter stops.` : `Not done yet: nothing was written for ${item.repo} ${named} since its line was given. r + Enter gives the line again; s + Enter skips the part; q + Enter stops.`);
+        } else
+          io.out("Not done yet: 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 = after;
+        prev = after;
+        lastRemind = clock.now();
+      }
+      if (clock.now() - lastChange >= idleMinutes * 6e4) {
+        io.out(`Stopped waiting on ${item.repo} ${label}: nothing was written for ${plural(idleMinutes, "minute")} (--idle ${idleMinutes}). Where the estate stands is saved: ${resumeAs} carries on from here (it verifies what was written and gives the line again for what's left).`);
+        ps.state = "incomplete";
+        idleStop = true;
+        await save();
+        return "quit";
+      }
+      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();
+      if (item2.force) {
+        const wrote = await writtenOf(root, item2.repo) !== base;
+        const v = existsSync(join(factsDirOf(root), `${item2.repo}.jsonl`)) ? await verifyStep(item2) : void 0;
+        if (v && !v.rejected && await covered(root, item2, part2, first, await snapOf(root, item2.repo), v.coverage.unknown, wrote))
+          return "done";
+      }
+      const rest = item2.kind === "rules" ? await rulesLine(item2) : item2.kind === "gaps" ? await gapsLine(item2) : item2.force ? forceLine(item2, part2) : 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 leftNow(item, part, unknown) {
+    if (item.force)
+      return leftOf(part, unknown);
+    const s = (await readPlanProgress(root, item.repo))?.parts.find((x) => x.part === part.part);
+    return s ? partUnaccounted(s, unknown) : leftOf(part, unknown);
+  }
+  function forceLine(item, part) {
+    return `/atticus-map ${item.repo}${item.total > 1 ? ` --part ${part.part}` : ""}`;
+  }
+  async function finishPart(item, part, ps) {
+    ps.state = "done";
+    if (item.kind === "gaps" || part.part === item.total)
+      repoState(item).done = true;
+    if (item.force && Object.keys(repoState(item).parts).length >= item.total && Object.values(repoState(item).parts).every((p) => p.state === "done"))
+      await recordRulesNow(root, item.repo, item.commit);
+    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 } : {},
+      ...o.models ? { models: o.models } : {}
+    }, 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 g.prompt ? preparedLine(item.repo, g.prompt) : `/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,
+      ...o.models ? { models: o.models } : {}
+    });
+    if (typeof p === "string" || !p.parts.length)
+      return "done";
+    const c = captured();
+    const code = await mapCommand(root, item.repo, {
+      rules: true,
+      json: true,
+      commit: item.commit,
+      maxTokens: limit,
+      ...o.models ? { models: o.models } : {}
+    }, c, deps.git ? { git: deps.git } : {});
+    const j = code === 0 ? jsonOf(c.lines) : void 0;
+    return j?.prompt ? preparedLine(item.repo, j.prompt) : `/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,
+      ...o.models ? { models: o.models } : {}
+    }, 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;
+    }
+    if (!g.sessions.length)
+      return void 0;
+    return g.prompt ? preparedLine(item.repo, g.prompt) : `/atticus-map ${item.repo} --gaps`;
+  }
+  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.force)
+      io.out(`${item.total > 1 ? `That chat reads part ${part.part} whole again: ${part.paths.join(", ")} (about ${tokensText(part.tokens)} tokens). ` : ""}The facts on file stay, as already kept: the chat names one by its id and doesn't write it again (one whose line changed it rewrites under the same id).`);
+    else 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.");
+  }
+  function overCap() {
+    return o.maxParts !== void 0 && totals.spent.prompts >= o.maxParts || o.budgetTokens !== void 0 && totals.spent.tokens >= o.budgetTokens;
+  }
+  async function acpPart(item, part, where) {
+    const ps = partState(item, part.part);
+    const label = item.total > 1 ? `part ${part.part} of ${item.total}` : "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) : item.force ? forceLine(item, part) : ps.retries > 0 || progress?.next && progress.next.part !== part.part ? await restLine(item, part) ?? `/atticus-map ${item.repo}${item.total > 1 ? ` --part ${part.part}` : ""}` : `/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;
+    const runner = deps.acp ?? await deps.makeAcp?.();
+    if (!runner) {
+      io.err("No Copilot session runner: copilot-acp needs runtime.yaml's copilotAcp.");
+      return "quit";
+    }
+    let more = 0;
+    for (let attempt = 0; attempt < 2; attempt++) {
+      if (stopped())
+        break;
+      if (overCap())
+        return "cap";
+      io.out("");
+      io.out(`===== ${item.repo}, ${item.kind === "gaps" ? "the gaps pass" : item.kind === "rules" ? "the rules top-up" : label} (${where})${attempt ? ", given again in a new session" : ""} =====`);
+      io.out(`In a NEW Copilot session (copilot-acp): ${line}`);
+      emit({
+        type: "session",
+        repo: item.repo,
+        label: item.kind === "gaps" ? "the gaps pass" : item.kind === "rules" ? "the rules top-up" : label,
+        line,
+        attempt
+      });
+      const base = item.force ? await writtenOf(root, item.repo) : "";
+      const first = await snapOf(root, item.repo);
+      totals.spent.prompts++;
+      let cut = false;
+      try {
+        const r = await runner({
+          line,
+          change: `map-${item.repo}`,
+          writeRoots: readWrites(root),
+          ...deps.signal ? { signal: deps.signal } : {},
+          onProgress: io.out
+        });
+        totals.spent.tokens += r.usage ? r.usage.inputTokens + r.usage.outputTokens : part.tokens;
+        io.out(`The session ended (${r.stopped ?? r.stopReason}).`);
+        emit({
+          type: "session.end",
+          repo: item.repo,
+          ended: r.stopped ?? r.stopReason,
+          ...r.usage ? { tokens: r.usage.inputTokens + r.usage.outputTokens } : {}
+        });
+        cut = !!r.stopped;
+      } catch (e) {
+        if (e instanceof AcpSetupError) {
+          io.err(`${e.message} The run stops here; ${resumeAs} carries on once it is put right.`);
+          emit({ type: "session.end", repo: item.repo, ended: "failed", failed: e.message });
+          ps.state = "incomplete";
+          await save();
+          return "quit";
+        }
+        if (e instanceof AcpSignInError) {
+          io.err(e.message);
+          emit({ type: "session.end", repo: item.repo, ended: "failed", failed: e.message });
+          signIn = true;
+          ps.state = "incomplete";
+          await save();
+          return "quit";
+        }
+        totals.spent.tokens += part.tokens;
+        io.out(`${item.repo} ${label}: the Copilot session failed: ${firstLine(e)}`);
+        emit({ type: "session.end", repo: item.repo, ended: "failed", failed: firstLine(e) });
+      }
+      if (stopped())
+        break;
+      const wrote = item.force ? await writtenOf(root, item.repo) !== base : void 0;
+      const v = existsSync(join(factsDirOf(root), `${item.repo}.jsonl`)) ? await verifyStep(item) : void 0;
+      const after = await snapOf(root, item.repo);
+      if (v && !v.rejected && // beta.17: a one-session read stopped by Atticus is done only once its coverage leaves
+      // nothing (what it wrote may be only the start).
+      !(cut && item.total <= 1 && item.kind !== "rules" && (v.coverage.unknown?.length ?? 0) > 0) && await covered(root, item, part, first, after, v.coverage.unknown, wrote)) {
+        const was = item.kind === "gaps" ? await gapsTextAt(root, item.repo) : void 0;
+        const next = item.kind === "gaps" ? await gapsLine(item) : void 0;
+        if (next !== void 0 && more < MAX_GAPS_SESSIONS && await gapsTextAt(root, item.repo) !== was) {
+          more++;
+          line = next;
+          attempt = -1;
+          continue;
+        }
+        return finishPart(item, part, ps);
+      }
+      if (attempt > 0)
+        break;
+      ps.retries++;
+      await save();
+      const rest = item.kind === "rules" ? await rulesLine(item) : item.kind === "gaps" ? await gapsLine(item) : item.force ? forceLine(item, part) : await restLine(item, part);
+      if (rest === "done" || rest === void 0 && item.kind === "gaps")
+        return finishPart(item, part, ps);
+      line = rest ?? `/atticus-map ${item.repo}${item.total > 1 ? ` --part ${part.part}` : ""}`;
+      io.out(`${item.repo} ${label} isn't accounted for yet${v?.rejected ? ` (${plural(v.rejected, "fact")} rejected)` : ""}: one more try in a NEW session with only what is left (${line}).`);
+    }
+    ps.state = "incomplete";
+    await save();
+    if (stopped())
+      return "quit";
+    io.out(`${item.repo} ${label}: still not accounted for after a second session; moving on. atticus map --all carries on from here.`);
+    totals.ends.push(endOf(item, part, "incomplete"));
+    return "incomplete";
+  }
+  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,
+          ...o.models ? { models: o.models } : {},
+          ...item.kind === "rules" ? { rules: true } : {},
+          ...resume && !(item.force && attempt === 1) ? { next: true } : item.force && attempt === 1 || 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" : ""}${item.force ? " --force" : ""} (or /atticus-map ${item.repo}${o.gaps ? " --gaps" : item.force && item.total > 1 ? ` --part ${part.part}` : ""} 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")})` : mode === "copilot-acp" ? ` (${plural(totals.spent.prompts, "session")})` : ""}; ${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,
+  mapReader,
+  modelModeAllowed,
+  planEstate,
+  preparedLine,
+  readMapAllState,
+  unaccountedWords
+};