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

package/dist/{chunk-AY2IUF4K.js → chunk-22GLUHGE.js}

@@ -7,18 +7,18 @@ import {
   featuresForScan,
   namingHint,
   syncSources
-} from "./chunk-6JLPXDWN.js";
+} from "./chunk-QR65C3DV.js";
 import {
   dirSource,
   sameCommit,
   verifyFacts
-} from "./chunk-4GZXS6S2.js";
+} from "./chunk-MLAACAES.js";
 import {
   scanInputs
-} from "./chunk-R4TBNKKC.js";
+} from "./chunk-HY2VVVFZ.js";
 import {
   listIngestors
-} from "./chunk-NIXVDQVO.js";
+} from "./chunk-PJRMMWU4.js";
 import {
   BUILT_IN_EXTRACTORS,
   MODEL_READERS,
@@ -33,12 +33,12 @@ import {
   runDialectTests,
   runFrameworkTests,
   unmodelledFrameworks
-} from "./chunk-UR7RMZ3R.js";
+} from "./chunk-34NWVIBC.js";
 import {
   baseClonePath,
   changesSince,
   checkoutState
-} from "./chunk-PGKHJYOB.js";
+} from "./chunk-RA64IK43.js";
 import {
   DEFAULT_IGNORES,
   configHash,
@@ -50,11 +50,11 @@ import {
   sandboxedExtractor,
   scanRepo,
   withParseCache
-} from "./chunk-MKRBG5EF.js";
+} from "./chunk-MRLCNXXR.js";
 import {
   buildContextPack,
   toRunSummary
-} from "./chunk-5XDNUJ4P.js";
+} from "./chunk-CQD26SMZ.js";
 import {
   AgentDefinition,
   DECLARED_CALLER,
@@ -69,8 +69,11 @@ import {
   REPO_TYPE_SCHEMA_VERSION,
   RecordId,
   SCAN_SETTINGS_SCHEMA_VERSION,
+  TARGETS_ANOTHER_LABEL,
   TARGETS_SPLIT_LABEL,
   TARGETS_STEP_ID,
+  TOPICS_OUTSIDE_LABEL,
+  TOPICS_STEP_ID,
   applyCurated,
   applyLinkEvidence,
   applySharedMaps,
@@ -101,6 +104,7 @@ import {
   joinGuessesOf,
   joinRecords,
   joinSharedMaps,
+  joinTerms,
   lineNamesField,
   lineNamesRoute,
   lineNamesWord,
@@ -126,14 +130,16 @@ import {
   stackHelpersOff,
   stripLinkEvidence,
   stripSharedMaps,
+  termGrantRecords,
   throwIfCancelled,
   toCanonicalYaml,
+  topicQuestionText,
   urlHostPort
-} from "./chunk-577AJVRS.js";
+} from "./chunk-U25OX22K.js";
 import {
   SCHEMA_VERSION,
   writeFileAtomic
-} from "./chunk-D3PO4DOZ.js";
+} from "./chunk-MMB2OHUY.js";
 import {
   __toESM
 } from "./chunk-TV45EUGM.js";
@@ -1484,6 +1490,332 @@ import { join as join6 } from "node:path";
 
 // packages/scanner/dist/facts-catalog.js
 import { createHash as createHash2 } from "node:crypto";
+
+// packages/scanner/dist/target-suggest.js
+var TARGETS_MAX_SUGGESTED = 5;
+var TARGETS_ANOTHER = TARGETS_ANOTHER_LABEL;
+var TARGETS_NO_EVIDENCE = "no evidence; listed so you can pick it";
+var STOP = new Set("url uri base host client clients service services svc api apis http https rest endpoint endpoints impl java kt ts js py cs go src main test get post put delete patch the and for com www internal example config configs properties yaml yml env app apps application new call calls feign template web request requests response gateway proxy remote adapter port".split(" "));
+function nameWords(s) {
+  if (!s)
+    return [];
+  return [
+    ...new Set(s.replace(/([a-z0-9])([A-Z])/g, "$1 $2").toLowerCase().split(/[^a-z0-9]+/).filter((w) => w.length >= 3 && !STOP.has(w) && !/^v?\d+$/.test(w)).map((w) => w.length > 4 && w.endsWith("s") && !w.endsWith("ss") ? w.slice(0, -1) : w))
+  ];
+}
+var segs = (p) => p.split(/[?#]/)[0].split("/").filter(Boolean).map((x) => /^[{:<$]/.test(x) ? "{}" : x);
+var sameSeg = (a, b) => a === "{}" || b === "{}" || a === b;
+var under = (path, prefix) => {
+  const a = segs(prefix);
+  const b = segs(path);
+  return a.length > 0 && a.length <= b.length && a.every((x, i) => x === b[i]);
+};
+function serves(entry, call, bases) {
+  const e = segs(entry);
+  const tries = [
+    segs(call),
+    ...bases.filter((b) => under(call, b)).map((b) => segs(call).slice(segs(b).length))
+  ];
+  return tries.some((c) => c.length === e.length && c.every((x, i) => sameSeg(x, e[i])));
+}
+function clientOf(f) {
+  const q = f.cite.quote ?? "";
+  const named2 = /\b([A-Z][A-Za-z0-9]*(?:Client|Service|Api|Feign|Gateway|Proxy))\b/.exec(q)?.[1];
+  if (named2)
+    return named2;
+  const file = f.cite.file.split("/").pop().replace(/\.[^.]+$/, "");
+  return /(Client|Service|Api|Feign|Gateway|Proxy)$/.test(file) ? file : void 0;
+}
+function hostOf(f, facts) {
+  const fromUrl = (u) => /^[a-z][a-z0-9+.-]*:\/\/([^/:?#]+)/i.exec(u)?.[1];
+  if (f.host)
+    return fromUrl(f.host) ?? f.host.split(/[/:]/)[0];
+  if (f.base) {
+    const cfg = facts.find((x) => x.kind === "config" && x.key === f.base && !!x.value);
+    if (!cfg?.value)
+      return void 0;
+    return fromUrl(cfg.value) ?? (/^[a-z0-9-]+(\.[a-z0-9-]+)+(:\d+)?$/i.test(cfg.value) ? cfg.value.split(":")[0] : void 0);
+  }
+  return void 0;
+}
+var answerLabel = (q) => q.answer?.option !== void 0 ? q.options[q.answer.option - 1]?.label : q.answer?.text;
+var NOT_A_TARGET = /* @__PURE__ */ new Set(["None of these", TARGETS_SPLIT_LABEL, TARGETS_ANOTHER_LABEL]);
+function candidates(callerRepo, ctx) {
+  const manifest = estateRepos(ctx.op).filter((r) => r.id !== callerRepo || !!ctx.only);
+  const systems = ctx.op.profiles.flatMap((p) => p.profile?.systems ?? []);
+  const reposOfSystem = /* @__PURE__ */ new Map();
+  for (const r of estateRepos(ctx.op))
+    if (r.system)
+      reposOfSystem.set(r.system, (reposOfSystem.get(r.system) ?? 0) + 1);
+  const read = new Set((ctx.estate ?? []).filter((x) => x.facts.length > 0).map((x) => x.repo));
+  const repoOf = /* @__PURE__ */ new Map();
+  for (const r of ctx.records)
+    if (r.kind === "Component" && r.repo)
+      repoOf.set(r.id, r.repo);
+  if (!ctx.estate)
+    for (const repo of repoOf.values())
+      read.add(repo);
+  const endpoints = ctx.records.filter((r) => r.kind === "Endpoint");
+  const deploys = (ctx.estate ?? []).flatMap((x) => x.facts.filter((f) => f.kind === "deploy" && !!f.basePath));
+  const out = [];
+  for (const m of manifest) {
+    const own2 = new Set([m.id, m.component, ...m.modules.map((x) => x.component)].filter((x) => !!x).map(factIdPart));
+    const sys = m.system && reposOfSystem.get(m.system) === 1 ? systems.find((s) => s.id === m.system) : void 0;
+    const names = /* @__PURE__ */ new Map();
+    for (const n of [m.id, m.component, ...m.modules.map((x) => x.component)])
+      for (const w of nameWords(n))
+        if (!names.has(w))
+          names.set(w, n);
+    for (const a of sys ? [sys.id, ...sys.aliases] : [])
+      for (const w of nameWords(a))
+        if (!names.has(w))
+          names.set(w, a);
+    const bases = [];
+    if (m.basePath)
+      bases.push({ path: m.basePath, from: "the manifest's basePath" });
+    for (const x of m.modules)
+      if (x.basePath)
+        bases.push({ path: x.basePath, from: `the basePath of its module ${x.component}` });
+    for (const d of deploys) {
+      const reaches = d.exposes ? factIdPart(d.exposes) : d.repo === m.id ? m.id : void 0;
+      if (!reaches || !(own2.has(reaches) || d.repo === m.id && !d.exposes))
+        continue;
+      const what2 = d.platform === "apigee" ? "its proxy's BasePath" : `the ${d.resourceType ?? "route"} ${d.resourceName ?? d.id}`;
+      bases.push({ path: d.basePath, from: `${what2} (${d.repo} ${d.cite.file}:${d.cite.line})` });
+    }
+    const comps = [
+      ...new Set(endpoints.filter((e) => repoOf.get(e.component) === m.id).map((e) => e.component))
+    ].sort();
+    const isRead = read.has(m.id);
+    const forLabel = comps.length ? comps : [m.id];
+    for (const label2 of forLabel) {
+      const mine = endpoints.filter((e) => e.component === label2);
+      const entries = (ctx.estate ?? []).filter((x) => x.repo === m.id).flatMap((x) => x.facts.filter((f) => f.kind === "entry" && (!comps.length || factIdPart(f.component ?? m.component ?? m.id) === label2 || comps.length === 1))).map((f) => ({
+        ...f.method ? { method: f.method.toUpperCase() } : {},
+        path: f.path,
+        at: `${f.cite.file}:${f.cite.line}`
+      }));
+      for (const e of mine)
+        if (!entries.some((x) => x.path === e.pathOrTopic))
+          entries.push({
+            ...e.method ? { method: e.method.toUpperCase() } : {},
+            path: e.pathOrTopic,
+            at: e.id
+          });
+      out.push({
+        s: { label: label2, kind: "repo", repo: m.id, read: isRead, score: 0, why: [] },
+        names,
+        bases,
+        entries,
+        ...m.description?.text ? { description: m.description.text } : {},
+        hosts: m.hosts.map((h) => h.toLowerCase())
+      });
+    }
+  }
+  for (const c of ctx.only ?? [])
+    if (!out.some((x) => x.s.label === c))
+      out.push({
+        s: {
+          label: c,
+          kind: "repo",
+          repo: repoOf.get(c) ?? callerRepo,
+          read: true,
+          score: 0,
+          why: []
+        },
+        names: /* @__PURE__ */ new Map(),
+        bases: [],
+        entries: [],
+        hosts: []
+      });
+  const own = new Set(estateRepos(ctx.op).flatMap((r) => r.system ? [r.system] : []));
+  const seen = /* @__PURE__ */ new Set();
+  for (const s of systems) {
+    if (!(s.boundary === "vendor" || !own.has(s.id)) || seen.has(s.id))
+      continue;
+    seen.add(s.id);
+    const names = /* @__PURE__ */ new Map();
+    for (const n of [s.id, s.name, ...s.aliases])
+      for (const w of nameWords(n))
+        if (!names.has(w))
+          names.set(w, n);
+    out.push({
+      s: {
+        label: s.id,
+        kind: "outside",
+        read: false,
+        name: s.name,
+        boundary: s.boundary,
+        score: 0,
+        why: []
+      },
+      names,
+      bases: [],
+      entries: [],
+      hosts: s.aliases.map((a) => a.toLowerCase())
+    });
+  }
+  return out;
+}
+function targetSuggestions(f, ctx) {
+  const all = candidates(f.repo, ctx);
+  const df = /* @__PURE__ */ new Map();
+  for (const c of all)
+    for (const w of c.names.keys())
+      df.set(w, (df.get(w) ?? 0) + 1);
+  const telling = (w) => (df.get(w) ?? 0) <= Math.max(2, Math.floor(all.length / 3));
+  const host = hostOf(f, ctx.facts)?.toLowerCase();
+  const client = clientOf(f);
+  const said = [
+    { from: f.base ? `the config key ${f.base}` : "", words: nameWords(f.base), weight: 4 },
+    { from: client ? `the client ${client}` : "", words: nameWords(client), weight: 4 },
+    {
+      from: host ? `the host label ${host.split(".")[0]} (${host})` : "",
+      words: host ? nameWords(host.split(".")[0]) : [],
+      weight: 4
+    },
+    {
+      from: `the path ${f.path}`,
+      words: nameWords(segs(f.path).filter((x) => x !== "{}").join(" ")),
+      weight: 2
+    }
+  ].filter((x) => x.from && x.words.length);
+  const method = f.method?.toUpperCase();
+  const earlier = (ctx.questions ?? []).filter((q) => q.askedBy?.step === TARGETS_STEP_ID && q.state === "answered" && q.repo === f.repo && !q.evidence.includes(`${f.cite.file}:${f.cite.line}`));
+  const only = ctx.only ? new Set(ctx.only) : void 0;
+  const out = [];
+  for (const c of all) {
+    if (only && c.s.kind === "repo" && !only.has(c.s.label))
+      continue;
+    const s = { ...c.s, why: [] };
+    const add = (n, why) => {
+      s.score += n;
+      s.why.push(why);
+    };
+    if (only?.has(c.s.label))
+      add(6, "the join found an entry of it that serves the call");
+    const hit = c.entries.find((e) => (!method || !e.method || e.method === method || e.method === "ANY") && serves(e.path, f.path, c.bases.map((b) => b.path)));
+    if (hit && !only) {
+      const what2 = [hit.method, hit.path].filter(Boolean).join(" ");
+      add(6, `serves ${what2} (${hit.at})`);
+      s.serves = [what2];
+    }
+    const base2 = c.bases.find((b) => under(f.path, b.path));
+    if (base2)
+      add(5, `its basePath ${base2.path} matches: ${base2.from}`);
+    if (host && c.hosts.includes(host))
+      add(8, `it lists ${host} under hosts`);
+    for (const x of said) {
+      const w = x.words.find((y) => c.names.has(y) && telling(y));
+      if (w)
+        add(x.weight, `named like ${x.from}`);
+    }
+    if (c.description) {
+      const d = new Set(nameWords(c.description));
+      const w = said.flatMap((x) => x.words).find((y) => d.has(y) && telling(y));
+      if (w)
+        add(2, `its description mentions ${w}`);
+    }
+    const named2 = earlier.filter((q) => {
+      const l = answerLabel(q);
+      if (!l || NOT_A_TARGET.has(l))
+        return false;
+      const t = slugify(l);
+      return t === slugify(c.s.label) || !!c.s.repo && t === slugify(c.s.repo);
+    }).length;
+    if (named2)
+      add(3, `picked for ${named2} other ${named2 === 1 ? "call" : "calls"} of ${f.repo}`);
+    if (!s.score)
+      s.why.push(TARGETS_NO_EVIDENCE);
+    s.why = [...new Set(s.why)];
+    out.push(s);
+  }
+  return out.sort((a, b) => b.score - a.score || Number(b.read) - Number(a.read) || (a.kind === b.kind ? 0 : a.kind === "repo" ? -1 : 1) || a.label.localeCompare(b.label));
+}
+function offeredSuggestions(ranked, o) {
+  const max = o.max ?? TARGETS_MAX_SUGGESTED;
+  const strong = ranked.filter((s) => s.score >= 2);
+  const fill = ranked.filter((s) => s.score < 2 && (s.kind === "outside" || s.read && o.serving.has(s.label)));
+  return [...strong, ...fill].slice(0, max);
+}
+function targetPicker(op, read = /* @__PURE__ */ new Set()) {
+  const repos = estateRepos(op).map((r) => ({
+    id: r.id,
+    kind: "repo",
+    name: r.component && r.component !== r.id ? `${r.id} (${r.component})` : r.id,
+    read: read.has(r.id)
+  })).sort((a, b) => a.id.localeCompare(b.id));
+  const seen = /* @__PURE__ */ new Set();
+  const systems = op.profiles.flatMap((p) => p.profile?.systems ?? []).filter((s) => !seen.has(s.id) && !!seen.add(s.id)).map((s) => ({ id: s.id, kind: "system", name: s.name, boundary: s.boundary })).sort((a, b) => a.id.localeCompare(b.id));
+  const owned = new Set(op.profiles.flatMap((p) => (p.profile?.systems ?? []).flatMap((s) => s.owner ? [s.owner] : [])));
+  const teams = (op.roles?.teams ?? []).map((t) => {
+    const name = t.name ?? t.id;
+    const has = owned.has(t.id);
+    return {
+      id: t.id,
+      kind: "team",
+      name,
+      ...has ? {} : {
+        adds: {
+          id: slugify(`${t.id}-system`),
+          name: `${name}'s system`,
+          boundary: "internal",
+          owner: t.id
+        }
+      }
+    };
+  }).sort((a, b) => a.id.localeCompare(b.id));
+  return [...repos, ...systems, ...teams];
+}
+function pickerLines(picks) {
+  const of = (k) => picks.filter((p) => p.kind === k);
+  return [
+    `Repos (${of("repo").length}): ${of("repo").map((p) => `${p.id}${p.read ? "" : " (not read yet)"}`).join(", ") || "none"}`,
+    `Systems (${of("system").length}): ${of("system").map((p) => `${p.id} (${p.boundary})`).join(", ") || "none"}`,
+    `Teams (${of("team").length}): ${of("team").map((p) => `${p.id}${p.adds ? " (no system yet)" : ""}`).join(", ") || "none"}`
+  ];
+}
+function topicQuestionDrafts(repo, records) {
+  const out = /* @__PURE__ */ new Map();
+  for (const r of records) {
+    if (r.kind !== "Unresolved")
+      continue;
+    const x = r;
+    if (x.unresolvedKind !== "event-publish" && x.unresolvedKind !== "event-subscribe")
+      continue;
+    const topic = String(x.raw);
+    if (!topic || topic.includes("${") || /\s/.test(topic))
+      continue;
+    const ev = x.evidence.filter((e) => e.repo === repo && e.path && e.line && !/[\s:]/.test(e.path)).map((e) => `${e.path}:${e.line}`).sort();
+    if (!ev.length)
+      continue;
+    const side = x.unresolvedKind === "event-publish" ? "publish" : "listen";
+    const question = topicQuestionText(topic, x.owner ?? repo, side);
+    const draft = {
+      question,
+      options: [
+        {
+          label: TOPICS_OUTSIDE_LABEL,
+          means: `${topic} belongs to another team's system or a vendor's: name it, or the team, from the list`,
+          changes: `${topic} is added under that system's topics in the profile (or the system is added, owner the team), as a file change for review; the next write ${side === "publish" ? "sends the publish to it" : "takes the listener's messages from it"}, marked as your word`
+        },
+        {
+          label: "None of these",
+          means: `Nothing outside the estate owns ${topic}, or a repo not read yet serves it`,
+          changes: `It stays a loose end, and this isn't asked again`
+        }
+      ],
+      evidence: [...new Set(ev)],
+      scope: "repo"
+    };
+    const id = questionId({ step: TOPICS_STEP_ID, repo, question, evidence: draft.evidence });
+    if (!out.has(id))
+      out.set(id, { topic, id, draft });
+  }
+  return [...out.values()].sort((a, b) => a.topic.localeCompare(b.topic));
+}
+
+// packages/scanner/dist/facts-catalog.js
 var TARGETS_STEP = TARGETS_STEP_ID;
 var TARGETS_NONE = "None of these";
 var byKindId = (a, b) => a.kind === b.kind ? a.id.localeCompare(b.id) : a.kind.localeCompare(b.kind);
@@ -1556,27 +1888,88 @@ function targetAsks(facts, records, asks) {
   }
   return { list, repoOf };
 }
-var vendorsOf = (op) => outsideProfileSystems(op);
 var outsideAs = (s) => s.boundary === "vendor" ? "an outside system" : "another team's system";
 var callWhat = (f) => [f.method?.toUpperCase(), f.path].filter(Boolean).join(" ");
-function targetQuestionDrafts(facts, records, op, asks) {
-  const { list, repoOf } = targetAsks(facts, records, asks);
-  const vendors = vendorsOf(op);
-  return list.map(({ f, q, servers }) => {
-    const what2 = callWhat(f);
+function suggestionWhy(s, prefix) {
+  const served = s.serves ?? [];
+  let why = s.why;
+  if (prefix !== void 0 && served.length > 1) {
+    const under2 = prefix === "/" ? "" : ` under ${prefix}`;
+    why = [
+      `serves ${served[0]} and ${served.length - 1} more${under2}`,
+      ...why.filter((w) => !w.startsWith("serves "))
+    ];
+  }
+  return (why.length ? why : [TARGETS_NO_EVIDENCE]).slice(0, 3).join("; ");
+}
+function suggestionOption(s, callerRepo, n, prefix) {
+  const why = suggestionWhy(s, prefix);
+  if (s.kind === "outside")
+    return {
+      label: s.label,
+      means: `${s.name}, ${outsideAs({ boundary: s.boundary ?? "vendor" })}: ${why}`,
+      changes: n ? `The ${n} calls go to ${s.name} when the facts are next written` : `The call goes to ${s.name} when the facts are next written`
+    };
+  const who = s.label === s.repo ? `${s.repo}${s.read ? "" : " (not read yet)"}` : `${s.label}, built in ${s.repo}${s.read ? "" : " (not read yet)"}`;
+  const them = n ? `The ${n} calls` : "The call";
+  return {
+    label: s.label,
+    means: `${who}: ${why}`,
+    changes: s.read ? `${them} ${n ? "join" : "joins"} ${s.label} when the facts are next written (atticus verify ${callerRepo} --write)` : `${them} ${n ? "go" : "goes"} to ${s.repo} when the facts are next written (atticus verify ${callerRepo} --write), and ${n ? "join" : "joins"} its route once ${s.repo} is read and verified (/atticus-map ${s.repo}); if no route of it serves ${n ? "them" : "it"}, the question opens again`
+  };
+}
+var anotherOption = (op) => {
+  const repos = estateRepos(op).length;
+  const systems = new Set(op.profiles.flatMap((p) => (p.profile?.systems ?? []).map((s) => s.id))).size;
+  const teams = op.roles?.teams?.length ?? 0;
+  return {
+    label: TARGETS_ANOTHER,
+    means: `A repo, system or team not listed here: the manifest's ${repos} repos (read or not), the profiles' ${systems} systems and the ${teams} teams in roles.yaml`,
+    changes: "Nothing until you name one: atticus questions answer <id> --target <repo, system or team id> lists them and takes the one you name (the app's Questions page lists them too); naming a vendor or a team with no system adds that system to the profile for review"
+  };
+};
+function offered(members, facts, records, op, asks, ctx) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const m of members) {
+    const ambiguous = asks?.some((a) => a.reason === "ambiguous" && a.call.repo === m.f.repo && a.call.fact === m.f.id);
+    for (const s of targetSuggestions(m.f, {
+      op,
+      records,
+      facts,
+      ...ctx.estate ? { estate: ctx.estate } : {},
+      ...ctx.questions ? { questions: ctx.questions } : {},
+      ...ambiguous ? { only: m.servers } : {}
+    })) {
+      const x = merged.get(s.label);
+      if (!x)
+        merged.set(s.label, { ...s, why: [...s.why], serves: [...s.serves ?? []] });
+      else {
+        x.score += s.score;
+        for (const w of s.why)
+          if (!x.why.includes(w))
+            x.why.push(w);
+        for (const w of s.serves ?? [])
+          if (!x.serves.includes(w))
+            x.serves.push(w);
+        if (x.why.length > 1)
+          x.why = x.why.filter((w) => w !== TARGETS_NO_EVIDENCE);
+      }
+    }
+  }
+  const ranked = [...merged.values()].sort((a, b) => b.score - a.score || Number(b.read) - Number(a.read) || (a.kind === b.kind ? 0 : a.kind === "repo" ? -1 : 1) || a.label.localeCompare(b.label));
+  const serving = new Set(members.flatMap((m) => m.servers));
+  const types = new Set(members.flatMap((m) => SERVES[m.f.callType] ?? []));
+  return offeredSuggestions(ranked, { types, serving });
+}
+function targetQuestionDrafts(facts, records, op, asks, ctx = {}) {
+  const { list } = targetAsks(facts, records, asks);
+  return list.map((m) => {
+    const { f, q } = m;
     const draft = {
       question: q.question,
       options: [
-        ...servers.map((c) => ({
-          label: c,
-          means: `${c}${repoOf.get(c) ? `, built in ${repoOf.get(c)},` : ""} answers ${what2}`,
-          changes: `The call joins ${c} when the facts are next written (atticus verify ${f.repo} --write)`
-        })),
-        ...vendors.map((s) => ({
-          label: s.id,
-          means: `${s.name}, ${outsideAs(s)}, answers ${what2}`,
-          changes: `The call goes to ${s.name} when the facts are next written`
-        })),
+        ...offered([m], facts, records, op, asks, ctx).map((s) => suggestionOption(s, f.repo)),
+        anotherOption(op),
         {
           label: TARGETS_NONE,
           means: "Nothing in the estate or the org pack's systems answers it",
@@ -1622,28 +2015,51 @@ function groupVia(f) {
     return ` through ${f.base}`;
   return "";
 }
-function targetGroupQuestion(repo, f) {
+function targetGroupQuestion(repo, f, facts) {
+  const proxy = facts ? proxyOf(f, facts) : void 0;
+  const through = f.base ?? f.host ?? f.to;
+  if (proxy && through) {
+    const p = targetPathPrefix(f.path);
+    return `Which repo serves the routes under ${p === "/" ? "" : p}/** that ${proxy} forwards to ${through}?`;
+  }
   return `Which repo or system answers the calls ${repo} makes under ${targetPathPrefix(f.path)}${groupVia(f)}?`;
 }
+function proxyOf(f, facts) {
+  if (!f.from)
+    return void 0;
+  const from = facts.find((x) => x.id === f.from);
+  if (!from || from.kind !== "entry")
+    return void 0;
+  const proxy = facts.find((x) => x.kind === "deploy" && x.repo === f.repo && x.platform === "apigee" && !!x.basePath);
+  return proxy ? proxy.resourceName ?? f.repo : void 0;
+}
+function targetGroupWordings(repo, f, facts) {
+  return [.../* @__PURE__ */ new Set([targetGroupQuestion(repo, f, facts), targetGroupQuestion(repo, f)])];
+}
+var repo0 = (members) => members[0].f.repo;
 var byLine = (a, b) => a.localeCompare(b, "en", { numeric: true });
-var answerLabel = (q) => q.answer?.option !== void 0 ? q.options[q.answer.option - 1]?.label : q.answer?.text;
+var answerLabel2 = (q) => q.answer?.option !== void 0 ? q.options[q.answer.option - 1]?.label : q.answer?.text;
 function splitTargetGroups(questions) {
-  return new Set(questions.filter((q) => q.askedBy?.step === TARGETS_STEP && q.state === "answered" && answerLabel(q) === TARGETS_SPLIT).map((q) => q.question.trim()));
+  return new Set(questions.filter((q) => q.askedBy?.step === TARGETS_STEP && q.state === "answered" && answerLabel2(q) === TARGETS_SPLIT).map((q) => q.question.trim()));
 }
 function groupedTargetDrafts(facts, records, op, asks, o) {
-  const { list, repoOf } = targetAsks(facts, records, asks);
-  const own = new Map(targetQuestionDrafts(facts, records, op, asks).map((d) => [d.factId, d]));
+  const { list } = targetAsks(facts, records, asks);
+  const ctx = {
+    ...o.estate ? { estate: o.estate } : {},
+    ...o.questions ? { questions: o.questions } : {}
+  };
+  const own = new Map(targetQuestionDrafts(facts, records, op, asks, ctx).map((d) => [d.factId, d]));
   const groups = /* @__PURE__ */ new Map();
   for (const a of list) {
     if (!o.ask.has(a.f.id))
       continue;
-    const k = targetGroupQuestion(a.f.repo, a.f);
+    const k = targetGroupQuestion(a.f.repo, a.f, facts);
     groups.set(k, [...groups.get(k) ?? [], a]);
   }
-  const vendors = vendorsOf(op);
   const out = [];
   for (const [question, members] of groups) {
-    if (members.length === 1 || o.split?.has(question)) {
+    const split = targetGroupWordings(repo0(members), members[0].f, facts).some((w) => o.split?.has(w));
+    if (members.length === 1 || split) {
       for (const m of members)
         out.push({ ...own.get(m.f.id), factIds: [m.f.id] });
       continue;
@@ -1652,21 +2068,12 @@ function groupedTargetDrafts(facts, records, op, asks, o) {
     const whats = [...new Set(members.map((m) => callWhat(m.f)))];
     const listed = whats.length > 5 ? `${whats.slice(0, 5).join(", ")} and ${whats.length - 5} more` : whats.join(", ");
     const n = members.length;
-    const servers = [...new Set(members.flatMap((m) => m.servers))].sort();
     const evidence = [...new Set(members.flatMap((m) => m.q.evidence))].sort(byLine);
     const draft = {
       question,
       options: [
-        ...servers.map((c) => ({
-          label: c,
-          means: `${c}${repoOf.get(c) ? `, built in ${repoOf.get(c)},` : ""} answers all ${n} calls: ${listed}`,
-          changes: `The ${n} calls join ${c} when the facts are next written (atticus verify ${repo} --write)`
-        })),
-        ...vendors.map((s) => ({
-          label: s.id,
-          means: `${s.name}, ${outsideAs(s)}, answers all ${n} calls: ${listed}`,
-          changes: `The ${n} calls go to ${s.name} when the facts are next written`
-        })),
+        ...offered(members, facts, records, op, asks, ctx).map((s) => suggestionOption(s, repo, n, targetPathPrefix(members[0].f.path))),
+        anotherOption(op),
         {
           label: TARGETS_SPLIT,
           means: `The ${n} calls (${listed}) don't all go to one place`,
@@ -1691,6 +2098,40 @@ function groupedTargetDrafts(facts, records, op, asks, o) {
   }
   return out.sort((a, b) => a.factId.localeCompare(b.factId));
 }
+function targetRuleOffers(questions, factsOf) {
+  const byKey = /* @__PURE__ */ new Map();
+  for (const q of questions) {
+    if (q.state !== "open" || q.askedBy?.step !== TARGETS_STEP)
+      continue;
+    const facts = factsOf(q.repo) ?? [];
+    const at3 = new Set(q.evidence);
+    const calls = facts.filter((f) => f.kind === "call" && f.repo === q.repo && at3.has(`${f.cite.file}:${f.cite.line}`));
+    if (!calls.length)
+      continue;
+    const prefixes = new Set(calls.map((c) => targetPathPrefix(c.path)));
+    const hosts = new Set(calls.map((c) => c.host?.replace(/^[a-z][a-z0-9+.-]*:\/\//i, "").split(/[/:]/)[0]));
+    const [prefix] = prefixes;
+    const [host] = hosts;
+    const match = prefixes.size === 1 && prefix !== "/" ? `${prefix}/**` : hosts.size === 1 && host ? host : void 0;
+    if (!match)
+      continue;
+    const key = `${q.repo}
+${match}`;
+    const x = byKey.get(key) ?? { match, ids: [], calls: 0 };
+    x.ids.push(q.id);
+    x.calls += calls.length;
+    byKey.set(key, x);
+  }
+  const out = /* @__PURE__ */ new Map();
+  for (const x of byKey.values()) {
+    if (x.ids.length < 2)
+      continue;
+    const ids = [...x.ids].sort();
+    for (const id of ids)
+      out.set(id, { match: x.match, ids, calls: x.calls });
+  }
+  return out;
+}
 var segmentsOf = (p) => p.split(/[?#]/)[0].split("/").filter(Boolean).map((x) => /^[{:<]/.test(x) ? "{}" : x);
 function ruleCoversCall(match, f, facts) {
   if (isPathMatch(match)) {
@@ -1711,7 +2152,7 @@ function ruledTargets(repo, facts, questions, o = {}) {
     if (!needsTarget(f, facts))
       continue;
     const q = rules.find((r) => ruleCoversCall(r.answer.match, f, facts));
-    const label2 = q ? answerLabel(q) : void 0;
+    const label2 = q ? answerLabel2(q) : void 0;
     if (q && label2 && label2 !== TARGETS_SPLIT)
       out.set(f.id, { id: q.id, match: q.answer.match, label: label2 });
   }
@@ -1732,13 +2173,13 @@ function targetsFromAnswers(repo, facts, questions, o = {}) {
       continue;
     let asked = byId.get(questionId({ step: TARGETS_STEP, repo, ...q }));
     if (!asked || asked.state !== "answered" || !asked.answer) {
-      const g = groups.get(targetGroupQuestion(repo, f));
+      const g = targetGroupWordings(repo, f, facts).map((w) => groups.get(w)).find((x) => !!x);
       asked = g && (needsTarget(f, facts) || g.evidence.includes(q.evidence[0])) ? g : void 0;
     }
-    let label2 = asked && asked.state === "answered" && asked.answer ? answerLabel(asked) : void 0;
-    if (!label2 || label2 === TARGETS_SPLIT)
+    let label2 = asked && asked.state === "answered" && asked.answer ? answerLabel2(asked) : void 0;
+    if (!label2 || label2 === TARGETS_SPLIT || label2 === TARGETS_ANOTHER)
       label2 = ruled.get(f.id)?.label;
-    if (!label2 || label2 === TARGETS_SPLIT)
+    if (!label2 || label2 === TARGETS_SPLIT || label2 === TARGETS_ANOTHER)
       continue;
     if (label2 === TARGETS_NONE) {
       out[f.id] = NO_TARGET;
@@ -1750,6 +2191,23 @@ function targetsFromAnswers(repo, facts, questions, o = {}) {
   }
   return out;
 }
+function answeredQuestionOfCall(repo, facts, questions, factId) {
+  const f = facts.find((x) => x.id === factId);
+  if (!f || f.kind !== "call")
+    return void 0;
+  const own = targetQuestionFor(f);
+  const ownId = questionId({ step: TARGETS_STEP, repo, ...own });
+  const answered = questions.filter((q2) => q2.askedBy?.step === TARGETS_STEP && q2.state === "answered" && q2.repo === repo);
+  const q = answered.find((x) => x.id === ownId) ?? answered.find((x) => targetGroupWordings(repo, f, facts).includes(x.question.trim()) && x.evidence.includes(own.evidence[0]));
+  return q?.answer?.match ? void 0 : q;
+}
+function answerReconfirmed(q) {
+  if (!q.answer || !q.reopened)
+    return false;
+  const now2 = answerLabel2(q);
+  const was = answerLabel2({ ...q, answer: q.reopened.answer });
+  return !!now2 && !!was && slugify(now2) === slugify(was);
+}
 var JOINED_BY = {
   named: "the call names it",
   repo: "the call names its repo",
@@ -1763,7 +2221,7 @@ function callsOfTargetQuestion(repo, facts, q) {
     const own = targetQuestionFor(f);
     if (questionId({ step: TARGETS_STEP, repo, ...own }) === q.id)
       return true;
-    return targetGroupQuestion(repo, f) === q.question.trim() && q.evidence.includes(own.evidence[0]);
+    return targetGroupWordings(repo, f, facts).includes(q.question.trim()) && q.evidence.includes(own.evidence[0]);
   });
 }
 function staleTargetQuestions(input) {
@@ -2055,7 +2513,9 @@ function catalogWithFacts(given) {
   const remap = /* @__PURE__ */ new Map();
   const stepTo = /* @__PURE__ */ new Map();
   let join10;
+  let answerMisses;
   let estateJoin;
+  let terms;
   let records0 = [...kept2, ...newRecords];
   if (input.estate) {
     const repos = joinReposOf(op, [{ repo, facts }, ...others], renames);
@@ -2069,6 +2529,16 @@ function catalogWithFacts(given) {
     });
     join10 = joinAbout(whole, repo);
     estateJoin = { whole, repos };
+    const named2 = { ...input.estateTargets, [repo]: input.targets ?? {} };
+    const mine2 = /* @__PURE__ */ new Set([
+      factIdPart(repo),
+      ...repos.filter((r) => r.repo === repo).flatMap((r) => [r.component, ...(r.modules ?? []).map((m) => m.component)]).filter((x) => !!x).map(factIdPart),
+      ...facts.flatMap((f) => f.component ? [factIdPart(f.component)] : [])
+    ]);
+    answerMisses = whole.misses.filter((m) => {
+      const t = named2[m.call.repo]?.[m.call.fact];
+      return !!t && t !== NO_TARGET && (m.call.repo === repo || mine2.has(factIdPart(m.target)));
+    });
     records0 = applyFactJoins(records0, join10, repos, {
       callers: joinCallers({
         repos,
@@ -2079,6 +2549,8 @@ function catalogWithFacts(given) {
       join: whole,
       only: [repo]
     });
+    terms = joinTerms({ repos, join: whole, bundleFolders: joinConventions(op).bundleFolders });
+    records0 = [...records0, ...termGrantRecords(terms, repos, { only: [repo] })];
     for (const j of join10.joins) {
       const id = j.call.repo === repo ? projected.ids[j.call.fact] : void 0;
       if (!id || remap.has(id))
@@ -2185,7 +2657,9 @@ function catalogWithFacts(given) {
     notes: merged.notes,
     ...join10 ? { join: join10 } : {},
     ...linkEvidence ? { linkEvidence } : {},
-    ...sharedWhole ? { shared: sharedJoinAbout(sharedWhole, repo) } : {}
+    ...sharedWhole ? { shared: sharedJoinAbout(sharedWhole, repo) } : {},
+    ...terms ? { terms } : {},
+    ...answerMisses?.length ? { answerMisses } : {}
   };
 }
 function prototypeLeftOut(input) {
@@ -2238,6 +2712,61 @@ function estateFromFacts(input) {
   });
   return { records, specs, join: join10, invalid };
 }
+function answerRuleOffers(input) {
+  const ruled = input.questions.filter((q) => q.askedBy?.step === TARGETS_STEP && q.state === "answered" && !!q.answer?.match);
+  const groups = /* @__PURE__ */ new Map();
+  for (const r of input.repos)
+    for (const f of r.facts) {
+      if (f.kind !== "call")
+        continue;
+      const q = answeredQuestionOfCall(r.repo, r.facts, input.questions, f.id);
+      const label2 = q ? answerLabel2(q) : void 0;
+      if (!q || !label2 || label2 === TARGETS_NONE || label2 === TARGETS_SPLIT || label2 === TARGETS_ANOTHER)
+        continue;
+      const url = urlOf(f, r.facts);
+      const host = url ? urlHostPort(url)?.host : void 0;
+      const via = host ? `on ${host.toLowerCase()}` : f.base ? `through ${f.base}` : void 0;
+      if (!via)
+        continue;
+      groups.set(via, [
+        ...groups.get(via) ?? [],
+        { repo: r.repo, q, label: label2, f, facts: r.facts, ...r.type ? { type: r.type } : {} }
+      ]);
+    }
+  const out = [];
+  for (const [via, xs] of [...groups].sort(([a], [b]) => a.localeCompare(b))) {
+    const repos = [...new Set(xs.map((x) => x.repo))].sort();
+    const labels = new Set(xs.map((x) => slugify(x.label)));
+    if (repos.length < 2 || labels.size !== 1)
+      continue;
+    if (xs.every((x) => ruled.some((q) => ruleCoversCall(q.answer.match, x.f, x.facts))))
+      continue;
+    const label2 = xs[0].label;
+    const prefixes = new Set(xs.map((x) => targetPathPrefix(x.f.path)));
+    const prefix = prefixes.size === 1 ? [...prefixes][0] : void 0;
+    const match = via.startsWith("on ") ? via.slice(3) : prefix && prefix !== "/" ? `${prefix}/**` : void 0;
+    const types = new Set(xs.map((x) => x.type));
+    const type = types.size === 1 ? xs[0].type : void 0;
+    const questions = [...new Set(xs.map((x) => x.q.id))].sort();
+    const first = xs.find((x) => x.q.id === questions[0]).q;
+    const n = first.options.findIndex((o) => o.label === label2);
+    const pick = n >= 0 ? `--option ${n + 1}` : `--text "${label2}"`;
+    if (!match || !type)
+      continue;
+    const command = `atticus questions answer ${first.id} ${pick} --match ${match} --scope repo-type --type ${type}`;
+    out.push({
+      via,
+      label: label2,
+      repos,
+      questions,
+      match,
+      type,
+      command,
+      line: `${repos.length} repos (${repos.join(", ")}) answer the calls ${via} the same way, ${label2} (${questions.join(", ")}): one answer can say it for every ${type} repo. As a rule: ${command}.`
+    });
+  }
+  return out;
+}
 
 // packages/scanner/dist/facts-scan.js
 async function factsForScan(root, op, repo, commit, readerRecords, at3 = {}) {
@@ -2422,8 +2951,8 @@ async function checkScanSettings(s, repo) {
     if (!(isConfigFile(file) && names)) {
       const dropped = code.filter((f) => re.test(f));
       const root = mainRoots.find((d) => {
-        const under = code.filter((f) => f.startsWith(`${d}/`));
-        return under.length && under.every((f) => re.test(f));
+        const under2 = code.filter((f) => f.startsWith(`${d}/`));
+        return under2.length && under2.every((f) => re.test(f));
       });
       const why = " so it is still read; only a build or config file that leaves it out itself can say so";
       if (dropped.length * 2 > code.length) {
@@ -3329,8 +3858,8 @@ async function resolveSettingsTemplate(t, repo, repoId) {
       out.exclude.push({ path: e.path, why: e.why, at: `${first}:1` });
   }
   for (const rule of t.settings.prefixes) {
-    const candidates = (await files.matching(rule.files)).sort((a, b) => a.length - b.length || a.localeCompare(b));
-    for (const f of candidates) {
+    const candidates2 = (await files.matching(rule.files)).sort((a, b) => a.length - b.length || a.localeCompare(b));
+    for (const f of candidates2) {
       const hit = await readRule(rule, f, files);
       if (!hit)
         continue;
@@ -4054,7 +4583,7 @@ function parseEntry(s) {
   const m = /^([A-Za-z]+)\s+(\S+)$/.exec(s.trim());
   return m ? { method: m[1].toUpperCase(), path: m[2] } : { path: s.trim() };
 }
-var segs = (p) => normalizePath(p).toLowerCase().split("/").filter(Boolean);
+var segs2 = (p) => normalizePath(p).toLowerCase().split("/").filter(Boolean);
 var sameMethod = (a, b) => !a || !b || a.toUpperCase() === b.toUpperCase();
 async function joinEstate(o) {
   const byId = new Map(o.records.map((r) => [r.id, r]));
@@ -4066,8 +4595,8 @@ async function joinEstate(o) {
     const out = [i.normalizedPath];
     const route = i.route ? byId.get(i.route) : void 0;
     if (route?.kind === "GatewayRoute") {
-      const base2 = segs(route.basepath);
-      const p = segs(i.normalizedPath);
+      const base2 = segs2(route.basepath);
+      const p = segs2(i.normalizedPath);
       if (base2.length && base2.every((s, k) => p[k] === s))
         out.push(`/${p.slice(base2.length).join("/")}`);
     }
@@ -4182,27 +4711,27 @@ async function joinEstate(o) {
           within = "estate";
           hits = servingExactly(flow.component, want);
         }
-        const candidates = [...new Set(hits.map((e) => e.component))].sort();
-        if (candidates.length === 0) {
+        const candidates2 = [...new Set(hits.map((e) => e.component))].sort();
+        if (candidates2.length === 0) {
           miss({
             reason: "no-target",
             message: `${s.to.component} isn't a component in the catalog, and neither an Interface from ${flow.component} nor an entry point of the estate serves ${s.to.entry}`
           });
           continue;
         }
-        if (candidates.length > 1) {
-          const repos = [...new Set(candidates.map(repoOfComponent))];
+        if (candidates2.length > 1) {
+          const repos = [...new Set(candidates2.map(repoOfComponent))];
           const of = repos.length === 1 && repos[0] ? repos[0] : "the estate";
           miss({
             reason: "no-target",
-            message: `${s.to.component} isn't a component in the catalog, and ${candidates.length} components of ${of} serve ${s.to.entry} (${candidates.join(", ")}): a person says which`
+            message: `${s.to.component} isn't a component in the catalog, and ${candidates2.length} components of ${of} serve ${s.to.entry} (${candidates2.join(", ")}): a person says which`
           });
           asks.push({
             from,
             caller: flow.component,
             named: s.to.component,
             what: s.to.entry,
-            candidates
+            candidates: candidates2
           });
           continue;
         }
@@ -4430,6 +4959,17 @@ function fieldLineage(f, field) {
 }
 
 // packages/scanner/dist/hosts-asked.js
+var segs3 = (p) => p.split(/[?#]/)[0].split("/").filter(Boolean).map((x) => /^[{:<$]/.test(x) ? "{}" : x);
+var underPath = (path, base2) => {
+  const b = segs3(base2);
+  const c = segs3(path);
+  return b.length > 0 && b.length <= c.length && b.every((x, i) => x === c[i]);
+};
+var servesPath = (entry, path) => {
+  const e = segs3(entry);
+  const c = segs3(path);
+  return e.length === c.length && e.every((x, i) => x === "{}" || c[i] === "{}" || x === c[i]);
+};
 var HTTP_TYPES = /* @__PURE__ */ new Set(["rest", "graphql", "soap", "websocket", "sse", "webhook"]);
 var CONFIG_FILES = [
   "**/application*.properties",
@@ -4492,8 +5032,12 @@ async function unknownHosts(o) {
     const entry = byHost.get(h.label) ?? {
       ...h.port !== void 0 ? { port: h.port } : {},
       explicit: h.label !== h.host,
-      calls: []
+      calls: [],
+      paths: /* @__PURE__ */ new Set()
     };
+    const path = /^[a-z][a-z0-9+.-]*:\/\/[^/?#]*(\/[^?#]*)?/i.exec(url)?.[1];
+    if (path)
+      entry.paths.add(path);
     const at3 = `${e.path}:${e.line}`;
     if (!entry.calls.some((c) => c.repo === repo && c.at === at3))
       entry.calls.push({ repo, at: at3 });
@@ -4546,6 +5090,25 @@ async function unknownHosts(o) {
       }
     const suggest = hits.length === 1 ? hits[0] : void 0;
     const calls = entry.calls.sort((a, b) => a.repo.localeCompare(b.repo) || a.at.localeCompare(b.at, "en", { numeric: true }));
+    const byPath = [];
+    for (const g of o.records) {
+      if (g.kind !== "GatewayRoute")
+        continue;
+      const repo = g.evidence.find((e) => e.repo)?.repo;
+      if (!repo || byPath.some((b) => b.repo === repo))
+        continue;
+      const under2 = [...entry.paths].filter((p) => underPath(p, g.basepath));
+      if (!under2.length)
+        continue;
+      const comps = new Set([...compRepo].filter(([, r]) => r === repo).map(([c]) => c));
+      const hit = o.records.find((r) => r.kind === "Endpoint" && comps.has(r.component) && under2.some((p) => servesPath(r.pathOrTopic, p)));
+      byPath.push({
+        repo,
+        serves: hit ? [hit.method?.toUpperCase(), hit.pathOrTopic].filter(Boolean).join(" ") : `the routes under ${g.basepath}`
+      });
+    }
+    byPath.sort((a, b) => a.repo.localeCompare(b.repo));
+    const first = suggest ? [suggest.repo] : byPath.map((b) => b.repo).filter((x) => servers.includes(x));
     const about = Object.fromEntries(servers.flatMap((s) => {
       const d = o.repos.find((r) => r.id === s)?.description;
       return d ? [[s, { text: d.text, trust: d.trust }]] : [];
@@ -4553,9 +5116,10 @@ async function unknownHosts(o) {
     asks.push({
       host,
       calls,
-      servers: suggest ? [suggest.repo, ...servers.filter((s) => s !== suggest.repo)] : servers,
+      servers: [...first, ...servers.filter((s) => !first.includes(s))],
       ...suggest ? { suggest } : {},
-      ...Object.keys(about).length ? { about } : {}
+      ...Object.keys(about).length ? { about } : {},
+      ...byPath.length ? { byPath } : {}
     });
   }
   return asks;
@@ -4566,18 +5130,24 @@ function aboutOf(a, repo) {
     return "";
   return d.trust === "suggested" ? `. What it is, as your assistant drafted it (unconfirmed): ${d.text}` : `. What it is: ${d.text}`;
 }
+function gatewayHostFix(host, byPath) {
+  const repos = byPath.map((b) => b.repo);
+  return `${repos.length === 1 ? `${repos[0]}'s routes serve` : `The routes of ${repos.join(", ")} serve`} the paths the calls to ${host} make, and no repo lists ${host}: it looks like a shared gateway's host. Once, not per call: list ${host} under hosts: on each proxy repo in repos.manifest.yaml (${repos.join(", ")}, and any other proxy on it); the path then picks the proxy, and this question retires itself`;
+}
 function hostQuestionDrafts(asks) {
   return asks.map((a) => {
     const repo = a.calls[0].repo;
+    const byPath = new Map((a.byPath ?? []).map((b) => [b.repo, b.serves]));
     return {
       repo,
+      ...a.byPath?.length ? { byPath: a.byPath } : {},
       draft: {
         question: hostQuestionText(a.host),
         options: [
           ...a.servers.map((s) => ({
             label: s,
-            means: (a.suggest?.repo === s ? `${s} serves HTTP, and its ${a.suggest.at} sets the port ${a.host.split(":").pop()} (${a.suggest.line})` : `${s} serves HTTP`) + aboutOf(a, s),
-            changes: `${a.host} goes under hosts for ${s} in repos.manifest.yaml, and the calls to it join ${s} on the next scan`
+            means: (a.suggest?.repo === s ? `${s} serves HTTP, and its ${a.suggest.at} sets the port ${a.host.split(":").pop()} (${a.suggest.line})` : byPath.has(s) ? `${s} serves ${byPath.get(s)}, a path the calls to ${a.host} make` : `${s} serves HTTP`) + aboutOf(a, s),
+            changes: byPath.has(s) ? `${a.host} goes under hosts for ${s} in repos.manifest.yaml, and the calls to it join ${s} on the next scan; on a shared gateway host, list it on each proxy repo instead (${[...byPath.keys()].join(", ")}, and any other proxy on it), and the path picks the proxy` : `${a.host} goes under hosts for ${s} in repos.manifest.yaml, and the calls to it join ${s} on the next scan`
           })),
           // O1: a system outside the estate, declared in the profile with the host as its alias.
           ...[
@@ -4696,12 +5266,12 @@ function parseLinkReference(source) {
   return { ok: true, reference: { ...estate ? { estate } : {}, repos } };
 }
 var stripped = (o) => Object.fromEntries(Object.entries(o).filter(([, v]) => v !== void 0));
-function segs2(path) {
+function segs4(path) {
   return path.split(/[?#]/)[0].split("/").filter(Boolean).map((s) => /^(\{[^}]*\}|:\w+|\*)$/.test(s) ? "{}" : s.toLowerCase());
 }
 function pathMatch(a, b) {
-  const x = segs2(a);
-  const y = segs2(b);
+  const x = segs4(a);
+  const y = segs4(b);
   if (x.length === y.length && x.every((s, i) => s === y[i]))
     return 2;
   const [short, long] = x.length < y.length ? [x, y] : [y, x];
@@ -4996,19 +5566,33 @@ export {
   estateMergeInput,
   mergeEstate,
   curatedDirOf,
+  TARGETS_MAX_SUGGESTED,
+  TARGETS_ANOTHER,
+  TARGETS_NO_EVIDENCE,
+  nameWords,
+  targetSuggestions,
+  offeredSuggestions,
+  targetPicker,
+  pickerLines,
+  topicQuestionDrafts,
   TARGETS_STEP,
   TARGETS_NONE,
   remapIds,
   targetQuestionFor,
+  suggestionWhy,
   targetQuestionDrafts,
   TARGETS_SPLIT,
   targetPathPrefix,
   targetGroupQuestion,
+  targetGroupWordings,
   splitTargetGroups,
   groupedTargetDrafts,
+  targetRuleOffers,
   ruleCoversCall,
   ruledTargets,
   targetsFromAnswers,
+  answeredQuestionOfCall,
+  answerReconfirmed,
   staleTargetQuestions,
   componentRenames,
   factsRecords,
@@ -5020,6 +5604,7 @@ export {
   catalogWithFacts,
   prototypeLeftOut,
   estateFromFacts,
+  answerRuleOffers,
   factsForScan,
   estateFacts,
   NO_SETTINGS,
@@ -5063,6 +5648,7 @@ export {
   fieldLineage,
   lineSetsPort,
   unknownHosts,
+  gatewayHostFix,
   hostQuestionDrafts,
   parseLinkReference,
   measureLinks,