@polycode-projects/the-mechanical-code-talker 2.5.2 → 2.5.3

package/src/surfaces/web/memory-ask-browser.bundle.js

@@ -975,6 +975,12 @@
   function provenanceTagToSource(tag) {
     const t = String(tag || "").trim();
     if (!t) return null;
+    if (t.startsWith("reference:")) {
+      const rest = t.slice("reference:".length);
+      const colon = rest.indexOf(":");
+      if (colon < 0) return { kind: "reference", pack: rest || "unknown", article: "" };
+      return { kind: "reference", pack: rest.slice(0, colon) || "unknown", article: rest.slice(colon + 1) };
+    }
     const head = t.split(/\s+/)[0];
     if (head.startsWith("corpus-weak:")) return { kind: "corpusWeak", name: head.slice("corpus-weak:".length) || "unknown" };
     if (head.startsWith("corpus:")) return { kind: "corpus", name: head.slice("corpus:".length) || "unknown" };
@@ -1056,6 +1062,7 @@
         teach: 0.95,
         provider: 0.9,
         corpus: 0.7,
+        reference: 0.6,
         corpusWeak: 0.55,
         web: 0.4,
         extracted: 0.45,
@@ -1346,6 +1353,7 @@
           if (!subjModId || !objModId) continue;
           const subjLabel = graph.byId.get(subjModId)?.label || subjModId;
           addDependent(objModId, subjModId, subjLabel, g.predicate);
+          if (subjModId !== objModId) addDependent(e.object, subjModId, subjLabel, g.predicate);
         }
       } else if (kind === "tests") {
         for (const e of g.edges) {
@@ -2875,8 +2883,8 @@ ${shown.join("\n")}${tail}`;
       EXPLAIN_WRAPPER_RE = /^explain\s+(?:to\s+me\s+|please\s+)*(.+?)\??$/i;
       TELL_ME_WRAPPER_RE = /^tell\s+me\s+(.+?)\??$/i;
       KNOW_WRAPPER_RE = /^do\s+you\s+know\s+(.+?)\??$/i;
-      WANT_KNOW_WRAPPER_RE = /^i(?:'d|\s+would)?\s+(?:like|want|need)\s+to\s+know\s+(.+?)\??$/i;
-      WONDERING_WRAPPER_RE = /^i(?:\s+was|\s+am|'m)?\s+(?:just\s+)?(?:wonder(?:ing|ed)|curious)(?:\s+(?:if|whether|about))?\s+(.+?)\??$/i;
+      WANT_KNOW_WRAPPER_RE = /^i(?:'d|\s+would)?\s+(?:(?:like|want|need)\s+to|wanna)\s+know\s+(.+?)\??$/i;
+      WONDERING_WRAPPER_RE = /^i(?:\s+was|\s+am|'m)?\s+(?:just\s+)?(?:wonder(?:ing|ed)?|curious)(?:\s+(?:if|whether|about))?\s+(.+?)\??$/i;
       EMBEDDED_WHATIS_RE = /^what\s+((?:an?\s+|the\s+)?[\w'-]+(?:\s+[\w'-]+){0,2})\s+(is|are)\??$/i;
       EMBEDDED_MEANS_RE = /^what\s+((?:an?\s+|the\s+)?[\w'-]+(?:\s+[\w'-]+){0,2})\s+means\??$/i;
       SHOW_GIVE_ME_RE = /^(?:show|give)\s+me\s+(?:the\s+)?(.+?)\??$/i;
@@ -2992,6 +3000,17 @@ ${shown.join("\n")}${tail}`;
         { re: /^(?:is|are)\s+(?!.*\bnot\b)(.+?)\s+tested\??$/i, to: (m) => `what tests ${m[1]}` },
         // NEEDS-TESTS → the untested-module survey.
         { re: /^what\s+needs\s+(?:to\s+be\s+)?(?:a\s+)?(?:tested|tests?|testing|coverage|covering)\??$/i, to: () => "untested modules" },
+        // NO-TESTS → the same untested survey, attributive form. "no tests" would
+        // otherwise read as a literal object term ("…defines no tests") and the
+        // resulting empty answers as "it has none" to a coverage question.
+        {
+          re: /^(?:which|what|list|show(?:\s+me)?|find)?\s*(?:the\s+|all\s+)?([a-z][a-z-]*?)\s+(?:(?:that|which)\s+)?(?:have|has|having|with)\s+no\s+tests?\??$/i,
+          to: (m) => `untested ${m[1].toLowerCase()}`
+        },
+        {
+          re: /^(?:which|what|list|show(?:\s+me)?|find)?\s*(?:the\s+|all\s+)?([a-z][a-z-]*?)\s+without\s+(?:any\s+)?tests?\??$/i,
+          to: (m) => `untested ${m[1].toLowerCase()}`
+        },
         // DOES-X-VERB-ANYTHING-ELSE → "what does X <verb>" (drops the placeholder
         // "anything/something else" object, which otherwise made the two parse
         // strategies disagree on the span). Anchored to VERB_TO_KIND so it can't
@@ -3410,7 +3429,10 @@ ${shown.join("\n")}${tail}`;
       if (INHERITS_REVERSE_VERBS.includes(verbPhrase)) [subject, object] = [object, subject];
       return stamp({ shape: "ask", entityType: null, modifier: "direct", kind, subject, object });
     }
-    if (afterText) return stamp({ shape: "reverse", entityType, modifier, kind, object: afterText });
+    if (afterText) {
+      const resultType = entityHit && entityHit.start >= verbHit.end ? null : entityType;
+      return stamp({ shape: "reverse", entityType: resultType, modifier, kind, object: afterText });
+    }
     if (kind === "inherits" && !beforeText && entityHit && entityHit.start === verbHit.end) {
       const entityText = canonWords.slice(entityHit.start, entityHit.end).join(" ");
       if (entityText) return stamp({ shape: "reverse", entityType: null, modifier, kind, object: entityText });
@@ -3855,7 +3877,9 @@ ${shown.join("\n")}${tail}`;
     return classes;
   }
   function kindObjectClass(graph, kind) {
-    const classes = classesForKinds(graph, kindsFor(kind));
+    const kinds = kindsFor(kind);
+    const coarse = kinds.filter((k) => !SYMBOL_GRAIN_KINDS.has(k));
+    const classes = classesForKinds(graph, coarse.length ? coarse : kinds);
     return classes.size === 1 ? [...classes][0] : null;
   }
   function parseSetPhrase(text, nlp, depth) {
@@ -4233,7 +4257,9 @@ ${shown.join("\n")}${tail}`;
       if (!entityType) return { node: "miss", reason: "a superlative needs an entity kind (module, class, function, \u2026)" };
     }
     if (!metric) return { node: "miss", reason: "name what to rank by (imports, callers, methods, tests, or connections)" };
-    return { node: "superlative", entityType, metric, metricNoun, extreme: ext };
+    const NEED_LACK_WORDS = ["needs", "need", "needing", "lacks", "lack", "lacking", "misses", "missing"];
+    const extreme = lc.some((x) => NEED_LACK_WORDS.includes(x)) ? ext === "most" ? "fewest" : "most" : ext;
+    return { node: "superlative", entityType, metric, metricNoun, extreme };
   }
   function parseFind(w, lc, nlp, depth) {
     if (lc[0] !== "find") return null;
@@ -5426,7 +5452,20 @@ ${shown.join("\n")}${tail}`;
     return out;
   }
   function declineOnUnplacedWords(result, term) {
-    if (!result?.match || result.ambiguous || result.tier !== 3 || result.matchedVia) return result;
+    if (!result?.match || result.tier !== 3 || result.matchedVia) return result;
+    if (result.ambiguous) {
+      const pool = [result.match, ...result.candidates || []];
+      const shared = pool.map((m) => new Set(unplacedTermWords(term, m.label))).reduce((acc, s) => acc.filter((w) => s.has(w)), unplacedTermWords(term, pool[0].label));
+      if (!shared.length) return result;
+      return {
+        match: null,
+        candidates: [],
+        tier: null,
+        ambiguous: false,
+        unplacedWords: shared,
+        nearestLabel: listJoin(pool.slice(0, 4).map((m) => m.label))
+      };
+    }
     const unplaced = unplacedTermWords(term, result.match.label);
     if (!unplaced.length) return result;
     return {
@@ -5774,7 +5813,7 @@ ${shown.join("\n")}${tail}`;
         traversal: `reverse dependency closure over imports+calls edges from ${objMatch.label} (impactClosure, maxDepth=${TRANSITIVE_MAX_DEPTH})`
       };
     }
-    const symbolKind = SYMBOL_GRAIN_SIBLING[kind];
+    const symbolKind = SYMBOL_GRAIN_SIBLING[kind] || kindsFor(kind).find((k) => SYMBOL_GRAIN_KINDS.has(k)) || null;
     const objIsFineSymbol = !!(objMatch.class && FINE_ENTITY_TYPES.has(objMatch.class));
     if (symbolKind && (FINE_ENTITY_TYPES.has(entityType) || objIsFineSymbol)) {
       const edges2 = edgesOfKind2(graph, symbolKind).filter((e) => e.object === objMatch.id);
@@ -5789,7 +5828,7 @@ ${shown.join("\n")}${tail}`;
           widenNote = `, widened to ${siblingClass} subjects (no ${entityType} recorded)`;
         }
       }
-      const upRefineEligible = (kind === "touches" || kind === "calls") && objMatch.class === "Class" && !edgesOfKind2(graph, "contains").some((e) => e.subject === objMatch.id);
+      const upRefineEligible = (kind === "touches" || kind === "calls" || kind === "uses") && objMatch.class === "Class" && !edgesOfKind2(graph, "contains").some((e) => e.subject === objMatch.id);
       const upRefineModule = upRefineEligible ? graph.byId.get(moduleIdOf2(graph, objMatch) || "") : null;
       if (matches2.length || !(upRefineEligible && upRefineModule)) {
         return { matches: matches2, objMatch, candidates, traversal: `${symbolKind} edges where object = ${objMatch.label}${widenNote}`, ambiguous, matchedVia };
@@ -6224,6 +6263,14 @@ ${result.branches.map((b, i) => `${i + 1}) ${b.candidate.label}: ${b.rendered.co
     }
     if (!result.matches.length) {
       if (parsed.shape === "forward") {
+        if (MEMBERSHIP_KINDS.includes(parsed.kind) && graph && result.objMatch) {
+          for (const alt of MEMBERSHIP_KINDS) {
+            if (alt === parsed.kind) continue;
+            const altParsed = { ...parsed, kind: alt };
+            const altResult = traverse(graph, altParsed, { pinnedObjMatch: result.objMatch });
+            if (altResult?.matches?.length && !altResult.ambiguous) return renderCore(altParsed, altResult, graph);
+          }
+        }
         return {
           content: `${result.objMatch.label} has no ${verbFor(parsed.kind)} edges in the index.`,
           miss: true,
@@ -6265,7 +6312,7 @@ ${result.branches.map((b, i) => `${i + 1}) ${b.candidate.label}: ${b.rendered.co
     return { content: clauses.join(" and ") + extra + ".", miss: false, ambiguous: false, matches: result.matches };
   }
   function fuzzyCascadeWord(w) {
-    if (w.length < 4) return null;
+    if (w.length < 4 || CASCADE_FUZZY_REAL_WORDS.has(w)) return null;
     const bound = fuzzyBound(w);
     let best = bound + 1;
     let hit2 = null;
@@ -6582,7 +6629,7 @@ ${lines.join("\n")}`;
       }
     };
   }
-  var askEdgesOfKindCache, SYMBOL_GRAIN_SIBLING, FINE_ENTITY_TYPES, FINE_CLASS_SIBLING, KIND_UNIONS, kindsFor, OVERFLOW_CAP, PLURAL_FORMS, REVERSE_MISS_VERB, PLURAL_SUBJECT_VERB, pluralVerbFor, LEADING_RELATION_VERB_RE, FROZEN_META_AMBIGUOUS_TERMS, MAX_COMPOSE_DEPTH, NEST_SENTINEL, PRED_LEAD_SKIP, FRAME_WORDS, COPULA_WORDS, entityNoun, isGerundVerb, UNIVERSAL_DET, FWD_NEG_FRAME, PLURAL_ANAPHORA_OBJECT, TEMPORAL_AUX, TEMPORAL_TAIL, TEMPORAL_TRAIL_FILLER, TEMPORAL_DET, COMMIT_FILTER_OPS, ANAPHORA_NAME_TOKEN_RE, AGG_TAIL_FILLER, LIST_SKIP, LIST_TRIGGERS_SORTED, LISTABLE_KINDS, SCOPE_PREPOSITIONS, FIND_LINKERS, RECENT_COMMIT_LEAD, qualCache, META_FALLBACK_CLASSES, inheritsApplicableCache, FIND_TIER, oppositeQualifierSpec, DEGREE_KINDS, COMMIT_FILTER_DATE_RE, compositeList, LEADING_ARTICLE_RE, TRAILING_GRAIN_WORD_RE, ENTRY_POINT_QUERY_RE, ENTRY_POINT_BASENAMES, TEST_FIXTURE_PATH_SEGMENTS, moduleStemOf, isTestFixturePath, TRANSITIVE_MAX_DEPTH, CONTENT_VOCAB, STRUCTURAL_WORDS, CASCADE_NOISE_SET, NOISE_OR_SCAFFOLD, TRIGGER_FUZZY_WORDS, CASCADE_FUZZY_TARGETS, LAST_COMMIT_PHRASE_RE, BARE_WHEN_COMMIT_RE, DYNAMIC_LIST_TRIGGER_RE, DYNAMIC_COUNT_TRIGGER_RE, DYNAMIC_TAIL_OK_RE, BARE_META_WHATIS_RE, WHATIS_FOR_FALLBACK_RE;
+  var askEdgesOfKindCache, SYMBOL_GRAIN_SIBLING, FINE_ENTITY_TYPES, FINE_CLASS_SIBLING, KIND_UNIONS, kindsFor, SYMBOL_GRAIN_KINDS, OVERFLOW_CAP, PLURAL_FORMS, REVERSE_MISS_VERB, PLURAL_SUBJECT_VERB, pluralVerbFor, LEADING_RELATION_VERB_RE, FROZEN_META_AMBIGUOUS_TERMS, MAX_COMPOSE_DEPTH, NEST_SENTINEL, PRED_LEAD_SKIP, FRAME_WORDS, COPULA_WORDS, entityNoun, isGerundVerb, UNIVERSAL_DET, FWD_NEG_FRAME, PLURAL_ANAPHORA_OBJECT, TEMPORAL_AUX, TEMPORAL_TAIL, TEMPORAL_TRAIL_FILLER, TEMPORAL_DET, COMMIT_FILTER_OPS, ANAPHORA_NAME_TOKEN_RE, AGG_TAIL_FILLER, LIST_SKIP, LIST_TRIGGERS_SORTED, LISTABLE_KINDS, SCOPE_PREPOSITIONS, FIND_LINKERS, RECENT_COMMIT_LEAD, qualCache, META_FALLBACK_CLASSES, inheritsApplicableCache, FIND_TIER, oppositeQualifierSpec, DEGREE_KINDS, COMMIT_FILTER_DATE_RE, compositeList, LEADING_ARTICLE_RE, TRAILING_GRAIN_WORD_RE, ENTRY_POINT_QUERY_RE, ENTRY_POINT_BASENAMES, TEST_FIXTURE_PATH_SEGMENTS, moduleStemOf, isTestFixturePath, TRANSITIVE_MAX_DEPTH, CONTENT_VOCAB, STRUCTURAL_WORDS, CASCADE_NOISE_SET, NOISE_OR_SCAFFOLD, TRIGGER_FUZZY_WORDS, CASCADE_FUZZY_TARGETS, CASCADE_FUZZY_REAL_WORDS, LAST_COMMIT_PHRASE_RE, BARE_WHEN_COMMIT_RE, DYNAMIC_LIST_TRIGGER_RE, DYNAMIC_COUNT_TRIGGER_RE, DYNAMIC_TAIL_OK_RE, BARE_META_WHATIS_RE, WHATIS_FOR_FALLBACK_RE;
   var init_ask = __esm({
     "src/domain/ask.mjs"() {
       init_codegraph();
@@ -6603,6 +6650,7 @@ ${lines.join("\n")}`;
       FINE_CLASS_SIBLING = { Function: "Method", Method: "Function" };
       KIND_UNIONS = { uses: ["imports", "calls", "callsSymbol"] };
       kindsFor = (kind) => KIND_UNIONS[kind] || [kind];
+      SYMBOL_GRAIN_KINDS = new Set(Object.values(SYMBOL_GRAIN_SIBLING));
       OVERFLOW_CAP = 12;
       PLURAL_FORMS = {
         Function: ["function", "functions"],
@@ -6752,6 +6800,7 @@ ${lines.join("\n")}`;
         ...Object.keys(ENTITY_TO_TYPE),
         ...TRIGGER_FUZZY_WORDS
       ])].filter((wd) => /^[a-z]+$/.test(wd) && wd.length >= 4 && !STOPWORDS2.has(wd));
+      CASCADE_FUZZY_REAL_WORDS = /* @__PURE__ */ new Set(["impact", "impacts", "impacted"]);
       LAST_COMMIT_PHRASE_RE = /\b(?:the\s+)?(?:last|latest|most\s+recent)\s+commit\b/i;
       BARE_WHEN_COMMIT_RE = /^when\s+(?:was|were|is|did|does|do)\s+commit\s+[0-9a-fA-F:]+$/i;
       DYNAMIC_LIST_TRIGGER_RE = /^(?:list|show(?:\s+me)?)\s+(?:all\s+|the\s+)?([a-z][a-z'-]*)\s*(.*)$/i;
@@ -7599,6 +7648,7 @@ ${bodyText}` : graphText, tier });
     CAX_MAXC0_RULE_CONFIDENCE: () => CAX_MAXC0_RULE_CONFIDENCE,
     CLS_SVF1_RULE: () => CLS_SVF1_RULE,
     CLS_SVF1_RULE_CONFIDENCE: () => CLS_SVF1_RULE_CONFIDENCE,
+    DEFAULT_MAX_ENVIRONMENTS: () => DEFAULT_MAX_ENVIRONMENTS,
     DISJOINT_PREDICATE: () => DISJOINT_PREDICATE,
     ENTAILED_DISJOINT_PROVENANCE: () => ENTAILED_DISJOINT_PROVENANCE,
     ENTAILED_PROVENANCE: () => ENTAILED_PROVENANCE,
@@ -7612,10 +7662,12 @@ ${bodyText}` : graphText, tier });
     SUBCLASS_PREDICATE: () => SUBCLASS_PREDICATE,
     TYPE_PREDICATE: () => TYPE_PREDICATE,
     buildCardinalityRestrictions: () => buildCardinalityRestrictions,
+    buildRelevanceFrontier: () => buildRelevanceFrontier,
     deriveDisjointViolations: () => deriveDisjointViolations,
     deriveSomeValuesFromApplication: () => deriveSomeValuesFromApplication,
     deriveSomeValuesFromSubsumption: () => deriveSomeValuesFromSubsumption,
     deriveSubClassClosure: () => deriveSubClassClosure,
+    deriveSubClassClosureDelta: () => deriveSubClassClosureDelta,
     deriveTypePropagation: () => deriveTypePropagation,
     entailedTrustFrom: () => entailedTrustFrom,
     findConsistencyViolations: () => findConsistencyViolations,
@@ -7693,6 +7745,65 @@ ${bodyText}` : graphText, tier });
     }
     return derived;
   }
