@polycode-projects/the-mechanical-code-talker 1.0.8 → 1.2.0

package/src/ask.mjs

@@ -38,7 +38,7 @@
 // edges (mgx:touchedByCommit / mgx:changeCoupledWith), which is a different (and
 // simpler) question than the browser's time-scrubbing view.
 
-import { relationKind, impactClosure, normPath } from "./codegraph.mjs";
+import { relationKind, impactClosure, normPath, HISTORY_CAP } from "./codegraph.mjs";
 import {
   VERB_TO_KIND, ENTITY_TO_TYPE, MODIFIER_TO_KIND,
   CONTEXT_PRONOUNS, META_MEANING_VERBS,
@@ -1005,6 +1005,10 @@ function buildPredicateAtoms(entityType, subjPrefix, predLc, predWords, nlp, dep
   return { atoms };
 }
 
+// Seonix Batch 3 (3b): the closed set of temporal-lead words a bare "<lead> commits"
+// query can use — see the dedicated recentCommits AST node this feeds, below.
+const RECENT_COMMIT_LEAD = new Set(["recent", "latest", "newest"]);
+
 function parseRelationalOrQualified(w, lc, nlp, depth) {
   // §6 generalization (predicate-find): seeds the SAME boolean/qualifier fold
   // below with a {node:"find",…} atom instead of the plain {node:"allOfClass"}
@@ -1038,6 +1042,17 @@ function parseRelationalOrQualified(w, lc, nlp, depth) {
     // auxiliary in that position ("what DID commit X touch") is left for the existing
     // parser, not mistaken for a term.
     const nextNoun = i + 1 < lc.length ? entityNoun(lc[i + 1]) : null;
+    // Seonix Batch 3 (3b) — a bare temporal-qualifier lead on a Commit noun with no
+    // further term ("recent commits", "latest commits", "newest commits") used to
+    // fall into the generic find-fallback just below with the qualifier WORD ITSELF
+    // as the search term ("no Commit found matching 'recent'") — a false miss, since
+    // "recent"/"latest"/"newest" were never meant as a name to search for, just a
+    // sort direction the graph already has (mgx:commitDate). Checked BEFORE the
+    // generic fallback, and only when nothing follows the noun (a real filter tail,
+    // e.g. "recent commits touching a.py", is left to the ordinary parser).
+    if (RECENT_COMMIT_LEAD.has(lc[i]) && nextNoun && nextNoun.entityType === "Commit" && i + 2 === lc.length) {
+      return { node: "recentCommits" };
+    }
     // CASCADE_NOISE_SET excluded alongside STOPWORDS (Tier-2 playtest, cycle 8):
     // "what about classes"/"how about the modules" used to reach here with
     // "about" sitting right where a real qualifying adjective would ("payment"
@@ -1102,9 +1117,46 @@ function parseRelationalOrQualified(w, lc, nlp, depth) {
       });
     }
   }
+  // Batch 4/5 (HANDOVER item 4, compositional-AND): a later AND-branch with its OWN
+  // DIFFERENT, but still RECOGNIZED, verb ("which functions call X and test Y" —
+  // "test" maps to "tests", a different kind from the lead "call"/"calls") is ALSO
+  // the compositional shape — additive to sameVerbLed above, not a replacement:
+  // sameVerbLed already covers a same-kind repeat or a bare ellipsis-borrowed
+  // object; this covers the one case it deliberately left closed (a branch with
+  // its own explicit, different verb). The atom-building loop below needs no
+  // change: it already builds one independent {kind:"set", ast} per verb-led
+  // branch regardless of kind, and evalBoolean intersects them the same way a
+  // qualifier atom is intersected (610915a) — this only widens the GATE that lets
+  // that existing machinery fire for a mixed-kind "and" chain too.
+  // NARROWED to a single-WORD later verb (`vh.end - vh.start === 1`) — same
+  // "narrow, low-risk signal" discipline 610915a itself used (it deliberately did
+  // NOT widen to "any boolean connective"): a bare single content word ("call",
+  // "test", "tests") reads unambiguously as its own relation no matter what
+  // follows it, whereas a multi-word verb PHRASE ("couples to", "is a subclass
+  // of", "depends on") is exactly the shape the pre-existing compat guard pins
+  // OFF (ask-compositional.test.mjs:67 and :144, both asserting
+  // `ambiguousParse:true` for "which classes extends Base and couples to
+  // logging" STRICTLY) — "couples to" IS recognized (VERB_TO_KIND maps it to
+  // "imports"; the two-different-recognized-verbs shape is structurally
+  // identical to the target case), so accepting ANY recognized different verb
+  // here regressed both pinned tests when tried; the single-word restriction is
+  // the narrowest rule that admits the required target case ("test") while
+  // leaving the multi-word compat case exactly as closed as it always was.
+  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;
+      });
+    }
+  }
   // marker gate — the crux of backward-compat: without one of these, this is not a
   // compositional query and we must NOT hijack it from the existing parser.
