@polycode-projects/seonix 0.10.14 → 0.10.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polycode-projects/seonix",
-  "version": "0.10.14",
+  "version": "0.10.18",
   "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.",
@@ -50,7 +50,7 @@
     "setup": "node scripts/setup.mjs",
     "bench": "node bench/run.mjs",
     "bench:quick": "node bench/run.mjs --instances 1 --runs 1",
-    "bench:telemetry": "node bench/run.mjs --suite django-lh --arms seonix-ask --instances 1 --runs 1 --telemetry",
+    "bench:telemetry": "node bench/run.mjs --suite django-lh --arms seonix --instances 1 --runs 1 --telemetry",
     "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",
@@ -89,7 +89,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@polycode-projects/the-mechanical-code-talker": "^1.0.4",
+    "@polycode-projects/the-mechanical-code-talker": "^1.3.0",
     "cytoscape": "^3.30.0",
     "smol-toml": "^1.7.0",
     "tree-sitter": "^0.21.1",

package/src/ask-browser.bundle.js

@@ -180,8 +180,17 @@
     const m = String(ind?.id || "").match(/^fn:(.+)#/);
     return m ? `mod:${m[1]}` : null;
   }
+  var HISTORY_CAP = 15;
 
   // node_modules/@polycode-projects/the-mechanical-code-talker/src/ask-vocab.mjs
+  var INHERITS_REVERSE_VERB_LIST = [
+    "is a superclass of",
+    "are a superclass of",
+    "is a parent class of",
+    "are a parent class of",
+    "superclass",
+    "superclasses"
+  ];
   var RELATIONS = {
     imports: {
       comment: "Module -> Module: subject's import graph references object (usesComplexType).",
@@ -323,6 +332,17 @@
       verbs: [
         "inherits from",
         "inherit from",
+        // bare "inherits"/"inherit" (Tier 6 playtest, §3b surface-variation axis):
+        // this list's own SIBLING verb "extends"/"extend" already works bare, with
+        // no "from" required, but "inherits"/"inherit" — arguably the MORE common
+        // everyday phrasing of the two ("TaskController inherits Controller",
+        // "does TaskController inherit Controller") — had no bare form at all,
+        // only the "... from" variant. VERB_ALT's longest-first sort (already
+        // relied on elsewhere in this file for the same reason) means "inherits
+        // from"/"inherit from" still win whenever "from" actually follows, so
+        // this is purely additive.
+        "inherits",
+        "inherit",
         "extends",
         "extend",
         "subclasses",
@@ -347,7 +367,13 @@
         "inheriting from",
         "inheriting",
         "subclassing",
-        "extends from"
+        "extends from",
+        // REVERSE phrasings (Seonix Batch 2 Fix 2, see INHERITS_REVERSE_VERB_LIST's own
+        // comment above): "is/are a|the superclass/parent class of" — folded in here so
+        // VERB_TO_KIND maps them to "inherits" like every other verb in this list; the
+        // subject/object SWAP their direction requires is handled at parse time by the
+        // strategies that build the "ask" shape, not here.
+        ...INHERITS_REVERSE_VERB_LIST
       ]
     },
     touches: {
@@ -424,7 +450,17 @@
         // producing a confidently-empty answer regardless of real cochange data.
         "changed together with",
         "change together with",
-        "changes together with"
+        "changes together with",
+        // Present-tense bare form (Seonix Batch 4/5 follow-up): only the past tense
+        // "changed with" existed above — "what changes with X"/"what usually changes
+        // with X" fell through entirely (ENTITY_TO_TYPE's own "changes"->"Change"
+        // pseudo-type noun risked consuming the word first; see parseRelationalOrQualified's
+        // guard against exactly that in ask.mjs).
+        "changes with",
+        "change with",
+        "tends to change with",
+        "tend to change with",
+        "usually changes with"
       ]
     },
     reexports: {
@@ -447,8 +483,30 @@
       ]
     }
   };
+  var INHERITS_REVERSE_VERBS = Object.freeze([
+    ...INHERITS_REVERSE_VERB_LIST,
+    "is the superclass of",
+    "are the superclass of",
+    "is the parent class of"
+  ]);
   var WHERE_MARKERS = Object.freeze(["defined", "declared", "located", "implemented"]);
   var MENTION_MARKERS = Object.freeze(["mentioned", "referenced"]);