+  function deriveSubClassClosureDelta(allEdges, deltaEdges, { depth = 32, budget = 50, focus = null } = {}) {
+    const present = /* @__PURE__ */ new Set();
+    const succ = /* @__PURE__ */ new Map();
+    const pred = /* @__PURE__ */ new Map();
+    for (const [a, b] of allEdges || []) {
+      if (!a || !b || a === b) continue;
+      present.add(`${a}${SEP}${b}`);
+      if (!succ.has(a)) succ.set(a, /* @__PURE__ */ new Set());
+      succ.get(a).add(b);
+      if (!pred.has(b)) pred.set(b, /* @__PURE__ */ new Set());
+      pred.get(b).add(a);
+    }
+    let delta = [];
+    const seenDelta = /* @__PURE__ */ new Set();
+    for (const [a, b] of deltaEdges || []) {
+      if (!a || !b || a === b) continue;
+      const key = `${a}${SEP}${b}`;
+      if (seenDelta.has(key)) continue;
+      seenDelta.add(key);
+      delta.push([a, b]);
+    }
+    const focusSet = focus instanceof Set ? focus.size ? focus : null : normalizeFocus(focus);
+    const inFocus = (a, b, c) => !focusSet || focusSet.has(a) || focusSet.has(b) || focusSet.has(c);
+    const derived = [];
+    const derivedKeys = /* @__PURE__ */ new Set();
+    for (let round2 = 0; round2 < depth && delta.length; round2 += 1) {
+      const additions = [];
+      const consider = (a, b, c) => {
+        if (a === c) return;
+        const key = `${a}${SEP}${c}`;
+        if (present.has(key) || derivedKeys.has(key)) return;
+        if (!inFocus(a, b, c)) return;
+        additions.push([a, b, c, key]);
+      };
+      for (const [a, b] of delta) {
+        for (const c of succ.get(b) || []) consider(a, b, c);
+        for (const z of pred.get(a) || []) consider(z, a, b);
+      }
+      if (!additions.length) break;
+      additions.sort((x, y) => x[0].localeCompare(y[0]) || x[2].localeCompare(y[2]) || x[1].localeCompare(y[1]));
+      let progressed = false;
+      const nextDelta = [];
+      for (const [a, b, c, key] of additions) {
+        if (derivedKeys.has(key)) continue;
+        if (derived.length >= budget) break;
+        derivedKeys.add(key);
+        derived.push({ subject: a, object: c, via: b });
+        if (!succ.has(a)) succ.set(a, /* @__PURE__ */ new Set());
+        succ.get(a).add(c);
+        if (!pred.has(c)) pred.set(c, /* @__PURE__ */ new Set());
+        pred.get(c).add(a);
+        nextDelta.push([a, c]);
+        progressed = true;
+      }
+      if (derived.length >= budget || !progressed) break;
+      delta = nextDelta;
+    }
+    return derived;
+  }
   function buildAncestorCloser(subClassEdges) {
     const succ = /* @__PURE__ */ new Map();
     for (const [a, b] of subClassEdges || []) {
@@ -7715,11 +7826,41 @@ ${bodyText}` : graphText, tier });
       return seen;
     };
   }
-  function deriveTypePropagation(typeEdges, subClassEdges, { budget = 50, focus = null } = {}) {
+  function buildDescendantCloser(subClassEdges) {
+    return buildAncestorCloser((subClassEdges || []).map(([a, b]) => [b, a]));
+  }
+  function buildRelevanceFrontier(rows, seedTerms) {
+    const subClassEdges = [];
+    const typeEdges = [];
+    const onPropertyOf = /* @__PURE__ */ new Map();
+    const someValuesFromOf = /* @__PURE__ */ new Map();
+    for (const r of rows || []) {
+      if (!r || !r.subject || !r.predicate || !r.object) continue;
+      if (isSubClassOf(r.predicate)) subClassEdges.push([r.subject, r.object]);
+      else if (isType(r.predicate)) typeEdges.push([r.subject, r.object]);
+      else if (isOnProperty(r.predicate)) onPropertyOf.set(r.subject, r.object);
+      else if (isSomeValuesFrom(r.predicate)) someValuesFromOf.set(r.subject, r.object);
+    }
+    const descendantsOf2 = buildDescendantCloser(subClassEdges);
+    const affectedClasses = /* @__PURE__ */ new Set();
+    for (const t of seedTerms || []) {
+      const n = normFactTerm(t);
+      if (!n) continue;
+      affectedClasses.add(n);
+      for (const d of descendantsOf2(n)) affectedClasses.add(d);
+    }
+    const frontier = new Set(affectedClasses);
+    for (const [x, c] of typeEdges) if (affectedClasses.has(c)) frontier.add(x);
+    for (const [restriction, target] of someValuesFromOf) {
+      if (onPropertyOf.has(restriction) && affectedClasses.has(target)) frontier.add(restriction);
+    }
+    return frontier;
+  }
+  function deriveTypePropagation(typeEdges, subClassEdges, { budget = 50, focus = null, presentTypeEdges = typeEdges } = {}) {
     const ancestorsOf2 = buildAncestorCloser(subClassEdges);
     const present = /* @__PURE__ */ new Set();
     const seenTypeEdge = /* @__PURE__ */ new Set();
-    for (const [x, c] of typeEdges || []) if (x && c) present.add(`${x}${SEP}${c}`);
+    for (const [x, c] of presentTypeEdges || []) if (x && c) present.add(`${x}${SEP}${c}`);
     const focusSet = focus instanceof Set ? focus.size ? focus : null : normalizeFocus(focus);
     const inFocus = (x, c, d) => !focusSet || focusSet.has(x) || focusSet.has(c) || focusSet.has(d);
     const candidates = [];
@@ -8015,8 +8156,17 @@ ${bodyText}` : graphText, tier });
     }
     return derived;
   }
