@maycombhq/atticus 2.0.0-beta.11 → 2.0.0-beta.12.1

package/dist/{chunk-26DBAGOP.js → chunk-PUGPT4Y6.js}

@@ -3,35 +3,35 @@ import { fileURLToPath as __atticusFileURLToPath } from "node:url";
 var require = __atticusCreateRequire(import.meta.url);
 var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
 var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
-import "./chunk-NIYB5K5B.js";
+import "./chunk-VRH6ITQH.js";
 import {
   loadCatalog
-} from "./chunk-BUWSOQLU.js";
+} from "./chunk-ML3HOWPI.js";
 import {
   repoFor
-} from "./chunk-LDIARP6F.js";
+} from "./chunk-7VNEDDCC.js";
 import {
   askHosts
-} from "./chunk-XR5DD5DQ.js";
-import "./chunk-XKJRPVJO.js";
+} from "./chunk-CYDJK34J.js";
+import "./chunk-KJ6IH2D5.js";
 import {
   estateFlow,
   estateStepKey,
   fieldLineage,
   joinEstate
-} from "./chunk-IILZ7J3L.js";
-import "./chunk-TEBBD4XH.js";
-import "./chunk-XPWSNKF3.js";
-import "./chunk-WIMOJMAK.js";
-import "./chunk-5V5BJACL.js";
-import "./chunk-GVFUEGGM.js";
-import "./chunk-YVCOQ5TZ.js";
-import "./chunk-XNRPCI23.js";
-import "./chunk-XZJE6WIT.js";
+} from "./chunk-DBZNQAMN.js";
+import "./chunk-QR65C3DV.js";
+import "./chunk-7VAMO66T.js";
+import "./chunk-HY2VVVFZ.js";
+import "./chunk-PJRMMWU4.js";
+import "./chunk-34NWVIBC.js";
+import "./chunk-TEHH47TG.js";
+import "./chunk-77UOXZVM.js";
+import "./chunk-RA64IK43.js";
 import {
   fsRepo
-} from "./chunk-FMRMTI7W.js";
-import "./chunk-BKFGGJKA.js";
+} from "./chunk-MRLCNXXR.js";
+import "./chunk-CQD26SMZ.js";
 import {
   listQuestions,
   loadOrgPack,
@@ -45,7 +45,7 @@ import {
   specsRelOf,
   templateRef,
   writeEstateJoins
-} from "./chunk-JMOLB347.js";
+} from "./chunk-U25OX22K.js";
 import "./chunk-MMB2OHUY.js";
 import "./chunk-TV45EUGM.js";
 

package/dist/{chunk-PQW7PYUR.js → chunk-PVMGHQWB.js}

@@ -7,11 +7,11 @@ import {
   buildStub,
   generate,
   parseSpec
-} from "./chunk-SKMHS4CL.js";
+} from "./chunk-TA2ZNDYD.js";
 import {
   loadPlanContext,
   parseStory
-} from "./chunk-EV4TEFOD.js";
+} from "./chunk-SR2M7DWL.js";
 import {
   docOf,
   fingerprint,
@@ -20,20 +20,20 @@ import {
   roundsOf,
   sectionLines,
   writeFinding
-} from "./chunk-T6ESD5KM.js";
+} from "./chunk-KPHPVOME.js";
 import {
   changeFolder
-} from "./chunk-3LU6YCSQ.js";
+} from "./chunk-G5SKNMPC.js";
 import {
   baseClonePath,
   changeWorktreesDir,
   readChangeRepos,
   worktreePath
-} from "./chunk-XZJE6WIT.js";
+} from "./chunk-RA64IK43.js";
 import {
   buildContextPack,
   toRunSummary
-} from "./chunk-BKFGGJKA.js";
+} from "./chunk-CQD26SMZ.js";
 import {
   AgentDefinition,
   ChecklistPack,
@@ -45,7 +45,7 @@ import {
   require_dist,
   taskBranch,
   toCanonicalYaml
-} from "./chunk-JMOLB347.js";
+} from "./chunk-U25OX22K.js";
 import {
   writeFileAtomic
 } from "./chunk-MMB2OHUY.js";

package/dist/{chunk-MSL3CLHX.js → chunk-Q4AWUD6C.js}

