@maycombhq/atticus 2.0.0-beta.26 → 2.0.0-beta.27.1

package/dist/{chunk-K3QKOVZN.js → chunk-N5DLB74D.js}

@@ -6,11 +6,7 @@ var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
 import {
   boundedId,
   opt
-} from "./chunk-QAFQLILX.js";
-import {
-  curatedAliases,
-  resolveNames
-} from "./chunk-HQMLY2R6.js";
+} from "./chunk-IPSZDVLI.js";
 import {
   DATA_RULE,
   INSTRUCTION_RULES,
@@ -27,9 +23,14 @@ import {
   toRunSummary,
   verdictOf,
   wrapData
-} from "./chunk-ZDA72732.js";
+} from "./chunk-2MRYL45Z.js";
+import {
+  curatedAliases,
+  resolveNames
+} from "./chunk-ELJ5Q4J2.js";
 import {
   JOINED_BY_PERSON,
+  byDecisionTime,
   deserializeRecord,
   estimateTokens,
   isAdopted,
@@ -47,10 +48,10 @@ import {
   recordPath,
   serializeRecord,
   toCanonicalYaml
-} from "./chunk-6ZDAEUKB.js";
+} from "./chunk-WJWSB65O.js";
 import {
   writeFileAtomic
-} from "./chunk-MEMEO7YO.js";
+} from "./chunk-SMFFUFMN.js";
 import {
   AgentDefinition,
   ChecklistPack,
@@ -72,10 +73,10 @@ import {
   pageStanding,
   platformsMatch,
   sourceReadsPage
-} from "./chunk-LZFKJ2BR.js";
+} from "./chunk-A3LVMCA5.js";
 import {
   SCHEMA_VERSION
-} from "./chunk-CTJHEG6A.js";
+} from "./chunk-NWMFVPEP.js";
 import {
   require_dist
 } from "./chunk-BQGDB6ZL.js";