-  async function syllogise(repoDir, { depth = 32, budget = 50, focus = null, store } = {}) {
+  async function syllogise(repoDir, {
+    depth = 32,
+    budget = 50,
+    focus = null,
+    expandFocus = false,
+    maxEnvironments = DEFAULT_MAX_ENVIRONMENTS,
+    full = false,
+    store
+  } = {}) {
     const { loadMemory: loadMemory2, readFactRows: readFactRows2, appendFacts: appendFacts2 } = requireStore(store, ["loadMemory", "readFactRows", "appendFacts"], "syllogise");
+    const stateFnsPresent = typeof store?.loadSyllogiseState === "function" && typeof store?.saveSyllogiseState === "function";
     const memory = await loadMemory2(repoDir);
     const rows = readFactRows2(memory);
     const subClassEdges = rows.filter((r) => isSubClassOf(r.predicate)).map((r) => [r.subject, r.object]);
@@ -8036,22 +8186,64 @@ ${bodyText}` : graphText, tier });
       const target = someValuesFromOf.get(restriction);
       if (target) restrictionEdges.push({ restriction, property, target });
     }
-    const normalizedFocus = normalizeFocus(focus);
+    const callerFocus = normalizeFocus(focus);
+    const normalizedFocus = expandFocus && callerFocus ? buildRelevanceFrontier(rows, [...callerFocus]) : callerFocus;
+    const state = normalizedFocus === null && stateFnsPresent ? await store.loadSyllogiseState(repoDir) : null;
+    const currentIdSet = new Set(rows.map((r) => r.id));
+    const removedSinceLast = Array.isArray(state?.factIds) ? state.factIds.filter((id) => !currentIdSet.has(id)) : [];
+    const mode = state && Array.isArray(state.factIds) && !removedSinceLast.length && !full ? "delta" : "full";
+    const watermark = mode === "delta" ? new Set(state.factIds) : null;
+    const deltaRows = mode === "delta" ? rows.filter((r) => !watermark.has(r.id)) : rows;
+    const deltaSize = deltaRows.length;
     const trustByTriple = /* @__PURE__ */ new Map();
     for (const r of rows) trustByTriple.set(`${r.subject}${SEP}${r.predicate}${SEP}${r.object}`, r.trust);
     const premiseTrust = (s, p, o) => trustByTriple.get(`${s}${SEP}${p}${SEP}${o}`);
     const hasTriple = (s, p, o) => trustByTriple.has(`${s}${SEP}${p}${SEP}${o}`);
     const numericOnly = (arr) => arr.filter((t) => typeof t === "number");
-    const scmDerived = deriveSubClassClosure(subClassEdges, { depth, budget, focus: normalizedFocus });
+    const deltaEmpty = mode === "delta" && !deltaRows.length;
+    const deltaSubEdges = mode === "delta" ? deltaRows.filter((r) => isSubClassOf(r.predicate)).map((r) => [r.subject, r.object]) : [];
+    const scmDerived = mode === "delta" ? deltaSubEdges.length ? deriveSubClassClosureDelta(subClassEdges, deltaSubEdges, { depth, budget, focus: normalizedFocus }) : [] : deriveSubClassClosure(subClassEdges, { depth, budget, focus: normalizedFocus });
     const enlargedSubClassEdges = subClassEdges.concat(scmDerived.map((d) => [d.subject, d.object]));
+    let kernelFocus = normalizedFocus;
+    let frontier = null;
+    if (mode === "delta" && !deltaEmpty) {
+      const frontierRows = rows.concat(scmDerived.map((d) => ({ subject: d.subject, predicate: SUBCLASS_PREDICATE, object: d.object })));
+      const seeds = [];
+      for (const r of deltaRows) seeds.push(r.subject, r.object);
+      frontier = buildRelevanceFrontier(frontierRows, seeds);
+      kernelFocus = frontier;
+    }
+    const inFrontier = (t) => !frontier || frontier.has(t);
+    const caxTypeEdges = frontier ? typeEdges.filter(([x, c]) => inFrontier(x) || inFrontier(c)) : typeEdges;
+    const deltaDwEndpoints = /* @__PURE__ */ new Set();
+    if (frontier) {
+      for (const r of deltaRows) {
+        if (isDisjoint(r.predicate)) {
+          deltaDwEndpoints.add(r.subject);
+          deltaDwEndpoints.add(r.object);
+        }
+      }
+    }
+    const dwAncestorsOf = frontier && deltaDwEndpoints.size ? buildAncestorCloser(enlargedSubClassEdges) : null;
+    const dwTypeEdges = frontier ? typeEdges.filter(([x, c]) => inFrontier(x) || inFrontier(c) || dwAncestorsOf && [...dwAncestorsOf(c)].some((a) => deltaDwEndpoints.has(a))) : typeEdges;
+    const deltaRestrictionProperties = /* @__PURE__ */ new Set();
+    if (frontier) {
+      for (const r of deltaRows) {
+        if (isOnProperty(r.predicate) || isSomeValuesFrom(r.predicate)) {
+          const property = onPropertyOf.get(r.subject);
+          if (property) deltaRestrictionProperties.add(normFactTerm(property));
+        }
+      }
+    }
+    const svf1PropertyEdges = frontier ? propertyEdges.filter(([x, p, y]) => inFrontier(x) || inFrontier(y) || deltaRestrictionProperties.has(normFactTerm(p))) : propertyEdges;
     const remainingBudget = Math.max(0, budget - scmDerived.length);
-    const caxDerived = remainingBudget > 0 ? deriveTypePropagation(typeEdges, enlargedSubClassEdges, { budget: remainingBudget, focus: normalizedFocus }) : [];
+    const caxDerived = remainingBudget > 0 && !deltaEmpty ? deriveTypePropagation(caxTypeEdges, enlargedSubClassEdges, { budget: remainingBudget, focus: kernelFocus, presentTypeEdges: typeEdges }) : [];
     const remainingBudgetDw = Math.max(0, budget - scmDerived.length - caxDerived.length);
-    const dwDerived = remainingBudgetDw > 0 ? deriveDisjointViolations(typeEdges, enlargedSubClassEdges, disjointEdges, { budget: remainingBudgetDw, focus: normalizedFocus }) : [];
+    const dwDerived = remainingBudgetDw > 0 && !deltaEmpty ? deriveDisjointViolations(dwTypeEdges, enlargedSubClassEdges, disjointEdges, { budget: remainingBudgetDw, focus: kernelFocus }) : [];
     const remainingBudgetSvf1 = Math.max(0, budget - scmDerived.length - caxDerived.length - dwDerived.length);
-    const svf1Derived = remainingBudgetSvf1 > 0 && restrictionEdges.length ? deriveSomeValuesFromApplication(propertyEdges, typeEdges, enlargedSubClassEdges, restrictionEdges, { budget: remainingBudgetSvf1, focus: normalizedFocus }) : [];
+    const svf1Derived = remainingBudgetSvf1 > 0 && restrictionEdges.length && !deltaEmpty ? deriveSomeValuesFromApplication(svf1PropertyEdges, typeEdges, enlargedSubClassEdges, restrictionEdges, { budget: remainingBudgetSvf1, focus: kernelFocus }) : [];
     const remainingBudgetScmSvf = Math.max(0, budget - scmDerived.length - caxDerived.length - dwDerived.length - svf1Derived.length);
-    const scmSvfDerived = remainingBudgetScmSvf > 0 && restrictionEdges.length > 1 ? deriveSomeValuesFromSubsumption(restrictionEdges, enlargedSubClassEdges, { budget: remainingBudgetScmSvf, focus: normalizedFocus }) : [];
+    const scmSvfDerived = remainingBudgetScmSvf > 0 && restrictionEdges.length > 1 && !deltaEmpty ? deriveSomeValuesFromSubsumption(restrictionEdges, enlargedSubClassEdges, { budget: remainingBudgetScmSvf, focus: kernelFocus }) : [];
     const restrictionByRid = new Map(restrictionEdges.map((r) => [r.restriction, r]));
     const toWrite = [
       ...scmDerived.map((d) => ({
@@ -8059,16 +8251,18 @@ ${bodyText}` : graphText, tier });
         predicate: SUBCLASS_PREDICATE,
         object: d.object,
         provenance: ENTAILED_PROVENANCE,
-        // Persisted justification: the premise fact ids this conclusion rode
-        // (a⊑b, b⊑c) — content-addressed ids work even when a premise is
-        // itself an entailment this same pass just derived. Read back by
+        // Persisted justification: one environment per independent derivation,
+        // each an ordered premise fact-id list — this first one is the premise
+        // set the conclusion rode (a⊑b, b⊑c); the alternate-discovery step
+        // below may append more. Content-addressed ids work even when a premise
+        // is itself an entailment this same pass just derived. Read back by
         // retractSubClassOf (below) to find every entailment a retracted
         // premise could have supported. All five rules persist one, each
         // citing its own premise shape.
-        justification: [
+        justification: [[
           factIdForTriple(d.subject, SUBCLASS_PREDICATE, d.via),
           factIdForTriple(d.via, SUBCLASS_PREDICATE, d.object)
-        ]
+        ]]
       })),
       ...caxDerived.map((d) => ({
         subject: d.subject,
@@ -8079,10 +8273,10 @@ ${bodyText}` : graphText, tier });
         // taught chain is multi-hop: scm-sco materialises that edge (this same
         // pass or an earlier one), and retraction re-VERIFIES every candidate
         // anyway, so a citation left dangling by budget truncation is inert.
-        justification: [
+        justification: [[
           factIdForTriple(d.subject, TYPE_PREDICATE, d.via),
           factIdForTriple(d.via, SUBCLASS_PREDICATE, d.object)
-        ]
+        ]]
       })),
       ...dwDerived.map((d) => {
         const dwStoredForward = hasTriple(d.viaClass, DISJOINT_PREDICATE, d.object);
@@ -8099,11 +8293,11 @@ ${bodyText}` : graphText, tier });
           predicate: DISJOINT_PREDICATE,
           object: d.object,
           provenance: ENTAILED_DISJOINT_PROVENANCE,
-          justification: [
+          justification: [[
             factIdForTriple(d.subject, TYPE_PREDICATE, d.viaType),
             factIdForTriple(dwS, DISJOINT_PREDICATE, dwO),
             ...d.viaClass !== d.viaType ? [factIdForTriple(d.viaType, SUBCLASS_PREDICATE, d.viaClass)] : []
-          ],
+          ]],
           ...premiseTrusts.length ? { premiseTrusts, ruleConfidence: CAX_DW_RULE_CONFIDENCE } : {}
         };
       }),
@@ -8122,13 +8316,13 @@ ${bodyText}` : graphText, tier });
           predicate: TYPE_PREDICATE,
           object: d.object,
           provenance: ENTAILED_SVF1_PROVENANCE,
-          justification: [
+          justification: [[
             factIdForTriple(d.subject, d.viaProperty, d.viaValue),
             factIdForTriple(d.viaValue, TYPE_PREDICATE, d.viaType),
             factIdForTriple(d.object, ON_PROPERTY_PREDICATE, d.viaPropertyKey),
             factIdForTriple(d.object, SOME_VALUES_FROM_PREDICATE, d.viaTarget),
             ...d.viaType !== d.viaTarget ? [factIdForTriple(d.viaType, SUBCLASS_PREDICATE, d.viaTarget)] : []
-          ],
+          ]],
           // same sub-1 discount as cax-dw, same reason (see CAX_DW_RULE_CONFIDENCE).
           ...premiseTrusts.length ? { premiseTrusts, ruleConfidence: CLS_SVF1_RULE_CONFIDENCE } : {}
         };
@@ -8148,18 +8342,70 @@ ${bodyText}` : graphText, tier });
           predicate: SUBCLASS_PREDICATE,
           object: d.object,
           provenance: ENTAILED_SCM_SVF_PROVENANCE,
-          justification: [
+          justification: [[
             ...r1 ? [factIdForTriple(d.subject, ON_PROPERTY_PREDICATE, r1.property)] : [],
             factIdForTriple(d.subject, SOME_VALUES_FROM_PREDICATE, d.viaY1),
             ...r2 ? [factIdForTriple(d.object, ON_PROPERTY_PREDICATE, r2.property)] : [],
             factIdForTriple(d.object, SOME_VALUES_FROM_PREDICATE, d.viaY2),
             factIdForTriple(d.viaY1, SUBCLASS_PREDICATE, d.viaY2)
-          ],
+          ]],
           // same sub-1 discount as cax-dw/cls-svf1, same reason (see CAX_DW_RULE_CONFIDENCE).
           ...premiseTrusts.length ? { premiseTrusts, ruleConfidence: SCM_SVF_RULE_CONFIDENCE } : {}
         };
       })
     ];