-  if (!(quals.length || relFlag || membershipLed || gerundLed || boolQualLed || sameVerbLed)) return null;
+  if (!(quals.length || relFlag || membershipLed || gerundLed || boolQualLed || sameVerbLed || differentVerbLed)) return null;
 
   // empty predicate → a bare qualified class ("public methods")
   if (!predWords.length) {
@@ -1291,6 +1343,67 @@ function moduleIdOf(graph, ind) {
   return qualSets(graph).moduleOfSymbol.get(ind.id) || null;
 }
 
+// ---- MEMBERSHIP inheritance cascade (HANDOVER item 6) — "<kind> of <owner>" walks
+// UP `inherits` when the owner's own surface has nothing, exactly the way
+// computeFind's narrow-then-broaden pass does for predicate-find, below. ----
+
+/** OWN-ONLY membership hits for exactly ONE owner id — every MEMBERSHIP_KINDS
+ *  forward-hit from `id` alone (never an ancestor), filtered to `entityType` when
+ *  given. This IS the un-broadened lookup the "membership" case always ran before
+ *  item 6 — extracted so both the plain evalSet case and the inheritance-aware
+ *  cascade below (computeMembership) share the exact same one-node lookup. */
+function membershipOwnSet(graph, id, entityType) {
+  const objs = uniqueById(MEMBERSHIP_KINDS.flatMap((k) => forwardOverSet(graph, k, new Set([id]))));
+  return entityType ? objs.filter((o) => o.class === entityType) : objs;
+}
+
+/** Resolve a "<kind> of/in <term>" owner term to either a DIRECTORY scope (a bare
+ *  path prefix with no exact node of its own — see directoryScopeModules's own
+ *  doc) or a single container individual, exactly like the "membership" case's own
+ *  pre-item-6 resolution — extracted unchanged so evalSet's plain path and the
+ *  composite/disclosure path (evalMembershipComposite) can never drift. */
+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 };
+}
+
+/** The narrow-then-walk inheritance cascade behind a "<kind> of <owner>" membership
+ *  query (HANDOVER item 6): the owner's OWN members — optionally `filterFn`-
+ *  filtered (a qualifier, e.g. "public") — win outright whenever non-empty; only
+ *  when that (possibly filtered) own result is EMPTY, and the owner's class
+ *  actually participates in `inherits` today (inheritsApplicable), do we walk
+ *  `ancestorsOf` NEAREST-FIRST, stopping at the first ancestor whose own
+ *  (identically filtered) member set is non-empty. Applying `filterFn` INSIDE the
+ *  walk — not once after it returns — is what makes a QUALIFIED query ("public
+ *  methods of TaskController") correctly walk up when the owner has own members
+ *  but none satisfy the qualifier, rather than stopping early on an unfiltered
+ *  non-empty own-set that the qualifier alone would have emptied (see the two
+ *  call sites: an omitted/identity `filterFn` is the plain unqualified case).
+ *  Returns {own, inherited, viaId, viaLabel} — `inherited`/`viaId`/`viaLabel` are
+ *  populated ONLY when the walk actually found something on an ancestor, so a
+ *  caller can disclose "inherited from <viaLabel>" rather than silently
+ *  presenting an ancestor's members as the owner's own (never-fabricate — the
+ *  same discipline computeFind's "related, not exact" broad pass documents). */
+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 };
+}
+
 /** Does an individual satisfy one qualifier (spec from QUALIFIERS)? Reads only
  *  attributes/edges the graph already carries — an unpopulated attribute (e.g.
  *  isAbstract) simply yields false, an honest empty rather than an error. */
