@polycode-projects/seonix 0.9.0 → 0.10.0

package/src/ask-browser.bundle.js

@@ -50,6 +50,8 @@
   };
   var createRequire2 = unavailable2("createRequire");
   var readFileSync2 = unavailable2("readFileSync");
+  var join = (...a) => a.join("/");
+  var dirname = (p) => String(p).replace(/\/[^/]*$/, "");
   var randomBytes2 = unavailable2("randomBytes");
 
   // node-stub:node:url
@@ -58,6 +60,7 @@
   };
   var createRequire3 = unavailable3("createRequire");
   var readFileSync3 = unavailable3("readFileSync");
+  var fileURLToPath = (u) => String(u);
   var randomBytes3 = unavailable3("randomBytes");
 
   // node_modules/@polycode-projects/the-mechanical-code-talker/src/codegraph.mjs
@@ -949,12 +952,62 @@
   );
   var MISSPELLING_RE = correctionRe(MISSPELLINGS);
   var WRONG_WORD_RE = correctionRe(WRONG_WORDS);
+  var RELATION_VERB_RE = new RegExp(
+    "\\b(?:" + Object.keys(VERB_TO_KIND).sort((a, b) => b.length - a.length).map(escapeRegex).join("|") + ")\\b",
+    "i"
+  );
+  var INTERROGATIVE_LEAD_RE = /^(?:which|what|who|whose|where|when|why|how)\b/i;
+  var LISTING_TAIL_KINDS = /* @__PURE__ */ new Set([
+    "modules",
+    "files",
+    "functions",
+    "methods",
+    "classes",
+    "attributes",
+    "fields",
+    "properties",
+    "variables",
+    "globals",
+    "commits",
+    "changes",
+    "tests",
+    "members"
+  ]);
+  var BARE_KIND_RE = /^(?:all\s+|the\s+)?(?:module|file|function|method|class|attribute|field|property|variable|global|commit|change|test|member)\??$/i;
+  var isListingRemainder = (rest) => {
+    if (BARE_KIND_RE.test(rest)) return true;
+    const words = rest.replace(/\?+\s*$/, "").trim().split(/\s+/);
+    return LISTING_TAIL_KINDS.has((words[words.length - 1] || "").toLowerCase());
+  };
+  var GREETING_PREAMBLE_RE = /^(?:hi|hiya|hello|hey|yo|howdy)(?:\s+there)?\s*[,—–-]\s*(?:(?:just\s+a\s+)?quick\s+question\s*[,:—–-]?\s*)?(.+)$/i;
+  var MODAL_WRAPPER_RE = /^(?:can|could|would|will)\s+you\s+(?:please\s+)?(.+?)(?:[,\s]+please)?\??$/i;
+  var SHOW_GIVE_ME_RE = /^(?:show|give)\s+me\s+(?:the\s+)?(.+?)\??$/i;
+  function applyPreambleFrames(text) {
+    let q = String(text || "");
+    for (let pass = 0; pass < 3; pass++) {
+      const before = q;
+      let m = q.match(GREETING_PREAMBLE_RE);
+      if (m) q = m[1].trim();
+      m = q.match(MODAL_WRAPPER_RE);
+      if (m) q = m[1].trim();
+      m = q.match(SHOW_GIVE_ME_RE);
+      if (m) {
+        const rest = m[1].trim();
+        if (!isListingRemainder(rest)) {
+          q = RELATION_VERB_RE.test(rest) || INTERROGATIVE_LEAD_RE.test(rest) ? rest : `describe ${rest}`;
+        }
+      }
+      if (q === before) break;
+    }
+    return q;
+  }
   function normalizeQuery(text) {
     let q = String(text || "");
     q = q.replace(CONTRACTION_RE, (m) => CONTRACTIONS[m.toLowerCase()]);
     q = q.replace(MISSPELLING_RE, (m) => MISSPELLINGS[m.toLowerCase()]);
     q = q.replace(WRONG_WORD_RE, (m) => WRONG_WORDS[m.toLowerCase()]);
     q = q.replace(G_DROP, "$1ing");
+    q = applyPreambleFrames(q);
     if (FILLER_WORDS.length) {
       const fillerRe = new RegExp(
         "\\b(" + [...FILLER_WORDS].sort((a, b) => b.length - a.length).map(escapeRegex).join("|") + ")\\b",
@@ -972,6 +1025,108 @@
     }
     return text;
   }
+  var PHRASING_FRAMES = Object.freeze([
+    // MEMBERS-of-class → "what does X contain".
+    //   "what functions are in Task", "what methods are inside X", "what attributes are in X"
+    { re: /^what\s+(?:functions?|methods?|members?|attributes?|fields?|properties)\s+(?:are|is)\s+(?:in|inside|within)\s+(?:the\s+)?(.+?)\??$/i, to: (m) => `what does ${m[1]} contain` },
+    //   "what functions does Task have", "what methods does X have"
+    { re: /^what\s+(?:functions?|methods?|members?|attributes?|fields?|properties)\s+(?:does|do)\s+(.+?)\s+have\??$/i, to: (m) => `what does ${m[1]} contain` },
+    //   "what are the members of X", "what are the methods in X"
+    { re: /^what\s+are\s+(?:the\s+)?(?:functions?|methods?|members?|attributes?|fields?|properties)\s+(?:of|in|inside|within)\s+(?:the\s+)?(.+?)\??$/i, to: (m) => `what does ${m[1]} contain` },
+    //   "members of X", "methods of X", "contents of X"
+    { re: /^(?:the\s+)?(?:members?|methods?|attributes?|contents)\s+of\s+(?:the\s+)?(.+?)\??$/i, to: (m) => `what does ${m[1]} contain` },
+    //   "what's in X" / "what is in X" (contraction already expanded; sha handled above)
+    { re: /^what\s+is\s+(?:in|inside)\s+(?:the\s+)?(.+?)\??$/i, to: (m) => `what does ${m[1]} contain` },
+    // WHERE-DEFINED → "where is X defined". PAST TENSE ONLY ("what defined X", "what
+    // declared X"): the PRESENT "what defines X" already parses as a reverse-defines
+    // query (the module defining symbol X — test/ask.test.mjs pins that), so rewriting
+    // it would change that receipt. The past-tense form is the one that hit the wall.
+    { re: /^what\s+(?:defined|declared)\s+(?:the\s+)?(?:function\s+|method\s+|class\s+|module\s+|variable\s+|constant\s+)?(.+?)\??$/i, to: (m) => `where is ${m[1]} defined` },
+    //   "where's X defined" (the "where's" contraction is not in the contraction table)
+    { re: /^where'?s\s+(?:the\s+)?(.+?)\s+(defined|declared|located|implemented)\??$/i, to: (m) => `where is ${m[1]} ${m[2]}` },
+    // PREDICATIVE QUALIFIER → the ATTRIBUTIVE form the grammar already answers. The
+    // adjective-qualifier post-filters (ask-vocab.mjs QUALIFIERS: tested/untested,
+    // public/private, exported, static/abstract/constant, …) parse in the ATTRIBUTIVE
+    // slot — "untested modules", "public methods" — but a developer just as naturally
+    // asks the PREDICATIVE "which modules are untested" / "what functions are tested",
+    // which hit the grammar wall (and, worse, the wall's own hint SUGGESTED "which
+    // functions are tested" — a shape it could not then answer). Rewriting the
+    // predicative "<which|what> <kind> are <QUALIFIER>" to "<QUALIFIER> <kind>" routes
+    // it onto the working attributive filter. Closed to the known qualifier adjectives
+    // (not a general "… are X" catch), and the QUALIFIER must sit immediately after
+    // are/is, so "which modules are NOT tested" never matches here — that keeps its own
+    // set-complement handler (matchNegationSet, downstream in ask.mjs's parseNegation).
+    {
+      re: /^(?:which|what)\s+(?:the\s+|all\s+)?([a-z][a-z-]*?)\s+(?:are|is)\s+(public|private|protected|static|abstract|constant|exported|re-?exported|tested|covered|untested|uncovered)\??$/i,
+      to: (m) => `${m[2].toLowerCase()} ${m[1].toLowerCase()}`
+    },
+    // BARE COVERAGE SURVEY (no entity kind) → the attributive "<qualifier> modules"
+    // the grammar already answers. Once "what is a test" opens the topic, a developer
+    // asks the survey the plainest way — "what is untested", "what's not tested",
+    // "what isn't covered", "what is covered" — with NO entity noun at all, so the
+    // predicative-qualifier frame above (which needs a KIND between what/which and
+    // are/is) can't catch it, and it fell through to a soft wall ("no module matching
+    // 'not'…" / the "I answer questions…" orientation). Default the surveyed kind to
+    // modules (the same set "which modules are not tested" / "untested modules" return)
+    // and fold the negation into the qualifier (not tested → untested, not covered →
+    // uncovered). Anchored with no object, so "what tests cover X" / "what is a test"
+    // never match here.
+    {
+      re: /^what\s+(?:is|are)\s+(not\s+)?(tested|untested|covered|uncovered)\??$/i,
+      to: (m) => {
+        const q = m[2].toLowerCase();
+        const flipped = m[1] ? q === "tested" ? "untested" : q === "covered" ? "uncovered" : q : q;
+        return `${flipped} modules`;
+      }
+    },
+    // CO-CHANGE → the "co-changes with" canonical the RELATIONS table answers. The
+    // cochange verb synonyms (ask-vocab.mjs) include "co-changes with" / "moves
+    // together with" / "tends to change together with", but NOT the plainest form a
+    // developer types — the one the README itself prints and the relation renders as:
+    // "what does X change together with" / "what changes together with X". Both hit a
+    // dead-end ("couldn't resolve one of the terms" / the grammar wall); rewriting them
+    // onto "what co-changes with X" routes them to the working change-coupling query.
+    { re: /^what\s+does\s+(.+?)\s+changes?\s+together\s+with\??$/i, to: (m) => `what co-changes with ${m[1]}` },
+    { re: /^what\s+changes?\s+together\s+with\s+(.+?)\??$/i, to: (m) => `what co-changes with ${m[1]}` },
+    // AUTHORSHIP → the "who touched X" churn query. "who touched X" now names the
+    // commit author beside the sha (the 0.8.1 commit-ref quick-win), which invites the
+    // synonyms a developer reaches for next — "who wrote X", "who authored X", "who is
+    // the author of X" — and every one of them hit the grammar wall. tmct has no
+    // separate authorship edge; "touched" IS the authorship signal (the churn commits
+    // carry the author), so these are true synonyms of "who touched X", not a new
+    // capability. Anaphora rides through untouched ("who wrote it" → "who touched it").
+    // SHA GUARD (0.8.2 feel wave): a COMMIT object is NOT a synonym — "who is the
+    // author of abc1234" rewritten to "who touched abc1234" dumps the commit's
+    // touch-SET instead of naming its author. The negative lookahead refuses the
+    // rewrite when the object is a bare (optionally "commit "-prefixed) 7-40 char
+    // hex sha, leaving the un-rewritten form for the author lane to consume;
+    // file/symbol objects (anything non-sha, e.g. "deadbeef.mjs") keep the rewrite.
+    { re: /^who\s+(?:wrote|authored)\s+(?:the\s+)?(?!(?:commit\s+)?[0-9a-f]{7,40}\??$)(.+?)\??$/i, to: (m) => `who touched ${m[1]}` },
+    { re: /^who\s+is\s+the\s+authors?\s+of\s+(?:the\s+)?(?!(?:commit\s+)?[0-9a-f]{7,40}\??$)(.+?)\??$/i, to: (m) => `who touched ${m[1]}` },
+    // HAS-TESTS → the coverage question the RELATIONS table answers. "does X have
+    // tests" parses "have" as a defines-verb (VERB_TO_KIND), producing the garbled
+    // "No — no defines edge found from X to <whatever resolves>" receipt; "is X
+    // tested" traverses tests edges from the WRONG side (subject = X). Both mean
+    // the coverage question "what tests X" — rewrite onto it. Closed to a
+    // tests/coverage object ("does X have methods/members" stays the members
+    // family) and refuses any "not" in the subject span, so the set-complement
+    // negations ("is X not tested") keep their own handler downstream.
+    { re: /^(?:does|do)\s+(?!.*\bnot\b)(.+?)\s+have\s+(?:any\s+)?(?:tests?|test\s+coverage|coverage)\??$/i, to: (m) => `what tests ${m[1]}` },
+    { re: /^(?:is|are)\s+(?!.*\bnot\b)(.+?)\s+tested\??$/i, to: (m) => `what tests ${m[1]}` },
+    // NEEDS-TESTS → the untested-module survey. "what needs tests" / "what needs
+    // testing" is the plainest way to ask which modules are uncovered, and it hit the
+    // grammar wall ("no module matching 'needs'…"). Route it onto the same attributive
+    // survey the bare "what is untested" frame lands on. Closed to the tests/coverage
+    // object, so it can't swallow a general "what needs X".
+    { re: /^what\s+needs\s+(?:to\s+be\s+)?(?:a\s+)?(?:tested|tests?|testing|coverage|covering)\??$/i, to: () => "untested modules" }
+  ]);
+  function applyPhrasingFrames(text) {
+    for (const frame of PHRASING_FRAMES) {
+      const m = text.match(frame.re);
+      if (m) return frame.to(m).replace(/\s+/g, " ").trim();
+    }
+    return text;
+  }
   var NEGATION_SET_RE = new RegExp(
     "^(?:which|what|who|list|show(?:\\s+me)?|find|give\\s+me)?\\s*(?:the\\s+|all\\s+)?([a-z][a-z-]*)\\s+(?:(?:that|which|who)\\s+)?(?:(?:do|does|did|are|is|was|were|have|has)\\s+)?not\\s+(.+)$",
     // the negation marker + (2) the predicate
@@ -1058,17 +1213,17 @@
   function fuzzyVocabWord(w) {
     const bound = fuzzyBound(w);
     let best = bound + 1;
-    let hit = null;
+    let hit2 = null;
     let tied = false;
     for (const target of FUZZY_TARGET_WORDS) {
       const d = editDistance(w, target, Math.min(best, bound));
       if (d < best) {
         best = d;
-        hit = target;
+        hit2 = target;
         tied = false;
-      } else if (d === best && d <= bound && target !== hit) tied = true;
+      } else if (d === best && d <= bound && target !== hit2) tied = true;
     }
-    return best <= bound && !tied ? hit : null;
+    return best <= bound && !tied ? hit2 : null;
   }
 
   // node_modules/@polycode-projects/the-mechanical-code-talker/src/interpret/strategies/grammar.mjs
@@ -1253,8 +1408,8 @@
       }
     }
     const consumed = /* @__PURE__ */ new Set();