+    const conclusionCandidates = toWrite.map((w) => ({
+      id: factIdForTriple(w.subject, w.predicate, w.object),
+      subject: w.subject,
+      predicate: w.predicate,
+      object: w.object,
+      environments: w.justification,
+      write: w
+    }));
+    const enumerateSupport = buildSupportEnumerator(rows.concat(conclusionCandidates.map((c) => ({
+      id: c.id,
+      subject: c.subject,
+      predicate: c.predicate,
+      object: c.object
+    }))));
+    const rowById = new Map(rows.map((r) => [r.id, r]));
+    const ownedPredicate = (p) => isSubClassOf(p) || isType(p) || isDisjoint(p);
+    const storedCandidateInScope = (r) => mode !== "delta" || frontier !== null && (frontier.has(r.subject) || frontier.has(r.object));
+    const storedCandidates = rows.filter((r) => ownedPredicate(r.predicate) && isPurelyEntailed(r.provenance) && environmentsOf(r).length < maxEnvironments && storedCandidateInScope(r)).map((r) => ({
+      id: r.id,
+      subject: r.subject,
+      predicate: r.predicate,
+      object: r.object,
+      environments: environmentsOf(r),
+      provenance: r.provenance
+    }));
+    const alternateCandidates = [...conclusionCandidates, ...storedCandidates].sort((a, b) => a.subject.localeCompare(b.subject) || a.predicate.localeCompare(b.predicate) || a.object.localeCompare(b.object));
+    let environmentsAdded = 0;
+    let alternatesTruncated = false;
+    let examined = 0;
+    for (const cand of alternateCandidates) {
+      if (examined >= budget) {
+        alternatesTruncated = true;
+        break;
+      }
+      examined += 1;
+      const discovered = enumerateSupport(cand, { maxEnvironments: maxEnvironments + 1 });
+      const { kept, truncated: mergeTruncated } = capMergeEnvironments(cand.environments, discovered, maxEnvironments);
+      if (mergeTruncated) alternatesTruncated = true;
+      if (kept.length <= cand.environments.length) continue;
+      environmentsAdded += kept.length - cand.environments.length;
+      if (cand.write) {
+        cand.write.justification = kept;
+        continue;
+      }
+      toWrite.push({
+        subject: cand.subject,
+        predicate: cand.predicate,
+        object: cand.object,
+        justification: kept,
+        ...bestEnvironmentTrustOpts(cand.provenance, kept, (pid) => rowById.get(pid)?.trust) || {}
+      });
+    }
     const { ids } = await appendFacts2(repoDir, toWrite);
     const written = [];
     let i = 0;
@@ -8183,7 +8429,27 @@ ${bodyText}` : graphText, tier });
       written.push({ id: ids[i], subject: d.subject, object: d.object, via: d.viaY1, rule: SCM_SVF_RULE });
       i += 1;
     }
-    return { derived: written, count: written.length, budget, depth, truncated: written.length >= budget };
+    const truncated = written.length >= budget;
+    if (normalizedFocus === null && stateFnsPresent && !truncated) {
+      const factIds = new Set(currentIdSet);
+      for (const id of ids) factIds.add(id);
+      await store.saveSyllogiseState(repoDir, {
+        version: 1,
+        factIds: [...factIds].sort(),
+        completedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+    return {
+      derived: written,
+      count: written.length,
+      budget,
+      depth,
+      truncated,
+      mode,
+      deltaSize,
+      environmentsAdded,
+      alternatesTruncated
+    };
   }
   function isPurelyEntailed(provenance) {
     const tags = String(provenance || "").split(" | ").filter(Boolean);
@@ -8254,8 +8520,185 @@ ${bodyText}` : graphText, tier });
       return true;
     };
   }
-  async function retractSubClassOf(repoDir, subject, object, { budget = 50, depth = 32, store } = {}) {
+  function buildSupportEnumerator(rows) {
+    const storedIds = /* @__PURE__ */ new Set();
+    const subClassEdges = [];
+    const succ = /* @__PURE__ */ new Map();
+    const typesOf = /* @__PURE__ */ new Map();
+    const disjointForward = /* @__PURE__ */ new Set();
+    const disjointOf = /* @__PURE__ */ new Map();
+    const onPropertyOf = /* @__PURE__ */ new Map();
+    const someValuesFromOf = /* @__PURE__ */ new Map();
+    const propertyEdgesOf = /* @__PURE__ */ new Map();
+    for (const r of rows) {
+      if (!r || !r.subject || !r.predicate || !r.object) continue;
+      if (r.id) storedIds.add(r.id);
+      const pLower = String(r.predicate || "").trim().toLowerCase();
+      if (isSubClassOf(r.predicate)) {
+        subClassEdges.push([r.subject, r.object]);
+        if (!succ.has(r.subject)) succ.set(r.subject, /* @__PURE__ */ new Set());
+        succ.get(r.subject).add(r.object);
+      } else if (isType(r.predicate)) {
+        if (!typesOf.has(r.subject)) typesOf.set(r.subject, /* @__PURE__ */ new Set());
+        typesOf.get(r.subject).add(r.object);
+      } else if (isDisjoint(r.predicate)) {
+        disjointForward.add(`${r.subject}${SEP}${r.object}`);
+        if (!disjointOf.has(r.subject)) disjointOf.set(r.subject, /* @__PURE__ */ new Set());
+        disjointOf.get(r.subject).add(r.object);
+        if (!disjointOf.has(r.object)) disjointOf.set(r.object, /* @__PURE__ */ new Set());
+        disjointOf.get(r.object).add(r.subject);
+      } else if (isOnProperty(r.predicate)) onPropertyOf.set(r.subject, r.object);
+      else if (isSomeValuesFrom(r.predicate)) someValuesFromOf.set(r.subject, r.object);
+      else if (!RESERVED_PREDICATES.has(pLower)) {
+        if (!propertyEdgesOf.has(r.subject)) propertyEdgesOf.set(r.subject, []);
+        propertyEdgesOf.get(r.subject).push([r.predicate, r.object]);
+      }
+    }
+    const ancestorsOf2 = buildAncestorCloser(subClassEdges);
+    const succOf = (a) => succ.get(a) || /* @__PURE__ */ new Set();
+    const restrictionOf = (node) => {
+      const property = onPropertyOf.get(node);
+      const target = someValuesFromOf.get(node);
+      return property && target ? { property, propertyKey: normFactTerm(property), target } : null;
+    };
+    return (row, { maxEnvironments = DEFAULT_MAX_ENVIRONMENTS } = {}) => {
+      const out = [];
+      const seen = /* @__PURE__ */ new Set();
+      const admit = (env) => {
+        if (out.length >= maxEnvironments) return;
+        if (row.id && env.includes(row.id)) return;
+        if (!env.every((id) => storedIds.has(id))) return;
+        const key = [...env].sort().join(" ");
+        if (seen.has(key)) return;
+        seen.add(key);
+        out.push(env);
+      };
+      if (isSubClassOf(row.predicate)) {
+        for (const m of [...succOf(row.subject)].sort()) {
+          if (out.length >= maxEnvironments) break;
+          if (m === row.subject || m === row.object) continue;
+          if (!succOf(m).has(row.object)) continue;
+          admit([
+            factIdForTriple(row.subject, SUBCLASS_PREDICATE, m),
+            factIdForTriple(m, SUBCLASS_PREDICATE, row.object)
+          ]);
+        }
+        if (out.length < maxEnvironments) {
+          const r1 = restrictionOf(row.subject);
+          const r2 = restrictionOf(row.object);
+          if (r1 && r2 && r1.propertyKey === r2.propertyKey && r1.target !== r2.target && succOf(r1.target).has(r2.target)) {
+            admit([
+              factIdForTriple(row.subject, ON_PROPERTY_PREDICATE, r1.property),
+              factIdForTriple(row.subject, SOME_VALUES_FROM_PREDICATE, r1.target),
+              factIdForTriple(row.object, ON_PROPERTY_PREDICATE, r2.property),
+              factIdForTriple(row.object, SOME_VALUES_FROM_PREDICATE, r2.target),
+              factIdForTriple(r1.target, SUBCLASS_PREDICATE, r2.target)
+            ]);
+          }
+        }
+        return out;
+      }
+      if (isType(row.predicate)) {
+        for (const c of [...typesOf.get(row.subject) || []].sort()) {
+          if (out.length >= maxEnvironments) break;
+          if (c === row.object) continue;
+          if (!succOf(c).has(row.object)) continue;
+          admit([
+            factIdForTriple(row.subject, TYPE_PREDICATE, c),
+            factIdForTriple(c, SUBCLASS_PREDICATE, row.object)
+          ]);
+        }
+        const rec = restrictionOf(row.object);
+        if (rec) {
+          const edges = [...propertyEdgesOf.get(row.subject) || []].filter(([p]) => normFactTerm(p) === rec.propertyKey).sort((a, b) => a[0].localeCompare(b[0]) || a[1].localeCompare(b[1]));
+          for (const [p, y] of edges) {
+            if (out.length >= maxEnvironments) break;
+            for (const c of [...typesOf.get(y) || []].sort()) {
+              if (out.length >= maxEnvironments) break;
+              if (c !== rec.target && !succOf(c).has(rec.target)) continue;
+              admit([
+                factIdForTriple(row.subject, p, y),
+                factIdForTriple(y, TYPE_PREDICATE, c),
+                factIdForTriple(row.object, ON_PROPERTY_PREDICATE, rec.propertyKey),
+                factIdForTriple(row.object, SOME_VALUES_FROM_PREDICATE, rec.target),
+                ...c !== rec.target ? [factIdForTriple(c, SUBCLASS_PREDICATE, rec.target)] : []
+              ]);
+            }
+          }
+        }
+        return out;
+      }
+      if (isDisjoint(row.predicate)) {
+        const pairs = [];
+        for (const c of typesOf.get(row.subject) || []) {
+          for (const d of [c, ...ancestorsOf2(c)]) {
+            if ((disjointOf.get(d) || /* @__PURE__ */ new Set()).has(row.object)) pairs.push([c, d]);
+          }
+        }
+        pairs.sort((a, b) => a[0].localeCompare(b[0]) || a[1].localeCompare(b[1]));
+        for (const [c, d] of pairs) {
+          if (out.length >= maxEnvironments) break;
+          const dwStoredForward = disjointForward.has(`${d}${SEP}${row.object}`);
+          const [dwS, dwO] = dwStoredForward ? [d, row.object] : [row.object, d];
+          admit([
+            factIdForTriple(row.subject, TYPE_PREDICATE, c),
+            factIdForTriple(dwS, DISJOINT_PREDICATE, dwO),
+            ...d !== c ? [factIdForTriple(c, SUBCLASS_PREDICATE, d)] : []
+          ]);
+        }
+        return out;
+      }
+      return out;
+    };
+  }
+  function capMergeEnvironments(storedEnvs, discoveredEnvs, cap) {
+    const kept = [];
+    const seen = /* @__PURE__ */ new Set();
+    let truncated = false;
+    for (const env of [...storedEnvs || [], ...discoveredEnvs || []]) {
+      if (!Array.isArray(env) || !env.length) continue;
+      const key = [...env].sort().join(" ");
+      if (seen.has(key)) continue;
+      if (kept.length >= cap) {
+        truncated = true;
+        continue;
+      }
+      seen.add(key);
+      kept.push(env);
+    }
+    return { kept, truncated };
+  }
+  function bestEnvironmentTrustOpts(provenance, environments, trustOfId) {
+    let ruleConfidence;
+    for (const tag of String(provenance || "").split(" | ")) {
+      const rc = ENTAILED_RULE_CONFIDENCE_BY_TAG.get(tag);
+      if (rc !== void 0) {
+        ruleConfidence = rc;
+        break;
+      }
+    }
+    if (ruleConfidence === void 0) return null;
+    let best = null;
+    let bestMin = -1;
+    for (const env of environments || []) {
+      const trusts = env.map((id) => trustOfId(id)).filter((t) => typeof t === "number");
+      if (trusts.length !== env.length) continue;
+      const weakest = Math.min(...trusts);
+      if (weakest > bestMin) {
+        bestMin = weakest;
+        best = trusts;
+      }
+    }
+    return best ? { premiseTrusts: best, ruleConfidence } : null;
+  }
+  async function retractSubClassOf(repoDir, subject, object, {
+    budget = 50,
+    depth = 32,
+    maxEnvironments = DEFAULT_MAX_ENVIRONMENTS,
+    store
+  } = {}) {
     const { loadMemory: loadMemory2, readFactRows: readFactRows2, removeFacts: removeFacts2 } = requireStore(store, ["loadMemory", "readFactRows", "removeFacts"], "retractSubClassOf");
+    const appendFactsFn = typeof store?.appendFacts === "function" ? store.appendFacts : null;
     const s = normFactTerm(subject);
     const o = normFactTerm(object);
     const targetId = factIdForTriple(s, SUBCLASS_PREDICATE, o);
@@ -8263,28 +8706,58 @@ ${bodyText}` : graphText, tier });
     const rows = readFactRows2(memory);
     const byId = new Map(rows.map((r) => [r.id, r]));
     if (!byId.has(targetId)) return { retracted: [], count: 0, budget, depth, truncated: false, found: false };
-    const entailedRows = rows.filter((r) => r.justification.length && isPurelyEntailed(r.provenance));
+    const entailedRows = rows.filter((r) => environmentsOf(r).length && isPurelyEntailed(r.provenance));
+    const citedBy = /* @__PURE__ */ new Map();
+    for (const r of entailedRows) {
+      for (const env of environmentsOf(r)) {
+        for (const premiseId of env) {
+          if (!citedBy.has(premiseId)) citedBy.set(premiseId, /* @__PURE__ */ new Set());
+          citedBy.get(premiseId).add(r.id);
+        }
+      }
+    }
     const removed = /* @__PURE__ */ new Set([targetId]);
     const order = [targetId];
+    const reground = /* @__PURE__ */ new Map();
     let truncated = false;
     let round2 = 0;
+    let newlyRemoved = [targetId];
     for (; round2 < depth; round2 += 1) {
-      const candidates = entailedRows.filter((r) => !removed.has(r.id) && r.justification.some((j) => removed.has(j))).sort((a, b) => a.subject.localeCompare(b.subject) || a.predicate.localeCompare(b.predicate) || a.object.localeCompare(b.object));
+      const candidateIds = /* @__PURE__ */ new Set();
+      for (const id of newlyRemoved) {
+        for (const cited of citedBy.get(id) || []) {
+          if (!removed.has(cited)) candidateIds.add(cited);
+        }
+      }
+      const candidates = [...candidateIds].map((id) => byId.get(id)).sort((a, b) => a.subject.localeCompare(b.subject) || a.predicate.localeCompare(b.predicate) || a.object.localeCompare(b.object));
       if (!candidates.length) break;
-      const candidateIds = new Set(candidates.map((c) => c.id));
-      const stillDerivable = buildSurvivorDerivabilityCheck(
-        rows.filter((r) => !removed.has(r.id) && !candidateIds.has(r.id))
-      );
+      const survivors = rows.filter((r) => !removed.has(r.id) && !candidateIds.has(r.id));
+      const survivorIds = new Set(survivors.map((r) => r.id));
+      const enumerateSupport = buildSupportEnumerator(survivors);
+      const stillDerivable = buildSurvivorDerivabilityCheck(survivors);
       let progressed = false;
       let hitBudget = false;
+      newlyRemoved = [];
       for (const c of candidates) {
         if (removed.size >= budget) {
           hitBudget = true;
           break;
         }
+        const environments = environmentsOf(c);
+        const intact = environments.filter((env) => env.every((id) => survivorIds.has(id)));
+        if (intact.length) {
+          if (intact.length !== environments.length) reground.set(c.id, intact);
+          continue;
+        }
+        const fresh = enumerateSupport(c, { maxEnvironments });
+        if (fresh.length) {
+          reground.set(c.id, fresh);
+          continue;
+        }
         if (stillDerivable(c)) continue;
         removed.add(c.id);
         order.push(c.id);
+        newlyRemoved.push(c.id);
         progressed = true;
       }
       if (hitBudget) {
@@ -8297,6 +8770,20 @@ ${bodyText}` : graphText, tier });
       truncated = entailedRows.some((r) => !removed.has(r.id) && r.justification.some((j) => removed.has(j)));
     }
     const { removed: actuallyRemoved } = await removeFacts2(repoDir, order);