@@ -1531,22 +1644,34 @@ function evalSet(graph, ast, opts) {
       // node match (tier 1 — a real file/symbol named that) still wins outright
       // (unchanged single-container-node behavior, e.g. "methods in widget.mjs");
       // only when there is no exact match do we try directory-prefix scope first.
-      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 ids = new Set(dirMods.map((m) => m.id));
-          const objs = uniqueById(MEMBERSHIP_KINDS.flatMap((k) => forwardOverSet(graph, k, ids)));
-          return objs.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 = 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 [];
+      // item 6 (HANDOVER): the owner's own members win outright when non-empty;
+      // only an EMPTY own set walks up `inherits` (computeMembership) — see its
+      // own doc above. evalSet's flat-array embedding (a find-seed inside a
+      // boolean/qualifier fold, §6-style) transparently flattens own vs. inherited,
+      // same as evalSet's "find" case does for computeFind's narrow/broad split;
+      // the DISCLOSED (never-silent) version lives in evalMembershipComposite,
+      // below, for the top-level (and qualifier-wrapped) membership query shapes.
+      const { own, inherited } = computeMembership(graph, owner.id, owner.entityClass, ast.entityType);
+      return own.length ? own : inherited;
     }
     case "qualifier": {
+      // a qualifier wrapping a MEMBERSHIP inner needs the filter applied INSIDE
+      // the inheritance walk, at each level, not once after a flat resolve (item
+      // 6, Fix 1's per-level requirement — see computeMembership's own doc: a
+      // class can own a non-empty member set that the qualifier alone empties
+      // out, which must still walk up rather than stopping on the unfiltered own
+      // set). evalMembershipComposite is the single source of truth for this;
+      // reused here (matches-only) so evalSet's embedded-atom shape and the
+      // top-level composite path can never drift on WHICH set they compute.
+      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])));
     }
@@ -1632,6 +1757,19 @@ function degreeMetric(graph, ind, metric) {
   }
   return n;
 }
