@polycode-projects/the-mechanical-code-talker 2.9.0 → 2.9.4

package/src/services/chat-session.mjs

@@ -116,12 +116,14 @@ export async function createSession({
   gitRoot = gitToplevel,
   ephemeral = false,
   narrate = false,
-  // The storage-backend seam: "file" (default) keeps memoryDir a plain
-  // repo-path string (Backend A). "memory" selects Backend B (zero disk I/O,
-  // session-scoped). "sqlite" selects Backend C (a live node:sqlite
-  // connection, lazily imported only when chosen). This is `tmct chat
-  // --memory-backend <...>`'s already-resolved value; full precedence (this
-  // param > TMCT_MEMORY_BACKEND env > tmct.toml > "default") resolved below.
+  liveReference = false,
+  // The storage-backend seam: the default (empty or "default") resolves to
+  // Backend C — the sqlite store at .tmct/memory/graph.sqlite, a live
+  // node:sqlite connection lazily imported on open. The flat-file Backend A is
+  // retired from routing. "memory" selects Backend B (zero disk I/O,
+  // session-scoped). This is `tmct chat --memory-backend <...>`'s
+  // already-resolved value; full precedence (this param > TMCT_MEMORY_BACKEND
+  // env > tmct.toml > the sqlite default) resolved below.
   memoryBackend = null,
 } = {}) {
   // EPHEMERAL mode (--ephemeral, or TMCT_EPHEMERAL=1): read the target graph but
@@ -135,6 +137,12 @@ export async function createSession({
   // narrate mode already on. Session-scoped and mutable — `/narrate on|off`
   // flips it turn-to-turn (see `turn()` below). Default OFF.
   let narrateOn = narrate || /^(1|true|yes)$/i.test(String(env.TMCT_NARRATE || ""));
+  // LIVE WIKIPEDIA supplement (--live-wikipedia, TMCT_LIVE_WIKIPEDIA=1, or
+  // tmct.toml's corpus tier3 — the tier that already means "reach for the
+  // network"): start the session with the live lookup enabled. Session-scoped
+  // and mutable — `/wiki on|off` flips it turn-to-turn, exactly like narrate.
+  // Default OFF; the toml tier is folded in below, once toml has resolved.
+  let liveReferenceOn = liveReference || /^(1|true|yes)$/i.test(String(env.TMCT_LIVE_WIKIPEDIA || ""));
   // Graph resolution order (delegates to src/services/cli-args.mjs's
   // resolveRuntimeConfig): explicit --graph path(s) win outright; then --repo
   // (never silently redirected by env); then TMCT_GRAPH_FILE env; then
@@ -190,6 +198,10 @@ export async function createSession({
   // to the shipped defaults for every key.
   const gameConfig = resolveGameConfig(toml);
 
+  // tmct.toml's corpus tier3 opts the session into the live supplement too —
+  // the flag/env tiers above stay authoritative when set.
+  if (toml?.corpus?.tier === "tier3") liveReferenceOn = true;
+
   // Ephemeral: keep config.graphFile pointing at the READ graph, but divert the
   // write base (repo → logs/memory/sessions) to a throwaway temp dir. The committed
   // target is never touched; the demo's memory simply doesn't persist across runs.
@@ -259,9 +271,9 @@ export async function createSession({
   };
 
   // `memoryDir` is the opaque token every memory/core.mjs call in this file
-  // threads through unchanged. Backend A (default) keeps it the plain repo
-  // string; Backend B/C swap in a handle instead. Precedence — CLI flag > env
-  // > tmct.toml > default.
+  // threads through unchanged — always a Backend B/C handle from
+  // openMemoryBackend now that the flat-file Backend A is retired from
+  // routing. Precedence — CLI flag > env > tmct.toml > the sqlite default.
   const backendChoice = String(memoryBackend || env.TMCT_MEMORY_BACKEND || toml?.memory?.backend || "").trim().toLowerCase();
   // openMemoryBackend is the ONE shared resolver for this seam — init.mjs's
   // corpus seed calls the exact same function, so a repo's seeded facts and
@@ -276,14 +288,14 @@ export async function createSession({
   // bootstrap (a fixture/provider graph never seeds), only once (the marker),
   // and never when TMCT_NO_SEED=1 opts out.
   //
-  // Known Backend B/C limitation: seedBootstrapMemory/hasSeededVocabulary and
-  // sessions.mjs's own per-turn utterance mirror all resolve their marker
-  // file / repoDir directly off the STRING `repo` path, not the actual
-  // Backend B/C handle — so W3 seeding is skipped for a non-default backend,
-  // and a Backend B/C session's Utterance/Session individuals still land in
-  // an ordinary Backend-A .tmct/memory/graph.json. Taught FACTS themselves
-  // are unaffected: only the conversational transcript mirror leaks onto
-  // disk, never the facts.
+  // Known residual split: seedBootstrapMemory/hasSeededVocabulary resolve
+  // their marker file off the STRING `repo` path (correct — the marker is a
+  // file, not store content), so W3 seeding still only fires on the default
+  // token. And sessions.mjs's per-turn utterance mirror still writes an
+  // ordinary .tmct/memory/graph.json off the repo string — a file no routed
+  // reader opens now that Backend A is retired from routing. Taught FACTS
+  // themselves are unaffected: only the conversational transcript mirror
+  // leaks onto disk, never the facts.
   let seeded = null;
   if (empty && backendChoice === "" && String(env.TMCT_NO_SEED || "") !== "1") {
     seeded = await seedBootstrapMemory(repo, env);
@@ -336,6 +348,7 @@ export async function createSession({
     get planState() { return planState; },
     get turns() { return turns; },
     get narrate() { return narrateOn; },
+    get liveReference() { return liveReferenceOn; },
     promptFor: () => promptFor(focus),
 
     /** One dispatched turn through the FULL sink sequencing (writeLog → writeSidecar
@@ -346,7 +359,7 @@ export async function createSession({
     async turn(line) {
       let result;
       try {
-        result = await runTurn(line, { config, source, graph, focus, last, memoryDir, sessionId, env, lexicon, narrate: narrateOn, vocabHint, tel, biasByBundle, planState, gameConfig });
+        result = await runTurn(line, { config, source, graph, focus, last, memoryDir, sessionId, env, lexicon, narrate: narrateOn, liveReference: liveReferenceOn, vocabHint, tel, biasByBundle, planState, gameConfig });
       } catch (e) {
         const ts = new Date().toISOString();
         const message = e instanceof Error ? e.message : String(e);
@@ -357,13 +370,15 @@ export async function createSession({
         turns += 1;
         return { answer: `Something went wrong answering that (${message}). Try rephrasing, or /help.`, end: false, prompt: promptFor(focus) };
       }
-      const { answer, logLines, record, focus: nextFocus, last: nextLast, end, narrate: nextNarrate } = result;
+      const { answer, logLines, record, focus: nextFocus, last: nextLast, end, narrate: nextNarrate, liveReference: nextLiveReference } = result;
       focus = nextFocus;
       last = nextLast;
       if ("planState" in result) planState = result.planState;
-      // /narrate on|off (runCommand) rides the turn RESULT the same way a focus
-      // update does — apply it to this handle's session-scoped state.
+      // /narrate on|off and /wiki on|off (runCommand) ride the turn RESULT the
+      // same way a focus update does — apply them to this handle's
+      // session-scoped state.
       if (typeof nextNarrate === "boolean") narrateOn = nextNarrate;
+      if (typeof nextLiveReference === "boolean") liveReferenceOn = nextLiveReference;
       await writeLog(logLines.join("\n") + "\n");
       await writeSidecar(record);
       turnRecords.push(record);
@@ -416,12 +431,13 @@ export async function runChat({
   gitRoot = gitToplevel,
   ephemeral = false,
   narrate = false,
+  liveReference = false,
   memoryBackend = null,
 } = {}) {
   // createSession's first-run seed (~2-3s) produces ZERO output until it fully
   // resolves, which otherwise reads as `npm run chat` hanging with total silence.
   output.write("tmct — starting…\n");
-  const session = await createSession({ repoPath, graphPaths, configPath, source, env, cwd, gitRoot, ephemeral, narrate, memoryBackend });
+  const session = await createSession({ repoPath, graphPaths, configPath, source, env, cwd, gitRoot, ephemeral, narrate, liveReference, memoryBackend });
 
   const dim = (s) => (env.NO_COLOR || !output.isTTY ? s : `\x1b[2m${s}\x1b[0m`);
   for (const line of session.bannerLines) output.write(dim(line) + "\n");

package/src/services/chat.mjs

@@ -46,8 +46,12 @@ import { readConstructionFiles } from "../adapters/corpus/construction-banks.mjs
 import { fuzzyMatchInSet, fuzzyBound } from "../domain/interpret/fuzzy.mjs";
 import { loadLexicon, lookupNoun } from "../domain/grammar/lexicon.mjs";
 import { pickPhrase } from "../domain/answer-variants.mjs";
-import { REFERENCE_PACK_NAME, cleanMissReferenceTerm, renderReferenceAnswer, referenceProvenanceTag } from "../domain/reference-pack.mjs";
+import {
+  REFERENCE_PACK_NAME, cleanMissReferenceTerm, renderReferenceAnswer, referenceProvenanceTag,
+  LIVE_PACK_NAME, cleanMissLiveTerm, renderLiveReferenceAnswer, liveProvenanceTag,
+} from "../domain/reference-pack.mjs";
 import { getReferencePackProvider } from "../adapters/corpus/reference-pack.mjs";
+import { getLiveReferenceProvider } from "../adapters/corpus/wikipedia-live.mjs";
 import { CHILD_PACK_NAME, childProvenanceTag } from "../domain/child-pack.mjs";
 import { getChildPackProvider } from "../adapters/corpus/child-pack.mjs";
 import { dialogueActForLane } from "../domain/dialogue-acts.mjs";
@@ -2391,6 +2395,15 @@ const BOARD_WHERE_EVERY_RE = /^where\s+(?:is|are)\s+(?:every|each|all(?:\s+the)?
  *  question-shape ("was X Y?") this could ever misfire on. */
 const TEACH_PROPERTY_RE = /^(?:every\s+|each\s+|all\s+|the\s+)?(.+?)\s+(?:is|are|was|were)\s+(?!an?\b|the\b)([A-Za-z][\w-]*)$/i;
 
+/** The closed place-adverb set ("anywhere"/"everywhere"/"nowhere"/
+ *  "somewhere"). One of these sitting in an OBJECT slot ("http.mjs used is
+ *  anywhere") marks a garbled usage QUESTION, never a storable property or
+ *  relation object: no reader ever matches a fact whose object is a place
+ *  adverb, so storing one is a silent write with no possible read-back.
+ *  Every teach path that binds a free-form object refuses on it, and the
+ *  teach-offer generators never suggest a phrasing that contains one. */
+const PLACE_ADVERB_OBJECT_RE = /^(?:anywhere|everywhere|nowhere|somewhere)$/i;
+
 /** The teach lane's provenance tag — mirrors grammar/assert.mjs's provenanceTag
  *  shape under a distinct "teach:" family, so a taught fact is auditable apart
  *  from the ACE-parsed asserts: teach:chat:<sessionId>@<ts>. core.mjs maps the
@@ -2735,12 +2748,18 @@ async function objectReadsAsNonNoun(word) {
     return false;
   }
 }
-async function unknownObjectFallback(payload, { memoryDir, sessionId, lexicon }, cache = null) {
+async function unknownObjectFallback(payload, { memoryDir, sessionId, lexicon, classIntent = false }, cache = null) {
   if (!memoryDir) return null;
   const m = String(payload).trim().match(UNKNOWN_SUBJECT_RE);
   if (!m) return null;
   const [, det, subjectRaw, verb, objectRaw] = m;
-  if (!/^(?:every|each|all|any)$/i.test((det || "").trim())) return null; // class-level mint needs a real universal quantifier
+  // `classIntent` (an explicit "kind of"/"type of" infix in the ORIGINAL
+  // sentence, detected by the caller before stripKindOf erased it) is the
+  // same class-level signal a universal quantifier gives: "dog is a kind of
+  // mammal" — tmct's OWN read-back phrasing for a subClassOf fact — names a
+  // class relation, never one entity's property, so it earns the mint the
+  // bare unmarked "module is banana" shape must still never get.
+  if (!/^(?:every|each|all|any)$/i.test((det || "").trim()) && !classIntent) return null; // class-level mint needs a universal quantifier or an explicit kind-of infix
   const { loadLexicon, lookupNoun } = await import("../domain/grammar/lexicon.mjs");
   const lex = lexicon || loadLexicon();
   const subjectGrounded = await isGroundedTerm(subjectRaw, lex, memoryDir, cache);
@@ -2832,6 +2851,7 @@ async function unknownAdjectiveFallback(payload, { memoryDir, sessionId, lexicon
   const m = String(payload).trim().match(UNKNOWN_SUBJECT_RE);
   if (!m) return null;
   const [, , subjectRaw, , objectRaw] = m;
+  if (PLACE_ADVERB_OBJECT_RE.test(objectRaw)) return null; // a place adverb is never a property
   const { loadLexicon, lookupNoun, classify } = await import("../domain/grammar/lexicon.mjs");
   const lex = lexicon || loadLexicon();
   // Y already a known NOUN or a fact-grounded CLASS term — a genuine class-
@@ -3162,6 +3182,7 @@ async function generalVerbTeach(payload) {
   // object no question can match.
   const object = folded.object.replace(/^(?:an?|the)\s+/i, "").trim();
   if (!subject || !object) return null; // no well-formed triple — honest decline (point 6)
+  if (PLACE_ADVERB_OBJECT_RE.test(object)) return null; // a place adverb is never a real object
   return { subject, predicate: negated ? negatedPredicate(folded.predicate) : folded.predicate, object };
 }
 
@@ -3420,13 +3441,24 @@ function matchBareCanTeach(text) {
  *  user to teach a class-membership fact that was never what they said. Only
  *  a payload that ALREADY carried an article gets its article corrected —
  *  the "every monkey is a animal" -> "an animal" case this function exists
- *  for in the first place. */
+ *  for in the first place.
+ *
+ *  A PLURAL phrasing ("all spiders are venomous") folds its subject to the
+ *  singular the suggested "every …" rewrite grammatically requires — "every
+ *  spiders is venomous" is ungrammatical AND stores under a different
+ *  spelling than the singular every other frame uses, so following it
+ *  verbatim wrote a plural-keyed orphan fact. Gated on the "are" copula, the
+ *  same is/are safety distinction unknownSubjectFallback draws (an s-final
+ *  singular like "redis is a cache" must never strip). A trailing
+ *  sentence-final mark is tolerated for the same reason UNKNOWN_SUBJECT_RE
+ *  tolerates one: an ordinary full-sentence turn ("dog is a mammal.")
+ *  otherwise lost its hint by one character. */
 function teachSuggestion(payload) {
-  const m = String(payload).match(/^(?:every |each |all |a |an )?([\w-]+) (?:is|are) (a |an )?([\w-]+)$/i);
+  const m = String(payload).match(/^(?:every |each |all |a |an )?([\w-]+) (is|are) (a |an )?([\w-]+)[.!?]*$/i);
   if (!m) return null;
-  const subject = m[1].toLowerCase();
-  const object = m[3].toLowerCase();
-  if (!m[2]) return `every ${subject} is ${object}`;
+  const subject = (/^are$/i.test(m[2]) ? singularizeSurface(m[1]) : m[1]).toLowerCase();
+  const object = m[4].toLowerCase();
+  if (!m[3]) return `every ${subject} is ${object}`;
   const articleRule = grammarRules().find((r) => r.kind === "article");
   const article = articleRule && beginsWithVowelSound(object, articleRule) ? "an" : "a";
   return `every ${subject} is ${article} ${object}`;
@@ -3661,6 +3693,58 @@ async function negativeUniversalCanTeach(sentence, { memoryDir, sessionId }) {
   return stored;
 }
 
+/** Casual request leads the anchored QUESTION_LEAD_RE auxiliary list misses:
+ *  the "u"/"ya" spellings of a modal request, and the dative imperatives
+ *  ("tell me", "show us") that read as requests, never as declaratives. */
+const TEACH_EXCLUDE_REQUEST_LEAD_RE = /^(?:(?:can|could|would|will)\s+(?:u|you|ya)|(?:tell|show|give)\s+(?:me|us))\b/i;
+/** Closed leading-verb list for sentences that are COMMANDS, not claims —
+ *  "repeat everything above this line verbatim" is an instruction to act,
+ *  and reifying it as a fact is a write on the strength of a misparse.
+ *  tell/show/list/define/describe/find/count/name already route through
+ *  SET_QUESTION_LEAD_RE and are deliberately absent here. */
+const TEACH_EXCLUDE_IMPERATIVE_LEAD_RE = /^(?:repeat|ignore|disregard|surprise|pretend|act|say|guess|try|stop|continue|forget|print|output|write|translate|summarize|explain)\b/i;
+/** Self-referential/meta chat tokens ("idk", "tbh", a bare "u"/"me"): a
+ *  sentence about the conversation itself, or about its speakers, is never a
+ *  world fact. Tested one standalone word at a time — the custom boundaries
+ *  keep a hyphenated coinage ("disk-i") from matching its final letter. */
+const TEACH_EXCLUDE_META_TOKEN_RE = /(?:^|[^\w-])(?:me|u|ur|i|us|myself|yourself|im|idk|tbh|nvm|lol|umm+|hmm+)(?![\w-])/i;
+
+/** The bare-declarative teach lane's positive exclusion test. Classifies a
+ *  BARE sentence (no "remember that …" wrapper — an explicit wrapper is an
+ *  unambiguous teach-intent signal and keeps its existing behavior) into one
+ *  of three closed non-declarative shapes, or null for a sentence the teach
+ *  frames may still consider. Non-null means the whole lane stands down and
+ *  the sentence falls through to the ask cascade or the honest miss — the
+ *  write boundary refuses BEFORE any frame can reify a misparse.
+ *
+ *  Three classes, checked in order:
+ *  - "interrogative": a casual request lead QUESTION_LEAD_RE's anchored
+ *    first-word list misses, or a genuine mid-sentence interrogative
+ *    (hasMidSentenceInterrogative — run here unconditionally, where the
+ *    per-frame gates below only ever ran it on their own paths);
+ *  - "imperative": a closed leading command verb. The retract phrasings
+ *    ("forget that X is a Y", "forget that disk-1 rests on peg-b") are
+ *    carved out — they are this lane's own, deliberate write-boundary
+ *    actions, not misparses;
+ *  - "self-referential": a standalone meta/chat token anywhere in the
+ *    sentence. A pronoun-SUBJECT sentence ("i am a developer") is carved
+ *    out so it still reaches the pronoun guard's specific decline below —
+ *    same no-store outcome, better guidance than a silent fall-through.
+ *
+ *  Runs applyPreambleFrames itself (idempotent on an already-peeled
+ *  sentence), so a stripped greeting can never leave a leading token that
+ *  misclassifies, and callers outside teachLane can hand it a raw surface. */
+async function teachExclusionReason(sentence) {
+  const s = applyPreambleFrames(String(sentence || "").trim());
+  if (TEACH_EXCLUDE_REQUEST_LEAD_RE.test(s) || (await hasMidSentenceInterrogative(s))) return "interrogative";
+  const unpunctuated = s.replace(/[.!?]+\s*$/, "");
+  if (TEACH_EXCLUDE_IMPERATIVE_LEAD_RE.test(s)
+    && !RETRACT_FORGET_RE.test(unpunctuated) && !RETRACT_FORGET_LOCATIVE_RE.test(unpunctuated)) return "imperative";
+  if (TEACH_EXCLUDE_META_TOKEN_RE.test(s) && !TEACH_PRONOUN_RE.test(s)) return "self-referential";
+  return null;
+}
+export { teachExclusionReason };
+
 async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cache = null, planHolder = null }) {
   // A closed discourse-marker preamble ahead of a teach sentence ("howdy
   // pardner, remember that TaskController is fragile") would otherwise
@@ -3683,6 +3767,12 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
   if (QUESTION_LEAD_RE.test(correctMisspellings(rawInput))) return null;
   const m = rawInput.match(TEACH_RE);
   const wrappedInput = m ? m[1].trim() : null;
+  // The positive exclusion test (teachExclusionReason, above) — BARE surface
+  // only: an interrogative, imperative, or self-referential sentence never
+  // reaches any teach frame, so a fresh casual phrasing can't slip past the
+  // per-frame gates and reify as a fact. An explicit wrapper keeps its
+  // existing, more permissive path.
+  if (wrappedInput == null && (await teachExclusionReason(rawInput))) return null;
   // Refuse an existential BEFORE any frame below can read it as a universal:
   // every one of them stores "some men are fathers" as a premise meaning every
   // man, whether it keeps the quantifier as an attribute the reasoner doesn't
@@ -3712,7 +3802,12 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
   // kind of parent" normalizes to "a father is a parent", which
   // unknownSubjectFallback already stores as father ⊑ parent ("parent" is
   // already a lexicon noun).
-  const stripKindOf = (s) => (s == null ? s : s.replace(/\b(is|are|was|were)\s+(?:an?\s+)?(?:kind|type)\s+of\s+/i, "$1 a "));
+  const kindOfInfixRe = /\b(is|are|was|were)\s+(?:an?\s+)?(?:kind|type)\s+of\s+/i;
+  const stripKindOf = (s) => (s == null ? s : s.replace(kindOfInfixRe, "$1 a "));
+  // Remembered BEFORE the strip erases it: an explicit "kind of"/"type of"
+  // infix is an unambiguous class-level claim, and unknownObjectFallback's
+  // quantifier gate accepts it as a peer of "every" (its own docblock).
+  const kindOfClassIntent = kindOfInfixRe.test(wrappedInput ?? rawInput);
   // "my <class-noun> <Name> is/are …" — a THIRD natural phrasing of the exact
   // same "X is a Y" assertion this lane already teaches two other ways ("john
   // is a man", a bare name; "every cat is an animal", a universal quantifier) — a
@@ -4600,7 +4695,7 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
     // STATIC lexicon (or a prior taught fact) already grounds can mint a
     // brand-new object term. See unknownObjectFallback's own docblock for the
     // exact narrowing rules (the "both sides ungrounded" safety guard, etc.).
-    const objectFallback = await unknownObjectFallback(payload, { memoryDir, sessionId, lexicon }, cache);
+    const objectFallback = await unknownObjectFallback(payload, { memoryDir, sessionId, lexicon, classIntent: kindOfClassIntent }, cache);
     if (objectFallback) return objectFallback;
     // ADJECTIVE-MINT fallback: tried right after unknownObjectFallback
     // declines, so a grounded subject (static
@@ -4617,7 +4712,7 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
     // wrapped "X is a Y" over known lexicon still lands as rdfs:subClassOf.
     if (wrapped) {
       const prop = wrapped.match(TEACH_PROPERTY_RE);
-      if (prop) {
+      if (prop && !PLACE_ADVERB_OBJECT_RE.test(prop[2])) {
         const stored = await teachFact(memoryDir, sessionId, {
           subject: prop[1], predicate: HAS_PROPERTY_PREDICATE, object: prop[2],
         });
@@ -5270,6 +5365,7 @@ export async function helpText() {
     ["/capabilities", "what /plan can plan over: the built-in graph tools plus your taught actions"],
     ["/syllogise <term>", "work out and remember what follows from the facts about a term (needed for chains longer than 2 hops)"],
     ["/narrate on|off", "verbose developer/debug mode: decision points, matched pattern, results+sources, goal per turn"],
+    ["/wiki on|off", "live Wikipedia supplement (default off): a question I can't answer also tries en.wikipedia.org (network), cited"],
     ["/help", "this list"],
     ["/exit", "leave the session (also Ctrl+C / Ctrl+D)"],
   ];
@@ -7666,7 +7762,8 @@ async function factReadBackReaders(memoryDir, query, envelope, miss, graph = nul
         // only ever fires for "it"/"this"/"that" — never a personal pronoun like
         // "you", so `subject` itself would already carry the pronoun verbatim).
         if (subject && !/^there\b/i.test(subject) && !envelope?.parsed
-          && !IS_ADJECTIVE_YESNO_PRONOUN_SUBJECT_RE.test(rawSubject)) {
+          && !IS_ADJECTIVE_YESNO_PRONOUN_SUBJECT_RE.test(rawSubject)
+          && !PLACE_ADVERB_OBJECT_RE.test(emptyIsAdj[2].trim())) {
           return unknownAdjectiveOffer(subject, emptyIsAdj[2].trim().toLowerCase());
         }
       }
@@ -8815,7 +8912,7 @@ async function factReadBackReaders(memoryDir, query, envelope, miss, graph = nul
       // subject known only under an UNRELATED property (e.g. "deprecated")
       // must not offer to teach "tested" when ask()'s own grammar already
       // resolved it structurally.
-      if (!envelope?.parsed) return unknownAdjectiveOffer(subject, adjective);
+      if (!envelope?.parsed && !PLACE_ADVERB_OBJECT_RE.test(adjective)) return unknownAdjectiveOffer(subject, adjective);
     }
   }
 
@@ -9459,6 +9556,39 @@ async function referencePackMissAnswer(term, { graph, memoryDir, lexicon, env, c
   return key ? referencePackAnswerForKey(key, env) : null;
 }
 
+/** The LIVE variant of cleanMissPackKey — the same resolveEntity and
+ *  remembered-fact checks, but through cleanMissLiveTerm, which drops the
+ *  lexicon-membership wall: a word the lexicon has never met is exactly what
+ *  the live lookup exists for. Null means the turn proceeds byte-identically
+ *  to a live-off run. */
+async function cleanMissLiveKey(term, { graph, memoryDir, lexicon, cache }) {
+  if (!term || !memoryDir) return null;
+  let key = null;
+  try { key = cleanMissLiveTerm(term, lexicon ?? undefined); } catch { key = null; }
+  if (!key) return null;
+  if (await resolveEntity(graph, term)) return null;
+  let normFactTerm;
+  try { ({ normFactTerm } = await import("../adapters/memory/core.mjs")); } catch { return null; }
+  const variants = factTermVariants(normFactTerm, term);
+  variants.add(key);
+  const rows = await factRows(memoryDir, cache);
+  if (rows.some((f) => variants.has(f.subject) || variants.has(f.object))) return null;
+  return key;
+}
+
+/** The live Wikipedia lookup for an already-gated key: the article, or null
+ *  (toggle-off provider, network failure, throttle, drift-guard rejection —
+ *  all byte-identical to a live-off run). `onLiveLookup` is a notify-only
+ *  hook (the web page's "searching wikipedia…" statusline); its own failure
+ *  is swallowed too. */
+async function liveReferenceAnswerForKey(key, onLiveLookup) {
+  try { if (typeof onLiveLookup === "function") onLiveLookup(key); } catch { /* notify-only */ }
+  let article = null;
+  try { article = await getLiveReferenceProvider().lookup(key); } catch { article = null; }
+  if (!article) return null;
+  return { key, article, text: renderLiveReferenceAnswer(key, article) };
+}
+
 /** The child-pack half of learn-on-miss, for an already-gated key: look the
  *  key up in the shipped child triples pack and append every fact under child
  *  provenance, so the SAME question can be re-asked from the store. Null on a
@@ -9480,13 +9610,13 @@ async function childPackFactsForKey(key, { memoryDir, env, cache }) {
 /** Store the article's first-sentence isa as a subClassOf fact carrying
  *  reference provenance — AFTER the cited answer composed, and failure-
  *  tolerated: the answer stands whether or not the fact lands. */
-async function appendReferenceIsaFact(memoryDir, key, article, cache) {
+async function appendReferenceIsaFact(memoryDir, key, article, cache, tagFor = referenceProvenanceTag) {
   if (!article?.isa) return;
   try {
     const { appendFact } = await import("../adapters/memory/core.mjs");
     await appendFact(memoryDir, {
       subject: key, predicate: "rdfs:subClassOf", object: article.isa,
-      provenance: referenceProvenanceTag(article),
+      provenance: tagFor(article),
     });
     if (cache) cache.rows = null;
   } catch { /* tolerated — the cited answer is already composed */ }
@@ -10649,7 +10779,7 @@ const DECISION_RECALL_RE = /^(?:remind\s+me\s+)?what\s+(?:did\s+)?(?:we|i|you)\s
  *  than silently accepted alongside the current location. */
 const MOVE_HISTORY_RE = /^where\s+did\s+(.+?)\s+(?:move|get\s+moved|go)(?:\s+to)?[?.!\s]*$/i;
 
-async function runAsk(query, { config, source, graph, focus, last, templates, memoryDir, sessionId = "", lexicon = null, env, trace, vocabHint = null, tel = null, biasByBundle = {}, cache = null, vocabAntecedent = null, planHolder = null, gameConfig = DEFAULT_GAME_CONFIG }) {
+async function runAsk(query, { config, source, graph, focus, last, templates, memoryDir, sessionId = "", lexicon = null, env, trace, vocabHint = null, tel = null, biasByBundle = {}, cache = null, vocabAntecedent = null, planHolder = null, gameConfig = DEFAULT_GAME_CONFIG, liveReference = false, onLiveLookup = null }) {
   const ts = new Date().toISOString();
   // DISCOURSE ANAPHORA: a follow-up like "which of those are tested" / "count
   // them" filters or counts the PREVIOUS answer's entity set, threaded as
@@ -11251,6 +11381,14 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
           const ref = await referencePackAnswerForKey(key, env);
           if (ref) bareMetaHit = { text: ref.text, replace: true, reference: ref };
         }
+        // The live Wikipedia supplement (opt-in), LAST — the shipped packs
+        // always speak first, and a live null/failure leaves bareMetaHit
+        // exactly as a live-off run would.
+        if (!bareMetaHit && liveReference && refTerm) {
+          const liveKey = await cleanMissLiveKey(refTerm, { graph, memoryDir, lexicon, cache });
+          const live = liveKey ? await liveReferenceAnswerForKey(liveKey, onLiveLookup) : null;
+          if (live) bareMetaHit = { text: live.text, replace: true, live };
+        }
       }
     }
     // A bare "what is X" naming a REAL code-graph entity (not a taught fact,
@@ -11298,6 +11436,15 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
     note(trace, "lane: (2b) REFERENCE PACK — a bare \"what is X\" clean miss answered from the shipped reference pack, cited");
     note(trace, `source: reference pack ${REFERENCE_PACK_NAME} — article "${bareMetaHit.reference.article.title}" (revid ${bareMetaHit.reference.article.revid})`);
     await appendReferenceIsaFact(memoryDir, bareMetaHit.reference.key, bareMetaHit.reference.article, cache);
+  } else if (bareMetaHit?.live) {
+    // The bare-form LIVE hit settles the same way, under live provenance.
+    answer = bareMetaHit.text;
+    via = "reference";
+    recordMiss = false;
+    handled = true;
+    note(trace, "lane: (2b) LIVE WIKIPEDIA — a bare \"what is X\" clean miss answered from a live en.wikipedia.org lookup (opt-in), cited");
+    note(trace, `source: live reference ${LIVE_PACK_NAME} — article "${bareMetaHit.live.article.title}" (revid ${bareMetaHit.live.article.revid})`);
+    await appendReferenceIsaFact(memoryDir, bareMetaHit.live.key, bareMetaHit.live.article, cache, liveProvenanceTag);
   } else if (bareMetaHit) {
     answer = bareMetaHit.replace ? bareMetaHit.text : `${answer}\n${bareMetaHit.text}`;
     // Same discipline as lane (3): a fact-lane return flagged `miss` is an
@@ -11707,6 +11854,22 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
         await appendReferenceIsaFact(memoryDir, ref.key, ref.article, cache);
       }
     }
+    // The live Wikipedia supplement (opt-in), strictly AFTER both shipped
+    // packs: its own gate (no lexicon-membership wall) may pass where the
+    // pack gate could not, and a null/throwing lookup leaves the honest
+    // miss byte-identical to a live-off run.
+    if (miss && recordMiss && via === "composed" && liveReference && refTerm) {
+      const liveKey = await cleanMissLiveKey(refTerm, { graph, memoryDir, lexicon, cache });
+      const live = liveKey ? await liveReferenceAnswerForKey(liveKey, onLiveLookup) : null;
+      if (live) {
+        answer = live.text;
+        via = "reference";
+        recordMiss = false;
+        note(trace, "lane: (4h) LIVE WIKIPEDIA — a clean miss answered from a live en.wikipedia.org lookup (opt-in), cited");
+        note(trace, `source: live reference ${LIVE_PACK_NAME} — article "${live.article.title}" (revid ${live.article.revid})`);
+        await appendReferenceIsaFact(memoryDir, live.key, live.article, cache, liveProvenanceTag);
+      }
+    }
   }
   // (5) #1 SHORT TAILORED MISS — replace ONLY the engine's full grammar cheat-sheet
   // wall (WALL_MISS_RE). Receipt-bearing misses keep their specific wording.
@@ -11890,24 +12053,26 @@ const GOAL_BY_COMMAND = {
   arch: "understand the overall architecture (package/module boundaries)",
   capabilities: "see what /plan can plan over — built-in query tools and taught actions",
   syllogise: "materialize the entailed facts that follow from what's remembered about one term",
+  wiki: "toggle the live Wikipedia supplement for questions nothing local can answer",
 };
 
 /** A slash-command → the mapped tool (or the /help, /focus, /narrate, unknown
  *  cases). Returns the same { answer, logLines, record, focus } shape as
  *  runAsk. Also carries a `goal` field mirroring runAsk's own, so
  *  withGoalLine's "Goal (inferred): …" line fires for command dispatches too. */
-async function runCommand(line, { config, source, graph, focus, memoryDir, trace, narrate = false, tel = null, biasByBundle = {}, cache = null }) {
+async function runCommand(line, { config, source, graph, focus, memoryDir, trace, narrate = false, liveReference = 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();
   const argText = (sp === -1 ? "" : line.slice(sp + 1)).trim();
-  const mk = (answer, { resolvedIds = [], miss = false, newFocus = focus, narrateNext } = {}) => ({
+  const mk = (answer, { resolvedIds = [], miss = false, newFocus = focus, narrateNext, liveReferenceNext } = {}) => ({
     answer,
     logLines: [ts, `> ${line}`, answer, ""],
     record: { type: "turn", ts, query: line, command: name, via: "command", resolvedIds, answeredIds: [], miss },
     focus: newFocus,
     goal: GOAL_BY_COMMAND[name] || "use a specific tool/command directly",
     ...(narrateNext !== undefined ? { narrate: narrateNext } : {}),
+    ...(liveReferenceNext !== undefined ? { liveReference: liveReferenceNext } : {}),
   });
 
   if (name === "help") { note(trace, "goal: get oriented / learn available commands"); return mk(await helpText()); }
@@ -11931,6 +12096,20 @@ async function runCommand(line, { config, source, graph, focus, memoryDir, trace
     return mk(`narrate mode ${next ? "on" : "off"}.`, { narrateNext: next });
   }
 
+  // /wiki on|off — the live Wikipedia supplement toggle (session-scoped,
+  // exactly the /narrate pattern: the new state rides the turn RESULT as
+  // `liveReference`, and each session shell applies it to its own mutable
+  // state). A bare "/wiki" reports the CURRENT state and changes nothing.
+  if (name === "wiki") {
+    const arg = argText.toLowerCase();
+    if (arg !== "on" && arg !== "off") {
+      return mk(`live Wikipedia supplement is ${liveReference ? "on" : "off"} — /wiki on or /wiki off. `
+        + "When on, a question I can't answer also tries en.wikipedia.org (network).");
+    }
+    const next = arg === "on";
+    return mk(`live Wikipedia supplement ${next ? "on" : "off"}.`, { liveReferenceNext: next });
+  }
+
   // /memory [verbose] — what tmct remembers, as text (the same renderer
   // serves the `tmct memory` CLI).
   if (name === "memory") {
@@ -12871,7 +13050,7 @@ function vocabAntecedentFrom(last) {
   return m[1];
 }
 
-export async function runTurn(input, { config, source = defaultSource, graph = null, focus = null, last = null, memoryDir = null, sessionId = "", env = process.env, lexicon = null, narrate = false, vocabHint = null, tel = null, biasByBundle = {}, factRowsCache: injectedFactRowsCache = null, planState = null, gameConfig = null, _noSplit = false } = {}) {
+export async function runTurn(input, { config, source = defaultSource, graph = null, focus = null, last = null, memoryDir = null, sessionId = "", env = process.env, lexicon = null, narrate = false, liveReference = false, onLiveLookup = null, vocabHint = null, tel = null, biasByBundle = {}, factRowsCache: injectedFactRowsCache = null, planState = null, gameConfig = null, _noSplit = false } = {}) {
   // Every game's tuning knobs (spider-fly's mass economy, guess-the-number's
   // bounds, the shared plan lane's search-depth cap) — a caller's own
   // gameConfig (chat-session.mjs resolves one per session from tmct.toml)
@@ -12934,7 +13113,7 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
   // the PLAN NEXT block below write planHolder.state; every other path leaves
   // it untouched, and the caller re-threads whatever comes back.
   const planHolder = { state: planState };
-  const ctx = { config, source, graph, focus, last, memoryDir, sessionId, templates, env, lexicon, trace, narrate, vocabHint: resolvedVocabHint, tel, biasByBundle, cache: factRowsCache, vocabAntecedent, planHolder, gameConfig: resolvedGameConfig };
+  const ctx = { config, source, graph, focus, last, memoryDir, sessionId, templates, env, lexicon, trace, narrate, liveReference, onLiveLookup, vocabHint: resolvedVocabHint, tel, biasByBundle, cache: factRowsCache, vocabAntecedent, planHolder, gameConfig: resolvedGameConfig };
   // A DISPATCHED turn (count / slash-command / ask) becomes the new "last
   // answer" that why/say-more re-renders; a conversational turn does not.
   // Every dispatched turn's result passes through finish() here — the LAST