+    if (appendFactsFn) {
+      const regroundWrites = [...reground.entries()].filter(([id]) => !removed.has(id)).sort((a, b) => a[0].localeCompare(b[0])).map(([id, environments]) => {
+        const row = byId.get(id);
+        return {
+          subject: row.subject,
+          predicate: row.predicate,
+          object: row.object,
+          // provenance omitted — appendFacts' first-write-wins keeps the union
+          justification: environments,
+          ...bestEnvironmentTrustOpts(row.provenance, environments, (pid) => byId.get(pid)?.trust) || {}
+        };
+      });
+      if (regroundWrites.length) await appendFactsFn(repoDir, regroundWrites);
+    }
     return { retracted: actuallyRemoved, count: actuallyRemoved.length, budget, depth, truncated, found: true };
   }
   function findIsaChain(subj, targets, typeEdges, subClassEdges, { maxHops = 6 } = {}) {
@@ -8331,7 +8818,7 @@ ${bodyText}` : graphText, tier });
     }
     return null;
   }
-  var SUBCLASS_PREDICATE, SYLLOGISE_RULE, ENTAILED_PROVENANCE, TYPE_PREDICATE, CAX_SCO_RULE, ENTAILED_TYPE_PROVENANCE, DISJOINT_PREDICATE, CAX_DW_RULE, ENTAILED_DISJOINT_PROVENANCE, CAX_DW_RULE_CONFIDENCE, ON_PROPERTY_PREDICATE, SOME_VALUES_FROM_PREDICATE, CLS_SVF1_RULE, ENTAILED_SVF1_PROVENANCE, CLS_SVF1_RULE_CONFIDENCE, SEP, isSubClassOf, isType, isDisjoint, isOnProperty, isSomeValuesFrom, isOnClass, RESERVED_PREDICATES, HAS_PROPERTY_KEY, CARDINALITY_KIND_OF, SCM_SVF_RULE, ENTAILED_SCM_SVF_PROVENANCE, SCM_SVF_RULE_CONFIDENCE, CARDINALITY_RULE_CONFIDENCE, CAX_MAXC0_RULE_CONFIDENCE;
+  var SUBCLASS_PREDICATE, SYLLOGISE_RULE, ENTAILED_PROVENANCE, TYPE_PREDICATE, CAX_SCO_RULE, ENTAILED_TYPE_PROVENANCE, DISJOINT_PREDICATE, CAX_DW_RULE, ENTAILED_DISJOINT_PROVENANCE, CAX_DW_RULE_CONFIDENCE, ON_PROPERTY_PREDICATE, SOME_VALUES_FROM_PREDICATE, CLS_SVF1_RULE, ENTAILED_SVF1_PROVENANCE, CLS_SVF1_RULE_CONFIDENCE, DEFAULT_MAX_ENVIRONMENTS, SEP, isSubClassOf, isType, isDisjoint, isOnProperty, isSomeValuesFrom, isOnClass, RESERVED_PREDICATES, HAS_PROPERTY_KEY, CARDINALITY_KIND_OF, SCM_SVF_RULE, ENTAILED_SCM_SVF_PROVENANCE, SCM_SVF_RULE_CONFIDENCE, CARDINALITY_RULE_CONFIDENCE, CAX_MAXC0_RULE_CONFIDENCE, environmentsOf, ENTAILED_RULE_CONFIDENCE_BY_TAG;
   var init_syllogise = __esm({
     "src/domain/syllogise.mjs"() {
       init_hash();
@@ -8350,6 +8837,7 @@ ${bodyText}` : graphText, tier });
       CLS_SVF1_RULE = "someValuesFrom";
       ENTAILED_SVF1_PROVENANCE = `entailed:${CLS_SVF1_RULE}`;
       CLS_SVF1_RULE_CONFIDENCE = 0.95;
+      DEFAULT_MAX_ENVIRONMENTS = 4;
       SEP = "\u241F";
       isSubClassOf = (p) => String(p || "").trim().toLowerCase() === "rdfs:subclassof";
       isType = (p) => String(p || "").trim().toLowerCase() === "rdf:type";
@@ -8372,6 +8860,12 @@ ${bodyText}` : graphText, tier });
       SCM_SVF_RULE_CONFIDENCE = 0.95;
       CARDINALITY_RULE_CONFIDENCE = 0.95;
       CAX_MAXC0_RULE_CONFIDENCE = 0.95;
+      environmentsOf = (row) => row.environments || (Array.isArray(row.justification) && row.justification.length ? [row.justification] : []);
+      ENTAILED_RULE_CONFIDENCE_BY_TAG = /* @__PURE__ */ new Map([
+        [ENTAILED_DISJOINT_PROVENANCE, CAX_DW_RULE_CONFIDENCE],
+        [ENTAILED_SVF1_PROVENANCE, CLS_SVF1_RULE_CONFIDENCE],
+        [ENTAILED_SCM_SVF_PROVENANCE, SCM_SVF_RULE_CONFIDENCE]
+      ]);
     }
   });
 
@@ -8698,6 +9192,7 @@ ${bodyText}` : graphText, tier });
     SOURCE_CLASS: () => SOURCE_CLASS,
     SOURCE_RELIABILITY_PROP: () => SOURCE_RELIABILITY_PROP,
     STATED_BY_PROP: () => STATED_BY_PROP,
+    SYLLOGISE_STATE_REL: () => SYLLOGISE_STATE_REL,
     UPDATED_AT_PROP: () => UPDATED_AT_PROP,
     UTTERANCE_CLASS: () => UTTERANCE_CLASS,
     appendFact: () => appendFact,
@@ -8714,6 +9209,7 @@ ${bodyText}` : graphText, tier });
     findRuleByName: () => findRuleByName,
     findRulesByName: () => findRulesByName,
     loadMemory: () => loadMemory,
+    loadSyllogiseState: () => loadSyllogiseState,
     normFactPredicate: () => normFactPredicate,
     normFactTerm: () => normFactTerm,
     openMemoryBackend: () => openMemoryBackend,
@@ -8725,6 +9221,7 @@ ${bodyText}` : graphText, tier });
     resolveMemoryGraphFile: () => resolveMemoryGraphFile,
     resolveRelationChase: () => resolveRelationChase,
     resolveRelationChaseReverse: () => resolveRelationChaseReverse,
+    saveSyllogiseState: () => saveSyllogiseState,
     snapshotMemory: () => snapshotMemory
   });
   function emptyMemory() {
@@ -9035,7 +9532,9 @@ ${bodyText}` : graphText, tier });
     for (const ind of payload.individuals) {
       if (Array.isArray(ind?.derived_from) && ind.derived_from.length) ind.derived_from = ind.derived_from.map(remapId);
       const just = (ind?.attributes || []).find((a) => a?.prop === "mgx:factJustification");
-      if (just?.value) just.value = just.value.split(" ").filter(Boolean).map(remapId).join(" ");
+      if (just?.value) {
+        just.value = just.value.split(" | ").map((env) => env.split(" ").filter(Boolean).map(remapId).join(" ")).filter(Boolean).join(" | ");
+      }
     }
     return payload;
   }
@@ -9051,6 +9550,32 @@ ${bodyText}` : graphText, tier });
     await mkdir2(dirname(memoryGraphFile(dir)), { recursive: true });
     await atomicWriteJson(memoryGraphFile(dir), payload);
   }
+  async function loadSyllogiseState(dir) {
+    if (isMemoryHandle(dir)) return dir.syllogiseState ? structuredClone(dir.syllogiseState) : null;
+    if (isSqliteHandle(dir)) {
+      const row = dir.db.prepare("SELECT v FROM meta WHERE k = ?").get(SQLITE_SYLLOGISE_STATE_KEY);
+      return row?.v ? JSON.parse(row.v) : null;
+    }
+    try {
+      return JSON.parse(await readFile2(join(dir, SYLLOGISE_STATE_REL), "utf8"));
+    } catch (e) {
+      if (e?.code === "ENOENT") return null;
+      throw e;
+    }
+  }
+  async function saveSyllogiseState(dir, state) {
+    if (isMemoryHandle(dir)) {
+      dir.syllogiseState = structuredClone(state);
+      return;
+    }
+    if (isSqliteHandle(dir)) {
+      dir.db.prepare("INSERT OR REPLACE INTO meta(k, v) VALUES (?, ?)").run(SQLITE_SYLLOGISE_STATE_KEY, JSON.stringify(state));
+      return;
+    }
+    const file = join(dir, SYLLOGISE_STATE_REL);
+    await mkdir2(dirname(file), { recursive: true });
+    await atomicWriteJson(file, state);
+  }
   function buildMemoryIndex(payload) {
     const individualsById = /* @__PURE__ */ new Map();
     const sourcesById = /* @__PURE__ */ new Map();
@@ -9097,6 +9622,10 @@ ${bodyText}` : graphText, tier });
         return { id: `src:provider:${desc.name}`, type: "provider" };
       case "corpus":
         return { id: `src:corpus:${desc.name}`, type: "corpus" };
+      // One Source per pack article (the @revid stays in the article segment),
+      // so two facts from the same article corroborate nothing extra.
+      case "reference":
+        return { id: `src:reference:${desc.pack}:${desc.article}`, type: "reference" };
       // One Source per source-file basename, not per extraction run.
       case "extracted":
         return { id: `src:extracted:${desc.name}`, type: "extracted" };
@@ -9407,6 +9936,21 @@ ${bodyText}` : graphText, tier });
     });
     return { id };
   }
