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

package/dist/{chunk-XNRPCI23.js → chunk-77UOXZVM.js}

@@ -6,7 +6,7 @@ var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
 import {
   dotInt8,
   textSha
-} from "./chunk-BKFGGJKA.js";
+} from "./chunk-CQD26SMZ.js";
 import {
   Question,
   RECORD_KINDS,
@@ -28,7 +28,7 @@ import {
   splitForms,
   stateDirOf,
   toCanonicalYaml
-} from "./chunk-JMOLB347.js";
+} from "./chunk-U25OX22K.js";
 import {
   __toESM
 } from "./chunk-TV45EUGM.js";
@@ -1004,8 +1004,8 @@ var DOCUMENT_EXTENSIONS = /\.(docx|pptx|xlsx|pdf|md|markdown|html?|txt)$/i;
 async function documentNodes(path, bytes) {
   const out = { nodes: [], names: [], links: [] };
   const [{ readDocument }, { screenFile }] = await Promise.all([
-    import("./chunk-7VFVQX5K.js"),
-    import("./chunk-QWHTTA2X.js")
+    import("./chunk-CIIRPLI6.js"),
+    import("./chunk-3M7QBKKG.js")
   ]);
   const screen = screenFile(path, bytes);
   if (screen.problem)
@@ -2284,7 +2284,7 @@ function openDb(file) {
 // packages/index/dist/catalog-index.js
 var vectorsFileOf = (file) => join3(dirname2(file), "vectors.sqlite");
 var notInstalled = (e, pkg) => e.code === "ERR_MODULE_NOT_FOUND" && String(e.message).includes(pkg);
-async function embedderOf(root, setting, load = () => import("./chunk-EZSZFI54.js")) {
+async function embedderOf(root, setting, load = () => import("./chunk-OMH3I5BH.js")) {
   if (setting === "off")
     return { why: "turned off for this command" };
   if (setting && setting !== "auto")

package/dist/{chunk-LS3WR2RF.js → chunk-7C7PTJM2.js}

@@ -3,21 +3,20 @@ 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,
+  modelsLine,
+  reachHeadOf,
+  reachPlanOf,
+  readPathsOf
+} from "./chunk-XDTD55UU.js";
 import {
   notesAt
-} from "./chunk-52WCHTVZ.js";
+} from "./chunk-CGF4LKXR.js";
 import {
   houseUntaughtLines,
   houseUntaughtOf
-} from "./chunk-B3QOYE74.js";
-import {
-  loadReadPlan,
-  partOfWords,
-  readPlanProgress,
-  readPlanRelOf,
-  saveReadPlan,
-  writeReadPlan
-} from "./chunk-LVBPY2M6.js";
+} from "./chunk-PAQDPB6T.js";
 import {
   carryOf,
   checkoutOf,
@@ -25,22 +24,32 @@ import {
   estateComponentsOf,
   excludesOf,
   headOf,
+  loadReadPlan,
+  modelsModeOf,
+  partOfWords,
   raiseReadQuestions,
   readCorrections,
+  readPlanProgress,
+  readPlanRelOf,
   readReviewed,
+  recordNotReached,
   reviewedProblemsOf,
+  saveReadPlan,
   slipNoteLines,
+  writeReadPlan,
   writeVerifyFiles
-} from "./chunk-ASKDCMW5.js";
+} from "./chunk-6AYUBYK6.js";
 import {
   ABOUT_RULE,
+  MODELS_RULE,
   assistantTier,
   mapBatchInstructions,
   readProbes,
+  rulesNow,
   taughtFrameworksText,
   tierSource,
   tierWords
-} from "./chunk-6RGIM2ZH.js";
+} from "./chunk-J22RSFKY.js";
 import {
   FILE_KINDS,
   SHOWN_PROPOSALS,
@@ -62,10 +71,10 @@ import {
   sliceText,
   staleMessage,
   verifyFacts
-} from "./chunk-XPWSNKF3.js";
+} from "./chunk-7VAMO66T.js";
 import {
   loadRepos
-} from "./chunk-XZJE6WIT.js";
+} from "./chunk-RA64IK43.js";
 import {
   DATA_RULE,
   HandoffRuntime,
@@ -75,7 +84,7 @@ import {
   estimateTokens,
   promptBudget,
   wrapData
-} from "./chunk-BKFGGJKA.js";
+} from "./chunk-CQD26SMZ.js";
 import {
   AgentDefinition,
   Fact,
@@ -95,7 +104,7 @@ import {
   runsDirOf,
   saysNotProduct,
   stackHelpersOff
-} from "./chunk-JMOLB347.js";
+} from "./chunk-U25OX22K.js";
 import {
   writeFileAtomic
 } from "./chunk-MMB2OHUY.js";
