@polycode-projects/the-mechanical-code-talker 2.10.5 → 2.11.1

package/src/services/chat.mjs

@@ -51,13 +51,14 @@ import {
   LIVE_PACK_NAME, cleanMissLiveTerm, renderLiveReferenceAnswer, liveProvenanceTag,
 } from "../domain/reference-pack.mjs";
 import { getReferencePackProvider } from "../adapters/corpus/reference-pack.mjs";
-import { getLiveReferenceProvider } from "../adapters/corpus/wikipedia-live.mjs";
+import { getLiveReferenceProvider, getResearchProvider } from "../adapters/corpus/wikipedia-live.mjs";
+import { researchTurn, researchSnapshot, resolveResearchConfig, RESEARCH_DEFAULTS } from "./research.mjs";
 import { CHILD_PACK_NAME, childProvenanceTag } from "../domain/child-pack.mjs";
 import { getChildPackProvider } from "../adapters/corpus/child-pack.mjs";
 import { dialogueActForLane } from "../domain/dialogue-acts.mjs";
 import { subClassParents, ancestryChain, clusterSenses } from "../domain/sense-split.mjs";
 import { relatedForTerm } from "../domain/skos-view.mjs";
-import { adventureTurn, unclaimedAdventureOpening } from "./adventure.mjs";
+import { adventureTurn, unclaimedAdventureOpening, foldWorldState } from "./adventure.mjs";
 import { spiderFlyTurn } from "./spider-fly-turn.mjs";
 import { DEFAULT_GAME_CONFIG } from "../domain/game-config.mjs";
 