+  function normalizeJustificationEnvironments(justification) {
+    if (!Array.isArray(justification)) return void 0;
+    const rawEnvs = justification.some(Array.isArray) ? justification.filter(Array.isArray) : [justification];
+    const envs = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const raw of rawEnvs) {
+      const env = raw.filter((id) => typeof id === "string" && id);
+      if (!env.length) continue;
+      const key = [...env].sort().join(" ");
+      if (seen.has(key)) continue;
+      seen.add(key);
+      envs.push(env);
+    }
+    return envs.length ? envs : void 0;
+  }
   async function appendFacts(dir, facts) {
     const prepared = [];
     let skipped = 0;
@@ -9432,7 +9976,7 @@ ${bodyText}` : graphText, tier });
         quantifier: normText(f?.quantifier),
         premiseTrusts: Array.isArray(f?.premiseTrusts) ? f.premiseTrusts : void 0,
         ruleConfidence: typeof f?.ruleConfidence === "number" ? f.ruleConfidence : void 0,
-        justification: Array.isArray(f?.justification) ? f.justification.filter(Boolean) : void 0
+        environments: normalizeJustificationEnvironments(f?.justification)
       });
     }
     const ids = [];
@@ -9465,7 +10009,7 @@ ${bodyText}` : graphText, tier });
             ...provs.length ? [{ prop: "mgx:factProvenance", key: "provenance", value: provs.join(" | ") }] : [],
             ...f.tokens.length ? [{ prop: "mgx:hasProseTokens", key: "prose_tokens", value: f.tokens.join(" ") }] : [],
             ...qVal ? [{ prop: "mgx:factQuantifier", key: "quantifier", value: qVal }] : [],
-            ...f.justification && f.justification.length ? [{ prop: "mgx:factJustification", key: "justification", value: f.justification.join(" ") }] : []
+            ...f.environments ? [{ prop: "mgx:factJustification", key: "justification", value: f.environments.map((e) => e.join(" ")).join(" | ") }] : []
           ]
         };
         const stored = upsertIndividual(payload, ind);
@@ -9700,6 +10244,22 @@ ${bodyText}` : graphText, tier });
       const sourceIds = byFact.get(ind.id) || [];
       const sourceTypes = sourceIds.map((id) => (sourcesById.get(id)?.attributes || []).find((a) => a?.prop === "mgx:sourceType")?.value).filter(Boolean);
       const justificationRaw = get("justification");
+      const environments = [];
+      if (justificationRaw) {
+        for (const chunk of justificationRaw.split(" | ")) {
+          const env = chunk.split(" ").filter(Boolean);
+          if (env.length) environments.push(env);
+        }
+      }
+      const justification = [];
+      const seenPremise = /* @__PURE__ */ new Set();
+      for (const env of environments) {
+        for (const id of env) {
+          if (seenPremise.has(id)) continue;
+          seenPremise.add(id);
+          justification.push(id);
+        }
+      }
       rows.push({
         id: ind.id,
         subject: get("subject"),
@@ -9712,9 +10272,11 @@ ${bodyText}` : graphText, tier });
         sourceIds,
         sourceTypes,
         trust: Number((ind.attributes || []).find((a) => a?.prop === TRUST_SCORE_PROP)?.value) || 0,
-        // [] unless a rule persisted its premise fact ids (justification-tracking,
-        // scm-sco only today; see syllogise.mjs).
-        justification: justificationRaw ? justificationRaw.split(" ").filter(Boolean) : []
+        // `environments`: every persisted premise set (empty unless entailed);
+        // `justification`: their deduped union in first-occurrence order, for
+        // readers that only need "which premises does this fact cite at all".
+        environments,
+        justification
       });
     }
     return rows;
@@ -9759,7 +10321,7 @@ ${bodyText}` : graphText, tier });
     }
     return out.sort((a, b) => `${a[0].subject} ${a[0].predicate}`.localeCompare(`${b[0].subject} ${b[0].predicate}`));
   }
-  var MEMORY_DIR_REL, MEMORY_GRAPH_REL, UTTERANCE_CLASS, FACT_CLASS, MEMORY_SESSION_CLASS, SOURCE_CLASS, RULE_CLASS, SAID_IN_SESSION_PROP, IN_REPLY_TO_PROP, DERIVED_FROM_PROP, STATED_BY_PROP, CANONICALISED_FROM_PROP, SOURCE_RELIABILITY_PROP, OPERATOR_SOURCE_ID, TEACH_SOURCE_ID, ROLES, LABEL_CAP, MEMORY_VOCABULARY, memoryGraphFile, BACKEND_MEMORY, BACKEND_SQLITE, SQLITE_DDL, STD_EDGE_KEYS, cloneJson, MEMORY_MANIFEST_REL, DEFAULT_RETENTION, resolveManifestFile, LEGACY_FACT_ID_RE, MEMORY_INDEX, memoryIndexOf, labelOf, nowIso, sourceLabel, PROV_CLASS_BY_SOURCE_TYPE, isSessionScopedSourceId, RULE_KIND_COMPOSE2, RULE_KIND_FILTER, RULE_KIND_RECURSIVE, RULE_KIND_ACTION_SIGNATURE, RULE_KIND_ACTION_PRECOND, RULE_KIND_ACTION_EFFECT, RULE_KIND_ACTION_CONSTRAINT, RULE_KINDS2, RULE_NAME_PROP, RULE_KIND_PROP, RULE_SLOT_SPEC, ruleIdFor, CONTRADICTION_TRUST_FLOOR, HAS_A_PREDICATE, CAPABLE_OF_PREDICATE2, MULTI_VALUED_PREDICATES;
+  var MEMORY_DIR_REL, MEMORY_GRAPH_REL, UTTERANCE_CLASS, FACT_CLASS, MEMORY_SESSION_CLASS, SOURCE_CLASS, RULE_CLASS, SAID_IN_SESSION_PROP, IN_REPLY_TO_PROP, DERIVED_FROM_PROP, STATED_BY_PROP, CANONICALISED_FROM_PROP, SOURCE_RELIABILITY_PROP, OPERATOR_SOURCE_ID, TEACH_SOURCE_ID, ROLES, LABEL_CAP, MEMORY_VOCABULARY, memoryGraphFile, BACKEND_MEMORY, BACKEND_SQLITE, SQLITE_DDL, STD_EDGE_KEYS, cloneJson, MEMORY_MANIFEST_REL, DEFAULT_RETENTION, resolveManifestFile, LEGACY_FACT_ID_RE, SYLLOGISE_STATE_REL, SQLITE_SYLLOGISE_STATE_KEY, MEMORY_INDEX, memoryIndexOf, labelOf, nowIso, sourceLabel, PROV_CLASS_BY_SOURCE_TYPE, isSessionScopedSourceId, RULE_KIND_COMPOSE2, RULE_KIND_FILTER, RULE_KIND_RECURSIVE, RULE_KIND_ACTION_SIGNATURE, RULE_KIND_ACTION_PRECOND, RULE_KIND_ACTION_EFFECT, RULE_KIND_ACTION_CONSTRAINT, RULE_KINDS2, RULE_NAME_PROP, RULE_KIND_PROP, RULE_SLOT_SPEC, ruleIdFor, CONTRADICTION_TRUST_FLOOR, HAS_A_PREDICATE, CAPABLE_OF_PREDICATE2, MULTI_VALUED_PREDICATES;
   var init_core = __esm({
     "src/adapters/memory/core.mjs"() {
       init_promises();
@@ -9801,6 +10363,7 @@ ${bodyText}` : graphText, tier });
         { prop: "rdf:object", note: "reified fact: the triple's object term" },
         { prop: "mgx:factProvenance", note: "LEGACY COMPAT SHIM: the ' | '-joined provenance tag string a fact came from; the source-of-truth is now the mgx:statedBy edges derived from it" },
         { prop: "mgx:factQuantifier", note: "OPTIONAL: the quantifier word a plural class-membership teach used ('every'/'some'/'a few'), for literal recall by 'how many Xs are Ys' \u2014 never real cardinality counting" },
+        { prop: "mgx:factJustification", note: "an entailed Fact's supporting premise fact ids: ' | '-separated environments, one space-separated premise-id list per independent derivation, capped by syllogise's maxEnvironments knob; a value with no ' | ' is a single environment" },
         { prop: "mgx:ruleName", note: "a taught Rule's own name (e.g. 'grandparent') \u2014 the query-dispatcher's lookup key, PLAN_TAUGHT_RELATIONS.md \xA72/\xA73" },
         { prop: "mgx:ruleKind", note: "a taught Rule's SHAPE tag \u2014 the closed vocabulary compose2 | filter | recursive (structural, like 'Fact'/'Rule' themselves, never a domain word)" },
         { prop: "mgx:ruleBase1", note: "compose2: the first hop's base relation name; filter: the base rule/relation being filtered (same 'base relation' role in both kinds, so the name is shared)" },
@@ -9813,7 +10376,7 @@ ${bodyText}` : graphText, tier });
         { prop: DERIVED_FROM_PROP, predicate: "derivedFrom", note: "umbrella: a Fact derived from a Source (or another Fact). ext ref prov:wasDerivedFrom (UNVERIFIED-pending-web-check)" },
         { prop: STATED_BY_PROP, predicate: "statedBy", note: "subPropertyOf derivedFrom: a Source directly asserts this Fact (one edge per independent source \u2014 replaces the factProvenance union)" },
         { prop: CANONICALISED_FROM_PROP, predicate: "canonicalisedFrom", note: "subPropertyOf derivedFrom: a canonical Fact cleaned from a raw Block/Source, never replacing it" },
-        { prop: "mgx:sourceType", note: "a Source's kind: operator | teach | provider | corpus | corpusWeak | extracted | web | entailed (the trust-prior key)" },
+        { prop: "mgx:sourceType", note: "a Source's kind: operator | teach | provider | corpus | corpusWeak | reference | extracted | web | entailed (the trust-prior key)" },
         { prop: "mgx:sourceUrl", note: "a web Source's URL" },
         { prop: "mgx:sourceRule", note: "an entailed Source's rule id" },
         { prop: "mgx:sourceReliability", note: "actor-level (session-scoped) trust nudge in [0.5,1.5], neutral 1.0 when absent \u2014 materialised by recomputeSourceReliability from a session's asserted-vs-contradicted track record (memory/trust.mjs's sessionReliabilityFrom); folds into computeTrust's per-source prior" },
@@ -9839,6 +10402,8 @@ CREATE INDEX IF NOT EXISTS edges_by_prop ON edges(prop);
       DEFAULT_RETENTION = 5;
       resolveManifestFile = (dir) => join(dir, MEMORY_MANIFEST_REL);
       LEGACY_FACT_ID_RE = /^fact:[0-9a-f]{8}$/;
+      SYLLOGISE_STATE_REL = join(MEMORY_DIR_REL, "syllogise-state.json");
+      SQLITE_SYLLOGISE_STATE_KEY = "syllogiseState";
       MEMORY_INDEX = /* @__PURE__ */ Symbol("mutateMemory lookup index");
       memoryIndexOf = (payload) => payload?.[MEMORY_INDEX] || null;
       labelOf = (text) => text.length > LABEL_CAP ? text.slice(0, LABEL_CAP - 1) + "\u2026" : text;
@@ -9850,6 +10415,7 @@ CREATE INDEX IF NOT EXISTS edges_by_prop ON edges(prop);
         provider: { subClass: "tmct:AgentSource", prov: "prov:Agent" },
         corpus: { subClass: "tmct:DocumentSource", prov: "prov:Entity" },
         corpusWeak: { subClass: "tmct:DocumentSource", prov: "prov:Entity" },
+        reference: { subClass: "tmct:DocumentSource", prov: "prov:Entity" },
         web: { subClass: "tmct:DocumentSource", prov: "prov:Entity" },
         extracted: { subClass: "tmct:DocumentSource", prov: "prov:Entity" },
         entailed: { subClass: "tmct:ActivitySource", prov: "prov:Activity" }
@@ -21187,6 +21753,19 @@ ${codeblock}`, options);
       inputSchema: classArg("The class to walk the inheritance edges of."),
       example: { class: "Field" }
     },
+    {
+      name: "tmct_related",
+      tier: "cold",
+      summary: "A term's synonyms (skos:altLabel) and related concepts (skos:related), from the memory graph's relation facts.",
+      inputSchema: {
+        type: "object",
+        required: ["term"],
+        properties: {
+          term: { type: "string", description: "The term whose synonyms / related concepts you want." }
+        }
+      },
+      example: { term: "sofa" }
+    },
     {
       name: "tmct_architecture",
       tier: "cold",
@@ -21770,6 +22349,110 @@ ${hint}` : ""}${cand}`;
     resolveOrThrow(svc, symbol, "class");
   }
 