@@ -2024,14 +2025,20 @@ var FlowGraph = class {
   }
   /** Words that name the component or its system: they say where code is, not what it does. */
   ownWords(component) {
+    let own = this.ownMemo.get(component);
+    if (own)
+      return new Set(own);
     const s2 = this.systemOf(component);
     const sys = s2 ? this.systems.get(s2) : void 0;
-    return tokens([
+    own = tokens([
       ...splitWords(component),
       ...s2 ? splitWords(s2) : [],
       ...sys ? splitWords(sys.name) : []
     ]);
+    this.ownMemo.set(component, own);
+    return new Set(own);
   }
+  ownMemo = /* @__PURE__ */ new Map();
   /** The system's name as one singular word for job names (Reports → report), if it has one. */
   systemWord(component) {
     const s2 = this.systemOf(component);
@@ -2065,12 +2072,27 @@ var DEFAULT_DEPTH = 8;
 var WRITES = /* @__PURE__ */ new Set(["POST", "PUT", "PATCH", "DELETE"]);
 var modeOf = (method) => !method ? "any" : WRITES.has(method.toUpperCase()) ? "write" : "read";
 var union = (a, b) => /* @__PURE__ */ new Set([...a, ...b]);
+var unionNew = (a, b) => {
+  for (const x of b)
+    if (!a.has(x))
+      return union(a, b);
+  return a;
+};
 var sorted = (s2) => [...s2].sort();
 var Tracer = class {
   maxDepth;
   g;
   claimed = /* @__PURE__ */ new Map();
   entriesAt = /* @__PURE__ */ new Map();
+  // Memos (ADR 0195 point 9, the budgets): the graph never changes after the constructor, so a
+  // hop's, a call's, a table's and a component's words are worked out once, not on every trace
+  // that passes them. The sets are never handed out to be changed (a flow's words are a union).
+  hopMemo = /* @__PURE__ */ new Map();
+  callMemo = /* @__PURE__ */ new Map();
+  tableMemo = /* @__PURE__ */ new Map();
+  outsMemo = /* @__PURE__ */ new Map();
+  /** How many starts each component has, for the entry points in play (reset with them). */
+  startsMemo = /* @__PURE__ */ new Map();
   constructor(records, maxDepth = DEFAULT_DEPTH) {
     this.maxDepth = maxDepth;
     this.g = new FlowGraph(records);
@@ -2191,6 +2213,7 @@ var Tracer = class {
   useEntries(entries) {
     this.entriesAt.clear();
     this.claimed.clear();
+    this.startsMemo.clear();
     for (const e of entries) {
       const l = this.entriesAt.get(e.component) ?? [];
       l.push(e);
@@ -2198,10 +2221,116 @@ var Tracer = class {
     }
   }
   hopTokens(i) {
-    return tokens(i.sync === "async" ? topicWords(i.normalizedPath) : pathWords(i.normalizedPath));
+    let t = this.hopMemo.get(i);
+    if (!t) {
+      t = tokens(i.sync === "async" ? topicWords(i.normalizedPath) : pathWords(i.normalizedPath));
+      this.hopMemo.set(i, t);
+    }
+    return t;
   }
   callTokens(i) {
-    return union(this.hopTokens(i), this.g.classTokens(i.evidence, this.g.ownWords(i.from), ["caller"]));
+    let t = this.callMemo.get(i);
+    if (!t) {
+      t = union(this.hopTokens(i), this.g.classTokens(i.evidence, this.g.ownWords(i.from), ["caller"]));
+      this.callMemo.set(i, t);
+    }
+    return t;
+  }
+  tableTokens(t) {
+    let x = this.tableMemo.get(t);
+    if (!x) {
+      x = tokens(splitWords(t.name));
+      this.tableMemo.set(t, x);
+    }
+    return x;
+  }
+  /** A component's calls and events out, by id (the graph's `outOf`, kept). */
+  outsOf(component) {
+    let o = this.outsMemo.get(component);
+    if (!o) {
+      o = this.g.outOf(component);
+      this.outsMemo.set(component, o);
+    }
+    return o;
+  }
+  /**
+   * The calls and events out of each component by word (a trace follows the ones sharing a
+   * word with it: `outs.filter((i) => overlaps(toks, this.callTokens(i)))`).
+   */
+  outWordsMemo = /* @__PURE__ */ new Map();
+  /**
+   * Which of `items` share a word with `toks` (`hit[k]` is 1 where `overlaps(toks, wordsOf(x))`),
+   * and how many, through an index of a component's items by word (kept in `memo`), so a trace
+   * looks up its words instead of comparing them with every item. `items` must be the same list
+   * for the same component every time.
+   */
+  sharingHits(memo, component, items, toks, wordsOf) {
+    let hit = this.hitBufs.get(memo);
+    if (!hit || hit.length < items.length) {
+      hit = new Uint8Array(Math.max(items.length, 2 * (hit?.length ?? 32)));
+      this.hitBufs.set(memo, hit);
+    } else
+      hit.fill(0, 0, items.length);
+    let n = 0;
+    if (items.length < 8) {
+      for (let k = 0; k < items.length; k++)
+        if (overlaps(toks, wordsOf(items[k]))) {
+          hit[k] = 1;
+          n++;
+        }
+      return { hit, n };
+    }
+    let idx = memo.get(component);
+    if (!idx) {
+      idx = /* @__PURE__ */ new Map();
+      items.forEach((x, k) => {
+        for (const t of wordsOf(x)) {
+          const l = idx.get(t);
+          if (l)
+            l.push(k);
+          else
+            idx.set(t, [k]);
+        }
+      });
+      memo.set(component, idx);
+    }
+    words: for (const t of toks) {
+      const l = idx.get(t);
+      if (!l)
+        continue;
+      for (const k of l)
+        if (!hit[k]) {
+          hit[k] = 1;
+          if (++n === items.length)
+            break words;
+        }
+    }
+    return { hit, n };
+  }
+  hitBufs = /* @__PURE__ */ new Map();
+  /** A component's calls and events out as numbers: id, endpoint (or -1), callee, each. */
+  outsIxOf(component, outs) {
+    let x = this.outsIxMemo.get(component);
+    if (!x) {
+      x = new Int32Array(outs.length * 3);
+      outs.forEach((i, k) => {
+        x[k * 3] = this.indexOf(i.id);
+        x[k * 3 + 1] = i.endpoint ? this.indexOf(i.endpoint) : -1;
+        x[k * 3 + 2] = this.indexOf(i.to);
+      });
+      this.outsIxMemo.set(component, x);
+    }
+    return x;
+  }
+  outsIxMemo = /* @__PURE__ */ new Map();
+  tableWordsMemo = /* @__PURE__ */ new Map();
+  startCount(component) {
+    let n = this.startsMemo.get(component);
+    if (n === void 0) {
+      n = this.starts(component).length;
+      this.startsMemo.set(component, n);
+    }
+    return n;
   }
   /** Where work starts at a component: its entry points and the calls and events into it. */
   starts(component) {
@@ -2219,78 +2348,176 @@ var Tracer = class {
       c = /* @__PURE__ */ new Set();
       const starts = this.starts(component);
       for (const u of this.g.tables.get(component) ?? [])
-        if (starts.some((t) => overlaps(t, tokens(splitWords(u.table.name)))))
+        if (starts.some((t) => overlaps(t, this.tableTokens(u.table))))
           c.add(u.table.id);
       this.claimed.set(component, c);
     }
     return c;
   }
-  tablesFor(component, toks, mode) {
-    const uses = [...this.g.tables.get(component) ?? []];
-    const named = uses.filter((u) => overlaps(toks, tokens(splitWords(u.table.name))));
-    if (named.length)
-      return named;
+  /** Whether a component (by its number) is our own: `g.isOwn`, kept. */
+  ownAt(k, id) {
+    let o = this.ownMark[k];
+    if (o === void 0) {
+      o = this.g.isOwn(id) ? 1 : 0;
+      this.ownMark[k] = o;
+    }
+    return o === 1;
+  }
+  ownMark = [];
+  /**
+   * The tables a flow takes at a component, each given to `add` by its number, in the order of
+   * the component's tables: those that share a word with the flow's words, else the ones no
+   * start there claims that the flow's mode reads or writes (any, for "any").
+   */
+  tablesIx(component, toks, mode, add) {
+    const uses = this.g.tables.get(component);
+    if (!uses?.length)
+      return;
+    let tix = this.tablesIxMemo.get(component);
+    if (!tix) {
+      tix = Int32Array.from(uses, (u) => this.indexOf(u.table.id));
+      this.tablesIxMemo.set(component, tix);
+    }
+    const { hit, n } = this.sharingHits(this.tableWordsMemo, component, uses, toks, (u) => this.tableTokens(u.table));
+    if (n) {
+      for (let k = 0; k < uses.length; k++)
+        if (hit[k])
+          add(tix[k]);
+      return;
+    }
     const claimed = this.claimedAt(component);
-    return uses.filter((u) => !claimed.has(u.table.id) && (mode === "any" || (mode === "write" ? u.write : u.read)));
+    for (let k = 0; k < uses.length; k++) {
+      const u = uses[k];
+      if (!claimed.has(u.table.id) && (mode === "any" || (mode === "write" ? u.write : u.read)))
+        add(tix[k]);
+    }
+  }
+  tablesIxMemo = /* @__PURE__ */ new Map();
+  // A trace marks what it holds by number (ADR 0195 point 9: a flow of a big estate holds
+  // thousands of ids, and thousands of flows are traced): each id once, in the order a trace
+  // first adds it, as a Set of the ids would hold them.
+  ids = [];
+  ixOf = /* @__PURE__ */ new Map();
+  recMark = [];
+  reachMark = [];
+  queuedMark = [];
+  pass = 0;
+  /** The number a trace marks this id by. */
+  indexOf(id) {
+    let k = this.ixOf.get(id);
+    if (k === void 0) {
+      k = this.ids.length;
+      this.ids.push(id);
+      this.ixOf.set(id, k);
+    }
+    return k;
+  }
+  /** The id of a number `indexOf` gave. */
+  idOf(k) {
+    return this.ids[k];
   }
   trace(entry) {
-    const g = this.g;
-    const flow = {
+    const f = this.traceIx(entry, true);
+    return {
       entry,
-      records: /* @__PURE__ */ new Set([entry.id, entry.component]),
-      reached: /* @__PURE__ */ new Set([entry.id]),
-      visits: [],
-      hops: []
+      records: new Set(Array.from(f.records, (k) => this.idOf(k))),
+      reached: new Set(Array.from(f.reached, (k) => this.idOf(k))),
+      visits: f.visits,
+      hops: f.hops
     };
+  }
+  /**
+   * A flow as the numbers of what it spans and reaches, each in the order `trace` adds them;
+   * its visits and hops only with `keep` (a scan's features need neither).
+   */
+  traceIx(entry, keep) {
+    const g = this.g;
+    const pass = ++this.pass;
+    const recMark = this.recMark;
+    const reachMark = this.reachMark;
+    const records = [];
+    const reached = [];
+    const rec = (k) => {
+      if (recMark[k] !== pass) {
+        recMark[k] = pass;
+        records.push(k);
+      }
+    };
+    const reach = (k) => {
+      if (reachMark[k] !== pass) {
+        reachMark[k] = pass;
+        reached.push(k);
+      }
+    };
+    const visits = keep ? [] : void 0;
+    const hops = keep ? [] : void 0;
+    rec(this.indexOf(entry.id));
+    rec(this.indexOf(entry.component));
+    reach(this.indexOf(entry.id));
     const iface = g.interfaces.get(entry.id);
     if (iface) {
-      flow.records.add(iface.from);
+      rec(this.indexOf(iface.from));
       if (iface.endpoint)
-        flow.records.add(iface.endpoint);
+        rec(this.indexOf(iface.endpoint));
     } else if (g.endpoints.has(entry.id)) {
       for (const c of g.callers.get(entry.id) ?? []) {
-        flow.records.add(c.id);
-        flow.records.add(c.from);
+        rec(this.indexOf(c.id));
+        rec(this.indexOf(c.from));
       }
     }
-    const seen = /* @__PURE__ */ new Set();
-    const queue = [
-      { component: entry.component, toks: entry.tokens, depth: 0, mode: entry.mode }
-    ];
-    while (queue.length) {
-      const { component, toks, depth, mode } = queue.shift();
-      if (seen.has(component) || !g.isOwn(component))
+    const queuedMark = this.queuedMark;
+    const first = this.indexOf(entry.component);
+    queuedMark[first] = pass;
+    const queue = [{ component: entry.component, at: first, toks: entry.tokens, depth: 0, mode: entry.mode }];
+    for (let q = 0; q < queue.length; q++) {
+      const { component, at, toks, depth, mode } = queue[q];
+      if (!this.ownAt(at, component))
         continue;
-      seen.add(component);
-      flow.records.add(component);
-      flow.visits.push({ component, tokens: toks });
-      for (const u of this.tablesFor(component, toks, mode))
-        flow.records.add(u.table.id);
+      rec(at);
+      visits?.push({ component, tokens: toks });
+      this.tablesIx(component, toks, mode, rec);
       if (depth >= this.maxDepth)
         continue;
-      const outs = g.outOf(component);
-      let follow = outs.filter((i) => overlaps(toks, this.callTokens(i)));
-      if (!follow.length && this.starts(component).length <= 1)
-        follow = outs;
-      for (const i of follow) {
-        flow.hops.push(i);
-        flow.records.add(i.id);
-        flow.reached.add(i.id);
-        if (i.endpoint) {
-          flow.records.add(i.endpoint);
-          flow.reached.add(i.endpoint);
+      const outs = this.outsOf(component);
+      const { hit, n } = this.sharingHits(this.outWordsMemo, component, outs, toks, (i) => this.callTokens(i));
+      const all = n === 0 && this.startCount(component) <= 1;
+      if (n === 0 && !all)
+        continue;
+      const oix = this.outsIxOf(component, outs);
+      for (let k = 0; k < outs.length; k++) {
+        if (!all && !hit[k])
+          continue;
+        const i = outs[k];
+        hops?.push(i);
+        const id = oix[k * 3];
+        const ep = oix[k * 3 + 1];
+        const to = oix[k * 3 + 2];
+        rec(id);
+        reach(id);
+        if (ep >= 0) {
+          rec(ep);
+          reach(ep);
         }
-        flow.records.add(i.to);
-        if (g.isOwn(i.to) && !seen.has(i.to))
+        rec(to);
+        if (queuedMark[to] !== pass && this.ownAt(to, i.to)) {
+          queuedMark[to] = pass;
           queue.push({
             component: i.to,
-            toks: union(toks, this.hopTokens(i)),
+            at: to,
+            toks: unionNew(toks, this.hopTokens(i)),
             depth: depth + 1,
             mode: i.sync === "async" ? "any" : modeOf(i.method)
           });
+        }
       }
     }
-    return flow;
+    return {
+      entry,
+      records: Int32Array.from(records),
+      reached: Int32Array.from(reached),
+      ...visits ? { visits } : {},
+      ...hops ? { hops } : {}
+    };
   }
 };
 var Groups = class {
@@ -2309,7 +2536,11 @@ var Groups = class {
     let r = x;
     while (this.parent.get(r) !== r)
       r = this.parent.get(r);
-    this.parent.set(x, r);
+    for (let y = x; y !== r; ) {
+      const next = this.parent.get(y);
+      this.parent.set(y, r);
+      y = next;
+    }
     return r;
   }
   join(a, b) {
@@ -2331,14 +2562,18 @@ var Groups = class {
     const out = /* @__PURE__ */ new Map();
     for (const id of [...this.parent.keys()].sort()) {
       const r = this.find(id);
-      out.set(r, [...out.get(r) ?? [], id]);
+      const l = out.get(r);
+      if (l)
+        l.push(id);
+      else
+        out.set(r, [id]);
     }
     return [...out.values()];
   }
 };
 var isObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
 function currentDecisions(decisions) {
-  return decisions.filter((d) => d.kind === "CuratedDecision" && d.status === "current").filter((d) => d.target.startsWith("feature.")).sort((a, b) => a.at === b.at ? a.id < b.id ? -1 : 1 : a.at < b.at ? -1 : 1);
+  return decisions.filter((d) => d.kind === "CuratedDecision" && d.status === "current").filter((d) => d.target.startsWith("feature.")).sort(byDecisionTime);
 }
 function pinsFrom(decisions) {
   const latest = /* @__PURE__ */ new Map();
@@ -2355,6 +2590,15 @@ function pinsFrom(decisions) {
   return pins;
 }
 var evKey = (e) => JSON.stringify(Object.entries(e).sort());
+function withEachRepo(own, records) {
+  const have = new Set(own.flatMap((e) => e.repo ? [e.repo] : []));
+  const first = /* @__PURE__ */ new Map();
+  for (const r of records)
+    for (const e of r?.evidence ?? [])
+      if (e.repo && !have.has(e.repo) && !first.has(e.repo))
+        first.set(e.repo, e);
+  return [...own, ...[...first].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([, e]) => e)];
+}
 function dedupeEvidence(list2) {
   const seen = /* @__PURE__ */ new Set();
   return list2.filter((e) => {
@@ -2399,14 +2643,44 @@ function detectFeaturesWithReport(records, o = {}) {
       });
     }
   }
+  const byId2 = new Map(records.map((r) => [r.id, r]));
   const list2 = [...entries.values()].sort((a, b) => a.id < b.id ? -1 : 1);
   tracer.useEntries(list2);
-  const flows = new Map(list2.map((e) => [e.id, tracer.trace(e)]));
+  const keep = o.keepFlows !== false;
+  const traced = new Map(list2.map((e) => [e.id, tracer.traceIx(e, keep)]));
+  const flows = /* @__PURE__ */ new Map();
+  if (keep)
+    for (const [id, f] of traced)
+      flows.set(id, {
+        entry: f.entry,
+        records: new Set(Array.from(f.records, (k) => tracer.idOf(k))),
+        reached: new Set(Array.from(f.reached, (k) => tracer.idOf(k))),
+        visits: f.visits,
+        hops: f.hops
+      });
+  const entryAt = /* @__PURE__ */ new Map();
+  for (const e of list2)
+    entryAt.set(tracer.indexOf(e.id), e.id);
   const groups = new Groups(list2.map((e) => e.id), (id) => pins.get(id));
-  for (const f of flows.values())
-    for (const r of sorted(f.reached))
-      if (r !== f.entry.id && entries.has(r) && ["endpoint", "consumer", "pinned"].includes(entries.get(r).kind))
+  const reachers = /* @__PURE__ */ new Map();
+  const joining = /* @__PURE__ */ new Set(["endpoint", "consumer", "pinned"]);
+  for (const f of traced.values()) {
+    const hit = [];
+    for (const k of f.reached) {
+      const r = entryAt.get(k);
+      if (r !== void 0) {
+        hit.push(r);
+        const l = reachers.get(r);
+        if (l)
+          l.push(f.entry.id);
+        else
+          reachers.set(r, [f.entry.id]);
+      }
+    }
+    for (const r of pins.size ? hit.sort() : hit)
+      if (r !== f.entry.id && joining.has(entries.get(r).kind))
         groups.join(f.entry.id, r);
+  }
   const bySlug = /* @__PURE__ */ new Map();
   for (const e of list2) {
     const s2 = slugOf(e.resource);
@@ -2419,7 +2693,8 @@ function detectFeaturesWithReport(records, o = {}) {
   const built = [];
   for (const members of groups.groups()) {
     const pin = members.map((m) => pins.get(m)).find(Boolean);
-    const reachedByOthers = (m) => members.some((x) => x !== m && flows.get(x).reached.has(m));
+    const inGroup = new Set(members);
+    const reachedByOthers = (m) => (reachers.get(m) ?? []).some((x) => x !== m && inGroup.has(x));
     const outer = members.filter((m) => !reachedByOthers(m)).sort();
     const inner = members.filter((m) => reachedByOthers(m)).sort();
     let resource = entries.get(members[0]).resource;
@@ -2442,12 +2717,23 @@ function detectFeaturesWithReport(records, o = {}) {
     taken.add(id);
   }
   let features = /* @__PURE__ */ new Map();
-  for (const b of built.sort((x, y) => x.id < y.id ? -1 : 1))
+  const markedFor = [];
+  let feature = 0;
+  for (const b of built.sort((x, y) => x.id < y.id ? -1 : 1)) {
+    feature++;
+    const ids = [];
+    for (const m of b.members)
+      for (const k of traced.get(m).records)
+        if (markedFor[k] !== feature) {
+          markedFor[k] = feature;
+          ids.push(tracer.idOf(k));
+        }
     features.set(b.id, {
       members: b.members,
       name: displayName(b.resource),
-      records: new Set(b.members.flatMap((m) => [...flows.get(m).records]))
+      records: new Set(ids)
     });
+  }
   for (const d of decisions.filter((x) => x.action === "alias")) {
     const names = (Array.isArray(d.value) ? d.value : [d.value]).filter((v) => typeof v === "string" && v.startsWith("feature."));
     if (!names.length)
@@ -2482,16 +2768,17 @@ function detectFeaturesWithReport(records, o = {}) {
   const out = [];
   for (const [id, f] of features) {
     const p = proposals.get(id);
+    const records2 = sorted(f.records);
     out.push(capability({
       id,
       name: p?.name ?? f.name,
       ...p?.description ? { description: p.description } : {},
       entryPoints: f.members,
-      records: sorted(f.records),
+      records: records2,
       tags: p ? [...p.tags] : [],
       externalRefs: [],
       namedBy: p ? "ai" : "detected",
-      evidence: dedupeEvidence(f.members.flatMap((m) => entries.get(m).evidence))
+      evidence: withEachRepo(dedupeEvidence(f.members.flatMap((m) => entries.get(m).evidence)), records2.map((r) => byId2.get(r)))
     }));
   }
   return { features: out, flows, problems };
@@ -2566,7 +2853,9 @@ async function featuresForScan(input) {
   const r = detectFeaturesWithReport(input.records, {
     decisions: input.decisions,
     proposals: read.proposals,
-    ...input.maxDepth ? { maxDepth: input.maxDepth } : {}
+    ...input.maxDepth ? { maxDepth: input.maxDepth } : {},
+    // A scan keeps the features only (ADR 0195 point 9: the flows of a big estate are large).
+    keepFlows: false
   });
   return {
     features: r.features,
@@ -3915,6 +4204,11 @@ function knowledgeGaps(input) {
   }
   return out;
 }
+function ownerQuestionStillAsked(input) {
+  const raised = new Set(knowledgeGaps(input).map((g) => g.question.id));
+  const checks = [...KNOWLEDGE_CHECKS, ...input.checks ?? []].map((c) => `q.${c.id}.`);
+  return (r) => r.kind !== "OwnerQuestion" || raised.has(r.id) || !checks.some((p) => r.id.startsWith(p));
+}
 
 // packages/knowledge/dist/coverage.js
 var COVERAGE_AREAS = [
@@ -4169,6 +4463,7 @@ var TYPE = {
 };
 function domainProfile(records, system, o) {
   const all = [...records].sort((a, b) => cmp(a.id, b.id));
+  const stillAsked = o.orgPack ? ownerQuestionStillAsked({ records, orgPack: o.orgPack, now: o.now }) : void 0;
   const byId2 = new Map(all.map((r) => [r.id, r]));
   const of = (kind) => all.filter((r) => r.kind === kind);
   const sys = byId2.get(system);
@@ -4280,7 +4575,7 @@ function domainProfile(records, system, o) {
     `- Who is the business owner of ${name2}? (product owner)`,
     `- Which controls and obligations apply to ${name2}, and under which policy or decision? (architect)`,
     ...stores.map((d) => `- What are the classification and retention of the data in ${d.id}? (data owner)`),
-    ...of("OwnerQuestion").filter((q) => s(q.system) === system).map((q) => `- ${s(q.question)} (${s(q.owner) ?? "owner"}, ${s(q.questionState) ?? "open"})`),
+    ...of("OwnerQuestion").filter((q) => s(q.system) === system).filter((q) => !stillAsked || stillAsked(q) || q.questionState === "answered").map((q) => `- ${s(q.question)} (${s(q.owner) ?? "owner"}, ${s(q.questionState) ?? "open"})`),
     ...[
       ...new Set(of("Unresolved").filter((u) => own.has(s(u.owner) ?? "")).map((u) => s(u.owner)))
     ].sort().map((c) => {
@@ -8503,6 +8798,7 @@ export {
   freshness,
   KNOWLEDGE_CHECKS,
   knowledgeGaps,
+  ownerQuestionStillAsked,
   COVERAGE_AREAS,
   featureCoverage,
   coverage,

package/dist/{chunk-3D74UADA.js → chunk-NGSGJLKW.js}

@@ -9,8 +9,8 @@ import {
   loadEstimates,
   loadOpenSpecSettings,
   loadOrgPack
-} from "./chunk-LZFKJ2BR.js";
-import "./chunk-CTJHEG6A.js";
+} from "./chunk-A3LVMCA5.js";
+import "./chunk-NWMFVPEP.js";
 import "./chunk-BQGDB6ZL.js";
 import "./chunk-TV45EUGM.js";
 export {