+  var TRAILING_SCOPE_FILLER = Object.freeze([
+    "in this graph",
+    "in the graph",
+    "in this codebase",
+    "in the codebase",
+    "in this repo",
+    "in the repo",
+    "here"
+  ]);
+  var TRAILING_SCOPE_FILLER_RE = new RegExp(
+    `\\s+(?:${TRAILING_SCOPE_FILLER.join("|")})\\s*[?.!]*$`,
+    "i"
+  );
+  function stripTrailingScopeFiller(text) {
+    return text.replace(TRAILING_SCOPE_FILLER_RE, "").trim();
+  }
   var VERB_TO_KIND = Object.freeze(
     Object.fromEntries(
       Object.entries(RELATIONS).flatMap(([kind, { verbs }]) => verbs.map((v) => [v, kind]))
@@ -637,6 +695,14 @@
     "mnay": "many",
     "amny": "many",
     "mnany": "many",
+    // "hwo" (Tier 6 playtest, §3b typo axis): a transposed-letter typo of "how" —
+    // "hwo many classes are there" used to lose the aggregate/list trigger
+    // outright ("how many" only reads as a count trigger when both words are
+    // exact), same failure class as "manyn"/"mnay" just above, one word to the
+    // left of it. "how" is grammar-owned via AGGREGATE_TRIGGERS' own "how many"/
+    // "how much" entries (test/ask-vocab.test.mjs's canonical-value check
+    // splits those multi-word triggers into individual words).
+    "hwo": "how",
     "coutn": "count",
     "conut": "count",
     "cuont": "count",
@@ -981,6 +1047,8 @@
   );
   var MISSPELLING_RE = correctionRe(MISSPELLINGS);
   var WRONG_WORD_RE = correctionRe(WRONG_WORDS);
+  var KIND_NOUN_ANAPHORA_RE = /\b(this|that)\s+(class|module|function|method|attribute|variable|file|commit)\b/gi;
+  var VERB_ALTERNATION = Object.keys(VERB_TO_KIND).sort((a, b) => b.length - a.length).map(escapeRegex).join("|");
   var RELATION_VERB_RE = new RegExp(
     "\\b(?:" + Object.keys(VERB_TO_KIND).sort((a, b) => b.length - a.length).map(escapeRegex).join("|") + ")\\b",
     "i"
@@ -1008,23 +1076,42 @@
     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|g'?day|good\s+(?:morning|afternoon|evening|day)|greetings|salutations)(?:\s+there)?\s*[,.—–-]\s*(?:(?:just\s+a\s+)?quick\s+question\s*[,:—–-]?\s*)?(.+)$/i;
+  var GREETING_PREAMBLE_RE = /^(?:hi|hiya|hello|hey|yo|howdy|g'?day|yeah\s+nah|good\s+(?:morning|afternoon|evening|day)|greetings|salutations)(?:\s+(?:there|pardner|folks|friend|mate))?\s*[,.—–-]\s*(?:(?:just\s+a\s+)?quick\s+question\s*[,:—–-]?\s*)?(.+)$/i;
   var THANKS_PREAMBLE_RE = /^(?:thanks|thank\s+you|many\s+thanks|thx|ty|cheers)(?:\s+(?:so\s+much|a\s+lot|very\s+much|a\s+bunch))?\s*[,—–-]\s*(?:(?:just\s+a\s+)?quick\s+question\s*[,:—–-]?\s*)?(.+)$/i;
+  var ACK_PREAMBLE_RE = /^(?:(?:ok(?:ay)?|aight|cool|alright|sure|right|fine|great|nice|got it|gotcha|sounds good|no worries|no problem)[\s,]+)+(.+)$/i;
+  var BROWSING_PREAMBLE_RE = /^just\s+(?:poking\s+around|looking\s+around|browsing|exploring|checking\s+(?:this|it)\s+out)\s*[,.—–-]\s*(.+)$/i;
+  var HEDGE_ADVERB_PREAMBLE_RE = /^(?:(?:maybe|possibly|perhaps)\s+)+(.+)$/i;
+  var TROUBLE_ASIDE_RE = /,?\s*if\s+(?:it'?s|it\s+is|that'?s|that\s+is)\s+not\s+too\s+much\s+(?:trouble|bother|hassle)\s*,?\s*/i;
   var MODAL_WRAPPER_RE = /^(?:can|could|would|will)\s+you\s+(?:please\s+)?(.+?)(?:[,\s]+please)?\??$/i;
   var EXPLAIN_WRAPPER_RE = /^explain\s+(?:to\s+me\s+|please\s+)*(.+?)\??$/i;
+  var TELL_ME_WRAPPER_RE = /^tell\s+me\s+(.+?)\??$/i;
   var SHOW_GIVE_ME_RE = /^(?:show|give)\s+me\s+(?:the\s+)?(.+?)\??$/i;
+  var LEADING_CONNECTIVE_RE = /^(?:and|also|so|then|now|but)\s+(.+)$/i;
+  var QUESTION_AUX_LEAD_RE = /^(?:does|do|did|is|are|was|were|has|have|had|can|could|will|would|should)\b/i;
+  var TOPIC_SWITCH_PREAMBLE_RE = /^(?:(?:actually|no\s+wait|wait|hold\s+on|never\s+mind|scratch\s+that|on\s+second\s+thought|i\s+mean(?:t)?)[\s,.]+)+(.+)$/i;
   function applyPreambleFrames(text) {
     let q = String(text || "");
+    q = q.replace(TROUBLE_ASIDE_RE, " ").replace(/\s+/g, " ").trim();
     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(THANKS_PREAMBLE_RE);
       if (m) q = m[1].trim();
+      m = q.match(ACK_PREAMBLE_RE);
+      if (m) q = m[1].trim();
+      m = q.match(BROWSING_PREAMBLE_RE);
+      if (m) q = m[1].trim();
+      m = q.match(HEDGE_ADVERB_PREAMBLE_RE);
+      if (m) q = m[1].trim();
+      m = q.match(TOPIC_SWITCH_PREAMBLE_RE);
+      if (m) q = m[1].trim();
       m = q.match(MODAL_WRAPPER_RE);
       if (m) q = m[1].trim();
       m = q.match(EXPLAIN_WRAPPER_RE);
       if (m && INTERROGATIVE_LEAD_RE.test(m[1].trim())) q = m[1].trim();
+      m = q.match(TELL_ME_WRAPPER_RE);
+      if (m && INTERROGATIVE_LEAD_RE.test(m[1].trim())) q = m[1].trim();
       m = q.match(SHOW_GIVE_ME_RE);
       if (m) {
         const rest = m[1].trim();
@@ -1032,6 +1119,11 @@
           q = RELATION_VERB_RE.test(rest) || INTERROGATIVE_LEAD_RE.test(rest) ? rest : `describe ${rest}`;
         }
       }
+      m = q.match(LEADING_CONNECTIVE_RE);
+      if (m) {
+        const rest = m[1].trim();
+        if (INTERROGATIVE_LEAD_RE.test(rest) || QUESTION_AUX_LEAD_RE.test(rest) || TOPIC_SWITCH_PREAMBLE_RE.test(rest) || ACK_PREAMBLE_RE.test(rest) || HEDGE_ADVERB_PREAMBLE_RE.test(rest) || BROWSING_PREAMBLE_RE.test(rest)) q = rest;
+      }
       if (q === before) break;
     }
     return q;
@@ -1102,6 +1194,7 @@
     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(KIND_NOUN_ANAPHORA_RE, (_, pron) => pron);
     q = q.replace(G_DROP, "$1ing");
     q = applyPreambleFrames(q);
     q = applySelfCorrectionFrames(q);
@@ -1136,6 +1229,23 @@
     { 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` },
+    //   "what else is in X" (0.9.15 Tier-1 single-touch playtest) — the natural
+    //   "besides what I already know" drill-down after a members-of-class answer.
+    //   Distinct from the "what else does X <verb>" family (which the compositional
+    //   grammar already tolerates, dropping "else" as noise on its own): the "is
+    //   in" idiom is NOT a compositional marker, so parseComposite never sees it and
+    //   "what else is in X" fell through to the strategies with NO candidate at all
+    //   (neither recognizes the bare "is in" idiom once "else" sits in front of it).
+    //   The only rescue was the relaxation cascade's drop-unmatched layer — but that
+    //   layer refuses to accept a relaxed reading that still renders an honest EMPTY
+    //   (by design: relaxation must turn a miss into a real answer, never into
+    //   another kind of miss), so a genuinely empty class ("what else is in
+    //   Task.complete" — a method, no members) bottomed out at the bare grammar
+    //   wall instead of the specific "no contains edges" receipt. Routing this
+    //   frame onto the SAME direct "what does X contain" path the plain "what is
+    //   in X" frame above already uses sidesteps the cascade's conservative gate
+    //   entirely, so a real empty is reported honestly instead of walled.
+    { re: /^what\s+else\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
@@ -1226,7 +1336,26 @@
     // 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" }
+    { re: /^what\s+needs\s+(?:to\s+be\s+)?(?:a\s+)?(?:tested|tests?|testing|coverage|covering)\??$/i, to: () => "untested modules" },
+    // DOES-X-VERB-ANYTHING-ELSE → the plain forward "what does X <verb>" listing
+    // (0.9.15 Tier-1 single-touch playtest). A very natural drill-down follow-up
+    // after a relation answer — "does listTasks call anything else", "does
+    // src/handlers/tasks.mjs import something else" — used to dead-end: "anything"/
+    // "something" [else] is a placeholder standing in for "the rest of the list",
+    // not a real object term, but the two parse strategies disagreed on the SPAN
+    // (grammar kept "anything else" whole as the object, keyword-spot dropped
+    // "anything" and kept only "else"), landing on the {ambiguousParse} surface —
+    // two nonsense readings offered as if one might be right. "what does X <verb>"
+    // is the exact working canonical shape (see the MEMBERS-of-class frames above),
+    // so rewriting the whole closed pattern onto it sidesteps the disagreement
+    // instead of teaching either strategy's tokenizer to special-case "else".
+    // Anchored to the closed VERB_TO_KIND vocabulary so it can never swallow a
+    // genuine named object that happens to start with "any"/"some" (only the bare
+    // placeholder nouns "anything"/"something", optionally trailed by "else", match).
+    {
+      re: new RegExp(`^(?:do|does)\\s+(.+?)\\s+(${VERB_ALTERNATION})\\s+(?:anything|something)(?:\\s+else)?\\??$`, "i"),
+      to: (m) => `what does ${m[1]} ${m[2]}`
+    }
   ]);
   function applyPhrasingFrames(text) {
     for (const frame of PHRASING_FRAMES) {
@@ -1372,17 +1501,28 @@
     // does/is/do/did, which the reverse/forward templates below never match (those start with
     // which/what), so precedence between T1 and the rest is structural, not a tie-break guess.
     // "did" joins does/do for the past-tense commit forms ("did commit <sha> touch X").
+    // REVERSE VERB SWAP (Seonix Batch 2 Fix 2): this template fixes subject/object by regex
+    // capture POSITION, not by the verb's semantic direction — fine for every forward verb
+    // ("subclass of", "imports", …), but "is X a superclass of Y" MEANS the reverse of "is X
+    // a subclass of Y" (Y inherits from X, not X from Y). INHERITS_REVERSE_VERBS (ask-vocab.mjs)
+    // is the closed set of such reverse phrasings; when the matched verb is one of them,
+    // subject/object are swapped here, once, at parse time — so downstream evaluation (ask.mjs)
+    // sees "is Y a subclass of X" and needs zero changes of its own. (In practice this exact
+    // regex only ever matches a does/do/did lead, so "is …" phrasings actually reach the "ask"
+    // shape via keywords.mjs's decomposition strategy instead — that strategy applies the same
+    // swap for the same reason; this branch is kept for any does/do/did-led phrasing that names
+    // a reverse verb, and for structural symmetry with that sibling strategy.)
     {
       name: "ask",
       re: new RegExp(`^(?:does|do|did)\\s+(.+?)\\s+(${VERB_ALT})\\s+(.+?)\\??$`, "i"),
-      build: (m) => ({
-        shape: "ask",
-        entityType: null,
-        modifier: "direct",
-        kind: VERB_TO_KIND[m[2].toLowerCase()],
-        subject: m[1].trim(),
-        object: m[3].trim()
-      })
+      build: (m) => {
+        const verb = m[2].toLowerCase();
+        const kind = VERB_TO_KIND[verb];
+        let subject = m[1].trim();
+        let object = m[3].trim();
+        if (INHERITS_REVERSE_VERBS.includes(verb)) [subject, object] = [object, subject];
+        return { shape: "ask", entityType: null, modifier: "direct", kind, subject, object };
+      }
     },
     // T2 reverse: "which <entity> [<modifier>] <verb> <object>" — the operator's own example shape.
     {
@@ -1422,15 +1562,32 @@
       build: (m) => ({ shape: "meta", entityType: null, modifier: "direct", kind: "meta", object: m[1].trim() })
     },
     // T5 meta: "what is a/an <term>" — the OTHER worked phrasing ("what is a Commit").
-    // The indefinite article is REQUIRED (not optional): a bare "what is <anything>"
-    // would also swallow "what is the meaning of this codebase" (an existing, deliberately
-    // honest grammar-miss regression case — ask.test.mjs/ask-dual-strategy.test.mjs both
-    // assert it stays null), which never mentions "a"/"an" before its tail. Requiring the
-    // article keeps this template's reach to the one worked shape without reopening that.
+    // Seonix Batch 2 Fix 1: the indefinite article is now OPTIONAL, but the BARE
+    // (no-article) form is restricted to the CLOSED vocabulary ENTITY_TO_TYPE already
+    // imported above (function/method/class/module/attribute/variable/change/commit,
+    // singular and plural) — build() returns null (same "this template didn't actually
+    // match, keep scanning" contract T8/"when" below already relies on — see
+    // parseAnchored's own docblock) when the bare form's object isn't one of those
+    // closed terms, so the scan falls through exactly as if this template had not
+    // matched at all. This keeps "what is a doohickey"/"widget"/"gizmo" (still routed
+    // here via the WITH-article, fully unrestricted `(.+?)` path — pinned to resolve as
+    // an honest meta miss downstream, ask-combo.test.mjs/chat-readback.test.mjs) working
+    // unmodified, while ALSO keeping the two pinned bare-form honest misses intact:
+    // "what is the meaning of this codebase" (ask.test.mjs/ask-dual-strategy.test.mjs)
+    // and "what is exposed" (ask.test.mjs:840) both have bare objects absent from
+    // ENTITY_TO_TYPE, so build() still rejects them and they still fall through to null.
+    // Fix 3: stripTrailingScopeFiller (ask-vocab.mjs) trims a curated trailing clause
+    // ("what is a Module in this graph" -> "Module") off the object before it's
+    // returned, so a scoping tail never corrupts the lookup term either the bare-form
+    // check above or downstream resolution/rendering perform.
     {
       name: "meta-whatis",
-      re: new RegExp(`^what\\s+(?:is|are)\\s+(?:an?)\\s+(.+?)\\??$`, "i"),
-      build: (m) => ({ shape: "meta", entityType: null, modifier: "direct", kind: "meta", object: m[1].trim() })
+      re: new RegExp(`^what\\s+(?:is|are)\\s+(?:(an?)\\s+)?(.+?)\\??$`, "i"),
+      build: (m) => {
+        const object = m[2].trim();
+        if (!m[1] && !ENTITY_TO_TYPE[object.toLowerCase()]) return null;
+        return { shape: "meta", entityType: null, modifier: "direct", kind: "meta", object: stripTrailingScopeFiller(object) };
+      }
     },
     // T6 mention: "where is <term> mentioned/referenced" — the prose/mentions surface
     // (2026-07-02 query families). Tried BEFORE T7: T7's trailing marker is optional,
@@ -1592,7 +1749,13 @@
         return { shape: agentNamed ? "forward" : "reverse", entityType, modifier, kind, object };
       }
     }
-    if (beforeText && afterText) return { shape: "ask", entityType: null, modifier: "direct", kind, subject: beforeText, object: afterText };
+    if (beforeText && afterText) {
+      const verbPhrase = canonWords.slice(verbHit.start, verbHit.end).join(" ");
+      let subject = beforeText;
+      let object = afterText;
+      if (INHERITS_REVERSE_VERBS.includes(verbPhrase)) [subject, object] = [object, subject];
+      return { shape: "ask", entityType: null, modifier: "direct", kind, subject, object };
+    }
     if (afterText) return { shape: "reverse", entityType, modifier, kind, object: afterText };
     if (beforeText) return { shape: "forward", entityType, modifier: "direct", kind, object: beforeText };
     return null;
@@ -2326,6 +2489,10 @@
   var NEST_SENTINEL = "zzinnerset";
   var PRED_LEAD_SKIP = /* @__PURE__ */ new Set(["that", "which", "who", "are", "is", "was", "were", "do", "does", "also", "still", "both", "and", "then", "though"]);
   var FRAME_WORDS = /* @__PURE__ */ new Set(["which", "what", "who", "list", "show", "find", "give", "me", "us", "all"]);
+  var COPULA_WORDS = /* @__PURE__ */ new Set(["are", "is", "was", "were"]);
+  function dropLeadCopula(bw, blc) {
+    return blc.length && COPULA_WORDS.has(blc[0]) ? { bw: bw.slice(1), blc: blc.slice(1) } : { bw, blc };
+  }
   var entityNoun = (w) => ENTITY_TO_TYPE[w] ? { entityType: ENTITY_TO_TYPE[w], placeholder: false } : PLACEHOLDER_NOUNS.includes(w) ? { entityType: null, placeholder: true } : null;
   var isGerundVerb = (w) => !!VERB_TO_KIND[w] && w.endsWith("ing");
   function parseSimpleClause(text, nlp) {
@@ -2334,7 +2501,7 @@
   function parseComposite(text, nlp) {
     const w = splitWords(text);
     const lc = w.map((x) => x.toLowerCase());
-    return parseExistence(w, lc) || 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) || parseFind(w, lc, nlp, 0) || parseList(w, lc, nlp, 0) || parseNested(w, lc, nlp, 0) || parseRelationalOrQualified(w, lc, nlp, 0);
+    return parseExistence(w, lc) || parseQualifierCheck(w, lc) || 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) || parseFind(w, lc, nlp, 0) || parseList(w, lc, nlp, 0) || parseNested(w, lc, nlp, 0) || parseRelationalOrQualified(w, lc, nlp, 0);
   }
   function complementAst(entityType, diffAtom) {
     return {
@@ -2563,6 +2730,27 @@
     }
     return null;
   }
+  function parseQualifierCheck(w, lc) {
+    if (lc[0] !== "is" && lc[0] !== "are") return null;
+    if (lc[1] === "there") return null;
+    let qualIdx = -1;
+    let negated = false;
+    for (let i = 1; i < lc.length; i += 1) {
+      if (QUALIFIERS[lc[i]]) {
+        qualIdx = i;
+        negated = lc[i - 1] === "not";
+        break;
+      }
+    }
+    if (qualIdx < 0) return null;
+    let termStart = 1;
+    if (lc[termStart] === "the") termStart += 1;
+    let termEnd = negated ? qualIdx - 1 : qualIdx;
+    if (termEnd > termStart && (lc[termEnd - 1] === "a" || lc[termEnd - 1] === "an")) termEnd -= 1;
+    const term = termEnd > termStart ? w.slice(termStart, termEnd).join(" ").trim() : "";
+    if (!term) return { node: "miss", reason: `"is/are <qualifier>" needs a named thing to check first` };
+    return { node: "qualCheck", term, qualifier: lc[qualIdx], negated };
+  }
   var AGG_TAIL_FILLER = /* @__PURE__ */ new Set([
     "total",
     "altogether",
@@ -2708,6 +2896,15 @@
         break;
       }
     }
+    if (!metric) {
+      for (let i = extIdx - 1; i >= 0; i -= 1) {
+        if (EDGE_NOUN_TO_METRIC[lc[i]]) {
+          metric = EDGE_NOUN_TO_METRIC[lc[i]];
+          metricNoun = lc[i];
+          break;
+        }
+      }
+    }
     const connectivity = lc.includes("connected") || lc.slice(extIdx, extIdx + 2).join(" ") === "most connected" || ["largest", "biggest", "smallest"].includes(lc[extIdx]);
     if (!metric) {
       if (connectivity) {
@@ -2765,8 +2962,9 @@
       const bw = branches[b];
       const blc = bw.map((x) => x.toLowerCase());
       const op = b === 0 ? "intersection" : ops[b - 1];
-      if (bw.length && blc.every((x) => QUALIFIERS[x])) {
-        atoms.push({ op, kind: "qual", filters: blc });
+      const qc = dropLeadCopula(bw, blc);
+      if (qc.blc.length && qc.blc.every((x) => QUALIFIERS[x])) {
+        atoms.push({ op, kind: "qual", filters: qc.blc });
         continue;
       }
       if (blc[0] === "of" || blc[0] === "in") {
@@ -2783,6 +2981,7 @@
     }
     return { atoms };
   }
+  var RECENT_COMMIT_LEAD = /* @__PURE__ */ new Set(["recent", "latest", "newest"]);
   function parseRelationalOrQualified(w, lc, nlp, depth) {
     const findHead = parseFindPredicateHead(w, lc);
     if (findHead) {
@@ -2806,6 +3005,9 @@
     const noun = i < lc.length ? entityNoun(lc[i]) : null;
     if (!noun) {
       const nextNoun = i + 1 < lc.length ? entityNoun(lc[i + 1]) : null;
+      if (RECENT_COMMIT_LEAD.has(lc[i]) && nextNoun && nextNoun.entityType === "Commit" && i + 2 === lc.length) {
+        return { node: "recentCommits" };
+      }
       if ((framed || quals.length) && nextNoun && /^[a-z]+$/.test(lc[i]) && !VERB_TO_KIND[lc[i]] && !STOPWORDS2.has(lc[i]) && !CASCADE_NOISE_SET.has(lc[i])) {
         return { node: "find", entityType: nextNoun.entityType, term: w[i] };
       }
@@ -2824,11 +3026,40 @@
     }
     const membershipLed = predLc[0] === "of" || predLc[0] === "in";
     const gerundLed = predLc.length > 0 && isGerundVerb(predLc[0]);
-    if (!(quals.length || relFlag || membershipLed || gerundLed)) return null;
+    const boolQualLed = predWords.length > 0 && splitBoolean(predLc, predWords).branches.some((bw) => {
+      const { blc } = dropLeadCopula(bw, bw.map((x) => x.toLowerCase()));
+      return blc.length && blc.every((x) => QUALIFIERS[x]);
+    });
+    const sameVerbBranches = predWords.length > 0 ? splitBoolean(predLc, predWords).branches : [];
+    let sameVerbLed = false;
+    if (sameVerbBranches.length > 1) {
+      const firstBlc = sameVerbBranches[0].map((x) => x.toLowerCase());
+      const firstVh = findPhrase(firstBlc, VERB_TO_KIND);
+      if (firstVh && firstVh.start === 0) {
+        sameVerbLed = sameVerbBranches.slice(1).every((bw) => {
+          const blc = bw.map((x) => x.toLowerCase());
+          const vh = findPhrase(blc, VERB_TO_KIND);
+          return vh && vh.start === 0 ? vh.kind === firstVh.kind : !vh;
+        });
+      }
+    }
+    let differentVerbLed = false;
+    if (sameVerbBranches.length > 1) {
+      const firstBlc = sameVerbBranches[0].map((x) => x.toLowerCase());
+      const firstVh = findPhrase(firstBlc, VERB_TO_KIND);
+      if (firstVh && firstVh.start === 0) {
+        differentVerbLed = sameVerbBranches.slice(1).every((bw) => {
+          const blc = bw.map((x) => x.toLowerCase());
+          const vh = findPhrase(blc, VERB_TO_KIND);
+          return !!vh && vh.start === 0 && vh.end - vh.start === 1;
+        });
+      }
+    }
+    if (!(quals.length || relFlag || membershipLed || gerundLed || boolQualLed || sameVerbLed || differentVerbLed)) return null;
     if (!predWords.length) {
       let base = { node: "allOfClass", entityType };
       if (!quals.length) return { node: "miss", reason: "nothing to filter or traverse" };
-      return { node: "qualifier", filters: quals, inner: base };
+      return { node: "qualifier", filters: quals, inner: base, entityType };
     }
     const subjPrefix = noun.placeholder ? "what" : `which ${entWord}`;
     const { branches, ops } = splitBoolean(predLc, predWords);
@@ -2838,8 +3069,9 @@
       const bw = branches[b];
       const blc = bw.map((x) => x.toLowerCase());
       const op = b === 0 ? "seed" : ops[b - 1];
-      if (bw.length && blc.every((x) => QUALIFIERS[x])) {
-        atoms.push({ op, kind: "qual", filters: blc });
+      const qc = dropLeadCopula(bw, blc);
+      if (qc.blc.length && qc.blc.every((x) => QUALIFIERS[x])) {
+        atoms.push({ op, kind: "qual", filters: qc.blc });
         continue;
       }
       if (blc[0] === "of" || blc[0] === "in") {
@@ -2861,7 +3093,7 @@
     } else {
       result = { node: "boolean", entityType, atoms };
     }
-    if (quals.length) result = { node: "qualifier", filters: quals, inner: result };
+    if (quals.length) result = { node: "qualifier", filters: quals, inner: result, entityType };
     return result;
   }
   function parseBranchAst(text, nlp, depth) {
@@ -2960,6 +3192,33 @@
     if (ind.class === "Module") return ind.id;
     return qualSets(graph).moduleOfSymbol.get(ind.id) || null;
   }
+  function membershipOwnSet(graph, id, entityType) {
+    const objs = uniqueById(MEMBERSHIP_KINDS.flatMap((k) => forwardOverSet(graph, k, /* @__PURE__ */ new Set([id]))));
+    return entityType ? objs.filter((o) => o.class === entityType) : objs;
+  }
+  function resolveMembershipOwner(graph, term) {
+    const r = resolveObject(graph, term);
+    if (!(r.match && r.tier === 1)) {
+      const dirMods = directoryScopeModules(graph, term);
+      if (dirMods.length) return { kind: "dir", mods: dirMods };
+    }
+    if (!r.match) return { kind: "miss" };
+    return { kind: "single", id: r.match.id, entityClass: r.match.class, label: r.match.label };
+  }
+  function computeMembership(graph, ownerId, ownerClass, entityType, filterFn) {
+    const pass = filterFn || (() => true);
+    const own = membershipOwnSet(graph, ownerId, entityType).filter(pass);
+    if (own.length || !inheritsApplicable(graph, ownerClass)) {
+      return { own, inherited: [], viaId: null, viaLabel: null };
+    }
+    for (const ancId of ancestorsOf(graph, ownerId)) {
+      const anc = graph.byId.get(ancId);
+      if (!anc) continue;
+      const ancOwn = membershipOwnSet(graph, ancId, entityType).filter(pass);
+      if (ancOwn.length) return { own, inherited: ancOwn, viaId: ancId, viaLabel: anc.label };
+    }
+    return { own, inherited: [], viaId: null, viaLabel: null };
+  }
   function qualHolds(graph, ind, spec) {
     if (!spec) return false;
     switch (spec.via) {
@@ -3128,22 +3387,19 @@
         return forwardOverSet(graph, ast.kind, ids);
       }
       case "membership": {
-        const r = resolveObject(graph, ast.term);
-        if (!(r.match && r.tier === 1)) {
-          const dirMods = directoryScopeModules(graph, ast.term);
-          if (dirMods.length) {
-            if (!ast.entityType || ast.entityType === "Module") return dirMods;
-            const ids2 = new Set(dirMods.map((m) => m.id));
-            const objs2 = uniqueById(MEMBERSHIP_KINDS.flatMap((k) => forwardOverSet(graph, k, ids2)));
-            return objs2.filter((o) => o.class === ast.entityType);
-          }
+        const owner = resolveMembershipOwner(graph, ast.term);
+        if (owner.kind === "dir") {
+          if (!ast.entityType || ast.entityType === "Module") return owner.mods;
+          const ids = new Set(owner.mods.map((m) => m.id));
+          const objs = uniqueById(MEMBERSHIP_KINDS.flatMap((k) => forwardOverSet(graph, k, ids)));
+          return objs.filter((o) => o.class === ast.entityType);
         }
-        if (!r.match) return [];
-        const ids = /* @__PURE__ */ new Set([r.match.id]);
-        const objs = uniqueById(MEMBERSHIP_KINDS.flatMap((k) => forwardOverSet(graph, k, ids)));
-        return ast.entityType ? objs.filter((o) => o.class === ast.entityType) : objs;
+        if (owner.kind === "miss") return [];
+        const { own, inherited } = computeMembership(graph, owner.id, owner.entityClass, ast.entityType);
+        return own.length ? own : inherited;
       }
       case "qualifier": {
+        if (ast.inner.node === "membership") return evalMembershipComposite(graph, ast, opts).matches;
         const base = evalSet(graph, ast.inner, opts);
         return base.filter((ind) => ast.filters.every((f) => qualHolds(graph, ind, QUALIFIERS[f])));
       }
@@ -3183,7 +3439,8 @@
   function evalAnaphora(graph, ast, opts) {
     const prev = opts && opts.prev;
     if (!Array.isArray(prev) || !prev.length) return { compositeMiss: true, reason: "no-prev", matches: [] };
-    let items = prev.map((id) => graph.byId.get(id)).filter(Boolean);
+    const baseItems = prev.map((id) => graph.byId.get(id)).filter(Boolean);
+    let items = baseItems;
     const f = ast.filter;
     if (f && f.type === "qual") {
       items = items.filter((ind) => f.filters.every((q) => qualHolds(graph, ind, QUALIFIERS[q])));
@@ -3197,7 +3454,8 @@
         items = items.filter((ind) => ok.has(ind.id));
       }
     }
-    const common = items.length && items.every((x) => x.class === items[0].class) ? items[0].class : null;
+    const sameClass = (list) => list.length && list.every((x) => x.class === list[0].class) ? list[0].class : null;
+    const common = items.length ? sameClass(items) : sameClass(baseItems);
     if (ast.mode === "count") return { compositeKind: "count", count: items.length, entityType: common, matches: [] };
     return { compositeKind: "set", matches: items, entityType: common };
   }
@@ -3219,6 +3477,12 @@
     }
     return n;
   }
+  function evalRecentCommits(graph) {
+    const commits = graph.individuals.filter((i) => i.class === "Commit");
+    const dateOf = (c) => String((c.attributes || []).find((a) => a.key === "date")?.value || "");
+    commits.sort((a, b) => dateOf(b).localeCompare(dateOf(a)));
+    return { compositeKind: "recentCommits", matches: commits };
+  }
   function evalTemporal(graph, ast, opts) {
     const inner = evalSet(graph, ast.inner, opts);
     const ids = new Set(inner.map((i) => i.id));
@@ -3236,6 +3500,34 @@
     const winners = scored.filter((s) => s.score === best).map((s) => s.ind);
     return { compositeKind: "superlative", entityType: ast.entityType, metricNoun: ast.metricNoun, extreme: ast.extreme, score: best, matches: winners };
   }
+  function evalMembershipComposite(graph, ast, opts) {
+    const qualNode = ast.node === "qualifier" && ast.inner.node === "membership" ? ast : null;
+    const memNode = qualNode ? qualNode.inner : ast;
+    const entityType = memNode.entityType;
+    const filterFn = qualNode ? (ind) => qualNode.filters.every((f) => qualHolds(graph, ind, QUALIFIERS[f])) : null;
+    const owner = resolveMembershipOwner(graph, memNode.term);
+    if (owner.kind === "dir") {
+      let objs;
+      if (!entityType || entityType === "Module") objs = owner.mods;
+      else {
+        const ids = new Set(owner.mods.map((m) => m.id));
+        objs = uniqueById(MEMBERSHIP_KINDS.flatMap((k) => forwardOverSet(graph, k, ids))).filter((o) => o.class === entityType);
+      }
+      if (filterFn) objs = objs.filter(filterFn);
+      return { compositeKind: "set", matches: objs, entityType };
+    }
+    if (owner.kind === "miss") return { compositeKind: "set", matches: [], entityType };
+    const { own, inherited, viaLabel } = computeMembership(graph, owner.id, owner.entityClass, entityType, filterFn);
+    const inheritedNotOwn = !own.length && inherited.length > 0;
+    return {
+      compositeKind: "membership",
+      entityType,
+      matches: inheritedNotOwn ? inherited : own,
+      inheritedNotOwn,
+      viaLabel,
+      ownerLabel: owner.label
+    };
+  }
   function evalExists(graph, ast) {
     const { entityType, term, scopeModule } = ast;
     let scopeMatch = null;
@@ -3260,14 +3552,28 @@
     const pool = scopeMatch ? refineToEntities(graph, /* @__PURE__ */ new Set([scopeMatch.id]), entityType) : graph.individuals.filter((i) => i.class === entityType);
     return { compositeKind: "exists", entityType, term: null, scopeModule, scopeMatch, matches: pool };
   }
+  function evalQualCheck(graph, ast, opts) {
+    const { term, qualifier, negated } = ast;
+    const r = resolveTermOrContext(graph, term, opts.contextId);
+    if (r.unresolvedPronoun) return { compositeKind: "qualCheck", qualCheckMiss: "pronoun", term, matches: [] };
+    if (!r.match) return { compositeKind: "qualCheck", qualCheckMiss: "unresolved", term, matches: [] };
+    const rawHolds = qualHolds(graph, r.match, QUALIFIERS[qualifier]);
+    const holds = negated ? !rawHolds : rawHolds;
+    return { compositeKind: "qualCheck", subject: r.match, qualifier, negated, holds, matches: [r.match] };
+  }
   function evalComposite(graph, ast, opts = {}) {
     if (ast.node === "miss") return { compositeMiss: true, reason: ast.reason || null, matches: [] };
     if (ast.node === "exists") return evalExists(graph, ast);
+    if (ast.node === "qualCheck") return evalQualCheck(graph, ast, opts);
     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 === "recentCommits") return evalRecentCommits(graph);
     if (ast.node === "anaphora") return evalAnaphora(graph, ast, opts);
+    if (ast.node === "membership" || ast.node === "qualifier" && ast.inner.node === "membership") {
+      return evalMembershipComposite(graph, ast, opts);
+    }
     if (ast.node === "find") {
       const { narrow, broad } = computeFind(graph, ast.entityType, ast.term);
       return {
@@ -3318,6 +3624,23 @@
       }
       return { content: `Yes \u2014 ${compositeList(result.matches)}${scopeSuffix}.`, miss: false, ambiguous: false, matches: result.matches };
     }
+    if (result.compositeKind === "qualCheck") {
+      if (result.qualCheckMiss === "pronoun") {
+        return { content: `"${result.term}" needs a selected node to refer to \u2014 click a node first, or name it directly.`, miss: true, ambiguous: false };
+      }
+      if (result.qualCheckMiss === "unresolved") {
+        return { content: `couldn't find "${result.term}" in the index to check.`, miss: true, ambiguous: false };
+      }
+      const label = result.subject.label;
+      const truePhrase = result.negated ? `not ${result.qualifier}` : result.qualifier;
+      const falsePhrase = result.negated ? result.qualifier : `not ${result.qualifier}`;
+      return {
+        content: `${result.holds ? "Yes" : "No"} \u2014 ${label} is ${result.holds ? truePhrase : falsePhrase}.`,
+        miss: false,
+        ambiguous: false,
+        matches: result.matches
+      };
+    }
     if (result.compositeKind === "count") {
       const noun = result.entityType ? nounFor(result.entityType, result.count) : result.count === 1 ? "result" : "results";
       return { content: `${result.count} ${noun}.`, miss: false, ambiguous: false, matches: [] };
@@ -3330,6 +3653,23 @@
       const hint = !result.scoped && scopeable && result.matches.length > OVERFLOW_CAP ? ` \u2014 narrow with "${nounFor(result.entityType, 2)} in <module>"` : "";
       return { content: `${compositeList(result.matches)}${hint}.`, miss: false, ambiguous: false, matches: result.matches };
     }
+    if (result.compositeKind === "membership") {
+      if (!result.matches.length) {
+        return { content: `nothing in the index matches that${result.entityType ? ` (${nounFor(result.entityType, 2)})` : ""}.`, miss: true, ambiguous: false, matches: [] };
+      }
+      if (result.inheritedNotOwn) {
+        const kindPlural = nounFor(result.entityType, 2);
+        const ownerPhrase = result.ownerLabel ? `${result.ownerLabel} has no own ${kindPlural}` : `no own ${kindPlural}`;
+        return {
+          content: `${ownerPhrase} \u2014 inherited from ${result.viaLabel}: ${compositeList(result.matches)}.`,
+          miss: false,
+          ambiguous: false,
+          matches: result.matches,
+          inheritedNotOwn: true
+        };
+      }
+      return { content: `${compositeList(result.matches)}.`, miss: false, ambiguous: false, matches: result.matches };
+    }
     if (result.compositeKind === "find") {
       const typeNoun = nounFor(result.entityType, 1);
       if (!result.matches.length) {
@@ -3347,6 +3687,22 @@
       }
       return { content: `${cited}.`, miss: false, ambiguous: false, matches: result.matches };
     }
+    if (result.compositeKind === "recentCommits") {
+      if (!result.matches.length) return { content: `no commits recorded in this index.`, miss: true, ambiguous: false, matches: [] };
+      const dateOf = (c) => String((c.attributes || []).find((a) => a.key === "date")?.value || "");
+      const shown = result.matches.slice(0, HISTORY_CAP).map((c) => {
+        const day = dateOf(c).slice(0, 10);
+        const msg = (c.attributes || []).find((a) => a.key === "message")?.value || "";
+        return `${c.label}${day ? ` (${day})` : ""}${msg ? ` \u2014 ${msg}` : ""}`;
+      });
+      const tail = result.matches.length > HISTORY_CAP ? ` \u2026+${result.matches.length - HISTORY_CAP} more` : "";
+      return {
+        content: `${result.matches.length} recent commit(s): ${shown.join(", ")}${tail}.`,
+        miss: false,
+        ambiguous: false,
+        matches: result.matches
+      };
+    }
     if (result.compositeKind === "superlative") {
       if (!result.matches.length) return { content: `no ${nounFor(result.entityType, 2)} to rank in this index.`, miss: true, ambiguous: false };
       const lead = result.extreme === "most" ? "the most" : "the fewest";
@@ -3394,7 +3750,19 @@
   function componentSet(s) {
     return new Set(String(s).toLowerCase().split(/[^a-z0-9]+/).filter(Boolean));
   }
-  function resolveObject(graph, term, { expectedClass = null } = {}) {
+  function derivationalStem(w) {
+    if (w.length < 5) return w;
+    const stripped = w.replace(/(ing|ers|ors|er|or)$/, "");
+    if (stripped === w) return w;
+    return stripped.length >= 3 && stripped[stripped.length - 1] === stripped[stripped.length - 2] ? stripped.slice(0, -1) : stripped;
+  }
+  function joinedForm(label) {
+    return String(label || "").replace(/\.[a-z0-9]+$/i, "").toLowerCase().replace(/[/\-_.]+/g, "");
+  }
+  function joinedQueryForm(term) {
+    return String(term || "").trim().replace(/^(?:the|a|an)\s+/i, "").toLowerCase().replace(/[\s\-_]+/g, "");
+  }
+  function resolveObjectCore(graph, term, { expectedClass = null } = {}) {
     const t = String(term || "").trim();
     if (!t) return { match: null, candidates: [], tier: null, ambiguous: false };
     const tLc = t.toLowerCase();
@@ -3435,15 +3803,54 @@
         }
       }
     } else {
-      const termComps = componentSet(t);
+      const termComps = [...componentSet(t)];
+      const pathToken = tLc.split(/\s+/).find((tok) => tok.includes("/"));
+      const slashStem = pathToken ? pathToken.split("/").pop().replace(/\.[a-z0-9]+$/, "") : null;
+      const qWords = t.trim().replace(/^(?:the|a|an)\s+/i, "").trim().split(/\s+/).filter(Boolean);
+      const isMultiWord = qWords.length >= 2;
+      const qJoined = isMultiWord ? joinedQueryForm(t) : null;
       for (const m of pool) {
         const label = String(m.label || "").toLowerCase();
-        if (label.includes(tLc)) {
+        const stem = label.split("/").pop().replace(/\.[a-z0-9]+$/, "");
+        if (stem === tLc) {
+          scored.push({ ind: m, score: 5e3 });
+          continue;
+        }
+        if (tLc.length >= 4 && (stem.startsWith(tLc) || stem.endsWith(tLc))) {
+          scored.push({ ind: m, score: 4e3 - Math.abs(stem.length - tLc.length) });
+          continue;
+        }
+        if (isMultiWord) {
+          const candJoined = joinedForm(m.label);
+          if (candJoined && candJoined === qJoined) {
+            scored.push({ ind: m, score: 5e3 });
+            continue;
+          }
+          const hasExplicitSeparator = /[/_-]/.test(m.label) || /\.[a-z0-9]+$/i.test(String(m.label || ""));
+          if (candJoined && hasExplicitSeparator && qJoined.length >= 4 && candJoined.includes(qJoined)) {
+            scored.push({ ind: m, score: 2e3 - Math.abs(candJoined.length - qJoined.length) });
+            continue;
+          }
+        }
+        if (m.class === "Module") {
+          const termRoot = derivationalStem(tLc);
+          if (termRoot !== tLc && termRoot === derivationalStem(stem)) {
+            const bound = fuzzyBound(tLc);
+            if (editDistance(stem, tLc, bound) > bound) {
+              scored.push({ ind: m, score: 3e3 - Math.abs(stem.length - tLc.length) });
+              continue;
+            }
+          }
+        }
+        if (tLc.length >= 4 && label.includes(tLc)) {
           scored.push({ ind: m, score: 1e3 - Math.abs(label.length - tLc.length) });
           continue;
         }
-        const overlap = [...termComps].filter((c) => componentSet(m.label).has(c)).length;
-        if (overlap > 0) scored.push({ ind: m, score: overlap * 10 });
+        const labelComps = componentSet(m.label);
+        const overlap = termComps.filter((c) => labelComps.has(c)).length;
+        if (overlap > 0 && (!slashStem || labelComps.has(slashStem))) {
+          scored.push({ ind: m, score: overlap / termComps.length * 10 });
+        }
       }
     }
     scored.sort((a, b) => b.score - a.score);
@@ -3457,8 +3864,9 @@
         ambiguous: tied.length > 0
       };
     }