+  // src/tools/handlers/tmct-related.mjs
+  init_config();
+
+  // src/domain/skos-view.mjs
+  init_hash();
+  var SKOS_NS = "http://www.w3.org/2004/02/skos/core#";
+  var DEFAULT_RELATION_MAP = {
+    synonym: ["mgx:synonym"],
+    related: ["mgx:relatedTo", "mgx:similarTo"]
+  };
+  function buildSkosConceptView(rows, { conceptBase = "concept:", relationMap = DEFAULT_RELATION_MAP } = {}) {
+    const synonymPreds = new Set(relationMap.synonym || []);
+    const relatedPreds = new Set(relationMap.related || []);
+    const parent = /* @__PURE__ */ new Map();
+    const ensure = (t) => {
+      if (!parent.has(t)) parent.set(t, t);
+    };
+    const find = (x) => {
+      let r = x;
+      while (parent.get(r) !== r) r = parent.get(r);
+      while (parent.get(x) !== r) {
+        const next = parent.get(x);
+        parent.set(x, r);
+        x = next;
+      }
+      return r;
+    };
+    const union = (a, b) => {
+      const ra = find(a), rb = find(b);
+      if (ra === rb) return;
+      if (ra < rb) parent.set(rb, ra);
+      else parent.set(ra, rb);
+    };
+    const relatedRaw = [];
+    for (const r of rows) {
+      const p = r.predicate;
+      if (!synonymPreds.has(p) && !relatedPreds.has(p)) continue;
+      const s = normFactTerm(r.subject), o = normFactTerm(r.object);
+      if (!s || !o) continue;
+      ensure(s);
+      ensure(o);
+      if (synonymPreds.has(p)) union(s, o);
+      else relatedRaw.push({ s, o });
+    }
+    const iriFor = (rep) => conceptBase + rep.replace(/ /g, "_");
+    const componentTerms = /* @__PURE__ */ new Map();
+    for (const t of parent.keys()) {
+      const rep = find(t);
+      if (!componentTerms.has(rep)) componentTerms.set(rep, /* @__PURE__ */ new Set());
+      componentTerms.get(rep).add(t);
+    }
+    const concepts = [];
+    for (const [rep, terms] of componentTerms) {
+      const sorted = [...terms].sort();
+      concepts.push({ id: iriFor(rep), prefLabel: rep, altLabels: sorted.filter((t) => t !== rep) });
+    }
+    concepts.sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+    const seen = /* @__PURE__ */ new Set();
+    const related = [];
+    for (const { s, o } of relatedRaw) {
+      const cs = iriFor(find(s)), co = iriFor(find(o));
+      if (cs === co) continue;
+      const key = cs < co ? `${cs}\0${co}` : `${co}\0${cs}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      related.push({ subject: cs, object: co });
+    }
+    related.sort((a, b) => `${a.subject}${a.object}` < `${b.subject}${b.object}` ? -1 : 1);
+    const conceptIdForTerm = (term) => {
+      const t = normFactTerm(term);
+      return parent.has(t) ? iriFor(find(t)) : null;
+    };
+    return { concepts, related, conceptIdForTerm, namespace: SKOS_NS };
+  }
+  function relatedForTerm(rows, term, options = {}) {
+    const view = buildSkosConceptView(rows, options);
+    const conceptId = view.conceptIdForTerm(term);
+    if (!conceptId) return null;
+    const byId = new Map(view.concepts.map((c) => [c.id, c]));
+    const concept = byId.get(conceptId);
+    const queried = normFactTerm(term);
+    const synonyms = [concept.prefLabel, ...concept.altLabels].filter((label) => label !== queried);
+    const related = view.related.filter((r) => r.subject === conceptId || r.object === conceptId).map((r) => byId.get(r.subject === conceptId ? r.object : r.subject)).filter(Boolean);
+    return { conceptId, prefLabel: concept.prefLabel, altLabels: concept.altLabels, synonyms, related };
+  }
+
+  // src/tools/handlers/tmct-related.mjs
+  init_memory_fallthrough();
+  async function tmct_related(args, { config }) {
+    const term = requiredArg(args, "term");
+    const hit2 = relatedForTerm(await memoryFactRows(config), term);
+    if (!hit2) {
+      throw new ToolError(
+        `no synonym or related facts for "${term}" in the memory graph. This view answers where the store holds mgx:synonym / mgx:relatedTo facts (a corpus import seeds them).`
+      );
+    }
+    const lines = [`${hit2.prefLabel} [${hit2.conceptId}]`];
+    if (hit2.synonyms.length) lines.push(`synonyms (skos:altLabel): ${hit2.synonyms.join(", ")}`);
+    if (hit2.related.length) lines.push(`related (skos:related): ${hit2.related.map((c) => c.prefLabel).join(", ")}`);
+    lines.push("(from the memory graph's mgx:synonym / mgx:relatedTo / mgx:similarTo facts)");
+    return lines.join("\n");
+  }
+  tmct_related.ownsGraphLoad = true;
+
   // src/tools/handlers/tmct-architecture.mjs
   init_codegraph();
   function tmct_architecture(args, { graph }) {
@@ -21847,6 +22530,7 @@ ${JSON.stringify(envelope, null, 2)}`;
     tmct_search,
     tmct_members,
     tmct_subclasses,
+    tmct_related,
     tmct_architecture,
     tmct_exports,
     tmct_untested,
@@ -22326,7 +23010,15 @@ ${JSON.stringify(envelope, null, 2)}`;
     "i"
   );
   var GOAL_TEACH_IMPERATIVE_RE = new RegExp(
-    `^(?:get|put|place)\\s+(?:(every|each|all|both)\\s+)?(?:the\\s+)?([\\w-]+?)\\s+(${PREP_SRC})\\s+([\\w-]+)[?.!]*$`,
+    `^(?:get|put|place|stack)\\s+(?:(every|each|all|both)\\s+)?(?:the\\s+)?([\\w-]+?)\\s+(${PREP_SRC})\\s+([\\w-]+)[?.!]*$`,
+    "i"
+  );
+  var GOAL_TEACH_NP_RE = new RegExp(
+    `^the\\s+goal\\s+is\\s+(?:(every|each|all|both)\\s+)?(?:the\\s+)?([\\w-]+?)\\s+(${PREP_SRC})\\s+([\\w-]+)[?.!]*$`,
+    "i"
+  );
+  var GOAL_CONJUNCT_RE = new RegExp(
+    `^(?:(every|each|all)\\s+)?([\\w-]+)\\s+([a-z]+s)\\s+(${PREP_SRC})\\s+([\\w-]+)$`,
     "i"
   );
   var BOARD_REVERSE_LOC_RE = new RegExp(
@@ -22533,6 +23225,13 @@ ${JSON.stringify(envelope, null, 2)}`;
     if (hit2) return { text: `yes \u2014 ${renderFactLine(hit2)}`, replace: true };
     return null;
   }
+  function isaInconsistencyRefusal(posFact, disjointFact) {
+    const cite = (f) => `${factPhrase(f)}${f.provenance ? ` (source: ${f.provenance})` : ""}`;
+    return {
+      text: `you've told me both ${cite(posFact)} and ${cite(disjointFact)} \u2014 together those contradict, and I won't derive an answer from an inconsistency. To settle it, say "forget that ${posFact.subject} is ${indefiniteArticleFor(posFact.object)} ${posFact.object}".`,
+      replace: true
+    };
+  }
   function renderIsaChain(premises) {
     const step = (f) => `${factPhrase(f)}${f.provenance ? ` (source: ${f.provenance})` : ""}`;
     const first = premises[0];
@@ -22588,6 +23287,12 @@ ${JSON.stringify(envelope, null, 2)}`;
       return raw;
     }
   }
+  function suggestibleSubjectPhrase(subject) {
+    const m = String(subject || "").trim().match(/^(?:all|every|each|both|most|some)\s+([\w-]+)$/i);
+    if (!m) return teachableSubjectOf(subject);
+    const singular = teachableSubjectOf(singularizeSurface(m[1]));
+    return `${indefiniteArticleFor(singular)} ${singular}`;
+  }
   var QUANTIFIER_LEAD_RE = /^(?:every|each|all|any)\s+/i;
   function factTermVariants(normFactTerm2, term) {
     const t = normFactTerm2(term);
@@ -23067,8 +23772,13 @@ ${shown.map(renderFactLine).join("\n")}`,
     if (isa) {
       const subj = factTermVariants(normFactTerm2, isa[1]);
       const obj = factTermVariants(normFactTerm2, isa[2]);
-      const isaRows = await memoryFacts(memoryDir);
+      const isaRows = await factRows(memoryDir, cache2);
       const onTerms = (f) => subj.has(f.subject) && obj.has(f.object);
+      const { DISJOINT_PREDICATE: DISJOINT_PREDICATE2 } = await Promise.resolve().then(() => (init_syllogise(), syllogise_exports));
+      const touchesAskedTerm = (f) => subj.has(f.subject) || subj.has(f.object) || obj.has(f.subject) || obj.has(f.object);
+      if (isaRows.some((f) => f.predicate === DISJOINT_PREDICATE2 && isOperatorTaught(f) && touchesAskedTerm(f))) {
+        return null;
+      }
       const reply = isaPolarityReply(
         isaRows.find((f) => ISA_PREDICATES2.has(f.predicate) && onTerms(f)),
         isaRows.find((f) => f.predicate === NEG_SUBCLASS_PREDICATE && onTerms(f))
@@ -23096,10 +23806,20 @@ ${shown.map(renderFactLine).join("\n")}`,
     if (doesHave) {
       const subj = factTermVariants(normFactTerm2, doesHave[1]);
       const obj = factTermVariants(normFactTerm2, doesHave[2]);
-      const hit2 = (await memoryFacts(memoryDir)).find(
-        (f) => f.predicate === "mgx:hasA" && subj.has(f.subject) && obj.has(f.object)
+      const HAS_PREDICATES = /* @__PURE__ */ new Set(["mgx:hasA", "tmct:has"]);
+      const facts = await memoryFacts(memoryDir);
+      const hasHit = (subjectSet) => facts.find(
+        (f) => HAS_PREDICATES.has(f.predicate) && subjectSet.has(f.subject) && obj.has(f.object)
       );
+      const hit2 = hasHit(subj);
       if (hit2) return { text: `yes \u2014 ${renderFactLine(hit2)}`, replace: true };
+      const isaStep = facts.find((f) => ISA_PREDICATES2.has(f.predicate) && subj.has(f.subject));
+      if (isaStep) {
+        const lifted = hasHit(factTermVariants(normFactTerm2, isaStep.object));
+        if (lifted) {
+          return { text: `yes \u2014 ${renderFactLine(isaStep)}; ${renderFactLine(lifted)}`, replace: true };
+        }
+      }
       return null;
     }
     const doAsk = positiveQuestionSurface(q).match(DO_VERB_ASK_RE);
@@ -23128,6 +23848,14 @@ ${shown.map(renderFactLine).join("\n")}`,
         }
         const base = capabilityBaseRateReply(doAsk[2], doAsk[3], facts);
         if (base) return base;
+        if (!/\s/.test(doAsk[2].trim()) && !facts.some((f) => subj.has(f.subject) || subj.has(f.object))) {
+          const noun = singularizeSurface(teachableSubjectOf(doAsk[2]));
+          return {
+            text: `I can't confirm that \u2014 I don't know anything about "${doAsk[2]}" yet. Teach me "a ${noun} can ${doAsk[3]}" (or "a ${noun} cannot ${doAsk[3]}") and I'll remember it.`,
+            replace: true,
+            miss: true
+          };
+        }
       }
     }
     const canDo = q.match(WHAT_CAN_DO_RE);
@@ -23550,11 +24278,55 @@ ${shown.join("\n")}${extra}`, replace: true, ...rest.length ? { pending: { items
       const objVariants = factTermVariants(normFactTerm2, stripTrailingDiscourseTag(isaAsk[2]));
       const isaSubject = focusLabel && IS_ADJECTIVE_PRONOUN_RE.test(isaAsk[1].trim()) ? focusLabel : isaAsk[1];
       const subjCandidates = new Set(factTermVariants(normFactTerm2, isaSubject));
+      if ([...subjCandidates].some((s) => objVariants.has(s))) {
+        const kindEcho = stripTrailingDiscourseTag(isaAsk[2]).trim();
+        return {
+          text: `yes \u2014 ${indefiniteArticleFor(kindEcho)} ${kindEcho} is ${indefiniteArticleFor(kindEcho)} ${kindEcho}, trivially: every kind is a kind of itself.`,
+          replace: true
+        };
+      }
       const noun = await entityClassNoun(graph, isaSubject);
       if (noun) for (const v of factTermVariants(normFactTerm2, noun)) subjCandidates.add(v);
+      const {
+        findIsaChain: findIsaChain2,
+        deriveDisjointViolations: deriveDisjointViolations2,
+        SUBCLASS_PREDICATE: SC_PREDICATE,
+        TYPE_PREDICATE: RDF_TYPE_PREDICATE,
+        DISJOINT_PREDICATE: DISJOINT_PREDICATE2
+      } = await Promise.resolve().then(() => (init_syllogise(), syllogise_exports));
+      const isTaught = isOperatorTaught;
+      const chainSubClassRows = isa.filter((f) => f.predicate === SC_PREDICATE && isTaught(f));
+      const chainTypeRows = isa.filter((f) => f.predicate === RDF_TYPE_PREDICATE && isTaught(f));
+      const chainSubClassEdges = chainSubClassRows.map((f) => [f.subject, f.object]);
+      const chainTypeEdges = chainTypeRows.map((f) => [f.subject, f.object]);
+      const mixedSubClassRows = isa.filter((f) => f.predicate === SC_PREDICATE);
+      const mixedTypeRows = isa.filter((f) => f.predicate === RDF_TYPE_PREDICATE);
+      const mixedTypeEdges = mixedTypeRows.map((f) => [f.subject, f.object]);
+      const mixedSubClassEdges = mixedSubClassRows.map((f) => [f.subject, f.object]);
+      const disjointRows = rows.filter((f) => f.predicate === DISJOINT_PREDICATE2 && isTaught(f));
+      const disjointEdges = disjointRows.map((f) => [f.subject, f.object]);
+      const disjointGateViolations = disjointRows.length ? deriveDisjointViolations2(
+        mixedTypeEdges.concat(mixedSubClassEdges),
+        mixedSubClassEdges,
+        disjointEdges,
+        { budget: 20, focus: /* @__PURE__ */ new Set([...subjCandidates, ...objVariants]) }
+      ) : [];
+      const disjointRefusalFor = (subj) => {
+        const v = disjointGateViolations.find((vv) => vv.subject === subj && objVariants.has(vv.object));
+        if (!v) return null;
+        const posFact = isa.filter((f) => objVariants.has(f.object) && (f.subject === v.viaClass || f.subject === v.subject)).sort(byTrust)[0];
+        const disjointFact = disjointRows.find((f) => f.subject === v.viaClass && f.object === v.object || f.subject === v.object && f.object === v.viaClass);
+        if (!posFact || !disjointFact) return null;
+        return isaInconsistencyRefusal(posFact, disjointFact);
+      };
       const hit2 = isa.filter((f) => subjCandidates.has(f.subject) && objVariants.has(f.object)).sort(byTrust)[0];
       const negHit = rows.filter((f) => f.predicate === NEG_SUBCLASS_PREDICATE && subjCandidates.has(f.subject) && objVariants.has(f.object)).sort(byTrust)[0];
-      const polarityReply = isaPolarityReply(hit2, negHit);
+      const directDisjoint = disjointRows.find((f) => subjCandidates.has(f.subject) && objVariants.has(f.object) || subjCandidates.has(f.object) && objVariants.has(f.subject));
+      if (hit2 && !negHit) {
+        const chainRefusal = disjointRefusalFor(hit2.subject);
+        if (chainRefusal) return chainRefusal;
+      }
+      const polarityReply = isaPolarityReply(hit2, negHit || directDisjoint);
       if (polarityReply) return polarityReply;
       const ent = await resolveEntity(graph, isaSubject);
       if (ent) {
@@ -23572,34 +24344,26 @@ ${shown.join("\n")}${extra}`, replace: true, ...rest.length ? { pending: { items
           };
         }
       }
