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

package/src/services/chat.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.
  *
@@ -917,7 +920,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));
@@ -2746,6 +2749,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 +2780,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 +2895,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 +2937,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 +3108,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 +3122,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 +3206,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 +3239,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 +3906,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 +4417,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 +5202,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 +5330,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 +5351,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 +5360,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 +5423,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.`,
@@ -11992,10 +12049,11 @@ 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;
       if (!bound?.referent) {
@@ -12021,9 +12079,9 @@ 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;
@@ -12043,7 +12101,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 +12113,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 +12125,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 +12154,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 +12182,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 +12200,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 +12212,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
@@ -13400,7 +13460,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 +13472,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 +13959,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 +14036,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
   }
@@ -14878,7 +14942,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 +14963,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 +15085,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 +15130,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 +15159,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);
     }

package/src/services/extract-facts.mjs

@@ -53,7 +53,8 @@ import { readFile, writeFile, mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { basename, join, resolve } from "node:path";
 
-import { runTurn, uuidv7 } from "./chat.mjs";
+import { runTurn, uuidv7, stripLeadingDiscourseAdverb } from "./chat.mjs";
+import { beginsWithVowelSound, grammarRules } from "./finish.mjs";
 import { splitSentencesPreservingPaths, stripCitationResidue } from "./sentences.mjs";
 import { loadMemory, readFactRows, appendFact } from "../adapters/memory/core.mjs";
 import { loadConfig } from "../adapters/config.mjs";
@@ -125,6 +126,12 @@ const RELATIVE_PRONOUNS = new Set(["that", "which", "who", "whom", "whose"]);
 // At most this many triples from one sentence — a bound so a run-on can never
 // shatter into noise, not a first-wins cap.
 const MAX_TRIPLES_PER_SENTENCE = 4;
+// How far a copula object scan walks past an attributive-adjective compound
+// (wink tokenizes "medium-sized" as NOUN + "-" + VERB and never re-fuses it) to
+// reach the real head noun through a coordinate modifier list
+// (", burrowing, nocturnal mammal"). A small, explicit bound: past it the object
+// abstains rather than guess, so a long noun pile never mints a stray class.
+const ATTRIBUTIVE_CHAIN_MAX_HOPS = 8;
 
 /** Fold an entity surface to its stored key: a lexicon noun's lemma, else the
  *  word's own normFactTerm (the optimistic tier mints unlisted content nouns
@@ -242,6 +249,25 @@ function optimisticTriplesPos(sentence, lexicon, nlp) {
       if (!isNounish(j)) continue;
       let hi = j;
       while (hi + 1 < values.length && isNounish(hi + 1)) hi += 1;
+      // A NOUN immediately followed by "-" then a VERB or ADJ is the left half of
+      // an attributive-adjective compound wink never re-fused ("medium-sized"),
+      // not the class. Walk forward through the coordinate modifier list (hyphens,
+      // commas, "and", further ADJ/VERB tokens) to the real head noun and re-point
+      // there; abstain if none appears within the bound, never mint the modifier.
+      if (values[hi + 1] === "-" && (pos[hi + 2] === "VERB" || pos[hi + 2] === "ADJ")) {
+        let head = null;
+        let k = hi + 1;
+        for (let hop = 0; hop < ATTRIBUTIVE_CHAIN_MAX_HOPS && k < values.length; hop += 1, k += 1) {
+          if (isNounish(k)) { head = k; break; }
+          const w = values[k]?.toLowerCase();
+          if (w === "-" || w === "," || w === "and" || pos[k] === "ADJ" || pos[k] === "VERB" || pos[k] === "CCONJ") continue;
+          break;
+        }
+        if (head === null) return null;
+        j = head;
+        hi = head;
+        while (hi + 1 < values.length && isNounish(hi + 1)) hi += 1;
+      }
       const headWord = String(values[hi]).toLowerCase();
       const nextIsOf = values[hi + 1]?.toLowerCase() === "of";
       if (!nextIsOf) return { label: entityRunAt(j), hi };
@@ -434,6 +460,17 @@ export function clauseCandidates(sentence, { nlp } = {}) {
 // live focus, never a stale paragraph carry.
 const PRONOUN_LEAD_RE = /^(?:they|it|these|those|this)\b\s*/i;
 
+/** Re-article a bare carried subject so the retried sentence is a grammatical
+ *  habitual surface the recognizer accepts: "cell" → "a cell", "orbit" → "an
+ *  orbit". Uses the same vowel-sound-aware article rule (grammar-rules.toml)
+ *  the chat recognizer's own capability rewrite uses, rather than a hardcoded
+ *  "a". */
+function articledSubject(subject) {
+  const articleRule = grammarRules().find((r) => r.kind === "article");
+  const article = articleRule && beginsWithVowelSound(subject, articleRule) ? "an" : "a";
+  return `${article} ${subject}`;
+}
+
 /** A readable predicate for canonical output: the local part of an rdfs:/ace:
  *  CURIE, otherwise the predicate verbatim. */
 const readablePredicate = (predicate) => String(predicate).replace(/^[a-z]+:/i, "");
@@ -532,9 +569,14 @@ export async function ingestText(text, {
         }
         // Bounded pronoun carry: a "they/it/these/those/this …" sentence the
         // recognizer skipped is retried once with the paragraph's last grounded
-        // subject in the pronoun's place. Never a chat turn — ingest only.
-        if (!rows && carrySubject && PRONOUN_LEAD_RE.test(cleaned)) {
-          rows = await strictRows(cleaned.replace(PRONOUN_LEAD_RE, `${carrySubject} `));
+        // subject in the pronoun's place. A leading ordinal/temporal discourse
+        // adverb ("Then it splits.") is stripped first so the pronoun reaches
+        // the sentence front; the carried subject is re-articled ("a cell") so
+        // the retry is a grammatical habitual surface. Never a chat turn —
+        // ingest only.
+        const threaded = stripLeadingDiscourseAdverb(cleaned);
+        if (!rows && carrySubject && PRONOUN_LEAD_RE.test(threaded)) {
+          rows = await strictRows(threaded.replace(PRONOUN_LEAD_RE, `${articledSubject(carrySubject)} `));
         }
         if (rows) {
           recognizedSentences += 1;

package/src/services/research.mjs

@@ -25,6 +25,7 @@
 
 import { normFactTerm } from "../domain/hash.mjs";
 import { loadLexicon, lookupNoun } from "../domain/grammar/lexicon.mjs";
+import { defaultNlp } from "../domain/interpret/nlp-registry.mjs";
 
 /** The search key a topic folds to: normFactTerm, then the lexicon lemma
  *  when the noun is known ("owls" → "owl") — the same fold the live
@@ -210,12 +211,87 @@ function queuedFolds(state) {
   return seen;
 }
 
+// The lexical-token split a fan-out candidate and the seed topic both fold
+// through before comparison — lowercased, split on anything that isn't a
+// letter or digit, empty pieces dropped.
+const LEXICAL_SPLIT_RE = /[^a-z0-9]+/i;
+function lexicalTokens(text) {
+  return String(text || "").toLowerCase().split(LEXICAL_SPLIT_RE).filter(Boolean);
+}
+function sharesLexicalToken(title, seedTokens) {
+  if (!seedTokens.size) return false;
+  for (const tok of lexicalTokens(title)) if (seedTokens.has(tok)) return true;
+  return false;
+}
+
+// A citation-shaped candidate: an ISBN/DOI prefix, a bare year, or a
+// "Nth century" phrase — the shape raw Wikipedia link lists carry for their
+// source apparatus rather than a kin article.
+const CITATION_PREFIX_RE = /^(isbn|doi)[\s:.-]/i;
+const CITATION_BARE_YEAR_RE = /^\d{3,4}$/;
+const CITATION_CENTURY_RE = /\b\d{1,2}(?:st|nd|rd|th)\s+century\b/i;
+function isCitationShaped(title) {
+  const t = String(title || "").trim();
+  if (!t) return false;
+  return CITATION_PREFIX_RE.test(t) || CITATION_BARE_YEAR_RE.test(t) || CITATION_CENTURY_RE.test(t);
+}
+
+const SINGLE_WORD_TITLE_RE = /^[A-Za-z][A-Za-z'-]*$/;
+// A short, neutral sentence to tag a bare candidate word inside — wink-nlp
+// reads an isolated capitalized word as PROPN with no sentence context to
+// tell it otherwise, so the word is lowercased and read at this fixed slot
+// inside real subject/verb/object context instead.
+const NOUN_CARRIER_PREFIX = ["this", "is", "about", "the"];
+const NOUN_CARRIER_SUFFIX = ["and", "its", "history"];
+const NOUN_CARRIER_WORD_INDEX = NOUN_CARRIER_PREFIX.length;
+
+/** True when `title` is a single word a general-English POS tagger reads as
+ *  a common noun (hub articles like "Earth"/"Geology") rather than a proper
+ *  noun (kin articles like "Hawaii") — false whenever `nlp` is unavailable,
+ *  never a throw. */
+function readsAsCommonNoun(title, nlp) {
+  if (!nlp || typeof nlp.posTags !== "function") return false;
+  const t = String(title || "").trim();
+  if (!SINGLE_WORD_TITLE_RE.test(t)) return false;
+  const carrier = [...NOUN_CARRIER_PREFIX, t.toLowerCase(), ...NOUN_CARRIER_SUFFIX];
+  let tags;
+  try { tags = nlp.posTags(carrier); } catch { return false; }
+  return Array.isArray(tags) && tags[NOUN_CARRIER_WORD_INDEX] === "NOUN";
+}
+
+/** Stable-sorts fan-out candidates into relevance tiers — never reorders
+ *  within a tier, only reprioritizes between them — from information the
+ *  runtime actually has (title strings, the seed topic, an optional POS
+ *  tagger), never bench-only ground truth:
+ *  0. shares a lexical token with `seedTopic` ("Active volcano" ~ "Volcano");
+ *  1. everything else, in original document order (the fallback tier);
+ *  2. a single-word title a POS tagger reads as a common noun rather than a
+ *     proper noun — the hub-article signal ("Earth", "Geology");
+ *  3. a citation-shaped title (ISBN/DOI prefix, bare year, "Nth century").
+ *  With no `nlp` adapter registered, tier 2 never fires (everything that
+ *  would have landed there stays in tier 1) — degrades gracefully, never
+ *  throws, never drops a candidate. */
+export function relevanceOrder(titles, seedTopic, nlp = null) {
+  const list = Array.isArray(titles) ? titles : [];
+  const seedTokens = new Set(lexicalTokens(seedTopic));
+  const tiers = [[], [], [], []];
+  for (const title of list) {
+    if (sharesLexicalToken(title, seedTokens)) { tiers[0].push(title); continue; }
+    if (isCitationShaped(title)) { tiers[3].push(title); continue; }
+    if (readsAsCommonNoun(title, nlp)) { tiers[2].push(title); continue; }
+    tiers[1].push(title);
+  }
+  return [...tiers[0], ...tiers[1], ...tiers[2], ...tiers[3]];
+}
+
 /** Queue `article`'s lead-section links at `fromDepth + 1`, subject to the run's
  *  depth ceiling, its per-fan-out cap and — crucially — its TOTAL node budget:
  *  the number added never pushes grounded+pending past `maxTopics`. Sets
  *  `state.nodeCapReached` when the budget (not the depth, not a lack of links)
- *  is what stopped the fan-out, so the progress line can say so. Returns the
- *  titles it enqueued. */
+ *  is what stopped the fan-out, so the progress line can say so. Candidates are
+ *  relevance-ordered (relevanceOrder) before the fan-out cap truncates them, so
+ *  a capped fetch keeps kin articles over generic hubs. Returns the titles it
+ *  enqueued. */
 async function enqueueFrom(state, article, fromDepth, provider) {
   const childDepth = fromDepth + 1;
   if (childDepth > runMaxDepth(state)) return [];
@@ -226,10 +302,11 @@ async function enqueueFrom(state, article, fromDepth, provider) {
   if (want <= 0) { state.nodeCapReached = true; return []; }
   let linked = null;
   try { linked = await provider.linkedTitles(article.title, { limit: want + 2 }); } catch { linked = null; }
+  const ordered = relevanceOrder(linked || [], article.title, defaultNlp());
   const seen = queuedFolds(state);
   if (!state.depths) state.depths = {};
   const added = [];
-  for (const title of linked || []) {
+  for (const title of ordered) {
     const folded = normFactTerm(title);
     if (!folded || seen.has(folded)) continue;
     seen.add(folded);