+    const pathShaped = dotted || tLc.includes("/");
     let proseResult = null;
-    const proseHits = !dotted && typeof lookupByProseTokens === "function" ? lookupByProseTokens(graph.proseIndex, t).filter((h) => !expectedClass || graph.byId.get(h.id)?.class === expectedClass) : [];
+    const proseHits = !pathShaped && typeof lookupByProseTokens === "function" ? lookupByProseTokens(graph.proseIndex, t).filter((h) => !expectedClass || graph.byId.get(h.id)?.class === expectedClass) : [];
     if (proseHits.length) {
       const [best, ...rest] = proseHits;
       const bestInd = graph.byId.get(best.id);
@@ -3501,6 +3909,29 @@
     }
     return proseResult || { match: null, candidates: [], tier: null, ambiguous: false };
   }
+  var LEADING_ARTICLE_RE = /^(?:the|a|an)\s+/i;
+  var TRAILING_GRAIN_WORD_RE = new RegExp(`\\s+(${Object.keys(ENTITY_TO_TYPE).join("|")})$`, "i");
+  function resolveObject(graph, term, opts = {}) {
+    const { expectedClass = null } = opts;
+    if (!expectedClass) {
+      const raw = String(term || "").trim();
+      const stripped = raw.replace(LEADING_ARTICLE_RE, "").trim();
+      const grainMatch = stripped.match(TRAILING_GRAIN_WORD_RE);
+      if (grainMatch) {
+        const head = stripped.slice(0, grainMatch.index).trim();
+        const grainClass = ENTITY_TO_TYPE[grainMatch[1].toLowerCase()];
+        if (head && grainClass) {
+          const rGrain = resolveObjectCore(graph, head, { expectedClass: grainClass });
+          if (rGrain?.match?.id && !rGrain.ambiguous) return rGrain;
+        }
+      }
+      if (stripped && stripped !== raw) {
+        const rStripped = resolveObjectCore(graph, stripped, opts);
+        if (rStripped?.match?.id && !rStripped.ambiguous) return rStripped;
+      }
+    }
+    return resolveObjectCore(graph, term, opts);
+  }
   function resolveTermOrContext(graph, term, contextId) {
     if (CONTEXT_PRONOUNS.includes(String(term || "").trim().toLowerCase())) {
       if (!contextId) return { match: null, candidates: [], tier: null, ambiguous: false, unresolvedPronoun: true };
@@ -4149,10 +4580,14 @@
       const r = resolveObject(graph, t);
       return !!r.match && r.tier != null && r.tier <= 3;
     };
-    const hasRealTerm = (s) => splitWords(String(s || "")).some((w) => {
-      const lc = w.toLowerCase();
-      return !CONTENT_VOCAB.has(lc) && !STRUCTURAL_WORDS.has(lc);
-    });
+    const hasRealTerm = (s) => {
+      const whole = String(s || "").trim().toLowerCase();
+      if (CONTEXT_PRONOUNS.includes(whole)) return true;
+      return splitWords(whole).some((w) => {
+        const lc = w.toLowerCase();
+        return !CONTENT_VOCAB.has(lc) && !STRUCTURAL_WORDS.has(lc);
+      });
+    };
     const TERM_SHAPES = /* @__PURE__ */ new Set(["reverse", "forward", "where", "when", "ask"]);
     const attempt = (toks) => {
       const text = toks.join(" ");
@@ -4243,6 +4678,20 @@
     }
     return null;
   }