+/** Seonix Batch 3 (3b): every Commit individual, newest date first — the eval side of
+ *  the bare "recent commits"/"latest commits"/"newest commits" AST node (see
+ *  RECENT_COMMIT_LEAD/parseRelationalOrQualified above). Reuses the SAME
+ *  dateOf/localeCompare sort every other Commit-date reader in this file already
+ *  uses (ISO-8601 sorts correctly lexically). An empty graph is an honest empty,
+ *  never a guess. */
+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 };
+}
+
 /** TEMPORAL over a nested set (lever 3) — the commits that touched ANY member of the
  *  inner set, newest commit date first. Reuses the SAME touches→commit→date-sort the
  *  flat when-shape runs (mgx:commitDate is ISO-8601, so a lexical sort IS a date sort;
@@ -1660,6 +1798,47 @@ function evalSuperlative(graph, ast) {
   return { compositeKind: "superlative", entityType: ast.entityType, metricNoun: ast.metricNoun, extreme: ast.extreme, score: best, matches: winners };
 }
 
+/** TOP-LEVEL "<kind> of/in <owner>" membership eval (HANDOVER item 6), covering
+ *  both a bare membership node and a QUALIFIER node wrapping one ("public methods
+ *  of TaskController") — the two share this one function so the qualifier's
+ *  filter is threaded INSIDE computeMembership's inheritance walk (item 6, Fix 1's
+ *  per-level requirement) rather than applied once, after a plain flat resolve
+ *  (which would wrongly stop on a non-empty-but-unfiltered own set that the
+ *  qualifier alone would empty out — see computeMembership's own doc). Unlike
+ *  evalSet's embedded (flattening) "membership"/"qualifier" cases — used when this
+ *  shape is nested inside a boolean fold — this keeps the inheritance provenance
+ *  (`inheritedNotOwn`/`viaLabel`/`ownerLabel`) so renderComposite can disclose an
+ *  ancestor-sourced answer ("TaskController has no own public methods — inherited
+ *  from Controller: render.") rather than ever silently presenting an ancestor's
+ *  members as the owner's own. A directory scope (no single owner individual) has
+ *  no inheritance chain to walk — unaffected by item 6, same behavior as before. */
+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,
+  };
+}
+
 /** EXISTENCE eval — "is there a/an <kind> [called/named <term>] [in <module>]": a
  *  direct membership/name check against the graph, never routed through the
  *  relation-verb machinery. A named check resolves the term against the SAME
@@ -1718,7 +1897,15 @@ export function evalComposite(graph, ast, opts = {}) {
   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);
+  // membership inheritance cascade (HANDOVER item 6), TOP-LEVEL: a bare "<kind> of
+  // <owner>" node, or a qualifier wrapping one ("public methods of <owner>") — see
+  // evalMembershipComposite's own doc for why the two share one function and why
+  // this keeps disclosure provenance the embedded evalSet path deliberately drops.
+  if (ast.node === "membership" || (ast.node === "qualifier" && ast.inner.node === "membership")) {
+    return evalMembershipComposite(graph, ast, opts);
+  }
   // predicate-find (Workstream 2), TOP-LEVEL: unlike evalSet's "find" case (used
   // when a find-seed is embedded inside a boolean/qualifier fold, §6), this keeps
   // the broad-pass provenance so renderComposite can label a "related, not exact"
@@ -1825,6 +2012,26 @@ function renderComposite(parsed, result) {
       : "";
     return { content: `${compositeList(result.matches)}${hint}.`, miss: false, ambiguous: false, matches: result.matches };
   }
+  // membership inheritance cascade (HANDOVER item 6): a zero-hit is the ordinary
+  // set-producing honest miss below; a non-empty INHERITED result (the owner's own
+  // set was empty, an ancestor's wasn't) is disclosed OUT LOUD — "X has no own
+  // <kind> — inherited from <ancestor>: …" — never silently presented as though
+  // the owner declared them itself (never-fabricate, the same discipline
+  // computeFind's "related, not exact" broad pass documents for predicate-find).
+  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} — 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 };
+  }
   // predicate-find (Workstream 2): zero hits -> an honest miss naming BOTH the type
   // and the term; the broad ("related, not exact") pass is ALWAYS clearly labeled,
   // never presented as an unqualified match — the confident-wrong discipline Bug
@@ -1844,6 +2051,24 @@ function renderComposite(parsed, result) {
     }
     return { content: `${cited}.`, miss: false, ambiguous: false, matches: result.matches };
   }
+  // Seonix Batch 3 (3b): bare "recent/latest/newest commits" — a real dated commit
+  // list, newest first, capped at HISTORY_CAP for consistency with renderFileHistory/
+  // renderSymbolHistory's own listing convention (codegraph.mjs) — never the false
+  // "no Commit found matching 'recent'" find-miss this used to fall into.
+  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 ? ` — ${msg}` : ""}`;
+    });
+    const tail = result.matches.length > HISTORY_CAP ? ` …+${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";
@@ -1899,6 +2124,59 @@ function componentSet(s) {
   return new Set(String(s).toLowerCase().split(/[^a-z0-9]+/).filter(Boolean));
 }
 
+/** A minimal, CLOSED derivational-suffix normalizer for tier 3's Module-basename
+ *  bridge (item 9 fix, 2026-07-09 playtest-freeze dead-end) — deliberately NOT a
+ *  general stemmer (prose.mjs's own tokenizer comment explicitly avoids a stemmer
+ *  dependency; this stays a few hand-picked suffixes, same "closed set over general
+ *  rule" preference as everywhere else in this file). Strips exactly one of a small
+ *  suffix set ("ing"/"er"/"ers"/"or"/"ors" — the gerund and agent-noun endings that
+ *  regularly pair up in English: "logging"/"logger", "routing"/"router") off the
+ *  END of the word, then collapses a doubled trailing letter the strip exposed (the
+ *  consonant-doubling spelling short CVC roots take before -ing/-er: "log" ->
+ *  "logging"/"logger", both reducing here to "log"). Length-floored at 5 BEFORE
+ *  stripping so it can never fire on a short word and reopen the accidental-
+ *  short-word-match bug tier 3's other floors guard against; returns the word
+ *  unchanged (so callers can detect "no-op" via `=== w`) when no suffix matches. */
+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;
+}
+
+/** Strip EXPLICIT separator characters only (path slashes, hyphens, underscores, a
+ *  trailing file extension) — never camelCase boundaries — so a candidate's own
+ *  label/path collapses to the same joined lowercase token a naming-convention-blind
+ *  user would type: "PaymentSystem" -> "paymentsystem", "payment-system" ->
+ *  "paymentsystem", "westfield-payment-system/src/MyCode.cs" ->
+ *  "westfieldpaymentsystemsrcmycode", "IPaymentSystemImpl.cs" -> "ipaymentsystemimpl".
+ *  Used by the compound-term tier just below (multi-word query bridge, 2026-07-09
+ *  compound-name fix, item: "match symbols where the question breaks a symbol into
+ *  2 words"). The extension strip is deliberately the SAME single-trailing-
+ *  extension regex tier 3's own `stem` computation already uses elsewhere in this
+ *  file — not reinvented. */
+function joinedForm(label) {
+  return String(label || "")
+    .replace(/\.[a-z0-9]+$/i, "")
+    .toLowerCase()
+    .replace(/[/\-_.]+/g, "");
+}
+
+/** Same joined-token normalization as joinedForm(), applied to the QUERY side of a
+ *  multi-word term: a leading article is stripped first (mirrors LEADING_ARTICLE_RE
+ *  below — "the payment system" and "payment system" must produce the identical
+ *  joined form), then whitespace/hyphens/underscores between words collapse out —
+ *  "the payment system" -> "payment system" -> "paymentsystem". */
+function joinedQueryForm(term) {
+  return String(term || "")
+    .trim()
+    .replace(/^(?:the|a|an)\s+/i, "")
+    .toLowerCase()
+    .replace(/[\s\-_]+/g, "");
+}
+
 /** Resolve a free-text object/subject term against the graph's individuals, in priority
  *  order (§4, generalized beyond the module-coupling worked example to cover every verb
  *  family's object grain — `inherits`/`calls` resolve against Class/Function names, not
@@ -1942,7 +2220,7 @@ function componentSet(s) {
  *  for a caller (traverse()'s reverse case) that already knows what class the
  *  relation's object slot expects ("which modules import logger" must never
  *  resolve "logger" to a same-stem Class). */
