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

package/dist/{chunk-3HI6Z55Y.js → chunk-K332XW7K.js}

@@ -12,14 +12,16 @@ import {
   changeTypeOf,
   checkFindings,
   loadChangeContext,
+  outsideKindOf,
+  outsideSystemsOf,
   phaseGates,
   statePhase
-} from "./chunk-XY3P7JW7.js";
+} from "./chunk-HSZMPH5T.js";
 import {
   daysBetween,
   knowledgeGaps,
   newestEvidence
-} from "./chunk-L24C55VN.js";
+} from "./chunk-64AADMTW.js";
 import {
   BREAKING_SPEC,
   INSTRUCTION_RULES,
@@ -31,45 +33,59 @@ import {
   screenText,
   settle,
   toRunSummary
-} from "./chunk-CNUKCS2T.js";
+} from "./chunk-QHJJMZLX.js";
 import {
+  ASKED_GAP_STEP,
   AgentDefinition,
   ChecklistPack,
   ChecklistRule,
   CriticQuestion,
   Finding,
   FindingAction,
+  HOSTS_STEP,
   IsoDateTime,
+  JOINED_BY_AI,
   LEGACY_LENSES,
   Lens,
   PHASES,
+  QUESTION_SCHEMA_VERSION,
+  Question,
   RECORD_KINDS,
   RecordId,
+  answerByWords,
   answerWords,
+  askedGapQuestionId,
   assistantActor,
+  callsOfQuestion,
   changesDirOf,
   changesRelOf,
   external_exports,
   fileJudgments,
   findingPath,
   gateRoundLimit,
+  hostOfQuestion,
   isAssistantResolution,
   isCriticQuestion,
+  isLinkQuestion,
   judgmentKey,
   lensCovers,
   listQuestions,
   orgPackDirOf,
   orgPackRelOf,
   questionOfLens,
+  questionsRelOf,
   quotedIn,
+  readQuestion,
+  repoReadOf,
   require_dist,
   runsDirOf,
   stateDirOf,
-  toCanonicalYaml
-} from "./chunk-S2A7YC3Q.js";
+  toCanonicalYaml,
+  writeQuestion
+} from "./chunk-PAINMSID.js";
 import {
   writeFileAtomic
-} from "./chunk-D3PO4DOZ.js";
+} from "./chunk-ODMBPDDV.js";
 import {
   __toESM
 } from "./chunk-TV45EUGM.js";