+  var LAST_COMMIT_PHRASE_RE = /\b(?:the\s+)?(?:last|latest|most\s+recent)\s+commit\b/i;
+  var BARE_WHEN_COMMIT_RE = /^when\s+(?:was|were|is|did|does|do)\s+commit\s+[0-9a-fA-F:]+$/i;
+  function substituteLastCommitPhrase(graph, query) {
+    const q = String(query || "");
+    if (!graph || !LAST_COMMIT_PHRASE_RE.test(q)) return q;
+    const commits = graph.individuals.filter((i) => i.class === "Commit");
+    if (!commits.length) return q;
+    const dateOf = (c) => String((c.attributes || []).find((a) => a.key === "date")?.value || "");
+    const newest = [...commits].sort((a, b) => dateOf(b).localeCompare(dateOf(a)))[0];
+    if (!newest) return q;
+    const out = q.replace(LAST_COMMIT_PHRASE_RE, `commit ${newest.label}`);
+    const bareTrimmed = out.trim().replace(/[?.!]+$/, "");
+    return BARE_WHEN_COMMIT_RE.test(bareTrimmed) ? `${bareTrimmed} touched` : out;
+  }
   function ask(graph, query, { contextId = null, nlp = void 0, prev = null } = {}) {
     if (isHelpRequest(query)) {
       return {
@@ -4260,6 +4709,7 @@
         }
       };
     }