-export function resolveObject(graph, term, { expectedClass = null } = {}) {
+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();
@@ -2049,8 +2327,113 @@ export function resolveObject(graph, term, { expectedClass = null } = {}) {
     // no-op for those (unaffected — original ANY-overlap behavior).
     const pathToken = tLc.split(/\s+/).find((tok) => tok.includes("/"));
     const slashStem = pathToken ? pathToken.split("/").pop().replace(/\.[a-z0-9]+$/, "") : null;
+    // Compound-term bridge (2026-07-09, "match symbols where the question breaks a
+    // symbol into 2 [words]"): a query with 2+ SPACE-SEPARATED words ("payment
+    // system", "the payment system") has no separator of its own to compare against
+    // a label's literal spelling — the tiers above/below all compare tLc verbatim,
+    // so "payment system" never equals/contains/overlaps "PaymentSystem" or
+    // "payment-system" by those checks even though a human reads them as the same
+    // concept. Computed ONCE per query (article-stripped, space-collapsed — see
+    // joinedQueryForm) and checked per-candidate below via each candidate's OWN
+    // joinedForm(). Single-word queries are unaffected: isMultiWord is false, the
+    // branch below never fires, and they resolve exactly as before through the
+    // tiers already in this loop.
+    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();
+      // Basename-exact/prefix/suffix tier (large-scale-fixture bug, 2026-07-09): a bare
+      // term that IS a file's basename ("verify-shipped" -> scripts/verify-shipped.mjs)
+      // must outrank every sibling that merely shares a directory or a component
+      // ("verify") with it — checked BEFORE the raw-containment/overlap passes below so
+      // an exact stem match always wins over a same-directory partial. Only meaningful
+      // for a bare (unslashed) term, since `stem` is compared directly against the whole
+      // `tLc` — a slashed query term (e.g. "src/nope.mjs") already contains "/" and can
+      // never equal/prefix/suffix a bare stem, so it falls through unaffected to the
+      // existing slashStem-gated overlap logic just below, unchanged.
+      // The prefix/suffix half (not the exact-equality half) shares the SAME sub-4-char
+      // floor as the containment tier just below it — an unguarded stem.startsWith(tLc)
+      // reintroduces the exact short-word accidental-match bug that floor was added to
+      // close (e.g. bare "so" prefix-matching "someOtherFile"'s stem). A full stem
+      // EQUALITY, at any length, is never an accidental substring — "db"/"fs"-shaped
+      // short real identifiers must still resolve — so it stays unguarded.
+      const stem = label.split("/").pop().replace(/\.[a-z0-9]+$/, "");
+      if (stem === tLc) { scored.push({ ind: m, score: 5000 }); continue; }
+      if (tLc.length >= 4 && (stem.startsWith(tLc) || stem.endsWith(tLc))) {
+        scored.push({ ind: m, score: 4000 - Math.abs(stem.length - tLc.length) });
+        continue;
+      }
+      // Compound-term bridge (2026-07-09): the multi-word analog of the exact/
+      // prefix-suffix tier just above — a query that breaks a single joined symbol
+      // into 2+ words ("payment system") is compared against the candidate's OWN
+      // joined form (separators stripped, camelCase left alone), not its literal
+      // spelling. An exact joined match ("payment system" == "PaymentSystem"'s
+      // "paymentsystem") is scored the SAME as the single-word exact-stem tier
+      // above (5000) — it is equally strong evidence, just phrased with spaces.
+      // A CONTAINMENT match ("payment system" found inside "westfield-payment-
+      // system"'s or "IPaymentSystemImpl.cs"'s joined form) is scored strictly
+      // BELOW every single-word tier above (a real single-word substring/prefix/
+      // suffix hit is stronger evidence than a multi-word query merely appearing
+      // somewhere in a longer joined string) but ABOVE the raw component-overlap
+      // tier further below (score <= 10). CONTAINMENT is additionally gated on the
+      // candidate label carrying an EXPLICIT separator (path slash, hyphen,
+      // underscore, or a real file extension) — a pure-camelCase label with none
+      // of those (e.g. Function "calculateTotalPrice") is deliberately left to
+      // tier 4's prose/decomposed-identifier fallback below, which already owns
+      // exactly that "query words are a sub-sequence of a compound identifier's
+      // OWN decomposed tokens" territory (frozen test: "total price" ->
+      // calculateTotalPrice must resolve at tier 4 via matchedVia:"prose", not
+      // tier 3) — without this gate, EVERY multi-word query touching prose
+      // territory would be silently reclassified as a tier-3 containment hit and
+      // break that precedent. The EXACT tier just above has no such gate: an
+      // exact joined-form equality is unambiguous evidence regardless of whether
+      // the label happens to use an explicit separator (PascalCase "PaymentSystem"
+      // included) — only the fuzzier CONTAINMENT check needs the extra guard.
+      // Gated on isMultiWord so a single-word query is never affected (it already
+      // resolves via the tiers above/below, unchanged).
+      if (isMultiWord) {
+        const candJoined = joinedForm(m.label);
+        if (candJoined && candJoined === qJoined) { scored.push({ ind: m, score: 5000 }); 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: 2000 - Math.abs(candJoined.length - qJoined.length) });
+          continue;
+        }
+      }
+      // Derivational-suffix basename bridge (item 9 fix, 2026-07-09): a bare term
+      // that is a MODULE's own basename one gerund/agent-noun suffix-swap away
+      // ("logging" for src/lib/logger.mjs's basename "logger" — neither is a
+      // substring/prefix/suffix of the other, so the tiers just above miss it)
+      // is still a real NAME match, not free text — Module-only (mirrors the
+      // dotted-branch's own Module-only exact-basename special case just above
+      // in this file), specifically so it can never also fire for a same-stem
+      // Class/Method/Function sharing the same root ("Logger", "Logger.info")
+      // and manufacture a false three-way tie; a bare-word class-ambiguity like
+      // that is exactly the documented, already-accepted expectedClass-gated
+      // case this function's own docblock calls out ("logger" -> Class), left
+      // untouched. Scored below the literal exact/prefix/suffix tiers above (a
+      // real substring is always stronger evidence) but above plain containment/
+      // overlap (a genuine one-suffix-away basename match is still far more
+      // specific than an accidental shared word). Guarded against tier 5's OWN
+      // territory: a term that is merely a near-miss TYPO of an already-close
+      // literal stem ("loging" for "logging", 1 edit away) must still fall
+      // through to the bounded-fuzzy tier and be ANNOUNCED ("assuming you
+      // meant…") — it is not a distinct derivational word-form, it is the same
+      // word misspelled — so this bridge only fires when the term is OUTSIDE
+      // the fuzzy tier's own distance bound (a real morphological pair like
+      // "logging"/"logger" is 3 edits apart, well past tier 5's 2-edit budget
+      // for words this length, so there is no overlap between the two tiers).
+      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: 3000 - Math.abs(stem.length - tLc.length) });
+            continue;
+          }
+        }
+      }
       if (tLc.length >= 4 && label.includes(tLc)) {
         scored.push({ ind: m, score: 1000 - Math.abs(label.length - tLc.length) });
         continue;
@@ -2072,7 +2455,13 @@ export function resolveObject(graph, term, { expectedClass = null } = {}) {
       // "cover"/"touch" themselves never overlap anything, so overlap>0 and
       // the stem gate both hold.
       if (overlap > 0 && (!slashStem || labelComps.has(slashStem))) {
-        scored.push({ ind: m, score: overlap * 10 });
+        // Normalized by the TERM's own component count (not a flat overlap*10): a
+        // 1-of-3-component partial match ("verify" out of "verify-shipped"'s two
+        // components, or similar) must never outscore a clean exact/prefix/suffix
+        // stem hit from the tier above, nor a fuller-fraction overlap on another
+        // candidate. termComps.length > 0 is guaranteed here (overlap > 0 requires
+        // at least one termComps entry to have matched).
+        scored.push({ ind: m, score: (overlap / termComps.length) * 10 });
       }
     }
   }