@@ -397,6 +406,12 @@ async function packFor(root, s, batch, source, op, now, notes) {
   const onFile = (await listQuestions(root, { repo: s.repo })).questions.filter((q) => q.state !== "retired");
   const rules = await rulesCovering(root, s.repo, op);
   const slices = fix ? [] : s.batches[batch];
+  const inBatch = new Set(slices.map((x) => x.path));
+  const reachedHere = (s.reached ?? []).filter((r) => inBatch.has(r.path));
+  const models = reachedHere.length ? [
+    "Model classes in this batch the entry points and calls reach (read these, and write their fields):",
+    ...reachedHere.map((r) => `- ${r.path} (${r.types.join(", ")}), from ${r.from}`)
+  ].join("\n") : void 0;
   const rejected = s.rejected.map((r) => rejectedText(r, source));
   const own = kindsOf(slices.map((x) => x.path));
   const theirs = kindsOf(s.rejected.flatMap((r) => citedFiles(r.fact)));
@@ -419,15 +434,29 @@ async function packFor(root, s, batch, source, op, now, notes) {
         // build files are read first, so from the second batch on this is what the code says.
         frameworks: await frameworksFor(root, s.repo, facts),
         // Nothing says what this repo is: ask for one line, cited, for a person to confirm.
-        ...about ? {} : { askAbout: true },
+        ...about || s.sets ? {} : { askAbout: true },
+        // ADR 0167: a top-up carries only the rule sets the read lacked.
+        ...s.sets ? { sets: s.sets } : {},
         // A-taught: how to read the wrapper calls and annotations of the frameworks it is built on.
         ...taughtOption(taughtIn(source, op)),
         // ADR 0163: what the organisation's terms mean here and what must hold, as data.
-        ...notes ? { notes } : {}
+        ...notes ? { notes } : {},
+        // ADR 0169: the model classes of this batch the read reaches, listed beside it.
+        ...models ? { models: true } : {}
       }),
       classification: "public",
       trusted: true
     },