@@ -1081,6 +1082,11 @@ const CAPABILITY_PHRASES = [
   // — closed to the same self-referential noun set META_ORIENT_RE uses, so a
   // real module/class named literally "repo"/"codebase" is never at risk.
   /^what(?:'s|s|\s+is) in (?:this|the)\s+(?:app|codebase|repo|repository|project|code)\??$/i,
+  // "can I ask you something random" — an ordinary conversational preamble
+  // asking permission before a real question, not itself a question about
+  // anything nameable. Answered the same as any other vague opener: sure,
+  // here's what I can help with.
+  /^can i ask (?:you\s+)?something(?:\s+random)?\??$/i,
 ];
 /** IDENTITY questions — "who/what are you", by name, in plain or ESL-ish phrasing.
  *  Routed to a self-description (identity-self) that works regardless of graph
@@ -1131,6 +1137,25 @@ const AI_IDENTITY_PHRASES = [
   // product path (no-LLM constitution, deterministic offline reasoning), so
   // this is a real "no", not the generic capability listing.
   /^can (?:you|u) (?:browse|access|use|go on|connect to) the internet\??$/i,
+  // "can you look things up on the internet" / "browse the web to check
+  // something" — the same offline-capability question as the entry just
+  // above, worded around "web"/"look up" instead of "browse the internet".
+  // With no closed match, this fell into a code-graph module-name search for
+  // the literal words instead of the plain "no, I'm offline" answer.
+  /^can (?:you|u) look (?:things?\s+)?up on the internet\??$/i,
+  /^can (?:you|u) (?:browse|search|check) the web(?:\s+to\s+check\s+(?:something|this|that))?\??$/i,
+  // "are you like chatgpt or gemini or something" — the comparison phrasing
+  // of the "are you an AI" question, a named model or two followed by a
+  // trailing "or something" hedge.
+  /^(?:are you|r u)\s+like\s+(?:chatgpt|gpt|claude|gemini|llama)(?:\s+or\s+(?:chatgpt|gpt|claude|gemini|llama))*\s+or\s+something\??$/i,
+  // "what model are you, gpt-4 or claude or something else" — the SAME
+  // open-pick question "what model are you built on" already answers, just
+  // without the "built/based/running on" bridge phrase.
+  /^what model are you,?\s*(?:gpt-?\d(?:\.\d)?|chatgpt|claude|gemini|llama)(?:\s+or\s+(?:gpt-?\d(?:\.\d)?|chatgpt|claude|gemini|llama|something\s+else))*\??$/i,
+  // "can you use an LLM to answer this" — asks the identical no-LLM question
+  // as "do you use ai", just with "use an LLM to answer this" as the verb
+  // phrase instead of a bare "use ai".
+  /^can (?:you|u) use (?:an? )?(?:llm|ai|gpt|chatgpt) to answer (?:this|that|it)\??$/i,
 ];
 
 /** META-COMMAND/SESSION questions — a RETURNING USER checking whether a
@@ -1218,10 +1243,25 @@ const FEELINGS_PHRASES = [
   // "keeps growing as new natural phrasings surface" precedent.
   /^how (?:are|r) (?:you|u) doing(?:\s+today)?\??$/i,
   /^what(?:'s|s|\s+is) your (?:favou?rite\s+(?:colou?r|food|movie|book|band|song|number)|name)\??$/i,
-  /^do you (?:get|ever get) bored\??$/i,
+  /^do you (?:get|ever get) (?:bored|tired)\??$/i,
   /^what do you do for fun\??$/i,
   /^can you (?:tell|make)\s+(?:me\s+)?(?:a\s+)?jokes?\??$/i,
   /^do you (?:know|know anything|know much)\s+about\s+(?:movies?|sports?|music|tv|television)(?:\s+or\s+(?:movies?|sports?|music|tv|television))?\??$/i,
+  // "do you think dogs are smarter than cats" — a personal-opinion comparison,
+  // same family as the direct personal questions above: closed to a small
+  // comparative-adjective vocabulary, open on the two compared things (the
+  // SAME discipline PHRASING_FRAMES' object captures use elsewhere).
+  /^do you think .+?\s+(?:is|are)\s+(?:smarter|dumber|better|worse|nicer|cooler|cuter|friendlier|stronger|faster)\s+than\s+.+\??$/i,
+];
+/** "can you make up an answer if you don't actually know" — a direct probe of
+ *  the product's own headline promise (the honest miss: a query it can't
+ *  ground gets a refusal, never a guess). With no closed match this fell to
+ *  the plain grammar wall instead of confirming the very thing it asked
+ *  about. Same family/placement as FEELINGS_PHRASES just above. */
+const HONEST_MISS_PHRASES = [
+  /^can (?:you|u) make up an answer if you (?:don'?t|do\s+not) (?:actually\s+|really\s+)?know\??$/i,
+  /^(?:do|would) you (?:ever\s+)?(?:make (?:something|stuff) up|make up an answer)(?:\s+if you (?:don'?t|do\s+not) know)?\??$/i,
+  /^what if you (?:don'?t|do\s+not) know (?:the\s+)?answer\??$/i,
 ];
 /** "whats 2+2" — a bare arithmetic expression, not a code/vocabulary question
  *  at all. With no closed-set match of its own, this fell into the SAME
@@ -1234,6 +1274,15 @@ const FEELINGS_PHRASES = [
  *  structural answer, never this decline. "+"/"*"/"/" have no such
  *  collision in tmct's own vocabulary. */
 const ARITHMETIC_RE = /\d+\s*[+*/]\s*\d+/;
+/** A bare SQL data-definition/manipulation statement typed at the prompt
+ *  ("DROP TABLE users;") — nonsense as a code-graph question, and with no
+ *  closed match of its own this fell to the ≤3-word catch-all's identity/
+ *  orientation blurb, the same wrong-flavor miss ARITHMETIC_RE exists to
+ *  avoid for arithmetic. Each alternative requires the FULL SQL clause shape
+ *  (not just the bare leading verb), so an ordinary English imperative
+ *  ("update the readme") is never caught here — "table"/"from"/"into"/"set"
+ *  are the words that make this unambiguously SQL rather than English. */
+const SQL_STATEMENT_RE = /^(?:(?:drop|truncate|alter)\s+table|delete\s+from|insert\s+into|update\s+[a-z0-9_.]+\s+set)\s+[a-z0-9_.]+\b/i;
 /** The structural verbs/nouns that mark a near-miss code question (→ keep the
  *  precise grammar hint, not the friendly nudge). */
 const STRUCT_WORDS = new Set([
@@ -1427,6 +1476,10 @@ const T_ORIENTATION_EMPTY = "orientation-empty";
 const T_IDENTITY_SELF = "identity-self";
 const T_IDENTITY_NOT_LLM = "identity-not-an-llm";
 const T_IDENTITY_NO_FEELINGS = "identity-no-feelings";
+/** Confirms the honest-miss promise itself when a user asks about it directly
+ *  ("can you make up an answer if you don't know"). Same "works regardless of
+ *  graph state" family as the identity answers just above. */
+const T_IDENTITY_HONEST_MISS = "identity-honest-miss";
 /** THE CONCEPT FORCE (concept.mjs): the three-band answer to a vague "what is a X"
  *  that names a known concept WITH instances — {definition}/{examples}/{followups}. */
 const T_CONCEPT = "concept-force";
@@ -1496,6 +1549,13 @@ 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
   // conversationalTurn, so having it here would silently end the session on
@@ -1513,6 +1573,11 @@ const WHY = new Set([
 const OK_ACK = new Set([
   "ok", "okay", "cool", "aight", "fair enough", "got it", "gotcha", "noted",
   "sounds good", "sure", "cool cool", "right",
+  // "haha ok fair enough" — a laughter beat leading a two-word ack ("fair
+  // enough") that dismissalSignal's own peeling can't reach: it peels
+  // single-WORD fluff off each end, but "fair enough" is itself two words.
+  // Whole-phrase entry, closed and hand-curated, this exact reported phrasing.
+  "haha ok fair enough",
 ]);
 /** Dismissals — "drop it, no question here" beats. Routed to a warm dismissal
  *  template, never the identity/orientation blurb (which reads like the tool
@@ -1619,6 +1684,11 @@ const CLOSING_FILLER_CLAUSES = new Set([
   "that's everything for now", "that's all for now",
   "that's everything i needed", "that's all i needed",
   "that's everything for today", "that's all for today",
+  // "thats enough for now" — the same closing-filler shape, worded around
+  // "enough" instead of "everything"/"all", and without the apostrophe a
+  // casual typer routinely drops (conversationalTurn's own `q` never runs an
+  // apostrophe/contraction pass, so both spellings are curated explicitly).
+  "that's enough for now", "thats enough for now",
 ]);
 /** Strip a hedging lead ("i think that's everything for today" → "that's
  *  everything for today") so a hedged closing clause still matches the closed
@@ -1875,6 +1945,20 @@ function conversationalTurn(line, ctx) {
     note(ctx.trace, "lane: conversational — identity/feelings (FEELINGS_PHRASES closed set)");
     return mk(t(T_IDENTITY_NO_FEELINGS), { lane: "help" });
   }
+  if (HONEST_MISS_PHRASES.some((re) => re.test(raw))) {
+    note(ctx.trace, "goal: identity — a direct probe of the honest-miss promise itself");
+    note(ctx.trace, "lane: conversational — identity/honest-miss (HONEST_MISS_PHRASES closed set)");
+    return mk(t(T_IDENTITY_HONEST_MISS), { lane: "help" });
+  }
+  if (SQL_STATEMENT_RE.test(raw)) {
+    note(ctx.trace, "goal: nonsense input shaped like a SQL statement — a targeted decline, not the identity blurb");
+    note(ctx.trace, "lane: conversational — SQL-statement decline (SQL_STATEMENT_RE)");
+    return mk(
+      "That reads like a SQL statement, not a question about a code graph or taught facts. "
+      + "Try \"what is a dog\" for vocabulary, or point me at a repo with --repo <path>.",
+      { lane: "help" },
+    );
+  }
   if (ARITHMETIC_RE.test(raw)) {
     note(ctx.trace, "goal: arithmetic — not a code/vocabulary question, an honest decline");
     note(ctx.trace, "lane: conversational — arithmetic decline (ARITHMETIC_RE)");
@@ -2112,7 +2196,7 @@ const WALL_MISS_ANYWHERE_RE = /couldn't parse this as a graph question\. Try:/;
 // bare "X is a Y" declarative the graph parser couldn't handle → route to the
 // assert/memory path; when it can't be stored, say what CAN be remembered
 // instead of the grammar wall or a silent data loss.
-const TEACH_RE = /^(?:please\s+)?(?:i\s+(?:want|wanted)\s+you\s+to\s+|i(?:'d|\s+would)\s+like\s+you\s+to\s+)?(?:remember|note|keep in mind|jot down|for the record|fyi|learn)\b(?:\s+(?:this|that|also))?[:,]?\s*(?:that\s+)?(.+?)[.?!]*$/i;
+const TEACH_RE = /^(?:please\s+)?(?:i\s+(?:want|wanted)\s+you\s+to\s+|i(?:'d|\s+would)\s+like\s+you\s+to\s+)?(?:remember|note|keep in mind|jot down|for the record|fyi|learn|teach(?:\s+me)?)\b(?:\s+(?:this|that|also))?[:,]?\s*(?:that\s+)?(.+?)[.?!]*$/i;
 // A trailing sentence-final mark ([.!?]*) is tolerated at the very end: an
 // ordinary first turn typed as a full sentence ("every dog is a mammal.")
 // otherwise failed this shape test by one character whenever neither ACE nor
@@ -2861,8 +2945,20 @@ async function unknownSubjectFallback(payload, { memoryDir, sessionId, lexicon }
   const [, det, subjectRaw, verb, objectRaw] = m;
   const { loadLexicon, lookupNoun, lookupAdjective, classify } = await import("../domain/grammar/lexicon.mjs");
   const lex = lexicon || loadLexicon();
-  // A known X's own ACE miss is a real miss — never silently reinterpreted here.
-  if (classify(subjectRaw, lex)) return null;
+  // A known X's own ACE miss is a real miss — never silently reinterpreted
+  // here. EXCEPT: classify() folds a trailing "-s" the same way resolveNP
+  // does (lexicon.mjs's lookupNoun), so a bare proper name that happens to
+  // end in "s" and collide with an unrelated dictionary noun ("whiskers" ->
+  // "whisker") reads as "already known" under a SINGULAR "is" sentence, where
+  // no plural evidence supports the fold at all (the genuinely-plural "are"
+  // case is handled correctly a few lines down). Refuse only the fold's own
+  // contribution here — an EXACT noun hit (no fold), or any non-noun
+  // classification (a real verb/adjective/proper name/determiner), still
+  // blocks this fallback exactly as before.
+  const subjectClass = classify(subjectRaw, lex);
+  const subjectFoldedNounOnly = subjectClass?.pos === "noun" && !/^are$/i.test(verb)
+    && (lookupNoun(lex, subjectRaw)?.lemma || "").toLowerCase() !== String(subjectRaw).toLowerCase();
+  if (subjectClass && !subjectFoldedNounOnly) return null;
   const quantifier = /^every$/i.test((det || "").trim()) ? "every" : "";
   // Singularize the SUBJECT before storage, but ONLY on a genuinely PLURAL
   // phrasing ("all men ARE mortal", verb "are"). This
@@ -3138,7 +3234,8 @@ async function unknownAdjectiveFallback(payload, { memoryDir, sessionId, lexicon
 // sentence said ("tony never eats ribs" -> tony eats ribs) — a truthful teach
 // read back as a confident lie. It belongs to NEG_MARKER_SRC below.
 const TEACH_ADVERB_SKIP_SRC = "(?:(?:usually|often|sometimes|rarely|always|typically|generally|"
-  + "occasionally|frequently|normally|regularly|commonly|mostly|currently|still|also|really|actually)\\s+)?";
+  + "occasionally|frequently|normally|regularly|commonly|mostly|currently|still|also|really|actually|"
+  + "closely|strongly|directly)\\s+)?";
 /** The negation markers a teach/query frame recognizes, in ONE place so the
  *  teach side and the query side can never disagree about what negates a
  *  sentence — the same discipline TEACH_ADVERB_SKIP_SRC is shared under. */
@@ -3163,6 +3260,110 @@ function splitTeachNegation(payload) {
   return { payload: `${m[1]} ${canFamily ? "can " : ""}${m[3]}`.trim(), negated: true };
 }
 const GENERAL_VERB_TEACH_RE = new RegExp(`^([\\w'-]+)\\s+${TEACH_ADVERB_SKIP_SRC}([a-z]+)\\s+(.+?)[.!?]*$`, "i");
+/** The closed participle set the relational teach frames read as "X is
+ *  <participle> <prep> Y" — a past participle whose own form is the word, so it
+ *  reads back with no morphology. Closed by list (templates over general
+ *  grammar), so the frame can never widen onto an arbitrary "-ed" adjective. */
+const TEACH_PARTICIPLE_SRC = "connected|related|associated|linked|based|derived|composed|made|used|known|located|found|involved|concerned";
+/** The prepositions those participles take. A closed set, folded into the
+ *  minted predicate (mgx:<participle>-<prep>) the same way PREP_SRC folds into
+ *  the general-verb frame's. */
+const TEACH_PARTICIPLE_PREP_SRC = "with|to|from|by|of|in|on|for|as|about|into";
+/** "X is <participle> <prep> Y" — "sales are closely connected with marketing"
+ *  → sales mgx:connected-with marketing. The subject is one or two tokens (the
+ *  same bound the comparative/unknown-subject frames use), an optional adverb
+ *  is skipped, and the object is captured for a determiner-strip + 3-token cap
+ *  by its handler. */
+const PARTICIPLE_PREP_TEACH_RE = new RegExp(
+  `^(?:the\\s+|an?\\s+)?([\\w'-]+(?:\\s+[\\w'-]+)?)\\s+(?:is|are|was|were)\\s+${TEACH_ADVERB_SKIP_SRC}(${TEACH_PARTICIPLE_SRC})\\s+(${TEACH_PARTICIPLE_PREP_SRC})\\s+(.+)$`,
+  "i",
+);
+/** "X is a <noun> <participle> <prep> Y" — a copula-NP with a trailing
+ *  participle clause: "sales are activities related to selling" decomposes into
+ *  the class-membership half (sales ⊑ activity, through the ordinary mint/assert
+ *  path) AND the relational half (sales mgx:related-to selling). The NP head is
+ *  a single token, followed by a closed participle — which keeps this disjoint
+ *  from PARTICIPLE_PREP_TEACH_RE, where the participle sits right after the
+ *  copula. */
+const COPULA_NP_PARTICIPLE_TEACH_RE = new RegExp(
+  `^(?:the\\s+|an?\\s+)?([\\w'-]+(?:\\s+[\\w'-]+)?)\\s+(is|are|was|were)\\s+(?:an?\\s+)?([\\w'-]+)\\s+(${TEACH_PARTICIPLE_SRC})\\s+(${TEACH_PARTICIPLE_PREP_SRC})\\s+(.+)$`,
+  "i",
+);
+/** "A and B have/share the same <noun>" — "sales and marketing have the same
+ *  goal" → sales mgx:same-goal-as marketing. A closed shape; the conjunction
+ *  pre-pass leaves it alone (its second clause never opens with is/are/has/
+ *  have/can), so it reaches the teach dispatch whole. */
+const SAME_NOUN_TEACH_RE = /^(?:the\s+)?([\w'-]+)\s+and\s+(?:the\s+)?([\w'-]+)\s+(?:have|has|share|shares)\s+(?:the\s+)?same\s+([\w'-]+)[.!?]*$/i;
+/** "the letter is in the garden" — a locative teach whose subject the running
+ *  adventure world already places somewhere. Group 1 is the subject; the world
+ *  place is left to the fold, since the sentence is stored as a note either
+ *  way. */
+const LOCATIVE_TEACH_RE = /^(?:the\s+)?([\w'-]+)\s+(?:is|are|was|were)\s+(?:in|on|under|inside|at|near|behind|above|below)\s+(?:the\s+)?[\w'-]+/i;
+/** Fold a relational object down to its head phrase: cut at the first clause
+ *  boundary (a comma, semicolon, or a coordinating "or"/"and"), strip a leading
+ *  determiner, then cap at 3 tokens — "selling or the number of goods sold in a
+ *  period" folds to "selling", "the number of goods" to "number of goods".
+ *  Keeps a minted relational object bounded, the same discipline the general-
+ *  verb frame's own object fold uses. */
+function participleObject(raw) {
+  const cleaned = String(raw).trim()
+    .replace(/[.!?]+$/, "")
+    .split(/\s*[,;]\s*|\s+(?:or|and)\s+/i)[0]
+    .trim()
+    .replace(/^(?:the|an?|its|his|her|their|our|my|your|some|any)\s+/i, "");
+  return cleaned.split(/\s+/).slice(0, 3).join(" ");
+}
+/** Does a bare (unwrapped) sentence fit one of the relational teach frames —
+ *  including its negated twin, read through splitTeachNegation the same way the
+ *  general-verb and capability frames read theirs? Used only to admit the
+ *  sentence as a teach payload; the dispatch below re-matches and stores.
+ *
+ *  Each regex's own subject capture is a bare word/short NP with no pronoun
+ *  exclusion of its own (unlike generalVerbTeach's GENERAL_VERB_NOT_A_VERB_RE
+ *  check) — this frame used to be reached only once the bare-sentence pronoun
+ *  guard (TEACH_PRONOUN_BARE_RE) had already declined, but that guard is
+ *  deliberately narrow (copula + a SHORT complement only), so a pronoun
+ *  subject with a longer relational complement ("it is closely connected
+ *  with hunting" — the ingest pronoun-carry mechanism's own first, expected-
+ *  to-fail attempt) reaches here unprotected. isTeachPronoun is the same
+ *  closed check every other mint fallback in this lane uses. */
+function matchesRelationalTeachFrame(sentence) {
+  const { payload } = splitTeachNegation(String(sentence || "").trim());
+  const pp = payload.match(PARTICIPLE_PREP_TEACH_RE);
+  if (pp) return !isTeachPronoun(pp[1]);
+  const np = payload.match(COPULA_NP_PARTICIPLE_TEACH_RE);
+  if (np) return !isTeachPronoun(np[1]);
+  const same = payload.match(SAME_NOUN_TEACH_RE);
+  if (same) return !isTeachPronoun(same[1]) && !isTeachPronoun(same[2]);
+  return false;
+}
+/** Does a relational-frame sentence name a code-graph entity? "the Router is
+ *  used by every handler" reads as a passive uses-CLAIM the ask engine verifies
+ *  against the graph ("No — no uses edge found…"), not a fact to store — the
+ *  participle+preposition frame would otherwise intercept it. When any term the
+ *  frame would store resolves to a graph entity, the frame yields so the graph
+ *  lane keeps the sentence. No graph (a bare/browser/ingest turn) means nothing
+ *  to yield to, so the frame proceeds. */
+async function relationalFrameNamesGraphEntity(sentence, graph) {
+  if (!graph) return false;
+  const { payload } = splitTeachNegation(String(sentence || "").trim());
+  let terms = null;
+  const pp = payload.match(PARTICIPLE_PREP_TEACH_RE);
+  if (pp) terms = [pp[1], participleObject(pp[4])];
+  else {
+    const np = payload.match(COPULA_NP_PARTICIPLE_TEACH_RE);
+    if (np) terms = [np[1], np[3], participleObject(np[6])];
+    else {
+      const same = payload.match(SAME_NOUN_TEACH_RE);
+      if (same) terms = [same[1], same[2]];
+    }
+  }
+  if (!terms) return false;
+  for (const t of terms) {
+    try { if (await resolveEntity(graph, String(t).trim())) return true; } catch { /* unresolved is fine */ }
+  }
+  return false;
+}
 /** Determiners/quantifiers that make the FIRST token an article, not a real
  *  bare-name subject ("every controller…", "the cache…") — GENERAL_VERB_TEACH_RE
  *  would otherwise happily bind them as a 1-token subject and misread the
@@ -3251,7 +3452,17 @@ const GENERAL_VERB_ANYWHERE_EXCLUDE_RE = /\b(?:is|are|am|owns|maintains)\b/i;
  *  the legit "mentors" as NOUN, so a POS gate would have regressed a real
  *  teach; a closed list (templates over general grammar rules) is both more
  *  reliable here and, being closed, can never widen recognition the way a
- *  probabilistic POS heuristic could. */
+ *  probabilistic POS heuristic could.
+ *
+ *  The interrogative pronouns (what/who/which/where/when/why/how) join the
+ *  list for the same reason: a dropped-copula casual fragment ("k what abt
+ *  users.mjs", missing the "is" QUESTION_LEAD_RE/hasMidSentenceInterrogative
+ *  both expect) leaves the WH-word sitting in the verb slot exactly like "if"
+ *  or "in" above — subject "k", verb "what", object "abt users.mjs" — and
+ *  the SAME nonsense -s fold ("k WHATs abt users.mjs") mints it as a fact. A
+ *  WH-word is never a genuine general-verb-frame verb, so this is the same
+ *  pure narrowing the block above already describes, just closing the one
+ *  closed class it left out. */
 const GENERAL_VERB_NOT_A_VERB_RE = new RegExp(
   "^(?:"
   // personal/possessive/demonstrative pronouns + determiners (mirrors, and
@@ -3264,6 +3475,9 @@ const GENERAL_VERB_NOT_A_VERB_RE = new RegExp(
   + "|up|down|off|out|above|below|between|among|against|without|within|along|across|behind|beyond|upon|toward|towards|per"
   // conjunctions/subordinators
   + "|and|but|or|if|because|although|though|while|when|since|unless|until|whether|so|nor|than|as"
+  // interrogative pronouns/adverbs — never a real verb, only ever the
+  // fronted question-word of a copula-dropped fragment
+  + "|what|who|whom|whose|which|where|why|how"
   + ")$",
   "i",
 );
@@ -3819,20 +4033,38 @@ function habitualGroundingHintText(line, habitual) {
  *  a demonstrated entity ("that is a bug", pointing at something real) is a
  *  much closer call than "every you is a womble".
  *
- *  The verb slot matches ANY word, not just the is/are/am copula: a pronoun
+ *  The verb slot matches ANY word, not just the is/are/am copula — a pronoun
  *  is just as invalid a fact subject under a general verb ("remember you has
- *  a hat", "remember he eats ribs") as it is under "is" — this is a
- *  grammatical category error regardless of the verb — keeping the guard
- *  ahead of every teach recognizer (copula AND general-verb alike) the same
- *  way it already stood ahead of teachSuggestion/unknownSubjectFallback. */
-// The contracted forms ("i'm new here …") join the bare pronouns: a leading
-// pronoun+copula contraction is exactly as invalid a fact subject, and it
-// slipped past this guard into the general-verb mint as a one-token "i'm".
-const TEACH_PRONOUNS = Object.freeze([
-  "you're", "i'm", "it's", "they're", "he's", "she's", "we're",
-  "you", "i", "it", "they", "he", "she", "we",
-]);
-const TEACH_PRONOUN_RE = new RegExp(`^(?:every\\s+|each\\s+|all\\s+|some\\s+|a few\\s+|a\\s+|an\\s+)?(${TEACH_PRONOUNS.join("|")})\\s+\\S+`, "i");
+ *  a hat", "remember he eats ribs") as it is under "is" — but ONLY once an
+ *  explicit "remember"/"note"/"teach me"-style wrapper (TEACH_RE) already
+ *  named this an unambiguous teach attempt (TEACH_PRONOUN_WRAPPED_RE, tried
+ *  first when `wrapped` is set). A BARE sentence with no such signal gets the
+ *  narrower TEACH_PRONOUN_BARE_RE instead: pronoun + copula + a SHORT
+ *  complement (one word, one optional leading article) — the exact shape
+ *  TEACH_PROPERTY_RE/BARE_DECLARATIVE_RE would themselves recognize from a
+ *  legal subject. Without that narrowing, an ordinary opener that merely
+ *  STARTS with "I" ("I am new here", "I want to know X") reached this guard
+ *  too (teachLane is the LAST lane tried, after every query strategy already
+ *  missed) and fired the copula-specific decline over a sentence no frame
+ *  would ever have stored regardless of subject — a confusing answer to a
+ *  question nobody asked. Those now fall to teachExclusionReason's existing
+ *  self-referential exclusion (a standalone "i"/"me" is already a
+ *  TEACH_EXCLUDE_META_TOKEN_RE hit) or to generalVerbTeach's own silent
+ *  decline (GENERAL_VERB_NOT_A_VERB_RE covers the same closed pronoun set) —
+ *  the same clean stand-down a non-pronoun subject already gets. */
+const TEACH_PRONOUNS_BARE = Object.freeze(["you", "i", "it", "they", "he", "she", "we"]);
+// The contracted forms ("i'm new here …") bake the copula into one token, so
+// they get their own branch below rather than a separate copula match.
+const TEACH_PRONOUNS_CONTRACTED = Object.freeze(["you're", "i'm", "it's", "they're", "he's", "she's", "we're"]);
+const TEACH_PRONOUNS = Object.freeze([...TEACH_PRONOUNS_CONTRACTED, ...TEACH_PRONOUNS_BARE]);
+const TEACH_PRONOUN_WRAPPED_RE = new RegExp(`^(?:every\\s+|each\\s+|all\\s+|some\\s+|a few\\s+|a\\s+|an\\s+)?(${TEACH_PRONOUNS.join("|")})\\s+\\S+`, "i");
+const TEACH_PRONOUN_BARE_RE = new RegExp(
+  "^(?:every\\s+|each\\s+|all\\s+|some\\s+|a few\\s+|a\\s+|an\\s+)?"
+  + `(?:(${TEACH_PRONOUNS_BARE.join("|")})\\s+(?:is|are|am|was|were)`
+  + `|(${TEACH_PRONOUNS_CONTRACTED.join("|")}))`
+  + "\\s+(?:an?\\s+)?[\\w'-]+[.!?]*$",
+  "i",
+);
 /** The same closed set, read as a whole-word membership test: a pronoun is no
  *  more a legal fact subject when a reader LIFTS one out of a prior answer than
  *  when a teach frame offers one. */
@@ -3988,12 +4220,12 @@ async function teachExclusionReason(sentence) {
   const unpunctuated = s.replace(/[.!?]+\s*$/, "");
   if (TEACH_EXCLUDE_IMPERATIVE_LEAD_RE.test(s)
     && !RETRACT_FORGET_RE.test(unpunctuated) && !RETRACT_FORGET_LOCATIVE_RE.test(unpunctuated)) return "imperative";
-  if (TEACH_EXCLUDE_META_TOKEN_RE.test(s) && !TEACH_PRONOUN_RE.test(s)) return "self-referential";
+  if (TEACH_EXCLUDE_META_TOKEN_RE.test(s) && !TEACH_PRONOUN_BARE_RE.test(s)) return "self-referential";
   return null;
 }
 export { teachExclusionReason };
 
-async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cache = null, planHolder = null }) {
+async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cache = null, planHolder = null, graph = null }) {
   // A closed discourse-marker preamble ahead of a teach sentence ("howdy
   // pardner, remember that TaskController is fragile") would otherwise
   // corrupt TEACH_RE's own match, so strip it first. applyPreambleFrames is
@@ -4165,10 +4397,10 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
   // wrapped; trailing punctuation stripped the same way the OWNS/SOME_A_FEW
   // lanes below do) before anything else in this function, so a pronoun
   // subject NEVER reaches teachSuggestion's "did you mean" hint or
-  // unknownSubjectFallback's direct-write path — see TEACH_PRONOUN_RE's own
-  // docblock above for why.
+  // unknownSubjectFallback's direct-write path — see TEACH_PRONOUN_WRAPPED_RE/
+  // TEACH_PRONOUN_BARE_RE's own shared docblock above for why the two differ.
   const pronounSrc = (wrapped ?? raw).replace(/[.!?]+\s*$/, "");
-  const pronounMatch = pronounSrc.match(TEACH_PRONOUN_RE);
+  const pronounMatch = pronounSrc.match(wrapped != null ? TEACH_PRONOUN_WRAPPED_RE : TEACH_PRONOUN_BARE_RE);
   // A pronoun-led sentence that's ALSO a mid-sentence question ("it uses
   // which controller as its base") isn't a pronoun-classification problem at
   // all — "it" was never going to be storable either way, so naming the
@@ -4184,7 +4416,7 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
   // declining right here.
   if (pronounMatch && !ACTION_SIGNATURE_TEACH_RE.test(pronounSrc)
     && !(await hasMidSentenceInterrogative(pronounSrc))) {
-    const pronoun = pronounMatch[1];
+    const pronoun = pronounMatch[1] || pronounMatch[2];
     return {
       text: `I can't store a fact about "${pronoun}" as a class — pronouns aren't things I can classify. `
         + `I remember facts in the shape "every X is a Y", where X is a specific noun, not a pronoun. `
@@ -4196,10 +4428,14 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
   // NEGATION ("X is not a Y") and RETRACTION ("forget that X is a Y"). Two
   // sentences, two intents, and the split is the point: a negative is a source
   // DISAGREEING, never an instruction to destroy. Each branch documents itself
-  // below; both are tried here, right after the pronoun guard, so a pronoun
-  // subject ("it is not an animal") still falls to that guard's own decline
-  // first (TEACH_PRONOUN_RE matches ANY verb after the pronoun, including
-  // "is not"), never reaching this block.
+  // below; both are tried here, right after the pronoun guard. A WRAPPED
+  // pronoun subject ("remember that it is not an animal") still falls to that
+  // guard's own decline first. A BARE one ("it is not an animal") reaches this
+  // block instead, but stays safe either way: retractNotMatch's own "gated on
+  // the positive existing" rule below finds no stored "it ⊑ …" fact to
+  // disagree with (a pronoun was never a legal mint subject anywhere in this
+  // lane), so it falls through to the ordinary cascade unstored, same as
+  // today — just without this guard's more specific wording.
   const retractSrc = (wrapped ?? raw).replace(/[.!?]+\s*$/, "");
   const retractSrcMidQuestion = memoryDir && !QUESTION_LEAD_RE.test(retractSrc)
     ? await hasMidSentenceInterrogative(retractSrc) : false;
@@ -4869,7 +5105,10 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
 
   let payload = null;
   if (wrapped && /\b(?:is|are)\b/i.test(wrapped)) payload = wrapped;
-  else if ((BARE_DECLARATIVE_RE.test(raw) || COMPARATIVE_TEACH_RE.test(raw) || matchBareHabitualTeach(raw) || matchBareCanTeach(raw)) && !QUESTION_LEAD_RE.test(raw) && !(await hasMidSentenceInterrogative(raw))) payload = raw;
+  else if ((BARE_DECLARATIVE_RE.test(raw) || COMPARATIVE_TEACH_RE.test(raw)
+      || (matchesRelationalTeachFrame(raw) && !(await relationalFrameNamesGraphEntity(raw, graph)))
+      || matchBareHabitualTeach(raw) || matchBareCanTeach(raw))
+      && !QUESTION_LEAD_RE.test(raw) && !(await hasMidSentenceInterrogative(raw))) payload = raw;
   if (!payload) {
     // "remember margo eats ribs", re-escaping here through a combination
     // that mechanism's own deliberate subject-shape restriction doesn't
@@ -4901,6 +5140,58 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
       });
       if (stored) return stored;
     }
+    // RELATIONAL teach frames — a participle+preposition claim
+    // ("sales are closely connected with marketing"), a copula-NP with a
+    // trailing participle ("sales are activities related to selling"), or a
+    // shared-attribute claim ("sales and marketing have the same goal"). Each
+    // reads through splitTeachNegation like its comparative/general-verb
+    // siblings, so a negated form stores the mgxneg: twin.
+    {
+      const { payload: posPayload, negated } = splitTeachNegation(String(payload).trim());
+      // (D) participle + preposition, checked ahead of the copula-NP form so a
+      // bare participle right after the copula is never misread as a noun.
+      const pp = posPayload.match(PARTICIPLE_PREP_TEACH_RE);
+      if (pp) {
+        const pred = `mgx:${pp[2].toLowerCase()}-${pp[3].toLowerCase()}`;
+        const stored = await teachFact(memoryDir, sessionId, {
+          subject: pp[1].trim(), predicate: negated ? negatedPredicate(pred) : pred,
+          object: participleObject(pp[4]),
+        });
+        if (stored) return stored;
+      }
+      // (E) copula-NP + trailing participle — decomposed into the
+      // class-membership half (subject ⊑ singular(NP head)) and the relational
+      // half. The copula-NP shape is a deliberate declarative, strong enough to
+      // mint the membership directly, so it lands even when neither term is in
+      // the lexicon (the acceptance the ingest pipeline needs). Either half may
+      // stand on its own if the other's write fails.
+      const np = posPayload.match(COPULA_NP_PARTICIPLE_TEACH_RE);
+      if (np) {
+        const subject = np[1].trim();
+        const relPred = `mgx:${np[4].toLowerCase()}-${np[5].toLowerCase()}`;
+        const isaStored = await teachFact(memoryDir, sessionId, {
+          subject, predicate: SUBCLASS_PREDICATE, object: singularizeSurface(np[3]),
+        });
+        const relStored = await teachFact(memoryDir, sessionId, {
+          subject, predicate: negated ? negatedPredicate(relPred) : relPred,
+          object: participleObject(np[6]),
+        });
+        const stripNoted = (t) => String(t).replace(/^noted — remembered(?:\s+\d+\s+facts?)?:\s*/i, "").trim();
+        if (isaStored && relStored) return { text: `noted — remembered both: ${stripNoted(isaStored.text)}; and ${stripNoted(relStored.text)}`, via: "assert", miss: false };
+        if (relStored) return relStored;
+        if (isaStored) return isaStored;
+      }
+      // (F) shared attribute — "A and B have the same <noun>".
+      const same = posPayload.match(SAME_NOUN_TEACH_RE);
+      if (same) {
+        const pred = `mgx:same-${same[3].toLowerCase()}-as`;
+        const stored = await teachFact(memoryDir, sessionId, {
+          subject: same[1].trim(), predicate: negated ? negatedPredicate(pred) : pred,
+          object: same[2].trim(),
+        });
+        if (stored) return stored;
+      }
+    }
     for (const cand of assertCandidates(payload)) {
       // assertTurn ITSELF records the "every" quantifier (point 3) on a plain
       // universal success, so every caller (this loop AND the top-level
@@ -5624,7 +5915,8 @@ export async function helpText() {
     ["/export <path>", "write the memory store to a file, as JSONL (the same shape `tmct memory --export` writes)"],
     ["/ingest <path>", "read a local text file and store every fact the recognizer grounds from it (same recognizer as `tmct extract`)"],
     ["/narrate on|off", "verbose developer/debug mode: decision points, matched pattern, results+sources, goal per turn"],
-    ["/wiki on|off|supplement", "live Wikipedia (default off): on tries en.wikipedia.org when I can't answer (network), cited; supplement also adds a read-out under every grounded answer"],
+    ["/wiki on|off|supplement|always", "live Wikipedia (default off): on tries en.wikipedia.org when I can't answer (network), cited; supplement also adds a read-out under every grounded vocabulary answer; always widens that to every grounded answer"],
+    ["research <topic> [limit N]", "fetch the topic from Simple English Wikipedia (the explicit ask is the network consent), store what it grounds, and queue its linked topics — \"research next\" steps the queue; also status/stop"],
     ["/help", "this list"],
     ["/exit", "leave the session (also Ctrl+C / Ctrl+D)"],
   ];
@@ -5904,6 +6196,14 @@ function predicatePhrase(predicate) {
   // "is smaller than" (never a 3sg fold — "smallers" isn't a word)
   const comp = /^mgx:([a-z]+(?:-[a-z]+)*)-than$/i.exec(p);
   if (comp) return `is ${comp[1].replace(/-/g, " ")} than`;
+  // a participle + preposition renders as its copula surface: mgx:connected-with
+  // -> "is connected with" (the participle is already a participle, so no 3sg
+  // fold — "connecteds" isn't a word)
+  const part = new RegExp(`^mgx:(${TEACH_PARTICIPLE_SRC})-([a-z]+)$`, "i").exec(p);
+  if (part) return `is ${part[1].toLowerCase()} ${part[2].toLowerCase()}`;
+  // a shared-attribute predicate: mgx:same-goal-as -> "has the same goal as"
+  const same = /^mgx:same-([a-z]+)-as$/i.exec(p);
+  if (same) return `has the same ${same[1].toLowerCase()} as`;
   const m = /^mgx:([a-z]+)(?:-([a-z]+))?$/i.exec(p);
   if (!m) return predicate;
   // a folded preposition renders back naturally: mgx:rest-on -> "rests on"
@@ -7939,13 +8239,14 @@ const IS_ADJECTIVE_PRONOUN_RE = /^(?:it|this|that)$/i;
  *  SUBJECT capture — factReadBack then treats "you"/"you like"/"you secretly
  *  chatgpt or" as a literal fact subject and offers to teach a fact ABOUT the
  *  pronoun ("remember that you is happy"), exactly the grammatical category
- *  error TEACH_PRONOUN_RE (above) was already built to reject
- *  on the teach-lane side. Same pronoun set (you|i|they|he|she|we) reused
- *  here, checked at the START of the subject capture only (not anchored to
- *  the whole capture — a pronoun subject can carry trailing words, "you
- *  like"/"you secretly … or", the same way TEACH_PRONOUN_RE's own `\s+\S+`
- *  tail allows). "it" is deliberately EXCLUDED from this set, unlike
- *  TEACH_PRONOUN_RE — IS_ADJECTIVE_PRONOUN_RE (just above) already gives "it"
+ *  error TEACH_PRONOUN_WRAPPED_RE/TEACH_PRONOUN_BARE_RE (above) were already
+ *  built to reject on the teach-lane side. Same pronoun set (you|i|they|he|
+ *  she|we) reused here, checked at the START of the subject capture only
+ *  (not anchored to the whole capture — a pronoun subject can carry trailing
+ *  words, "you like"/"you secretly … or", the same class of category error
+ *  those two regexes reject on the teach-lane side). "it" is deliberately
+ *  EXCLUDED from this set, unlike TEACH_PRONOUN_WRAPPED_RE/
+ *  TEACH_PRONOUN_BARE_RE — IS_ADJECTIVE_PRONOUN_RE (just above) already gives "it"
  *  its own correct, wanted behavior (anaphoric resolution against the
  *  session's current FOCUS, "is it deprecated" → resolves off focusLabel),
  *  which this guard must not shadow. Every call site below is expected to
@@ -10012,7 +10313,7 @@ async function liveReferenceAnswerForKey(key, onLiveLookup) {
  *  key up in the shipped child triples pack and append every fact under child
  *  provenance, so the SAME question can be re-asked from the store. Null on a
  *  pack miss or any failure — the turn then proceeds byte-identically. */
-async function childPackFactsForKey(key, { memoryDir, env, cache }) {
+async function childPackFactsForKey(key, { memoryDir, env, cache, synthesisBudget = AUTO_SYNTHESIS_BUDGET }) {
   let row = null;
   try { row = await getChildPackProvider(env).lookup(key); } catch { row = null; }
   if (!row?.facts?.length) return null;
@@ -10023,7 +10324,7 @@ async function childPackFactsForKey(key, { memoryDir, env, cache }) {
     })));
   } catch { return null; }
   if (cache) cache.rows = null;
-  await synthesiseAroundTerm(memoryDir, key, cache);
+  await synthesiseAroundTerm(memoryDir, key, cache, synthesisBudget);
   return { key, count: row.facts.length };
 }
 
@@ -10034,7 +10335,7 @@ async function childPackFactsForKey(key, { memoryDir, env, cache }) {
  *  and is failure-tolerated: the answer stands whether or not the facts land.
  *  The optimistic tier is pure (no recognizer re-entry), so this stays cheap on
  *  the chat turn. Returns the count stored. */
-async function ingestReferenceArticle(memoryDir, key, article, cache, tagFor = referenceProvenanceTag, lexicon = null) {
+async function ingestReferenceArticle(memoryDir, key, article, cache, tagFor = referenceProvenanceTag, lexicon = null, synthesisBudget = AUTO_SYNTHESIS_BUDGET) {
   if (!article) return 0;
   const provenance = tagFor(article);
   const facts = [];
@@ -10056,7 +10357,7 @@ async function ingestReferenceArticle(memoryDir, key, article, cache, tagFor = r
     await appendFacts(memoryDir, facts);
     if (cache) cache.rows = null;
   } catch { return 0; }
-  await synthesiseAroundTerm(memoryDir, key, cache);
+  await synthesiseAroundTerm(memoryDir, key, cache, synthesisBudget);
   return facts.length;
 }
 
@@ -10072,15 +10373,15 @@ const AUTO_SYNTHESIS_BUDGET = 12;
  *  facts carry entailed:* provenance at their discounted trust and are
  *  retractable. Failure-tolerated: a synthesis miss never disturbs the answer
  *  the load already composed. Returns the count derived. */
-async function synthesiseAroundTerm(memoryDir, term, cache) {
-  if (!memoryDir || !term) return 0;
+async function synthesiseAroundTerm(memoryDir, term, cache, budget = AUTO_SYNTHESIS_BUDGET) {
+  if (!memoryDir || !term || budget <= 0) return 0;
   try {
     const { syllogise } = await import("../domain/syllogise.mjs");
     const { loadMemory, readFactRows, appendFacts, normFactTerm } = await import("../adapters/memory/core.mjs");
     const res = await syllogise(memoryDir, {
       focus: [...factTermVariants(normFactTerm, term)],
       expandFocus: true,
-      budget: AUTO_SYNTHESIS_BUDGET,
+      budget,
       store: { loadMemory, readFactRows, appendFacts },
     });
     if (res?.count && cache) cache.rows = null;
@@ -10453,9 +10754,13 @@ async function compareAnswer(query, { graph, config, source }) {
  *  "give me a detailed overview of X", wired to src/domain/completions/'s extractive
  *  multi-sentence pipeline below. Two closed shapes (DETAILED_HOW_WORKS_RE
  *  tried first, more specific); distinct from DESCRIBE_WRAPPER_RE, which
- *  neither anchors on "give me"/"explain ... in detail". */
+ *  neither anchors on "give me"/"explain ... in detail". The article before
+ *  "detailed" and the "of" before "how" are both OPTIONAL: a non-native
+ *  speaker's "give me detailed summary how this application works" carries
+ *  the identical intent as the fully-articled form, and dropping either word
+ *  changes nothing the pipeline downstream reads — same shape, same term. */
 const DETAILED_HOW_WORKS_RE =
-  /^(?:(?:can|could|would)\s+you\s+(?:please\s+)?|please\s+)?(?:give\s+me\s+a\s+detailed\s+(?:summary|overview|explanation)\s+of\s+how|explain\s+(?:to\s+me\s+)?in\s+detail\s+how)\s+(.+?)\s+works\s*\??$/i;
+  /^(?:(?:can|could|would)\s+you\s+(?:please\s+)?|please\s+)?(?:give\s+me\s+(?:an?\s+)?detailed\s+(?:summary|overview|explanation)\s+(?:of\s+)?how|explain\s+(?:to\s+me\s+)?in\s+detail\s+how)\s+(.+?)\s+works\s*\??$/i;
 
 const DETAILED_OVERVIEW_RE =
   /^(?:(?:can|could|would)\s+you\s+(?:please\s+)?|please\s+)?give\s+me\s+a\s+detailed\s+(?:overview|summary|explanation)\s+of\s+(.+?)\s*\??$/i;
@@ -11280,8 +11585,12 @@ const DECISION_RECALL_RE = /^(?:remind\s+me\s+)?what\s+(?:did\s+)?(?:we|i|you)\s
  *  than silently accepted alongside the current location. */
 const MOVE_HISTORY_RE = /^where\s+did\s+(.+?)\s+(?:move|get\s+moved|go)(?:\s+to)?[?.!\s]*$/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, gameConfig = DEFAULT_GAME_CONFIG, liveReference = false, onLiveLookup = null }) {
+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, gameConfig = DEFAULT_GAME_CONFIG, liveReference = false, onLiveLookup = null, uiContext = "cli", synthesisBudget = AUTO_SYNTHESIS_BUDGET }) {
   const ts = new Date().toISOString();
+  // The surface this turn runs on ("cli" default; "browser" from a web entry) —
+  // the honest-miss tail below points a browser/adventure miss at the teach
+  // lane instead of the CLI-only --repo/tmct-init remedy.
+  const browser = uiContext === "browser";
   // DISCOURSE ANAPHORA: a follow-up like "which of those are tested" / "count
   // 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
@@ -11340,7 +11649,7 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
       try { liveKey = cleanMissLiveTerm(wikiTerm, lexicon ?? undefined); } catch { liveKey = null; }
       const live = liveKey ? await liveReferenceAnswerForKey(liveKey, onLiveLookup) : null;
       if (live) {
-        await ingestReferenceArticle(memoryDir, live.key, live.article, cache, liveProvenanceTag, lexicon);
+        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 });
       }
@@ -11503,8 +11812,12 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
     // examples are the wrong audience here), an unseeded one at the seed/
     // teach pair — vocabHint already carries exactly that split.
     answer = (!graph || noCodeGraph(graph)) && (!config || e?.emptyGraph || /^cannot read graph artifact\b/.test(thrown))
+      // A browser session has no `tmct init in a repo` to reach for, so its
+      // fallback drops that CLI-only remedy and keeps just the teach pointer.
       ? `I can't answer that as a code question — no code graph is loaded in this session. ${vocabHint
-        || "I can still remember and answer taught facts (try \"every bug is an issue\"), or run `tmct init` in a repo to index one."}`
+        || (browser
+          ? "I can still remember and answer taught facts (try \"every bug is an issue\")."
+          : "I can still remember and answer taught facts (try \"every bug is an issue\"), or run `tmct init` in a repo to index one.")}`
       : thrown;
     note(trace, `intermediate: the ask engine threw — ${thrown}`);
   }
@@ -11903,7 +12216,7 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
       if (!bareMetaHit) {
         const refTerm = metaTermOf(factQuery, envelope);
         const key = refTerm ? await cleanMissPackKey(refTerm, { graph, memoryDir, lexicon, cache }) : null;
-        const learned = key ? await childPackFactsForKey(key, { memoryDir, env, cache }) : null;
+        const learned = key ? await childPackFactsForKey(key, { memoryDir, env, cache, synthesisBudget }) : null;
         if (learned) {
           const fact = (await factAnswer(memoryDir, factQuery, envelope, miss, biasByBundle, cache, newFocus?.label))
             ?? (await factReadBack(memoryDir, factQuery, envelope, miss, graph, newFocus?.label, biasByBundle, cache));
@@ -11967,7 +12280,7 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
     handled = true;
     note(trace, "lane: (2b) REFERENCE PACK — a bare \"what is X\" clean miss answered from the shipped reference pack, cited");
     note(trace, `source: reference pack ${REFERENCE_PACK_NAME} — article "${bareMetaHit.reference.article.title}" (revid ${bareMetaHit.reference.article.revid})`);
-    await ingestReferenceArticle(memoryDir, bareMetaHit.reference.key, bareMetaHit.reference.article, cache, referenceProvenanceTag, lexicon);
+    await ingestReferenceArticle(memoryDir, bareMetaHit.reference.key, bareMetaHit.reference.article, cache, referenceProvenanceTag, lexicon, synthesisBudget);
   } else if (bareMetaHit?.live) {
     // The bare-form LIVE hit settles the same way, under live provenance.
     answer = bareMetaHit.text;
@@ -11976,7 +12289,7 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
     handled = true;
     note(trace, "lane: (2b) LIVE WIKIPEDIA — a bare \"what is X\" clean miss answered from a live en.wikipedia.org lookup (opt-in), cited");
     note(trace, `source: live reference ${LIVE_PACK_NAME} — article "${bareMetaHit.live.article.title}" (revid ${bareMetaHit.live.article.revid})`);
-    await ingestReferenceArticle(memoryDir, bareMetaHit.live.key, bareMetaHit.live.article, cache, liveProvenanceTag, lexicon);
+    await ingestReferenceArticle(memoryDir, bareMetaHit.live.key, bareMetaHit.live.article, cache, liveProvenanceTag, lexicon, synthesisBudget);
   } else if (bareMetaHit) {
     answer = bareMetaHit.replace ? bareMetaHit.text : `${answer}\n${bareMetaHit.text}`;
     // Same discipline as lane (3): a fact-lane return flagged `miss` is an
@@ -12203,7 +12516,7 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
   // (4) #2 TEACH lane — a teach-shaped would-miss nothing above answered: route to
   // memory, or say what CAN be remembered (LOUD), never the wall / a silent drop.
   if (miss && recordMiss && via === "composed") {
-    const taught = await teachLane(query, { memoryDir, sessionId, lexicon, cache, planHolder });
+    const taught = await teachLane(query, { memoryDir, sessionId, lexicon, cache, planHolder, graph });
     if (taught) {
       answer = taught.text; via = taught.via; recordMiss = taught.miss;
       if (!taught.miss) dialogueLaneOverride = "teach";
@@ -12222,6 +12535,26 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
       // kind of parent" as inherits) keeps its canonical: it genuinely
       // restates the relation the teach stored.
       if (envelope?.parsed?.fuzzyVerb) canonical = null;
+      // A mid-game locative teach is accepted and stored as the player's own
+      // note, but a running adventure's world only moves through actions — so
+      // when the taught subject is a term the world already places, the
+      // confirmation says so plainly. (The fold itself keeps taught rows out of
+      // the world state; this is the matching UX.)
+      if (!taught.miss && planHolder?.state?.adventure) {
+        const loc = String(query).trim().match(LOCATIVE_TEACH_RE);
+        if (loc) {
+          let placed = false;
+          try {
+            const { normFactTerm } = await import("../adapters/memory/core.mjs");
+            const world = foldWorldState(await factRows(memoryDir, cache));
+            placed = world.placements.has(normFactTerm(loc[1]));
+          } catch { placed = false; }
+          if (placed) {
+            answer = `${answer}\n(noted as your note — the game world itself only changes through actions like go, take and open.)`;
+            note(trace, "intermediate: mid-game locative teach — stored as a note; the adventure fold only moves through actions");
+          }
+        }
+      }
     }
   }
   // (4b) #4 AUTHOR lane — "who is <Name>", "what did <Name> touch",
@@ -12362,7 +12695,7 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
   if (miss && recordMiss && via === "composed" && memoryDir) {
     const refTerm = metaTermOf(query, envelope);
     const key = refTerm ? await cleanMissPackKey(refTerm, { graph, memoryDir, lexicon, cache }) : null;
-    const learned = key ? await childPackFactsForKey(key, { memoryDir, env, cache }) : null;
+    const learned = key ? await childPackFactsForKey(key, { memoryDir, env, cache, synthesisBudget }) : null;
     if (learned) {
       const fact = (await factAnswer(memoryDir, query, envelope, miss, biasByBundle, cache, newFocus?.label))
         ?? (await factReadBack(memoryDir, query, envelope, miss, graph, newFocus?.label, biasByBundle, cache));
@@ -12383,7 +12716,7 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
         recordMiss = false;
         note(trace, "lane: (4h) REFERENCE PACK — a clean miss on a lexicon term answered from the shipped reference pack, cited");
         note(trace, `source: reference pack ${REFERENCE_PACK_NAME} — article "${ref.article.title}" (revid ${ref.article.revid})`);
-        await ingestReferenceArticle(memoryDir, ref.key, ref.article, cache, referenceProvenanceTag, lexicon);
+        await ingestReferenceArticle(memoryDir, ref.key, ref.article, cache, referenceProvenanceTag, lexicon, synthesisBudget);
       }
     }
     // The live Wikipedia supplement (opt-in), strictly AFTER both shipped
@@ -12399,7 +12732,7 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
         recordMiss = false;
         note(trace, "lane: (4h) LIVE WIKIPEDIA — a clean miss answered from a live en.wikipedia.org lookup (opt-in), cited");
         note(trace, `source: live reference ${LIVE_PACK_NAME} — article "${live.article.title}" (revid ${live.article.revid})`);
-        await ingestReferenceArticle(memoryDir, live.key, live.article, cache, liveProvenanceTag, lexicon);
+        await ingestReferenceArticle(memoryDir, live.key, live.article, cache, liveProvenanceTag, lexicon, synthesisBudget);
       }
     }
   }
@@ -12421,12 +12754,25 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
     note(trace, `lane: (5) SHORT TAILORED MISS — every lane above declined; ${repeat ? "REPEAT collapsed to one-liner (wall kindness)" : "the full grammar wall was shortened + tailored to the query's keywords"}`);
   }
   // #4 HONEST-EMPTY POLISH — an empty CODE graph: any still-standing engine
-  // dead-end (an honest empty, the short miss, the bootstrap note) carries the exit
-  // toward a real graph, unless it already points there. Only when genuinely empty.
+  // dead-end (an honest empty, the short miss, the bootstrap note) carries the
+  // exit toward a real graph, unless it already points there. Only when
+  // genuinely empty. The CLI keeps the --repo/example pointer verbatim; a
+  // browser or a live adventure has no such command to reach for, so each gets
+  // a teach-forward pointer (and the adventure also names the world asides that
+  // are guaranteed to hit).
+  const adventureLive = !!planHolder?.state?.adventure;
   if (recordMiss && (via === "composed" || via === "miss")
       && noCodeGraph(graph) && !/--repo|tmct init|no code graph/i.test(answer)) {
-    answer = `${answer}\n(this repo has no code graph — for structure, point me at a \`.tmct/graph.json\` with \`--repo <path>\` or run \`npm run example:mini\`; tmct doesn't index code itself.)`;
-    note(trace, "intermediate: HONEST-EMPTY POLISH — the loaded graph has 0 modules, so the dead-end got a --repo/tmct init pointer appended");
+    if (adventureLive) {
+      answer = `${answer}\n(I don't know that yet — you can teach me: say "remember: <thing> is a <kind>". Or ask the world: "look", "where is the key", "talk to the butler".)`;
+      note(trace, "intermediate: HONEST-EMPTY POLISH — a live adventure miss points at the teach lane and the world asides, not the --repo remedy");
+    } else if (browser) {
+      answer = `${answer}\n(I don't know that yet — you can teach me: say "remember: <thing> is a <kind>".)`;
+      note(trace, "intermediate: HONEST-EMPTY POLISH — a browser miss points at the teach lane, not the CLI-only --repo remedy");
+    } else {
+      answer = `${answer}\n(this repo has no code graph — for structure, point me at a \`.tmct/graph.json\` with \`--repo <path>\` or run \`npm run example:mini\`; tmct doesn't index code itself.)`;
+      note(trace, "intermediate: HONEST-EMPTY POLISH — the loaded graph has 0 modules, so the dead-end got a --repo/tmct init pointer appended");
+    }
   }
   // TEACH-OFFER: a "what is X" miss where X is genuinely unknown EVERYWHERE —
   // not a real graph entity, not a schema/vocab term, and not already in
@@ -12497,20 +12843,24 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
     answer = `hypothetically, if ${counterfactualSubject[1].trim()} were removed: ${answer}`;
     note(trace, `intermediate: COUNTERFACTUAL_RE matched — compiled to a real traversal, wrapped as hypothetical ("${counterfactualSubject[1].trim()}" removed)`);
   }
-  // LIVE SUPPLEMENT (/wiki supplement): a grounded answer also carries what
-  // Wikipedia says about its subject — corroboration, not rescue. Scoped to a
-  // clean vocabulary subject (a "what is X" / "tell me about X" term), never a
-  // code-graph entity, and never doubled onto an answer that already IS a
-  // Wikipedia read-out. Failure-tolerated, and network-gated by the same toggle
-  // (the "supplement" value is truthy, so the rescue lanes above already ran).
-  if (liveReference === "supplement" && !recordMiss && via !== "reference") {
-    const supplementTerm = metaTermOf(query, envelope) || vagueTouchTermOf(query);
+  // LIVE SUPPLEMENT (/wiki supplement, and its superset /wiki always): a
+  // grounded answer also carries what Wikipedia says about its subject —
+  // corroboration, not rescue. Scoped to a clean vocabulary subject (a
+  // "what is X" / "tell me about X" term), never doubled onto an answer that
+  // already IS a Wikipedia read-out. Failure-tolerated, and network-gated by
+  // the same toggle (both values are truthy, so the rescue lanes above already
+  // ran). "always" widens the term fallback to an ordinary grounded ask's own
+  // parsed object, so a plain code/fact answer also gets corroborated; the
+  // adapter's throttle bounds the request rate.
+  if ((liveReference === "supplement" || liveReference === "always") && !recordMiss && via !== "reference") {
+    const supplementTerm = metaTermOf(query, envelope) || vagueTouchTermOf(query)
+      || (liveReference === "always" ? envelope?.parsed?.object : null);
     let liveKey = null;
     try { liveKey = supplementTerm ? cleanMissLiveTerm(supplementTerm, lexicon ?? undefined) : null; } catch { liveKey = null; }
     const live = liveKey ? await liveReferenceAnswerForKey(liveKey, onLiveLookup) : null;
     if (live) {
       answer = `${answer}\nWikipedia adds: ${live.text}`;
-      await ingestReferenceArticle(memoryDir, live.key, live.article, cache, liveProvenanceTag, lexicon);
+      await ingestReferenceArticle(memoryDir, live.key, live.article, cache, liveProvenanceTag, lexicon, synthesisBudget);
       note(trace, `intermediate: LIVE SUPPLEMENT — appended a cited en.wikipedia.org read-out for "${supplementTerm}" (supplement mode)`);
     }
   }
@@ -12653,13 +13003,14 @@ async function runCommand(line, { config, source, graph, focus, memoryDir, trace
   // state). A bare "/wiki" reports the CURRENT state and changes nothing.
   if (name === "wiki") {
     const arg = argText.toLowerCase();
-    const stateWord = (v) => (v === "supplement" ? "supplement" : v ? "on" : "off");
-    if (arg !== "on" && arg !== "off" && arg !== "supplement") {
-      return mk(`live Wikipedia supplement is ${stateWord(liveReference)} — /wiki on, /wiki off, or /wiki supplement. `
+    const stateWord = (v) => (v === "always" ? "always" : v === "supplement" ? "supplement" : v ? "on" : "off");
+    if (arg !== "on" && arg !== "off" && arg !== "supplement" && arg !== "always") {
+      return mk(`live Wikipedia supplement is ${stateWord(liveReference)} — /wiki on, /wiki off, /wiki supplement, or /wiki always. `
         + "When on, a question I can't answer also tries en.wikipedia.org (network); "
-        + "supplement adds a cited Wikipedia read-out under every grounded answer too.");
+        + "supplement adds a cited Wikipedia read-out under every grounded vocabulary answer too; "
+        + "always widens that to every grounded answer.");
     }
-    const next = arg === "supplement" ? "supplement" : arg === "on";
+    const next = arg === "always" ? "always" : arg === "supplement" ? "supplement" : arg === "on";
     return mk(`live Wikipedia supplement ${stateWord(next)}.`, { liveReferenceNext: next });
   }
 
@@ -13747,7 +14098,7 @@ function vocabAntecedentFrom(last) {
   return m[1];
 }
 
-export async function runTurn(input, { config, source = defaultSource, graph = null, focus = null, last = null, memoryDir = null, sessionId = "", env = process.env, lexicon = null, narrate = false, liveReference = false, onLiveLookup = null, vocabHint = null, tel = null, biasByBundle = {}, factRowsCache: injectedFactRowsCache = null, planState = null, gameConfig = null, _noSplit = false } = {}) {
+export async function runTurn(input, { config, source = defaultSource, graph = null, focus = null, last = null, memoryDir = null, sessionId = "", env = process.env, lexicon = null, narrate = false, liveReference = false, onLiveLookup = null, vocabHint = null, tel = null, biasByBundle = {}, factRowsCache: injectedFactRowsCache = null, planState = null, gameConfig = null, uiContext = "cli", synthesisBudget = AUTO_SYNTHESIS_BUDGET, researchState = null, researchConfig = null, _noSplit = false } = {}) {
   // Every game's tuning knobs (spider-fly's mass economy, guess-the-number's
   // bounds, the shared plan lane's search-depth cap) — a caller's own
   // gameConfig (chat-session.mjs resolves one per session from tmct.toml)
@@ -13812,7 +14163,7 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
   // the PLAN NEXT block below write planHolder.state; every other path leaves
   // it untouched, and the caller re-threads whatever comes back.
   const planHolder = { state: planState };
-  const ctx = { config, source, graph, focus, last, memoryDir, sessionId, templates, env, lexicon, trace, narrate, liveReference, onLiveLookup, vocabHint: resolvedVocabHint, tel, biasByBundle, cache: factRowsCache, vocabAntecedent, planHolder, gameConfig: resolvedGameConfig };
+  const ctx = { config, source, graph, focus, last, memoryDir, sessionId, templates, env, lexicon, trace, narrate, liveReference, onLiveLookup, vocabHint: resolvedVocabHint, tel, biasByBundle, cache: factRowsCache, vocabAntecedent, planHolder, gameConfig: resolvedGameConfig, uiContext, synthesisBudget };
   // A DISPATCHED turn (count / slash-command / ask) becomes the new "last
   // answer" that why/say-more re-renders; a conversational turn does not.
   // Every dispatched turn's result passes through finish() here — the LAST
@@ -13950,6 +14301,47 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
     }
   }
 
+  // RESEARCH — "research <topic>[, limit N]" runs a Simple English Wikipedia
+  // queue through the same ingest path a live-Wikipedia rescue uses: depth 0
+  // now, the lead section's linked topics queued for "research next" (which
+  // the web pages' auto-play button submits turn by turn). The explicit
+  // request is the network consent for its own fetches — unlike the
+  // clean-miss rescue, which fires on an ordinary question and so stays
+  // behind /wiki on. Queue state threads turn-to-turn as researchState, the
+  // same way planState does.
+  {
+    const researchHolder = { state: researchState };
+    const resolvedResearchConfig = researchConfig ?? RESEARCH_DEFAULTS;
+    const rTurn = await researchTurn(workingLine, {
+      holder: researchHolder,
+      memoryDir,
+      lexicon,
+      provider: getResearchProvider({ minIntervalMs: resolvedResearchConfig.minIntervalMs }),
+      config: resolvedResearchConfig,
+      planActive: Boolean(planHolder.state && !planHolder.state.done),
+      pagerActive: Boolean(Array.isArray(last?.detail?.pending?.items) && last.detail.pending.items.length),
+      notify: onLiveLookup,
+      ingest: (key, article, tag) =>
+        ingestReferenceArticle(memoryDir, key, article, factRowsCache, () => tag, lexicon, synthesisBudget),
+    });
+    if (rTurn) {
+      note(trace, `lane: ${rTurn.note}`);
+      note(trace, `goal: ${rTurn.goal}`);
+      const result = plainTurn(workingLine, rTurn.text, { via: "research", miss: !!rTurn.miss, focus });
+      result.lane = "research";
+      const snapshot = researchSnapshot(researchHolder.state);
+      if (snapshot) result.record.research = snapshot;
+      const rec = withLast(result, rTurn.goal);
+      rec.planState = planHolder.state;
+      rec.researchState = researchHolder.state;
+      // Present on EVERY research turn — null when the run ended or never
+      // started — so a UI can tell "queue cleared" from "not a research
+      // turn" (where the field is absent entirely).
+      rec.research = snapshot;
+      return rec;
+    }
+  }
+
   // Conversational layer next (greetings, thanks, help, bye, why/say-more) — these
   // resolve no entity and carry their own preserved `last`. Bypasses withLast (a
   // conversational turn is never finish()'d / never becomes a new `last`), so the