+    query = substituteLastCommitPhrase(graph, query);
     const direct = parseQuery(query, { nlp });
     let parsed = direct;
     let relaxed = null;

package/src/ask-browser.bundle.version

@@ -1 +1 @@
-1.0.4
+1.3.0

package/src/concept-digest.mjs

@@ -0,0 +1,157 @@
+// concept-digest.mjs — PROTOTYPE, not wired into any product surface (PLAN_CONCEPT_DIGEST.md).
+//
+// Extracts concept words from a task prompt (reusing prose.mjs's two tokenizer primitives, §3.1),
+// then sweeps them type-scoped across the graph for literal file:line hits (§3.2). The
+// ask()-driven ontology sweep (§3.3) and the combined two-section digest (§3.5) are NOT
+// implemented this round — see the TODOs below and PLAN_CONCEPT_DIGEST.md §6/§7.
+//
+// §3.2(b): `identComponents` below is a standalone duplicate of codegraph.mjs's private (non-
+// exported) helper of the same name — pure string manipulation, no graph-shape dependency, so
+// duplicating it carries no correctness risk. `definesIndex`'s edge lookup, by contrast, uses
+// codegraph.mjs's own EXPORTED `edgesOfKind`/`relationKind` machinery directly rather than
+// re-deriving relation classification locally — that classification (PROP_KIND, the mgx/seon
+// alias table) is exactly the kind of thing that must never drift between two copies. Only
+// `matchSymbols`-shaped per-kind scoring (§3.2(a)) is still standalone-duplicated pending the
+// codegraph.mjs refactor PLAN_CONCEPT_DIGEST.md §3.2(a)/§7 phase 2 proposes.
+
+import { splitIdentifierWords, tokenizeProse } from "./prose.mjs";
+import { siteOf, edgesOfKind } from "./codegraph.mjs";
+
+const SYMBOL_CLASSES = { function: "Function", class: "Class", method: "Method", attribute: "Attribute", route: "Route" };
+export const LITERAL_SWEEP_KINDS = ["module", "function", "class", "method", "attribute", "route"];
+
+/** §3.1: the task prompt's concept words. NOT a bare `proseTokensFor({name, doc: promptText})`
+ *  call — proseTokensFor is built for a single SYMBOL name + its doc, and its `name` half
+ *  (splitIdentifierWords) deliberately carries NO stopword filter, because a real identifier
+ *  never contains an English stopword in the first place. A whole task PROMPT is different: it
+ *  mixes ordinary stopword-laden prose with embedded identifiers ("fix Truncator.chars"), so
+ *  feeding the same full prompt text through both proseTokensFor halves re-admits "the"/"and"/
+ *  "its" via the identifier-decomposition path even though tokenizeProse already dropped them
+ *  from the prose path (caught by this file's own test suite, §6 — see the "reuses prose.mjs's
+ *  stopword filter" test). The correct composition: decompose identifiers FIRST
+ *  (splitIdentifierWords, camelCase/snake/dotted boundaries), then run the DECOMPOSED text back
+ *  through tokenizeProse so the stopword filter applies to both origins uniformly, unioned with
+ *  tokenizeProse over the raw prompt (covers plain prose words untouched by decomposition). */
+export function extractConceptWords(promptText) {
+  const prose = tokenizeProse(promptText);
+  const decomposed = tokenizeProse(splitIdentifierWords(promptText).join(" "));
+  return [...new Set([...prose, ...decomposed])].sort();
+}
+
+/** Mirrors codegraph.mjs's private `identComponents` (camelCase/snake_case boundary split) —
+ *  duplicated per the file-header note above, not imported (it is not exported there). */
+function identComponents(name) {
+  return new Set(String(name).replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase().split(/[^a-z0-9]+/).filter(Boolean));
+}
+
+/** subject id -> [defined symbol labels], built off codegraph.mjs's own EXPORTED `edgesOfKind`
+ *  (which in turn uses the real `relationKind` classifier — the mgx/seon PROP_KIND alias table
+ *  lives there ONCE; this file must never re-derive it, see the file-header note above). */
+function definesIndex(graph) {
+  const idx = new Map();
+  for (const e of edgesOfKind(graph, "defines")) {
+    if (!idx.has(e.subject)) idx.set(e.subject, []);
+    idx.get(e.subject).push(e.objectLabel || e.object);
+  }
+  return idx;
+}
+
+function siteFileLine(graph, id) {
+  const ind = graph.byId?.get?.(id);
+  const site = ind ? siteOf(ind) : null;
+  return site ? { file: site.path, line: site.start } : { file: null, line: null };
+}
+
+/** One module's combined literal-match text bag: lowercased path components + every defined
+ *  symbol's name components + (when present) its `prose_tokens` attribute — the same "per-module
+ *  combined text" idiom moduleEmbedTexts/definesIndex already use in codegraph.mjs (§3.2). */
+function moduleTextBag(ind, defines) {
+  const bag = new Set();
+  for (const c of String(ind.label).toLowerCase().split(/[^a-z0-9]+/).filter(Boolean)) bag.add(c);
+  for (const d of defines) for (const c of identComponents(d)) bag.add(c);
+  const prose = (ind.attributes || []).find((a) => a.key === "prose_tokens")?.value;
+  if (prose) for (const t of String(prose).split(/\s+/).filter(Boolean)) bag.add(t);
+  return bag;
+}
+
+/** §3.2 module-kind sweep: strict AND over each module's text bag (every concept word must be
+ *  present somewhere in the module), falling back to a coverage-ranked list when the AND-set is
+ *  empty — the same "try strict first, relax only on a genuine miss" shape as tmct's ask()
+ *  relaxation cascade (PLAN_CONCEPT_DIGEST.md §3.2). Never throws, never silently returns
+ *  nothing when SOME module matched at least one word. */
+function sweepModules(graph, conceptWords) {
+  const defIdx = definesIndex(graph);
+  const andHits = [];
+  const coverageHits = [];
+  for (const ind of graph.individuals) {
+    if ((ind.class || "") !== "Module") continue;
+    const defines = defIdx.get(ind.id) || [];
+    const bag = moduleTextBag(ind, defines);
+    const matched = conceptWords.filter((w) => bag.has(w));
+    if (!matched.length) continue;
+    const { file, line } = siteFileLine(graph, ind.id);
+    const hit = {
+      id: ind.id, label: ind.label, kind: "module", file: file || ind.label, line,
+      literalScore: matched.length, literalMatchedWords: matched, ontologyHits: [],
+    };
+    coverageHits.push(hit);
+    if (matched.length === conceptWords.length) andHits.push(hit);
+  }
+  const rank = (a, b) => b.literalScore - a.literalScore || String(a.label).length - String(b.label).length;
+  if (andHits.length) return andHits.sort(rank);
+  return coverageHits.sort(rank);
+}
+
+/** §3.2 symbol-kind sweep (function/class/method/attribute/route): coverage-ranked, NOT AND —
+ *  see PLAN_CONCEPT_DIGEST.md §3.2 for why AND is reserved for the module grain only. Mirrors
+ *  searchSymbols's own coverage-not-AND scoring shape (codegraph.mjs:1622-1656), applied per
+ *  concept word instead of per raw query token. */
+function sweepSymbols(graph, conceptWords, kind) {
+  const targetClass = SYMBOL_CLASSES[kind];
+  if (!targetClass) return [];
+  const hits = [];
+  for (const ind of graph.individuals) {
+    if ((ind.class || "") !== targetClass) continue;
+    const labelLc = String(ind.label).toLowerCase();
+    const comps = identComponents(ind.label);
+    const matched = conceptWords.filter((w) => comps.has(w) || labelLc.includes(w));
+    if (!matched.length) continue;
+    const { file, line } = siteFileLine(graph, ind.id);
+    hits.push({
+      id: ind.id, label: ind.label, kind, file, line,
+      literalScore: matched.length, literalMatchedWords: matched, ontologyHits: [],
+    });
+  }
+  return hits.sort((a, b) => b.literalScore - a.literalScore || String(a.label).length - String(b.label).length);
+}
+
+/** §3.2: the full type-specific literal sweep — module-kind AND (coverage fallback) UNION
+ *  symbol-kind coverage sweeps, one per requested kind. Returns a flat, per-kind-ranked hit list
+ *  (NOT deduped/combined with an ontology sweep — that composition is buildConceptDigest's job,
+ *  §3.5, not yet implemented — see the TODO at the bottom of this file). */
+export function literalSweep(graph, conceptWords, { kinds = LITERAL_SWEEP_KINDS } = {}) {
+  const words = [...new Set(conceptWords)];
+  if (!words.length) return [];
+  const out = [];
+  if (kinds.includes("module")) out.push(...sweepModules(graph, words));
+  for (const kind of kinds) {
+    if (kind === "module" || !SYMBOL_CLASSES[kind]) continue;
+    out.push(...sweepSymbols(graph, words, kind));
+  }
+  return out;
+}
+
+// TODO(concept-digest, ontology sweep — PLAN_CONCEPT_DIGEST.md §3.3/§7 phase 1): sentence-split
+// the prompt + templated subclass/superclass/find probes over extractConceptWords' output, run
+// through makeSeonixProvider(graph).ask(fragment) in-process (never a subprocess — §3.4), map
+// tmct_ask.matches[].id -> siteOf for file:line. Not implemented this round.
+export function ontologySweep(_graph, _promptText, _opts = {}) {
+  throw new Error("concept-digest: ontologySweep is not implemented yet — see PLAN_CONCEPT_DIGEST.md §3.3/§7");
+}
+
+// TODO(concept-digest, combine — PLAN_CONCEPT_DIGEST.md §3.5/§7 phase 1): dedupe literalSweep +
+// ontologySweep by individual id into the two-section {literal, ontology} digest + rendered text.
+// Depends on ontologySweep above; not implemented this round.
+export function buildConceptDigest(_graph, _promptText, _opts = {}) {
+  throw new Error("concept-digest: buildConceptDigest is not implemented yet — see PLAN_CONCEPT_DIGEST.md §3.5/§7");
+}