@@ -2174,6 +2563,65 @@ export function resolveObject(graph, term, { expectedClass = null } = {}) {
   return proseResult || { match: null, candidates: [], tier: null, ambiguous: false };
 }
 
+/** A leading article is pure noise on a structural entity term ("the logger" ==
+ *  "logger") — mirrors memory/core.mjs's normFactTerm article-strip for taught
+ *  facts (Tier 5, T1), applied here on the graph-resolution side instead. */
+const LEADING_ARTICLE_RE = /^(?:the|a|an)\s+/i;
+
+/** A trailing GENERIC GRAIN WORD ("the logger MODULE", "the Task CLASS") is a
+ *  TYPE HINT a real user attaches to disambiguate WHICH grain they mean — but
+ *  resolveObjectCore's plain word-overlap scoring (tier 3) can't read
+ *  grammatical role, so the grain word instead becomes an ordinary overlapping
+ *  component and can manufacture an accidental TIE between the actual module and
+ *  any same-stem Class/Method sharing its name (Tier 6 playtest, found live:
+ *  "the logger module" tied mod:src/lib/logger.mjs against fn:...#Logger and
+ *  fn:...#Logger.info, all scoring identically on the shared "logger" component
+ *  once "module"/"the" themselves matched nothing — the caller's own
+ *  `!ambiguous` gate then silently declined the whole thing, walling
+ *  moduleOrientLane/"describe the logger module"/"where is the logger module
+ *  defined"/etc. even though a human reads "module" as fully disambiguating).
+ *  Reuses ENTITY_TO_TYPE (ask-vocab.mjs) — the SAME closed noun→grain table the
+ *  grammar's own entity-slot parsing already trusts — so this never invents a
+ *  new vocabulary, only a new place the existing one gets consulted. */
+const TRAILING_GRAIN_WORD_RE = new RegExp(`\\s+(${Object.keys(ENTITY_TO_TYPE).join("|")})$`, "i");
+
+/** resolveObject: the grain-aware disambiguation PRE-PASS, wrapping
+ *  resolveObjectCore (the tiered resolver, unchanged) — only when the CALLER
+ *  hasn't already pinned an expectedClass (a caller that already knows the
+ *  class, e.g. traverse()'s reverse case, needs no help). Tries, in order:
+ *  (1) a trailing grain word ("module"/"class"/"function"/"method"/…, after a
+ *  leading-article strip) narrows the pool to that ONE grain and retries on
+ *  just the head noun — closing exactly the accidental-tie class this
+ *  docblock above describes; (2) failing that, a plain leading-article strip
+ *  alone (no grain word) — "the logger" resolves the same way bare "logger"
+ *  always has. Either retry is used ONLY on an unambiguous hit; any miss/tie
+ *  falls through unchanged to the ORIGINAL (unstripped) term via
+ *  resolveObjectCore, so this is purely additive — a term that already
+ *  resolved before resolves exactly the same way now (a multi-word "the X
+ *  module"-shaped term never equals a real label outright, so the exact-match
+ *  tier the pre-pass could theoretically shadow is never actually in play). */
+export 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);
+}
+
 /** Resolve a term that may be a context pronoun ("this"/"it"/"that"/"here") —
  *  when `contextId` is given, resolve straight to that graph entity (a real
  *  click/focus in the caller's UI, not a guess); with no contextId, an honest
@@ -3279,6 +3727,46 @@ export function relaxParse(graph, query, { nlp = undefined, contextId = null, pr
  *  miss. Returns the full {content, tmct_ask:
  *  {mechanical,parsed,matches,traversal,miss,ambiguous,candidates?}} envelope
  *  §6.2 specifies. Zero generative model calls. */
