@polycode-projects/the-mechanical-code-talker 1.8.20 → 1.9.1

package/src/chat.mjs

@@ -677,7 +677,7 @@ async function answerEdgeCount(graph, query) {
  *  Consulted only when answerCount can't map the noun to a graph class (an unknown
  *  kind) AND a session's memory is in hand. Returns the count string or null (no
  *  such fact → the honest "I can't count …" from answerCount stands). */
-async function countFromFacts(graph, memoryDir, query, biasByBundle = {}) {
+async function countFromFacts(graph, memoryDir, query, biasByBundle = {}, cache = null) {
   if (!graph || !memoryDir) return null;
   const m = String(query).match(/\b(?:how many|number of|count(?:\s+the)?)\s+([a-z]+)\b/i);
   if (!m) return null;
@@ -686,7 +686,7 @@ async function countFromFacts(graph, memoryDir, query, biasByBundle = {}) {
   let normFactTerm;
   try { ({ normFactTerm } = await import("./memory/core.mjs")); } catch { return null; }
   const objVariants = factTermVariants(normFactTerm, asked);
-  const isa = (await factRows(memoryDir))
+  const isa = (await factRows(memoryDir, cache))
     .filter((f) => ISA_PREDICATES.has(f.predicate) && objVariants.has(f.object));
   // pick the highest-bias, then highest-trust asserted subject that maps to a
   // countable graph class (rankByBiasThenTrust: bias-tied/unconfigured degrades
@@ -721,7 +721,7 @@ async function countFromFacts(graph, memoryDir, query, biasByBundle = {}) {
 // graph-cardinality count untouched — same honest-decline discipline as
 // every other lane here).
 const HOW_MANY_ARE_RE = /^how\s+many\s+([\w-]+)\s+(?:are|is)\s+(.+?)[?.!\s]*$/i;
-async function answerQuantifierRecall(memoryDir, query, biasByBundle = {}) {
+async function answerQuantifierRecall(memoryDir, query, biasByBundle = {}, cache = null) {
   if (!memoryDir) return null;
   const m = String(query).trim().match(HOW_MANY_ARE_RE);
   if (!m) return null;
@@ -730,7 +730,7 @@ async function answerQuantifierRecall(memoryDir, query, biasByBundle = {}) {
   let normFactTerm;
   try { ({ normFactTerm } = await import("./memory/core.mjs")); } catch { return null; }
   const subjVariants = factTermVariants(normFactTerm, asked);
-  const rows = (await factRows(memoryDir)).filter((f) => ISA_PREDICATES.has(f.predicate) && subjVariants.has(f.subject));
+  const rows = (await factRows(memoryDir, cache)).filter((f) => ISA_PREDICATES.has(f.predicate) && subjVariants.has(f.subject));
   if (!rows.length) return null; // never heard of this subject at all — let answerCount own the shape
   const objVariants = factTermVariants(normFactTerm, m[2]);
   const hit = rankByBiasThenTrust(rows.filter((f) => objVariants.has(f.object)), biasByBundle)[0];
@@ -2067,7 +2067,7 @@ const GENERIC_ANCHOR_NOUNS = new Set(["thing", "concept", "object", "entity"]);
  *  fact-grounded term matches under the EXACT spelling teachFact itself stored
  *  it under. Failure-tolerated: no memory dir / no match → false, never a
  *  guessed "yes". */
-async function isGroundedByFact(term, memoryDir) {
+async function isGroundedByFact(term, memoryDir, cache = null) {
   if (!memoryDir) return false;
   const raw = String(term ?? "").trim();
   if (!raw) return false;
@@ -2083,7 +2083,7 @@ async function isGroundedByFact(term, memoryDir) {
   // OPERATOR actually taught (or a prior `tmct syllogise` entailment) anchors
   // a term here. factRows (not memoryFacts) is used specifically because it's
   // the one read path that carries sourceTypes for this filter.
-  const rows = await factRows(memoryDir);
+  const rows = await factRows(memoryDir, cache);
   const isTaught = (f) => !f.sourceTypes?.includes("corpus") && !f.sourceTypes?.includes("web");
   return rows.some((f) => MINT_ISA_PREDICATES.has(f.predicate) && isTaught(f) && (f.subject === t || f.object === t));
 }
@@ -2098,13 +2098,13 @@ async function isGroundedByFact(term, memoryDir) {
  *  narrower and NOUN-specific — see its own comment — so an object that's
  *  merely a known ADJECTIVE doesn't get misrouted into the class/subClassOf
  *  branch instead of the property branch.) */
-async function isGroundedTerm(term, lex, memoryDir) {
+async function isGroundedTerm(term, lex, memoryDir, cache = null) {
   const raw = String(term ?? "").trim();
   if (!raw) return false;
   if (GENERIC_ANCHOR_NOUNS.has(raw.toLowerCase())) return true;
   const { classify } = await import("./grammar/lexicon.mjs");
   if (classify(raw, lex)) return true;
-  return isGroundedByFact(raw, memoryDir);
+  return isGroundedByFact(raw, memoryDir, cache);
 }
 
 /** The "both sides ungrounded" grounding NUDGE (operator refinement,
@@ -2127,15 +2127,15 @@ async function isGroundedTerm(term, lex, memoryDir) {
  *  unchanged) whenever the payload doesn't fit the shape, or at least one
  *  side IS already grounded — a DIFFERENT, more specific reason it declined,
  *  where this nudge would be actively unhelpful noise. */
-async function ungroundedPairHint(payload, lexicon, memoryDir) {
+async function ungroundedPairHint(payload, lexicon, memoryDir, cache = null) {
   if (!memoryDir) return "";
   const m = String(payload).trim().match(UNKNOWN_SUBJECT_RE);
   if (!m) return "";
   const [, , subjectRaw, , objectRaw] = m;
   const { loadLexicon } = await import("./grammar/lexicon.mjs");
   const lex = lexicon || loadLexicon();
-  if (await isGroundedTerm(subjectRaw, lex, memoryDir)) return "";
-  if (await isGroundedTerm(objectRaw, lex, memoryDir)) return "";
+  if (await isGroundedTerm(subjectRaw, lex, memoryDir, cache)) return "";
+  if (await isGroundedTerm(objectRaw, lex, memoryDir, cache)) return "";
   // 2026-07-10 (found live via SKILL_BENCHMARK_CONVERSATION.md playtest, a
   // classic first-thing-a-user-tries example: "john is a man"): the original
   // suggestion chained the second term UNDER the first's now-grounded proper
@@ -2179,7 +2179,7 @@ async function ungroundedPairHint(payload, lexicon, memoryDir) {
  *  the SUBJECT, not about the "remember that" wrapper). Only the "every"
  *  determiner records a quantifier (point 3: "a"/bare/"your" read as one
  *  specific entity, not a class-level generalization). */
-async function unknownSubjectFallback(payload, { memoryDir, sessionId, lexicon }) {
+async function unknownSubjectFallback(payload, { memoryDir, sessionId, lexicon }, cache = null) {
   if (!memoryDir) return null;
   const m = String(payload).trim().match(UNKNOWN_SUBJECT_RE);
   if (!m) return null;
@@ -2211,7 +2211,7 @@ async function unknownSubjectFallback(payload, { memoryDir, sessionId, lexicon }
   // lexicon noun — both are always treated as class-level (never property),
   // consistent with unknownObjectFallback (below) always minting a CLASS.
   if (lookupNoun(lex, objectRaw) || GENERIC_ANCHOR_NOUNS.has(String(objectRaw).toLowerCase())
-    || (await isGroundedByFact(objectRaw, memoryDir))) {
+    || (await isGroundedByFact(objectRaw, memoryDir, cache))) {
     return teachFact(memoryDir, sessionId, {
       subject, predicate: SUBCLASS_PREDICATE, object: objectRaw, quantifier,
     });
@@ -2297,7 +2297,7 @@ async function objectReadsAsNonNoun(word) {
     return false;
   }
 }
-async function unknownObjectFallback(payload, { memoryDir, sessionId, lexicon }) {
+async function unknownObjectFallback(payload, { memoryDir, sessionId, lexicon }, cache = null) {
   if (!memoryDir) return null;
   const m = String(payload).trim().match(UNKNOWN_SUBJECT_RE);
   if (!m) return null;
@@ -2305,9 +2305,9 @@ async function unknownObjectFallback(payload, { memoryDir, sessionId, lexicon })
   if (!/^(?:every|each|all)$/i.test((det || "").trim())) return null; // class-level mint needs a real universal quantifier
   const { loadLexicon, lookupNoun } = await import("./grammar/lexicon.mjs");
   const lex = lexicon || loadLexicon();
-  const subjectGrounded = await isGroundedTerm(subjectRaw, lex, memoryDir);
+  const subjectGrounded = await isGroundedTerm(subjectRaw, lex, memoryDir, cache);
   if (!subjectGrounded) return null; // ungrounded subject isn't this fallback's asymmetry — never a guessed mint
-  const objectGrounded = await isGroundedTerm(objectRaw, lex, memoryDir);
+  const objectGrounded = await isGroundedTerm(objectRaw, lex, memoryDir, cache);
   if (objectGrounded) return null; // object already known — nothing to mint
   if (await objectReadsAsNonNoun(objectRaw)) return null; // reads like an adjective/verb, not a class noun — defer to unknownAdjectiveFallback
   const quantifier = /^every$/i.test((det || "").trim()) ? "every" : "";
@@ -2399,7 +2399,7 @@ async function unknownObjectFallback(payload, { memoryDir, sessionId, lexicon })
  *  otherwise provide. "the cache is bespoke" and "Mary is female" both carry
  *  one of those signals (the leading "the", and capitalization,
  *  respectively); "module is banana" carries none. */
-async function unknownAdjectiveFallback(payload, { memoryDir, sessionId, lexicon }) {
+async function unknownAdjectiveFallback(payload, { memoryDir, sessionId, lexicon }, cache = null) {
   if (!memoryDir) return null;
   const m = String(payload).trim().match(UNKNOWN_SUBJECT_RE);
   if (!m) return null;
@@ -2410,7 +2410,7 @@ async function unknownAdjectiveFallback(payload, { memoryDir, sessionId, lexicon
   // membership sentence, unknownSubjectFallback/unknownObjectFallback's own
   // territory (already had first refusal on it) — never misread as a property.
   if (lookupNoun(lex, objectRaw) || GENERIC_ANCHOR_NOUNS.has(String(objectRaw).toLowerCase())
-    || (await isGroundedByFact(objectRaw, memoryDir))) return null;
+    || (await isGroundedByFact(objectRaw, memoryDir, cache))) return null;
   // Subject-side groundedness — strip a leading "the"/"a"/"an" first
   // (normFactTerm's own article-strip, mirrored here) so "the cache" checks
   // groundedness under its real head noun "cache", the same spelling
@@ -2418,7 +2418,7 @@ async function unknownAdjectiveFallback(payload, { memoryDir, sessionId, lexicon
   const bareSubject = subjectRaw.replace(/^(?:the|an?)\s+/i, "").trim() || subjectRaw;
   const hadArticle = bareSubject !== subjectRaw;
   const capitalized = /^[A-Z]/.test(bareSubject);
-  const factGrounded = await isGroundedByFact(bareSubject, memoryDir);
+  const factGrounded = await isGroundedByFact(bareSubject, memoryDir, cache);
   const genericAnchor = GENERIC_ANCHOR_NOUNS.has(bareSubject.toLowerCase());
   // A bare (no article, no capitalization) subject grounded ONLY via the
   // static lexicon is exactly the pinned "module is banana" shape — see this
@@ -2745,7 +2745,7 @@ const RETRACT_NOT_A_RE = /^(?:a\s+|an\s+)?([\w-]+(?:\s+[\w-]+)?)\s+(?:(?:is|are)
  *  is tried against the remember-wrapped surface too. */
 const RETRACT_FORGET_RE = /^forget\s+(?:that\s+)?(?:a\s+|an\s+)?([\w-]+(?:\s+[\w-]+)?)\s+(?:is|are)\s+(?:an?\s+)?(?:(?:kind|type)\s+of\s+)?([\w-]+)$/i;
 
-async function teachLane(query, { memoryDir, sessionId = "", lexicon = null }) {
+async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cache = null }) {
   // Tier 6 playtest: this lane read the raw, un-normalized query, so a closed
   // discourse-marker preamble ahead of a teach sentence ("howdy pardner,
   // remember that TaskController is fragile") corrupted TEACH_RE's own match —
@@ -3174,7 +3174,7 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null }) {
       // assertTurn ITSELF records the "every" quantifier (point 3) on a plain
       // universal success, so every caller (this loop AND the top-level
       // declarative-sentence dispatch in runTurn) gets it uniformly.
-      const stored = await assertTurn(cand, { memoryDir, sessionId, focus: null, lexicon });
+      const stored = await assertTurn(cand, { memoryDir, sessionId, focus: null, lexicon, cache });
       if (stored) return { text: stored.answer, via: "assert", miss: false };
     }
     // BUG "redis" fix (Feature A point 1): the real ACE grammar just declined
@@ -3183,7 +3183,7 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null }) {
     // Covers BOTH the bare and the wrapped surface (payload is already
     // unwrapped either way) — see unknownSubjectFallback's own docblock for
     // the exact narrowing rules (object must still be known, etc.).
-    const fallback = await unknownSubjectFallback(payload, { memoryDir, sessionId, lexicon });
+    const fallback = await unknownSubjectFallback(payload, { memoryDir, sessionId, lexicon }, cache);
     if (fallback) return fallback;
     // MIRROR mint fallback (Feature A, 2026-07-09 operator-authorized vocabulary-
     // growth extension): the known-subject/unknown-object asymmetry — tried
@@ -3191,7 +3191,7 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null }) {
     // lexicon (or a prior taught fact) already grounds can mint a brand-new
     // object term. See unknownObjectFallback's own docblock for the exact
     // narrowing rules (the "both sides ungrounded" safety guard, etc.).
-    const objectFallback = await unknownObjectFallback(payload, { memoryDir, sessionId, lexicon });
+    const objectFallback = await unknownObjectFallback(payload, { memoryDir, sessionId, lexicon }, cache);
     if (objectFallback) return objectFallback;
     // ADJECTIVE-MINT fallback (PLAN_TAUGHT_RELATIONS.md Item 5, Phase 1): tried
     // right after unknownObjectFallback declines, so a grounded subject (static
@@ -3200,7 +3200,7 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null }) {
     // docblock for the exact narrowing rules (the "both sides ungrounded"
     // safety guard, and why this must be a standalone function rather than
     // nested inside unknownSubjectFallback).
-    const adjectiveFallback = await unknownAdjectiveFallback(payload, { memoryDir, sessionId, lexicon });
+    const adjectiveFallback = await unknownAdjectiveFallback(payload, { memoryDir, sessionId, lexicon }, cache);
     if (adjectiveFallback) return adjectiveFallback;
     // PROPERTY teach — "remember/note that <X> is <adjective>": wrapper-REQUIRED
     // (a bare "X is deprecated" is never silently reified), and only after the
@@ -3271,7 +3271,7 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null }) {
   // replacement, exactly like "did" above — see ungroundedPairHint's own
   // docblock for why this is scoped to the "both sides ungrounded, fits the
   // X is/are Y shape" case only.
-  const groundingHint = await ungroundedPairHint(payload, lexicon, memoryDir);
+  const groundingHint = await ungroundedPairHint(payload, lexicon, memoryDir, cache);
   return {
     text: `I couldn't store that —${why} I remember facts in the shape "every X is a Y", where X and Y are `
       + `words I know.${did}${groundingHint} Type /memory to see what I already remember.`,
@@ -4044,6 +4044,11 @@ const FACT_PREDICATE_PHRASES = {
   "mgx:hasLastSubevent": "ends with",
   "mgx:hasPrerequisite": "requires",
   "mgx:ownedBy": "is owned by", // the teach lane's ownership frame ("Priya owns tasks.mjs")
+  "mgx:synonym": "means the same as",
+  "mgx:antonym": "is the opposite of",
+  "mgx:similarTo": "is similar to",
+  "mgx:relatedTo": "is related to",
+  "mgx:symbolOf": "is a symbol of",
 };
 
 /** Bug 3 (2026-07-09) point 3b: the MECHANICAL fallback for a predicate this
@@ -4138,16 +4143,26 @@ function splitMetaPredicate(term) {
 
 /** One rendered fact line. An OPERATOR-asserted fact keeps the true first-person
  *  provenance ("you told me: …"). A CORPUS fact is presented as clean DATA with its
- *  source cited — NEVER "i learned: …", which over-claims and anthropomorphises
- *  (especially when the corpus row is noise); the relation and its provenance speak
- *  for themselves. Provenance stays VERBATIM either way. */
+ *  source cited, not "i learned: …" — that phrase over-claims and anthropomorphises
+ *  a first-person experience the bot never had; the relation and its provenance
+ *  speak for themselves. A WEAK-corpus fact (memory/trust.mjs SOURCE_PRIOR.corpusWeak
+ *  — real data, low-precision relation, e.g. ConceptNet's undirected /r/RelatedTo)
+ *  still isn't "i learned" (same anthropomorphism problem), but reads identically to
+ *  a solid corpus fact loses the only reader-visible signal that it's lower-
+ *  confidence — re-examined 2026-07-12 (TOO_HARD_AUDIT.md): the prior blanket "corpus
+ *  never hedges" rule predates corpus data having any confidence spread at all, so a
+ *  distinct, honest hedge ("possibly: …") applies here instead of either extreme.
+ *  Provenance stays VERBATIM in every case. */
 function renderFactLine(f) {
   const cite = f.provenance ? ` (source: ${f.provenance})` : "";
   // ace:chat = the ACE-parsed operator assert; teach:chat = the teach lane's
   // natural frames — both are things the operator SAID, so both read first-person.
   if (f.provenance.includes("ace:chat") || f.provenance.includes("teach:chat")) return `you told me: ${factPhrase(f)}${cite}`;
-  // CORPUS facts are background DATA — present the relation plainly, cited to its
-  // source, NEVER "i learned: …" (the footgun: a first-person claim over corpus noise).
+  // WEAK corpus facts (lower trust, e.g. RelatedTo) — real, cited, but hedged as
+  // uncertain rather than either flatly stated or falsely claimed as "learned".
+  if (f.provenance.includes("corpus-weak:")) return `possibly: ${factPhrase(f)}${cite}`;
+  // SOLID corpus facts are background DATA — present the relation plainly, cited
+  // to its source, never "i learned: …" (a first-person claim over corpus data).
   if (f.provenance.includes("corpus:")) return `${factPhrase(f)}${cite}`;
   return `i learned: ${factPhrase(f)}${cite}`;
 }
@@ -4190,11 +4205,27 @@ async function memoryFacts(memoryDir) {
 /** Load memory once and resolve every reified Fact into a TRUST-BEARING row
  *  ({subject,predicate,object,provenance,trust,sourceTypes,…}) via core's
  *  readFactRows — the seam the answer layer ranks + cites without re-walking the
- *  graph shape (Wave-A memory/core.mjs). Lazy + failure-tolerated: no memory → []. */
-async function factRows(memoryDir) {
+ *  graph shape (Wave-A memory/core.mjs). Lazy + failure-tolerated: no memory → [].
+ *
+ *  `cache` (PLAN_GRAPH_SCAN.md "Query side: memoize the per-turn reload"): an
+ *  optional, caller-owned plain object (`{ rows: null }`, e.g. one runTurn call's
+ *  own `factRowsCache`) — when `cache.rows` is already populated, it's returned
+ *  directly, skipping loadMemory/readFactRows entirely; otherwise the result is
+ *  computed as before and stashed onto `cache.rows` for the next caller sharing
+ *  the same cache this turn. Absent/null (the default) reproduces today's
+ *  behavior exactly — a fresh, uncached reload every call — so every caller that
+ *  doesn't pass one is byte-for-byte unaffected. Never shared across turns or
+ *  with mutateMemory (see the plan doc for why a global cache was rejected).
+ *  `cache.reloads` is bumped once per REAL loadMemory/readFactRows call (never on
+ *  a cache hit) purely so a test can assert "computed once per turn" by call
+ *  count instead of wall-clock — see test/chat-factrows-cache.test.mjs. */
+async function factRows(memoryDir, cache = null) {
+  if (cache?.rows) return cache.rows;
   try {
     const { loadMemory, readFactRows } = await import("./memory/core.mjs");
-    return readFactRows(await loadMemory(memoryDir));
+    const rows = readFactRows(await loadMemory(memoryDir));
+    if (cache) { cache.rows = rows; cache.reloads = (cache.reloads || 0) + 1; }
+    return rows;
   } catch {
     return [];
   }
@@ -4508,6 +4539,42 @@ const WHAT_HAS_RE = /^what\s+has\s+(?:an?\s+)?(.+?)[?.!\s]*$/i;
 // (object known, subject unknown), so it fell all the way through to the
 // code-graph miss cascade — actively misleading for a pure vocabulary query.
 const WHAT_USED_FOR_RE = /^what\s+(?:(?:can\s+be|is)\s+used\s+for|is\s+for)\s+(.+?)[?.!\s]*$/i;
+
+// Live-caught 2026-07-12 follow-up: the SAME gap as mgx:usedFor above turned
+// out to be systemic, not one-off — "what causes fire", "what is made of
+// wood", "what is found in a kitchen", "what wants food" all fell through to
+// the same misleading code-graph miss, for the same reason (no reverse-by-
+// object reader existed for these predicates either). Rather than hand-roll
+// one more one-off regex per predicate, this DERIVES a reverse-by-object
+// regex for every FACT_PREDICATE_PHRASES entry that's safe to reverse — the
+// same "derivation, not a curated subset" philosophy TRAILING_PREDICATE_MARKERS
+// already uses for the forward direction (see that const's own docblock).
+// Excluded, each for a specific reason:
+//   - rdfs:subClassOf, mgx:hasA, mgx:capableOf, mgx:usedFor — already have
+//     their own dedicated, richer reverse readers (WHAT_INHERITS_RE/
+//     WHAT_HAS_RE/WHAT_CAN_DO_RE/WHAT_USED_FOR_RE above).
+//   - mgx:ownedBy — already has its own dedicated "who owns X" reader
+//     (WHO_OWNS_RE) — a WHO question, not a WHAT question, so it would never
+//     collide, but is excluded anyway to keep exactly one reader per relation.
+//   - rdf:type ("is a") and mgx:hasProperty ("is") — too short/generic to
+//     safely anchor a reverse question: "what is X" already belongs to the
+//     meta lane's own vocabulary lookup, and reversing it here would mean
+//     guessing whether the user meant "define X" or "what has property X"
+//     from word order alone.
+//   - owl:disjointWith ("is not a") and mgx:receivesAction ("can be") — both
+//     broad enough that "what is not a X" / "what can be X" read as much more
+//     likely to be a different question shape than a genuine reverse lookup.
+const REVERSE_PREDICATE_EXCLUDE = new Set([
+  "rdfs:subClassOf", "rdf:type", "mgx:hasA", "mgx:capableOf", "mgx:usedFor",
+  "mgx:ownedBy", "owl:disjointWith", "mgx:hasProperty", "mgx:receivesAction",
+]);
+const REVERSE_PREDICATE_MARKERS = Object.entries(FACT_PREDICATE_PHRASES)
+  .filter(([predicate]) => !REVERSE_PREDICATE_EXCLUDE.has(predicate))
+  .map(([predicate, phrase]) => ({
+    predicate,
+    re: new RegExp(`^what\\s+${escapeRegex(phrase)}\\s+(.+?)[?.!\\s]*$`, "i"),
+  }))
+  .sort((a, b) => b.re.source.length - a.re.source.length); // longest phrase first
 // Widened 2026-07-11 (live-caught follow-up to the ambiguousParse fix, commit
 // 5c858bf): on the FIRST turn of a graph-less session, dispatchTool's
 // loadGraph() throws its own documented "the graph is empty... this repo
@@ -4549,8 +4616,19 @@ function uniqueFacts(rows) {
 /** W4 seam: answer (or extend) a vocabulary/definition question from the MEMORY
  *  graph's Facts. Returns { text, replace } — `replace:false` means the engine's
  *  own (schema-docs) answer stands and the fact lines are appended under it —
- *  or null when memory holds nothing relevant (misses stay unchanged). */
-async function factAnswer(memoryDir, query, envelope, miss, biasByBundle = {}) {
+ *  or null when memory holds nothing relevant (misses stay unchanged).
+ *  Exported (PLAN_VIZ_MEMORY.md Bug 1 fix) so src/memory-ask-browser-entry.mjs
+ *  can re-export it for `tmct viz`'s embedded "Ask the graph" panel — the ONLY
+ *  reason this is `export` rather than module-private; the function's own
+ *  behavior is unchanged (same signature, same logic, answers identically in
+ *  the CLI and the browser bundle). `memoryDir` may be memory/core.mjs's
+ *  Backend-B in-memory handle (`createInMemoryStore()`) as well as a real repo
+ *  path — every I/O this function does routes through `loadMemory(memoryDir)`
+ *  (via factRows/memoryFacts below), and loadMemory's own Backend-B branch
+ *  returns the handle's `payload` directly with ZERO fs calls — so a caller
+ *  that hands this a handle already carrying the embedded page's full graph
+ *  gets a pure, disk-free traversal, no bundle-time module shimming needed. */
+export async function factAnswer(memoryDir, query, envelope, miss, biasByBundle = {}, cache = null) {
   let normFactTerm;
   try { ({ normFactTerm } = await import("./memory/core.mjs")); } catch { return null; }
   const q = String(query).trim();
@@ -4570,7 +4648,7 @@ async function factAnswer(memoryDir, query, envelope, miss, biasByBundle = {}) {
   const usedForQ = q.match(WHAT_USED_FOR_RE);
   if (usedForQ) {
     const variants = factTermVariants(normFactTerm, usedForQ[1]);
-    const hits = (await factRows(memoryDir)).filter((f) => f.predicate === "mgx:usedFor" && variants.has(f.object));
+    const hits = (await factRows(memoryDir, cache)).filter((f) => f.predicate === "mgx:usedFor" && variants.has(f.object));
     if (hits.length) {
       const ranked = rankByBiasThenTrust(uniqueFacts(hits), biasByBundle);
       const lines = ranked.map(renderFactLine);
@@ -4581,6 +4659,26 @@ async function factAnswer(memoryDir, query, envelope, miss, biasByBundle = {}) {
     }
   }
 
+  // (a-pre2) The generic derived cascade for every other reversible predicate
+  // (REVERSE_PREDICATE_MARKERS, see its own docblock for the exclusion list
+  // and why). Same checked-before-the-meta-lane placement and same
+  // only-take-over-on-a-real-hit discipline as (a-pre) just above — a phrase
+  // like "is found in"/"is made of" also starts with "what is …", so it must
+  // run before (a) can greedily claim the whole tail as a literal term.
+  for (const { predicate, re } of REVERSE_PREDICATE_MARKERS) {
+    const m = q.match(re);
+    if (!m) continue;
+    const variants = factTermVariants(normFactTerm, m[1]);
+    const hits = (await factRows(memoryDir, cache)).filter((f) => f.predicate === predicate && variants.has(f.object));
+    if (!hits.length) continue; // try the next candidate marker, don't give up yet
+    const ranked = rankByBiasThenTrust(uniqueFacts(hits), biasByBundle);
+    const lines = ranked.map(renderFactLine);
+    const shown = lines.slice(0, FACT_ANSWER_CAP);
+    const rest = lines.slice(FACT_ANSWER_CAP);
+    const extra = rest.length ? `\n…and ${rest.length} more — say 'more' to see them.` : "";
+    return { text: shown.join("\n") + extra, replace: true, ...(rest.length ? { pending: { items: rest, noun: "facts" } } : {}) };
+  }
+
   // (a) meta-shaped questions ("what is a module", "what does cache mean") — the
   // parsed object term, matched against fact SUBJECTS; consulted for hits (append
   // alongside the schema-docs answer) and misses (facts answer alone) alike.
@@ -4621,7 +4719,7 @@ async function factAnswer(memoryDir, query, envelope, miss, biasByBundle = {}) {
     // factRows (trust+sourceIds-bearing), not the plain memoryFacts shape — the
     // bias-weighted ranking below needs each hit's sourceIds to resolve which
     // bundle it came from (memory/bias.mjs's biasForRow).
-    const subjectHits = (await factRows(memoryDir)).filter((f) => variants.has(f.subject));
+    const subjectHits = (await factRows(memoryDir, cache)).filter((f) => variants.has(f.subject));
     let hits = predicate ? subjectHits.filter((f) => f.predicate === predicate) : subjectHits;
     if (!hits.length) {
       // The subject itself is known, but not under this specific relation —
@@ -4681,7 +4779,7 @@ async function factAnswer(memoryDir, query, envelope, miss, biasByBundle = {}) {
   const canDo = q.match(WHAT_CAN_DO_RE);
   if (canDo) {
     const variants = factTermVariants(normFactTerm, canDo[1]);
-    const hits = (await factRows(memoryDir)).filter((f) => f.predicate === "mgx:capableOf" && variants.has(f.subject));
+    const hits = (await factRows(memoryDir, cache)).filter((f) => f.predicate === "mgx:capableOf" && variants.has(f.subject));
     if (!hits.length) return null;
     const ranked = rankByBiasThenTrust(uniqueFacts(hits), biasByBundle);
     const lines = ranked.map(renderFactLine);
@@ -4700,7 +4798,7 @@ async function factAnswer(memoryDir, query, envelope, miss, biasByBundle = {}) {
   const hasQ = q.match(WHAT_HAS_RE);
   if (hasQ && !HAS_TEMPORAL_TAIL.has(hasQ[1].trim().split(/\s+/)[0]?.toLowerCase())) {
     const variants = factTermVariants(normFactTerm, hasQ[1]);
-    const hits = (await factRows(memoryDir)).filter((f) => f.predicate === "mgx:hasA" && variants.has(f.object));
+    const hits = (await factRows(memoryDir, cache)).filter((f) => f.predicate === "mgx:hasA" && variants.has(f.object));
     if (!hits.length) return null;
     const ranked = rankByBiasThenTrust(uniqueFacts(hits), biasByBundle);
     const lines = ranked.map(renderFactLine);
@@ -4737,7 +4835,7 @@ async function factAnswer(memoryDir, query, envelope, miss, biasByBundle = {}) {
     : inheritsQ?.[1];
   if (inheritsObj) {
     const variants = factTermVariants(normFactTerm, inheritsObj);
-    const hits = (await factRows(memoryDir)).filter((f) => ISA_PREDICATES.has(f.predicate) && variants.has(f.object));
+    const hits = (await factRows(memoryDir, cache)).filter((f) => ISA_PREDICATES.has(f.predicate) && variants.has(f.object));
     // Only diverts on a REAL hit — same discipline every other reader in this
     // cascade follows (CAN_ASK_RE/WHAT_CAN_DO_RE/WHAT_HAS_RE above all `return
     // null` on zero hits too). A zero-hit case here must NOT invent its own
@@ -4765,7 +4863,7 @@ async function factAnswer(memoryDir, query, envelope, miss, biasByBundle = {}) {
   const know = q.match(KNOW_ABOUT_RE);
   if (know) {
     const variants = factTermVariants(normFactTerm, know[1]);
-    const rows = await factRows(memoryDir);
+    const rows = await factRows(memoryDir, cache);
     // Bug E subtype walk (operator follow-up request, this session): a
     // cycle-safe BFS DOWNWARD over isa-family facts from the term's own
     // variants — every fact whose OBJECT is in the current frontier
@@ -5201,7 +5299,7 @@ function inheritsChain(graph, startId) {
  *        "what kind of thing is an X" reports X's own type (subject-side first).
  *  Miss-only and run AFTER factAnswer returns null, so it never shadows the
  *  subject-side answer or a schema hit. Returns { text, replace:true } or null. */
-async function factReadBack(memoryDir, query, envelope, miss, graph = null, focusLabel = null, biasByBundle = {}) {
+async function factReadBack(memoryDir, query, envelope, miss, graph = null, focusLabel = null, biasByBundle = {}, cache = null) {
   if (!miss) return null;
   let normFactTerm;
   try { ({ normFactTerm } = await import("./memory/core.mjs")); } catch { return null; }
@@ -5248,7 +5346,7 @@ async function factReadBack(memoryDir, query, envelope, miss, graph = null, focu
   // fragile" is the SAME one-word-out-of-alignment problem the hedge adverbs
   // above were fixed for, just a dialect opener instead of a hedge adverb.
   const qHedge = q.replace(/^(?:actually|really|honestly|yeah\s+nah)\s*,?\s+/i, "");
-  const rows = await factRows(memoryDir);
+  const rows = await factRows(memoryDir, cache);
   if (!rows.length) {
     // Tier-5 playtest fix (cycle 2), found live: with TRULY zero facts
     // remembered yet (a fresh session, nothing taught at all), the early
@@ -6329,10 +6427,10 @@ async function factReadBack(memoryDir, query, envelope, miss, graph = null, focu
  *  only (a `/describe` names ONE code entity as the subject of its own facts,
  *  not every fact that merely mentions it in passing) — null when memory holds
  *  nothing about this subject. */
-async function describedFacts(memoryDir, label, biasByBundle = {}) {
+async function describedFacts(memoryDir, label, biasByBundle = {}, cache = null) {
   let normFactTerm;
   try { ({ normFactTerm } = await import("./memory/core.mjs")); } catch { return null; }
-  const rows = await factRows(memoryDir);
+  const rows = await factRows(memoryDir, cache);
   if (!rows.length) return null;
   const variants = factTermVariants(normFactTerm, label);
   const hits = rankByBiasThenTrust(rows.filter((f) => variants.has(f.subject)), biasByBundle);
@@ -7267,7 +7365,7 @@ async function relationForceAnswer(query, envelope, { graph, config, source, tem
  *  shipped corpus/seon file (seonDefinitions), so it works without per-repo memory
  *  seeding; the memory fact rows only ADD remembered "A is a X" examples when present.
  *  Lazy + failure-tolerated throughout (chat.mjs ethos). Returns { text, instances }. */
-async function conceptForceAnswer(query, envelope, { graph, config, source, memoryDir, templates }) {
+async function conceptForceAnswer(query, envelope, { graph, config, source, memoryDir, templates, cache = null }) {
   const rawTerm = conceptTermOf(query, envelope);
   if (!rawTerm) return null;
   let normFactTerm; let composeConcept; let CONCEPT_CLASS;
@@ -7287,7 +7385,7 @@ async function conceptForceAnswer(query, envelope, { graph, config, source, memo
     try { g = parseEntities(await source.fetchEntities(config)); } catch { g = null; }
   }
   if (!g) return null;
-  const rows = memoryDir ? await factRows(memoryDir) : [];
+  const rows = memoryDir ? await factRows(memoryDir, cache) : [];
   let composed;
   try { composed = composeConcept(g, term, { definition, factRows: rows }); }
   catch { return null; }
@@ -7343,7 +7441,7 @@ async function entityOfKindInText(graph, expectedClass, answerText) {
  *  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, vocabHint = null, tel = null, biasByBundle = {} }) {
+async function runAsk(query, { config, source, graph, focus, last, templates, memoryDir, sessionId = "", lexicon = null, env, trace, vocabHint = null, tel = null, biasByBundle = {}, cache = 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
@@ -7850,11 +7948,25 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
   // further down is UNCHANGED, so a CamelCase term with no real hit still falls
   // through to its existing miss handling, never the generic orientation card.
   const isBareCamelCaseWhatisCandidate = conversationalCandidateBaseGate && isBareCamelCaseMetaQuestion(gateQuery);
+  // 2026-07-12 follow-up to the used-for/reverse-predicate fix (factAnswer's
+  // WHAT_USED_FOR_RE/REVERSE_PREDICATE_MARKERS, above): the SAME race BUG 2/
+  // Tier-5/CamelCase already fixed above hits these too, and for the shortest
+  // members of the family it's actually MORE likely to fire — "what wants
+  // happiness" is exactly 3 words, none of them in STRUCT_WORDS, so
+  // isConversational() claims it before factAnswer ever gets a turn, even
+  // though a real mgx:desires fact answers it correctly once reached (proven:
+  // the longer "what can be used for riding" already worked, since 5 words
+  // clears isConversational's <=3-word gate outright — only the short
+  // members of this family were ever actually broken). Same discipline as
+  // every sibling exemption on this gate: matching the shape alone changes
+  // nothing by itself, factAnswer below still only diverts on a REAL hit.
+  const reversePredicateShape = WHAT_USED_FOR_RE.test(gateQuery)
+    || REVERSE_PREDICATE_MARKERS.some(({ re }) => re.test(gateQuery));
   let bareMetaHit = null;
-  if ((isConversationalCandidate || isBareCamelCaseWhatisCandidate) && (bareWhatisShape || isAdjectiveShape)) {
+  if ((isConversationalCandidate || isBareCamelCaseWhatisCandidate) && (bareWhatisShape || isAdjectiveShape || reversePredicateShape)) {
     if (memoryDir) {
-      bareMetaHit = (await factAnswer(memoryDir, gateQuery, envelope, miss, biasByBundle))
-        ?? (await factReadBack(memoryDir, gateQuery, envelope, miss, graph, newFocus?.label, biasByBundle));
+      bareMetaHit = (await factAnswer(memoryDir, gateQuery, envelope, miss, biasByBundle, cache))
+        ?? (await factReadBack(memoryDir, gateQuery, envelope, miss, graph, newFocus?.label, biasByBundle, cache));
       // HANDOVER.md 2026-07-10 item 10 (dropped-article gap): a bare "what is X"
       // with NO taught fact but a KNOWN curated corpus term ("what is cache", no
       // article) used to lose this exact same isConversationalCandidate race —
@@ -7946,8 +8058,8 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
     // reified fact is stronger evidence than a transcript echo. Subject-side facts
     // first (factAnswer), then the reverse-membership read-back (factReadBack) so an
     // asserted "every X is a Y" answers "what is a Y" too.
-    const fact = (await factAnswer(memoryDir, query, envelope, miss, biasByBundle))
-      ?? (await factReadBack(memoryDir, query, envelope, miss, graph, newFocus?.label, biasByBundle));
+    const fact = (await factAnswer(memoryDir, query, envelope, miss, biasByBundle, cache))
+      ?? (await factReadBack(memoryDir, query, envelope, miss, graph, newFocus?.label, biasByBundle, cache));
     if (fact) {
       answer = fact.replace ? fact.text : `${answer}\n${fact.text}`;
       via = "fact";
@@ -8021,7 +8133,7 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
   let conceptAllIds = null;
   let conceptPending = null;
   if (via === "composed" || via === "corpus/seon") {
-    const concept = await conceptForceAnswer(query, envelope, { graph, config, source, memoryDir, templates });
+    const concept = await conceptForceAnswer(query, envelope, { graph, config, source, memoryDir, templates, cache });
     if (concept) {
       answer = concept.text; via = "corpus/seon"; recordMiss = false;
       conceptInstances = concept.instances;
@@ -8078,7 +8190,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 });
+    const taught = await teachLane(query, { memoryDir, sessionId, lexicon, cache });
     if (taught) {
       answer = taught.text; via = taught.via; recordMiss = taught.miss;
       note(trace, `lane: (4) TEACH — TEACH_RE/OWNS_TEACH_RE/BARE_DECLARATIVE_RE matched, ${taught.miss ? "but the payload could not be stored" : "reified into .tmct/memory"}`);
@@ -8444,7 +8556,7 @@ const GOAL_BY_COMMAND = {
  *  field now (Bug F point 5) — mirrors runAsk's own `goal` field so
  *  withGoalLine's short "Goal (inferred): …" line fires for command
  *  dispatches too, not just ask()-parsed queries. */
-async function runCommand(line, { config, source, graph, focus, memoryDir, trace, narrate = false, tel = null, biasByBundle = {} }) {
+async function runCommand(line, { config, source, graph, focus, memoryDir, trace, narrate = false, tel = null, biasByBundle = {}, cache = null }) {
   const ts = new Date().toISOString();
   const sp = line.indexOf(" ");
   const name = (sp === -1 ? line.slice(1) : line.slice(1, sp)).toLowerCase();
@@ -8555,7 +8667,7 @@ async function runCommand(line, { config, source, graph, focus, memoryDir, trace
       // matching taught facts (subject === the resolved entity, trust-ranked)
       // under the code-map answer, mirroring the ask-path's fact-append pattern.
       if (name === "describe" && memoryDir) {
-        const facts = await describedFacts(memoryDir, ent.label, biasByBundle);
+        const facts = await describedFacts(memoryDir, ent.label, biasByBundle, cache);
         if (facts) { answer = `${answer}\n${facts}`; note(trace, "source: memory facts (describedFacts) appended to the code-map answer"); }
       }
       return mk(answer, { resolvedIds: [ent.id], newFocus: nextFocus(graph, focus, ent) });
@@ -8603,7 +8715,7 @@ function renderAmbiguousAssert(line, ambiguous, normFactTerm) {
  *  relation-shaped with 0-1 surviving readings), so this adds exactly one
  *  cheap check ahead of the EXISTING, unchanged parseAce path below — every
  *  single-reading sentence renders byte-identically to before. */
-async function assertTurn(line, { memoryDir, sessionId, focus, lexicon = null }) {
+async function assertTurn(line, { memoryDir, sessionId, focus, lexicon = null, cache = null }) {
   try {
     const { parseAce, parseAceAmbiguous } = await import("./grammar/ace.mjs");
     // A session handle carries its own loaded lexicon (createSession loads it once);
@@ -8682,7 +8794,7 @@ async function assertTurn(line, { memoryDir, sessionId, focus, lexicon = null })
         const newSubj = normFactTerm(res.triples[0].subject);
         const newObj = normFactTerm(res.triples[0].object);
         const isTaughtRow = (f) => !f.sourceTypes?.includes("corpus") && !f.sourceTypes?.includes("web");
-        const priorEdges = (await factRows(memoryDir))
+        const priorEdges = (await factRows(memoryDir, cache))
           .filter((f) => f.predicate === SUBCLASS_PREDICATE && isTaughtRow(f)
             && !(normFactTerm(f.subject) === newSubj && normFactTerm(f.object) === newObj))
           .map((f) => [normFactTerm(f.subject), normFactTerm(f.object)]);
@@ -8834,8 +8946,22 @@ function rewriteUsesAsBaseFrame(text) {
   return null;
 }
 
-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, tel = null, biasByBundle = {} } = {}) {
+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, tel = null, biasByBundle = {}, factRowsCache: injectedFactRowsCache = null } = {}) {
   const line = String(input ?? "").trim();
+  // PLAN_GRAPH_SCAN.md "Query side: memoize the per-turn reload": ONE fresh,
+  // empty cache for this turn only — every factRows() reader reached from this
+  // call (factAnswer, factReadBack, describedFacts, countFromFacts,
+  // answerQuantifierRecall, assertTurn, teachLane's grounding fallbacks,
+  // conceptForceAnswer, …) shares it via `ctx`/an explicit trailing arg, so the
+  // first reader to run computes loadMemory+readFactRows once and every later
+  // reader THIS TURN reuses that same result instead of reloading from disk.
+  // Never persisted, never shared across turns or with mutateMemory (a global
+  // cache was explicitly rejected — see the plan doc's own reasoning: a reader
+  // could observe a mutator's half-written object). `injectedFactRowsCache` is a
+  // TEST-ONLY escape hatch (default null, so every real caller gets a fresh one
+  // exactly as before) — passing one in lets a test observe `.reloads` after the
+  // call to assert the real load path ran exactly once this turn.
+  const factRowsCache = injectedFactRowsCache ?? { rows: null };
   // The captured residue is used for RECOGNITION at every dispatch site below
   // (asBareCommand, conversationalTurn, assertTurn, the count lanes, runAsk);
   // the ORIGINAL `line` survives untouched for record.query/logLines fidelity
@@ -8863,7 +8989,7 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
   // 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, tel, biasByBundle };
+  const ctx = { config, source, graph, focus, last, memoryDir, sessionId, templates, env, lexicon, trace, narrate, vocabHint: resolvedVocabHint, tel, biasByBundle, cache: factRowsCache };
   // 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
@@ -8955,7 +9081,7 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
   // authority gate declines (returns null) for anything answerCount should own,
   // so ordinary structural counts fall through completely unaffected.
   if (memoryDir) {
-    const quantifierRecall = await answerQuantifierRecall(memoryDir, workingLine, biasByBundle);
+    const quantifierRecall = await answerQuantifierRecall(memoryDir, workingLine, biasByBundle, factRowsCache);
     if (quantifierRecall != null) {
       note(trace, 'goal: recall a taught quantifier for a class-membership pair ("how many Xs are Ys")');
       note(trace, "lane: answerQuantifierRecall — matched HOW_MANY_ARE_RE with a subject tmct has facts about; literal recall, never real counting");
@@ -8983,7 +9109,7 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
     // ASSERTED vocabulary fact ("every class is a type" → "how many types" = the
     // class count). countFromFacts declines on a real graph kind, so ordinary
     // counts are unaffected; it only speaks for a remembered object noun.
-    const viaFact = memoryDir ? await countFromFacts(graph, memoryDir, workingLine, biasByBundle) : null;
+    const viaFact = memoryDir ? await countFromFacts(graph, memoryDir, workingLine, biasByBundle, factRowsCache) : null;
     if (viaFact != null) {
       note(trace, 'goal: get a count of an asserted-vocabulary kind ("every X is a Y" inherited cardinality)');
       note(trace, "lane: countFromFacts — the counted noun matched a remembered isa-fact's SUBJECT, whose class IS countable");
@@ -9175,9 +9301,11 @@ export async function createSession({
   // module-global state). "sqlite" selects Backend C (createSqliteMemoryStore
   // — a live node:sqlite connection kept open for the session's lifetime,
   // lazily imported only when this is actually chosen). TMCT_MEMORY_BACKEND
-  // mirrors the TMCT_EPHEMERAL/TMCT_NARRATE on/off env convention. No CLI flag
-  // wires this yet (bin/tmct.mjs's flag parsing is out of this change's
-  // scope) — a library/test caller sets the option directly for now.
+  // mirrors the TMCT_EPHEMERAL/TMCT_NARRATE on/off env convention. This
+  // parameter IS `bin/tmct.mjs`'s `tmct chat --memory-backend <...>` CLI flag
+  // (a library/test caller can still set it directly) — the full precedence
+  // (this param > TMCT_MEMORY_BACKEND env > tmct.toml's `[memory] backend` >
+  // "default") is resolved below, once `toml` is known.
   memoryBackend = null,
 } = {}) {
   // EPHEMERAL mode (--ephemeral, or TMCT_EPHEMERAL=1): read the target graph but
@@ -9218,6 +9346,13 @@ export async function createSession({
   // instead of the whole repo.
   let repo;
   let config;
+  // tmct.toml's normalized knobs (src/toml-config.mjs), captured alongside
+  // `config` in whichever branch below resolves the graph path — used further
+  // down for the memory-backend precedence (`toml.memory.backend`), so that
+  // knob is honoured the same way regardless of which graph-resolution tier
+  // fired. `null` when no branch could read a tmct.toml (never fatal — the
+  // backend precedence below just skips this tier).
+  let toml = null;
   const explicitGraphs = (graphPaths || []).filter(Boolean);
   if (explicitGraphs.length) {
     repo = repoPath || gitRoot(cwd) || cwd;
@@ -9225,6 +9360,11 @@ export async function createSession({
     config = resolvedGraphs.length > 1
       ? { graphFile: resolvedGraphs[0], graphFiles: resolvedGraphs }
       : { graphFile: resolvedGraphs[0] };
+    try {
+      const argv = ["--repo", repo];
+      if (configPath) argv.push("--config", configPath);
+      ({ toml } = await resolveRuntimeConfig({ argv, cwd, env: {}, gitRoot }));
+    } catch { toml = null; }
   } else if (repoPath) {
     repo = repoPath;
     // env is deliberately withheld from resolveRuntimeConfig here (passed as
@@ -9235,17 +9375,22 @@ export async function createSession({
     // honored too.
     const argv = ["--repo", repoPath];
     if (configPath) argv.push("--config", configPath);
-    ({ config } = await resolveRuntimeConfig({ argv, cwd, env: {}, gitRoot }));
+    ({ config, toml } = await resolveRuntimeConfig({ argv, cwd, env: {}, gitRoot }));
   } else {
     const root = gitRoot(cwd);
     repo = root || cwd;
     const envGraph = env.TMCT_GRAPH_FILE && String(env.TMCT_GRAPH_FILE).trim();
     if (envGraph) {
       config = loadConfig(env, cwd);
+      try {
+        const argv = [];
+        if (configPath) argv.push("--config", configPath);
+        ({ toml } = await resolveRuntimeConfig({ argv, cwd, env: {}, gitRoot }));
+      } catch { toml = null; }
     } else {
       const argv = [];
       if (configPath) argv.push("--config", configPath);
-      ({ config } = await resolveRuntimeConfig({ argv, cwd, env, gitRoot }));
+      ({ config, toml } = await resolveRuntimeConfig({ argv, cwd, env, gitRoot }));
     }
   }
 
@@ -9330,20 +9475,22 @@ export async function createSession({
   // `closeMemoryStore` is a no-op unless Backend C actually opened a
   // connection (Backend C's node:sqlite import is lazy — it only happens if
   // this branch is actually taken).
-  const backendChoice = String(memoryBackend || env.TMCT_MEMORY_BACKEND || "").trim().toLowerCase();
-  let memoryDir = repo;
-  let closeMemoryStore = async () => {};
-  if (backendChoice === "memory") {
-    const { createInMemoryStore } = await import("./memory/core.mjs");
-    memoryDir = createInMemoryStore();
-  } else if (backendChoice === "sqlite") {
-    const { createSqliteMemoryStore, closeSqliteMemoryStore } = await import("./memory/core.mjs");
-    const dbPath = join(repo, ".tmct", "memory", "graph.sqlite");
-    await mkdir(dirname(dbPath), { recursive: true });
-    const handle = await createSqliteMemoryStore(dbPath);
-    memoryDir = handle;
-    closeMemoryStore = async () => closeSqliteMemoryStore(handle);
-  }
+  //
+  // Precedence — CLI flag > env > tmct.toml > default — matches the graph-path
+  // precedence documented above: `memoryBackend` here is `tmct chat
+  // --memory-backend <...>`'s already-resolved value; TMCT_MEMORY_BACKEND is
+  // the env tier; `toml.memory.backend` is tmct.toml's `[memory] backend`
+  // (src/toml-config.mjs). A toml value of "default" (or anything unrecognized)
+  // falls through to Backend A below, same as an absent value always has.
+  const backendChoice = String(memoryBackend || env.TMCT_MEMORY_BACKEND || toml?.memory?.backend || "").trim().toLowerCase();
+  // openMemoryBackend (memory/core.mjs) is the ONE shared resolver for this
+  // seam — src/init.mjs's corpus seed and bin/tmct.mjs's --corpus/--ontology/
+  // --lexicon activation now call the exact same function, so a repo's
+  // seeded facts and its chat-taught facts always land in the same backend
+  // (a split-brain bug found in review: init used to always seed Backend A
+  // regardless of the configured backend).
+  const { openMemoryBackend } = await import("./memory/core.mjs");
+  const { dir: memoryDir, close: closeMemoryStore } = await openMemoryBackend(repo, backendChoice);
 
   const empty = graph.individuals.length === 0;
   // W3: FIRST RUN in a graph-less repo seeds a capped ConceptNet slice into