@@ -5,10 +5,10 @@ var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
 var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
 import {
   storeChangeRows
-} from "./chunk-7LCQ7JAM.js";
+} from "./chunk-NAKVQU6F.js";
 import {
   metarepoOpenSpec
-} from "./chunk-EV4TEFOD.js";
+} from "./chunk-SR2M7DWL.js";
 import {
   table
 } from "./chunk-VOGCSYOI.js";
@@ -16,7 +16,7 @@ import {
   gateStatus,
   ownerWaitsLine,
   reviewedGates
-} from "./chunk-T6ESD5KM.js";
+} from "./chunk-KPHPVOME.js";
 import {
   ChangeError,
   archiveChange,
@@ -32,23 +32,23 @@ import {
   newChange,
   returnToPo,
   syncHandoff
-} from "./chunk-3LU6YCSQ.js";
+} from "./chunk-G5SKNMPC.js";
 import {
   createAdapters,
   fileStepStore
-} from "./chunk-CAN3EBE5.js";
+} from "./chunk-DW4BM73R.js";
 import {
   baseClonePath,
   createWorkspace,
   isInPlace,
   loadRepos
-} from "./chunk-XZJE6WIT.js";
+} from "./chunk-RA64IK43.js";
 import {
   changesRelOf,
   handoffBranch,
   loadOrgPack,
   orgPackDirOf
-} from "./chunk-JMOLB347.js";
+} from "./chunk-U25OX22K.js";
 
 // packages/cli/dist/change-commands.js
 import { existsSync } from "node:fs";
