@polycode-projects/the-mechanical-code-talker 0.9.10 → 0.9.12

package/ROADMAP.md

@@ -650,13 +650,45 @@ outward from high-trust premises (the provenance primitive) toward novel, releva
 timestamping each so recency and novelty stay computable. The mechanics are the easy half
 (bounded forward chaining materializes entailments; backward chaining from frequent query shapes
 pre-derives likely answers). **The residual hard half is still the FRAME PROBLEM / relevance
-realization — unsolved in the general case and not pretended otherwise;** trust+novelty+relevance
-are the tractable approximation, not a solution. The plan's job is
-to make it TRACTABLE in tmct's narrow, closed world, not to solve it: usefulness is approximated
-from what the system actually gets asked (query-shape frequency), what connects to recent focus,
-what a cheap forward step yields that isn't already stored, and a hard
-budget (inference is bounded, its output trust-scored via the provenance primitive, and anything
-speculative is retractable and never outranks a stated fact). Everything else is deferred to the
+realization — unsolved in the general case and not pretended otherwise.** This is not one problem
+but two, of different hardness (full literature + citations in `PLAN_CAPABILITY_ROUTER.md`'s "The
+open-world boundary" section):
+
+- **The frame-*axiom* problem — solved, inside a declared world.** McCarthy & Hayes named it in
+  1969 ("Some Philosophical Problems from the Standpoint of Artificial Intelligence", *Machine
+  Intelligence* 4); Reiter's 1991 successor-state axioms and Kowalski & Sergot's 1986 event
+  calculus (*New Generation Computing* 4(1)) both solve the narrow reading — stating what changes
+  without enumerating what doesn't — inside a **declared** effect/predicate model. That's exactly
+  the OWL base the Syllogist forward-chains over: the axioms and rules are declared, so applying
+  them is mechanical, bounded, and already shipped (`src/syllogise.mjs`).
+- **The relevance-*bounding* problem — genuinely open, and possibly not just unbuilt.** Given the
+  unbounded set of entailments a rich KB licenses, which ones are worth materializing *before
+  anyone asks* — without an oracle telling the pass what matters? That is McCarthy's deeper,
+  unsolved reading, and it has no known algorithm. It is also, independently, the central problem
+  a live cognitive-science literature has converged on: Vervaeke, Lillicrap & Richards ("Relevance
+  Realization and the Emerging Framework in Cognitive Science", *Journal of Logic and Computation*
+  22(1):79–99, 2012) frame it as the pervasive problem cognitive science keeps rediscovering: Jaeger,
+  Riedl, Djedovic, Vervaeke & Walsh ("Naturalizing relevance realization: why agency and cognition
+  are fundamentally not computational", *Frontiers in Psychology*, 2024) go further and argue —
+  contestably, but rigorously, not as a popular-science claim — that relevance realization
+  *cannot* be an algorithmic process at all, by an analogy to Gödelian incompleteness. Take that as
+  a live, unresolved argument, not a proof: the honest position is that tmct doesn't know whether
+  this is "hard" or "impossible", and says so.
+
+trust+novelty+relevance (query-shape frequency, recent-focus connectivity, a hard depth/budget
+cap) are the **tractable approximation** the plan actually ships — a proxy for relevance, not a
+solution to it, and openly so. **A speculative angle, still respecting no-LLM-in-product:** the
+same bounded-region trick sketched for the router's open-world goal recognition
+(`PLAN_CAPABILITY_ROUTER.md`) applies here. Instead of trying to bound relevance globally (the
+open problem above), bound it *per query-shape*: a query shape already declares which
+predicates/fluents it touches — it's how `parseQuery` resolves it — so restricting speculative
+forward-chaining to premises reachable within N hops of an **observed** query shape's declared
+predicates is a *structurally*-bounded relevance filter, not a learned or statistical one. It is
+narrower than "what's relevant in general" (that stays open) but might be enough to keep
+materialization from drifting into computing entailments nobody will ever ask about — trading
+"relevant to anyone" (unsolved) for "relevant to what this system has actually been asked"
+(a proxy, but a principled, deterministic one). This has not been built or measured; it is a
+candidate for the plan's next spike, not a claimed result. Everything else is deferred to the
 plan's open questions, where the relevance problem is named as the open research risk it is.
 
 ### Open-source the ACE-OWL parser as a standalone library
@@ -811,7 +843,72 @@ critical build path:
 ## Phase LATER — recognized, deferred, not now
 
 Features we have deliberately shaped seams for but will not build until the phases above have
-earned them:
+earned them. **Not everything below is deferred for the same reason** — the design horizon,
+stated explicitly (2026-07-08 research pass):
+
+### The design horizon
+
+**Before the horizon — known-how, not-yet-built, no research risk.** Sequencing or engineering
+debt: the technique exists (in tmct's own prior work or the wider literature), building it is a
+matter of scheduling and effort, not discovery. Everything shipped this session lives here, plus:
+tone-of-voice adaptation (below — deliberately dropped by design choice, not unsolved);
+tier-4 learn-on-miss (below — prerequisites not yet met, not research-blocked); `PLAN_CODE.md`
+Tracks 2–4 (mutation search/repair, JS/HTML/CSS synthesis — APR and CEGIS are established
+techniques); `PLAN_OSS_ACE_PARSER.md` (pure extraction/packaging); OWL 2 RL forward-chaining and
+DL tableau consistency checking (`PLAN_INFERENCE_TESTING.md` stages 3–5 — the W3C's own OWL 2 RL
+profile is a published, complete rule table; Pellet/HermiT/RDFox/Jena are real production
+reasoners built on solved theory); RETE/incremental forward-chaining (same doc — Forgy 1982 is a
+citable, portable algorithm); contingent/conformant planning under initial-state uncertainty
+(`PLAN_CAPABILITY_ROUTER.md` — Bonet & Geffner 2000, Hoffmann & Brafman 2006, Petrick & Bacchus
+2002 all have working algorithms); ordinary closed-domain anaphora resolution (`nextFocus`,
+already shipped, plus a real theoretical grounding available in Grosz/Joshi/Weinstein's centering
+theory, 1995).
+
+**After the horizon — genuinely unsolved in the field, or abandoned by the field in favor of
+approaches tmct's no-LLM ethos rules out.** Named as real research targets, with citations, not
+stop signs (full detail + full citation lists in each owning doc):
+- **The frame problem / relevance realization** — the open-world planning boundary
+  (`PLAN_CAPABILITY_ROUTER.md`'s "The open-world boundary" section; this doc's tier-5 Syllogist
+  paragraph below). McCarthy & Hayes 1969 named it; Jaeger, Riedl, Djedovic, Vervaeke & Walsh
+  (2024) argue it may not be algorithmically solvable in the general case at all. Speculative
+  angle recorded: bounded (N+1) goal recognition — recognize declared goal 1..N, or reject to an
+  explicit "escalate" class, via parse-shape membership (the same mechanism Bug 8's domain gate
+  already uses) — not published anywhere found.
+- **Symbolic (non-neural) dependency parsing at real coverage** — `PLAN_ADVANCED_GRAMMAR.md`
+  track (c). Largely abandoned by mainstream NLP research once neural parsers won CoNLL
+  2017/2018, not disproven at any fixed data budget. Speculative angle: a hand-built,
+  closed-vocabulary disjunct/category dictionary (Link Grammar/CCG-style) scoped only to tmct's
+  own closed relation vocabulary, registered as another additive interpretation strategy.
+- **Winograd-hard commonsense coreference** — `PLAN_ADVANCED_GRAMMAR.md` track (g). Genuinely
+  open without either massive statistical priors (ruled out) or a full commonsense KB (Cyc's
+  decades-long cautionary history). Speculative angle: tmct's own closed, complete graph makes a
+  *narrow slice* of Winograd-shaped ambiguity a graph-query-filtering problem rather than
+  open-domain commonsense reasoning — explicitly not the same as solving Winograd.
+- **Bounded, incremental, trust-tiered, retraction-safe justification tracking** —
+  `PLAN_INFERENCE_TESTING.md`'s stage-3/4/5 discussion. Doyle's JTMS (1979) and de Kleer's ATMS
+  (1986) solve retraction; DRed/RDFox's Backward-Forward solve incremental Datalog maintenance;
+  nobody has published the specific combination with tmct's multi-trust-tier, hard-budget
+  requirement. Speculative angle: an ATMS-lite extension to `syllogise.mjs`'s currently-flat
+  provenance tag, sketched but unbuilt.
+- **A shared ~2M-word cross-domain ontology (1M general-English base + 1M
+  technical/scientific/engineering/programming-language/slang)** — `PLAN_ontology-hierarchies.md`
+  §7, additive to (not a revision of) that doc's existing track (e), which stays about importing
+  raw WordNet into tmct's own small tier-1 corpus specifically. Walked into, not avoided: merging
+  two 1M-word vocabularies collides senses of lexically-shared words (`class`, `cache`, `thread`,
+  `wave`, `cell`, `field`, `state`, …) across general/CS/physics/biology/slang registers —
+  knowledge-based (non-neural) WSD is real but measurably weaker than supervised/neural WSD (Lesk
+  1986; Raganato, Camacho-Collados & Navigli, EACL 2017), and BabelNet (Navigli & Ponzetto,
+  *Artificial Intelligence* 193, 2012) proves automatic cross-resource sense merging at this scale
+  is achievable — but its own pipeline moved toward statistical/graph-ML methods as it scaled,
+  solves the cross-*lingual* not cross-*domain* axis, and carries a non-commercial licence, so it
+  is a precedent, not a usable vehicle. Speculative angle recorded: mutual disambiguation from
+  already-resolved neighbouring terms in tmct's own closed graph (a structurally-bounded,
+  deterministic reading of Gale/Church/Yarowsky's "one sense per discourse/collocation"
+  regularities) — not published anywhere found for this application.
+
+Every item above is honestly labeled speculative — a direction recorded so it isn't
+re-discovered from scratch, not a committed build plan. None of it is scheduled; the phases above
+this line are still the actual near-term work.
 
 ### Tone-of-voice adaptation (dropped from Phase 6, 2026-07-05)
 Per-voice synonym/phrase substitution over prose spans. Dropped because tmct's protected-span

package/data/templates/responses.jsonl

@@ -60,10 +60,12 @@
 {"id":"conversational-greeting-good-evening","class":"conversational","register":"friendly","template":"Good evening. Ask me about this codebase, or /help."}
 {"id":"conversational-thanks","class":"conversational","register":"friendly","template":"Any time. Ask another, or /help for what I can do."}
 {"id":"conversational-farewell","class":"conversational","register":"friendly","template":"Bye — flushing the session log. Come back with a question any time."}
-{"id":"orientation-friendly","class":"orientation","register":"friendly","template":"I answer questions about THIS codebase's structure — imports, calls, definitions,\nhistory and counts. For example:\n  which modules import {example1}\n  what calls {example2}\n  how many classes are there\n/help for commands, /stats for an overview of the graph."}
+{"id":"orientation-friendly","class":"orientation","register":"friendly","template":"I'm tmct — a deterministic, offline code-graph assistant (no LLM). I answer questions about THIS codebase's structure — imports, calls, definitions,\nhistory and counts. For example:\n  which modules import {example1}\n  what calls {example2}\n  how many classes are there\n/help for commands, /stats for an overview of the graph."}
 {"id":"miss-no-previous-answer","class":"miss","register":"friendly","template":"No previous answer to expand yet — ask me a question first, then say \"why\" or \"say more\"."}
-{"id":"conversational-greeting-empty","class":"conversational","register":"friendly","template":"Hi. There's no code graph loaded here — for code structure (imports, calls, definitions) I need a `.tmct/graph.json`: point me at one with `--repo <path>`, or try the shipped example `npm run example:mini`. (tmct reads graphs; it doesn't index code itself.) For general vocabulary, `tmct init` seeds concepts — try \"what is a cache\". /help for commands."}
-{"id":"orientation-empty","class":"orientation","register":"friendly","template":"There's no code graph loaded here, so I can't answer structure questions (imports, calls, definitions) yet.\nFor those I need a `.tmct/graph.json` produced by a graph producer — point me at one with `--repo <path>`, or try the shipped example `npm run example:mini`. tmct reads graphs; it doesn't index code itself.\nFor general vocabulary, `tmct init` seeds concepts — try \"what is a cache\". /help for commands, /memory for what I remember."}
+{"id":"conversational-greeting-empty","class":"conversational","register":"friendly","template":"Hi. I'm tmct. {vocabHint} Point me at a repo with `--repo <path>` for code-structure questions too (imports, calls, definitions). /help for commands."}
+{"id":"orientation-empty","class":"orientation","register":"friendly","template":"I'm tmct — a deterministic, offline chat assistant (no LLM). {vocabHint} /memory for what I remember.\nFor code structure (imports, calls, definitions) point me at a repo: `--repo <path>`, or try the shipped example `npm run example:mini`. tmct reads graphs; it doesn't index code itself.\n/help for commands."}
+{"id":"identity-self","class":"conversational","register":"friendly","template":"I'm tmct — a deterministic, offline chat assistant. No LLM: wink-nlp parsing over a seeded ontology/lexicon, plus a code graph when you point me at a repo with `--repo <path>`. /help for commands, /stats for an overview."}
+{"id":"identity-not-an-llm","class":"conversational","register":"friendly","template":"No — no LLM involved. tmct is deterministic: wink-nlp parsing over a graph/ontology, not a language model. /help for commands."}
 {"id":"technical-density","class":"count","register":"technical","template":"{subject} carries {count} {noun} across {scope} — a concentration well above what a codebase of this size typically sustains ({provenance})."}
 {"id":"technical-comparison","class":"count","register":"technical","template":"At {count} {noun}, {subject} sits {comparison} the comparable-project baseline, a divergence that reflects deliberate structure rather than measurement noise ({provenance})."}
 {"id":"technical-superlative","class":"count","register":"technical","template":"No {noun} in {scope} is more {metric} than {subject}; it leads the next candidate by a clear margin of {count} ({provenance})."}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polycode-projects/the-mechanical-code-talker",
-  "version": "0.9.10",
+  "version": "0.9.12",
   "private": false,
   "type": "module",
   "description": "The Mechanical Code Talker (tmct) — a tolerant, offline, $0 chat surface that guides you toward precision queries about a software repository. ELIZA/PARRY-style but domain-obsessed with code. No model calls; no codebase index of its own.",

package/src/chat.mjs

@@ -54,6 +54,7 @@ import { loadTemplates, render as renderTemplate } from "./corpus/templates.mjs"
 import { finish } from "./finish.mjs";
 import { VERB_TO_KIND, WHERE_MARKERS, MENTION_MARKERS, ENTITY_TO_TYPE } from "./ask-vocab.mjs";
 import { COUNTERFACTUAL_RE } from "./interpret/normalize.mjs";
+import { fuzzyMatchInSet, fuzzyBound } from "./interpret/fuzzy.mjs";
 
 // uuidv7 lives in ./uuid.mjs (shared with telemetry + the bench stamp); re-exported
 // here because callers/tests still import it from chat.mjs.
@@ -497,15 +498,38 @@ export function renderStats(graph) {
 
 // ---- friendly handling of non-structural / conversational input ----
 
-/** Greetings and small-talk openers that should get a friendly orientation line,
- *  never the raw grammar-miss hint. */
-const GREETINGS = new Set([
-  "hi", "hello", "hey", "yo", "sup", "hiya", "howdy", "hey there", "hi there", "hello there",
-  "thanks", "thank you", "thankyou", "thx", "ty", "cheers", "ok", "okay", "cool",
-]);
-const HELP_PHRASES = [
+/** CAPABILITY questions ("what can you do") — distinct from IDENTITY questions
+ *  ("who are you") below. Both used to be conflated into one HELP_PHRASES list,
+ *  which meant "who are you" always got the "here's what I can query" blurb and
+ *  never a self-description — split so each gets the answer it actually asked for. */
+const CAPABILITY_PHRASES = [
   /^what can (you|u) do\??$/i, /^what do you do\??$/i, /^help( me)?\??$/i, /^\?+$/,
-  /^who are you\??$/i, /^what (is|are|r) (this|you)\??$/i, /^how do (i|you) work\??$/i,
+  /^how do (i|you) work\??$/i, /^how does (this|it) work\??$/i,
+  // unix-habit openers typed inside the REPL out of muscle memory — argv-only
+  // today (bin/tmct.mjs), dead once inside the chat loop; route to the same
+  // capability answer a plain "help" gets.
+  /^--help$/i, /^-h$/i, /^man( tmct)?\??$/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
+ *  state, never the code-graph deflection. */
+const IDENTITY_PHRASES = [
+  /^who are you\??$/i, /^what (is|are|r) (this|you)\??$/i,
+  /^what('?s| is) your name\??$/i, /^what exactly are you\??$/i,
+  /^(tell me about|introduce) yourself\??$/i, /^what is this thing\??$/i,
+  /^what am i (talking|speaking|chatting) (to|with)\??$/i,
+  /^you are what\??$/i, /^what thing (are|is) you\??$/i,
+  /^explain( to me)? what (you are|this is)\??$/i,
+  /^whoami\??$/i,
+];
+/** "Are you an LLM/AI/bot" — tmct's actual positioning (no LLM, deterministic) is
+ *  a genuinely different, more specific answer than the generic self-description,
+ *  and this is a very likely first question given how most chat tools work today. */
+const AI_IDENTITY_PHRASES = [
+  /^(are you|r u) (an? )?(ai|a bot|chatgpt|gpt|an? llm|a language model|a robot)\??$/i,
+  /^is this (chatgpt|gpt|claude|an? ai|an? llm)\??$/i,
+  /^do you use ai\??$/i, /^what language model are you( using)?\??$/i,
+  /^am i (talking|speaking|chatting) (to|with) a (real )?(person|human|bot|ai)\??$/i,
 ];
 /** The structural verbs/nouns that mark a near-miss code question (→ keep the
  *  precise grammar hint, not the friendly nudge). */
@@ -523,16 +547,24 @@ const STRUCT_WORDS = new Set([
   "testing", "defining", "touching", "extending", "inheritance", "coverage", "member", "members",
 ]);
 
+/** Is this raw/normalized query "code-ish" (a dotted/pathed/CamelCase name, "()",
+ *  or a structural keyword)? Shared by isConversational and the fuzzy-typo fallback
+ *  so neither ever grabs a genuine near-miss structural question. */
+function looksCodeish(raw, q) {
+  return /[a-z][A-Z]|[_./]|\(\)/.test(raw) || q.split(/\s+/).some((w) => STRUCT_WORDS.has(w));
+}
+
 /** Does this look like small-talk / an orientation request rather than a
- *  (near-miss) structural question? Greetings & help-phrases always qualify; a
- *  very short input with no code-ish token (dotted/pathed/CamelCase name, "()",
- *  or a structural keyword) does too. */
+ *  (near-miss) structural question? Greetings & help/identity phrases always
+ *  qualify; a very short input with no code-ish token does too. */
 export function isConversational(query) {
   const raw = String(query).trim();
   const q = raw.toLowerCase().replace(/[.!?]+$/, "").trim();
-  if (GREETINGS.has(q)) return true;
-  if (HELP_PHRASES.some((re) => re.test(raw))) return true;
-  const codeish = /[a-z][A-Z]|[_./]|\(\)/.test(raw) || q.split(/\s+/).some((w) => STRUCT_WORDS.has(w));
+  if (GREET.has(q) || THANKS.has(q) || OK_ACK.has(q)) return true;
+  if (CAPABILITY_PHRASES.some((re) => re.test(raw))) return true;
+  if (IDENTITY_PHRASES.some((re) => re.test(raw))) return true;
+  if (AI_IDENTITY_PHRASES.some((re) => re.test(raw))) return true;
+  const codeish = looksCodeish(raw, q);
   return q.split(/\s+/).filter(Boolean).length <= 3 && !codeish;
 }
 
@@ -562,6 +594,11 @@ const T_WHY_EMPTY = "miss-no-previous-answer";
  *  over-promising "ask me about this codebase". */
 const T_GREETING_EMPTY = "conversational-greeting-empty";
 const T_ORIENTATION_EMPTY = "orientation-empty";
+/** IDENTITY answers — self-description and the "no LLM" clarification. Both work
+ *  regardless of graph state (no empty/populated variant): what tmct IS doesn't
+ *  depend on whether a repo is loaded. */
+const T_IDENTITY_SELF = "identity-self";
+const T_IDENTITY_NOT_LLM = "identity-not-an-llm";
 /** 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";
@@ -589,30 +626,115 @@ function tRender(templates, id, slots = {}) {
 // they record as plain turns with empty resolvedIds and never become mgx:asksAbout
 // graph edges (same as /help). Register stays plain and short: this is a code tool.
 
-/** Greetings → a short friendly line + one nudge. A couple carry a tasteful nod. */
+/** Greetings → a short friendly line + one nudge. A couple carry a tasteful nod.
+ *  Deliberately broad across register/dialect (UK/US/AU/NZ, formal, slang, texting
+ *  abbreviation) — a CLOSED curated list, same "never guess" ethos as the rest of
+ *  the file, just a bigger one; see collapseRuns/fuzzyMatchInSet below for the
+ *  typo/elongation multiplier layered on top instead of enumerating every typo. */
 const GREET = new Set([
   "hi", "hello", "hey", "yo", "hiya", "howdy", "sup", "greetings",
   "g'day", "gday", "hey there", "hi there", "hello there",
   "good morning", "good afternoon", "good evening", "morning",
+  // UK/AU/NZ
+  "alright", "you alright", "alright mate", "morning all", "yeah nah",
+  // US
+  "hey y'all", "howdy there", "hiya there",
+  // formal
+  "good day", "salutations", "good to meet you", "pleased to meet you",
+  // slang
+  "yo yo", "ayy", "wassup", "sup fam", "heya", "hiya!",
+  // texting abbreviation
+  "gm", "ge",
 ]);
 /** Acknowledgements → an "any time" style reply. */
 const THANKS = new Set([
   "thanks", "thank you", "thankyou", "thx", "ty", "ta", "cheers", "nice one",
-  "much appreciated", "cool thanks",
+  "much appreciated", "cool thanks", "many thanks", "much obliged", "ta very much",
+  "cheers mate", "cheers for that", "tks", "sweet thanks", "nice",
 ]);
 /** Farewells → a goodbye AND a clean end of session (same path as /exit). */
 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",
+  "good day to you", "farewell then",
 ]);
 /** Elaboration asks → RE-RENDER the last answer verbosely (traversal + matches). */
 const WHY = new Set([
   "why", "how", "how so", "how come", "explain", "say more", "go on",
   "elaborate", "tell me more", "more detail", "expand",
 ]);
+/** Bare acknowledgements — routed identically to THANKS (an "ok"/"cool" after an
+ *  answer reads the same as a thanks, not a new question). Kept separate from
+ *  THANKS/GREET because these aren't greetings or gratitude, just closing a beat. */
+const OK_ACK = new Set([
+  "ok", "okay", "cool", "aight", "fair enough", "got it", "gotcha", "noted",
+  "sounds good", "sure", "cool cool", "right",
+]);
+/** New-user / confused openers — "I don't know what this is" reads as an
+ *  orientation request, not small-talk and not a grammar-wall near-miss; routed
+ *  the same as CAPABILITY_PHRASES (→ orientationAnswer). */
+const ORIENT_OPENERS = new Set([
+  "what", "huh", "confused", "i dont know what this is", "i don't know what this is",
+  "i'm lost", "im lost", "no idea what this does", "just installed this",
+  "just installed you", "i just installed this", "i just installed you",
+  "first time here", "just started", "new to this", "new here",
+]);
 
 // (Greeting/thanks/farewell wording moved to data/templates/responses.jsonl — W1.
 // The expression-specific greeting variants map through T_GREETING_BY_PHRASE above.)
 
+/** Aggressive char-run collapse (2+ identical chars → 1) — used ONLY to build a
+ *  lookup key, never to change what's actually said back. Lets a typed-out
+ *  elongation ("heyyyy", "hellooo", "thanksss") match its canonical phrase for
+ *  free: both the canonical phrase and the elongated input collapse to the same
+ *  key (a legitimate double letter like "hello"'s "ll" collapses identically on
+ *  both sides, so there's no canonical/typed asymmetry to get wrong). */
+const collapseRuns = (s) => s.replace(/(.)\1+/g, "$1");
+
+/** phrase(collapsed) → canonical phrase, built once per closed set. */
+function collapsedIndex(set) {
+  const idx = new Map();
+  for (const phrase of set) if (!idx.has(collapseRuns(phrase))) idx.set(collapseRuns(phrase), phrase);
+  return idx;
+}
+const GREET_COLLAPSED = collapsedIndex(GREET);
+const THANKS_COLLAPSED = collapsedIndex(THANKS);
+const BYE_COLLAPSED = collapsedIndex(BYE);
+
+/** Exact match, else the elongation-collapsed match, else null — the canonical
+ *  phrase either way, so callers never see the raw (possibly elongated) input. */
+function closedOrCollapsed(q, set, idx) {
+  if (set.has(q)) return q;
+  return idx.get(collapseRuns(q)) ?? null;
+}
+
+/** The fuzzy-typo fallback's candidate pool: every canonical phrase across the
+ *  closed conversational sets, flattened once. Consulted only after every exact/
+ *  collapsed lookup misses (see fuzzyConversationalMatch). */
+const CONVERSATIONAL_PHRASES = [
+  ...GREET, ...THANKS, ...BYE,
+  "what can you do", "what do you do", "help", "how do you work",
+  "who are you", "what are you", "what is your name",
+];
+function classifyConversational(phrase) {
+  if (GREET.has(phrase)) return "greet";
+  if (THANKS.has(phrase)) return "thanks";
+  if (BYE.has(phrase)) return "bye";
+  if (phrase === "who are you" || phrase === "what are you" || phrase === "what is your name") return "identity";
+  return "capability";
+}
+/** UNIQUE within-bound fuzzy match of the whole trimmed line against
+ *  CONVERSATIONAL_PHRASES — the "helo"/"thnx"/"wat r u"/"byee" tier. Restricted to
+ *  short (≤4-word), non-code-ish inputs (looksCodeish, shared with
+ *  isConversational) so a genuine near-miss structural question is never grabbed;
+ *  a distance tie is refused, never guessed (same discipline as fuzzyVocabWord). */
+function fuzzyConversationalMatch(raw) {
+  const q = collapseRuns(raw.toLowerCase().replace(/[.!?]+$/, "").trim());
+  const words = q.split(/\s+/).filter(Boolean);
+  if (!words.length || words.length > 4 || looksCodeish(raw, q)) return null;
+  return fuzzyMatchInSet(q, CONVERSATIONAL_PHRASES, Math.min(2, fuzzyBound(q)));
+}
+
 /** Re-render the last answer in verbose form: the previous query + its full answer
  *  plus the ask envelope's traversal receipt and the matched entities (the detail a
  *  terse render trims). `empty:true` when there's no previous answer to expand. */
@@ -643,7 +765,7 @@ export function renderVerbose(last) {
 function conversationalTurn(line, ctx) {
   const raw = String(line);
   const q = raw.toLowerCase().replace(/[.!?]+$/, "").replace(/\s+/g, " ").trim();
-  const t = (id) => tRender(ctx.templates, id) ?? TEMPLATES_UNAVAILABLE;
+  const t = (id, slots = {}) => tRender(ctx.templates, id, slots) ?? TEMPLATES_UNAVAILABLE;
   const mk = (answer, { end = false, miss = false, via = "template" } = {}) => {
     const ts = new Date().toISOString();
     return {
@@ -675,27 +797,61 @@ function conversationalTurn(line, ctx) {
     note(ctx.trace, `result: re-rendering the previous answer to "${ctx.last?.query ?? "?"}" verbosely`);
     return mk(v.text, { via: "conversational" });
   }
-  if (GREET.has(q)) {
-    note(ctx.trace, "goal: casual/social — greeting, no graph intent");
-    note(ctx.trace, "lane: conversational — greeting (GREET closed set)");
-    // #3 empty/degenerate-graph greeting: a plain "hi"/"hello" over a graph with 0
-    // modules orients toward --repo/tmct init instead of over-promising "ask me
-    // about this codebase". Phrase-specific variants (good morning, hello there)
-    // keep their wording; only the default greeting swaps.
-    const id = (!T_GREETING_BY_PHRASE[q] && noCodeGraph(ctx.graph)) ? T_GREETING_EMPTY : (T_GREETING_BY_PHRASE[q] || T_GREETING);
-    note(ctx.trace, `pattern: template "${id}" (data/templates/responses.jsonl)`);
-    return mk(t(id));
-  }
-  if (THANKS.has(q)) {
-    note(ctx.trace, "goal: casual/social — acknowledgement, no graph intent");
-    note(ctx.trace, "lane: conversational — thanks/acknowledgement (THANKS closed set)");
-    note(ctx.trace, `pattern: template "${T_THANKS}" (data/templates/responses.jsonl)`);
-    return mk(t(T_THANKS));
-  }
-  if (q === "help" || q === "?" || HELP_PHRASES.some((re) => re.test(raw))) {
+  {
+    const greetHit = closedOrCollapsed(q, GREET, GREET_COLLAPSED);
+    if (greetHit) {
+      note(ctx.trace, "goal: casual/social — greeting, no graph intent");
+      note(ctx.trace, `lane: conversational — greeting (GREET closed set${greetHit === q ? "" : ", elongation-collapsed"})`);
+      // #3 empty/degenerate-graph greeting: a plain "hi"/"hello" over a graph with 0
+      // modules leads with the (now provably-correct) vocabulary hint instead of
+      // over-promising "ask me about this codebase". Phrase-specific variants (good
+      // morning, hello there) keep their wording; only the default greeting swaps.
+      const id = (!T_GREETING_BY_PHRASE[greetHit] && noCodeGraph(ctx.graph)) ? T_GREETING_EMPTY : (T_GREETING_BY_PHRASE[greetHit] || T_GREETING);
+      note(ctx.trace, `pattern: template "${id}" (data/templates/responses.jsonl)`);
+      return mk(t(id, { vocabHint: ctx.vocabHint }));
+    }
+  }
+  {
+    const thanksHit = closedOrCollapsed(q, THANKS, THANKS_COLLAPSED) || (OK_ACK.has(q) ? q : null);
+    if (thanksHit) {
+      note(ctx.trace, "goal: casual/social — acknowledgement, no graph intent");
+      note(ctx.trace, `lane: conversational — thanks/acknowledgement (${OK_ACK.has(q) ? "OK_ACK" : "THANKS"} closed set${thanksHit === q ? "" : ", elongation-collapsed"})`);
+      note(ctx.trace, `pattern: template "${T_THANKS}" (data/templates/responses.jsonl)`);
+      return mk(t(T_THANKS));
+    }
+  }
+  if (AI_IDENTITY_PHRASES.some((re) => re.test(raw))) {
+    note(ctx.trace, "goal: identity — is tmct an AI/LLM (a very likely first question)");
+    note(ctx.trace, "lane: conversational — identity/AI (AI_IDENTITY_PHRASES closed set)");
+    return mk(t(T_IDENTITY_NOT_LLM));
+  }
+  if (IDENTITY_PHRASES.some((re) => re.test(raw))) {
+    note(ctx.trace, "goal: identity — who/what tmct is, not a capability listing");
+    note(ctx.trace, "lane: conversational — identity (IDENTITY_PHRASES closed set)");
+    return mk(t(T_IDENTITY_SELF));
+  }
+  if (q === "help" || q === "?" || CAPABILITY_PHRASES.some((re) => re.test(raw)) || ORIENT_OPENERS.has(q)) {
     note(ctx.trace, "goal: get oriented — what can tmct answer, how do I start");
-    note(ctx.trace, "lane: conversational — help/orientation (HELP_PHRASES / bare help / ?)");
-    return mk(orientationAnswer(ctx.templates, ctx.graph));
+    note(ctx.trace, "lane: conversational — help/orientation (CAPABILITY_PHRASES/ORIENT_OPENERS / bare help / ?)");
+    return mk(orientationAnswer(ctx.templates, ctx.graph, ctx.vocabHint));
+  }
+  // Fuzzy-typo fallback (A4): every exact/collapsed closed-set lookup above missed —
+  // try a bounded edit-distance match against the flattened conversational phrase
+  // pool ("helo", "thnx", "wat r u", "byee"), restricted to short non-code-ish
+  // input so a genuine near-miss structural question is never grabbed.
+  {
+    const fuzzyHit = fuzzyConversationalMatch(raw);
+    if (fuzzyHit) {
+      const bucket = classifyConversational(fuzzyHit);
+      note(ctx.trace, `goal: casual/social or orientation — fuzzy-typo match "${raw}" → "${fuzzyHit}"`);
+      note(ctx.trace, `lane: conversational — fuzzy typo tolerance (${bucket})`);
+      if (bucket === "bye") return mk(t(T_FAREWELL), { end: true });
+      if (bucket === "thanks") return mk(t(T_THANKS));
+      if (bucket === "identity") return mk(t(T_IDENTITY_SELF));
+      if (bucket === "capability") return mk(orientationAnswer(ctx.templates, ctx.graph, ctx.vocabHint));
+      const id = (!T_GREETING_BY_PHRASE[fuzzyHit] && noCodeGraph(ctx.graph)) ? T_GREETING_EMPTY : (T_GREETING_BY_PHRASE[fuzzyHit] || T_GREETING);
+      return mk(t(id, { vocabHint: ctx.vocabHint }));
+    }
   }
   return null;
 }
@@ -754,22 +910,30 @@ function orientationExamples(graph) {
   return { example1, example2 };
 }
 
-/** The orientation surface, module-aware: the empty variant (→ --repo/tmct init +
- *  seeded vocabulary) when there's no code graph, the standard one (with live
- *  {example1}/{example2} query examples from the loaded graph) otherwise. */
-function orientationAnswer(templates, graph) {
-  if (noCodeGraph(graph)) return tRender(templates, T_ORIENTATION_EMPTY) ?? TEMPLATES_UNAVAILABLE;
+/** The orientation surface, module-aware: the empty variant (→ the provably-correct
+ *  vocabulary hint + --repo/tmct init) when there's no code graph, the standard one
+ *  (with live {example1}/{example2} query examples from the loaded graph) otherwise. */
+function orientationAnswer(templates, graph, vocabHint) {
+  if (noCodeGraph(graph)) return tRender(templates, T_ORIENTATION_EMPTY, { vocabHint }) ?? TEMPLATES_UNAVAILABLE;
   return tRender(templates, T_ORIENTATION, orientationExamples(graph)) ?? TEMPLATES_UNAVAILABLE;
 }
 
+/** A minimal, still identity-led fallback for orientationText's empty-graph branch
+ *  — used ONLY if the template library itself failed to load (tRender returned
+ *  null), matching the file's "never crash, always degrade to one honest line"
+ *  ethos. Kept short and hand-written so it never drifts silently. */
+const ORIENTATION_EMPTY_FALLBACK = "I'm tmct — a deterministic, offline chat assistant (no LLM). "
+  + "For code structure (imports, calls, definitions) point me at a repo with `--repo <path>`, "
+  + "or try the shipped example `npm run example:mini`. tmct reads graphs; it doesn't index code itself. /help for commands.";
+
 /** A dynamic orientation string for the meta/self lane: a /stats-style overview
- *  when a code graph is loaded, else the honest empty-graph orientation. */
-function orientationText(graph) {
+ *  when a code graph is loaded, else the honest empty-graph orientation — rendered
+ *  through the SAME template (T_ORIENTATION_EMPTY) conversationalTurn's orientation
+ *  branch uses, so there is exactly one copy of that wording to keep in sync, not
+ *  two hand-duplicated strings. */
+function orientationText(graph, templates, vocabHint) {
   if (noCodeGraph(graph)) {
-    return "There's no code graph loaded here, so I can't answer structure questions (imports, calls, definitions) yet. "
-      + "For those I need a `.tmct/graph.json` produced by a graph producer — point me at one with `--repo <path>`, "
-      + "or try the shipped example `npm run example:mini`. tmct reads graphs; it doesn't index code itself. "
-      + 'For general vocabulary, `tmct init` seeds concepts — try "what is a cache". /help for commands.';
+    return tRender(templates, T_ORIENTATION_EMPTY, { vocabHint }) ?? ORIENTATION_EMPTY_FALLBACK;
   }
   const by = (cls) => (graph.individuals || []).filter((i) => (i.class || "") === cls).length;
   const parts = [];
@@ -1008,13 +1172,18 @@ const WHAT_KNOW_RE = /^what\s+(?:do\s+you|d'?you)\s+know(?:\s+so\s+far)?$/;
 // first-touch question gets the live overview instead of the grammar wall.
 const META_ORIENT_RE = /^(?:what(?:'s| is| are)?\s+this(?:\s+(?:app|codebase|repo|repository|project|code|thing))?|what\s+(?:codebase|repo|repository|project)\s+is\s+this|what\s+does\s+(?:this|the)\s+(?:app|code|codebase|project|repo)\s+do|what\s+is\s+(?:this|the)\s+app(?:\s+for)?|what\s+am\s+i\s+looking\s+at|what\s+is\s+tmct|how\s+do\s+i\s+(?:start|begin|get\s+started|get\s+going|load\s+(?:my\s+)?code|index\s+(?:my\s+)?(?:code|repo|repository)|use\s+(?:this|you|tmct))|where\s+do\s+i\s+(?:start|begin))$/;
 
-/** A SHORT memory summary (never a fact dump) for the bare "what do you know". */
+/** A SHORT memory summary (never a fact dump) for the bare "what do you know".
+ *  This branch only fires when rows.length === 0 — i.e. precisely the case where
+ *  vocabulary seeding either hasn't run or produced nothing, so the hook makes NO
+ *  term-specific promise (an unconditionally-true pointer: the teach lane and
+ *  `tmct init` both work with zero preconditions), rather than suggesting a
+ *  vocabulary example that would be guaranteed to miss right after being offered. */
 async function memorySummary(memoryDir, graph) {
   const rows = memoryDir ? await memoryFacts(memoryDir) : [];
   if (!rows.length) {
     const hook = moduleCountOf(graph) > 0
       ? 'ask about this codebase\'s structure (imports, calls, definitions), or teach me with "every X is a Y"'
-      : 'teach me with "every X is a Y", or try general vocabulary like "what is a cache"';
+      : 'run `tmct init` to seed a starter vocabulary, or teach me directly with "every X is a Y"';
     return `I haven't been told any facts yet — ${hook}. /memory to inspect, /help for commands.`;
   }
   const preds = new Set(rows.map((f) => f.predicate).filter(Boolean));
@@ -1052,7 +1221,7 @@ async function moduleOrientLane(query, { graph }) {
   return { text: moduleOverviewText(graph, ind), via: "meta" };
 }
 
-async function metaLane(query, { graph, memoryDir, last = null }) {
+async function metaLane(query, { graph, memoryDir, last = null, templates = null, vocabHint = null }) {
   const q = String(query).trim().toLowerCase().replace(/[?.!]+$/, "").replace(/\s+/g, " ");
   if (WHAT_KNOW_RE.test(q) || q === "what have you learned" || q === "what have you learnt") {
     return { text: await memorySummary(memoryDir, graph), via: "meta" };
@@ -1065,7 +1234,7 @@ async function metaLane(query, { graph, memoryDir, last = null }) {
     // orientationText(graph) verbatim on every repeat, never collapsing). Mirrors
     // ORIENTATION_REPEAT_ONELINER's identity-check pattern exactly, with its own
     // distinct oneliner text (self-limiting for the same reason).
-    const text = orientationText(graph);
+    const text = orientationText(graph, templates, vocabHint);
     return { text: last?.answer === text ? META_ORIENT_REPEAT_ONELINER : text, via: "meta" };
   }
   // Bug E: an arbitrary "what does <term> do" that META_ORIENT_RE's closed noun
@@ -1530,6 +1699,23 @@ function renderFactLine(f) {
   return `i learned: ${factPhrase(f)}${cite}`;
 }
 
+/** PROOF-CHAIN RECEIPT (PLAN_INFERENCE_TESTING.md §4 stage 2; ROADMAP L788's
+ *  "renderable as a chain of thought in words"): render an ordered list of
+ *  premise Fact rows as one continuous argument — "cache is a kind of store;
+ *  store is a kind of component; so redis.mjs is a component" — each premise
+ *  cited via the SAME factPhrase + "(source: …)" convention renderFactLine
+ *  uses, just without its "you told me"/"i learned" framing (a chain reads as
+ *  one derivation, not a list of standalone recollections). The conclusion
+ *  clause is spelled directly from the first premise's subject and the last
+ *  premise's object — sound for any chain length, though today's only caller
+ *  (the live cax-sco/scm-sco chase below) ever passes exactly two. */
+function renderIsaChain(premises) {
+  const step = (f) => `${factPhrase(f)}${f.provenance ? ` (source: ${f.provenance})` : ""}`;
+  const first = premises[0];
+  const last = premises[premises.length - 1];
+  return `${premises.map(step).join("; ")}; so ${first.subject} is a ${last.object}`;
+}
+
 /** Read every reified Fact out of the memory graph as plain {subject, predicate,
  *  object, provenance} rows. Lazy + failure-tolerated: no memory → []. */
 async function memoryFacts(memoryDir) {
@@ -1892,6 +2078,40 @@ async function factReadBack(memoryDir, query, envelope, miss, graph = null) {
         };
       }
     }
+    // LIVE cax-sco / scm-sco PROOF CHASE (PLAN_INFERENCE_TESTING.md INF-A2,
+    // §4 stage 1): a direct isa fact and the graph inherits-bridge both
+    // missed — chase a chain over TWO TAUGHT isa-family facts (§1's PARTIAL
+    // note: "cax-sco over two TAUGHT facts is NOT implemented"; the band's own
+    // "Rules needed" column: "⊑-chain of length 2") via syllogise.mjs's
+    // findIsaChain, a rooted proof search built on the SAME two rule kernels,
+    // LIVE and READ-ONLY (nothing is written — the offline `tmct syllogise`
+    // batch pass, materializing the same two rules with `entailed:*`
+    // provenance, is the persisting counterpart). Deliberately narrow, twice
+    // over, to stay exactly in INF-A2's scope and not silently answer bands
+    // this stage doesn't (yet) certify:
+    //   - maxHops:2 — a longer taught chain is INF-B2's multi-hop +
+    //     proof-chain-materialization territory (§4 stage 2 proper), which
+    //     INFBENCH pins as an honest ceiling until it lands — answering
+    //     "yes" there today would be graded FABRICATION, not credit.
+    //   - CORPUS-sourced edges excluded — the bulk background corpus band
+    //     (trust 0.7) can coincidentally chain two unrelated classes into a
+    //     technically-true-per-ConceptNet "yes" that has nothing to do with
+    //     what the OPERATOR taught; only operator/teach/entailed-sourced isa
+    //     facts are chased, matching "TAUGHT" in the gap's own name.
+    const { findIsaChain, SUBCLASS_PREDICATE: SC_PREDICATE, TYPE_PREDICATE: RDF_TYPE_PREDICATE } = await import("./syllogise.mjs");
+    const isTaught = (f) => !f.sourceTypes?.includes("corpus") && !f.sourceTypes?.includes("web");
+    const chainSubClassRows = isa.filter((f) => f.predicate === SC_PREDICATE && isTaught(f));
+    const chainTypeRows = isa.filter((f) => f.predicate === RDF_TYPE_PREDICATE && isTaught(f));
+    const chainSubClassEdges = chainSubClassRows.map((f) => [f.subject, f.object]);
+    const chainTypeEdges = chainTypeRows.map((f) => [f.subject, f.object]);
+    const factForStep = (step) => (step.predicate === SC_PREDICATE ? chainSubClassRows : chainTypeRows)
+      .find((f) => f.subject === step.subject && f.object === step.object);
+    for (const subj of subjCandidates) {
+      const chain = findIsaChain(subj, objVariants, chainTypeEdges, chainSubClassEdges, { maxHops: 2 });
+      if (!chain) continue;
+      const premises = chain.map(factForStep);
+      if (premises.every(Boolean)) return { text: `yes — ${renderIsaChain(premises)}`, replace: true };
+    }
     return null; // no remembered fact — the honest miss stands (never a guessed "no")
   }
 
@@ -2347,7 +2567,7 @@ async function conceptForceAnswer(query, envelope, { graph, config, source, memo
  *  otherwise the unchanged dispatchTool path (which also yields the no-graph error).
  *  A hit updates the focus to the resolved object. Grammar miss / ToolError → a
  *  normal answer, never a crash. */
-async function runAsk(query, { config, source, graph, focus, last, templates, memoryDir, sessionId = "", lexicon = null, env, trace }) {
+async function runAsk(query, { config, source, graph, focus, last, templates, memoryDir, sessionId = "", lexicon = null, env, trace, vocabHint = null }) {
   const ts = new Date().toISOString();
   // DISCOURSE ANAPHORA (CHATBENCH_006 levers 1+2): a follow-up like "which of those
   // are tested" / "how many of those" / "count them" filters or counts the PREVIOUS
@@ -2472,7 +2692,7 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
   // codebase", "how do i start") → a summary / orientation, answered before the
   // fact-dump readers so "what do you know" gets a summary, not raw facts.
   if (miss) {
-    const meta = await metaLane(query, { graph, memoryDir, last });
+    const meta = await metaLane(query, { graph, memoryDir, last, templates, vocabHint });
     if (meta) {
       answer = meta.text; via = meta.via; recordMiss = false; handled = true;
       note(trace, `lane: (1) META/SELF — bare self/session question recognized, answered via="${meta.via}"`);
@@ -2498,7 +2718,7 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
     // structural (by construction, not word-count guesswork); its own composed
     // answer — hit, honest empty, or "it needs a referent" — is always more
     // truthful than the orientation card.
-    const orientation = orientationAnswer(templates, graph);
+    const orientation = orientationAnswer(templates, graph, vocabHint);
     const repeat = last?.answer === orientation;
     answer = repeat ? ORIENTATION_REPEAT_ONELINER : orientation;
     via = "template"; handled = true;
@@ -2954,7 +3174,7 @@ function morePage(query, { last, focus }) {
   return turn;
 }
 
-export async function runTurn(input, { config, source = defaultSource, graph = null, focus = null, last = null, memoryDir = null, sessionId = "", env = process.env, lexicon = null, narrate = 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, vocabHint = null } = {}) {
   const line = String(input ?? "").trim();
   const templates = await chatTemplates(); // failure-tolerated: null degrades, never throws
   // narrate mode: allocate the mutable trace array ONLY when on (`null` when off,
@@ -2964,7 +3184,12 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
   // the narrate:false path allocates nothing extra and renders byte-identically to
   // before this feature existed — see the "---- narrate mode ----" section above.
   const trace = narrate ? [] : null;
-  const ctx = { config, source, graph, focus, last, memoryDir, sessionId, templates, env, lexicon, trace, narrate };
+  // vocabHint: createSession computes this ONCE per session (a marker-file check)
+  // and threads it in; a direct runTurn() caller (tests, library use) that doesn't
+  // pass one gets it computed here instead, so "try this vocabulary example" is
+  // never wrong regardless of caller.
+  const resolvedVocabHint = vocabHint ?? vocabExampleHint(await hasSeededVocabulary(memoryDir));
+  const ctx = { config, source, graph, focus, last, memoryDir, sessionId, templates, env, lexicon, trace, narrate, vocabHint: resolvedVocabHint };
   // A DISPATCHED turn (count / slash-command / ask) becomes the new "last answer"
   // that why/say-more re-renders; a conversational turn does not (it preserves it).
   // FINISH SEAM (PLAN_RESPONSE_FINISHING §"Where it lives"): every dispatched turn's
@@ -3117,6 +3342,35 @@ async function seedBootstrapMemory(repo) {
   }
 }
 
+/** Whether THIS repo's memory actually carries the corpus seed — the marker is
+ *  authoritative regardless of whether the CURRENT run performed the seeding or
+ *  an earlier run (or `tmct init`) did (seedBootstrapMemory short-circuits on an
+ *  existing marker without re-reading the slice). The one signal every "try this
+ *  vocabulary example" surface must check before offering a term-specific query —
+ *  see vocabExampleHint. A cheap fs check, negligible next to the per-turn
+ *  template load. */
+async function hasSeededVocabulary(repo) {
+  if (!repo) return false;
+  try { await readFile(join(repo, SEED_MARKER_REL), "utf8"); return true; }
+  catch { return false; }
+}
+
+/** A "try this" vocabulary-example clause that's PROVABLY correct in the session
+ *  it's shown, mirroring the discipline orientationExamples() already applies to
+ *  structural examples (never offer an example that isn't confirmed to resolve).
+ *  `cache` is confirmed live: present in corpus/seon/definitions.jsonl, backed by
+ *  a corpus:seon concept fact, and a recognized lexicon noun — but only actually
+ *  answerable once the seed has run. When it hasn't (TMCT_NO_SEED=1,
+ *  seed.enabled=false, or corpus load failure), offering it would be a lie worse
+ *  than no example — swap to an unconditionally-true pointer instead (the teach
+ *  lane and `tmct init` both work with zero preconditions). Computed ONCE per
+ *  session (createSession), not per turn. */
+function vocabExampleHint(seeded) {
+  return seeded
+    ? 'Try "what is a cache" for general vocabulary.'
+    : 'Run `tmct init` to seed a starter vocabulary, or teach me directly with "every X is a Y".';
+}
+
 /** Trim a focus label for the prompt so a long module path can't run the line off. */
 const shortLabel = (l) => { const s = String(l); return s.length > 40 ? "…" + s.slice(-39) : s; };
 const promptFor = (focus) => (focus ? `tmct(${shortLabel(focus.label)})> ` : PROMPT);
@@ -3272,6 +3526,13 @@ export async function createSession({
   if (empty && String(env.TMCT_NO_SEED || "") !== "1") {
     seeded = await seedBootstrapMemory(repo);
   }
+  // vocabHint: computed ONCE per session (not per-turn — see runTurn's own
+  // per-call fallback for direct/library callers). `seeded` is only truthy when
+  // THIS run performed the seeding; a repo seeded by an EARLIER run (or `tmct
+  // init`) still needs the marker check, so this covers both — see
+  // hasSeededVocabulary's docblock.
+  const vocabSeeded = Boolean(seeded) || (await hasSeededVocabulary(repo));
+  const vocabHint = vocabExampleHint(vocabSeeded);
   // #3/#5: 0 modules means no code graph to answer structure questions from —
   // whether the graph file is absent (empty bootstrap) OR present with no code
   // entities (the degenerate trap). Both get orienting, non-over-promising banner
@@ -3287,9 +3548,11 @@ export async function createSession({
     // is the TOTAL appended, split into the curated SEON ontology + the ConceptNet band.
     ...(seeded ? [`seeded ${seeded.appended} starter facts (${seeded.seon} curated SEON + ${seeded.conceptnet} ConceptNet) — /memory to inspect`] : []),
     // no code graph → point at how to GET one (a graph producer / --repo / the shipped
-    // example), honest that `tmct init` seeds VOCABULARY, not a code graph, and at what
-    // IS answerable now. tmct reads graphs; it never indexes code itself.
-    ...(noCodeGraph ? ['for code structure, point me at a .tmct/graph.json with --repo <path> or try `npm run example:mini` (tmct reads graphs, it doesn\'t index code); `tmct init` only seeds vocabulary — try "what is a cache"'] : []),
+    // example), and at what IS answerable now — `vocabHint` is only ever a term
+    // confirmed to resolve in THIS session's actual seed state (see vocabExampleHint),
+    // never a hardcoded example that might not have been seeded. tmct reads graphs;
+    // it never indexes code itself.
+    ...(noCodeGraph ? [`for code structure, point me at a .tmct/graph.json with --repo <path> or try \`npm run example:mini\` (tmct reads graphs, it doesn't index code). ${vocabHint}`] : []),
     "pass --repo <path> to target a different repo",
     "ask a question, or /help for commands (/stats for an overview) — /exit to leave",
   ];
@@ -3319,7 +3582,7 @@ export async function createSession({
     async turn(line) {
       let result;
       try {
-        result = await runTurn(line, { config, source, graph, focus, last, memoryDir: repo, sessionId, env, lexicon, narrate: narrateOn });
+        result = await runTurn(line, { config, source, graph, focus, last, memoryDir: repo, sessionId, env, lexicon, narrate: narrateOn, vocabHint });
       } catch (e) {
         const ts = new Date().toISOString();
         const message = e instanceof Error ? e.message : String(e);

package/src/interpret/fuzzy.mjs

@@ -76,11 +76,21 @@ export function eligibleForCanon(w) {
  *  distinct target words at the same distance is refused outright (the honest-miss
  *  discipline at the vocabulary level; cf. MISSPELLINGS' curated "calss" decision). */
 export function fuzzyVocabWord(w) {
-  const bound = fuzzyBound(w);
+  return fuzzyMatchInSet(w, FUZZY_TARGET_WORDS, fuzzyBound(w));
+}
+
+/** GENERIC unique-within-bound fuzzy match of `w` against an arbitrary candidate
+ *  list, or null — same discipline as fuzzyVocabWord/resolveObject's tier-5 pass
+ *  (a distance tie between two distinct candidates is refused, never guessed),
+ *  factored out so callers outside the ask/keyword pipeline (e.g. chat.mjs's
+ *  conversational recognizers) can reuse the primitive without a bespoke
+ *  target-list wrapper. `bound` defaults to fuzzyBound(w) but callers may pass a
+ *  tighter budget (e.g. to keep short conversational tokens conservative). */
+export function fuzzyMatchInSet(w, candidates, bound = fuzzyBound(w)) {
   let best = bound + 1;
   let hit = null;
   let tied = false;
-  for (const target of FUZZY_TARGET_WORDS) {
+  for (const target of candidates) {
     const d = editDistance(w, target, Math.min(best, bound));
     if (d < best) { best = d; hit = target; tied = false; }
     else if (d === best && d <= bound && target !== hit) tied = true;