@@ -610,7 +626,8 @@ function catalogEvidence(ctx, id) {
     recordEvidence(id),
     ...file ? [
       {
-        source: file.source,
+        // ADR 0181: an AI evidence cites the call's own code line; a finding names it as code.
+        source: file.source === "ai" ? "code" : file.source,
         path: file.path,
         ...file.repo ? { repo: file.repo } : {},
         ...file.line ? { line: file.line } : {}
@@ -637,7 +654,7 @@ var observabilityPresent = {
     const design = docOf(ctx.files, "design.md");
     for (const id of ctx.footprint.components) {
       const c = ctx.get("Component", id);
-      if (!c || ctx.boundaryOf(c.system) === "vendor")
+      if (!c || ctx.outsideOf(c.system) === "vendor")
         continue;
       const assets = ctx.records.filter((r) => r.kind === "ObservabilityAsset" && r.component === id && kinds.includes(r.assetKind));
       const planned = design && contentLines(design).some((l) => l.text.toLowerCase().includes(id) && kinds.some((k) => l.text.toLowerCase().includes(k)));
@@ -720,7 +737,7 @@ var knowledgeCheck = {
     }
     const subjects = [...fp.components, ...fp.systems].filter((id) => {
       const sys = ctx.systemOf(id);
-      return !sys || ctx.boundaryOf(sys) !== "vendor";
+      return !sys || ctx.outsideOf(sys) !== "vendor";
     });
     return { hits, subjects };
   }
@@ -803,7 +820,7 @@ var factKnown = {
 var vendorOperationKnown = {
   id: "vendor-operation-known",
   question: "true",
-  description: "Each new or changed call to a vendor uses an operation in the vendor's published spec (as read into the catalog).",
+  description: "Each new or changed call to a vendor, or to another team's system, uses an operation in its published spec (as read into the catalog).",
   params: external_exports.strictObject({}),
   run(ctx) {
     const doc = docOf(ctx.files, "interfaces.md");
@@ -811,15 +828,20 @@ var vendorOperationKnown = {
     const subjects = /* @__PURE__ */ new Set();
     if (!doc)
       return { hits, subjects: [] };
+    const ofSystem = (component, sys) => ctx.systemOf(component) === sys || component === sys;
     for (const h of ctx.hops) {
       if (h.status !== "planned-new" && h.status !== "planned-modify")
         continue;
       const sys = ctx.systemOf(h.callee);
-      if (!sys || ctx.boundaryOf(sys) !== "vendor" || !h.method || !h.path)
+      const outside = sys ? ctx.outsideOf(sys) : void 0;
+      if (!sys || !outside || !h.method || !h.path)
+        continue;
+      const vendor = outside === "vendor";
+      if (!vendor && !ctx.records.some((r) => r.kind === "Endpoint" && ofSystem(r.component, sys)))
         continue;
       subjects.add(sys);
       const want = normalizePath(h.path);
-      const found = ctx.records.some((r) => r.kind === "Endpoint" && (r.component === h.callee || ctx.systemOf(r.component) === sys || r.component === sys) && (r.method ?? "").toUpperCase() === h.method && normalizePath(r.normalizedPath ?? r.pathOrTopic) === want);
+      const found = ctx.records.some((r) => r.kind === "Endpoint" && (r.component === h.callee || ofSystem(r.component, sys)) && (r.method ?? "").toUpperCase() === h.method && normalizePath(r.normalizedPath ?? r.pathOrTopic) === want);
       if (found)
         continue;
       const name = ctx.get("System", sys)?.name ?? sys;
@@ -828,9 +850,9 @@ var vendorOperationKnown = {
         artifact: "interfaces.md",
         locator: { line: h.line, record: sys },
         summary: sentence(`${name}'s published spec has no ${h.method} ${h.path}.`),
-        why: "The change plans a call to a vendor operation the catalog has never seen in the vendor's spec, so its contract, limits and errors are unknown.",
+        why: vendor ? "The change plans a call to a vendor operation the catalog has never seen in the vendor's spec, so its contract, limits and errors are unknown." : "The change plans a call to an operation of another team's system that the catalog has never seen in that team's published spec, so its contract, limits and errors are unknown.",
         fix: {
-          text: `Get the operation's spec from ${name} and add it to inputs/partner-specs, or correct the operation.`
+          text: vendor ? `Get the operation's spec from ${name} and add it to inputs/partner-specs, or correct the operation.` : `Get the operation's spec from the team that owns ${name} and add it to inputs/partner-specs, or correct the operation.`
         },
         evidence: [lineEvidence(doc, h.line), ...subjectEvidence(ctx, sys)],
         question: {
@@ -1277,6 +1299,8 @@ function patternProblems(ctx, o) {
   const doc = docOf(ctx.files, IFACES);
   if (!doc)
     return [];
+  if (ctx.patterns.size === 0)
+    return [];
   const hits = [];
   const codes = [...ctx.patterns.keys()].sort();
   for (const h of ctx.hops) {
@@ -1668,7 +1692,8 @@ var interfaceViaMatchesPattern = {
         evidence: [
           recordEvidence(rec.id),
           ...rec.evidence.filter((e) => e.path).slice(0, 1).map((e) => ({
-            source: e.source,
+            source: e.source === "ai" ? "code" : e.source,
+            // ADR 0181: the call's own line
             path: e.path,
             ...e.repo ? { repo: e.repo } : {},
             ...e.line ? { line: e.line } : {}
@@ -1681,8 +1706,178 @@ var interfaceViaMatchesPattern = {
   }
 };
 
-// packages/naysayer/dist/checks/questions.js
+// packages/naysayer/dist/checks/links.js
 var IFACES2 = "interfaces.md";
+var GUESSES = {
+  "joined-by-path": "by path",
+  "joined-by-label": "by a host's first label",
+  "joined-by-platform-setting": "by a platform-wide setting nobody set for it",
+  "joined-by-folder-name": "by the folder name of the setting that gives its host",
+  "joined-despite-conflict": "by a host or base path an open conflict disputes",
+  "joined-by-service-name": "by a Kubernetes Service's short name, from a namespace not shown to be its"
+};
+var guessOf = (f) => Object.hasOwn(GUESSES, f);
+function reposOf(ctx) {
+  const out = new Set(ctx.footprint.repos);
+  for (const c of calls(ctx))
+    for (const id of [c.caller, c.callee]) {
+      const repo = ctx.get("Component", id)?.repo;
+      if (repo)
+        out.add(repo);
+    }
+  return [...out].sort();
+}
+async function loadEstateReads(root, ctx) {
+  const reads = /* @__PURE__ */ new Map();
+  for (const r of reposOf(ctx))
+    reads.set(r, await repoReadOf(root, r));
+  const facts = new Map([...reads].map(([k, v]) => [k, v.facts]));
+  const open = await listQuestions(root, { state: "open" }).then((l) => l.questions, () => []);
+  return {
+    reads,
+    questions: open.filter((q) => isLinkQuestion(q) && reads.has(q.repo)).map((q) => ({
+      question: q,
+      calls: callsOfQuestion(q, facts),
+      file: `${questionsRelOf(root)}/${q.id}.yaml`
+    }))
+  };
+}
+var pathOf = (p) => normalizePath(p.split(/[?#]/)[0].trim()).toLowerCase();
+function sameCall(f, c) {
+  if (c.record?.evidence.some((e) => e.repo === f.repo && e.path === f.cite.file && e.line === f.cite.line))
+    return true;
+  const path = c.hop?.path ?? c.record?.normalizedPath;
+  const method = c.hop?.method ?? c.record?.method;
+  if (!path)
+    return false;
+  if (method && f.method && method.toUpperCase() !== f.method.toUpperCase())
+    return false;
+  return pathOf(path) === pathOf(f.path);
+}
+function placeOf(ctx, c) {
+  const ifaces = docOf(ctx.files, IFACES2);
+  if (c.hop && ifaces)
+    return {
+      artifact: IFACES2,
+      locator: rowLocator2(ifaces, c.hop.line),
+      evidence: [lineEvidence(ifaces, c.hop.line)]
+    };
+  return {
+    artifact: "catalog",
+    locator: { record: c.record?.id ?? c.caller },
+    evidence: c.record ? [recordEvidence(c.record.id)] : []
+  };
+}
+var plainWhat = (step, q) => step === HOSTS_STEP ? `which repo answers on ${hostOfQuestion(q) ?? "its host"}` : "which repo or system answers it";
+var changeLinksKnown = {
+  id: "change-links-known",
+  question: "true",
+  description: "Every call the change plans rests on a link read from code: not one the join guessed (by path, by a host's first label, by a platform-wide setting or a setting's folder name, or despite an open conflict), not one a link question still asks about, and not in a repo whose read is stale or incomplete.",
+  params: external_exports.strictObject({}),
+  run(ctx) {
+    const hits = [];
+    const all = calls(ctx);
+    for (const c of all) {
+      const rec = c.record;
+      const place = placeOf(ctx, c);
+      const flag = rec?.confidence === "inferred" ? rec.flags?.find(guessOf) : void 0;
+      if (rec && flag)
+        hits.push({
+          kind: "knowledge-gap",
+          ...place,
+          summary: sentence(`The change rests on a guessed link: the map joined ${c.caller} to ${c.callee} (${c.operation}) ${GUESSES[flag]}, not from code that names ${c.callee}.`),
+          why: `Nobody named ${c.callee} as the target of this call: the join found it ${GUESSES[flag]} (the Interface is inferred, flagged ${flag}). If the guess is wrong, the design is built on a call that goes somewhere else.`,
+          fix: {
+            text: `Confirm the target: name it on the call (the call's target in its facts, or Map \u203A Why is this linked? \u203A This link is wrong), then atticus verify ${ctx.get("Component", c.caller)?.repo ?? c.caller} --write.`
+          },
+          evidence: [
+            ...place.evidence.filter((e) => e.source !== "catalog"),
+            recordEvidence(rec.id)
+          ],
+          question: {
+            text: `Does ${c.caller}'s ${c.operation} go to ${c.callee}? The map joined them ${GUESSES[flag]}: nothing in ${c.caller}'s code names ${c.callee}.`,
+            owner: questionOwner(ctx, c.caller)
+          },
+          subject: c.caller,
+          key: `link-guess|${rec.id}`
+        });
+      if (rec && !flag && rec.flags?.includes(JOINED_BY_AI)) {
+        const run = rec.evidence.find((e) => e.source === "ai")?.run;
+        hits.push({
+          kind: "knowledge-gap",
+          ...place,
+          summary: sentence(`The change rests on a link the AI decided: ${c.caller} to ${c.callee} (${c.operation}), detected by AI${run ? ` (run ${run})` : ""} and not confirmed by a person.`),
+          why: `The AI paired this call with ${c.callee}, and Atticus applied it because its lines checked and its shape agreed; nobody has said it is right. If it is wrong, the design is built on a call that goes somewhere else.`,
+          fix: {
+            text: `Confirm or correct it: atticus questions decisions lists it; atticus questions correct (or Correct on the "Detected by AI" chip) makes it a person's word, then atticus verify ${ctx.get("Component", c.caller)?.repo ?? c.caller} --write.`
+          },
+          evidence: [
+            ...place.evidence.filter((e) => e.source !== "catalog"),
+            recordEvidence(rec.id)
+          ],
+          question: {
+            text: `Does ${c.caller}'s ${c.operation} go to ${c.callee}? The AI decided so; nobody has confirmed it.`,
+            owner: questionOwner(ctx, c.caller)
+          },
+          subject: c.caller,
+          key: `link-ai|${rec.id}`
+        });
+      }
+      const repo = ctx.get("Component", c.caller)?.repo;
+      for (const q of ctx.estate?.questions ?? []) {
+        if (!repo || q.question.repo !== repo || !q.calls.some((f) => sameCall(f, c)))
+          continue;
+        const id = q.question.id;
+        hits.push({
+          kind: "knowledge-gap",
+          ...place,
+          summary: sentence(`The call from ${c.caller} to ${c.callee} (${c.operation}) rests on an open question, ${id}: ${plainWhat(q.question.askedBy.step, q.question)}.`),
+          why: `The map doesn't know yet where this call goes: ${id} asks "${q.question.question}" and nobody has answered. Until it is answered, the link the design draws is a guess.`,
+          fix: {
+            text: `Answer it: atticus questions answer ${id} --option <n> (or on the app's Questions page), then ${q.question.rerun}.`
+          },
+          evidence: [
+            ...place.evidence,
+            ...rec && place.artifact !== "catalog" ? [recordEvidence(rec.id)] : [],
+            { source: "manual", path: q.file }
+          ],
+          question: { text: q.question.question, owner: questionOwner(ctx, c.caller) },
+          subject: c.caller,
+          key: `link-question|${id}|${c.hop?.line ?? rec?.id}`
+        });
+      }
+    }
+    for (const [repo, r] of ctx.estate?.reads ?? []) {
+      if (r.state !== "stale" && r.state !== "incomplete")
+        continue;
+      const c = all.find((x) => [x.caller, x.callee].some((id) => ctx.get("Component", id)?.repo === repo));
+      const component = ctx.records.find((x) => x.kind === "Component" && x.repo === repo);
+      const place = c ? placeOf(ctx, c) : {
+        artifact: "catalog",
+        locator: { record: component?.id ?? repo },
+        evidence: []
+      };
+      const evidence = [...place.evidence, ...component ? [recordEvidence(component.id)] : []];
+      if (!evidence.length)
+        continue;
+      hits.push({
+        kind: "issue",
+        ...place,
+        summary: sentence(`The change rests on ${repo}, whose read is ${r.state}: ${r.why.join("; ")}.`),
+        why: `What the catalog says of ${repo} comes from ${r.state === "stale" ? "an older commit than its checkout" : "a read that is not whole"}, so a link or entry the design relies on may have moved or be missing.`,
+        fix: {
+          text: `Read it again before relying on it: ${r.next ?? `atticus map ${repo}`}${r.next?.startsWith("atticus map") ? `, then atticus verify ${repo} --write` : ""}, and run the critic again.`
+        },
+        evidence,
+        key: `read|${repo}`
+      });
+    }
+    return { hits, subjects: [] };
+  }
+};
+
+// packages/naysayer/dist/checks/questions.js
+var IFACES3 = "interfaces.md";
 var ASYNC_ROUTES = /* @__PURE__ */ new Set(["event-bus", "pubsub", "mq", "sftp"]);
 function waits(c) {
   if (c.record?.sync === "async")
@@ -1691,11 +1886,11 @@ function waits(c) {
     return false;
   return !(c.via && ASYNC_ROUTES.has(c.via));
 }
-function placeOf(ctx, c) {
-  const ifaces = docOf(ctx.files, IFACES2);
+function placeOf2(ctx, c) {
+  const ifaces = docOf(ctx.files, IFACES3);
   if (c.hop && ifaces)
     return {
-      artifact: IFACES2,
+      artifact: IFACES3,
       locator: rowLocator2(ifaces, c.hop.line),
       evidence: [lineEvidence(ifaces, c.hop.line)]
     };
@@ -1720,7 +1915,7 @@ var callTimeoutStated = {
       const lines = callLines(ctx, c);
       if (setting || lines.some((l) => KIND_WORDS.timeout.test(l.text)))
         continue;
-      const place = placeOf(ctx, c);
+      const place = placeOf2(ctx, c);
       if (place.evidence.length === 0)
         continue;
       hits.push({
@@ -1783,7 +1978,7 @@ var publicEntryAuth = {
   description: "Every entry point the change adds or changes that another system or the gateway calls has an auth fact: the Endpoint's or the Interface's auth, or a gateway route that checks scopes. And the scopes hold up (A-gateway2): a route through the gateway that demands none, a caller whose own token can't hold the scope a hop downstream demands, and a scope a story's criteria name that no route demands.",
   params: external_exports.strictObject({}),
   run(ctx) {
-    const doc = docOf(ctx.files, IFACES2);
+    const doc = docOf(ctx.files, IFACES3);
     if (!doc)
       return { hits: [], subjects: [] };
     const hits = [];
@@ -1820,7 +2015,7 @@ var publicEntryAuth = {
       if (h.status !== "planned-new" && h.status !== "planned-modify")
         continue;
       const calleeSystem = ctx.systemOf(h.callee);
-      if (!calleeSystem || ctx.boundaryOf(calleeSystem) === "vendor")
+      if (!calleeSystem || ctx.outsideOf(calleeSystem) === "vendor")
         continue;
       const callerSystem = ctx.systemOf(h.caller);
       const rec = interfaceOf(ctx, h);
@@ -1845,7 +2040,7 @@ var publicEntryAuth = {
         if (!checked.length)
           hits.push({
             kind: "issue",
-            artifact: IFACES2,
+            artifact: IFACES3,
             locator: { ...rowLocator2(doc, h.line), field: "notes" },
             summary: sentence(`The gateway route ${routes.map((r) => r.id).join(", ")} that carries ${op} demands no scope.`),
             why: `The route checks who the caller is and nothing about what they may do, so any token the gateway accepts reaches ${h.callee}: ${h.caller} and every other client of ${routes[0].proxy} are let through alike.`,
@@ -1861,7 +2056,7 @@ var publicEntryAuth = {
           if (held.length && !wants.some((s) => held.includes(s)))
             hits.push({
               kind: "knowledge-gap",
-              artifact: IFACES2,
+              artifact: IFACES3,
               locator: { ...rowLocator2(doc, h.line), field: "notes" },
               summary: sentence(`${op} demands ${wants.join(", ")}, and the token ${h.caller} is itself called with holds ${held.join(", ")}.`),
               why: `The routes into ${h.caller} demand ${held.join(", ")}, so a token passed straight through would be refused at ${routes.map((r) => r.id).join(", ")}. Nothing in the catalog says ${h.caller} gets a token that holds ${wants.join(", ")}.`,
@@ -1883,7 +2078,7 @@ var publicEntryAuth = {
       if (facts.length) {
         hits.push({
           kind: "issue",
-          artifact: IFACES2,
+          artifact: IFACES3,
           locator: { ...rowLocator2(doc, h.line), field: "notes" },
           summary: sentence(`${h.callee} takes ${op} from ${h.caller}, ${crosses ? "in another system" : "through the gateway"}, with no authentication.`),
           why: `The catalog records the entry's auth as none, and ${h.caller} calls it ${from}: anyone who can reach it can call it.`,
@@ -1897,7 +2092,7 @@ var publicEntryAuth = {
       }
       hits.push({
         kind: "knowledge-gap",
-        artifact: IFACES2,
+        artifact: IFACES3,
         locator: { ...rowLocator2(doc, h.line), field: "notes" },
         summary: sentence(`Nothing says how ${h.callee} authenticates callers of ${op}, which ${h.caller} calls ${from}.`),
         why: `No Endpoint or Interface in the catalog records the entry's auth, and no gateway route the hop names checks scopes, so nobody can say who may call it.`,
@@ -2063,7 +2258,7 @@ var breakingDeltaConsumers = {
   params: external_exports.strictObject({}),
   run(ctx) {
     const hits = [];
-    const ifaces = docOf(ctx.files, IFACES2);
+    const ifaces = docOf(ctx.files, IFACES3);
     const index = callersIndex(ctx);
     for (const d of deltas(ctx)) {
       const via = routeCallersOf(ctx, d, index);
@@ -2084,7 +2279,7 @@ var breakingDeltaConsumers = {
         ...via.evidence
       ];
       const through = via.labels.length ? ` They reach it through ${and(via.routes)}${via.declared.length ? `; ${and(via.declared)} ${via.declared.length === 1 ? "is" : "are"} a person's word in the org pack's profile, not read from code` : ""}.` : "";
-      const place = d.hop && ifaces ? { artifact: IFACES2, locator: rowLocator2(ifaces, d.hop.line) } : { artifact: "catalog", locator: { record: d.record.id } };
+      const place = d.hop && ifaces ? { artifact: IFACES3, locator: rowLocator2(ifaces, d.hop.line) } : { artifact: "catalog", locator: { record: d.record.id } };
       const key = `breaking|${d.hop?.line ?? d.record?.id}`;
       const repos = [
         ...new Set(scanned.map((w) => ctx.get("Component", w)?.repo).filter((r) => r !== void 0))
@@ -2129,7 +2324,7 @@ var routeCallersKnown = {
   params: external_exports.strictObject({}),
   run(ctx) {
     const hits = [];
-    const ifaces = docOf(ctx.files, IFACES2);
+    const ifaces = docOf(ctx.files, IFACES3);
     const index = callersIndex(ctx);
     const asked = /* @__PURE__ */ new Set();
     for (const d of deltas(ctx))
@@ -2141,7 +2336,7 @@ var routeCallersKnown = {
         if (asked.has(key))
           continue;
         asked.add(key);
-        const place = d.hop && ifaces ? { artifact: IFACES2, locator: rowLocator2(ifaces, d.hop.line) } : { artifact: "catalog", locator: { record: r.id } };
+        const place = d.hop && ifaces ? { artifact: IFACES3, locator: rowLocator2(ifaces, d.hop.line) } : { artifact: "catalog", locator: { record: r.id } };
         hits.push({
           kind: "knowledge-gap",
           ...place,
@@ -2538,7 +2733,9 @@ var BUILT_IN_CHECKS = [
   // Who a gateway route lets in (ADR 0124 addendum A-callers).
   routeCallersKnown,
   // ADR 0113 addendum (2026-10-26): a criterion an attached note gives quotes the note's line.
-  noteCitesOnLine
+  noteCitesOnLine,
+  // ADR 0140: a change that rests on a guessed link, an open link question or a stale read.
+  changeLinksKnown
 ];
 function checkRegistry(extra = []) {
   const m = /* @__PURE__ */ new Map();
@@ -2823,6 +3020,7 @@ function buildContext(o) {
     return r?.kind === kind ? r : void 0;
   };
   const profileSystems = new Map(lifecycle.orgPack.profiles.flatMap((p) => p.profile?.systems ?? []).map((s) => [s.id, s]));
+  const outside = outsideSystemsOf(lifecycle.orgPack);
   const endpointOwners = new Set(records.filter((r) => r.kind === "Endpoint").map((r) => r.component));
   const systemOf = (id) => {
     const c = get("Component", id);
@@ -2866,6 +3064,7 @@ function buildContext(o) {
     get,
     systemOf,
     boundaryOf: (s) => get("System", s)?.boundary ?? profileSystems.get(s)?.boundary,
+    outsideOf: (s) => outsideKindOf(outside, s, get("System", s)?.boundary ?? profileSystems.get(s)?.boundary),
     ownerOf: (s) => profileSystems.get(s)?.owner ?? get("System", s)?.owner,
     isKnown: (id) => get("Component", id) !== void 0 || get("System", id) !== void 0 || profileSystems.has(id) || endpointOwners.has(id),
     namesOf: (id) => {
@@ -3066,7 +3265,8 @@ async function changeAnswers(root, change) {
     id: q.id,
     question: q.question.trim(),
     answer: (answerWords(q) ?? "").trim(),
-    by: q.answer.by,
+    // ADR 0181: an AI answer reads as the AI's, never a person's word.
+    by: answerByWords(q.answer.by),
     at: q.answer.at
   })).filter((a) => a.answer.length > 0);
 }
@@ -4040,6 +4240,33 @@ async function sinceReview(root, o) {
 }
 
 // packages/naysayer/dist/ai.js
+var LENS_BATCH_AGENT = "critic-lenses";
+var batchingOf = (rt) => typeof rt.prepareBatch === "function" && typeof rt.canBatch === "function" ? rt : void 0;
+async function batchLenses(ctx, runtime, runs) {
+  const batching = batchingOf(runtime);
+  const waiting = runs.filter((r) => r.state === "waiting" && r.runId);
+  if (!batching || waiting.length < 2)
+    return void 0;
+  const tokens = waiting.reduce((n, r) => n + (r.context?.tokens ?? 0), 0);
+  if (!batching.canBatch(waiting.length, tokens))
+    return void 0;
+  const first = lensAgent(ctx, waiting[0].lens);
+  const batch = await batching.prepareBatch({
+    change: ctx.change.id,
+    agent: {
+      ...first,
+      id: LENS_BATCH_AGENT,
+      description: `The critic's ${waiting.map((r) => r.lens).join(", ")} lenses on change ${ctx.change.id}, asked in one prompt: each lens is its own review, answered in its own section.`,
+      allowedRuntimes: ["hand-off"]
+    },
+    parts: waiting.map((r) => ({ name: r.lens, runId: r.runId })),
+    stepClass: "critic"
+  });
+  const run = await runtime.run(batch.runId);
+  for (const r of waiting)
+    r.batch = run.runId;
+  return run.runId;
+}
 var ALL_INPUTS = [
   "brief",
   "proposal",
@@ -4784,7 +5011,8 @@ async function runLenses(ctx, rules, o) {
       runs.push({ ...base, state: "failed", reason: e.message });
     }
   }
-  return { hits, runs, discarded, skipped, reviewed };
+  const batch = o.runtime && o.batch ? await batchLenses(ctx, o.runtime, runs).catch(() => void 0) : void 0;
+  return { hits, runs, discarded, skipped, reviewed, ...batch ? { batch } : {} };
 }
 
 // packages/naysayer/dist/gates.js
@@ -4807,7 +5035,9 @@ async function gateStatusOf(root, lifecycle, change, gate) {
     return p && f.finding.state === "open" ? { ...f, proposal: p } : f;
   });
   const open = findings.filter((f) => f.finding.state === "open");
-  const blocking = (await checkFindings(root, change, [gate])).map((r) => r.message);
+  const checked = await checkFindings(root, change, [gate]);
+  const blocking = checked.map((r) => r.message);
+  const onlyGaps = checked.length > 0 && checked.every((r) => r.code === "open-gap");
   const waiting = round ? ((await readRoundMeta(root, change.id, gate, round))?.lenses ?? []).filter((l) => l.state === "waiting" && l.runId).map((l) => ({ lens: l.lens, runId: l.runId })) : [];
   const proposed = findings.filter((f) => f.proposal && f.finding.severity === "blocking");
   const reasons = [
@@ -4829,7 +5059,7 @@ async function gateStatusOf(root, lifecycle, change, gate) {
     total: count(findings),
     mayProceed: reasons.length === 0,
     // An open gap with nothing blocking waits on its owner, not on a person's decision.
-    humanDecides: blocking.length > 0 && usedUp && !(count(open).blocking === 0 && count(open).gaps > 0 && waiting.length === 0),
+    humanDecides: blocking.length > 0 && usedUp && !(count(open).blocking === 0 && onlyGaps && waiting.length === 0),
     checkRound: usedUp && (await checkRoundDue(root, change.id, gate)).length > 0,
     checkRoundsRun,
     waiting,
@@ -4946,6 +5176,7 @@ async function prepareLayers(root, g, now, teamPacks, checks = []) {
   const ctx = buildContext({ root, change, type, lifecycle, footprint, files, gate, now });
   ctx.answers = await changeAnswers(root, change.id);
   ctx.recorded = await recordedFacts(root, change.id);
+  ctx.estate = await loadEstateReads(root, ctx);
   const { sources, problems } = await ruleSources(ctx, teamPacks);
   const layered = layerRules(sources);
   problems.push(...layered.problems);
@@ -5149,6 +5380,7 @@ async function runCritic(root, changeId, opts = {}) {
   }) : void 0;
   const ai = await runLenses(ctx, applicable, {
     ...opts.runtime ? { runtime: opts.runtime } : {},
+    ...opts.batchLenses ? { batch: true } : {},
     lenses,
     failed,
     ...opts.maxClassification ? { maxClassification: opts.maxClassification } : {},
@@ -5243,6 +5475,8 @@ async function runCritic(root, changeId, opts = {}) {
       artifacts: r.artifacts,
       ...r.promptSha256 ? { promptSha256: r.promptSha256 } : {},
       ...r.runId ? { runId: r.runId } : {},
+      // ADR 0185: the one prompt it was asked in with the round's other waiting lenses.
+      ...r.batch ? { batch: r.batch } : {},
       // What the lens was sent (ADR 0115 addendum, 2026-10-25): its size, what was cut to
       // need, and in a redraft the round it was diffed against and what wasn't sent.
       ...r.context ? { context: r.context } : {}
@@ -5262,6 +5496,7 @@ async function runCritic(root, changeId, opts = {}) {
     refused: layered.refused,
     problems,
     lenses: ai.runs,
+    ...ai.batch ? { batch: ai.batch } : {},
     discarded: ai.discarded,
     failedLayer1: [...failed].sort(),
     model,
@@ -5404,6 +5639,19 @@ async function completeLensRun(root, run, opts = {}) {
     status: await gateStatusOf(root, lifecycle, change, gateId)
   };
 }
+async function completeLensBatch(root, batch, result, opts = {}) {
+  const out = [];
+  for (const p of batch.parts ?? []) {
+    const run = await result(p.runId).catch(() => void 0);
+    if (run?.state !== "validated" || !lensRunOf(run.request))
+      continue;
+    const found = await roundOf(root, run.request.change, run.runId);
+    if (found?.entry.state !== "waiting")
+      continue;
+    out.push(await completeLensRun(root, run, opts));
+  }
+  return out;
+}
 async function failLens(root, change, gate, round, runId, reason) {
   const meta = await readRoundMeta(root, change, gate, round);
   if (!meta || !meta.lenses.some((l) => l.runId === runId && l.state === "waiting"))
@@ -5417,6 +5665,29 @@ import { createHash } from "node:crypto";
 import { readdir as readdir7, readFile as readFile8 } from "node:fs/promises";
 import { join as join12, normalize, sep as sep2 } from "node:path";
 var import_yaml8 = __toESM(require_dist(), 1);
+async function raiseAskedQuestion(root, f, askedOf, at) {
+  const id = askedGapQuestionId(f.change, f);
+  if (await readQuestion(root, id).catch(() => void 0))
+    return id;
+  const rel = `${changesRelOf(root)}/${f.change}`;
+  const file = f.artifact === "catalog" ? "change.yaml" : f.artifact;
+  const rerun = `atticus critic ${f.change} --gate ${f.gate}`;
+  await writeQuestion(root, Question.parse({
+    schemaVersion: QUESTION_SCHEMA_VERSION,
+    id,
+    askedBy: { step: ASKED_GAP_STEP, command: `atticus finding ${f.change} ${f.id} ask`, at },
+    repo: f.change,
+    question: f.question?.text ?? f.summary,
+    options: [],
+    evidence: [`${rel}/${file}:${f.artifact === "catalog" ? 1 : f.locator.line ?? 1}`],
+    scope: { level: "repo", id: f.change },
+    askedOf,
+    finding: { change: f.change, gate: f.gate, round: f.round, id: f.id },
+    state: "open",
+    rerun
+  }));
+  return id;
+}
 async function locate(lifecycle, root, change, id, gate) {
   const gates = gate ? [gate] : await reviewedGates(root, change);
   const order = lifecycle.orgPack.gates.gates.map((g) => g.id);
@@ -5561,7 +5832,7 @@ async function act(root, changeId, findingId, action, o) {
     const said = o.reason?.trim().replace(/[.!?]+$/, "");
     message = edited.length ? `Recorded your edit to ${edited.join(", ")}.` : said ? `Recorded what you did: ${said}.` : `Recorded your edit to ${f.artifact}.`;
   } else if (act2 === "ask")
-    message = `Asked ${askedOf}. The gap stops blocking while the question is open.`;
+    message = `Asked ${askedOf}.`;
   else if (act2 === "waive")
     message = `Waived ${f.id}. The waiver, its reason and your name are recorded on the finding; it reaches main with the ${f.gate} hand-off PR, where reviewers see it.`;
   else
@@ -5590,6 +5861,11 @@ async function act(root, changeId, findingId, action, o) {
     };
   }
   await writeFinding(root, next.data);
+  let question;
+  if (act2 === "ask" && gap) {
+    question = await raiseAskedQuestion(root, next.data, askedOf, next.data.resolution.at);
+    message = `Asked ${askedOf}: owner question ${question} is in Questions, Owner questions. The ${f.gate} gate waits for its answer.`;
+  }
   if (waiting)
     await writeProposals(root, change.id, f.gate, f.round, proposals.filter((p) => p.finding !== f.id));
   const after = act2 === "ask" ? void 0 : await afterLimit(lifecycle, root, change.id, next.data);
@@ -5597,7 +5873,13 @@ async function act(root, changeId, findingId, action, o) {
     message = `${message} ${after}`;
   else if (act2 === "apply" || act2 === "edit-and-apply")
     message = patched || act2 === "edit-and-apply" ? `${message.replace(/\.$/, "")}; the next critic round checks it.` : `${message} The next critic round checks the fix.`;
-  return { finding: next.data, path: found.path, ...patched ? { patched } : {}, message };
+  return {
+    finding: next.data,
+    path: found.path,
+    ...patched ? { patched } : {},
+    ...question ? { question } : {},
+    message
+  };
 }
 async function afterLimit(ctx, root, change, f) {
   const max = gateRoundLimit(ctx.orgPack.gates, f.gate);
@@ -5649,8 +5931,8 @@ async function editedByPerson(folder) {
     if (!written || typeof written !== "object")
       continue;
     for (const [file, hash] of Object.entries(written)) {
-      const now = await readFile8(join12(folder, ...file.split("/"))).catch(() => void 0);
-      const h = now ? createHash("sha256").update(now).digest("hex") : void 0;
+      const now = await readFile8(join12(folder, ...file.split("/")), "utf8").catch(() => void 0);
+      const h = now !== void 0 ? createHash("sha256").update(now.replace(/\r\n?/g, "\n"), "utf8").digest("hex") : void 0;
       if (h !== hash)
         out.add(file);
     }
@@ -5920,6 +6202,7 @@ export {
   focusTerms,
   trimSources,
   sinceReview,
+  LENS_BATCH_AGENT,
   lensAgent,
   catalogSlice,
   lensAnswerProblem,
@@ -5943,7 +6226,9 @@ export {
   lensRunOf,
   waitingLenses,
   completeLensRun,
+  completeLensBatch,
   failLens,
   act,
+  editedByPerson,
   overrideStats
 };