@@ -116,7 +116,7 @@ async function changeNew(root, o, io, deps = {}) {
   }
   let like;
   if (o.like) {
-    const { findPastChange } = await import("./chunk-RIEFYHXI.js");
+    const { findPastChange } = await import("./chunk-JS3DJH3Q.js");
     like = await findPastChange(root, o.like);
     if (!like) {
       io.err(`There is no archived change ${o.like}: atticus change similar "<what it is about>" lists them.`);
@@ -125,7 +125,7 @@ async function changeNew(root, o, io, deps = {}) {
   }
   let impact;
   if (o.impact) {
-    const { loadVendorImpact } = await import("./chunk-RB2VSED2.js");
+    const { loadVendorImpact } = await import("./chunk-GIPQHVJF.js");
     const got = await loadVendorImpact(root, o.impact, io);
     if ("error" in got) {
       io.err(got.error);
@@ -155,16 +155,16 @@ async function changeNew(root, o, io, deps = {}) {
     });
     io.out(`Created ${c.id} (${c.type}, from the ${c.template} template). It is in ${c.state}.`);
     if (impact) {
-      const { attachToChange } = await import("./chunk-QWHTTA2X.js");
-      const { changeFolder } = await import("./chunk-4ONORLK5.js");
-      const { impactDocument, IMPACT_WORDS } = await import("./chunk-RB2VSED2.js");
+      const { attachToChange } = await import("./chunk-3M7QBKKG.js");
+      const { changeFolder } = await import("./chunk-O62VA6MH.js");
+      const { impactDocument, IMPACT_WORDS } = await import("./chunk-GIPQHVJF.js");
       const doc = impactDocument(impact);
       const attached = await attachToChange(changeFolder(root, c.id), [{ name: doc.name, bytes: new TextEncoder().encode(doc.text) }], { by: o.by, at: deps.now ?? (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z") });
       const path = attached.added[0]?.path ?? `inputs/${doc.name}`;
       io.out(IMPACT_WORDS.started(impact.name, impact.impact.newer.version ?? impact.impact.newer.id, impact.impact, path));
     }
     if (like) {
-      const { attachPastChange } = await import("./chunk-RIEFYHXI.js");
+      const { attachPastChange } = await import("./chunk-JS3DJH3Q.js");
       const name = await attachPastChange(root, c.id, like, o.by, deps.now ? new Date(deps.now) : /* @__PURE__ */ new Date());
       io.out(`It starts from ${like}: attached as inputs/${name}, which its steps read as an example.`);
     }
@@ -235,7 +235,7 @@ async function usedUpGates(root, id) {
   for (const g of await reviewedGates(root, id).catch(() => [])) {
     const s = await gateStatus(root, id, g).catch(() => void 0);
     if (s && (s.humanDecides || s.checkRound || ownerWaitsLine(s, id)))
-      out.push((await import("./chunk-7KXYMC2P.js")).statusLine(s, id));
+      out.push((await import("./chunk-6R2OM6Y3.js")).statusLine(s, id));
   }
   return out;
 }
@@ -263,7 +263,7 @@ async function changeHandoff(root, id, o, io, deps = {}) {
       ...o.base ? { base: o.base } : {},
       ...deps.publisher ? { publisher: deps.publisher } : {},
       // WP7.4: the PR reviews itself: the change as a picture, its estimate, its open findings.
-      review: await (await import("./chunk-SUQZGPVG.js")).handoffReview(root, id),
+      review: await (await import("./chunk-XB64FJLU.js")).handoffReview(root, id),
       ...metarepoOpenSpec(root) ? { openspec: metarepoOpenSpec(root) } : {}
     });
     io.out(`Hand-off PR #${h.pr.number} (${h.branch}) is open: ${h.pr.url}`);
@@ -437,7 +437,7 @@ async function rescanAfterArchive(root, id, io, deps) {
       io.out(`Couldn't update the base clone of ${s.id} (${s.reason ?? s.action}); scanning what is there.`);
   }
   io.out(`Rescanning for ${id}'s repos: ${here.join(", ")}.`);
-  const code = await (await import("./chunk-4Y4FY34K.js")).scanCommand(root, {}, io);
+  const code = await (await import("./chunk-S3QCJWCF.js")).scanCommand(root, {}, io);
   if (away.length)
     io.out(`Not in a base clone here: ${away.join(", ")}. To add them, run: ${command(away)}`);
   return code;

package/dist/{chunk-JQX6BSE4.js → chunk-QC24Z5JU.js}

@@ -7,19 +7,19 @@ import {
   estateFacts,
   measureLinks,
   parseLinkReference
-} from "./chunk-IILZ7J3L.js";
-import "./chunk-TEBBD4XH.js";
-import "./chunk-XPWSNKF3.js";
-import "./chunk-WIMOJMAK.js";
-import "./chunk-5V5BJACL.js";
-import "./chunk-GVFUEGGM.js";
-import "./chunk-XZJE6WIT.js";
-import "./chunk-FMRMTI7W.js";
-import "./chunk-BKFGGJKA.js";
+} from "./chunk-DBZNQAMN.js";
+import "./chunk-QR65C3DV.js";
+import "./chunk-7VAMO66T.js";
+import "./chunk-HY2VVVFZ.js";
+import "./chunk-PJRMMWU4.js";
+import "./chunk-34NWVIBC.js";
+import "./chunk-RA64IK43.js";
+import "./chunk-MRLCNXXR.js";
+import "./chunk-CQD26SMZ.js";
 import {
   loadOrgPack,
   orgPackDirOf
-} from "./chunk-JMOLB347.js";
+} from "./chunk-U25OX22K.js";
 import "./chunk-MMB2OHUY.js";
 import "./chunk-TV45EUGM.js";
 

package/dist/{chunk-WCLAOKCH.js → chunk-QKSWQBWD.js}

@@ -9,14 +9,14 @@ import {
 } from "./chunk-3G4YI4ZU.js";
 import {
   upgradeCheck
-} from "./chunk-LUPW4WLK.js";
+} from "./chunk-3W5R5J65.js";
 import {
   ASSISTANT_FORMATS,
   assistantTier,
   generateAssistantFiles,
   readProbes,
   tierLine
-} from "./chunk-6RGIM2ZH.js";
+} from "./chunk-J22RSFKY.js";
 import {
   BETA_FEATURES,
   OPENSPEC_PINNED,
@@ -26,22 +26,22 @@ import {
   openspecFeatures,
   openspecHasStores,
   readStoreMarker
-} from "./chunk-L7I5PKGD.js";
+} from "./chunk-JQG4VO47.js";
 import {
   versionAtLeast
-} from "./chunk-7RUMD56V.js";
+} from "./chunk-M4D3VKAS.js";
 import {
   baseClonePath,
   createGit,
   isInPlace,
   loadRepos,
   remoteDefaultBranch
-} from "./chunk-XZJE6WIT.js";
+} from "./chunk-RA64IK43.js";
 import {
   modelEnvOf,
   modelSourceWords,
   modelsByClass
-} from "./chunk-BKFGGJKA.js";
+} from "./chunk-CQD26SMZ.js";
 import {
   DEFAULT_PORT,
   STEP_CLASSES,
@@ -52,7 +52,7 @@ import {
   require_dist,
   retrievalOf,
   stepModelsOf
-} from "./chunk-JMOLB347.js";
+} from "./chunk-U25OX22K.js";
 import {
   readLock
 } from "./chunk-MMB2OHUY.js";