+    ...models ? [
+      {
+        id: "1-models",
+        kind: "document",
+        origin: "atticus/reachable",
+        text: models,
+        classification: "internal",
+        priority: 9
+      }
+    ] : [],
     ...s.reread ? [
       {
         id: "0-reread",
@@ -551,7 +580,7 @@ async function mapCommand(root, repo, o, io, deps = {}) {
   const repoNotes = await notesAt(root, repo, dir, op);
   const notesPrompt = notesText(repoNotes.notes, repoNotes.type);
   if (o.gaps) {
-    const { mapGaps } = await import("./chunk-S7ZWCMDO.js");
+    const { mapGaps } = await import("./chunk-PKCYRG6G.js");
     const tier = await tierHere(root, op);
     let part;
     if (o.part !== void 0) {
@@ -570,7 +599,24 @@ async function mapCommand(root, repo, o, io, deps = {}) {
       source,
       session: sessionTokensFor(limitOf(o, op, tier).limit),
       ...o.json ? { json: true } : {},
-      ...part ? { part } : {}
+      ...part ? { part } : {},
+      ...o.models ? { models: o.models } : {},
+      exclude,
+      conventions
+    }, io);
+  }
+  if (o.rules && !deps.runtime) {
+    const { mapRules } = await import("./chunk-TJP2KLZI.js");
+    const tier = await tierHere(root, op);
+    return mapRules(root, repo, {
+      commit,
+      source,
+      exclude,
+      conventions,
+      session: sessionTokensFor(limitOf(o, op, tier).limit),
+      notes: notesPrompt,
+      ...o.json ? { json: true } : {},
+      ...o.models ? { models: o.models } : {}
     }, io);
   }
   if (o.estimate)
@@ -645,44 +691,131 @@ async function mapCommand(root, repo, o, io, deps = {}) {
     if (room < MIN_ROOM)
       return tooSmall(0);
     const frameworks = await frameworksFor(root, repo, existing);
-    const re = await rereadOf(dir, existing, commit, source, exclude, deps.git, conventions);
-    const reread = re.plan && !re.plan.unknown.length ? re.plan : void 0;
-    const since = reread?.from.map((x) => x.commit.slice(0, 12)).join(", ");
-    if (reread && !reread.files.length && !reread.reread.length) {
-      io.out(`Nothing ${repo}'s facts cite changed since ${since}, and no source file did: atticus verify ${repo} carries its ${plural(reread.carried, "fact")} to ${commit.slice(0, 12)}.`);
-      return 0;
-    }
-    const plan = planBatches(reread ? onlyFiles(source, reread.files.map((f) => f.path)) : source, { room, exclude, overhead: overheadOf(repo, commit, frameworks), conventions });
-    if (plan.leastRoom < MIN_ROOM)
-      return tooSmall(room - plan.leastRoom);
-    if (!plan.batches.length && !reread) {
-      io.out(`${repo} has no source files to read${plan.excluded.length ? ` (${plural(plan.excluded.length, "file")} excluded)` : ""}.`);
-      return 0;
+    if (o.rules) {
+      const { topUpOf, recordRulesNow, ruleSetsOfFiles } = await import("./chunk-TJP2KLZI.js");
+      const t = await topUpOf(root, repo, {
+        commit,
+        facts: existing,
+        source,
+        exclude,
+        conventions,
+        ...o.models ? { models: o.models } : {}
+      });
+      if ("error" in t) {
+        io.err(t.error);
+        return 2;
+      }
+      if (!t.lacking.length) {
+        io.out(`${repo} was read under the reading rules there are now: nothing to top up.`);
+        return 0;
+      }
+      if (!t.files.length) {
+        await recordRulesNow(root, repo, commit);
+        io.out(`No file of ${repo} is one the reading rules added since it was read apply to (${t.lacking.join(", ")}): its read is recorded as under the rules there are now.`);
+        return 0;
+      }
+      const sets = ruleSetsOfFiles(t.files);
+      const plan = planBatches(onlyFiles(source, t.files.map((f) => f.path)), { room, exclude, overhead: overheadOf(repo, commit, frameworks), conventions });
+      if (plan.leastRoom < MIN_ROOM)
+        return tooSmall(room - plan.leastRoom);
+      s = {
+        schemaVersion: 1,
+        repo,
+        commit,
+        ...limit ? { maxTokens: limit } : {},
+        room,
+        batches: plan.batches,
+        next: 0,
+        rejected: [],
+        problems: [],
+        sets,
+        // ADR 0169: the reached model classes, listed in the prompts of the batches holding them.
+        ...t.reach?.reach.rooted && t.reach.reach.reached.length ? {
+          reached: t.reach.reach.reached.map((r) => ({
+            path: r.path,
+            types: r.types,
+            from: r.from
+          }))
+        } : {}
+      };
+      if (t.reach)
+        await recordNotReached(root, repo, {
+          commit,
+          session: sessionTokensFor(limit),
+          models: t.reach.mode,
+          ...t.reach.notReached ? { notReached: t.reach.notReached } : {}
+        });
+      await saveState(root, s);
+      io.out(`Topping up ${repo} at ${commit.slice(0, 12)} for the reading rules added since it was read (${sets.join(", ")}): ${plural(plan.files, "source file")} in ${batches(plan.batches.length)}; facts go to ${factsFile}.`);
+    } else {
+      const re = await rereadOf(dir, existing, commit, source, exclude, deps.git, conventions);
+      const reread = re.plan && !re.plan.unknown.length ? re.plan : void 0;
+      const since = reread?.from.map((x) => x.commit.slice(0, 12)).join(", ");
+      if (reread && !reread.files.length && !reread.reread.length) {
+        io.out(`Nothing ${repo}'s facts cite changed since ${since}, and no source file did: atticus verify ${repo} carries its ${plural(reread.carried, "fact")} to ${commit.slice(0, 12)}.`);
+        return 0;
+      }
+      const mode = await modelsModeOf(root, repo, o.models);
+      const rp = reread ? void 0 : reachPlanOf({
+        paths: readPathsOf(source, exclude, conventions),
+        source,
+        facts: existing,
+        mode
+      });
+      const plan = planBatches(reread ? onlyFiles(source, reread.files.map((f) => f.path)) : source, {
+        room,
+        exclude,
+        overhead: overheadOf(repo, commit, frameworks),
+        conventions,
+        ...rp?.reach.rooted && rp.reach.models ? { reach: { first: rp.first, leaveOut: rp.leaveOut } } : {}
+      });
+      if (plan.leastRoom < MIN_ROOM)
+        return tooSmall(room - plan.leastRoom);
+      if (!plan.batches.length && !reread) {
+        io.out(`${repo} has no source files to read${plan.excluded.length ? ` (${plural(plan.excluded.length, "file")} excluded)` : ""}.`);
+        return 0;
+      }
+      const byId = new Map(existing.map((f) => [f.id, f]));
+      s = {
+        schemaVersion: 1,
+        repo,
+        commit,
+        ...limit ? { maxTokens: limit } : {},
+        room,
+        batches: plan.batches,
+        next: 0,
+        rejected: (reread?.reread ?? []).map((r) => {
+          const fact = byId.get(r.id);
+          return { id: r.id, code: "cite-changed", message: staleMessage(fact, r, commit), fact };
+        }),
+        problems: [],
+        ...rp?.reach.rooted && rp.reach.reached.length ? {
+          reached: rp.reach.reached.map((r) => ({
+            path: r.path,
+            types: r.types,
+            from: r.from
+          }))
+        } : {},
+        ...reread ? {
+          reread: {
+            from: reread.from.map((x) => x.commit),
+            carried: reread.carried,
+            facts: reread.reread.length
+          }
+        } : {}
+      };
+      await saveState(root, s);
+      if (rp)
+        await recordNotReached(root, repo, {
+          commit,
+          session: sessionTokensFor(limit),
+          models: mode,
+          ...rp.notReached ? { notReached: rp.notReached } : {}
+        });
+      if (rp?.leaveOut.length)
+        io.out(`${rp.leaveOut.length} model ${rp.leaveOut.length === 1 ? "class" : "classes"} no entry or call reaches are left out (ADR 0169; recorded in ${readPlanRelOf(root, repo)}): atticus map ${repo} --models all reads them.`);
+      io.out(reread ? `Re-reading ${repo} at ${commit.slice(0, 12)}: ${plural(plan.files, "source file")} changed since ${since}, in ${batches(plan.batches.length)}${plan.batches.length ? ` (about ${plan.tokens} tokens${limit ? `, each prompt within ${limit} tokens` : ""})` : ""}; ${plural(reread.reread.length, "fact")} to rewrite, ${reread.carried} carried as they are; facts go to ${factsFile}.` : `Reading ${repo} at ${commit.slice(0, 12)} in ${batches(plan.batches.length)} (${plural(plan.files, "source file")}, about ${plan.tokens} tokens${limit ? `, each prompt within ${limit} tokens` : ""}); facts go to ${factsFile}.`);
     }
-    const byId = new Map(existing.map((f) => [f.id, f]));
-    s = {
-      schemaVersion: 1,
-      repo,
-      commit,
-      ...limit ? { maxTokens: limit } : {},
-      room,
-      batches: plan.batches,
-      next: 0,
-      rejected: (reread?.reread ?? []).map((r) => {
-        const fact = byId.get(r.id);
-        return { id: r.id, code: "cite-changed", message: staleMessage(fact, r, commit), fact };
-      }),
-      problems: [],
-      ...reread ? {
-        reread: {
-          from: reread.from.map((x) => x.commit),
-          carried: reread.carried,
-          facts: reread.reread.length
-        }
-      } : {}
-    };
-    await saveState(root, s);
-    io.out(reread ? `Re-reading ${repo} at ${commit.slice(0, 12)}: ${plural(plan.files, "source file")} changed since ${since}, in ${batches(plan.batches.length)}${plan.batches.length ? ` (about ${plan.tokens} tokens${limit ? `, each prompt within ${limit} tokens` : ""})` : ""}; ${plural(reread.reread.length, "fact")} to rewrite, ${reread.carried} carried as they are; facts go to ${factsFile}.` : `Reading ${repo} at ${commit.slice(0, 12)} in ${batches(plan.batches.length)} (${plural(plan.files, "source file")}, about ${plan.tokens} tokens${limit ? `, each prompt within ${limit} tokens` : ""}); facts go to ${factsFile}.`);
   }
   if (!s)
     return 2;
@@ -774,7 +907,9 @@ async function takeAnswer(root, s, run, batch, source, exclude, now, io, at) {
     ...estate ? { estate } : {},
     conventions: await conventionsAt(root),
     // ADR 0163: a term's note is one of those the batch was handed.
-    notes: (await notesAt(root, s.repo, at.dir)).notes
+    notes: (await notesAt(root, s.repo, at.dir)).notes,
+    // ADR 0169: the model files the read leaves out, counted apart.
+    notReached: (await loadReadPlan(root, s.repo))?.notReached?.files ?? []
   });
   const q = await raiseReadQuestions(root, s.repo, answer.questions, source, {
     command: `atticus map ${s.repo}`,
@@ -783,7 +918,7 @@ async function takeAnswer(root, s, run, batch, source, exclude, now, io, at) {
   });
   const summary = await writeVerifyFiles(root, s.repo, report, s.commit, q.problems, [], reviewedProblemsOf(reviewed.bad, report), answer.slips);
   if (answer.about) {
-    const { keepDraftedDescription } = await import("./chunk-ZKUDS7JG.js");
+    const { keepDraftedDescription } = await import("./chunk-HMQXIFOL.js");
     const d = await keepDraftedDescription(root, s.repo, answer.about, now());
     if (d.kept)
       io.out(`Your assistant says ${s.repo} is: "${answer.about.text}" \u2014 written to the manifest as a draft, unconfirmed. Confirm it (atticus repo describe ${s.repo} --accept), change it (--description "...") or drop it (--reject).`);
@@ -816,6 +951,10 @@ async function finish(root, s, io, o) {
   s.done = true;
   await saveState(root, s);
   const last = s.last;
+  if (last && !last.rejected && !s.reread) {
+    const { recordRulesNow } = await import("./chunk-TJP2KLZI.js");
+    await recordRulesNow(root, s.repo, s.commit);
+  }
   const rel = factsRelOf(root);
   if (o.json) {
     io.out(JSON.stringify({ state: "done", repo: s.repo, batches: s.batches.length, ...last }, null, 2));
@@ -825,7 +964,7 @@ async function finish(root, s, io, o) {
     io.out(`Read ${s.repo}: nothing was kept.`);
     return 0;
   }
-  io.out(`Read ${s.repo} in ${batches(s.batches.length)}: ${plural(last.accepted, "fact")} kept in ${rel}/${s.repo}.jsonl, ${last.rejected} still rejected; coverage ${Math.round(last.coverage.ratio * 100)}% (${last.coverage.read} read, ${last.coverage.reviewed ? `${last.coverage.reviewed} reviewed with nothing to record, ` : ""}${last.coverage.unknown.length} unknown).`);
+  io.out(`Read ${s.repo} in ${batches(s.batches.length)}: ${plural(last.accepted, "fact")} kept in ${rel}/${s.repo}.jsonl, ${last.rejected} still rejected; coverage ${Math.round(last.coverage.ratio * 100)}% (${last.coverage.read} read, ${last.coverage.reviewed ? `${last.coverage.reviewed} reviewed with nothing to record, ` : ""}${last.coverage.unknown.length} unknown${last.coverage.notReached?.length ? `, ${last.coverage.notReached.length} model files no entry or call reaches` : ""}).`);
   if (last.rejected)
     io.out(`The rejected facts are in ${rel}/${s.repo}.rejected.jsonl; fix them by hand or with your assistant, then atticus verify ${s.repo}.`);
   if (last.coverage.unknown.length)
@@ -872,13 +1011,6 @@ async function estimate(root, repo, c, io) {
     exclude: c.exclude,
     conventions
   });
-  const planned = room >= MIN_ROOM ? planBatches(readSource, {
-    room,
-    exclude: c.exclude,
-    conventions,
-    overhead: overheadOf(repo, c.commit, await frameworksFor(root, repo, typeof existing === "string" ? [] : existing))
-  }) : void 0;
-  const plan = planned && planned.leastRoom >= MIN_ROOM ? planned : void 0;
   const files = whole.batches.flat().map((s) => ({ path: s.path, tokens: s.tokens }));
   const proposed = reread ? { proposals: [], before: whole.tokens, after: whole.tokens } : proposeExclusions(files, c.source.list(), (p) => c.source.read(p), {
     // What the person's description plainly says this repo holds (ADR 0128).
@@ -892,16 +1024,38 @@ async function estimate(root, repo, c, io) {
     const text = c.source.read(f.path);
     return text === void 0 ? f : { ...f, lines: text.split(/\r?\n/).length };
   });
-  const parts = planParts(product, session);
+  const mode = await modelsModeOf(root, repo, c.o.models);
+  const facts0 = typeof existing === "string" ? [] : existing;
+  const rp = reread ? void 0 : reachPlanOf({ paths: product.map((f) => f.path), source: c.source, facts: facts0, mode });
+  const leave = new Set(rp?.leaveOut ?? []);
+  const kept = product.filter((f) => !leave.has(f.path));
+  const ordered = rp && rp.reach.rooted && rp.reach.models > 0;
+  const parts = planParts(kept, session, ordered ? {
+    head: reachHeadOf(kept.map((f) => f.path), rp),
+    models: rp.reach.reached.map((r) => r.path),
+    leftOut: rp.leaveOut
+  } : void 0);
+  const planned = room >= MIN_ROOM ? planBatches(readSource, {
+    room,
+    exclude: c.exclude,
+    conventions,
+    overhead: overheadOf(repo, c.commit, await frameworksFor(root, repo, facts0)),
+    ...rp && ordered ? { reach: { first: rp.first, leaveOut: rp.leaveOut } } : {}
+  }) : void 0;
+  const plan = planned && planned.leastRoom >= MIN_ROOM ? planned : void 0;
   const plan0 = await loadReadPlan(root, repo);
   const same = plan0 !== void 0 && plan0.commit === c.commit && plan0.session === session && plan0.parts.length === parts.length && plan0.parts.every((p, i) => p.paths.length === parts[i].paths.length && p.paths.every((x, j) => x === parts[i].paths[j]));
   const estimate2 = {
-    files: product.length,
-    tokens: product.reduce((n, f) => n + f.tokens, 0),
+    files: kept.length,
+    tokens: kept.reduce((n, f) => n + f.tokens, 0),
     sessions: parts.length || 1,
     ...reread ? { reread: true } : {}
   };
   const sameEstimate = plan0?.estimate !== void 0 && plan0.estimate.files === estimate2.files && plan0.estimate.tokens === estimate2.tokens && plan0.estimate.sessions === estimate2.sessions && plan0.estimate.reread === estimate2.reread;
+  const firstRead = typeof existing !== "string" && existing.length === 0 && !reread;
+  const readRules = firstRead ? rulesNow() : plan0?.rules;
+  const notReached = rp ? rp.notReached : plan0?.notReached;
+  const sameModels = plan0 !== void 0 && (plan0.models ?? "reachable") === mode && JSON.stringify(plan0.notReached ?? null) === JSON.stringify(notReached ?? null);
   if (!same)
     await writeReadPlan(root, repo, {
       commit: c.commit,
@@ -909,10 +1063,21 @@ async function estimate(root, repo, c, io) {
       parts,
       estimate: estimate2,
       // What the reader reported of an earlier plan stays, under the commit it was of.
-      ...plan0?.reported ? { reported: plan0.reported } : {}
+      ...plan0?.reported ? { reported: plan0.reported } : {},
+      ...readRules ? { rules: readRules } : {},
+      models: mode,
+      ...notReached ? { notReached } : {}
+    });
+  else if (!sameEstimate || !sameModels || firstRead && plan0.rules?.hash !== readRules?.hash) {
+    const { notReached: _n, models: _m, ...rest0 } = plan0;
+    await saveReadPlan(root, {
+      ...rest0,
+      estimate: estimate2,
+      ...readRules ? { rules: readRules } : {},
+      ...mode === "all" ? { models: "all" } : {},
+      ...notReached ? { notReached } : {}
     });
-  else if (!sameEstimate)
-    await saveReadPlan(root, { ...plan0, estimate: estimate2 });
+  }
   const progress = parts.length ? await readPlanProgress(root, repo, { commit: c.commit }) : void 0;
   const questions = (await listQuestions(root, { repo })).questions.filter((q) => q.state !== "retired");
   const notes = await notesAt(root, repo, c.dir, c.op);
@@ -937,6 +1102,8 @@ async function estimate(root, repo, c, io) {
       maxTokensGiven: given !== void 0,
       maxTokensFrom: from ?? "example",
       batches: plan?.batches.length ?? null,
+      // ADR 0169: what the read plans to read (the model classes it leaves out, out).
+      read: { files: estimate2.files, tokens: estimate2.tokens },
       order: whole.batches.flat().map((x) => x.path),
       // ADR 0128: what a person says the repo is, and whether that eased the proposals.
       about: about ? { text: about.text, trust: about.trust, eased: saysNotProduct(about) } : null,
@@ -960,6 +1127,13 @@ async function estimate(root, repo, c, io) {
           }
         } : {}
       },
+      // ADR 0169: the model classes reached from the entry points and calls, and those left out.
+      models: rp ? {
+        mode,
+        roots: rp.reach.roots,
+        reached: rp.reach.reached,
+        notReached: rp.leaveOut
+      } : null,
       tier,
       // A-taught: the frameworks of the organisation it is built on, as taught to Atticus.
       taughtFrameworks: taughtIn(c.source, c.op).map((m) => m.name),
@@ -1037,6 +1211,15 @@ repo: ${repo}`);
           io.out(`  part ${p.part} is part-read: nothing in the facts yet for ${p.left.join(", ")}.`);
     }
   }
+  const line = rp ? modelsLine(repo, rp) : void 0;
+  if (rp && line) {
+    io.out(line);
+    const data = modelsData(repo, rp);
+    if (data) {
+      io.out(MODELS_RULE);
+      io.out(data);
+    }
+  }
   io.out(`Your assistant: ${tierWords(tier)}, ${tierSource(tier)}. ${tier.how}`);
   io.out(`Another agentic assistant (Claude Code, Cursor, Gemini CLI) reads it the same way: /atticus-map ${repo}; one without file tools gets batches with atticus map ${repo} --handoff --max-tokens <its limit>.`);
   if (tier.fallback)

package/dist/{chunk-VYNZED7B.js → chunk-7FPTI62T.js}

@@ -15,27 +15,27 @@ import {
   glossaryScan,
   testsGenerate,
   traceCommand
-} from "./chunk-J27QGXO4.js";
-import "./chunk-PQW7PYUR.js";
-import "./chunk-SKMHS4CL.js";
-import "./chunk-EV4TEFOD.js";
-import "./chunk-6N2GUZMZ.js";
+} from "./chunk-TIUBGJG3.js";
+import "./chunk-PVMGHQWB.js";
+import "./chunk-TA2ZNDYD.js";
+import "./chunk-SR2M7DWL.js";
+import "./chunk-ISXNWUG7.js";
 import "./chunk-VOGCSYOI.js";
-import "./chunk-T6ESD5KM.js";
-import "./chunk-3LU6YCSQ.js";
-import "./chunk-L7I5PKGD.js";
-import "./chunk-CAN3EBE5.js";
-import "./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-XNRPCI23.js";
-import "./chunk-XZJE6WIT.js";
-import "./chunk-FMRMTI7W.js";
-import "./chunk-BKFGGJKA.js";
-import "./chunk-JMOLB347.js";
+import "./chunk-KPHPVOME.js";
+import "./chunk-G5SKNMPC.js";
+import "./chunk-JQG4VO47.js";
+import "./chunk-DW4BM73R.js";
+import "./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-77UOXZVM.js";
+import "./chunk-RA64IK43.js";
+import "./chunk-MRLCNXXR.js";
+import "./chunk-CQD26SMZ.js";
+import "./chunk-U25OX22K.js";
 import "./chunk-MMB2OHUY.js";
 import "./chunk-TV45EUGM.js";
 export {

package/dist/{chunk-Z2EYRUOH.js → chunk-7H5HYERS.js}

@@ -5,33 +5,33 @@ var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
 var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
 import {
   targetFlowsOf
-} from "./chunk-JEUXCIRD.js";
-import "./chunk-BUWSOQLU.js";
+} from "./chunk-CJ5FQHST.js";
+import "./chunk-ML3HOWPI.js";
 import {
   MAX_CHAIN_DEPTH,
   changeImpact,
   loadEstate
-} from "./chunk-EV4TEFOD.js";
-import "./chunk-6N2GUZMZ.js";
-import "./chunk-T6ESD5KM.js";
-import "./chunk-3LU6YCSQ.js";
-import "./chunk-L7I5PKGD.js";
-import "./chunk-CAN3EBE5.js";
-import "./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-XNRPCI23.js";
+} from "./chunk-SR2M7DWL.js";
+import "./chunk-ISXNWUG7.js";
+import "./chunk-KPHPVOME.js";
+import "./chunk-G5SKNMPC.js";
+import "./chunk-JQG4VO47.js";
+import "./chunk-DW4BM73R.js";
+import "./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-77UOXZVM.js";
 import {
   loadRepos
-} from "./chunk-XZJE6WIT.js";
-import "./chunk-FMRMTI7W.js";
-import "./chunk-BKFGGJKA.js";
+} from "./chunk-RA64IK43.js";
+import "./chunk-MRLCNXXR.js";
+import "./chunk-CQD26SMZ.js";
 import {
   readTeams
-} from "./chunk-JMOLB347.js";
+} from "./chunk-U25OX22K.js";
 import "./chunk-MMB2OHUY.js";
 import "./chunk-TV45EUGM.js";