package/src/extract.mjs

@@ -438,21 +438,35 @@ export function buildEntities(modules, commits, { generatedAt = "", symbolHistor
       }
 
       // symbol-granular calls: caller fn/method → callee fn/class/method. The top-level
-      // function/class registry resolves first, unchanged (exactly ONE in-repo definition —
-      // same unique-name discipline as the module-coarse calls). On a complete miss there,
-      // receiver-typed call texts fall through to the tiered METHOD registry above, so
-      // `_svc.ProcessOrder(...)` reaches `B.ProcessOrder` even though no top-level symbol
-      // carries that name (C#/Java estates have none). Ambiguous / external names are
-      // dropped (honest Group-A). Reuses the per-function call names the extractors parsed.
+      // function/class registry resolves first (exactly ONE in-repo definition — same
+      // unique-name discipline as the module-coarse calls) UNLESS the name is globally
+      // ambiguous but the CALLING module's own imports narrow it to one candidate (a
+      // same-named top-level helper the caller never imported must not block resolution
+      // of the one it did — e.g. two files each define `parseEntities`, only one is
+      // imported by a given caller; mirrors the same-module/imported-tiering already used
+      // for base-class resolution above, minus a same-module tier: two SIBLING top-level
+      // defines of one name, in the SAME module as the caller, stay ambiguous — see
+      // "ambiguous call names are dropped" in test/extract.test.mjs). On a complete
+      // registry miss, receiver-typed call texts fall through to the tiered METHOD
+      // registry above, so `_svc.ProcessOrder(...)` reaches `B.ProcessOrder` even though no
+      // top-level symbol carries that name (C#/Java estates have none). Still-ambiguous /
+      // external names are dropped (honest Group-A). Reuses the per-function call names
+      // the extractors parsed.
       if ((d.kind === "function" || d.kind === "method") && d.calls?.length) {
         for (const callName of d.calls) {
           const ident = lastIdent(callName);
           if (!ident) continue;
           const ids = nameToSymbolIds.get(ident);
           let callee = null;
-          if (ids?.size === 1) callee = [...ids][0];
-          else if (!ids) callee = resolveMethodCallee(callName, ident, m.path); // method fallback on a clean miss only
-          if (!callee) continue; // ambiguous or external → drop
+          if (ids?.size === 1) {
+            callee = [...ids][0];
+          } else if (ids?.size > 1) {
+            const reachable = [...ids].filter((id) => imports.has(id.slice(3, id.lastIndexOf("#"))));
+            if (reachable.length === 1) callee = reachable[0];
+          } else {
+            callee = resolveMethodCallee(callName, ident, m.path); // method fallback on a clean miss only
+          }
+          if (!callee) continue; // still ambiguous or external → drop
           if (callee === oid) continue; // self-recursion not an edge
           const ckey = `${oid}>${callee}`;
           if (seenCallSymbol.has(ckey)) continue;