@@ -459,7 +459,7 @@ async function doctorChecks(root, deps = {}) {
     });
   }
   const lexical = "the context engine searches by words and names only";
-  const embed = await (deps.embed ?? (() => import("./chunk-EZSZFI54.js")))().catch((e) => e);
+  const embed = await (deps.embed ?? (() => import("./chunk-OMH3I5BH.js")))().catch((e) => e);
   if (embed instanceof Error) {
     const model2 = retrievalOf(rt).embeddings.model;
     const off = process.env.ATTICUS_EMBEDDINGS === "off" || model2 === "off";

package/dist/{chunk-GMJXC5AL.js → chunk-QL4VNY4U.js}

@@ -8,7 +8,7 @@ import {
   RuntimeError,
   estimateTokens,
   registerModelProvider
-} from "./chunk-BKFGGJKA.js";
+} from "./chunk-CQD26SMZ.js";
 import {
   redactText
 } from "./chunk-MMB2OHUY.js";

package/dist/chunk-QOF7U6BI.js

@@ -0,0 +1,363 @@
+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 {
+  modelsData,
+  reachPlanOf
+} from "./chunk-XDTD55UU.js";
+import {
+  loadReadPlan,
+  modelsModeOf,
+  recordNotReached,
+  saveReadPlan
+} from "./chunk-6AYUBYK6.js";
+import {
+  FACT_RULES_HASH,
+  MODELS_RULE,
+  RULE_SETS,
+  factRulesFor,
+  factsReference,
+  ruleSetKinds,
+  rulesLacking,
+  rulesNow,
+  topUpWords
+} from "./chunk-J22RSFKY.js";
+import {
+  fileKinds,
+  kindsOf,
+  lineRangeOf,
+  planBatches,
+  readingRank,
+  sameCommit
+} from "./chunk-7VAMO66T.js";
+import {
+  DATA_RULE,
+  neutralise,
+  wrapData
+} from "./chunk-CQD26SMZ.js";
+import {
+  citedFiles,
+  factsDirOf,
+  factsRelOf,
+  parseFacts
+} from "./chunk-U25OX22K.js";
+import {
+  writeFileAtomic
+} from "./chunk-MMB2OHUY.js";
+
+// packages/cli/dist/map-rules.js
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+var has = (a, b) => a.some((x) => b.includes(x));
+function applies(set, f) {
+  switch (set) {
+    case "field-types":
+    case "message-types":
+      return f.code ? f.rank === 2 || f.rank === 3 || f.cited.has("entry") || f.cited.has("call") || f.cited.has("field") : f.rank === 3 && f.kinds.includes("protocols");
+    case "mappings":
+      return f.kinds.includes("gateway");
+    case "terms":
+      return !f.code && has(f.kinds, ["config", "deploy", "gateway"]);
+    case "call-auth":
+      return f.code ? f.rank === 1 || f.rank === 3 || f.cited.has("call") : has(f.kinds, ["config", "gateway"]);
+  }
+}
+function topUpFiles(o) {
+  const whole = planBatches(o.source, {
+    room: Number.MAX_SAFE_INTEGER,
+    exclude: o.exclude,
+    ...o.conventions ? { conventions: o.conventions } : {},
+    ...o.reach?.reach.rooted && o.reach.reach.models ? { reach: { first: o.reach.first, leaveOut: o.reach.leaveOut } } : {}
+  });
+  const cites = /* @__PURE__ */ new Map();
+  for (const f of o.facts)
+    for (const p of citedFiles(f)) {
+      const k = cites.get(p) ?? /* @__PURE__ */ new Set();
+      k.add(f.kind);
+      cites.set(p, k);
+    }
+  const out = [];
+  for (const slice of whole.batches.flat()) {
+    const path = slice.path;
+    const rank = readingRank(path);
+    if (rank === 5)
+      continue;
+    const kinds = fileKinds(path);
+    const of = {
+      kinds,
+      rank,
+      code: kinds.includes("backend") || kinds.includes("frontend"),
+      cited: cites.get(path) ?? /* @__PURE__ */ new Set()
+    };
+    const sets = o.sets.filter((s) => has(kinds, ruleSetKinds(s)) && applies(s, of));
+    if (sets.length)
+      out.push({ path, tokens: slice.tokens, lines: slice.of, sets });
+  }
+  return out;
+}
+function ruleSetsOfFiles(files) {
+  const all = new Set(files.flatMap((f) => f.sets));
+  return RULE_SETS.filter((x) => all.has(x));
+}
+function topUpSessions(files, room) {
+  const reads = [];
+  for (const f of files) {
+    if (f.tokens <= room || f.lines <= 1) {
+      reads.push({ path: f.path, file: f.path, tokens: f.tokens, sets: f.sets });
+      continue;
+    }
+    const per = Math.max(1, Math.floor(f.lines * room / f.tokens));
+    for (let from = 1; from <= f.lines; from += per) {
+      const to = Math.min(f.lines, from + per - 1);
+      reads.push({
+        path: `${f.path}#L${from}-L${to}`,
+        file: f.path,
+        tokens: Math.ceil(f.tokens * (to - from + 1) / f.lines),
+        sets: f.sets
+      });
+    }
+  }
+  const sessions = [];
+  for (const r of reads) {
+    const last = sessions.at(-1);
+    if (last && last.tokens + r.tokens <= room) {
+      last.reads.push(r);
+      last.tokens += r.tokens;
+    } else
+      sessions.push({ reads: [r], tokens: r.tokens });
+  }
+  return sessions.map((s) => ({
+    paths: s.reads.map((r) => r.path),
+    sets: ruleSetsOfFiles(s.reads),
+    files: new Set(s.reads.map((r) => r.file)).size,
+    tokens: s.tokens
+  }));
+}
+var stamp = () => (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
+async function factsOf(root, repo) {
+  const text = await readFile(join(factsDirOf(root), `${repo}.jsonl`), "utf8").catch(() => "");
+  if (!text.trim())
+    return `${repo} isn't read yet: atticus map ${repo} reads it, under every rule.`;
+  const p = parseFacts(text);
+  return p.ok ? p.facts : `${factsRelOf(root)}/${repo}.jsonl does not read as facts (${p.issues[0]?.message ?? "?"}).`;
+}
+async function topUpOf(root, repo, o) {
+  const plan = await loadReadPlan(root, repo);
+  const lacking = rulesLacking(plan?.rules);
+  if (!lacking.length)
+    return { lacking, files: [], ...plan ? { plan } : {} };
+  const facts = o.facts?.length ? [...o.facts] : await factsOf(root, repo);
+  if (typeof facts === "string")
+    return { error: facts };
+  if (!facts.length)
+    return { error: `${repo} isn't read yet: atticus map ${repo} reads it.` };
+  if (!facts.every((f) => sameCommit(f.commit, o.commit)))
+    return {
+      error: `${repo}'s clone moved past its facts' commit: read what changed first (atticus map ${repo}), then top it up.`
+    };
+  const all = planBatches(o.source, {
+    room: Number.MAX_SAFE_INTEGER,
+    exclude: o.exclude,
+    ...o.conventions ? { conventions: o.conventions } : {}
+  });
+  const reach = reachPlanOf({
+    paths: all.batches.flat().map((x) => x.path),
+    source: o.source,
+    facts,
+    mode: await modelsModeOf(root, repo, o.models)
+  });
+  const files = topUpFiles({
+    facts,
+    source: o.source,
+    exclude: o.exclude,
+    sets: lacking,
+    ...o.conventions ? { conventions: o.conventions } : {},
+    reach
+  });
+  return { lacking, files, reach, ...plan ? { plan } : {} };
+}
+var planOr = (plan, repo, commit, session) => plan ?? { schemaVersion: 2, repo, commit, session, plannedAt: stamp(), parts: [] };
+async function recordRulesNow(root, repo, commit) {
+  const plan = await loadReadPlan(root, repo);
+  const { topUp: _t, ...rest } = planOr(plan, repo, commit, 15e4);
+  if (plan?.rules?.hash === FACT_RULES_HASH && !plan.topUp)
+    return;
+  await saveReadPlan(root, { ...rest, rules: rulesNow() });
+}
+async function recordTopUpVerified(root, repo, o) {
+  const plan = await loadReadPlan(root, repo);
+  const t = plan?.topUp;
+  if (!plan || !t || !o.commit || !sameCommit(t.commit, o.commit))
+    return;
+  const given = t.sessions.filter((s) => s.given && !s.done);
+  if (!given.length)
+    return;
+  const at = o.now ?? stamp();
+  const sessions = t.sessions.map((s) => s.given && !s.done ? { ...s, done: { at, commit: o.commit } } : s);
+  if (sessions.every((s) => s.done)) {
+    const { topUp: _t, ...rest } = plan;
+    const sets = [.../* @__PURE__ */ new Set([...plan.rules?.sets ?? [], ...t.sets])];
+    await saveReadPlan(root, {
+      ...rest,
+      rules: t.hash === FACT_RULES_HASH ? rulesNow() : { hash: t.hash, sets }
+    });
+    return;
+  }
+  await saveReadPlan(root, { ...plan, topUp: { ...t, sessions } });
+}
+var rulesRelOf = (root, repo) => `${factsRelOf(root)}/${repo}.rules.md`;
+var sameSets = (a, b) => a.length === b.length && a.every((x) => b.includes(x));
+async function plannedTopUp(root, repo, o) {
+  const t = await topUpOf(root, repo, o);
+  if ("error" in t)
+    return t;
+  if (!t.lacking.length)
+    return { lacking: [], facts: [] };
+  const facts = await factsOf(root, repo);
+  if (typeof facts === "string")
+    return { error: facts };
+  if (!o.dryRun && t.reach)
+    await recordNotReached(root, repo, {
+      commit: o.commit,
+      session: o.session,
+      models: t.reach.mode,
+      ...t.reach.notReached ? { notReached: t.reach.notReached } : {}
+    });
+  const reach = t.reach ? { reach: t.reach } : {};
+  const on = (await loadReadPlan(root, repo))?.topUp;
+  if (on && sameCommit(on.commit, o.commit) && on.hash === FACT_RULES_HASH && sameSets(on.sets, t.lacking))
+    return { lacking: t.lacking, topUp: on, facts, ...reach };
+  const topUp = {
+    commit: o.commit,
+    hash: FACT_RULES_HASH,
+    sets: t.lacking,
+    session: o.session,
+    plannedAt: stamp(),
+    sessions: topUpSessions(t.files, o.session)
+  };
+  if (!o.dryRun && topUp.sessions.length)
+    await saveReadPlan(root, {
+      ...planOr(await loadReadPlan(root, repo), repo, o.commit, o.session),
+      topUp
+    });
+  return { lacking: t.lacking, topUp, facts, ...reach };
+}
+async function mapRules(root, repo, o, io) {
+  const p = await plannedTopUp(root, repo, o);
+  if ("error" in p) {
+    io.err(p.error);
+    return 2;
+  }
+  if (!p.lacking.length || !p.topUp) {
+    if (o.json)
+      io.out(JSON.stringify({ repo, commit: o.commit, sets: [], sessions: 0 }, null, 2));
+    else
+      io.out(`${repo} was read under the reading rules there are now: nothing to top up.`);
+    return 0;
+  }
+  const t = p.topUp;
+  if (!t.sessions.length) {
+    await recordRulesNow(root, repo, o.commit);
+    if (o.json)
+      io.out(JSON.stringify({ repo, commit: o.commit, sets: t.sets, sessions: 0 }, null, 2));
+    else
+      io.out(`No file of ${repo} is one the reading rules added since it was read apply to (${t.sets.join(", ")}): its read is recorded as under the rules there are now.`);
+    return 0;
+  }
+  const n = t.sessions.findIndex((s) => !s.done);
+  const next = t.sessions[n];
+  const sessions = t.sessions.map((s, i) => i === n ? { ...s, given: stamp() } : s);
+  const plan = await loadReadPlan(root, repo);
+  await saveReadPlan(root, { ...plan, topUp: { ...t, sessions } });
+  const rel = rulesRelOf(root, repo);
+  await writeFileAtomic(join(factsDirOf(root), `${repo}.rules.md`), rulesPrompt(repo, o.commit, {
+    rel: factsRelOf(root),
+    session: next,
+    n: n + 1,
+    of: t.sessions.length,
+    facts: p.facts,
+    notes: o.notes,
+    ...p.reach ? { reach: p.reach } : {}
+  }));
+  if (o.json) {
+    io.out(JSON.stringify({
+      repo,
+      commit: o.commit,
+      sets: t.sets,
+      session: n + 1,
+      sessions: t.sessions.length,
+      paths: next.paths,
+      tokens: next.tokens,
+      prompt: rel
+    }, null, 2));
+    return 0;
+  }
+  const files = new Set(t.sessions.flatMap((s) => s.paths.map((x) => lineRangeOf(x)?.file ?? x)));
+  const tokens = t.sessions.reduce((x, s) => x + s.tokens, 0);
+  io.out(`Top-up of ${repo} for the reading rules added since it was read (${t.sets.join(", ")}): ${files.size} ${files.size === 1 ? "file" : "files"}, about ${tokens.toLocaleString("en-US")} tokens, in ${t.sessions.length} ${t.sessions.length === 1 ? "session" : "sessions"} of ${o.session.toLocaleString("en-US")} at most.`);
+  io.out(`Wrote ${rel}: session ${n + 1} of ${t.sessions.length}, ${next.paths.length} ${next.paths.length === 1 ? "read" : "reads"} (${next.sets.join(", ")}), about ${next.tokens.toLocaleString("en-US")} tokens.`);
+  io.out(`Start a new chat, so the session holds only these files, and run /atticus-map ${repo} --rules there (or paste ${rel}). When atticus verify ${repo} passes after it, the session is done${t.sessions.length > n + 1 ? `; the next is for another new chat` : ` and the read records the rules there are now`}.`);
+  return 0;
+}
+var factLine = (f) => `- ${f.id} (${f.kind}, ${f.cite.file}:${f.cite.line})`;
+function rulesPrompt(repo, commit, c) {
+  const s = c.session;
+  const sets = s.sets;
+  const files = s.paths.map((x) => lineRangeOf(x)?.file ?? x);
+  const list = s.paths.map((x) => `- \`${x}\``).join("\n");
+  const kept = c.facts.filter((f) => citedFiles(f).some((p) => files.includes(p)));
+  const block = (id, kind, origin, text) => wrapData({ id, kind, origin }, neutralise(text, void 0, { mark: true }).text);
+  return [
+    `# Top-up of ${repo} at ${commit}`,
+    "",
+    `Session ${c.n} of ${c.of}, about ${s.tokens.toLocaleString("en-US")} tokens of source. ${topUpWords(sets)} Open each path below and nothing else: a path ending \`#L<from>-L<to>\` by those lines only, never the whole file.`,
+    "",
+    `- Write each fact to \`${c.rel}/${repo}.jsonl\`, appended, with \`commit\` ${commit}. A kept fact you add to is written again whole, under its id.`,
+    `- Then run \`atticus verify ${repo}\` and fix what it rejects until it exits 0: that records this session done${c.of > c.n ? `. The next session is for a new chat: \`/atticus-map ${repo} --rules\` there` : ", and the read as under the rules there are now"}.`,
+    "",
+    "## The rules",
+    "",
+    "Each fact has this shape:",
+    "",
+    factsReference(),
+    "",
+    factRulesFor(kindsOf(files), void 0, sets),
+    "",
+    "## Read",
+    "",
+    `The paths to open are in the data block below. ${DATA_RULE}`,
+    "",
+    block(`${repo}.rules`, "rules", `${c.rel}/${repo}.read-plan.yaml`, list),
+    "",
+    "## Facts already kept (by id; don't write them again)",
+    "",
+    kept.length ? block(`${repo}.kept`, "facts", `${c.rel}/${repo}.jsonl`, kept.map(factLine).join("\n")) : "None cite these files.",
+    ...c.notes ? [
+      "",
+      "## The organisation's notes for this repo",
+      "",
+      block(`${repo}.notes`, "notes", "org-pack", c.notes)
+    ] : [],
+    "",
+    ...modelsPart(repo, c.reach, new Set(files))
+  ].join("\n");
+}
+function modelsPart(repo, r, files) {
+  const data = r ? modelsData(repo, r, { only: files }) : void 0;
+  return data ? ["## Model classes", "", MODELS_RULE, "", data, ""] : [];
+}
+
+export {
+  topUpFiles,
+  ruleSetsOfFiles,
+  topUpSessions,
+  topUpOf,
+  recordRulesNow,
+  recordTopUpVerified,
+  rulesRelOf,
+  plannedTopUp,
+  mapRules,
+  rulesPrompt
+};