-      const { findIsaChain: findIsaChain2, SUBCLASS_PREDICATE: SC_PREDICATE, TYPE_PREDICATE: RDF_TYPE_PREDICATE } = await Promise.resolve().then(() => (init_syllogise(), syllogise_exports));
-      const isTaught = isOperatorTaught;
-      const chainSubClassRows = isa.filter((f) => f.predicate === SC_PREDICATE && isTaught(f));
-      const chainTypeRows = isa.filter((f) => f.predicate === RDF_TYPE_PREDICATE && isTaught(f));
-      const chainSubClassEdges = chainSubClassRows.map((f) => [f.subject, f.object]);
-      const chainTypeEdges = chainTypeRows.map((f) => [f.subject, f.object]);
       const factForStep = (step) => (step.predicate === SC_PREDICATE ? chainSubClassRows : chainTypeRows).find((f) => f.subject === step.subject && f.object === step.object);
       for (const subj of subjCandidates) {
         const chain = findIsaChain2(subj, objVariants, chainTypeEdges, chainSubClassEdges, { maxHops: 2 });
         if (!chain) continue;
+        const chainRefusal = disjointRefusalFor(subj);
+        if (chainRefusal) return chainRefusal;
         const premises = chain.map(factForStep);
         if (premises.every(Boolean)) return { text: `yes \u2014 ${renderIsaChain(premises)}`, replace: true };
       }
-      const mixedSubClassRows = isa.filter((f) => f.predicate === SC_PREDICATE);
-      const mixedTypeRows = isa.filter((f) => f.predicate === RDF_TYPE_PREDICATE);
       const mixedFactForStep = (step) => (step.predicate === SC_PREDICATE ? mixedSubClassRows : mixedTypeRows).find((f) => f.subject === step.subject && f.object === step.object);
-      const mixedTypeEdges = mixedTypeRows.map((f) => [f.subject, f.object]);
-      const mixedSubClassEdges = mixedSubClassRows.map((f) => [f.subject, f.object]);
       for (const subj of subjCandidates) {
         const chain = findIsaChain2(subj, objVariants, mixedTypeEdges, mixedSubClassEdges, { maxHops: 2 });
         if (!chain) continue;
+        const chainRefusal = disjointRefusalFor(subj);
+        if (chainRefusal) return chainRefusal;
         const premises = chain.map(mixedFactForStep);
         if (premises.every(Boolean) && premises.some(isTaught)) {
           return { text: `yes \u2014 ${renderIsaChain(premises)}`, replace: true };
         }
       }
-      const { deriveDisjointViolations: deriveDisjointViolations2, DISJOINT_PREDICATE: DISJOINT_PREDICATE2 } = await Promise.resolve().then(() => (init_syllogise(), syllogise_exports));
-      const disjointRows = rows.filter((f) => f.predicate === DISJOINT_PREDICATE2 && isTaught(f));
       const negSubjectMatch = isaSubject.match(/^(.*\S)\s+not$/i);
       const negSubject = negSubjectMatch && [
         negSubjectMatch[0],
@@ -23621,14 +24385,16 @@ ${shown.join("\n")}${extra}`, replace: true, ...rest.length ? { pending: { items
         };
       }
       if (disjointRows.length) {
-        const directDisjoint = disjointRows.find((f) => subjCandidates.has(f.subject) && objVariants.has(f.object) || subjCandidates.has(f.object) && objVariants.has(f.subject));
-        if (directDisjoint) return { text: `no \u2014 ${renderFactLine(directDisjoint)}`, replace: true };
-        const disjointEdges = disjointRows.map((f) => [f.subject, f.object]);
-        const violations = deriveDisjointViolations2(chainTypeEdges, chainSubClassEdges, disjointEdges, { budget: 10 });
+        const violations = deriveDisjointViolations2(
+          chainTypeEdges.concat(chainSubClassEdges),
+          chainSubClassEdges,
+          disjointEdges,
+          { budget: 10 }
+        );
         for (const subj of subjCandidates) {
           const v = violations.find((vv) => vv.subject === subj && objVariants.has(vv.object));
           if (!v) continue;
-          const typeFact = chainTypeRows.find((f) => f.subject === v.subject && f.object === v.viaType);
+          const typeFact = chainTypeRows.concat(chainSubClassRows).find((f) => f.subject === v.subject && f.object === v.viaType);
           const disjointFact = disjointRows.find((f) => f.subject === v.viaClass && f.object === v.object || f.subject === v.object && f.object === v.viaClass);
           const parts = [typeFact, disjointFact].filter(Boolean).map(renderFactLine);
           return { text: `no \u2014 ${parts.length ? parts.join("; ") : `${v.viaClass} and ${v.object} are disjoint.`}`, replace: true };
@@ -23725,6 +24491,14 @@ ${shown.join("\n")}${extra}`, replace: true, ...rest.length ? { pending: { items
           // still a MISS in the turn record — honest wording, not an answer
         };
       }
+      const converseHit = isa.filter((f) => subjCandidates.has(f.object) && objVariants.has(f.subject)).sort(byTrust)[0];
+      if (converseHit) {
+        return {
+          text: `I can't confirm that \u2014 what I know runs the other way: ${renderFactLine(converseHit)}. A kind doesn't reverse. If it's true, teach me: "every ${subjectWord} is a ${kindWord}".`,
+          replace: true,
+          miss: true
+        };
+      }
       if (!ent && !noun && !isPronoun(subjectWord) && !rows.some((f) => subjCandidates.has(f.subject) || subjCandidates.has(f.object))) {
         return {
           text: `I can't confirm that \u2014 I don't know "${subjectWord}" at all yet. If it's true, teach me: "${subjectWord} is a kind of ${kindWord}".`,
@@ -23902,7 +24676,7 @@ ${shown.join("\n")}${extra}`, replace: true, ...rest.length ? { pending: { items
           }
         }
         if (rows.some(subjectMatch) && !envelope?.parsed) {
-          return { text: `I don't have a fact saying ${teachableSubjectOf(subject)} is ${adjective}.`, replace: true };
+          return { text: `I don't have a fact saying ${suggestibleSubjectPhrase(subject)} is ${adjective}.`, replace: true };
         }
         if (!envelope?.parsed) return unknownAdjectiveOffer(subject, adjective);
       }
@@ -24024,8 +24798,25 @@ ${shown.join("\n")}${extra}`, replace: true, ...rest.length ? { pending: { items
     capabilities: "see what /plan can plan over \u2014 built-in query tools and taught actions",
     syllogise: "materialize the entailed facts that follow from what's remembered about one term"
   };
+  var IMPACT_CHANGE_VERBS = "(?:changed?|modif(?:y|ied)|edits?|edited|touch(?:es|ed)?|updates?|updated|alters?|altered|deletes?|deleted|removes?|removed|drops?|dropped)";
   var IMPACT_PARAPHRASE_RE = new RegExp(
-    "^what\\s+(?:would|will|might|could|does|do)?\\s*(?:breaks?|fails?|is\\s+affected|are\\s+affected|gets?\\s+affected|be\\s+affected|is\\s+impacted|be\\s+impacted)\\s+if\\s+(?:i|we|you|one|someone)\\s+(?:changed?|modif(?:y|ied)|edits?|edited|touch(?:es|ed)?|updates?|updated|alters?|altered)\\s+(?:the\\s+)?(.+?)[?.!\\s]*$",
+    `^what\\s+(?:would|will|might|could|does|do)?\\s*(?:breaks?|fails?|happens?|stops?\\s+working|is\\s+affected|are\\s+affected|gets?\\s+affected|be\\s+affected|is\\s+impacted|be\\s+impacted)\\s+if\\s+(?:i|we|you|one|someone)\\s+${IMPACT_CHANGE_VERBS}\\s+(?:the\\s+)?(.+?)[?.!\\s]*$`,
+    "i"
+  );
+  var IMPACT_REVERSED_RE = new RegExp(
+    `^if\\s+(?:i|we|you|one|someone)\\s+${IMPACT_CHANGE_VERBS}\\s+(?:the\\s+)?(.+?),?\\s+what\\s+(?:would\\s+|will\\s+|might\\s+|could\\s+|does\\s+|do\\s+)?(?:breaks?|fails?|happens?|stops?\\s+working|is\\s+affected|are\\s+affected|gets?\\s+affected|be\\s+affected|would\\s+break|will\\s+break)[?.!\\s]*$`,
+    "i"
+  );
+  var IMPACT_AFFECTED_BY_RE = new RegExp(
+    "^what\\s+(?:is|are|gets?|would\\s+be|will\\s+be)\\s+(?:affected|impacted|broken)\\s+(?:by|when|if)\\s+(?:i\\s+|we\\s+|you\\s+)?(?:chang(?:e|es|ing)|edit(?:s|ing)?|modif(?:y|ies|ying)|touch(?:es|ing)?|updat(?:e|es|ing)|delet(?:e|es|ing)|remov(?:e|es|ing)|a\\s+change\\s+to)\\s+(?:the\\s+)?(.+?)[?.!\\s]*$",
+    "i"
+  );
+  var IMPACT_SAFE_CHANGE_RE = new RegExp(
+    "^(?:(?:can|could)\\s+(?:i|we|you|one|someone)\\s+safely|is\\s+it\\s+safe\\s+to)\\s+(?:change|edit|modify|touch|update|alter|delete|remove|drop)\\s+(?:the\\s+)?(.+?)[?.!\\s]*$",
+    "i"
+  );
+  var IMPACT_NOUN_RE = new RegExp(
+    "^(?:what(?:'s|\\s+is)\\s+the\\s+)?(?:blast\\s+radius|impact)\\s+(?:of|for)\\s+(?:chang(?:ing|es)\\s+|editing\\s+|modifying\\s+|touching\\s+|updating\\s+|deleting\\s+|removing\\s+)?(?:the\\s+)?(.+?)[?.!\\s]*$",
     "i"
   );
   var BASE_QUALIFIER_SRC = "as\\s+(?:its|the|an?)?\\s*(?:base\\s+class|parent\\s+class|base|parent)";