@polycode-projects/the-mechanical-code-talker 5.0.12 → 5.0.14

package/src/services/chat.mjs

@@ -59,7 +59,8 @@ import { loadResearchQueue, saveResearchQueue } from "../adapters/research-queue
 import { CHILD_PACK_NAME, childProvenanceTag } from "../domain/child-pack.mjs";
 import { getChildPackProvider } from "../adapters/corpus/child-pack.mjs";
 import { dialogueActForLane } from "../domain/dialogue-acts.mjs";
-import { subClassParents, ancestryChain, clusterSenses } from "../domain/sense-split.mjs";
+import { subClassParents, subClassChildren, descendantSet, ancestryChain, clusterSenses } from "../domain/sense-split.mjs";
+import { ANSWER_STOP_SET } from "../domain/hub-terms.mjs";
 import { relatedForTerm } from "../domain/skos-view.mjs";
 import { adventureTurn, unclaimedAdventureOpening, foldWorldState } from "./adventure.mjs";
 import { spiderFlyTurn } from "./spider-fly-turn.mjs";
@@ -966,14 +967,47 @@ async function answerMemoryClassQuery(memoryDir, query) {
 // stealing the phrasing before a member count ever runs.
 const TAUGHT_CLASS_COUNT_RE = /^how\s+many\s+([a-z][\w-]*(?:\s+[a-z][\w-]*)*)\s*(.*)$/i;
 
+/** A fact row's deterministic identity for ordering. */
+const orderKeyOf = (f) => `${f.subject} ${f.predicate} ${f.object} ${f.provenance || ""}`;
+const orderKeyCompare = (a, b) => {
+  const ka = orderKeyOf(a); const kb = orderKeyOf(b);
+  return ka < kb ? -1 : ka > kb ? 1 : 0;
+};
+
+/** The store's subclass graph, both directions, built once per turn.
+ *  Keyed on the rows array identity so a rebuilt row cache rebuilds the maps. */
+function classGraphFor(rows, cache) {
+  if (cache && cache.classGraphRows === rows) return cache.classGraph;
+  const subClassEdges = rows.filter((f) => f.predicate === SUBCLASS_PREDICATE).map((f) => [f.subject, f.object]);
+  const graph = { parents: subClassParents(subClassEdges), children: subClassChildren(subClassEdges) };
+  if (cache) { cache.classGraphRows = rows; cache.classGraph = graph; }
+  return graph;
+}
+
+/** Every taught member of the class named by `variants`, direct and inherited.
+ *  Direct = an isa row whose OBJECT is one of the asked spellings. Inherited =
+ *  an isa row whose OBJECT is a class transitively below the asked one.
+ *  Pure over (isa, children, variants) — no I/O, no clock, no arrival order. */
+function taughtMembersUnder(isa, children, variants, biasByBundle) {
+  const classes = new Set();
+  for (const v of variants) for (const d of descendantSet(v, children)) classes.add(d);
+  const isDirect = (f) => variants.has(f.object);
+  const candidates = isa.filter((f) => isDirect(f) || classes.has(f.object));
+  const keyed = uniqueFacts(candidates).slice().sort(orderKeyCompare);
+  const direct = rankByBiasThenTrust(keyed.filter(isDirect), biasByBundle);
+  const inherited = rankByBiasThenTrust(keyed.filter((f) => !isDirect(f)), biasByBundle);
+  return { direct, inherited, members: [...direct, ...inherited], classes };
+}
+
 /** The longest leading run of `nounRun`'s words that names a class something was
- *  actually taught about, as `{asked, tail, members}` — its taught members and
- *  whatever words are left over, joined onto `trailing` as the restrictor tail.
- *  A class name is a noun PHRASE, not a word ("sprite class", "body of water"),
- *  so the run is tried longest-first and the shortest reading wins only when no
- *  longer one is on record. That ordering is what keeps a single-word class
- *  carrying a restrictor ("list the animals in the graph") reading exactly as it
- *  did when only the first word was ever considered. */
+ *  actually taught about, as `{asked, tail, members, directMembers, inheritedMembers}`
+ *  — its taught members (direct AND transitively inherited through taught
+ *  subclasses) and whatever words are left over, joined onto `trailing` as the
+ *  restrictor tail. A class name is a noun PHRASE, not a word ("sprite class",
+ *  "body of water"), so the run is tried longest-first and the shortest reading
+ *  wins only when no longer one is on record. That ordering is what keeps a
+ *  single-word class carrying a restrictor ("list the animals in the graph")
+ *  reading exactly as it did when only the first word was ever considered. */
 async function longestTaughtClassInRun(memoryDir, nounRun, trailing, biasByBundle, cache) {
   const words = String(nounRun || "").trim().split(/\s+/).filter(Boolean);
   if (!words.length) return null;
@@ -982,12 +1016,31 @@ async function longestTaughtClassInRun(memoryDir, nounRun, trailing, biasByBundl
   try { ({ normFactTerm } = await import("../adapters/memory/core.mjs")); } catch { return null; }
   const rows = await factRows(memoryDir, cache);
   const isa = rows.filter((f) => ISA_PREDICATES.has(f.predicate));
+  const { parents, children } = classGraphFor(rows, cache);
   for (let take = words.length; take >= 1; take -= 1) {
     const asked = words.slice(0, take).join(" ").toLowerCase();
     const variants = factTermVariants(normFactTerm, asked);
-    const members = rankByBiasThenTrust(isa.filter((f) => variants.has(f.object)), biasByBundle);
-    if (!members.length) continue; // nothing taught under this reading — try a shorter one
-    return { asked, tail: [words.slice(take).join(" "), String(trailing || "")].filter(Boolean).join(" ").trim(), members };
+    // The row whose OBJECT is actually stored under one of the asked spellings
+    // — its object is the class's CANONICAL stored term, which `asked` itself
+    // is not (a plural typed by the reader, "letters", never equals the
+    // singular stored term, "letter"). `ancestryChain`'s `toward` steering
+    // compares by exact string, so it has to aim at this stored term, not the
+    // raw asked phrase.
+    const onRecord = isa.find((f) => variants.has(f.object));
+    if (!onRecord) continue; // not on record as a reading — try a shorter one
+    const found = taughtMembersUnder(isa, children, variants, biasByBundle);
+    return {
+      asked,
+      classTerm: onRecord.object,
+      tail: [words.slice(take).join(" "), String(trailing || "")].filter(Boolean).join(" ").trim(),
+      members: found.members,
+      directMembers: found.direct,
+      inheritedMembers: found.inherited,
+      variants,
+      parents,
+      classes: found.classes,
+      subjectSet: new Set(found.members.map((f) => f.subject)),
+    };
   }
   return null;
 }
@@ -995,7 +1048,10 @@ async function longestTaughtClassInRun(memoryDir, nounRun, trailing, biasByBundl
 /** Count the taught members of a class named by a noun phrase ("how many animals
  *  are there" → every "X is a kind of animal"). Declines (null) for a real
  *  code-countable class (answerCount owns it) or a class nothing was taught
- *  about, so structural counts and the quantifier lane are unaffected. */
+ *  about, so structural counts and the quantifier lane are unaffected. A count
+ *  above zero carries a follow-up pointing at the list lane — a bare number
+ *  answers the question asked but leaves the obvious next question ("which
+ *  ones?") with no signposted way to ask it. */
 async function answerTaughtClassCount(memoryDir, query, biasByBundle = {}, cache = null) {
   if (!memoryDir) return null;
   const m = String(query).trim().match(TAUGHT_CLASS_COUNT_RE);
@@ -1006,10 +1062,27 @@ async function answerTaughtClassCount(memoryDir, query, biasByBundle = {}, cache
   // A member whose SUBJECT is itself a countable graph class ("every class is a
   // component") is an asserted-vocabulary cardinality, not a member enumeration —
   // countFromFacts counts the real class, so defer to it rather than tallying the
-  // one class-level fact.
-  if (hit.members.some((f) => COUNT_NOUNS[String(f.subject).toLowerCase()])) return null;
-  const n = hit.members.length;
-  return `${n} ${n === 1 ? hit.asked.replace(/s$/, "") : hit.asked}.`;
+  // one class-level fact. Only a DIRECT member triggers the deferral: an
+  // inherited member reached through a taught subclass is still a genuine
+  // count of this class's membership.
+  if (hit.directMembers.some((f) => COUNT_NOUNS[String(f.subject).toLowerCase()])) return null;
+  const n = new Set(hit.members.map((f) => String(f.subject).toLowerCase())).size;
+  const noun = n === 1 ? hit.asked.replace(/s$/, "") : hit.asked;
+  // Sense reporting: cluster the classes the members were found under,
+  // excluding the asked class itself — leaving it in would let clusterSenses'
+  // "one subsumes the other" verdict collapse every taught subclass into the
+  // asked class's own lineage and report one sense no matter how many there are.
+  const senseObjects = [...new Set(hit.members.map((f) => f.object))]
+    .filter((o) => !hit.variants.has(o))
+    .sort();
+  let senses = 1;
+  if (senseObjects.length >= 2) {
+    const rows = await factRows(memoryDir, cache);
+    const disjointEdges = rows.filter((f) => f.predicate === "owl:disjointWith").map((f) => [f.subject, f.object]);
+    senses = clusterSenses(senseObjects, { parents: hit.parents, disjointEdges }).clusters.length;
+  }
+  const senseClause = senses >= 2 ? `, in ${senses} senses` : "";
+  return `${n} ${noun}${senseClause}. Say "list ${hit.asked}" to see them.`;
 }
 
 // "list all animals" / "list the animals" — enumerate a taught class's members,
@@ -1019,29 +1092,171 @@ async function answerTaughtClassCount(memoryDir, query, biasByBundle = {}, cache
 // orientation lane claims the bare "list …" phrasing before factReadBack runs.
 const MEMBERSHIP_LIST_RE = /^(?:list|show(?:\s+me)?)\s+(?:all\s+|the\s+)?([a-z][\w-]*(?:\s+[a-z][\w-]*)*)\s*(.*)$/i;
 
+// "list letters but not greek letters" — the tail left over once the class name
+// is stripped, when that tail names an EXCLUSION rather than an unreadable
+// restrictor. Checked ahead of the DYNAMIC_TAIL_OK_RE refusal below so a real
+// subtraction still gets its own trigger to run, rather than sharing "list
+// letters"'s bare enumeration and losing the "but not …" clause entirely.
+const EXCLUSION_TAIL_RE = /^(?:but\s+not|except(?:\s+for)?|excluding|other\s+than)\s+(.+)$/i;
+
 /** List the taught members of a class named by a noun phrase ("list all animals"
  *  → every "X is a kind of animal"). Declines (null) for a code-countable class
  *  or a class nothing was taught about; declines with a message for a real
- *  restrictor tail rather than answering as if it weren't there. */
+ *  restrictor tail rather than answering as if it weren't there. An exclusion
+ *  tail ("but not greek letters") is its own case: it resolves the excluded
+ *  phrase the same way and subtracts, rather than falling into that refusal. */
 async function answerMembershipList(memoryDir, query, biasByBundle = {}, cache = null) {
   if (!memoryDir) return null;
   const m = String(query).trim().match(MEMBERSHIP_LIST_RE);
   if (!m) return null;
   const hit = await longestTaughtClassInRun(memoryDir, m[1], m[2], biasByBundle, cache);
   if (!hit) return null;
-  const { asked, tail, members } = hit;
+  const { asked, classTerm, tail, members, directMembers, inheritedMembers, parents, subjectSet } = hit;
+  const declineTail = (badTail) => ({
+    text: `I can list the ${asked}, but not the "${badTail}" part of that question — `
+      + `so I won't answer as if you hadn't asked it. Ask "list ${asked}" for all of them.`,
+    miss: true,
+  });
+  const renderMembers = (directList, inheritedList, note) => {
+    const lines = [
+      ...directList.map(renderFactLine),
+      ...inheritedList.map((f) => renderFactLineWithChain(f, parents, subjectSet, { toward: classTerm })),
+    ];
+    const shown = lines.slice(0, FACT_ANSWER_CAP);
+    const rest = lines.slice(FACT_ANSWER_CAP);
+    const extra = rest.length ? `\n…and ${rest.length} more — say 'more' to see them.` : "";
+    return { text: shown.join("\n") + extra + (note || ""), ...(rest.length ? { pending: { items: rest, noun: asked } } : {}) };
+  };
+  const exclusionM = tail.match(EXCLUSION_TAIL_RE);
+  if (exclusionM) {
+    const excludedHit = await longestTaughtClassInRun(memoryDir, exclusionM[1], "", biasByBundle, cache);
+    if (!excludedHit || !DYNAMIC_TAIL_OK_RE.test(excludedHit.tail)) {
+      // The excluded phrase itself named no taught class, or left its own
+      // residue behind — decline naming whatever part stayed unresolved.
+      return declineTail(excludedHit ? excludedHit.tail : tail);
+    }
+    let normFactTerm;
+    try { ({ normFactTerm } = await import("../adapters/memory/core.mjs")); } catch { return declineTail(tail); }
+    // The excluded side is resolved through the same taught-subclass closure
+    // as the list itself, so a member reached only through a taught subclass
+    // of the excluded class still drops, and the excluded class's own
+    // membership row (e.g. "greek letter is a kind of letter") drops too.
+    const excludedSubjects = new Set();
+    for (const f of excludedHit.members) {
+      for (const v of factTermVariants(normFactTerm, f.subject)) excludedSubjects.add(v);
+    }
+    for (const c of excludedHit.classes) {
+      for (const v of factTermVariants(normFactTerm, c)) excludedSubjects.add(v);
+    }
+    const notExcluded = (f) => {
+      for (const v of factTermVariants(normFactTerm, f.subject)) {
+        if (excludedSubjects.has(v)) return false;
+      }
+      return true;
+    };
+    const directKept = directMembers.filter(notExcluded);
+    const inheritedKept = inheritedMembers.filter(notExcluded);
+    if (!directKept.length && !inheritedKept.length) {
+      return { text: `I hold no ${asked} outside the ${excludedHit.asked}.`, miss: true };
+    }
+    const note = (directKept.length + inheritedKept.length) === members.length
+      ? `\n(none of the ${asked} I know are marked as ${excludedHit.asked} yet.)`
+      : "";
+    return renderMembers(directKept, inheritedKept, note);
+  }
+  if (!DYNAMIC_TAIL_OK_RE.test(tail)) return declineTail(tail);
+  return renderMembers(directMembers, inheritedMembers);
+}
+
+// "give me an example of a letter" / "name a letter" — the single-member
+// counterpart to the list trigger above: the same taught class, but one
+// representative rather than the whole enumeration, for a user who wants a
+// sample before asking for everything.
+const EXAMPLE_OF_RE = /^(?:give me\s+|what(?:'s|\s+is)\s+)?(?:an\s+example\s+of|example\s+of|name)\s+(?:an?\s+)?([a-z][\w-]*(?:\s+[a-z][\w-]*)*)\s*(.*)$/i;
+
+/** Answer with one taught member of a class named by a noun phrase ("give me an
+ *  example of a letter" → the top-ranked "X is a kind of letter"). Resolves the
+ *  class exactly as answerMembershipList does, and declines the same way: null
+ *  for a code-countable or untaught class, a named-tail refusal for a real
+ *  restrictor. */
+async function answerMembershipExample(memoryDir, query, biasByBundle = {}, cache = null) {
+  if (!memoryDir) return null;
+  const m = String(query).trim().match(EXAMPLE_OF_RE);
+  if (!m) return null;
+  const hit = await longestTaughtClassInRun(memoryDir, m[1], m[2], biasByBundle, cache);
+  if (!hit) return null;
+  const { asked, tail, members, directMembers } = hit;
   if (!DYNAMIC_TAIL_OK_RE.test(tail)) {
     return {
-      text: `I can list the ${asked}, but not the "${tail}" part of that question — `
-        + `so I won't answer as if you hadn't asked it. Ask "list ${asked}" for all of them.`,
+      text: `I can name a ${asked}, but not the "${tail}" part of that question — `
+        + `so I won't answer as if you hadn't asked it. Ask "name a ${asked}" for one.`,
       miss: true,
     };
   }
-  const lines = members.map(renderFactLine);
-  const shown = lines.slice(0, FACT_ANSWER_CAP);
-  const rest = lines.slice(FACT_ANSWER_CAP);
+  const n = members.length;
+  // directMembers is never empty here: longestTaughtClassInRun only reads a
+  // phrase as "on record" once something is taught directly under it, and the
+  // example is always that direct member, not one only reached by closure.
+  return { text: `${renderFactLine(directMembers[0])}\nSay "list ${asked}" for all ${n}.` };
+}
+
+/** "words with the letter p in it" / "words containing p" / "which words
+ *  contain p" — a closed set of phrasings, one capture each, and a SINGLE
+ *  letter only. The politeness/give-me lead is stripped by the same shared
+ *  prefix before these are tried, so each pattern only carries the question
+ *  itself. */
+const WORDS_WITH_LETTER_LEAD_RE =
+  /^(?:(?:can|could|would)\s+you\s+(?:please\s+)?|please\s+)?(?:(?:give|show|tell|find)\s+me\s+|list\s+)?(?:some\s+|the\s+|any\s+|all\s+(?:of\s+)?(?:the\s+)?)?/i;
+const WORDS_WITH_LETTER_PATTERNS = [
+  /^words\s+(?:that\s+|which\s+)?contain(?:s|ing)?\s+(?:the\s+letter\s+)?([a-z])$/i,
+  /^words\s+with\s+(?:the\s+letter\s+)?([a-z])(?:\s+in\s+(?:it|them))?$/i,
+  /^(?:what|which)\s+words\s+(?:contain|have|include)\s+(?:the\s+letter\s+)?([a-z])$/i,
+];
+
+/** The letter a words-containing question asks about, or null when the line
+ *  isn't one. */
+function wordsWithLetterOf(query) {
+  const q = String(query || "").trim().replace(/[?.!]+$/, "").replace(/\s+/g, " ")
+    .replace(WORDS_WITH_LETTER_LEAD_RE, "");
+  for (const re of WORDS_WITH_LETTER_PATTERNS) {
+    const m = q.match(re);
+    if (m) return m[1].toLowerCase();
+  }
+  return null;
+}
+
+/** A stored term counts as a WORD this lane may list when it is a single run
+ *  of letters, so a multi-word phrase, a path, a number or a predicate name
+ *  never reaches the list. Hyphens and apostrophes stay in, since "t-shirt"
+ *  and "o'clock" are words people mean. */
+const LISTABLE_WORD_RE = /^[a-z][a-z'-]*$/;
+
+/** Answer "which words contain p" from the store's own vocabulary: every
+ *  distinct single-word term standing as the subject or object of a remembered
+ *  fact, filtered to those carrying the letter. Sorted alphabetically, so the
+ *  answer is a pure function of the fact set and never of the order rows
+ *  arrived in. Nothing matching is the ordinary honest miss. */
+async function answerWordsWithLetter(memoryDir, query, cache = null) {
+  if (!memoryDir) return null;
+  const letter = wordsWithLetterOf(query);
+  if (!letter) return null;
+  const words = new Set();
+  for (const f of await factRows(memoryDir, cache)) {
+    if (WORLD_INTERNAL_PREDICATES.has(f.predicate)) continue;
+    for (const side of [f.subject, f.object]) {
+      const w = String(side || "").toLowerCase();
+      if (LISTABLE_WORD_RE.test(w) && w.includes(letter)) words.add(w);
+    }
+  }
+  if (!words.size) {
+    return { text: `none of the words I know contain "${letter}".`, miss: true };
+  }
+  const sorted = [...words].sort();
+  const shown = sorted.slice(0, FACT_ANSWER_CAP);
+  const rest = sorted.slice(FACT_ANSWER_CAP);
   const extra = rest.length ? `\n…and ${rest.length} more — say 'more' to see them.` : "";
-  return { text: shown.join("\n") + extra, ...(rest.length ? { pending: { items: rest, noun: asked } } : {}) };
+  const text = `Among the words I know, ${sorted.length} contain "${letter}": ${shown.join(", ")}.${extra}`;
+  return { text, ...(rest.length ? { pending: { items: rest, noun: "words" } } : {}) };
 }
 
 /** `/stats`: a one-screen overview of the graph — class counts, relationship
@@ -3159,6 +3374,17 @@ async function isGroundedByFact(term, memoryDir, cache = null) {
   return rows.some((f) => MINT_ISA_PREDICATES.has(f.predicate) && isOperatorTaught(f) && (f.subject === t || f.object === t));
 }
 
+/** A bare single alphabetic character ("a", "i", …) classify() resolves only
+ *  as a CLOSED-CLASS word (a determiner — "a"/"an" are the only ones a
+ *  single letter can spell — or a pronoun) never actually names a class or
+ *  entity, but real teach subjects land here too ("a is a kind of alphabet
+ *  letter"). Every grounding check below treats this shape as UNCLASSIFIED,
+ *  the same as any other genuinely unknown noun, so the classify() veto
+ *  stops shadowing the one-letter word itself. */
+function isClosedClassSingleLetter(raw, classified) {
+  return /^[a-z]$/i.test(String(raw ?? "").trim()) && (classified?.pos === "determiner" || classified?.pos === "pronoun");
+}
+
 /** Shared "is this term grounded in ANY sense" aggregate — a static lexicon
  *  word (any part of speech, via `classify`), a GENERIC_ANCHOR_NOUNS root, a
  *  term already anchored by a previously taught isa-family fact
@@ -3176,7 +3402,8 @@ async function isGroundedTerm(term, lex, memoryDir, cache = null, graph = null)
   if (!raw) return false;
   if (GENERIC_ANCHOR_NOUNS.has(raw.toLowerCase())) return true;
   const { classify } = await import("../domain/grammar/lexicon.mjs");
-  if (classify(raw, lex)) return true;
+  const classified = classify(raw, lex);
+  if (classified && !isClosedClassSingleLetter(raw, classified)) return true;
   if (graph && resolveSymbol(graph, raw)?.match) return true;
   return isGroundedByFact(raw, memoryDir, cache);
 }
@@ -3202,21 +3429,32 @@ export { isGroundedTerm };
  *  unchanged) whenever the payload doesn't fit the shape, or at least one
  *  side IS already grounded — a DIFFERENT, more specific reason it declined,
  *  where this nudge would be actively unhelpful noise. */
-async function ungroundedPairHint(payload, lexicon, memoryDir, cache = null, graph = null) {
-  if (!memoryDir) return "";
+/** The subject/object NP terms ungroundedPairHint's message names, computed
+ *  once and shared with the honest-miss builder's own residue clause below —
+ *  so a decline never names one pair of unknown words in one sentence and a
+ *  DIFFERENT pair (a wider or narrower slice of the same NPs) in the next.
+ *  Null when the payload doesn't fit the shape, or at least one side IS
+ *  already grounded — see ungroundedPairHint's own docblock for why. */
+async function ungroundedPairTerms(payload, lexicon, memoryDir, cache = null, graph = null) {
+  if (!memoryDir) return null;
   const m = String(payload).trim().match(UNKNOWN_SUBJECT_RE);
-  if (!m) return "";
+  if (!m) return null;
   const [, , subjectRaw, verb, objectRaw] = m;
   const { loadLexicon, lookupNoun } = await import("../domain/grammar/lexicon.mjs");
   const lex = lexicon || loadLexicon();
-  if (await isGroundedTerm(subjectRaw, lex, memoryDir, cache, graph)) return "";
-  if (await isGroundedTerm(objectRaw, lex, memoryDir, cache, graph)) return "";
+  if (await isGroundedTerm(subjectRaw, lex, memoryDir, cache, graph)) return null;
+  if (await isGroundedTerm(objectRaw, lex, memoryDir, cache, graph)) return null;
   // The sentences suggested here have to be the ones that actually store, so
   // both sides fold to the singular a plural surface named ("all zorps are
   // florbs" → "every zorp is a thing"). Following the plural verbatim teaches
   // a second class under a spelling nothing else uses.
   const subject = /^are$/i.test(verb) ? singularOf(subjectRaw, lex, lookupNoun) : subjectRaw;
   const object = storedObjectTerm(objectRaw, { verb, payload, lex, lookupNoun });
+  return { subject, object };
+}
+
+/** The grounding-nudge sentence for a resolved ungroundedPairTerms pair. */
+function groundingHintText({ subject, object }) {
   // Chaining the second term UNDER the first's now-grounded proper name
   // ("every man is a john") is technically accepted by the grammar (once
   // "john" is grounded, ANY term can be taught as a kind of it), but reads as
@@ -3228,6 +3466,11 @@ async function ungroundedPairHint(payload, lexicon, memoryDir, cache = null, gra
     + ` original fact.`;
 }
 
+async function ungroundedPairHint(payload, lexicon, memoryDir, cache = null, graph = null) {
+  const terms = await ungroundedPairTerms(payload, lexicon, memoryDir, cache, graph);
+  return terms ? groundingHintText(terms) : "";
+}
+
 /** The unknown-SUBJECT direct-write fallback: tried ONLY after the real ACE
  *  grammar (assertTurn) has already had its turn and declined. Declines
  *  itself (returns null, never a guess)
@@ -3274,11 +3517,14 @@ async function unknownSubjectFallback(payload, { memoryDir, sessionId, lexicon,
   // case is handled correctly a few lines down). Refuse only the fold's own
   // contribution here — an EXACT noun hit (no fold), or any non-noun
   // classification (a real verb/adjective/proper name/determiner), still
-  // blocks this fallback exactly as before.
+  // blocks this fallback exactly as before. A bare single letter ("a is a
+  // kind of alphabet letter") classifies as the determiner "a"/"an" itself,
+  // never a real class — isClosedClassSingleLetter exempts it the same way
+  // isGroundedTerm does, so the letter reads as an unknown noun instead.
   const subjectClass = classify(subjectRaw, lex);
   const subjectFoldedNounOnly = subjectClass?.pos === "noun" && !/^are$/i.test(verb)
     && (lookupNoun(lex, subjectRaw)?.lemma || "").toLowerCase() !== String(subjectRaw).toLowerCase();
-  if (subjectClass && !subjectFoldedNounOnly) return null;
+  if (subjectClass && !subjectFoldedNounOnly && !isClosedClassSingleLetter(subjectRaw, subjectClass)) return null;
   const quantifier = /^every$/i.test((det || "").trim()) ? "every" : "";
   // Singularize the SUBJECT before storage, but ONLY on a genuinely PLURAL
   // phrasing ("all men ARE mortal", verb "are"). This
@@ -4513,15 +4759,22 @@ const RELATED_TO_TEACH_RE = /^(?:a\s+|an\s+|the\s+)?([\w-]+)\s+(?:relates\s+to|i
  *  a plural surface folds to the singular the ⊑ facts use. */
 const NEGATIVE_UNIVERSAL_TEACH_RE = /^no\s+([\w-]+)\s+(is|are)\s+(?:an?\s+)?(?:(?:kind|type)\s+of\s+)?([\w-]+)[.!]*$/i;
 
-/** The mint (or the reflexive refusal) for a NEGATIVE_UNIVERSAL_TEACH_RE
- *  match, shared by teachLane and the ACE-path reflexive gate: null when the
- *  sentence isn't this shape. */
-async function negativeUniversalTeach(sentence, { memoryDir, sessionId, observedAt, dateText }) {
-  const m = String(sentence || "").trim().match(NEGATIVE_UNIVERSAL_TEACH_RE);
-  if (!m || !memoryDir) return null;
-  const plural = m[2].toLowerCase() === "are";
-  const subject = plural ? singularizeSurface(m[1]) : m[1];
-  const object = plural ? singularizeSurface(m[3]) : m[3];
+/** "X is not a Y" / "X isn't a Y" — the phrasing people reach for far more
+ *  often than the canonical "no X is a Y" above, for the exact same
+ *  class-pair exclusion. Tried only from inside the retraction block below,
+ *  once a stored positive fact to disagree with (the per-instance negation,
+ *  RETRACT_NOT_A_RE's own territory) has already been ruled out — this is
+ *  the sibling reading for what's LEFT: two classes the user is telling us
+ *  are disjoint. Single-token sides only, matching
+ *  NEGATIVE_UNIVERSAL_TEACH_RE's own discipline. */
+const SINGULAR_NEGATION_TEACH_RE = /^(?:an?\s+)?([\w-]+)\s+(?:is\s+not|isn't)\s+(?:an?\s+)?(?:(?:kind|type)\s+of\s+)?([\w-]+)$/i;
+
+/** The mint (or the reflexive refusal) shared by every "no X is Y"-shaped
+ *  teach surface: null only when the store write itself fails. ackText
+ *  overrides teachFact's own acknowledgment for a caller whose surface form
+ *  isn't already the canonical "no X is a Y" restatement, so the user still
+ *  sees how the sentence actually landed. */
+async function mintNegativeUniversal(subject, object, { memoryDir, sessionId, observedAt, dateText, ackText }) {
   if (subject.toLowerCase() === object.toLowerCase()) {
     return {
       text: `I can't store "no ${subject} is a ${object}" — every ${subject} is a ${subject} by definition, so that exclusion contradicts itself. Nothing was stored.`,
@@ -4538,7 +4791,19 @@ async function negativeUniversalTeach(sentence, { memoryDir, sessionId, observed
       via: "teach-miss", miss: true,
     };
   }
-  return stored;
+  return ackText ? { ...stored, text: ackText } : stored;
+}
+
+/** The mint (or the reflexive refusal) for a NEGATIVE_UNIVERSAL_TEACH_RE
+ *  match, shared by teachLane and the ACE-path reflexive gate: null when the
+ *  sentence isn't this shape. */
+async function negativeUniversalTeach(sentence, { memoryDir, sessionId, observedAt, dateText }) {
+  const m = String(sentence || "").trim().match(NEGATIVE_UNIVERSAL_TEACH_RE);
+  if (!m || !memoryDir) return null;
+  const plural = m[2].toLowerCase() === "are";
+  const subject = plural ? singularizeSurface(m[1]) : m[1];
+  const object = plural ? singularizeSurface(m[3]) : m[3];
+  return mintNegativeUniversal(subject, object, { memoryDir, sessionId, observedAt, dateText });
 }
 
 /** "no X can Y" — NEGATIVE_UNIVERSAL_TEACH_RE's sibling one relation over:
@@ -4931,6 +5196,23 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
           };
         }
       }
+      // SINGULAR NEGATION AS CLASS EXCLUSION — "car is not a bike" states the
+      // same class-pair disjointness "no car is a bike" does. Tried here,
+      // once the per-instance disagreement above has found no positive fact
+      // to attach to, and gated on the OBJECT resolving as a known class
+      // noun, so an adjective property claim ("zeus is not mortal") keeps
+      // declining exactly as it always has — this widens which NOUN pairs
+      // read as an exclusion, never which property claims do.
+      const singularNegation = retractSrc.match(SINGULAR_NEGATION_TEACH_RE);
+      if (singularNegation && lookupNoun(loadLexicon(), singularNegation[2])) {
+        const [, negationSubject, negationObject] = singularNegation;
+        const negUniversal = await mintNegativeUniversal(negationSubject, negationObject, {
+          memoryDir, sessionId, observedAt, dateText,
+          ackText: `noted — remembered: no ${negationSubject} is a ${negationObject}`,
+        });
+        if (negUniversal) return negUniversal;
+      }
+
       // Nothing stored to disagree with. The gate above is right to refuse
       // storing a bare negative with no positive behind it — but a subject
       // the store has never heard of fell PAST every teach lane onto the
@@ -5830,15 +6112,26 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
   // grounded (or the sentence must fit a specific relation shape) — general
   // vocabulary teaching itself is fully supported (e.g. "Paris is the capital
   // of France" stores directly).
-  const why = unknown.length
-    ? ` I don't recognize ${joinList(unknown.map((w) => `"${w}"`))} as ${unknown.length === 1 ? "a word" : "words"} I know — `
-      + "any vocabulary works, but at least one side of a fact needs to already be grounded to something I "
-      + "know (or fit one of my specific relation shapes), not two brand-new terms at once."
+  //
+  // Both sides ungrounded (pairTerms below) means the grounding hint fires
+  // too, naming the SAME two NPs — so this clause names them at the NP level
+  // as well (residue token -> its containing NP), rather than the raw
+  // per-token parse residue, which can name a narrower slice of the same
+  // phrase ("alphabet" alone out of the object NP "alphabet letter"). One
+  // decline, one consistent pair of unknown terms, never two.
+  const pairTerms = await ungroundedPairTerms(payload, lexicon, memoryDir, cache, graph);
+  const whyTerms = pairTerms && unknown.length ? [pairTerms.subject, pairTerms.object] : unknown;
+  const why = whyTerms.length
+    ? ` I don't recognize ${joinList(whyTerms.map((w) => `"${w}"`))} as ${whyTerms.length === 1 ? "a word" : "words"} I know`
+      + (pairTerms
+        ? "."
+        : " — any vocabulary works, but at least one side of a fact needs to already be grounded to something I "
+          + "know (or fit one of my specific relation shapes), not two brand-new terms at once.")
     : "";
   // Grounding NUDGE: APPENDED, never a replacement, exactly like "did" above
-  // — see ungroundedPairHint's own docblock for why this is scoped to the
+  // — see ungroundedPairTerms' own docblock for why this is scoped to the
   // "both sides ungrounded, fits the X is/are Y shape" case only.
-  const groundingHint = await ungroundedPairHint(payload, lexicon, memoryDir, cache, graph);
+  const groundingHint = pairTerms ? groundingHintText(pairTerms) : "";
   return {
     text: `I couldn't store that —${why} I remember facts in the shape "every X is a Y", where X and Y are `
       + `words I know.${did}${groundingHint} Type /memory to see what I already remember.`,
@@ -6509,6 +6802,7 @@ export async function helpText() {
     ["/export <path>", "write the memory store to a file, as JSONL (the same shape `tmct memory --export` writes)"],
     ["/ingest <path>", "read a local text file and store every fact the recognizer grounds from it (same recognizer as `tmct extract`)"],
     ["remember <X> is a <Y>", "teach a fact in plain English (\"every X is a Y\" and a bare \"X is a Y\" work too)"],
+    ["list <kind>", "list what you've taught under a class (\"list letters\"); \"list facts\" lists memory itself"],
     ["forget that <X> is a <Y>", "withdraw a fact you taught, and anything derived from it — the phrasing the retract lane reads"],
     ["/narrate on|off", "verbose developer/debug mode: decision points, matched pattern, results+sources, goal per turn"],
     ["/wiki on|off|supplement|always", "live Wikipedia (default off): on tries en.wikipedia.org when I can't answer (network), cited; supplement also adds a read-out under every grounded vocabulary answer; always widens that to every grounded answer"],
@@ -6894,11 +7188,15 @@ const SENSE_CITE_RE = / \(source: [^)]*\)$/;
 /** Append an is-a object's superclass chain to its rendered fact line, before
  *  the citation: "rover is a kind of dog" becomes "rover is a kind of dog →
  *  canine → mammal → animal". Only the subject-side is-a lines of the queried
- *  term get a chain; every other line renders unchanged. */
-function renderFactLineWithChain(f, parents, subjectVariants) {
+ *  term get a chain; every other line renders unchanged.
+ *
+ *  `toward` steers the chain toward a specific ancestor (the class a "list …"
+ *  question actually asked about) when the is-a object has more than one
+ *  taught parent. */
+function renderFactLineWithChain(f, parents, subjectVariants, { toward = null } = {}) {
   const base = renderFactLine(f);
   if (!ISA_PREDICATES.has(f.predicate) || !subjectVariants.has(f.subject)) return base;
-  const chain = ancestryChain(f.object, parents, { cap: 6 });
+  const chain = ancestryChain(f.object, parents, { cap: 6, stopAt: ANSWER_STOP_SET, toward });
   if (chain.length <= 1) return base;
   const suffix = ` → ${chain.slice(1).join(" → ")}`;
   const cite = base.match(SENSE_CITE_RE);
@@ -7471,6 +7769,31 @@ const KNOW_ABOUT_RE = /^(?:what\s+do\s+you\s+know\s+about|what(?:'s|s|\s+is)\s+i
 /** How many facts a single answer lists before the remainder is paged with "more". */
 const FACT_ANSWER_CAP = 32;
 
+/** The thing named by an APPOSITION: "the letter p" and "letter p" both name
+ *  p, because the store already holds "p is a letter". Read as one literal
+ *  term instead, the whole phrase matches nothing, so a store that answers
+ *  "what is p" walls on "what is the letter p".
+ *
+ *  A closed rule, not a grammar: the split only stands when a remembered
+ *  isa-fact pairs exactly this class word with exactly this thing, so an
+ *  ordinary multi-word term ("body of water", "task controller") never
+ *  splits. Splits are tried shortest-class-word first and the first confirmed
+ *  one wins, so the answer is a pure function of the fact set rather than of
+ *  row order. Returns the classified term, or null. */
+function apposedFactTerm(term, rows, normFactTerm) {
+  const words = String(term || "").trim().split(/\s+/).filter(Boolean);
+  if (words.length < 2) return null;
+  const isa = rows.filter((f) => ISA_PREDICATES.has(f.predicate));
+  if (!isa.length) return null;
+  for (let take = 1; take < words.length; take += 1) {
+    const kinds = factTermVariants(normFactTerm, words.slice(0, take).join(" "));
+    const thing = words.slice(take).join(" ");
+    const things = factTermVariants(normFactTerm, thing);
+    if (isa.some((f) => things.has(f.subject) && kinds.has(f.object))) return thing;
+  }
+  return null;
+}
+
 /** Five sibling readers closing the gap left
  *  by ISA_ASK_RE's own family: forward yes/no and reverse-by-object shapes for
  *  `mgx:capableOf`, `mgx:hasA`, and the ISA-family predicates. None of these
@@ -8153,7 +8476,19 @@ async function factAnswerReaders(memoryDir, query, envelope, miss, biasByBundle
       subject = focusLabel;
       focusSubstituted = true;
     }
-    const variants = factTermVariants(normFactTerm, subject);
+    let variants = factTermVariants(normFactTerm, subject);
+    // "what is the letter p" names p, not a term spelled "letter p" — see
+    // apposedFactTerm. Tried only where the phrase itself names nothing on
+    // either side of any remembered fact, so a term that already answers keeps
+    // its own answer.
+    const knownRows = await factRows(memoryDir, cache);
+    if (!knownRows.some((f) => variants.has(f.subject) || variants.has(f.object))) {
+      const apposed = apposedFactTerm(subject, knownRows, normFactTerm);
+      if (apposed) {
+        subject = apposed;
+        variants = factTermVariants(normFactTerm, subject);
+      }
+    }
     // factRows (trust+sourceIds-bearing), not the plain memoryFacts shape — the
     // bias-weighted ranking below needs each hit's sourceIds to resolve which
     // bundle it came from (memory/bias.mjs's biasForRow). A live world's secret
@@ -9057,6 +9392,13 @@ const HAS_METHOD_OPEN_RE = /^what\s+methods\s+does\s+([\w'-]+)\s+have[?.!\s]*$/i
  *  cascade/orientation nudge that already handles it. */
 const IS_ADJECTIVE_YESNO_RE = /^(?:is|are|was|were)\s+(.+?)\s+([A-Za-z][\w-]*)[?.!\s]*$/i;
 const IS_ADJECTIVE_PRONOUN_RE = /^(?:it|this|that)$/i;
+/** IS_ADJECTIVE_YESNO_RE's unrestricted backtracking sometimes lands the
+ *  "adjective" capture on a closed-class function word instead of a real
+ *  property — "are there words with the letter p in it" backtracks "it"
+ *  into that slot. A hit here is never a property, so any reader keyed off
+ *  the captured adjective should decline rather than restate the mangled
+ *  parse back at the user. */
+const NON_ADJECTIVE_TOKEN_RE = /^(?:it|them|this|that|in|on|of|to|at)$/i;
 /** A backtracked subject that is really a cross-turn temporal comparison —
  *  a bindable form followed by a comparison word ("that before chat.mjs
  *  was", from "was that before chat.mjs was touched"). The comparison lane
@@ -10103,7 +10445,7 @@ async function factReadBackReaders(memoryDir, query, envelope, miss, graph = nul
       const shown = knownSubjectIsa.slice(0, 3).map(renderFactLine).join("; ");
       const recovery = deeperChainExists
         ? `The facts to settle it are here, but the chain is longer than I follow while answering. Run "/syllogise ${subjectWord}", then ask me again.`
-        : `If it's true, teach me: "${subjectWord} is a kind of ${kindWord}".`;
+        : `If it's true, teach me: "${subjectWord} is a kind of ${kindWord}". If it isn't, teach me: "no ${subjectWord} is a ${kindWord}".`;
       return {
         text: `I can't confirm that — nothing I remember says ${subjectWord} is a ${kindWord}. I do know: ${shown}. ${recovery}`,
         replace: true,
@@ -10119,7 +10461,7 @@ async function factReadBackReaders(memoryDir, query, envelope, miss, graph = nul
       .sort(byTrust)[0];
     if (converseHit) {
       return {
-        text: `I can't confirm that — what I know runs the other way: ${renderFactLine(converseHit)}. A kind doesn't reverse. If it's true, teach me: "every ${subjectWord} is a ${kindWord}".`,
+        text: `I can't confirm that — what I know runs the other way: ${renderFactLine(converseHit)}. A kind doesn't reverse. If it's true, teach me: "every ${subjectWord} is a ${kindWord}". If it isn't, teach me: "no ${subjectWord} is a ${kindWord}".`,
         replace: true,
         miss: true,
       };
@@ -10131,7 +10473,7 @@ async function factReadBackReaders(memoryDir, query, envelope, miss, graph = nul
     if (!ent && !noun && !isPronoun(subjectWord)
       && !rows.some((f) => subjCandidates.has(f.subject) || subjCandidates.has(f.object))) {
       return {
-        text: `I can't confirm that — I don't know "${subjectWord}" at all yet. If it's true, teach me: "${subjectWord} is a kind of ${kindWord}".`,
+        text: `I can't confirm that — I don't know "${subjectWord}" at all yet. If it's true, teach me: "${subjectWord} is a kind of ${kindWord}". If it isn't, teach me: "no ${subjectWord} is a ${kindWord}".`,
         replace: true,
         miss: true,
       };
@@ -10452,6 +10794,13 @@ async function factReadBackReaders(memoryDir, query, envelope, miss, graph = nul
       // originally-intended case here) still gets this receipt exactly as
       // before, since envelope.parsed is null for those adjectives.
       if (rows.some(subjectMatch) && !envelope?.parsed) {
+        // An existential subject ("there words with the letter p in") or a
+        // non-adjective captured token means IS_ADJECTIVE_YESNO_RE backtracked
+        // onto the wrong words — see NON_ADJECTIVE_TOKEN_RE's own docblock.
+        // Restating that parse back ("I don't have a fact saying there words
+        // ... is it") would read as nonsense, so this declines honestly
+        // instead, the same way the empty-store guard above does.
+        if (/^there\b/i.test(subject) || NON_ADJECTIVE_TOKEN_RE.test(adjective)) return null;
         return { text: `I don't have a fact saying ${suggestibleSubjectPhrase(subject)} is ${adjective}.`, replace: true };
       }
       // Without this, "is the checkout flow
@@ -11520,7 +11869,23 @@ async function describeGrainRescue(graph, term) {
   return null;
 }
 
-async function describeWrapperAnswer(query, { config, source, focus, graph, tel = null }) {
+/** apposedFactTerm for the describe lane: the same closed apposition rule,
+ *  plus the two gates a describe target needs. It declines when the phrase
+ *  resolves to a code-map entity of its own, and when memory already holds a
+ *  fact naming the phrase on either side — either way the phrase means itself
+ *  and reading past it would answer a different question. */
+async function apposedDescribeTerm(term, { graph, memoryDir, cache }) {
+  if (!memoryDir || !/\s/.test(String(term || ""))) return null;
+  if (await resolveEntity(graph, term)) return null;
+  let normFactTerm;
+  try { ({ normFactTerm } = await import("../adapters/memory/core.mjs")); } catch { return null; }
+  const rows = await factRows(memoryDir, cache);
+  const variants = factTermVariants(normFactTerm, term);
+  if (rows.some((f) => variants.has(f.subject) || variants.has(f.object))) return null;
+  return apposedFactTerm(term, rows, normFactTerm);
+}
+
+async function describeWrapperAnswer(query, { config, source, focus, graph, memoryDir = null, cache = null, tel = null }) {
   // The detailed-summary/overview phrasings belong to the completions rescue
   // (4e, tried right after this lane) — applyPreambleFrames' show/give-me
   // bridge would otherwise rewrite them into a describe this lane claims
@@ -11563,6 +11928,10 @@ async function describeWrapperAnswer(query, { config, source, focus, graph, tel
       // — resolveSymbol (codegraph.mjs) has no component/overlap tier at all,
       // so a leading "the"/"a"/"an" is pure noise here, safe to strip.
       term = term.replace(/^(?:the|a|an)\s+/i, "");
+      // "tell me about the letter p" describes p — see apposedFactTerm. Tried
+      // only where the phrase names nothing itself, in the code map or in
+      // memory, so a real symbol or a taught multi-word term keeps its answer.
+      term = (await apposedDescribeTerm(term, { graph, memoryDir, cache })) || term;
       // The stale-modifier residue guard, carried into this lane — the last
       // of the 1.4 family without it: "describe the old Task class" must not
       // return the Task card with "old" silently swallowed. The resolver's
@@ -13890,7 +14259,7 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
   // richer answer unmolested. A last-resort rescue, never a competing route:
   // it only claims the turn if /describe actually resolves the captured term.
   if (miss && recordMiss && via === "composed") {
-    const described = await describeWrapperAnswer(query, { config, source, focus: newFocus, graph, tel });
+    const described = await describeWrapperAnswer(query, { config, source, focus: newFocus, graph, memoryDir, cache, tel });
     if (described) {
       answer = described.text; via = described.miss ? "miss" : "describe"; recordMiss = !!described.miss;
       // The composed engine's failed parse above (`via` was still "composed"
@@ -15680,7 +16049,16 @@ async function dispatchTurn(input, { config, source = defaultSource, graph = nul
   // layer, so a forgiving shell answers "stats" the way it answers "/stats" instead
   // of falling through to the generic orientation.
   const bareCmd = asBareCommand(workingLine);
-  if (bareCmd) return withLast(await runCommand(bareCmd, ctx), "use a specific tool/command directly");
+  if (bareCmd) {
+    // "describe the letter p" routes straight to /describe with the whole
+    // phrase as its symbol, so it never reaches the describe-wrapper rescue's
+    // own apposition read. Same rule and the same gates, applied here too.
+    const describeArg = bareCmd.match(/^\/describe\s+(.+)$/i)?.[1];
+    const apposed = describeArg
+      ? await apposedDescribeTerm(describeArg, { graph, memoryDir, cache: factRowsCache })
+      : null;
+    return withLast(await runCommand(apposed ? `/describe ${apposed}` : bareCmd, ctx), "use a specific tool/command directly");
+  }
 
   // GUESS-THE-NUMBER — opening moves, and (with a game standing) the
   // closed-set continuation replies. Checked before the conversational layer
@@ -16053,14 +16431,33 @@ async function dispatchTurn(input, { config, source = defaultSource, graph = nul
       note(trace, `goal: ${goal}`);
       note(trace, "lane: answerMemoryClassQuery — matched a memory-store class noun, answered off the .tmct/memory store's own individuals");
       const turn = plainTurn(workingLine, memClass.text, { via: memClass.miss ? "miss" : "fact", miss: !!memClass.miss, focus });
-      // A bare numeric count ("1 source.") stays silent, matching every other
-      // count lane's tested contract — only a real list enumeration gets the
-      // trailer. answerMemoryClassQuery serves both shapes through one lane.
+      // A bare numeric count ("1 source.") stays silent here — only a real list
+      // enumeration gets the trailer. answerMemoryClassQuery serves both shapes
+      // through one lane. answerTaughtClassCount below is the one count lane that
+      // does NOT stay silent: it appends its own recovery hint pointing at the
+      // list lane, since a taught-class count always has a corresponding "list
+      // <class>" trigger to point at.
       if (!memClass.miss && memClass.kind !== "count") turn.goal = goal;
       if (memClass.pending) turn.detail = { traversal: null, matches: [], pending: memClass.pending };
       return withLast(turn, goal);
     }
   }
+  // "words with the letter p in it" — the store's own vocabulary, filtered by a
+  // letter. Ahead of the count/list lanes: "show me words with the letter p"
+  // otherwise reads as a membership list over a taught class called "words".
+  if (memoryDir) {
+    const lettered = await answerWordsWithLetter(memoryDir, workingLine, factRowsCache);
+    if (lettered) {
+      const goal = "list the words I know that contain a given letter";
+      note(trace, `goal: ${goal}`);
+      note(trace, "lane: answerWordsWithLetter — matched a closed words-containing-a-letter phrasing over the store's own subject/object terms");
+      const turn = plainTurn(workingLine, lettered.text, { via: lettered.miss ? "miss" : "fact", miss: !!lettered.miss, focus });
+      if (!lettered.miss) turn.goal = goal;
+      turn.lane = lettered.miss ? "honest-miss" : "ask-set";
+      if (lettered.pending) turn.detail = { traversal: null, matches: [], pending: lettered.pending };
+      return withLast(turn, goal);
+    }
+  }
   // "how many animals are there" — count a taught class's members, ahead of the
   // quantifier lane (which reads "there" as a second noun and answers "I was never
   // told a quantifier" for the exact same phrasing).
@@ -16087,6 +16484,20 @@ async function dispatchTurn(input, { config, source = defaultSource, graph = nul
       return withLast(turn, goal);
     }
   }
+  // "give me an example of a letter"/"name a letter" — one taught member of a
+  // class rather than the whole enumeration, right next to the list trigger it
+  // shares a class-resolution path with.
+  if (memoryDir) {
+    const memberExample = await answerMembershipExample(memoryDir, workingLine, biasByBundle, factRowsCache);
+    if (memberExample != null) {
+      const goal = "give an example of a taught class's member";
+      note(trace, `goal: ${goal}`);
+      note(trace, "lane: answerMembershipExample — matched 'example of a <noun>'/'name a <noun>' over taught isa-facts whose OBJECT is that class");
+      const turn = plainTurn(workingLine, memberExample.text, { via: memberExample.miss ? "miss" : "fact", miss: !!memberExample.miss, focus });
+      if (!memberExample.miss) turn.goal = goal;
+      return withLast(turn, goal);
+    }
+  }
   // "how many Xs are Ys" — a taught-quantifier RECALL, checked explicitly
   // ahead of answerCount. Its own authority gate declines for anything
   // answerCount should own, so ordinary structural counts are unaffected.