-    const mark = (hit) => {
-      if (hit) for (let i = hit.start; i < hit.end; i += 1) consumed.add(i);
+    const mark = (hit2) => {
+      if (hit2) for (let i = hit2.start; i < hit2.end; i += 1) consumed.add(i);
     };
     mark(verbHit);
     const entityHit = findPhrase(canonWords, ENTITY_TO_TYPE, consumed);
@@ -1356,9 +1511,428 @@
     }
   };
 
+  // node_modules/@polycode-projects/the-mechanical-code-talker/src/grammar/lexicon.mjs
+  var import_meta = {};
+  var CORE_FILE = join(dirname(fileURLToPath(import_meta.url)), "lexicon-core.json");
+  var DETERMINERS = Object.freeze({
+    every: "universal",
+    a: "indefinite",
+    an: "indefinite",
+    the: "definite",
+    no: "negative"
+  });
+  var QUANTIFIERS = Object.freeze({
+    "at least": "owl:minCardinality",
+    "at most": "owl:maxCardinality",
+    exactly: "owl:cardinality"
+  });
+  var NUMBER_WORDS = Object.freeze({
+    one: 1,
+    two: 2,
+    three: 3,
+    four: 4,
+    five: 5,
+    six: 6,
+    seven: 7,
+    eight: 8,
+    nine: 9,
+    ten: 10
+  });
+  function numberOf(word) {
+    const w = String(word ?? "").trim().toLowerCase();
+    if (/^\d+$/.test(w)) return Number(w);
+    return NUMBER_WORDS[w] ?? null;
+  }
+  function thirdPerson(base) {
+    const b = String(base);
+    if (b === "have") return "has";
+    if (/[^aeiou]y$/.test(b)) return `${b.slice(0, -1)}ies`;
+    if (/(s|x|z|ch|sh)$/.test(b)) return `${b}es`;
+    return `${b}s`;
+  }
+  function predicateOf(verbEntry) {
+    if (verbEntry.predicate) return verbEntry.predicate;
+    const prep = verbEntry.prep ? verbEntry.prep[0].toUpperCase() + verbEntry.prep.slice(1) : "";
+    return `tmct:${thirdPerson(verbEntry.lemma)}${prep}`;
+  }
+  function foldCandidates(word) {
+    const w = String(word);
+    const out = [w];
+    if (w.length > 4 && /[a-z]ies$/.test(w)) out.push(`${w.slice(0, -3)}y`);
+    if (/(ses|xes|zes|ches|shes)$/.test(w)) out.push(w.slice(0, -2));
+    if (/[a-z]s$/.test(w) && !/ss$/.test(w)) out.push(w.slice(0, -1));
+    if (w === "has") out.push("have");
+    return out;
+  }
+  var NOUN_PROPERTY_TYPES = /* @__PURE__ */ new Set(["data", "object"]);
+  var ADJECTIVE_TYPES = /* @__PURE__ */ new Set(["subclass", "data"]);
+  function ingest(lex, raw = {}) {
+    for (const [lemma, e] of Object.entries(raw.nouns || {})) {
+      const entry = { lemma, ...e || {} };
+      if (entry.property && !NOUN_PROPERTY_TYPES.has(entry.property)) {
+        throw new Error(`lexicon noun "${lemma}": property must be "data" or "object", got ${JSON.stringify(entry.property)}`);
+      }
+      lex.nouns.set(lemma, entry);
+      if (entry.plural) lex.nounPlurals.set(entry.plural, lemma);
+    }
+    for (const [lemma, e] of Object.entries(raw.verbs || {})) {
+      lex.verbs.set(lemma, { lemma, ...e || {} });
+    }
+    for (const [lemma, e] of Object.entries(raw.adjectives || {})) {
+      const entry = { lemma, ...e || {} };
+      if (!ADJECTIVE_TYPES.has(entry.type)) {
+        throw new Error(`lexicon adjective "${lemma}": type must be "subclass" or "data", got ${JSON.stringify(entry.type)}`);
+      }
+      lex.adjectives.set(lemma, entry);
+    }
+    for (const name of raw.properNames || []) {
+      lex.properNames.set(String(name).toLowerCase(), String(name));
+    }
+  }
+  var coreCache = null;
+  function loadLexicon(extra) {
+    if (!extra && coreCache) return coreCache;
+    const raw = JSON.parse(readFileSync(CORE_FILE, "utf8"));
+    const lex = {
+      nouns: /* @__PURE__ */ new Map(),
+      nounPlurals: /* @__PURE__ */ new Map(),
+      verbs: /* @__PURE__ */ new Map(),
+      adjectives: /* @__PURE__ */ new Map(),
+      properNames: /* @__PURE__ */ new Map()
+      // lowercased → canonical spelling
+    };
+    ingest(lex, raw);
+    if (extra) {
+      ingest(lex, extra);
+      return lex;
+    }
+    coreCache = lex;
+    return lex;
+  }
+  function lookupNoun(lexicon, word) {
+    const w = String(word ?? "").toLowerCase();
+    const irregular = lexicon.nounPlurals.get(w);
+    if (irregular) return lexicon.nouns.get(irregular) ?? null;
+    for (const cand of foldCandidates(w)) {
+      const hit2 = lexicon.nouns.get(cand);
+      if (hit2) return hit2;
+    }
+    return null;
+  }
+  function lookupVerb(lexicon, word) {
+    const w = String(word ?? "").toLowerCase();
+    for (const cand of foldCandidates(w)) {
+      const hit2 = lexicon.verbs.get(cand);
+      if (hit2) return hit2;
+    }
+    return null;
+  }
+  function lookupAdjective(lexicon, word) {
+    return lexicon.adjectives.get(String(word ?? "").toLowerCase()) ?? null;
+  }
+  function lookupProperName(lexicon, word) {
+    return lexicon.properNames.get(String(word ?? "").toLowerCase()) ?? null;
+  }
+  function classify(word, lexicon = loadLexicon()) {
+    const w = String(word ?? "").trim();
+    if (!w) return null;
+    const lower = w.toLowerCase();
+    if (DETERMINERS[lower]) return { pos: "determiner", type: DETERMINERS[lower] };
+    if (QUANTIFIERS[lower]) return { pos: "quantifier", type: QUANTIFIERS[lower] };
+    const n = numberOf(lower);
+    if (n != null) return { pos: "number", type: "cardinal", value: n };
+    const proper = lookupProperName(lexicon, w);
+    if (proper) return { pos: "properName", type: "individual", canonical: proper };
+    const noun = lookupNoun(lexicon, lower);
+    if (noun) {
+      return noun.property ? { pos: "noun", type: `${noun.property}-property`, lemma: noun.lemma, property: noun.property } : { pos: "noun", type: "class", lemma: noun.lemma };
+    }
+    const verb = lookupVerb(lexicon, lower);
+    if (verb) {
+      return { pos: "verb", type: "objectProperty", lemma: verb.lemma, predicate: predicateOf(verb), ...verb.prep ? { prep: verb.prep } : {} };
+    }
+    const adj = lookupAdjective(lexicon, lower);
+    if (adj) return { pos: "adjective", type: adj.type, lemma: adj.lemma };
+    return null;
+  }
+
+  // node_modules/@polycode-projects/the-mechanical-code-talker/src/grammar/ace.mjs
+  var DET = /* @__PURE__ */ new Set(["a", "an", "the"]);
+  var CODE_REF = /[./\\#:@]/;
+  function tokenize(sentence) {
+    return String(sentence ?? "").replace(/[‘’]/g, "'").replace(/[,;]/g, " ").replace(/[?!.]+\s*$/, "").trim().split(/\s+/).filter(Boolean);
+  }
+  var local = (term) => String(term).replace(/^tmct:/, "");
+  var stripDet = (tokens) => tokens.length > 1 && DET.has(tokens[0].toLowerCase()) ? tokens.slice(1) : tokens;
+  function resolveNP(lexicon, tokensIn) {
+    const tokens = stripDet(tokensIn);
+    if (tokens.length === 1) {
+      const t = tokens[0];
+      const proper = lookupProperName(lexicon, t);
+      if (proper) return { term: `tmct:${proper}`, individual: true, extras: [], unknown: [] };
+      if (CODE_REF.test(t)) return { term: `tmct:${t}`, individual: true, extras: [], unknown: [] };
+      const noun = lookupNoun(lexicon, t);
+      if (noun) return { term: `tmct:${noun.lemma}`, individual: false, noun, extras: [], unknown: [] };
+      return { term: null, individual: false, extras: [], unknown: [t] };
+    }
+    if (tokens.length === 2) {
+      const adj = lookupAdjective(lexicon, tokens[0]);
+      const noun = lookupNoun(lexicon, tokens[1]);
+      if (adj && noun) {
+        const term = `tmct:${adj.lemma}-${noun.lemma}`;
+        const extras = [
+          { subject: term, predicate: "rdfs:subClassOf", object: `tmct:${noun.lemma}`, kind: "rdfs:subClassOf" }
+        ];
+        if (adj.type === "subclass") {
+          extras.push({ subject: term, predicate: "rdfs:subClassOf", object: `tmct:${adj.lemma}`, kind: "rdfs:subClassOf" });
+        } else {
+          const r = `tmct:has-${adj.lemma}`;
+          extras.push(
+            { subject: r, predicate: "rdf:type", object: "owl:Restriction", kind: "owl:hasValue" },
+            { subject: r, predicate: "owl:onProperty", object: adj.property || `tmct:${adj.lemma}`, kind: "owl:hasValue" },
+            { subject: r, predicate: "owl:hasValue", object: adj.value ?? "true", kind: "owl:hasValue" },
+            { subject: term, predicate: "rdfs:subClassOf", object: r, kind: "owl:hasValue" }
+          );
+        }
+        return { term, individual: false, noun, extras, unknown: [] };
+      }
+      const unknown = tokens.filter((t) => !classify(t, lexicon));
+      return { term: null, individual: false, extras: [], unknown };
+    }
+    return { term: null, individual: false, extras: [], unknown: tokens.filter((t) => !classify(t, lexicon)) };
+  }
+  function missOrNull(pattern, nps, extraUnknown = []) {
+    const residue = [...extraUnknown, ...nps.flatMap((np) => np.unknown)];
+    return residue.length ? { pattern, triples: [], residue } : null;
+  }
+  var hit = (pattern, nps, triples, more = {}) => ({
+    pattern,
+    triples: [...nps.flatMap((np) => np.extras), ...triples],
+    residue: [],
+    ...more
+  });
+  function parseRelation(lexicon, toks, lower) {
+    for (let i = 1; i < toks.length - 1; i += 1) {
+      const verb = lookupVerb(lexicon, lower[i]);
+      if (!verb) continue;
+      let objStart = i + 1;
+      if (verb.prep) {
+        if (lower[objStart] !== verb.prep) continue;
+        objStart += 1;
+        if (objStart >= toks.length) continue;
+      }
+      const np1 = resolveNP(lexicon, toks.slice(0, i));
+      const np2 = resolveNP(lexicon, toks.slice(objStart));
+      if (np1.term == null || np2.term == null) return missOrNull("relation", [np1, np2]);
+      return hit("relation", [np1, np2], [
+        { subject: np1.term, predicate: predicateOf(verb), object: np2.term, kind: "owl:ObjectProperty" }
+      ]);
+    }
+    const content = toks.filter((t) => !DET.has(t.toLowerCase()));
+    if (content.length === 3 && !classify(content[1], lexicon)) {
+      const np1 = resolveNP(lexicon, [content[0]]);
+      const np2 = resolveNP(lexicon, [content[2]]);
+      if (np1.term != null && np2.term != null) return { pattern: "relation", triples: [], residue: [content[1]] };
+    }
+    return null;
+  }
+  function adjectiveCopula(pattern, np1, adj) {
+    if (np1.term == null) return missOrNull(pattern, [np1]);
+    if (adj.type === "data") {
+      return hit(pattern, [np1], [
+        { subject: np1.term, predicate: adj.property || `tmct:${adj.lemma}`, object: adj.value ?? "true", kind: "owl:DatatypeProperty" }
+      ]);
+    }
+    const predicate = np1.individual ? "rdf:type" : "rdfs:subClassOf";
+    return hit(pattern, [np1], [
+      { subject: np1.term, predicate, object: `tmct:${adj.lemma}`, kind: predicate }
+    ]);
+  }
+  function parseRestriction(lexicon, toks, lower, thatIdx) {
+    const isIdx = lower.indexOf("is", thatIdx + 2);
+    if (isIdx < 0 || thatIdx + 1 >= isIdx) return null;
+    const verb = lookupVerb(lexicon, lower[thatIdx + 1]);
+    const np1 = resolveNP(lexicon, toks.slice(1, thatIdx));
+    let objStart = thatIdx + 2;
+    if (verb?.prep) {
+      if (lower[objStart] !== verb.prep) return null;
+      objStart += 1;
+    }
+    const np2 = resolveNP(lexicon, toks.slice(objStart, isIdx));
+    const np3 = resolveNP(lexicon, toks.slice(isIdx + 1));
+    if (!verb) return missOrNull("someValuesFrom", [np1, np2, np3], [toks[thatIdx + 1]]);
+    if (np1.term == null || np2.term == null || np3.term == null) {
+      return missOrNull("someValuesFrom", [np1, np2, np3]);
+    }
+    if (np1.individual || np2.individual || np3.individual) return null;
+    const pred = predicateOf(verb);
+    const k = "owl:someValuesFrom";
+    const r = `tmct:some-${local(pred)}-${local(np2.term)}`;
+    const inter = `tmct:${local(np1.term)}-that-${local(pred)}-${local(np2.term)}`;
+    return hit("someValuesFrom", [np1, np2, np3], [
+      { subject: r, predicate: "rdf:type", object: "owl:Restriction", kind: k },
+      { subject: r, predicate: "owl:onProperty", object: pred, kind: k },
+      { subject: r, predicate: "owl:someValuesFrom", object: np2.term, kind: k },
+      { subject: inter, predicate: "owl:intersectionOf", object: np1.term, kind: k },
+      { subject: inter, predicate: "owl:intersectionOf", object: r, kind: k },
+      { subject: inter, predicate: "rdfs:subClassOf", object: np3.term, kind: k }
+    ]);
+  }
+  function parseCardinality(lexicon, toks, lower, hasIdx) {
+    let kind = null;
+    let nIdx = -1;
+    if (lower[hasIdx + 1] === "at" && lower[hasIdx + 2] === "least") {
+      kind = "owl:minCardinality";
+      nIdx = hasIdx + 3;
+    } else if (lower[hasIdx + 1] === "at" && lower[hasIdx + 2] === "most") {
+      kind = "owl:maxCardinality";
+      nIdx = hasIdx + 3;
+    } else if (lower[hasIdx + 1] === "exactly") {
+      kind = "owl:cardinality";
+      nIdx = hasIdx + 2;
+    } else return null;
+    const n = numberOf(lower[nIdx]);
+    if (n == null || nIdx + 1 >= toks.length) return null;
+    const np1 = resolveNP(lexicon, toks.slice(1, hasIdx));
+    const np2 = resolveNP(lexicon, toks.slice(nIdx + 1));
+    if (np1.term == null || np2.term == null) return missOrNull("cardinality", [np1, np2]);
+    if (np1.individual || np2.individual) return null;
+    const tag = { "owl:minCardinality": "min", "owl:maxCardinality": "max", "owl:cardinality": "exactly" }[kind];
+    const r = `tmct:${tag}-${n}-${local(np2.term)}`;
+    return hit("cardinality", [np1, np2], [
+      { subject: r, predicate: "rdf:type", object: "owl:Restriction", kind },
+      { subject: r, predicate: "owl:onProperty", object: "tmct:has", kind },
+      { subject: r, predicate: kind, object: String(n), kind, n },
+      { subject: r, predicate: "owl:onClass", object: np2.term, kind },
+      { subject: np1.term, predicate: "rdfs:subClassOf", object: r, kind }
+    ], { n });
+  }
+  function parseEvery(lexicon, toks, lower) {
+    const thatIdx = lower.indexOf("that");
+    if (thatIdx > 1) return parseRestriction(lexicon, toks, lower, thatIdx);
+    const hasIdx = lower.indexOf("has");
+    if (hasIdx > 1 && (lower[hasIdx + 1] === "at" || lower[hasIdx + 1] === "exactly")) {
+      return parseCardinality(lexicon, toks, lower, hasIdx);
+    }
+    const isIdx = lower.indexOf("is");
+    if (isIdx <= 1 || isIdx === toks.length - 1) return null;
+    const np1 = resolveNP(lexicon, toks.slice(1, isIdx));
+    const rest = toks.slice(isIdx + 1);
+    if (rest.length === 1) {
+      const adj = lookupAdjective(lexicon, rest[0]);
+      if (adj) return adjectiveCopula("adjective", np1, adj);
+    }
+    const np2 = resolveNP(lexicon, rest);
+    if (np1.term == null || np2.term == null) return missOrNull("subClassOf", [np1, np2]);
+    if (np1.individual || np2.individual) return null;
+    return hit("subClassOf", [np1, np2], [
+      { subject: np1.term, predicate: "rdfs:subClassOf", object: np2.term, kind: "rdfs:subClassOf" }
+    ]);
+  }
+  function parseDisjoint(lexicon, toks, lower) {
+    const isIdx = lower.indexOf("is");
+    if (isIdx <= 1 || isIdx === toks.length - 1) return null;
+    const np1 = resolveNP(lexicon, toks.slice(1, isIdx));
+    const np2 = resolveNP(lexicon, toks.slice(isIdx + 1));
+    if (np1.term == null || np2.term == null) return missOrNull("disjointWith", [np1, np2]);
+    if (np1.individual || np2.individual) return null;
+    return hit("disjointWith", [np1, np2], [
+      { subject: np1.term, predicate: "owl:disjointWith", object: np2.term, kind: "owl:disjointWith" }
+    ]);
+  }
+  function buildPossessive(lexicon, ownerToks, headToks, valueToks) {
+    const owner = resolveNP(lexicon, ownerToks);
+    if (headToks.length !== 1) return null;
+    const head = lookupNoun(lexicon, headToks[0]);
+    if (!head) return missOrNull("possessive", [owner], [headToks[0]]);
+    if (owner.term == null) return missOrNull("possessive", [owner]);
+    if (!valueToks.length) return null;
+    const predicate = `tmct:${head.lemma}`;
+    if ((head.property || "data") === "object") {
+      const value = resolveNP(lexicon, valueToks);
+      if (value.term == null) return missOrNull("possessive", [owner, value]);
+      return hit("possessive", [owner, value], [
+        { subject: owner.term, predicate, object: value.term, kind: "owl:ObjectProperty" }
+      ]);
+    }
+    return hit("possessive", [owner], [
+      { subject: owner.term, predicate, object: valueToks.join(" "), kind: "owl:DatatypeProperty" }
+    ]);
+  }
+  function parsePossessive(lexicon, toks, lower) {
+    const ownerRaw = toks[0].replace(/'s$/i, "");
+    const isIdx = lower.indexOf("is");
+    if (isIdx < 2 || !ownerRaw) return null;
+    return buildPossessive(lexicon, [ownerRaw], toks.slice(1, isIdx), toks.slice(isIdx + 1));
+  }
+  function parseOfForm(lexicon, toks, lower) {
+    const ofIdx = lower.indexOf("of");
+    const isIdx = lower.indexOf("is", ofIdx + 1);
+    if (ofIdx < 2 || isIdx < ofIdx + 2) return null;
+    return buildPossessive(lexicon, toks.slice(ofIdx + 1, isIdx), toks.slice(1, ofIdx), toks.slice(isIdx + 1));
+  }
+  function parseCopula(lexicon, toks, lower, isIdx) {
+    const np1 = resolveNP(lexicon, toks.slice(0, isIdx));
+    const rest = toks.slice(isIdx + 1);
+    if (!rest.length) return null;
+    if (rest.length === 1) {
+      const adj = lookupAdjective(lexicon, rest[0]);
+      if (adj) return adjectiveCopula("adjective", np1, adj);
+    }
+    const np2 = resolveNP(lexicon, rest);
+    if (np1.term == null || np2.term == null) {
+      return missOrNull(np1.individual ? "typeAssertion" : "subClassOf", [np1, np2]);
+    }
+    if (np2.individual) return null;
+    if (np1.individual) {
+      return hit("typeAssertion", [np1, np2], [
+        { subject: np1.term, predicate: "rdf:type", object: np2.term, kind: "rdf:type" }
+      ]);
+    }
+    return hit("subClassOf", [np1, np2], [
+      { subject: np1.term, predicate: "rdfs:subClassOf", object: np2.term, kind: "rdfs:subClassOf" }
+    ]);
+  }
+  function parseAce(sentence, lexicon = loadLexicon()) {
+    const toks = tokenize(sentence);
+    if (toks.length < 3) return null;
+    const lower = toks.map((t) => t.toLowerCase());
+    if (lower[0] === "every") return parseEvery(lexicon, toks, lower);
+    if (lower[0] === "no") return parseDisjoint(lexicon, toks, lower);
+    if (/'s$/.test(lower[0]) && lower[0].length > 2) return parsePossessive(lexicon, toks, lower);
+    if (lower[0] === "the" && lower.includes("of") && lower.includes("is")) {
+      return parseOfForm(lexicon, toks, lower);
+    }
+    const isIdx = lower.indexOf("is");
+    if (isIdx > 0) return parseCopula(lexicon, toks, lower, isIdx);
+    return parseRelation(lexicon, toks, lower);
+  }
+
+  // node_modules/@polycode-projects/the-mechanical-code-talker/src/interpret/strategies/ace.mjs
+  function runAce(text) {
+    let parsed = null;
+    try {
+      parsed = parseAce(text);
+    } catch {
+      return null;
+    }
+    if (!parsed || !Array.isArray(parsed.triples) || parsed.triples.length === 0) return null;
+    return { strategyId: "ace", class: "ace-fact", candidates: [{ parsed, confidence: 0.85, via: "exact", note: `ACE ${parsed.pattern}` }] };
+  }
+  var aceStrategy = {
+    id: "ace",
+    class: "ace-fact",
+    // eslint-disable-next-line require-await
+    async run(text) {
+      return runAce(text);
+    }
+  };
+
   // node_modules/@polycode-projects/the-mechanical-code-talker/src/interpret/merge.mjs
   var DEFAULT_CONFIDENCE = 0.5;
-  var cmpTerm = (s) => String(s || "").trim().toLowerCase().replace(/\s+/g, " ").replace(/^commit\s+(?=[0-9a-f]{7,40}$)/, "");
+  var cmpTerm = (s) => String(s || "").trim().toLowerCase().replace(/\s+/g, " ").replace(/^(?:the|a|an)\s+/, "").replace(/^commit\s+(?=[0-9a-f]{7,40}$)/, "");
+  var LEADING_DET_RE = /^\s*(?:the|a|an)\s+/i;
+  var detCount = (p) => [p?.subject, p?.object].filter((t) => LEADING_DET_RE.test(String(t || ""))).length;
   function sameParse(p, q) {
     if (p.shape !== q.shape || p.kind !== q.kind) return false;
     if (p.shape === "ask") return cmpTerm(p.subject) === cmpTerm(q.subject) && cmpTerm(p.object) === cmpTerm(q.object);
@@ -1398,6 +1972,7 @@
         if (dup) {
           dup.agreed += 1;
           dup.confidence = Math.max(dup.confidence, c.confidence);
+          if (detCount(c.parsed) < detCount(dup.parsed)) dup.parsed = c.parsed;
           continue;
         }
         distinct.push({ ...c, agreed: 1 });
@@ -1422,7 +1997,7 @@
   var randomBytes4 = unavailable4("randomBytes");
 
   // node_modules/@polycode-projects/the-mechanical-code-talker/src/wink-model.mjs
-  var import_meta = {};
+  var import_meta2 = {};
   var injected;
   var cached;
   function loadWinkModel() {
@@ -1436,7 +2011,7 @@
     return cached;
   }
   function nodeRequireWink() {
-    const require2 = createRequire4(import_meta.url);
+    const require2 = createRequire4(import_meta2.url);
     return {
       winkNLP: require2("wink-nlp"),
       model: require2("wink-eng-lite-web-model")
@@ -1526,7 +2101,8 @@
   }
 
   // node_modules/@polycode-projects/the-mechanical-code-talker/src/interpret/pipeline.mjs
-  var STRATEGIES = [grammarStrategy, keywordSpotStrategy, noiseStripStrategy];
+  var OPTIONAL_STRATEGIES = typeof aceStrategy !== "undefined" ? [aceStrategy] : [];
+  var STRATEGIES = [grammarStrategy, keywordSpotStrategy, noiseStripStrategy, ...OPTIONAL_STRATEGIES];
   function runStrategiesSync(text, ctx = {}, strategies = STRATEGIES) {
     const results = [];
     for (const s of strategies) {
@@ -1542,11 +2118,15 @@
   // node_modules/@polycode-projects/the-mechanical-code-talker/src/ask.mjs
   function edgesOfKind(graph, kind) {
     const out = [];
-    for (const g of graph.relations) if (relationKind(g) === kind) out.push(...g.edges);
+    for (const g of graph.relations) {
+      if (relationKind(g) !== kind) continue;
+      for (const e of g.edges) out.push(e);
+    }
     return out;
   }
   var SYMBOL_GRAIN_SIBLING = { calls: "callsSymbol", touches: "touchesSymbol" };
   var FINE_ENTITY_TYPES = /* @__PURE__ */ new Set(["Function", "Method", "Class", "Attribute", "GlobalVariable"]);
+  var FINE_CLASS_SIBLING = { Function: "Method", Method: "Function" };
   var KIND_UNIONS = { uses: ["imports", "calls", "callsSymbol"] };
   var kindsFor = (kind) => KIND_UNIONS[kind] || [kind];
   var OVERFLOW_CAP = 12;
@@ -1570,6 +2150,10 @@
   function verbFor(kind) {
     return REVERSE_MISS_VERB[kind] || kind;
   }
+  var LEADING_RELATION_VERB_RE = new RegExp(
+    `^(?:${Object.keys(VERB_TO_KIND).sort((a, b) => b.length - a.length).map((v) => v.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|")})(?:s|ing|ed)?\\s+`,
+    "i"
+  );
   function defaultNlp() {
     return typeof nlpAdapter === "function" ? nlpAdapter() : null;
   }
@@ -1577,7 +2161,7 @@
     const adapter = nlp === void 0 ? defaultNlp() : nlp;
     const raw = String(query || "").trim().replace(/\s+/g, " ");
     if (!raw) return null;
-    const text = applyNegationFrames(normalizeQuery(raw));
+    const text = applyPhrasingFrames(applyNegationFrames(normalizeQuery(raw)));
     if (!text) return null;
     const composite = parseComposite(text, adapter);
     if (composite) return composite;
@@ -1596,7 +2180,7 @@
   function parseComposite(text, nlp) {
     const w = splitWords(text);
     const lc = w.map((x) => x.toLowerCase());
-    return parseNegation(text, nlp, 0) || parseForwardNegation(w, lc, nlp) || parseAnaphora(w, lc, nlp) || parseAggregate(w, lc, nlp) || parseSuperlative(w, lc, nlp) || parseList(w, lc, nlp, 0) || parseNested(w, lc, nlp, 0) || parseRelationalOrQualified(w, lc, nlp, 0);
+    return parseNegation(text, nlp, 0) || parseForwardNegation(w, lc, nlp) || parseTemporal(w, lc, nlp, 0) || parseAnaphora(w, lc, nlp) || parseAggregate(w, lc, nlp) || parseSuperlative(w, lc, nlp) || parseList(w, lc, nlp, 0) || parseNested(w, lc, nlp, 0) || parseRelationalOrQualified(w, lc, nlp, 0);
   }
   function complementAst(entityType, diffAtom) {
     return {
@@ -1693,6 +2277,58 @@
     }
     return null;
   }
+  var TEMPORAL_AUX = /* @__PURE__ */ new Set(["did", "was", "were", "do", "does", "has", "have", "had"]);
+  var TEMPORAL_TAIL = /* @__PURE__ */ new Set([
+    "change",
+    "changed",
+    "changes",
+    "update",
+    "updated",
+    "updates",
+    "modify",
+    "modified",
+    "modifies",
+    "touch",
+    "touched",
+    "touches",
+    "edit",
+    "edited",
+    "revise",
+    "revised"
+  ]);
+  var TEMPORAL_TRAIL_FILLER = /* @__PURE__ */ new Set(["last", "recently", "ever", "get", "got", "been", "then", "now", "already"]);
+  var TEMPORAL_DET = /* @__PURE__ */ new Set(["the", "a", "an", "all", "those", "these", "any"]);
+  function parseTemporal(w, lc, nlp, depth = 0) {
+    if (lc[0] !== "when") return null;
+    let i = 1;
+    if (!TEMPORAL_AUX.has(lc[i])) return null;
+    i += 1;
+    let t = -1;
+    for (let k = lc.length - 1; k >= i; k -= 1) {
+      if (TEMPORAL_TAIL.has(lc[k])) {
+        t = k;
+        break;
+      }
+    }
+    if (t < 0) return null;
+    let subjWords = w.slice(i, t);
+    let subjLc = lc.slice(i, t);
+    while (subjLc.length && TEMPORAL_TRAIL_FILLER.has(subjLc[subjLc.length - 1])) {
+      subjWords = subjWords.slice(0, -1);
+      subjLc = subjLc.slice(0, -1);
+    }
+    while (subjLc.length && TEMPORAL_DET.has(subjLc[0])) {
+      subjWords = subjWords.slice(1);
+      subjLc = subjLc.slice(1);
+    }
+    if (!subjWords.length) return null;
+    if (!subjLc.some((x) => RELATIVE_PRONOUNS.includes(x))) return null;
+    const framed = FRAME_WORDS.has(subjLc[0]) ? subjWords.join(" ") : `which ${subjWords.join(" ")}`;
+    const inner = parseSetPhrase(framed, nlp, depth + 1);
+    if (!inner || inner.node === "miss") return inner ? { node: "miss", reason: inner.reason || "the inner set of the temporal query didn't parse" } : { node: "miss", reason: "the inner set of the temporal query didn't parse" };
+    const noun = entityNoun(subjLc[0]);
+    return { node: "temporal", inner, entityType: noun && noun.entityType || null };
+  }
   function parseAnaphora(w, lc, nlp) {
     let p = -1;
     let viaOf = false;
@@ -1958,21 +2594,21 @@
     let start = 0;
     let i = 0;
     while (i < predLc.length) {
-      let hit = null;
+      let hit2 = null;
       for (const c of conns) {
         const cw = c.split(" ");
         if (predLc.slice(i, i + cw.length).join(" ") === c) {
-          hit = { c, len: cw.length };
+          hit2 = { c, len: cw.length };
           break;
         }
       }
-      if (hit && i > start) {
+      if (hit2 && i > start) {
         branches.push(predWords.slice(start, i));
-        ops.push(BOOLEAN_CONNECTIVES[hit.c]);
-        i += hit.len;
+        ops.push(BOOLEAN_CONNECTIVES[hit2.c]);
+        i += hit2.len;
         start = i;
-      } else if (hit) {
-        i += hit.len;
+      } else if (hit2) {
+        i += hit2.len;
         start = i;
       } else i += 1;
     }
@@ -1985,7 +2621,9 @@
       const edges2 = edgesOfKind(graph, symbolKind).filter((e) => objectIds.has(e.object));
       return uniqueById(edges2.map((e) => graph.byId.get(e.subject)).filter((s) => s && s.class === entityType));
     }
-    const edges = kindsFor(kind).flatMap((k) => edgesOfKind(graph, k)).filter((e) => objectIds.has(e.object));
+    const objHasFine = !!symbolKind && [...objectIds].some((id) => FINE_ENTITY_TYPES.has(graph.byId.get(id)?.class));
+    const scanKinds = objHasFine ? [...kindsFor(kind), symbolKind] : kindsFor(kind);
+    const edges = scanKinds.flatMap((k) => edgesOfKind(graph, k)).filter((e) => objectIds.has(e.object));
     const subjects = uniqueById(edges.map((e) => graph.byId.get(e.subject)).filter(Boolean));
     if (!entityType || entityType === "Change") return subjects;
     const direct = subjects.filter((s) => s.class === entityType);
@@ -2165,6 +2803,15 @@
     }
     return n;
   }
+  function evalTemporal(graph, ast, opts) {
+    const inner = evalSet(graph, ast.inner, opts);
+    const ids = new Set(inner.map((i) => i.id));
+    if (!ids.size) return { compositeKind: "temporal", matches: [], entityType: ast.entityType, innerCount: 0 };
+    const commits = reverseOverSet(graph, "touches", "Commit", ids);
+    const dateOf = (c) => String((c.attributes || []).find((a) => a.key === "date")?.value || "");
+    commits.sort((a, b) => dateOf(b).localeCompare(dateOf(a)));
+    return { compositeKind: "temporal", matches: commits, entityType: ast.entityType, innerCount: inner.length };
+  }
   function evalSuperlative(graph, ast) {
     const pool = graph.individuals.filter((i) => i.class === ast.entityType);
     const scored = pool.map((ind) => ({ ind, score: degreeMetric(graph, ind, ast.metric) })).sort((a, z) => ast.extreme === "most" ? z.score - a.score : a.score - z.score);
@@ -2178,6 +2825,7 @@
     if (ast.node === "count") return { compositeKind: "count", count: evalSet(graph, ast.base, opts).length, entityType: ast.entityType, matches: [] };
     if (ast.node === "list") return { compositeKind: "list", matches: evalSet(graph, ast.base, opts), entityType: ast.entityType, scoped: ast.scoped };
     if (ast.node === "superlative") return evalSuperlative(graph, ast);
+    if (ast.node === "temporal") return evalTemporal(graph, ast, opts);
     if (ast.node === "anaphora") return evalAnaphora(graph, ast, opts);
     return { compositeKind: "set", matches: evalSet(graph, ast, opts), entityType: ast.entityType || null };
   }
@@ -2215,6 +2863,31 @@
         matches: result.matches
       };
     }
+    if (result.compositeKind === "temporal") {
+      const n = result.innerCount || 0;
+      const setNoun = result.entityType ? nounFor(result.entityType, n || 2) : n === 1 ? "entity" : "entities";
+      const wasWere = n === 1 ? "was" : "were";
+      if (!n) {
+        return { content: `nothing in the index matches the inner set, so there is no change history to date.`, miss: true, ambiguous: false, matches: [] };
+      }
+      if (!result.matches.length) {
+        return { content: `no recorded commit touched the ${n} ${setNoun} in that set in this index.`, miss: true, ambiguous: false, matches: [] };
+      }
+      const newest = result.matches[0];
+      const date = (newest.attributes || []).find((a) => a.key === "date")?.value || "";
+      if (!date) {
+        return { content: `the ${setNoun} in that set ${wasWere} last touched by commit ${newest.label}, but this index records no commit dates \u2014 regenerate the graph to attach mgx:commitDate.`, miss: true, ambiguous: false, matches: result.matches };
+      }
+      const msg = (newest.attributes || []).find((a) => a.key === "message")?.value || "";
+      const day = String(date).slice(0, 10);
+      const more = result.matches.length - 1;
+      return {
+        content: `the ${setNoun} in that set ${wasWere} last touched by commit ${newest.label} on ${day}${msg ? ` ("${msg}")` : ""}${more ? `; ${more} earlier commit${more === 1 ? "" : "s"} recorded` : ""}.`,
+        miss: false,
+        ambiguous: false,
+        matches: result.matches
+      };
+    }
     if (!result.matches.length) {
       return { content: `nothing in the index matches that${result.entityType ? ` (${nounFor(result.entityType, 2)})` : ""}.`, miss: true, ambiguous: false, matches: [] };
     }
@@ -2385,7 +3058,24 @@
         const token = (i.attributes || []).find((a) => a.key === "token")?.value;
         return token && String(token).toLowerCase() === termLc;
       });
-      if (!match) return { matches: [], objMatch: null, candidates: [], traversal: `schema lookup for "${term}"`, ambiguous: false };
+      if (!match) {
+        const classHits = (graph.individuals || []).filter((i) => i.class === "Class" && String(i.label).toLowerCase() === termLc);
+        if (classHits.length === 1) {
+          const hit2 = classHits[0];
+          const mid = moduleIdOf2(graph, hit2);
+          const modLabel = mid && graph.byId.get(mid)?.label || String((hit2.attributes || []).find((a) => a.key === "site")?.value || "").split(":")[0] || null;
+          return {
+            matches: [hit2],
+            objMatch: hit2,
+            candidates: [],
+            ambiguous: false,
+            metaCodeClass: true,
+            metaModuleLabel: modLabel,
+            traversal: `schema lookup for "${term}" (miss), then unique Class individual by label`
+          };
+        }
+        return { matches: [], objMatch: null, candidates: [], traversal: `schema lookup for "${term}"`, ambiguous: false };
+      }
       return {
         matches: [match],
         objMatch: match,
@@ -2494,9 +3184,13 @@
       return commitTouches(graph, objMatch, entityType, { candidates, ambiguous, matchedVia });
     }
     if (shape === "forward") {
-      const edges2 = kindsFor(kind).flatMap((k) => edgesOfKind(graph, k)).filter((e) => e.subject === objMatch.id);
-      const matches2 = edges2.map((e) => graph.byId.get(e.object)).filter(Boolean);
-      return { matches: matches2, objMatch, candidates, traversal: `${kindsFor(kind).join("+")} edges where subject = ${objMatch.label}`, ambiguous, matchedVia };
+      const fwdSibling = SYMBOL_GRAIN_SIBLING[kind];
+      const subjIsFineSymbol = !!(fwdSibling && objMatch.class && FINE_ENTITY_TYPES.has(objMatch.class));
+      const fwdKinds = subjIsFineSymbol ? [.../* @__PURE__ */ new Set([...kindsFor(kind), fwdSibling])] : kindsFor(kind);
+      const edges2 = fwdKinds.flatMap((k) => edgesOfKind(graph, k)).filter((e) => e.subject === objMatch.id);
+      const targets = edges2.map((e) => graph.byId.get(e.object)).filter(Boolean);
+      const matches2 = subjIsFineSymbol ? uniqueById(targets) : targets;
+      return { matches: matches2, objMatch, candidates, traversal: `${fwdKinds.join("+")} edges where subject = ${objMatch.label}`, ambiguous, matchedVia };
     }
     if (parsed.modifier === "transitive") {
       const levels = impactClosure(graph, objMatch, { maxDepth: TRANSITIVE_MAX_DEPTH });
@@ -2515,8 +3209,17 @@
     if (symbolKind && (FINE_ENTITY_TYPES.has(entityType) || objIsFineSymbol)) {
       const edges2 = edgesOfKind(graph, symbolKind).filter((e) => e.object === objMatch.id);
       const subjects2 = uniqueById(edges2.map((e) => graph.byId.get(e.subject)).filter(Boolean));
-      const matches2 = !entityType || entityType === "Change" ? subjects2 : subjects2.filter((i) => i.class === entityType);
-      return { matches: matches2, objMatch, candidates, traversal: `${symbolKind} edges where object = ${objMatch.label}`, ambiguous, matchedVia };
+      let matches2 = !entityType || entityType === "Change" ? subjects2 : subjects2.filter((i) => i.class === entityType);
+      let widenNote = "";
+      const siblingClass = FINE_CLASS_SIBLING[entityType];
+      if (!matches2.length && siblingClass) {
+        const widened = subjects2.filter((i) => i.class === siblingClass);
+        if (widened.length) {
+          matches2 = widened;
+          widenNote = `, widened to ${siblingClass} subjects (no ${entityType} recorded)`;
+        }
+      }
+      return { matches: matches2, objMatch, candidates, traversal: `${symbolKind} edges where object = ${objMatch.label}${widenNote}`, ambiguous, matchedVia };
     }
     let edges = kindsFor(kind).flatMap((k) => edgesOfKind(graph, k)).filter((e) => e.object === objMatch.id);
     let extNote = "";
@@ -2562,6 +3265,11 @@
     const label = String(ind.label || ind.id || "");
     return ["Function", "Method"].includes(ind.class) ? `function ${label}()` : label;
   }
+  function commitRefOf(ind) {
+    const sha = String(ind.label || ind.id || "");
+    const author = (ind.attributes || []).find((a) => a.key === "author")?.value;
+    return author ? `${sha} (${author})` : sha;
+  }
   function listJoin(syms) {
     return syms.length > 1 ? `${syms.slice(0, -1).join(", ")} and ${syms[syms.length - 1]}` : syms[0];
   }
@@ -2613,6 +3321,16 @@
           ambiguous: false
         };
       }