+// Seonix Batch 3 (3b), singular subject: "the last commit"/"the latest commit"/"the
+// most recent commit" — literal-phrase substitution, checked as a whole-word match
+// (not anchored to the whole line, since it may sit mid-sentence as the subject of a
+// longer question, e.g. "what did the last commit touch").
+const LAST_COMMIT_PHRASE_RE = /\b(?:the\s+)?(?:last|latest|most\s+recent)\s+commit\b/i;
+
+/** resolveObject has no notion of "the newest Commit individual" — it only matches
+ *  literal graph labels, and the bare word "commit" itself component-matches the
+ *  Commit SchemaClass node (a known risk noted around resolveObject's own tier-3
+ *  comments), so "what did the last commit touch" used to render a false "Commit
+ *  has no touches edges in the index" instead of an honest answer. Fixed by textual
+ *  substitution BEFORE the normal parse/resolve pipeline runs: the phrase is swapped
+ *  for "commit <newest-sha>" (the SAME dateOf/localeCompare sort every other
+ *  Commit-date reader in this file already uses), so the rest of the pipeline sees
+ *  exactly what it would for "what did commit <realsha> touch" and needs no other
+ *  change. A graph with no commits, or no date on any commit, leaves the query text
+ *  untouched — an honest miss downstream, never a guess at which commit is "last". */
+// A bare "when was/did commit X" with no change-verb tail at all (the shape left
+// once "the latest commit" is substituted out of "when was the latest commit") —
+// grammar.mjs's T8 "when" template requires a touches-family verb to fire, so this
+// would otherwise honestly miss even though traverse()'s own "when" branch already
+// special-cases a Commit OBJECT to answer with its own date (see the commit-as-
+// subject flip's sibling branch, just above the flip itself). Bridged by appending
+// the neutral "touched" tail — never for a query that already names its own verb
+// ("what did the last commit touch" is untouched).
+const 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;
+}
+
 export function ask(graph, query, { contextId = null, nlp = undefined, prev = null } = {}) {
   // Explicit help/orientation request → the rephrase hint directly (the honest bottom
   // of the cascade, reached on demand), never a pretend answer or a relaxation attempt.
@@ -3291,6 +3779,11 @@ export function ask(graph, query, { contextId = null, nlp = undefined, prev = nu
       },
     };
   }
+  // Seonix Batch 3 (3b), singular subject: substitute "the last/latest/most recent
+  // commit" for the real newest Commit's own id BEFORE anything else runs, so the
+  // rest of the pipeline (direct parse, relaxation, resolveObject) never has to know
+  // this phrase existed — see substituteLastCommitPhrase's own doc above.
+  query = substituteLastCommitPhrase(graph, query);
   const direct = parseQuery(query, { nlp });
   // The relaxation cascade fires ONLY when the DIRECT parse would miss (no parse, a
   // compositional {node:"miss"}, or an unresolved named term) — a clean hit, an