@polycode-projects/the-mechanical-code-talker 3.0.5 → 3.0.7

package/src/services/chat.mjs

@@ -20,7 +20,7 @@
 import { join, dirname } from "node:path";
 import { dispatchTool, loadGraph, TOOLS } from "../tools/server.mjs";
 import { ToolError } from "../adapters/config.mjs";
-import { parseEntities, edgesOfKind, moduleCountOf, renderAuthorCard, renderAuthorTouches, renderCommitAuthor, resolveSymbol, renderCompare } from "../domain/codegraph.mjs";
+import { parseEntities, edgesOfKind, moduleCountOf, packageCounts, modulesOf, renderAuthorCard, renderAuthorTouches, renderCommitAuthor, resolveSymbol, renderCompare } from "../domain/codegraph.mjs";
 import { classDisplayName, DYNAMIC_TAIL_OK_RE } from "../domain/ask.mjs";
 import { emptyRecord as emptyDiscourseRecord, advanceTurn as advanceDiscourseTurn, register as registerReferent, bind as bindDiscourseForm } from "../domain/discourse.mjs";
 import { uuidv7 } from "../adapters/uuid.mjs";
@@ -273,9 +273,12 @@ function withNarration(result, trace, fallbackGoal) {
  *  above. Appending (not prepending) keeps the many tests that pin composed
  *  answers with a start-anchored regex intact.
  *
- *  `result.goal` is set by runAsk and by runCommand's own mk()
- *  (GOAL_BY_COMMAND, below); a plain count or a teach confirmation never
- *  carries the field, so this is a no-op for those turn types by
+ *  `result.goal` is set by runAsk, by runCommand's own mk()
+ *  (GOAL_BY_COMMAND, below), and by the plainTurn call sites that already
+ *  hold a precise goal string (a teach confirmation, a taxonomy/SKOS or
+ *  memory-store lookup, a plan-lane step, and runAsk's own honest-decline
+ *  early returns). A plain numeric count is the one turn type that stays
+ *  silent — it never sets the field, so this is a no-op there by
  *  construction. Also a no-op when `result.goal` is null/empty, so an
  *  unclear turn never grows a "Goal (inferred): unclear" line.
  *
@@ -459,6 +462,7 @@ const COUNT_NOUNS = {
   class: "Class", classes: "Class",
   function: "Function", functions: "Function", func: "Function", funcs: "Function",
   module: "Module", modules: "Module", file: "Module", files: "Module",
+  package: "Package", packages: "Package",
   method: "Method", methods: "Method",
   attribute: "Attribute", attributes: "Attribute",
   variable: "GlobalVariable", variables: "GlobalVariable", global: "GlobalVariable", globals: "GlobalVariable",
@@ -469,18 +473,25 @@ const COUNT_NOUNS = {
 /** class → [singular, plural] display noun, for echoing a count back in English. */
 const CLASS_LABELS = {
   Class: ["class", "classes"], Function: ["function", "functions"],
-  Module: ["module", "modules"], Method: ["method", "methods"],
+  Module: ["module", "modules"], Package: ["package", "packages"],
+  Method: ["method", "methods"],
   Attribute: ["attribute", "attributes"], GlobalVariable: ["variable", "variables"],
   Commit: ["commit", "commits"], Session: ["session", "sessions"],
 };
 const classNoun = (cls, n) => { const [s, p] = CLASS_LABELS[cls] || [cls, `${cls}s`]; return n === 1 ? s : p; };
 
-/** Count individuals of a class in the loaded graph (live, not the header field). */
-const countClass = (graph, cls) => graph.individuals.filter((i) => (i.class || "") === cls).length;
+/** Count individuals of a class in the loaded graph (live, not the header field).
+ *  No individual is ever stored with class "Package" — packages are the
+ *  directories grouping the modules, derived the same way the architecture map
+ *  derives them. */
+const countClass = (graph, cls) => (cls === "Package"
+  ? packageCounts(modulesOf(graph)).size
+  : graph.individuals.filter((i) => (i.class || "") === cls).length);
 
 /** The classes this graph can actually count, as a human list ("classes, functions, …"). */
 function countableKinds(graph) {
   const present = new Set(graph.individuals.map((i) => i.class).filter(Boolean));
+  if (present.has("Module")) present.add("Package");
   return Object.keys(CLASS_LABELS).filter((c) => present.has(c)).map((c) => CLASS_LABELS[c][1]);
 }
 
@@ -917,7 +928,7 @@ async function answerMemoryClassQuery(memoryDir, query) {
   let mem;
   try { mem = await loadMemory(memoryDir); } catch { return null; }
   const inds = (mem.individuals || []).filter((i) => (i.class || "") === cls);
-  if (countM) return { text: `${inds.length} ${inds.length === 1 ? plural.replace(/s$/, "") : plural}.` };
+  if (countM) return { text: `${inds.length} ${inds.length === 1 ? plural.replace(/s$/, "") : plural}.`, kind: "count" };
   if (!inds.length) return { text: `I don't have any ${plural} stored yet.`, miss: true };
   const factByLabel = cls === "Fact" ? new Map(readFactRows(mem).map((r) => [r.id, r])) : new Map();
   const lines = inds.map((ind) => memoryClassLine(cls, ind, factByLabel));
@@ -1076,13 +1087,15 @@ const CAPABILITY_PHRASES = [
   /^(?:what(?:'s|s|\s+is)|give me|show me|gimme) the big picture(?:\s+(?:here|(?:on|of|for|about)\s+(?:this|the)\s+(?:app|codebase|repo|repository|project|code)))?\??$/i,
   /^(?:give me|what's) the lay of the land\??$/i,
   // "give me an overview" / "an overview" — the plain-word sibling of "the
-  // big picture" just above, same optional here/of-this-repo tail. Without a
-  // closed entry the word "overview" prose-matches real symbols in an
-  // indexed graph (moduleOverviewText) and the describe rescue dumps that
-  // symbol's card. The detailed forms ("give me a detailed overview of X")
-  // carry a mandatory "detailed"+of-term and stay with the completions
-  // rescue, untouched by this anchor.
-  /^(?:(?:can|could|would) you\s+)?(?:give me|show me|gimme)\s+an overview(?:\s+(?:here|(?:on|of|for|about)\s+(?:this|the)\s+(?:app|codebase|repo|repository|project|code)))?\??$/i,
+  // big picture" just above. Without a closed entry the word "overview"
+  // prose-matches real symbols in an indexed graph (moduleOverviewText) and
+  // the describe rescue dumps that symbol's card. The detailed forms ("give
+  // me a detailed overview of X") carry a mandatory "detailed"+of-term and
+  // stay with the completions rescue, untouched by this anchor. An explicit
+  // of-this-repo tail is NOT matched here: that names the repo as the
+  // subject, so ARCH_OVERVIEW_PHRASES answers it with the architecture map
+  // instead of this card.
+  /^(?:(?:can|could|would) you\s+)?(?:give me|show me|gimme)\s+an overview(?:\s+here)?\??$/i,
   /^an overview(?:\s+please)?\??$/i,
   // "what have we got here"/"what've we got here" — a casual, self-answering
   // opener (matches after a leading "so" strips via LEADING_CONNECTIVE_RE,
@@ -1560,15 +1573,8 @@ const BYE = new Set([
   "bye", "goodbye", "quit", "exit", "see ya", "see you", "cya", "later", "farewell",
   "peace", "peace out", "im off", "i'm off", "gtg", "gotta go", "catch you later",
   "farewell then",
-  // "gtg thx" — the SAME "gtg" farewell above, immediately followed by a
-  // thanks word with no delimiter between them (so farewellOrThanksSignal's
-  // comma/semicolon clause split never sees two clauses to work with).
-  // Whole-phrase entry rather than a general "bye word + thanks word, no
-  // delimiter" mechanism — closed and hand-curated, this exact reported
-  // phrasing only.
-  "gtg thx",
   // "good day to you" deliberately does NOT live here: it's a formal-register
-  // GREETING, not a farewell. foldedBye is checked before GREET in
+  // GREETING, not a farewell. farewellClause is checked before GREET in
   // conversationalTurn, so having it here would silently end the session on
   // a plain formal greeting — every turn piped after it dropped with no log
   // entry, a worse outcome than any wall.
@@ -1674,15 +1680,39 @@ const CLAUSE_SPLIT_RE = /\s*[,;]\s*(?:and\s+)?|\s+and\s+/;
 function conversationalClauses(q) {
   return q.split(CLAUSE_SPLIT_RE).map((c) => c.trim()).filter(Boolean);
 }
-/** BYE match tolerant of informal reduplication ("bye bye", "no no" — general,
- *  not specific to any one word): a clause consisting of the SAME word twice
- *  folds to one instance before the ordinary closed/collapsed BYE lookup.
- *  Shared by the single-clause whole-line check and the multi-clause scan
- *  below, so "bye bye" resolves the same way whether or not a comma follows it. */
-function foldedBye(clause) {
+/** A thanks phrase and a bye phrase butted together with NO delimiter between
+ *  them, in either order ("gtg thx", "thanks bye"). conversationalClauses
+ *  splits on a comma, semicolon or a standalone "and", so these lines arrive
+ *  as one clause and match neither closed set whole. Splitting at each word
+ *  boundary and matching the two halves against their own sets keeps both
+ *  halves closed — no new literal, and no phrase is recognized here that
+ *  isn't already recognized alone. Without this the leading thanks word reads
+ *  as a bare subject noun and the farewell reads as its verb, so "thanks bye"
+ *  parses as a habitual-teach ("a thank can bye"). */
+function gluedThanksBye(clause) {
+  const words = clause.split(/\s+/).filter(Boolean);
+  for (let split = 1; split < words.length; split += 1) {
+    const head = words.slice(0, split).join(" ");
+    const tail = words.slice(split).join(" ");
+    const headIsBye = !!closedOrCollapsed(head, BYE, BYE_COLLAPSED);
+    const tailIsBye = !!closedOrCollapsed(tail, BYE, BYE_COLLAPSED);
+    const headIsThanks = !!closedOrCollapsed(head, THANKS, THANKS_COLLAPSED);
+    const tailIsThanks = !!closedOrCollapsed(tail, THANKS, THANKS_COLLAPSED);
+    if ((headIsBye && tailIsThanks) || (headIsThanks && tailIsBye)) return true;
+  }
+  return false;
+}
+/** Does this clause end the session? The closed BYE set, or informal
+ *  reduplication of one of its entries ("bye bye", "no no" — general, not
+ *  specific to any one word), or a thanks word glued to a bye word. Shared by
+ *  the single-clause whole-line check and the multi-clause scan below, so
+ *  "bye bye" resolves the same way whether or not a comma follows it. Bye wins
+ *  over thanks: a farewell should end the session even alongside gratitude. */
+function farewellClause(clause) {
   if (closedOrCollapsed(clause, BYE, BYE_COLLAPSED)) return true;
   const folded = clause.match(REPEATED_WORD_RE);
-  return !!(folded && closedOrCollapsed(folded[1], BYE, BYE_COLLAPSED));
+  if (folded && closedOrCollapsed(folded[1], BYE, BYE_COLLAPSED)) return true;
+  return gluedThanksBye(clause);
 }
 /** Closing-filler clauses — the CONTENT half of a farewell/thanks sentence
  *  ("thanks, that's everything for now") that isn't itself gratitude or bye
@@ -1736,7 +1766,7 @@ function farewellOrThanksSignal(raw, q) {
     const rawClause = clauses[i];
     const ackMatch = rawClause.match(ACK_LEAD_RE);
     const clause = ackMatch ? ackMatch[1].trim() : rawClause;
-    if (foldedBye(clause)) { byeHit = true; break; }
+    if (farewellClause(clause)) { byeHit = true; break; }
     const deIntensified = clause.replace(THANKS_HELP_TAIL_RE, "").replace(TRAILING_INTENSIFIER_RE, "").trim();
     if (thanksClauseIdx < 0 && closedOrCollapsed(deIntensified, THANKS, THANKS_COLLAPSED)) thanksClauseIdx = i;
   }
@@ -1874,9 +1904,9 @@ function conversationalTurn(line, ctx) {
       ...(end ? { end: true } : {}),
     }, ctx.trace);
   };
-  if (foldedBye(q)) {
+  if (farewellClause(q)) {
     note(ctx.trace, "goal: casual/social — ending the session (no graph intent)");
-    note(ctx.trace, "lane: conversational — farewell (BYE closed set, incl. bare reduplication e.g. \"bye bye\")");
+    note(ctx.trace, "lane: conversational — farewell (BYE closed set, incl. bare reduplication e.g. \"bye bye\" and a thanks word glued to a bye word e.g. \"thanks bye\")");
     return mk(t(T_FAREWELL), { end: true });
   }
   {
@@ -2746,6 +2776,20 @@ async function teachFact(memoryDir, sessionId, { subject, predicate, object, qua
 // are Ys" recall. Deliberately NARROW: only the SUBJECT gets a free pass past
 // parseAce's closed lexicon-noun gate, never the OBJECT. ----
 
+/** Singular nouns that already END in a bare sibilant "-s" and so form their
+ *  plural with "-es" (bus -> buses, gas -> gases, lens -> lenses). When a
+ *  "-ses" word strips two letters onto one of these, the "-es" was the plural
+ *  marker and the stem is correct; every OTHER "-ses" word kept a silent "-e"
+ *  and singularizes by stripping one letter (see singularizeSurface). Doubled
+ *  "-ss" stems (class, glass, boss) are caught by pattern, so only single-"s"
+ *  stems need listing here. */
+const BARE_SIBILANT_S_NOUNS = new Set([
+  "bus", "gas", "plus", "minus", "surplus", "lens", "bias", "atlas", "canvas",
+  "virus", "bonus", "campus", "census", "chorus", "circus", "focus", "status",
+  "iris", "genius", "sinus", "walrus", "cactus", "fungus", "radius", "nucleus",
+  "alias", "crocus", "abacus", "syllabus", "octopus", "platypus",
+]);
+
 /** Naive plural → singular fold for the "some/a few Xs are Ys" surface forms
  *  (mirrors factTermVariants' own naive -es/-s stripping, below, but returns
  *  ONE canonical spelling to STORE rather than a lookup Set of candidates to
@@ -2763,11 +2807,27 @@ async function teachFact(memoryDir, sessionId, { subject, predicate, object, qua
 function singularizeSurface(word) {
   const w = String(word || "").trim();
   if (/[a-z]ies$/i.test(w)) return `${w.slice(0, -3)}y`;
-  if (/(ses|xes|zes|ches|shes)$/i.test(w)) return w.slice(0, -2);
+  if (/[a-z]ses$/i.test(w)) {
+    // "-ses" is genuinely ambiguous. A base already ending in "-se" just adds
+    // "-s" (collapse -> collapses, cause -> causes, rose -> roses), so the
+    // singular strips ONE letter. A base ending in a bare sibilant "-s" adds
+    // "-es" (bus -> buses, class -> classes, lens -> lenses), so the singular
+    // strips TWO. Spelling alone can't separate every pair, so strip two only
+    // when the two-char strip lands on a doubled "-ss" or a known bare-sibilant
+    // "-s" noun; otherwise the base kept its silent "-e" and one letter comes
+    // off. The other "-es" endings (-xes/-zes/-ches/-shes) keep the plain
+    // two-char strip below.
+    const stem = w.slice(0, -2);
+    if (/ss$/i.test(stem) || BARE_SIBILANT_S_NOUNS.has(stem.toLowerCase())) return stem;
+    return w.slice(0, -1);
+  }
+  if (/(xes|zes|ches|shes)$/i.test(w)) return w.slice(0, -2);
   if (/[a-z]s$/i.test(w) && !/(?:ss|ous)$/i.test(w)) return w.slice(0, -1);
   return w;
 }
 
+export { singularizeSurface };
+
 /** "(every|each|all|a|an )?X is/are (a|an )?Y" — the shape the unknown-subject
  *  fallback recognizes (group 2 = X, group 4 = Y); group 1 (when present)
  *  names the determiner, so the caller can tell a genuine "every" universal
@@ -2862,22 +2922,27 @@ async function isGroundedByFact(term, memoryDir, cache = null) {
 }
 
 /** Shared "is this term grounded in ANY sense" aggregate — a static lexicon
- *  word (any part of speech, via `classify`), a GENERIC_ANCHOR_NOUNS root, OR
- *  a term already anchored by a previously taught isa-family fact
- *  (isGroundedByFact, above). Used by unknownObjectFallback's subject/object
- *  groundedness checks below, where no part-of-speech branching follows —
- *  just "known or not". (unknownSubjectFallback's own object-known check,
- *  above/below, stays narrower and NOUN-specific — see its own comment — so
- *  an object that's merely a known ADJECTIVE doesn't get misrouted into the
- *  class/subClassOf branch instead of the property branch.) */
-async function isGroundedTerm(term, lex, memoryDir, cache = null) {
+ *  word (any part of speech, via `classify`), a GENERIC_ANCHOR_NOUNS root, a
+ *  term already anchored by a previously taught isa-family fact
+ *  (isGroundedByFact, above), OR — when a code graph is supplied — a symbol
+ *  the code graph itself resolves (resolveSymbol, codegraph.mjs — the SAME
+ *  resolver /describe/`/members`/`/subclasses` already use, so "known to
+ *  describe" and "known to teach" can never disagree). Used by
+ *  unknownObjectFallback's subject/object groundedness checks below, where no
+ *  part-of-speech branching follows — just "known or not". (unknownSubjectFallback's
+ *  own object-known check, above/below, stays narrower and NOUN-specific — see
+ *  its own comment — so an object that's merely a known ADJECTIVE doesn't get
+ *  misrouted into the class/subClassOf branch instead of the property branch.) */
+async function isGroundedTerm(term, lex, memoryDir, cache = null, graph = null) {
   const raw = String(term ?? "").trim();
   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;
+  if (graph && resolveSymbol(graph, raw)?.match) return true;
   return isGroundedByFact(raw, memoryDir, cache);
 }
+export { isGroundedTerm };
 
 /** The "both sides ungrounded" grounding NUDGE: reuses teachSuggestion's own
  *  "compute a hint, APPEND it to the existing honest-miss message, never
@@ -2899,15 +2964,15 @@ async function isGroundedTerm(term, lex, memoryDir, cache = null) {
  *  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) {
+async function ungroundedPairHint(payload, lexicon, memoryDir, cache = null, graph = null) {
   if (!memoryDir) return "";
   const m = String(payload).trim().match(UNKNOWN_SUBJECT_RE);
   if (!m) return "";
   const [, , subjectRaw, , objectRaw] = m;
   const { loadLexicon } = await import("../domain/grammar/lexicon.mjs");
   const lex = lexicon || loadLexicon();
-  if (await isGroundedTerm(subjectRaw, lex, memoryDir, cache)) return "";
-  if (await isGroundedTerm(objectRaw, lex, memoryDir, cache)) return "";
+  if (await isGroundedTerm(subjectRaw, lex, memoryDir, cache, graph)) return "";
+  if (await isGroundedTerm(objectRaw, lex, memoryDir, cache, graph)) return "";
   // 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
@@ -3070,7 +3135,7 @@ async function objectReadsAsNonNoun(word) {
     return false;
   }
 }
-async function unknownObjectFallback(payload, { memoryDir, sessionId, lexicon, classIntent = false }, cache = null) {
+async function unknownObjectFallback(payload, { memoryDir, sessionId, lexicon, classIntent = false, graph = null }, cache = null) {
   if (!memoryDir) return null;
   const m = String(payload).trim().match(UNKNOWN_SUBJECT_RE);
   if (!m) return null;
@@ -3084,9 +3149,9 @@ async function unknownObjectFallback(payload, { memoryDir, sessionId, lexicon, c
   if (!/^(?:every|each|all|any)$/i.test((det || "").trim()) && !classIntent) return null; // class-level mint needs a universal quantifier or an explicit kind-of infix
   const { loadLexicon, lookupNoun } = await import("../domain/grammar/lexicon.mjs");
   const lex = lexicon || loadLexicon();
-  const subjectGrounded = await isGroundedTerm(subjectRaw, lex, memoryDir, cache);
+  const subjectGrounded = await isGroundedTerm(subjectRaw, lex, memoryDir, cache, graph);
   if (!subjectGrounded) return null; // ungrounded subject isn't this fallback's asymmetry — never a guessed mint
-  const objectGrounded = await isGroundedTerm(objectRaw, lex, memoryDir, cache);
+  const objectGrounded = await isGroundedTerm(objectRaw, lex, memoryDir, cache, graph);
   if (objectGrounded) return null; // object already known — nothing to mint
   if (await objectReadsAsNonNoun(objectRaw)) return null; // reads like an adjective/verb, not a class noun — defer to unknownAdjectiveFallback
   const quantifier = /^every$/i.test((det || "").trim()) ? "every" : "";
@@ -3168,7 +3233,7 @@ async function unknownObjectFallback(payload, { memoryDir, sessionId, lexicon, c
  *  otherwise provide. "the cache is bespoke" and "Mary is female" both carry
  *  one of those signals (the leading "the", and capitalization,
  *  respectively); "module is banana" carries none. */
-async function unknownAdjectiveFallback(payload, { memoryDir, sessionId, lexicon }, cache = null) {
+async function unknownAdjectiveFallback(payload, { memoryDir, sessionId, lexicon, graph = null }, cache = null) {
   if (!memoryDir) return null;
   const m = String(payload).trim().match(UNKNOWN_SUBJECT_RE);
   if (!m) return null;
@@ -3201,7 +3266,7 @@ async function unknownAdjectiveFallback(payload, { memoryDir, sessionId, lexicon
   // a noun-shaped Y was already minted as a class upstream and never reaches
   // this point.
   const universalQuantifier = /^(?:every|each|all|any)$/i.test((det || "").trim());
-  if (universalQuantifier && (await isGroundedTerm(subjectRaw, lex, memoryDir, cache))
+  if (universalQuantifier && (await isGroundedTerm(subjectRaw, lex, memoryDir, cache, graph))
     && (lookupAdjective(lex, objectRaw) || (await objectReadsAsNonNoun(objectRaw)))) {
     const classSubject = /^are$/i.test(verb)
       ? (lookupNoun(lex, subjectRaw)?.lemma || singularizeSurface(subjectRaw))
@@ -3868,8 +3933,27 @@ const HABITUAL_VERB_EXCLUDE = new Set([
   "please", "thanks", "kindly", "anyway", "though", "indeed", "maybe",
   "perhaps", "still", "too", "also", "instead", "now", "then", "here", "there",
 ]);
+/** Sentence-initial ordinal/temporal discourse adverbs — the "First", "Then",
+ *  "Next" … that thread a narrative across sentences without belonging to the
+ *  clause they lead. A closed set: a connective in this slot carries sequence,
+ *  not content, so stripping it lets "First a cell grows." read as the same
+ *  capability teach the bare "a cell grows." already does. */
+const LEADING_DISCOURSE_ADVERBS = [
+  "first", "second", "third", "then", "next", "finally",
+  "later", "meanwhile", "afterward", "afterwards",
+];
+const LEADING_DISCOURSE_ADVERB_RE = new RegExp(
+  `^(?:${LEADING_DISCOURSE_ADVERBS.join("|")})\\b\\s*,?\\s+`, "i",
+);
+/** Strip one leading ordinal/temporal discourse adverb (case-insensitive,
+ *  optional trailing comma) from the start of `text`, leaving the clause that
+ *  followed it. A word not in the closed set, or one with no clause after it,
+ *  is left untouched. */
+export function stripLeadingDiscourseAdverb(text) {
+  return String(text || "").trim().replace(LEADING_DISCOURSE_ADVERB_RE, "");
+}
 function matchBareHabitualTeach(text) {
-  const t = String(text || "").trim();
+  const t = stripLeadingDiscourseAdverb(String(text || "").trim());
   const plural = t.match(/^(?:all\s+|every\s+)?([\w-]+s)\s+([a-z][\w-]*)[.!?]*$/i);
   if (plural && !STRUCT_WORDS.has(plural[2].toLowerCase()) && !HABITUAL_VERB_EXCLUDE.has(plural[2].toLowerCase()) && !/[^s]s$/i.test(plural[2])) {
     const subject = singularizeSurface(plural[1].toLowerCase());
@@ -4360,7 +4444,7 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
   if (memoryDir && !QUESTION_LEAD_RE.test(conjSrc) && /\s+and\s+/i.test(conjSrc)
     && !(await hasMidSentenceInterrogative(conjSrc))) {
     const rewrap = (half) => (wrapped != null ? `remember that ${half}` : half);
-    const recurse = (half) => teachLane(rewrap(half), { memoryDir, sessionId, lexicon, cache, planHolder, gameConfig });
+    const recurse = (half) => teachLane(rewrap(half), { memoryDir, sessionId, lexicon, cache, planHolder, graph, gameConfig });
     const stripNoted = (t) => String(t).replace(/^noted — remembered(?:\s+\d+\s+facts?)?:\s*/i, "").trim();
     const shared = conjSrc.match(/^(.+?)\s+and\s+((?:is|are|has|have|can)\b.+)$/i);
     const sharedSubject = shared ? shared[1].match(/^(.+?)\s+(?:is|are|has|have|can)\b/i)?.[1]?.trim() : null;
@@ -5145,7 +5229,7 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
       if (canShape && canSingular !== canShape.subject) {
         let canLex = lexicon;
         if (!canLex) { const { loadLexicon } = await import("../domain/grammar/lexicon.mjs"); canLex = loadLexicon(); }
-        if (await isGroundedTerm(canSingular, canLex, memoryDir, cache)) {
+        if (await isGroundedTerm(canSingular, canLex, memoryDir, cache, graph)) {
           const stored = await teachFact(memoryDir, sessionId, {
             subject: canSingular, predicate: await capabilityPredicate(canShape.negated), object: canShape.verb,
           });
@@ -5273,7 +5357,7 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
       // every query-side variant fold) uses; a proper noun that only looks
       // plural ("redis") falls back to its own spelling.
       for (const subj of new Set([singularizeSurface(habitualTeach.subject), habitualTeach.subject])) {
-        if (await isGroundedTerm(subj, habLex, memoryDir, cache)) {
+        if (await isGroundedTerm(subj, habLex, memoryDir, cache, graph)) {
           const stored = await teachFact(memoryDir, sessionId, {
             subject: subj, predicate: await capabilityPredicate(habitualTeach.negated), object: habitualTeach.verb,
           });
@@ -5294,7 +5378,7 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
     // STATIC lexicon (or a prior taught fact) already grounds can mint a
     // brand-new object term. See unknownObjectFallback's own docblock for the
     // exact narrowing rules (the "both sides ungrounded" safety guard, etc.).
-    const objectFallback = await unknownObjectFallback(payload, { memoryDir, sessionId, lexicon, classIntent: kindOfClassIntent }, cache);
+    const objectFallback = await unknownObjectFallback(payload, { memoryDir, sessionId, lexicon, classIntent: kindOfClassIntent, graph }, cache);
     if (objectFallback) return objectFallback;
     // ADJECTIVE-MINT fallback: tried right after unknownObjectFallback
     // declines, so a grounded subject (static
@@ -5303,7 +5387,7 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
     // docblock for the exact narrowing rules (the "both sides ungrounded"
     // safety guard, and why this must be a standalone function rather than
     // nested inside unknownSubjectFallback).
-    const adjectiveFallback = await unknownAdjectiveFallback(payload, { memoryDir, sessionId, lexicon }, cache);
+    const adjectiveFallback = await unknownAdjectiveFallback(payload, { memoryDir, sessionId, lexicon, graph }, cache);
     if (adjectiveFallback) return adjectiveFallback;
     // PROPERTY teach — "remember/note that <X> is <adjective>": wrapper-REQUIRED
     // (a bare "X is deprecated" is never silently reified), and only after the
@@ -5366,7 +5450,7 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
   // Grounding NUDGE: APPENDED, never a replacement, exactly like "did" above
   // — see ungroundedPairHint's 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);
+  const groundingHint = await ungroundedPairHint(payload, lexicon, memoryDir, cache, graph);
   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.`,
@@ -6639,7 +6723,7 @@ function suggestibleSubjectPhrase(subject) {
  *  take the article. */
 const QUANTIFIER_LEAD_RE = /^(?:every|each|all|any)\s+/i;
 
-function factTermVariants(normFactTerm, term) {
+export function factTermVariants(normFactTerm, term) {
   const t = normFactTerm(term);
   const v = new Set();
   // The ask frames glue a quantifier onto the subject and looked up "every
@@ -8383,7 +8467,7 @@ const CARD_EXISTENCE_ASK_RE = /^does\s+an?\s+(.+?)\s+have\s+an?\s+(.+?)[?.!\s]*$
 /** The 4 pattern-5 cardinality-restriction predicates buildCardinalityRestrictions
  *  reconstructs from — owl:onProperty (shared scaffolding with someValuesFrom
  *  restrictions too) is added alongside this set by each reader below, not
- *  folded into it here, mirroring infbench/grade.mjs's own identically-named
+ *  folded into it here, mirroring test-benchmarks/infbench/grade.mjs's own identically-named
  *  set + separate owl:onProperty handling. */
 const CARDINALITY_ROW_PREDICATES = new Set(["owl:cardinality", "owl:minCardinality", "owl:maxCardinality", "owl:onClass"]);
 /** "who owns <X>" / "who maintains <X>" — the closed ownership read-back over
@@ -11158,7 +11242,7 @@ async function conceptForceAnswer(query, envelope, { graph, config, source, memo
   const definition = (await seonDefinitions()).get(term) ?? null;
   if (!definition) return null;
   // The runChat shell hands the loaded graph straight in; the pure runTurn(config)
-  // path (tests, chatbench) does not, so load it the same way dispatchTool does when
+  // path (tests, test-benchmarks/chatbench) does not, so load it the same way dispatchTool does when
   // it's missing. Failure-tolerated: no loadable graph → no concept force.
   let g = graph;
   if (!g && config && source) {
@@ -11927,6 +12011,15 @@ const MOVE_HISTORY_RE = /^where\s+did\s+(.+?)\s+(?:move|get\s+moved|go)(?:\s+to)
  *  the honest miss. */
 const TEMPORAL_COMPARISON_RE = /^(?:was|is)\s+(this one|that one|it|this|that)\s+(before|after)\s+(.+?)\s+(?:was|were)\s+(touched|changed|modified|edited|updated)[?.!\s]*$/i;
 
+/** "were those before logger.mjs was touched" — the plural sibling of
+ *  TEMPORAL_COMPARISON_RE. A plural bindable form (`those`/`them`/`these`)
+ *  binds a `set` referent a listing/filter answer established, and the
+ *  comparison runs over the whole set: each member is dated from the graph,
+ *  and the answer quantifies (all / none / M of N) rather than forcing one
+ *  date. A set whose members are not all datable refuses, the same honest
+ *  miss the singular lane takes on an undated referent. */
+const PLURAL_TEMPORAL_COMPARISON_RE = /^(?:were|are)\s+(those|them|these)\s+(before|after)\s+(.+?)\s+(?:was|were)\s+(touched|changed|modified|edited|updated)[?.!\s]*$/i;
+
 /** ARCHITECTURE-OVERVIEW intent — "show me the architecture", "what is the
  *  architecture of this repo": the whole-repo map the /arch command renders.
  *  A closed phrase set, because the literal word "architecture" is also a
@@ -11937,12 +12030,17 @@ const TEMPORAL_COMPARISON_RE = /^(?:was|is)\s+(this one|that one|it|this|that)\s
  *  an of-this-repo tail, or an overview/map noun); a query that NAMES a
  *  symbol ("describe renderArchitecture") never matches. */
 const ARCH_OVERVIEW_LEAD = "(?:(?:can|could|would)\\s+you\\s+(?:please\\s+)?)?(?:(?:show|give)\\s+(?:me|us)\\s+|describe\\s+|explain\\s+|what(?:'s|s|\\s+is)\\s+)?";
-const ARCH_OVERVIEW_TAIL = "(?:\\s+(?:of|for)\\s+(?:this|the)\\s+(?:app|codebase|repo|repository|project|code))?";
+const ARCH_OVERVIEW_OF_REPO = "(?:of|for)\\s+(?:this|the)\\s+(?:app|codebase|repo|repository|project|code)";
+const ARCH_OVERVIEW_TAIL = `(?:\\s+${ARCH_OVERVIEW_OF_REPO})?`;
 const ARCH_OVERVIEW_PHRASES = [
   // Article-carried: "the architecture" alone, or wrapped/tailed.
   new RegExp(`^${ARCH_OVERVIEW_LEAD}the\\s+architecture(?:\\s+(?:overview|map|diagram))?${ARCH_OVERVIEW_TAIL}(?:\\s+here)?\\??$`, "i"),
   // Article-less: anchored by the of-this-repo tail or the overview/map noun instead.
-  new RegExp(`^${ARCH_OVERVIEW_LEAD}architecture\\s+(?:(?:of|for)\\s+(?:this|the)\\s+(?:app|codebase|repo|repository|project|code)|overview|map|diagram)\\??$`, "i"),
+  new RegExp(`^${ARCH_OVERVIEW_LEAD}architecture\\s+(?:${ARCH_OVERVIEW_OF_REPO}|overview|map|diagram)\\??$`, "i"),
+  // Architecture-less: the topic noun stands in for the word, so the of-this-repo
+  // tail is REQUIRED here. A bare "give me an overview" names no subject and
+  // falls through to the ordinary lanes.
+  new RegExp(`^${ARCH_OVERVIEW_LEAD}(?:(?:an?|the)\\s+)?(?:overview|map|diagram)\\s+${ARCH_OVERVIEW_OF_REPO}(?:\\s+here)?\\??$`, "i"),
 ];
 
 async function runAsk(query, { config, source, graph, focus, last, templates, memoryDir, sessionId = "", lexicon = null, env, trace, vocabHint = null, tel = null, biasByBundle = {}, cache = null, vocabAntecedent = null, planHolder = null, discourseHolder = null, gameConfig = DEFAULT_GAME_CONFIG, liveReference = false, onLiveLookup = null, uiContext = "cli", synthesisBudget = AUTO_SYNTHESIS_BUDGET }) {
@@ -11955,9 +12053,19 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
   // them" filters or counts the PREVIOUS answer's entity set, threaded as
   // ask()'s `prev`. Prefers the FULL id set (`allIds`) over `matches`, since a
   // concept-force listing caps `matches` at MAX_EXAMPLES.
-  const prev = (last?.detail?.allIds && last.detail.allIds.length)
+  let prev = (last?.detail?.allIds && last.detail.allIds.length)
     ? last.detail.allIds.filter(Boolean)
     : (last?.detail?.matches || []).map((m) => m?.id).filter(Boolean);
+  // A count erases its own matches to [], so the previous turn carries no id
+  // set for the next "which of those" to narrow. When the carry is empty, fall
+  // back to the session record: a standing `set` referent that "those" binds
+  // keeps a narrowed set alive across a counting hop. No same-turn plural tie
+  // is reachable yet (no lane registers two set referents in one turn), so this
+  // probe needs no tie refusal.
+  if (!prev.length && discourseHolder) {
+    const boundSet = bindDiscourseForm(discourseHolder.record, "those");
+    if (boundSet?.referent?.ids?.length) prev = boundSet.referent.ids.filter(Boolean);
+  }
   // The query the ENGINE parses: a "what about X" continuation is rewritten to the
   // prior shape with X swapped in; everything else parses verbatim. The record and
   // transcript keep the user's ACTUAL words (`query`), only the parse target changes.
@@ -11992,12 +12100,17 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
     if (cmp) {
       const [, form, cmpOp, clauseSubject, participle] = cmp;
       const verb = participle.toLowerCase();
+      const temporalGoal = "compare a prior answer's dated referent against a freshly read event (cross-turn temporal composition)";
       const refMiss = (text) => {
-        note(trace, "goal: compare a prior answer's dated referent against a freshly read event (cross-turn temporal composition)");
+        note(trace, `goal: ${temporalGoal}`);
         note(trace, `lane: TEMPORAL_COMPARISON_RE — "${form}" could not compose a comparison; a specific miss names why, never the teach-offer cascade`);
-        return plainTurn(query, text, { via: "miss", miss: true, focus });
+        return plainTurn(query, text, { via: "miss", miss: true, focus, goal: temporalGoal });
       };
-      const bound = discourseHolder ? bindDiscourseForm(discourseHolder.record, form) : null;
+      const bound = discourseHolder ? bindDiscourseForm(discourseHolder.record, form, { tieRefuses: true }) : null;
+      if (bound?.tie) {
+        const options = joinOr(bound.tie.map((r) => r.label));
+        return refMiss(`"${form}" could mean ${options} — which do you mean?`);
+      }
       if (!bound?.referent) {
         return refMiss(`I don't have a referent for "${form}" yet — nothing answered earlier in this conversation binds it. Ask about the event first (e.g. "when was ${clauseSubject} last ${verb}"), then ask the comparison again.`);
       }
@@ -12021,14 +12134,88 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
       const holds = cmpOp.toLowerCase() === "before" ? refDay < clauseDay : refDay > clauseDay;
       const relation = refDay < clauseDay ? "came before" : refDay > clauseDay ? "came after" : "landed on the same day as";
       const text = `${holds ? "Yes" : "No"} — ${bound.referent.label} (${refDay}) ${relation} ${clauseSubject} was last ${verb} (${freshCommit.label}, ${clauseDay}).`;
-      note(trace, "goal: compare a prior answer's dated referent against a freshly read event (cross-turn temporal composition)");
+      note(trace, `goal: ${temporalGoal}`);
       note(trace, `lane: TEMPORAL_COMPARISON_RE — "${form}" bound ${bound.referent.label} (${refDay}) through the discourse record; the embedded clause re-ran as its own when-question`);
-      const turn = plainTurn(query, text, { via: "composed", miss: false, focus });
+      const turn = plainTurn(query, text, { via: "composed", miss: false, focus, goal: temporalGoal });
       const cited = [graph.byId?.get?.(bound.referent.ids[0]), freshCommit].filter(Boolean);
       turn.detail = { traversal: `discourse ${bound.referent.ref} (${refDay}) vs last-${verb} of ${clauseSubject} (${clauseDay})`, matches: cited };
       return turn;
     }
   }
+  // TEMPORAL COMPARISON OVER A PLURAL ANTECEDENT — "were those before
+  // logger.mjs was touched": the plural sibling of the block above. `those`
+  // binds a `set` referent a prior listing/filter established, and the whole
+  // set is compared against the freshly read clause date. Each member is dated
+  // from the graph (the set referent carries member ids, not per-member dates,
+  // so the dates are read here the same way the clause is read fresh), and the
+  // answer quantifies over the set — all, none, or M of N — rather than
+  // forcing the set onto a single date. A set whose members are not all
+  // datable refuses honestly, and an unbound form, an undatable clause, or a
+  // missing graph keep today's miss, the same specific declines the singular
+  // lane makes. Checked here, before the ask engine, for the same reason the
+  // singular lane is: otherwise "those before logger.mjs was" reaches the
+  // keyword-spot strategy as multi-token patient wreckage and the teach-offer
+  // cascade reads it as a subject to learn facts about.
+  {
+    const cmp = String(query).trim().match(PLURAL_TEMPORAL_COMPARISON_RE);
+    if (cmp) {
+      const [, form, cmpOp, clauseSubject, participle] = cmp;
+      const verb = participle.toLowerCase();
+      const temporalGoal = "compare a prior answer's dated set against a freshly read event (cross-turn temporal composition over a plural antecedent)";
+      const refMiss = (text) => {
+        note(trace, `goal: ${temporalGoal}`);
+        note(trace, `lane: PLURAL_TEMPORAL_COMPARISON_RE — "${form}" could not compose a set comparison; a specific miss names why, never the teach-offer cascade`);
+        return plainTurn(query, text, { via: "miss", miss: true, focus, goal: temporalGoal });
+      };
+      const bound = discourseHolder ? bindDiscourseForm(discourseHolder.record, form, { tieRefuses: true }) : null;
+      if (bound?.tie) {
+        const options = joinOr(bound.tie.map((r) => r.label));
+        return refMiss(`"${form}" could mean ${options} — which set do you mean?`);
+      }
+      if (!bound?.referent) {
+        return refMiss(`I don't have a set for "${form}" yet — nothing answered earlier in this conversation binds it. Ask for the set first (e.g. "what changed before <commit>"), then ask the comparison again.`);
+      }
+      const set = bound.referent;
+      const total = set.ids.length;
+      if (!graph) {
+        return refMiss(`"${form}" refers to ${set.label}, but I need a code graph to date its members and when ${clauseSubject} was last ${verb} — no code graph is loaded.`);
+      }
+      const dateOfId = (id) => {
+        const ind = graph.byId?.get?.(id);
+        return ind ? String((ind.attributes || []).find((a) => a.key === "date")?.value || "").slice(0, 10) : "";
+      };
+      const memberDates = set.ids.map(dateOfId);
+      const undated = memberDates.filter((d) => !d).length;
+      if (undated) {
+        return refMiss(`"${form}" refers to ${set.label}, but not every member carries a date I can compare — ${undated} of the ${total} have no date on record, so I can't place the set before or after ${clauseSubject} was ${verb}.`);
+      }
+      const { ask } = await import("../domain/ask.mjs");
+      const fresh = ask(graph, `when was ${clauseSubject} ${participle}`);
+      const freshHit = (!fresh?.tmct_ask?.miss && !fresh?.tmct_ask?.ambiguous) ? fresh?.tmct_ask?.matches?.[0] : null;
+      const freshCommit = freshHit?.id ? graph.byId?.get?.(freshHit.id) : null;
+      const clauseDay = freshCommit?.class === "Commit"
+        ? String((freshCommit.attributes || []).find((a) => a.key === "date")?.value || "").slice(0, 10)
+        : "";
+      if (!clauseDay) {
+        return refMiss(`"${form}" refers to ${set.label}, but I couldn't date when ${clauseSubject} was last ${verb} in this index — so I can't compare the set to it.`);
+      }
+      const before = cmpOp.toLowerCase() === "before";
+      const satisfied = memberDates.filter((d) => before ? d < clauseDay : d > clauseDay).length;
+      const relation = before ? "came before" : "came after";
+      const tail = `${clauseSubject} was last ${verb} (${freshCommit.label}, ${clauseDay})`;
+      const text = satisfied === total
+        ? `Yes — all ${set.label} ${relation} ${tail}.`
+        : satisfied === 0
+          ? `No — none of the ${set.label} ${relation} ${tail}.`
+          : `Partly — ${satisfied} of the ${set.label} ${relation} ${tail}; the other ${total - satisfied} did not.`;
+      note(trace, `goal: ${temporalGoal}`);
+      note(trace, `lane: PLURAL_TEMPORAL_COMPARISON_RE — "${form}" bound ${set.label} (${total} dated members) through the discourse record; ${satisfied}/${total} ${relation} the freshly read clause (${clauseDay})`);
+      const turn = plainTurn(query, text, { via: "composed", miss: false, focus, goal: temporalGoal });
+      const cited = [...set.ids.map((id) => graph.byId?.get?.(id)), freshCommit].filter(Boolean);
+      turn.detail = { traversal: `discourse ${set.ref} (${total} members) vs last-${verb} of ${clauseSubject} (${clauseDay})`, matches: cited };
+      return turn;
+    }
+  }
   // RENAME HISTORY — "what was X called before" and its siblings. The index
   // records current names only, and without this gate "called" fuzzes onto
   // the calls relation ("before" simply drops), so the reply read as fluent
@@ -12043,7 +12230,7 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
       note(trace, "goal: recover a name history the index does not record (honest decline)");
       note(trace, "lane: RENAME_HISTORY_RE — the index carries no rename data, so the calls-relation misread is refused by name");
       return plainTurn(query, `I can't say what ${ent ? ent.label : `"${term}"`} was called before — this index records current names only, no rename history. ${named}${ent ? ` here; "who touched ${ent.label}" lists its recorded commits` : ""}.`, {
-        via: "miss", miss: true, focus,
+        via: "miss", miss: true, focus, goal: "recover a name history the index does not record (honest decline)",
       });
     }
   }
@@ -12055,10 +12242,11 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
   {
     const wikiTerm = wikipediaAskTerm(query);
     if (wikiTerm) {
-      note(trace, "goal: read what Wikipedia says about a named term (explicit source request)");
+      const wikiGoal = "read what Wikipedia says about a named term (explicit source request)";
+      note(trace, `goal: ${wikiGoal}`);
       if (!liveReference) {
         note(trace, "lane: WIKIPEDIA ASK — the explicit request needs the network opt-in; live Wikipedia is off");
-        return plainTurn(query, `live Wikipedia is off, so I won't reach the network. Turn it on with /wiki on (it fetches from en.wikipedia.org), then ask again.`, { via: "miss", miss: true, focus });
+        return plainTurn(query, `live Wikipedia is off, so I won't reach the network. Turn it on with /wiki on (it fetches from en.wikipedia.org), then ask again.`, { via: "miss", miss: true, focus, goal: wikiGoal });
       }
       let liveKey = null;
       try { liveKey = cleanMissLiveTerm(wikiTerm, lexicon ?? undefined); } catch { liveKey = null; }
@@ -12066,10 +12254,10 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
       if (live) {
         await ingestReferenceArticle(memoryDir, live.key, live.article, cache, liveProvenanceTag, lexicon, synthesisBudget);
         note(trace, `lane: WIKIPEDIA ASK — answered from a live en.wikipedia.org lookup, cited (article "${live.article.title}", revid ${live.article.revid})`);
-        return plainTurn(query, live.text, { via: "reference", miss: false, focus });
+        return plainTurn(query, live.text, { via: "reference", miss: false, focus, goal: wikiGoal });
       }
       note(trace, "lane: WIKIPEDIA ASK — no matching live article (no title, timeout, throttle, or drift-guard reject)");
-      return plainTurn(query, `I couldn't reach a matching Wikipedia article for "${wikiTerm}" just now.`, { via: "miss", miss: true, focus });
+      return plainTurn(query, `I couldn't reach a matching Wikipedia article for "${wikiTerm}" just now.`, { via: "miss", miss: true, focus, goal: wikiGoal });
     }
   }
   // COLLECTIVE PLURAL SUBJECT — see COLLECTIVE_FORWARD_RE. Members are the
@@ -12095,9 +12283,10 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
         const text = labels.length
           ? `the ${stem} here are ${memberList} — together they ${verb}: ${joinList(labels)}.`
           : `the ${stem} here are ${memberList} — none of them has ${verb} edges in the index.`;
-        note(trace, `goal: read a forward relation over a module GROUP (${members.length} members), unioned with the set disclosed`);
+        const groupGoal = `read a forward relation over a module GROUP (${members.length} members), unioned with the set disclosed`;
+        note(trace, `goal: ${groupGoal}`);
         note(trace, `lane: COLLECTIVE_FORWARD_RE — "${stem}" resolved to ${members.length} modules; answered the union, never a silent single best-match`);
-        const turn = plainTurn(query, text, { via: "composed", miss: !labels.length, focus });
+        const turn = plainTurn(query, text, { via: "composed", miss: !labels.length, focus, goal: groupGoal });
         turn.detail = { traversal: `${verb} edges unioned over ${memberList}`, matches: [...union.keys()].map((id) => graph.byId?.get?.(id)).filter(Boolean) };
         return turn;
       }
@@ -12122,7 +12311,7 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
         note(trace, "goal: recover a move history the index does not record (premise denied, current location cited)");
         note(trace, "lane: MOVE_HISTORY_RE — no move data exists; the current location answers with the premise named");
         return plainTurn(query, `this index records current locations only, so I can't confirm ${ent.label} moved anywhere.${located}`, {
-          via: "composed", miss: false, focus,
+          via: "composed", miss: false, focus, goal: "recover a move history the index does not record (premise denied, current location cited)",
         });
       }
     }
@@ -12140,7 +12329,7 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
       note(trace, `lane: DECISION_RECALL_RE — routed to the folded-session recall surface, ${recalled ? "a relevant block answered" : "nothing relevant folded (honest miss)"}`);
       return plainTurn(query, recalled
         ?? `I don't have a recorded decision about "${term}" — I keep facts and session transcripts, and nothing folded mentions deciding on it. "what did i ask before" lists the last session's questions.`, {
-        via: recalled ? "recall" : "miss", miss: !recalled, focus,
+        via: recalled ? "recall" : "miss", miss: !recalled, focus, goal: "recall a decision from the conversation record (session-recall surface)",
       });
     }
   }
@@ -12152,7 +12341,7 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
     const summary = await recallSummary(memoryDir);
     note(trace, summary ? "source: memory/fold.mjs recallSummary" : "intermediate: no folded session blocks yet — nothing to recall");
     return plainTurn(query, summary ?? "nothing to recall yet — no earlier session has been folded into memory.", {
-      via: "recall", miss: !summary, focus,
+      via: "recall", miss: !summary, focus, goal: "recall what was discussed earlier (explicit recall phrasing)",
     });
   }
   // An explicit "this file"/"that module" kind-noun scope signal is collapsed
@@ -12212,10 +12401,10 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
     // content is still typed) register into the session's record here — the
     // one point both ask paths (direct call and dispatchTool) converge.
     if (discourseHolder && Array.isArray(envelope?.discourse)) {
-      for (const { lane, ...spec } of envelope.discourse) {
+      for (const { lane, bound, ...spec } of envelope.discourse) {
         discourseHolder.record = registerReferent(discourseHolder.record, {
           ...spec, from: { turn: discourseHolder.record.turn, lane, query: askQuery },
-        });
+        }, { bound: !!bound });
       }
     }
   } catch (e) {
@@ -13400,7 +13589,7 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
 
 /** A non-ask, non-dispatch chat turn (count answer, /stats) — the same
  *  { answer, logLines, record, focus } shape, recorded like any other turn. */
-function plainTurn(query, answer, { command, via = "composed", miss = false, focus = null, canonical = null } = {}) {
+function plainTurn(query, answer, { command, via = "composed", miss = false, focus = null, canonical = null, goal = null } = {}) {
   const ts = new Date().toISOString();
   return {
     answer,
@@ -13412,6 +13601,10 @@ function plainTurn(query, answer, { command, via = "composed", miss = false, foc
       canonical,
     },
     focus,
+    // Absent by default, so an untouched plainTurn call stays trailer-free.
+    // A caller that already holds a precise goal string passes it here, and
+    // withGoalLine appends the "Goal (inferred): …" line for that turn.
+    ...(goal ? { goal } : {}),
   };
 }
 
@@ -13895,7 +14088,7 @@ async function assertTurn(line, { memoryDir, sessionId, focus, lexicon = null, c
           .map((t) => `fact(${JSON.stringify(normFactTerm(t.subject))}, ${JSON.stringify(t.predicate)}, ${JSON.stringify(normFactTerm(t.object))})`)
           .join(", ")).join(" | "),
       };
-      return plainTurn(line, answer, { command: "assert", via: "assert", focus, canonical });
+      return plainTurn(line, answer, { command: "assert", via: "assert", focus, canonical, goal: "teach/remember a new fact" });
     }
     const parse = parseAce(line, lex);
     if (!parse || !parse.triples?.length || parse.residue?.length) return null;
@@ -13972,7 +14165,7 @@ async function assertTurn(line, { memoryDir, sessionId, focus, lexicon = null, c
         .map((t) => `fact(${JSON.stringify(normFactTerm(t.subject))}, ${JSON.stringify(t.predicate)}, ${JSON.stringify(normFactTerm(t.object))})`)
         .join(", "),
     };
-    return plainTurn(line, answer, { command: "assert", via: "assert", focus, canonical });
+    return plainTurn(line, answer, { command: "assert", via: "assert", focus, canonical, goal: "teach/remember a new fact" });
   } catch {
     return null; // grammar unavailable / write failed — fall through to the engine
   }
@@ -14062,6 +14255,10 @@ function matchImpactIntent(line) {
   return null;
 }
 const joinList = (a) => (a.length > 1 ? `${a.slice(0, -1).join(", ")} and ${a[a.length - 1]}` : (a[0] ?? ""));
+// A discourse tie lists its options with a short Oxford-comma "or" join,
+// deliberately not the resolver's longer numbered ambiguity format.
+const joinOr = (a) => (a.length > 2 ? `${a.slice(0, -1).join(", ")}, or ${a[a.length - 1]}`
+  : a.length === 2 ? `${a[0]} or ${a[1]}` : (a[0] ?? ""));
 
 /** Render the next page of a held remainder (pending: {items:[str], noun}). Returns a
  *  plain turn whose `detail.pending` carries what's still unseen (null when the batch
@@ -14749,7 +14946,7 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
   // otherwise read as a declarative or an orientation ask.
   {
     const advTurn = await adventureTurn(workingLine, {
-      planHolder, memoryDir, sessionId, env, lexicon, graph, cache: factRowsCache, isPlanFrameLine,
+      planHolder, memoryDir, sessionId, env, lexicon, graph, cache: factRowsCache, isPlanFrameLine, discourseHolder,
     });
     if (advTurn) {
       note(trace, `lane: ${advTurn.note}`);
@@ -14878,7 +15075,7 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
     const step = await executePlanStep(planHolder, { memoryDir, sessionId, gameConfig: resolvedGameConfig });
     note(trace, `goal: ${step.deduced}`);
     note(trace, "lane: PLAN NEXT — executed the active plan's next move as an @stepK snapshot write");
-    const stepTurn = plainTurn(workingLine, step.text, { via: "plan", focus });
+    const stepTurn = plainTurn(workingLine, step.text, { via: "plan", focus, goal: step.deduced });
     stepTurn.lane = "imperative";
     const rec = withLast(stepTurn, step.deduced);
     rec.planState = planHolder.state;
@@ -14899,7 +15096,7 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
     if (follow) {
       note(trace, `goal: ${follow.deduced}`);
       note(trace, `lane: ${follow.note}`);
-      const rec = withLast(plainTurn(workingLine, follow.text, { via: "plan", focus }), follow.deduced);
+      const rec = withLast(plainTurn(workingLine, follow.text, { via: "plan", focus, goal: follow.deduced }), follow.deduced);
       rec.planState = planHolder.state;
       return rec;
     }
@@ -15021,7 +15218,7 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
       note(trace, "goal: teach/remember a new fact (bare declarative taxonomy)");
       note(trace, "lane: bareTaxonomyTeach — hyphenated-instance or article-led kind-of declarative, stored before the ask engine could parse it as a question");
       const taxonomyTurn = plainTurn(workingLine, taxonomy.text, { via: taxonomy.via, miss: taxonomy.miss, focus });
-      if (!taxonomy.miss) taxonomyTurn.lane = "teach";
+      if (!taxonomy.miss) { taxonomyTurn.lane = "teach"; taxonomyTurn.goal = "teach/remember a new fact"; }
       return withLast(taxonomyTurn, "teach/remember a new fact");
     }
   }
@@ -15066,6 +15263,10 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
       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.
+      if (!memClass.miss && memClass.kind !== "count") turn.goal = goal;
       if (memClass.pending) turn.detail = { traversal: null, matches: [], pending: memClass.pending };
       return withLast(turn, goal);
     }
@@ -15091,6 +15292,7 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
       note(trace, `goal: ${goal}`);
       note(trace, "lane: answerMembershipList — matched a bare 'list <noun>' over taught isa-facts whose OBJECT is that class");
       const turn = plainTurn(workingLine, memberList.text, { via: memberList.miss ? "miss" : "fact", miss: !!memberList.miss, focus });
+      if (!memberList.miss) turn.goal = goal;
       if (memberList.pending) turn.detail = { traversal: null, matches: [], pending: memberList.pending };
       return withLast(turn, goal);
     }