+      if (result.metaCodeClass) {
+        const label = result.objMatch.label;
+        const definedIn = result.metaModuleLabel ? `, defined in ${result.metaModuleLabel}` : "";
+        return {
+          content: `${label} is a class in this codebase${definedIn} \u2014 try "describe ${label}" or "which classes inherit from ${label}".`,
+          miss: false,
+          ambiguous: false,
+          matches: result.matches
+        };
+      }
       const doc = (result.objMatch.attributes || []).find((a) => a.key === "doc")?.value || "";
       const kindWord = result.objMatch.class === "SchemaClass" ? "a class in the graph's schema" : "a predicate (relation) in the graph's schema";
       return { content: `${result.objMatch.label} is ${kindWord}: ${doc}`, miss: false, ambiguous: false, matches: result.matches };
@@ -2620,7 +3338,7 @@
     if (result.mentionsShape) {
       if (!result.matches.length) {
         return {
-          content: `"${parsed.object}" is not mentioned in any indexed identifier or doc-comment prose. (traversal: ${result.traversal})`,
+          content: `"${parsed.object}" is not mentioned in any indexed identifier or doc-comment prose.`,
           miss: true,
           ambiguous: false
         };
@@ -2677,7 +3395,7 @@
     if (result.whenShape) {
       const subject = result.objMatch.label;
       if (!result.matches.length) {
-        return { content: `no recorded commit touches ${subject} in this index. (traversal: ${result.traversal})`, miss: true, ambiguous: false };
+        return { content: `no recorded commit touches ${subject} in this index.`, miss: true, ambiguous: false };
       }
       const newest = result.matches[0];
       const date = (newest.attributes || []).find((a) => a.key === "date")?.value || "";
@@ -2705,7 +3423,7 @@
       const cite = `commit ${result.objMatch.label}`;
       if (!result.matches.length) {
         return {
-          content: `${cite} touched nothing recorded in the index. (traversal: ${result.traversal})`,
+          content: `${cite} touched nothing recorded in the index.`,
           miss: true,
           ambiguous: false
         };
@@ -2725,7 +3443,7 @@
         return { content: `couldn't resolve one of the terms in this question.`, miss: true, ambiguous: false };
       }
       return {
-        content: result.answer ? `Yes. (${result.traversal})` : `No \u2014 no ${parsed.kind} edge found from ${result.subjMatch.label} to ${result.objMatch.label}.`,
+        content: result.answer ? `Yes \u2014 ${result.traversal}.` : `No \u2014 no ${parsed.kind} edge found from ${result.subjMatch.label} to ${result.objMatch.label}.`,
         miss: !result.answer,
         ambiguous: false
       };
@@ -2733,20 +3451,29 @@
     if (!result.matches.length) {
       if (parsed.shape === "forward") {
         return {
-          content: `${result.objMatch.label} has no ${parsed.kind} edges in the index. (traversal: ${result.traversal || "no traversal resolved"})`,
+          content: `${result.objMatch.label} has no ${parsed.kind} edges in the index.`,
+          miss: true,
+          ambiguous: false
+        };
+      }
+      if (parsed.kind === "tests" && !parsed.entityType) {
+        const stripped = String(parsed.object || "").replace(LEADING_RELATION_VERB_RE, "").trim();
+        const obj = stripped || String(parsed.object || "").trim();
+        return {
+          content: `No tests cover ${obj}.`,
           miss: true,
           ambiguous: false
         };
       }
       const entityWord = nounFor(parsed.entityType || "Module", 2);
       return {
-        content: `No ${entityWord} found whose module directly ${verbFor(parsed.kind)} ${parsed.object}. (traversal: ${result.traversal || "no traversal resolved"})`,
+        content: `No ${entityWord} found whose module directly ${verbFor(parsed.kind)} ${parsed.object}.`,
         miss: true,
         ambiguous: false
       };
     }
     if (parsed.shape === "forward" || parsed.entityType === "Module" || result.matches.every((m) => !FINE_ENTITY_TYPES.has(m.class))) {
-      const shown = result.matches.slice(0, OVERFLOW_CAP).map((m) => m.label);
+      const shown = result.matches.slice(0, OVERFLOW_CAP).map((m) => m.class === "Commit" ? commitRefOf(m) : m.label);
       const extra2 = result.matches.length > OVERFLOW_CAP ? `, \u2026and ${result.matches.length - OVERFLOW_CAP} more` : "";
       return { content: shown.join(" and ") + extra2 + ".", miss: false, ambiguous: false, matches: result.matches };
     }
@@ -2806,17 +3533,17 @@
   function fuzzyCascadeWord(w) {
     const bound = fuzzyBound(w);
     let best = bound + 1;
-    let hit = null;
+    let hit2 = null;
     let tied = false;
     for (const target of CASCADE_FUZZY_TARGETS) {
       const d = editDistance(w, target, Math.min(best, bound));
       if (d < best) {
         best = d;
-        hit = target;
+        hit2 = target;
         tied = false;
-      } else if (d === best && d <= bound && target !== hit) tied = true;
+      } else if (d === best && d <= bound && target !== hit2) tied = true;
     }
-    return best <= bound && !tied ? hit : null;
+    return best <= bound && !tied ? hit2 : null;
   }
   function schemaTypoTrap(resolution, term) {
     if (!resolution?.match || resolution.matchedVia !== "fuzzy" || resolution.ambiguous) return false;
@@ -2875,7 +3602,7 @@
       const rendered = render(p, traverse(graph, p, { contextId, prev }));
       return rendered.miss ? null : { parsed: p, text };
     };
-    const done = (hit) => ({ parsed: hit.parsed, from, to: hit.text, dropped: [...dropped], steps });
+    const done = (hit2) => ({ parsed: hit2.parsed, from, to: hit2.text, dropped: [...dropped], steps });
     let guard = 0;
     const hardCap = Math.max(tokens.length, 1) + 12;
     for (; guard < hardCap; guard += 1) {
@@ -2892,8 +3619,8 @@
       tokens = tokens.filter((_, i) => i !== idx);
       dropped.push(removed);
       steps.push(`strip noise "${removed}" \u2192 "${tokens.join(" ")}"`);
-      const hit = attempt(tokens);
-      if (hit) return done(hit);
+      const hit2 = attempt(tokens);
+      if (hit2) return done(hit2);
     }
     const survivors = [];
     const nowDropped = [];
@@ -2918,8 +3645,8 @@
       dropped.push(...nowDropped);
       if (corrected.length) steps.push(`fuzzy-correct ${JSON.stringify(corrected)} \u2192 "${tokens.join(" ")}"`);
       if (nowDropped.length) steps.push(`drop unmatched ${JSON.stringify(nowDropped)} \u2192 "${tokens.join(" ")}"`);
-      const hit = attempt(tokens);
-      if (hit) return done(hit);
+      const hit2 = attempt(tokens);
+      if (hit2) return done(hit2);
     }
     let changed = false;
     const normed = tokens.map((t) => {
@@ -2932,8 +3659,8 @@
     });
     if (changed) {
       steps.push(`normalise synonyms \u2192 "${normed.join(" ")}"`);
-      const hit = attempt(normed);
-      if (hit) return done(hit);
+      const hit2 = attempt(normed);
+      if (hit2) return done(hit2);
     }
     const bareLc = splitWords(from).map((t) => t.toLowerCase());
     const kindWords = [];
@@ -2945,10 +3672,10 @@
       else others.push(t);
     }
     if (kindWords.length === 1 && others.length === 0) {
-      const hit = attempt(["count", kindWords[0]]);
-      if (hit) {
+      const hit2 = attempt(["count", kindWords[0]]);
+      if (hit2) {
         steps.push(`bare kind "${kindWords[0]}" \u2192 count`);
-        return done(hit);
+        return done(hit2);
       }
     }
     return null;
@@ -3013,7 +3740,7 @@
     };
   }
 
-  // packages/seonix/src/ask-browser-entry.mjs
+  // src/ask-browser-entry.mjs
   function parseEntities(payload) {
     const individuals = Array.isArray(payload?.individuals) ? payload.individuals : [];
     const byId = /* @__PURE__ */ new Map();