@polycode-projects/seonix 0.9.0 → 0.9.1

package/README.md

@@ -325,7 +325,7 @@ set `SEONIX_GRAPH_FORMAT=1` to opt back out to the legacy v1 form.
 An optional `seonix.toml` at a repo (or estate) root steers indexing and
 scoring. Absent file = shipped defaults, byte-for-byte today's behaviour.
 `seonix init` (or `seonix init --dotnet` for an estate) seeds a commented
-template — see `packages/seonix/templates/seonix.toml` and
+template — see `templates/seonix.toml` and
 `templates/seonix-dotnet.toml` for the full annotated reference.
 
 - **`repositories`** — the repo set for an estate config: an inline array of

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polycode-projects/seonix",
-  "version": "0.9.0",
+  "version": "0.9.1",
   "private": false,
   "type": "module",
   "description": "SEONIX — a deterministic, offline, $0 code-graph tool that makes a cheap coding agent edit like an expensive one. Indexes a repo with Python ast + git (zero model calls) and renders a bounded edit-digest.",
@@ -9,8 +9,7 @@
   "homepage": "https://seonix.polycode.co.uk",
   "repository": {
     "type": "git",
-    "url": "git+https://gitlab.com/polycode-projects/seonix.git",
-    "directory": "packages/seonix"
+    "url": "git+https://gitlab.com/polycode-projects/seonix.git"
   },
   "bugs": {
     "url": "https://gitlab.com/polycode-projects/seonix/-/issues"
@@ -42,9 +41,58 @@
   "publishConfig": {
     "access": "public"
   },
+  "workspaces": [
+    "infra"
+  ],
+  "scripts": {
+    "setup": "node scripts/setup.mjs",
+    "bench": "node bench/run.mjs",
+    "bench:quick": "node bench/run.mjs --instances 1 --runs 1",
+    "join:telemetry": "node scripts/join-telemetry.mjs",
+    "bench:lite": "node bench/run.mjs --suite lite",
+    "bench:seonix": "node bench/run.mjs --suite django-lh --arms seonix,seonix-min --runs 5",
+    "bench:b010": "node bench/run.mjs --suite django-lh --arms otb,seonix,seonix-min,seonix-b010 --models claude-opus-4-8,claude-sonnet-4-6 --runs 5 --concurrency 10",
+    "bench:b011": "node bench/run.mjs --suite django-lh --arms seonix,seonix-min --models claude-opus-4-8,claude-sonnet-4-6,claude-haiku-4-5 --runs 5 --concurrency 15",
+    "bench:b011-haiku-refs": "node bench/run.mjs --suite django-lh --arms otb,seonix-b010 --models claude-haiku-4-5 --runs 5 --concurrency 10",
+    "bench:b015": "node scripts/bench-b015.mjs",
+    "bench:b016p1": "node scripts/bench-b016-p1.mjs",
+    "bench:b016h": "node scripts/bench-b016-h.mjs",
+    "bench:b016p2": "node scripts/bench-b016-p2.mjs",
+    "bench:baseline": "node scripts/use-baseline.mjs",
+    "proof": "node scripts/proof-demo.mjs",
+    "smoke": "node bench/smoke.mjs --suite django-lh",
+    "report": "node bench/report.mjs",
+    "all": "npm run setup && npm run bench && npm run report",
+    "clean": "node scripts/clean.mjs",
+    "verify:counts": "node scripts/verify-counts.mjs",
+    "verify:sanity": "node scripts/verify-sanity.mjs",
+    "verify:index": "node scripts/verify-index.mjs",
+    "verify:query": "node scripts/verify-query.mjs",
+    "verify:review": "node scripts/verify-review.mjs",
+    "verify:loop": "node scripts/verify-loop.mjs",
+    "refs": "node scripts/fetch-references.mjs",
+    "refs:embeddings": "node scripts/fetch-embeddings.mjs",
+    "audit": "npm audit --audit-level=high",
+    "audit:fix": "npm audit fix",
+    "test:root": "node --test \"test/**/*.test.mjs\"",
+    "test": "npm run test:root && npm run chrono:test",
+    "chrono:build": "node chronograph/build.mjs",
+    "chrono:serve": "node chronograph/serve.mjs",
+    "chrono:test": "node --test \"chronograph/test/**/*.test.mjs\"",
+    "test:all": "npm run test",
+    "seonix": "node bin/cli.mjs",
+    "seonix:viz": "node bin/cli.mjs viz --",
+    "e2e:install": "npx playwright install chromium --with-deps",
+    "e2e": "playwright test",
+    "e2e:site": "playwright test site.behaviour.test.js",
+    "e2e:prod": "SEONIX_E2E_BASE_URL=https://seonix.polycode.co.uk playwright test site.behaviour.test.js",
+    "site:prompts": "node scripts/site-prompts.mjs",
+    "build:ask-bundle": "node scripts/build-ask-bundle.mjs",
+    "site:gen": "npm run build:ask-bundle && node bin/cli.mjs viz --focus buildContextBundle --depth 2 --repo-url https://gitlab.com/polycode-projects/seonix --site-nav --out site/seonix-graph.html --data-out site/seonix-graph-data.json --browser-out site/code-browser.html --browser-data-out site/code-browser-data.json --timeline-out site/timeline.html && npm run site:prompts"
+  },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@polycode-projects/the-mechanical-code-talker": "^0.8.0",
+    "@polycode-projects/the-mechanical-code-talker": "^0.8.1",
     "cytoscape": "^3.30.0",
     "smol-toml": "^1.7.0",
     "tree-sitter": "^0.21.1",
@@ -52,8 +100,8 @@
     "tree-sitter-java": "^0.21.0",
     "typescript": "~5.6.2"
   },
-  "scripts": {
-    "test": "node --test \"test/**/*.test.mjs\"",
-    "viz": "node bin/cli.mjs viz"
+  "devDependencies": {
+    "@playwright/test": "^1.56.0",
+    "esbuild": "^0.28.1"
   }
 }

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
@@ -972,6 +975,92 @@
     }
     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").
+    { re: /^who\s+(?:wrote|authored)\s+(?:the\s+)?(.+?)\??$/i, to: (m) => `who touched ${m[1]}` },
+    { re: /^who\s+is\s+the\s+authors?\s+of\s+(?:the\s+)?(.+?)\??$/i, to: (m) => `who touched ${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 +1147,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 +1342,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,6 +1445,423 @@
     }
   };
 
+  // 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}$)/, "");
@@ -1422,7 +1928,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 +1942,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 +2032,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) {
@@ -1577,7 +2084,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 +2103,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 +2200,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 +2517,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 +2544,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 +2726,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 +2748,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 +2786,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: [] };
     }
@@ -2562,6 +3158,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];
   }
@@ -2738,6 +3339,14 @@
           ambiguous: false
         };
       }
+      if (parsed.kind === "tests" && !parsed.entityType) {
+        const obj = String(parsed.object || "").replace(/^cover(?:s|ing)?\s+/i, "").trim();
+        return {
+          content: `No tests cover ${obj}. (traversal: ${result.traversal || "no traversal resolved"})`,
+          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"})`,
@@ -2746,7 +3355,7 @@
       };
     }
     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 +3415,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 +3484,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 +3501,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 +3527,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 +3541,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 +3554,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 +3622,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();