@polycode-projects/the-mechanical-code-talker 4.1.1 → 4.1.3

package/src/services/chat.mjs

@@ -18,7 +18,7 @@
 // loop, src/surfaces/tui/app.mjs's Ink shell).
 
 import { join, dirname } from "node:path";
-import { dispatchTool, loadGraph, TOOLS } from "../tools/server.mjs";
+import { dispatchTool, dispatchToolStructured, loadGraph, TOOLS } from "../tools/server.mjs";
 import { ToolError } from "../adapters/config.mjs";
 import { parseEntities, edgesOfKind, moduleCountOf, packageCounts, modulesOf, renderAuthorCard, renderAuthorTouches, renderCommitAuthor, resolveSymbol, renderCompare } from "../domain/codegraph.mjs";
 import { classDisplayName, DYNAMIC_TAIL_OK_RE } from "../domain/ask.mjs";
@@ -38,8 +38,9 @@ import { splitSentences, carriesASentenceBoundary } from "./sentences.mjs";
 import {
   VERB_TO_KIND, WHERE_MARKERS, MENTION_MARKERS, ENTITY_TO_TYPE, PASSIVE_PARTICIPLE_TO_KIND,
   stripTrailingScopeFiller, stripTrailingDiscourseTag, EDGE_NOUN_TO_METRIC, RELATIONS, LIST_TRIGGERS,
+  locativePreposition,
 } from "../domain/ask-vocab.mjs";
-import { COUNTERFACTUAL_RE, correctMisspellings, applyPreambleFrames, expandContractions, normalizeQuery, stripFillerWords, escapeRegex, kindNounAnaphoraHint } from "../domain/interpret/normalize.mjs";
+import { COUNTERFACTUAL_RE, correctMisspellings, applyPreambleFrames, expandContractions, normalizeQuery, stripFillerWords, escapeRegex, kindNounAnaphoraHint, datedTeachSuffix } from "../domain/interpret/normalize.mjs";
 import { setDefaultNlpAdapter } from "../domain/interpret/nlp-registry.mjs";
 import { setConstructionBanks } from "../domain/interpret/strategies/constructions.mjs";
 import { nlpAdapter } from "../adapters/ask-nlp.mjs";
@@ -84,12 +85,6 @@ export { uuidv7 };
 // importing createSession/runChat/SESSION_LOG_DIR/PROMPT from chat.mjs.
 export { createSession, runChat, SESSION_LOG_DIR, PROMPT } from "./chat-session.mjs";
 
-/** dispatchTool("tmct_ask", …) returns the prose answer plus a delimited
- *  machine-readable envelope; the TUI shows the prose only. Reused verbatim
- *  when chat builds the same string from a direct ask() call (the
- *  focus/contextId path), so runTurn parses one envelope shape either way. */
-const ASK_ENVELOPE_DELIM = "\n\n---tmct_ask---\n";
-
 /** The context pronouns a focus can stand in for — a bare `it`/`this`/`that`/`here`
  *  as a command arg reuses the focus, and the ask engine resolves the same words
  *  in a question against the contextId we thread through. */
@@ -593,8 +588,12 @@ const RESTRICTOR_VERB_RE = new RegExp(
  *  node (parseAggregate) already evaluates a restrictor tail correctly via
  *  parseSetPhrase, so once the tail names a real relation verb
  *  (RESTRICTOR_VERB_RE), decline here and let the turn fall through to the
- *  real ask engine instead of returning a misleading bare total. */
-export function answerCount(graph, query) {
+ *  real ask engine instead of returning a misleading bare total.
+ *
+ *  `uiContext` picks the empty-graph remedy: only a terminal session can run
+ *  the index/--repo commands, so a page names what it can actually offer
+ *  instead (see vocabExampleHint's own split). */
+export function answerCount(graph, query, { uiContext = "cli" } = {}) {
   if (!graph) return null;
   // ANAPHORIC counts ("how many of those are tested", "count them", "how many of
   // them") count the PREVIOUS answer's set, not a graph kind — decline so the turn
@@ -620,6 +619,9 @@ export function answerCount(graph, query) {
     // When no code graph is loaded, countableKinds(graph) is genuinely
     // empty — an honest, non-dangling message pointing at how to load one.
     if (!kinds.length) {
+      if (uiContext === "browser") {
+        return `I can't count "${noun}" — this page holds taught facts only, so there's no code structure to count.`;
+      }
       return `I can't count "${noun}" — no code graph is loaded yet, so there's nothing to count ` +
         `(index this repo with "tmct index", point me at another with --repo, or run "npm run example:mini").`;
     }
@@ -890,16 +892,12 @@ const MEMORY_CLASS_PLURALS = {
 const MEMORY_CLASS_LIST_TRIGGER_RE = /^(?:list|show(?:\s+me)?)\s+(?:all\s+|the\s+)?([a-z][a-z-]*)\s*(.*)$/i;
 const MEMORY_CLASS_COUNT_TRIGGER_RE = /^(?:how\s+many|number\s+of|count(?:\s+the)?)\s+(?:all\s+)?([a-z][a-z-]*)\s*(.*)$/i;
 
-/** One display line per stored individual of a class: a Fact reads back through
- *  the same renderFactLine every other fact list uses; the other classes show
- *  their own label. */
-function memoryClassLine(cls, ind, factByLabel) {
-  if (cls === "Fact") {
-    const row = factByLabel.get(ind.id);
-    if (row) return renderFactLine(row);
-  }
-  return String(ind.label || ind.id || "").trim();
-}
+/** One display line per stored individual of a class — its own label. Facts
+ *  never come through here: they are listed per TRIPLE, through the same
+ *  renderFactLine every other fact list uses, because the store holds one
+ *  record per asserting SOURCE and listing those would print a corroborated
+ *  triple once per source that vouched for it. */
+const memoryClassLine = (ind) => String(ind.label || ind.id || "").trim();
 
 /** Recognise "list <memory-class>" (any class) and "how many <meta-class>"
  *  (Session/Source/Rule — Fact/Utterance counts stay with answerMemoryCount) and
@@ -934,11 +932,11 @@ async function answerMemoryClassQuery(memoryDir, query) {
   try { ({ loadMemory, readFactRows } = await import("../adapters/memory/core.mjs")); } catch { return null; }
   let mem;
   try { mem = await loadMemory(memoryDir); } catch { return null; }
-  const inds = (mem.individuals || []).filter((i) => (i.class || "") === cls);
+  const rows = cls === "Fact" ? readFactRows(mem) : null;
+  const inds = rows || (mem.individuals || []).filter((i) => (i.class || "") === cls);
   if (countM) return { text: `${inds.length} ${inds.length === 1 ? plural.replace(/s$/, "") : plural}.`, kind: "count" };
   if (!inds.length) return { text: `I don't have any ${plural} stored yet.`, miss: true };
-  const factByLabel = cls === "Fact" ? new Map(readFactRows(mem).map((r) => [r.id, r])) : new Map();
-  const lines = inds.map((ind) => memoryClassLine(cls, ind, factByLabel));
+  const lines = rows ? rows.map(renderFactLine) : inds.map(memoryClassLine);
   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.` : "";
@@ -1551,13 +1549,21 @@ const T_WHY_EMPTY = "miss-no-previous-answer";
 /** Empty / degenerate-graph variants (#3/#5): shown when the loaded graph has 0
  *  modules (a graph-less bootstrap OR a graph.json with no code entities). They
  *  orient toward `--repo`/`tmct init` + the seeded vocabulary instead of
- *  over-promising "ask me about this codebase". */
+ *  over-promising "ask me about this codebase". The `_BROWSER` twins carry the
+ *  same content with the CLI-only remedy (`--repo`, `tmct index`,
+ *  `npm run example:mini`) swapped for what a page visitor can actually do —
+ *  selected via uiTemplateId()'s uiContext branch, the same split
+ *  offRampClause/vocabExampleHint already apply to the surrounding prose. */
 const T_GREETING_EMPTY = "conversational-greeting-empty";
+const T_GREETING_EMPTY_BROWSER = "conversational-greeting-empty-browser";
 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_ORIENTATION_EMPTY_BROWSER = "orientation-empty-browser";
+/** IDENTITY answers — self-description and the "no LLM" clarification. Neither
+ *  varies with graph state (empty vs. populated); identity-self DOES vary with
+ *  uiContext (its `--repo <path>` clause is CLI-only), so it alone carries a
+ *  `_BROWSER` twin. */
 const T_IDENTITY_SELF = "identity-self";
+const T_IDENTITY_SELF_BROWSER = "identity-self-browser";
 const T_IDENTITY_NOT_LLM = "identity-not-an-llm";
 const T_IDENTITY_NO_FEELINGS = "identity-no-feelings";
 /** Confirms the honest-miss promise itself when a user asks about it directly
@@ -1932,6 +1938,21 @@ export function renderVerbose(last) {
   return { text: lines.join("\n"), empty: false };
 }
 
+/** Picks a template id's browser twin when `uiContext` is "browser", else the
+ *  CLI id unchanged — the same surface split offRampClause/vocabExampleHint
+ *  apply to hand-written prose, applied here to which DATA row gets rendered. */
+const uiTemplateId = (uiContext, id, browserId) => (uiContext === "browser" ? browserId : id);
+
+/** The "here's what you CAN ask" tail on a decline that names no term of its own
+ *  (the SQL-statement and arithmetic shapes below). `ctx.vocabHint` already
+ *  carries the session-gated vocabulary/teach pointer, so only the CODE-graph
+ *  half needs the surface split: pointing at a repo is a command a terminal can
+ *  run and a page cannot. */
+const offRampClause = (ctx) => {
+  const hint = ctx.vocabHint || 'Try "what is a dog" for vocabulary.';
+  return ctx.uiContext === "browser" ? hint : `${hint} Or point me at a repo with --repo <path>.`;
+};
+
 /** Recognise a conversational expression and return a templated turn result, or null
  *  to fall through to counts/ask. Handled BEFORE slash-commands' non-slash siblings:
  *  greetings, thanks, help/orientation, farewell (ends the session via `end:true`),
@@ -2011,7 +2032,9 @@ function conversationalTurn(line, ctx) {
       // 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);
+      const id = (!T_GREETING_BY_PHRASE[greetHit] && noCodeGraph(ctx.graph))
+        ? uiTemplateId(ctx.uiContext, T_GREETING_EMPTY, T_GREETING_EMPTY_BROWSER)
+        : (T_GREETING_BY_PHRASE[greetHit] || T_GREETING);
       note(ctx.trace, `pattern: template "${id}" (data/templates/responses.jsonl)`);
       return mk(t(id, { vocabHint: ctx.vocabHint }), { lane: "greeting" });
     }
@@ -2055,8 +2078,7 @@ function conversationalTurn(line, ctx) {
     note(ctx.trace, "goal: nonsense input shaped like a SQL statement — a targeted decline, not the identity blurb");
     note(ctx.trace, "lane: conversational — SQL-statement decline (SQL_STATEMENT_RE)");
     return mk(
-      "That reads like a SQL statement, not a question about a code graph or taught facts. "
-      + "Try \"what is a dog\" for vocabulary, or point me at a repo with --repo <path>.",
+      `That reads like a SQL statement, not a question about a code graph or taught facts. ${offRampClause(ctx)}`,
       { lane: "help" },
     );
   }
@@ -2064,15 +2086,14 @@ function conversationalTurn(line, ctx) {
     note(ctx.trace, "goal: arithmetic — not a code/vocabulary question, an honest decline");
     note(ctx.trace, "lane: conversational — arithmetic decline (ARITHMETIC_RE)");
     return mk(
-      "I don't do arithmetic — I answer questions about a code graph or taught facts. "
-      + "Try \"what is a dog\" for vocabulary, or point me at a repo with --repo <path>.",
+      `I don't do arithmetic — I answer questions about a code graph or taught facts. ${offRampClause(ctx)}`,
       { lane: "help" },
     );
   }
   if (identityPhraseMatch(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), { lane: "help" });
+    return mk(t(uiTemplateId(ctx.uiContext, T_IDENTITY_SELF, T_IDENTITY_SELF_BROWSER), { vocabHint: ctx.vocabHint }), { lane: "help" });
   }
   {
     const metaHit = META_COMMAND_ANSWERS.find(([re]) => re.test(raw));
@@ -2092,7 +2113,7 @@ function conversationalTurn(line, ctx) {
     || CAPABILITY_PHRASES.some((re) => re.test(applyPreambleFrames(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 (CAPABILITY_PHRASES/ORIENT_OPENERS / bare help / ?)");
-    return mk(orientationAnswer(ctx.templates, ctx.graph, ctx.vocabHint), { lane: "help" });
+    return mk(orientationAnswer(ctx.templates, ctx.graph, ctx.vocabHint, ctx.uiContext), { lane: "help" });
   }
   // Fuzzy-typo fallback (A4): every exact/collapsed closed-set lookup above missed —
   // try a bounded edit-distance match against the flattened conversational phrase
@@ -2108,9 +2129,13 @@ function conversationalTurn(line, ctx) {
       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), { lane: "thanks" });
-      if (bucket === "identity") return mk(t(T_IDENTITY_SELF), { lane: "help" });
-      if (bucket === "capability") return mk(orientationAnswer(ctx.templates, ctx.graph, ctx.vocabHint), { lane: "help" });
-      const id = (!T_GREETING_BY_PHRASE[fuzzyHit] && noCodeGraph(ctx.graph)) ? T_GREETING_EMPTY : (T_GREETING_BY_PHRASE[fuzzyHit] || T_GREETING);
+      if (bucket === "identity") {
+        return mk(t(uiTemplateId(ctx.uiContext, T_IDENTITY_SELF, T_IDENTITY_SELF_BROWSER), { vocabHint: ctx.vocabHint }), { lane: "help" });
+      }
+      if (bucket === "capability") return mk(orientationAnswer(ctx.templates, ctx.graph, ctx.vocabHint, ctx.uiContext), { lane: "help" });
+      const id = (!T_GREETING_BY_PHRASE[fuzzyHit] && noCodeGraph(ctx.graph))
+        ? uiTemplateId(ctx.uiContext, T_GREETING_EMPTY, T_GREETING_EMPTY_BROWSER)
+        : (T_GREETING_BY_PHRASE[fuzzyHit] || T_GREETING);
       return mk(t(id, { vocabHint: ctx.vocabHint }), { lane: "greeting" });
     }
   }
@@ -2165,10 +2190,14 @@ function orientationExamples(graph) {
 }
 
 /** 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;
+ *  vocabulary hint + --repo/tmct init, or its browser twin) 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, uiContext = "cli") {
+  if (noCodeGraph(graph)) {
+    const id = uiTemplateId(uiContext, T_ORIENTATION_EMPTY, T_ORIENTATION_EMPTY_BROWSER);
+    return tRender(templates, id, { vocabHint }) ?? TEMPLATES_UNAVAILABLE;
+  }
   return tRender(templates, T_ORIENTATION, orientationExamples(graph)) ?? TEMPLATES_UNAVAILABLE;
 }
 
@@ -2179,20 +2208,24 @@ function orientationAnswer(templates, graph, vocabHint) {
 const ORIENTATION_EMPTY_FALLBACK = "I'm tmct — a deterministic, offline chat assistant (no LLM). "
   + "For code structure (imports, calls, definitions) run `tmct index` here, point me at a repo with `--repo <path>`, "
   + "or try the shipped example `npm run example:mini`. /help for commands.";
+const ORIENTATION_EMPTY_FALLBACK_BROWSER = "I'm tmct — a deterministic, offline chat assistant (no LLM). "
+  + "Teach me a fact directly, e.g. \"every bug is an issue\", or ask about what's already loaded. /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 — 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) {
+ *  through the SAME template (T_ORIENTATION_EMPTY/T_ORIENTATION_EMPTY_BROWSER)
+ *  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, uiContext = "cli") {
   // A null (never-loaded) graph reads as "unknown, not empty" to noCodeGraph,
   // which is the right call for the greeting/orientation CARD — but there is no
   // entity count to render from one either, so the empty wording is the only
   // truthful thing left to say. Without this the entity tally below threw on a
   // graph-less runTurn.
   if (!graph || noCodeGraph(graph)) {
-    return tRender(templates, T_ORIENTATION_EMPTY, { vocabHint }) ?? ORIENTATION_EMPTY_FALLBACK;
+    const id = uiTemplateId(uiContext, T_ORIENTATION_EMPTY, T_ORIENTATION_EMPTY_BROWSER);
+    const fallback = uiContext === "browser" ? ORIENTATION_EMPTY_FALLBACK_BROWSER : ORIENTATION_EMPTY_FALLBACK;
+    return tRender(templates, id, { vocabHint }) ?? fallback;
   }
   const by = (cls) => (graph.individuals || []).filter((i) => (i.class || "") === cls).length;
   const parts = [];
@@ -2635,13 +2668,33 @@ const INSTANCE_TYPE_TEACH_RE = /^([a-z][\w]*(?:-[\w]+)+)\s+is\s+an?\s+([a-z][\w-
 // Bare article-led kind-of taxonomy: "a disk is a kind of game piece".
 const BARE_KINDOF_TEACH_RE = /^an?\s+([a-z][\w-]+)\s+is\s+a\s+kind\s+of\s+(?:an?\s+)?([a-z][\w-]+(?:\s+[a-z][\w-]+)?)([.!?]*)$/i;
 
+/** Wink lemmatises a token with no sentence around it, so a surface that is
+ *  both a plural noun and a 3rd-person-singular verb comes back as the NOUN
+ *  singular: "lives" → "life", "halves" → "half", "shelves" → "shelf". Every
+ *  caller here has already bound the word to a VERB slot, so the noun reading
+ *  is the wrong one, and left alone it mints an mgx:life-in predicate that
+ *  reads back as "ann lifes in paris".
+ *
+ *  Spelling identifies the noun reading on its own: an "-f"/"-fe" noun forms
+ *  its plural in "-ves", and no verb base ends in a bare "-v", so a "-ves"
+ *  surface whose lemma ends in "-f"/"-fe" was read as that plural. The verb
+ *  base is then the surface minus its "s" ("lives" → "live", "shelves" →
+ *  "shelve"). Deliberately this one spelling pair and no more (same accepted
+ *  trade as singularizeSurface, no real morphology) — a "-ves" verb wink
+ *  already reads correctly ("leaves" → "leave", "moves" → "move") keeps its
+ *  lemma untouched. */
+function verbReadingOfLemma(surface, lemma) {
+  if (!/ves$/i.test(surface) || !/fe?$/i.test(lemma)) return lemma;
+  return surface.slice(0, -1);
+}
+
 /** Verb → lemma via the prose adapter, degrading to the word itself. */
 async function verbLemma(word) {
   const w = String(word || "").toLowerCase();
   try {
     const { proseLemma } = await import("../adapters/prose-nlp.mjs");
     const lemma = proseLemma();
-    return lemma ? lemma(w) : w;
+    return lemma ? verbReadingOfLemma(w, lemma(w)) : w;
   } catch { return w; }
 }
 
@@ -2829,7 +2882,7 @@ const teachProvenanceTag = (sessionId, ts) => `teach:chat${sessionId ? `:${sessi
 /** Reify one teach-lane fact + confirm (shared by the property and ownership
  *  frames). Lazy + failure-tolerated: a write failure degrades to null (the
  *  teach-miss text stands), never a crash. */
-async function teachFact(memoryDir, sessionId, { subject, predicate, object, quantifier = "" }) {
+async function teachFact(memoryDir, sessionId, { subject, predicate, object, quantifier = "", observedAt = "", dateText = "" }) {
   try {
     const { appendFact, normFactTerm } = await import("../adapters/memory/core.mjs");
     const s = normFactTerm(subject);
@@ -2839,9 +2892,13 @@ async function teachFact(memoryDir, sessionId, { subject, predicate, object, qua
       subject: s, predicate, object: o,
       provenance: teachProvenanceTag(sessionId, new Date().toISOString()),
       ...(quantifier ? { quantifier } : {}),
+      ...(observedAt ? { observedAt } : {}),
     });
     const phrase = predicatePhrase(predicate);
-    return { text: `noted — remembered: ${s} ${phrase} ${o}`, via: "assert", miss: false };
+    // The dated-teach frame's own echo: the user typed the date, so the
+    // acknowledgment shows it was registered rather than silently dropped.
+    const dateSuffix = observedAt && dateText ? ` (as of ${dateText})` : "";
+    return { text: `noted — remembered: ${s} ${phrase} ${o}${dateSuffix}`, via: "assert", miss: false };
   } catch {
     return null;
   }
@@ -3094,7 +3151,7 @@ async function ungroundedPairHint(payload, lexicon, memoryDir, cache = null, gra
  *  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 }, cache = null) {
+async function unknownSubjectFallback(payload, { memoryDir, sessionId, lexicon, observedAt, dateText }, cache = null) {
   if (!memoryDir) return null;
   const m = String(payload).trim().match(UNKNOWN_SUBJECT_RE);
   if (!m) return null;
@@ -3137,14 +3194,14 @@ async function unknownSubjectFallback(payload, { memoryDir, sessionId, lexicon }
   if (lookupNoun(lex, objectRaw) || GENERIC_ANCHOR_NOUNS.has(String(objectRaw).toLowerCase())
     || (await isGroundedByFact(objectRaw, memoryDir, cache))) {
     return teachFact(memoryDir, sessionId, {
-      subject, predicate: SUBCLASS_PREDICATE, object: objectRaw, quantifier,
+      subject, predicate: SUBCLASS_PREDICATE, object: objectRaw, quantifier, observedAt, dateText,
     });
   }
   if (lookupAdjective(lex, objectRaw)) {
     // property assertions are about ONE specific entity — never a quantifier,
     // even when phrased with "every" (point 3).
     return teachFact(memoryDir, sessionId, {
-      subject, predicate: HAS_PROPERTY_PREDICATE, object: objectRaw,
+      subject, predicate: HAS_PROPERTY_PREDICATE, object: objectRaw, observedAt, dateText,
     });
   }
   return null; // Y unknown too — decline honestly, never guess
@@ -3221,7 +3278,7 @@ async function objectReadsAsNonNoun(word) {
     return false;
   }
 }
-async function unknownObjectFallback(payload, { memoryDir, sessionId, lexicon, classIntent = false, graph = null }, cache = null) {
+async function unknownObjectFallback(payload, { memoryDir, sessionId, lexicon, classIntent = false, graph = null, observedAt, dateText }, cache = null) {
   if (!memoryDir) return null;
   const m = String(payload).trim().match(UNKNOWN_SUBJECT_RE);
   if (!m) return null;
@@ -3266,7 +3323,7 @@ async function unknownObjectFallback(payload, { memoryDir, sessionId, lexicon, c
     ? (lookupNoun(lex, subjectRaw)?.lemma || singularizeSurface(subjectRaw))
     : subjectRaw;
   return teachFact(memoryDir, sessionId, {
-    subject, predicate: SUBCLASS_PREDICATE, object: objectRaw, quantifier,
+    subject, predicate: SUBCLASS_PREDICATE, object: objectRaw, quantifier, observedAt, dateText,
   });
 }
 
@@ -3319,7 +3376,7 @@ async function unknownObjectFallback(payload, { memoryDir, sessionId, lexicon, c
  *  otherwise provide. "the cache is bespoke" and "Mary is female" both carry
  *  one of those signals (the leading "the", and capitalization,
  *  respectively); "module is banana" carries none. */
-async function unknownAdjectiveFallback(payload, { memoryDir, sessionId, lexicon, graph = null }, cache = null) {
+async function unknownAdjectiveFallback(payload, { memoryDir, sessionId, lexicon, graph = null, observedAt, dateText }, cache = null) {
   if (!memoryDir) return null;
   const m = String(payload).trim().match(UNKNOWN_SUBJECT_RE);
   if (!m) return null;
@@ -3358,7 +3415,7 @@ async function unknownAdjectiveFallback(payload, { memoryDir, sessionId, lexicon
       ? (lookupNoun(lex, subjectRaw)?.lemma || singularizeSurface(subjectRaw))
       : subjectRaw;
     return teachFact(memoryDir, sessionId, {
-      subject: classSubject, predicate: HAS_PROPERTY_PREDICATE, object: objectRaw, quantifier: "every",
+      subject: classSubject, predicate: HAS_PROPERTY_PREDICATE, object: objectRaw, quantifier: "every", observedAt, dateText,
     });
   }
   // Subject-side groundedness — strip a leading "the"/"a"/"an" first
@@ -3379,7 +3436,7 @@ async function unknownAdjectiveFallback(payload, { memoryDir, sessionId, lexicon
   const subjectGrounded = capitalized || factGrounded || genericAnchor || lexiconGrounded;
   if (!subjectGrounded) return null; // no deliberate-entity signal — never a guessed mint
   return teachFact(memoryDir, sessionId, {
-    subject: subjectRaw, predicate: HAS_PROPERTY_PREDICATE, object: objectRaw,
+    subject: subjectRaw, predicate: HAS_PROPERTY_PREDICATE, object: objectRaw, observedAt, dateText,
   });
 }
 
@@ -3725,9 +3782,7 @@ async function generalVerbPredicate(verb) {
   // "can a X <verb>" reader finds it (same reasoning as HAS_A above).
   if (v === "can") return "mgx:capableOf";
   try {
-    const { proseLemma } = await import("../adapters/prose-nlp.mjs");
-    const lemma = proseLemma();
-    const l = lemma ? lemma(v) : v;
+    const l = await verbLemma(v);
     if (l === "have") return HAS_A_PREDICATE;
     return normFactPredicate(`mgx:${l}`);
   } catch {
@@ -4304,7 +4359,7 @@ const NEGATIVE_UNIVERSAL_TEACH_RE = /^no\s+([\w-]+)\s+(is|are)\s+(?:an?\s+)?(?:(
 /** The mint (or the reflexive refusal) for a NEGATIVE_UNIVERSAL_TEACH_RE
  *  match, shared by teachLane and the ACE-path reflexive gate: null when the
  *  sentence isn't this shape. */
-async function negativeUniversalTeach(sentence, { memoryDir, sessionId }) {
+async function negativeUniversalTeach(sentence, { memoryDir, sessionId, observedAt, dateText }) {
   const m = String(sentence || "").trim().match(NEGATIVE_UNIVERSAL_TEACH_RE);
   if (!m || !memoryDir) return null;
   const plural = m[2].toLowerCase() === "are";
@@ -4318,7 +4373,7 @@ async function negativeUniversalTeach(sentence, { memoryDir, sessionId }) {
   }
   const { DISJOINT_PREDICATE } = await import("../domain/syllogise.mjs");
   const stored = await teachFact(memoryDir, sessionId, {
-    subject, predicate: DISJOINT_PREDICATE, object,
+    subject, predicate: DISJOINT_PREDICATE, object, observedAt, dateText,
   });
   if (!stored) {
     return {
@@ -4345,13 +4400,13 @@ const NEGATIVE_UNIVERSAL_CAN_TEACH_RE = /^no\s+([\w-]+)\s+can\s+([a-z][\w-]*)[.!
 /** The mint for a NEGATIVE_UNIVERSAL_CAN_TEACH_RE match, mirroring
  *  negativeUniversalTeach's own shape: null when the sentence isn't this
  *  shape. */
-async function negativeUniversalCanTeach(sentence, { memoryDir, sessionId }) {
+async function negativeUniversalCanTeach(sentence, { memoryDir, sessionId, observedAt, dateText }) {
   const m = String(sentence || "").trim().match(NEGATIVE_UNIVERSAL_CAN_TEACH_RE);
   if (!m || !memoryDir) return null;
   const subject = singularizeSurface(m[1]);
   const verb = m[2].toLowerCase();
   const stored = await teachFact(memoryDir, sessionId, {
-    subject, predicate: NEG_CAPABLE_OF_PREDICATE, object: verb,
+    subject, predicate: NEG_CAPABLE_OF_PREDICATE, object: verb, observedAt, dateText,
   });
   if (!stored) {
     return {
@@ -4414,7 +4469,26 @@ async function teachExclusionReason(sentence) {
 }
 export { teachExclusionReason };
 
-async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cache = null, planHolder = null, graph = null, gameConfig = DEFAULT_GAME_CONFIG }) {
+async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cache = null, planHolder = null, graph = null, gameConfig = DEFAULT_GAME_CONFIG, observedAt = "", dateText = "" }) {
+  // THE DATED TEACH FRAME — "<sentence> as of <date>" carries an explicit
+  // mgx:observedAt past the same shapes this lane already teaches. Tried
+  // ONCE, recursively, on the suffix-stripped text, the same
+  // "rewrap and recurse into this same lane" idiom the conjunction pre-pass
+  // below already uses. A miss on the stripped text falls through to the
+  // untouched ORIGINAL query below — a question that happens to end in
+  // "as of 2019" must keep asking, never get silently rewritten (see
+  // datedTeachSuffix's own docblock) — and a dated teach that fails to parse
+  // must never fall back to storing the same sentence undated.
+  if (!observedAt && memoryDir) {
+    const suffix = datedTeachSuffix(String(query));
+    if (suffix) {
+      const dated = await teachLane(suffix.stripped, {
+        memoryDir, sessionId, lexicon, cache, planHolder, graph, gameConfig,
+        observedAt: suffix.observedAt, dateText: suffix.dateText,
+      });
+      if (dated && !dated.miss) return dated;
+    }
+  }
   // A closed discourse-marker preamble ahead of a teach sentence ("howdy
   // pardner, remember that TaskController is fragile") would otherwise
   // corrupt TEACH_RE's own match, so strip it first. applyPreambleFrames is
@@ -4530,7 +4604,7 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
   if (memoryDir && !QUESTION_LEAD_RE.test(conjSrc) && /\s+and\s+/i.test(conjSrc)
     && !(await hasMidSentenceInterrogative(conjSrc))) {
     const rewrap = (half) => (wrapped != null ? `remember that ${half}` : half);
-    const recurse = (half) => teachLane(rewrap(half), { memoryDir, sessionId, lexicon, cache, planHolder, graph, gameConfig });
+    const recurse = (half) => teachLane(rewrap(half), { memoryDir, sessionId, lexicon, cache, planHolder, graph, gameConfig, observedAt, dateText });
     const stripNoted = (t) => String(t).replace(/^noted — remembered(?:\s+\d+\s+facts?)?:\s*/i, "").trim();
     const shared = conjSrc.match(/^(.+?)\s+and\s+((?:is|are|has|have|can)\b.+)$/i);
     const sharedSubject = shared ? shared[1].match(/^(.+?)\s+(?:is|are|has|have|can)\b/i)?.[1]?.trim() : null;
@@ -4688,7 +4762,7 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
       const positive = priorRows.find((r) => r.subject === negSubject && r.predicate === SUBCLASS_PREDICATE && r.object === negObject);
       if (positive) {
         const stored = await teachFact(memoryDir, sessionId, {
-          subject: retractSubject, predicate: NEG_SUBCLASS_PREDICATE, object: retractObject,
+          subject: retractSubject, predicate: NEG_SUBCLASS_PREDICATE, object: retractObject, observedAt, dateText,
         });
         if (stored) {
           return {
@@ -4822,8 +4896,8 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
     const negUniversalSrc = (wrapped ?? raw).replace(/[.!?]+\s*$/, "");
     if (memoryDir && !QUESTION_LEAD_RE.test(negUniversalSrc)
       && !(await hasMidSentenceInterrogative(negUniversalSrc))) {
-      const negUniversal = await negativeUniversalTeach(negUniversalSrc, { memoryDir, sessionId })
-        || await negativeUniversalCanTeach(negUniversalSrc, { memoryDir, sessionId });
+      const negUniversal = await negativeUniversalTeach(negUniversalSrc, { memoryDir, sessionId, observedAt, dateText })
+        || await negativeUniversalCanTeach(negUniversalSrc, { memoryDir, sessionId, observedAt, dateText });
       if (negUniversal) return negUniversal;
     }
   }
@@ -4847,7 +4921,7 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
   if (own && memoryDir && !QUESTION_LEAD_RE.test(ownSrc) && !ownSrcMidQuestion
     && (wrapped || /^[A-Z]/.test(own[1]) || /^[A-Z]/.test(own[2]))) {
     const stored = await teachFact(memoryDir, sessionId, {
-      subject: own[2], predicate: OWNED_BY_PREDICATE, object: own[1],
+      subject: own[2], predicate: OWNED_BY_PREDICATE, object: own[1], observedAt, dateText,
     });
     if (stored) return stored;
   }
@@ -4865,7 +4939,7 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
     && (wrapped || /^[A-Z]/.test(ownPassive[2]) || /^[A-Z]/.test(ownPassiveSubject)
       || MODULE_PATH_RE.test(ownPassiveSubject))) {
     const stored = await teachFact(memoryDir, sessionId, {
-      subject: ownPassive[1], predicate: OWNED_BY_PREDICATE, object: ownPassive[2],
+      subject: ownPassive[1], predicate: OWNED_BY_PREDICATE, object: ownPassive[2], observedAt, dateText,
     });
     if (stored) return stored;
   }
@@ -4878,7 +4952,7 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
   const relatedTo = ownSrc.match(RELATED_TO_TEACH_RE);
   if (relatedTo && memoryDir && !QUESTION_LEAD_RE.test(ownSrc) && !ownSrcMidQuestion) {
     const stored = await teachFact(memoryDir, sessionId, {
-      subject: relatedTo[1], predicate: "mgx:relatedTo", object: relatedTo[2],
+      subject: relatedTo[1], predicate: "mgx:relatedTo", object: relatedTo[2], observedAt, dateText,
     });
     if (stored) return stored;
   }
@@ -4894,7 +4968,7 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
   const rel = ownSrc.match(RELATION_FACT_TEACH_RE);
   if (rel && memoryDir && !QUESTION_LEAD_RE.test(ownSrc) && !ownSrcMidQuestion) {
     const stored = await teachFact(memoryDir, sessionId, {
-      subject: rel[1], predicate: await generalVerbPredicate(rel[2]), object: rel[3],
+      subject: rel[1], predicate: await generalVerbPredicate(rel[2]), object: rel[3], observedAt, dateText,
     });
     if (stored) return stored;
   }
@@ -4906,14 +4980,14 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
   const genitive = ownSrc.match(GENITIVE_RELATION_TEACH_RE);
   if (genitive && memoryDir && !QUESTION_LEAD_RE.test(ownSrc) && !ownSrcMidQuestion) {
     const stored = await teachFact(memoryDir, sessionId, {
-      subject: genitive[1], predicate: await generalVerbPredicate(genitive[3]), object: genitive[2],
+      subject: genitive[1], predicate: await generalVerbPredicate(genitive[3]), object: genitive[2], observedAt, dateText,
     });
     if (stored) return stored;
   }
   const genitiveRev = ownSrc.match(GENITIVE_RELATION_TEACH_REV_RE);
   if (genitiveRev && memoryDir && !QUESTION_LEAD_RE.test(ownSrc) && !ownSrcMidQuestion) {
     const stored = await teachFact(memoryDir, sessionId, {
-      subject: genitiveRev[3], predicate: await generalVerbPredicate(genitiveRev[2]), object: genitiveRev[1],
+      subject: genitiveRev[3], predicate: await generalVerbPredicate(genitiveRev[2]), object: genitiveRev[1], observedAt, dateText,
     });
     if (stored) return stored;
   }
@@ -4928,7 +5002,7 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
     ? await matchRelationalVerbTeach(ownSrc) : null;
   if (relVerb) {
     const stored = await teachFact(memoryDir, sessionId, {
-      subject: relVerb.subject, predicate: await generalVerbPredicate(relVerb.base), object: relVerb.object,
+      subject: relVerb.subject, predicate: await generalVerbPredicate(relVerb.base), object: relVerb.object, observedAt, dateText,
     });
     if (stored) return stored;
   }
@@ -4948,7 +5022,7 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
   const hasMethod = ownSrc.match(TEACH_HAS_METHOD_RE);
   if (hasMethod && memoryDir && !QUESTION_LEAD_RE.test(ownSrc) && !ownSrcMidQuestion) {
     const stored = await teachFact(memoryDir, sessionId, {
-      subject: hasMethod[1], predicate: HAS_A_PREDICATE, object: `${hasMethod[2]} method`,
+      subject: hasMethod[1], predicate: HAS_A_PREDICATE, object: `${hasMethod[2]} method`, observedAt, dateText,
     });
     if (stored) return stored;
   }
@@ -5251,7 +5325,7 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
   const rendersAs = ownSrc.match(RENDERS_AS_TEACH_RE);
   if (rendersAs && memoryDir && !QUESTION_LEAD_RE.test(ownSrc) && !ownSrcMidQuestion) {
     const stored = await teachFact(memoryDir, sessionId, {
-      subject: rendersAs[1], predicate: "mgx:rendersAs", object: rendersAs[2],
+      subject: rendersAs[1], predicate: "mgx:rendersAs", object: rendersAs[2], observedAt, dateText,
     });
     if (stored) return stored;
   }
@@ -5269,7 +5343,7 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
   if (wrapped && memoryDir && !QUESTION_LEAD_RE.test(wrapped) && !(await hasMidSentenceInterrogative(wrapped))) {
     const gv = await generalVerbTeach(wrapped);
     if (gv) {
-      const stored = await teachFact(memoryDir, sessionId, gv);
+      const stored = await teachFact(memoryDir, sessionId, { ...gv, observedAt, dateText });
       if (stored) return stored;
     }
   } else if (!wrapped && memoryDir && !QUESTION_LEAD_RE.test(correctMisspellings(raw))
@@ -5323,14 +5397,14 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
         if (!canLex) { const { loadLexicon } = await import("../domain/grammar/lexicon.mjs"); canLex = loadLexicon(); }
         if (await isGroundedTerm(canSingular, canLex, memoryDir, cache, graph)) {
           const stored = await teachFact(memoryDir, sessionId, {
-            subject: canSingular, predicate: await capabilityPredicate(canShape.negated), object: canShape.verb,
+            subject: canSingular, predicate: await capabilityPredicate(canShape.negated), object: canShape.verb, observedAt, dateText,
           });
           if (stored) return stored;
         }
       }
       const gv = await generalVerbTeach(raw);
       if (gv) {
-        const stored = await teachFact(memoryDir, sessionId, gv);
+        const stored = await teachFact(memoryDir, sessionId, { ...gv, observedAt, dateText });
         if (stored) return stored;
       }
     }
@@ -5369,7 +5443,7 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
       const compPredicate = `mgx:${comp[2].toLowerCase().replace(/\s+/g, "-")}-than`;
       const stored = await teachFact(memoryDir, sessionId, {
         subject: comp[1].trim(), predicate: compPredicate,
-        object: comp[3].trim().replace(/[.!?]+$/, ""),
+        object: comp[3].trim().replace(/[.!?]+$/, ""), observedAt, dateText,
       });
       if (stored) return stored;
     }
@@ -5388,7 +5462,7 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
         const pred = `mgx:${pp[2].toLowerCase()}-${pp[3].toLowerCase()}`;
         const stored = await teachFact(memoryDir, sessionId, {
           subject: pp[1].trim(), predicate: negated ? negatedPredicate(pred) : pred,
-          object: participleObject(pp[4]),
+          object: participleObject(pp[4]), observedAt, dateText,
         });
         if (stored) return stored;
       }
@@ -5403,11 +5477,11 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
         const subject = np[1].trim();
         const relPred = `mgx:${np[4].toLowerCase()}-${np[5].toLowerCase()}`;
         const isaStored = await teachFact(memoryDir, sessionId, {
-          subject, predicate: SUBCLASS_PREDICATE, object: singularizeSurface(np[3]),
+          subject, predicate: SUBCLASS_PREDICATE, object: singularizeSurface(np[3]), observedAt, dateText,
         });
         const relStored = await teachFact(memoryDir, sessionId, {
           subject, predicate: negated ? negatedPredicate(relPred) : relPred,
-          object: participleObject(np[6]),
+          object: participleObject(np[6]), observedAt, dateText,
         });
         const stripNoted = (t) => String(t).replace(/^noted — remembered(?:\s+\d+\s+facts?)?:\s*/i, "").trim();
         if (isaStored && relStored) return { text: `noted — remembered both: ${stripNoted(isaStored.text)}; and ${stripNoted(relStored.text)}`, via: "assert", miss: false };
@@ -5420,7 +5494,7 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
         const pred = `mgx:same-${same[3].toLowerCase()}-as`;
         const stored = await teachFact(memoryDir, sessionId, {
           subject: same[1].trim(), predicate: negated ? negatedPredicate(pred) : pred,
-          object: same[2].trim(),
+          object: same[2].trim(), observedAt, dateText,
         });
         if (stored) return stored;
       }
@@ -5429,7 +5503,7 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
       // 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, cache });
+      const stored = await assertTurn(cand, { memoryDir, sessionId, focus: null, lexicon, cache, observedAt, dateText });
       if (stored) return { text: stored.answer, via: "assert", miss: false };
     }
     // CAPABILITY over a GROUNDED subject — "penguins swim" (habitual) or "a
@@ -5451,7 +5525,7 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
       for (const subj of new Set([singularizeSurface(habitualTeach.subject), habitualTeach.subject])) {
         if (await isGroundedTerm(subj, habLex, memoryDir, cache, graph)) {
           const stored = await teachFact(memoryDir, sessionId, {
-            subject: subj, predicate: await capabilityPredicate(habitualTeach.negated), object: habitualTeach.verb,
+            subject: subj, predicate: await capabilityPredicate(habitualTeach.negated), object: habitualTeach.verb, observedAt, dateText,
           });
           if (stored) return stored;
         }
@@ -5463,14 +5537,14 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
     // 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 }, cache);
+    const fallback = await unknownSubjectFallback(payload, { memoryDir, sessionId, lexicon, observedAt, dateText }, cache);
     if (fallback) return fallback;
     // MIRROR mint fallback: the known-subject/unknown-object asymmetry —
     // tried right after the unknown-subject case declines, so a subject the
     // STATIC lexicon (or a prior taught fact) already grounds can mint a
     // brand-new object term. See unknownObjectFallback's own docblock for the
     // exact narrowing rules (the "both sides ungrounded" safety guard, etc.).
-    const objectFallback = await unknownObjectFallback(payload, { memoryDir, sessionId, lexicon, classIntent: kindOfClassIntent, graph }, cache);
+    const objectFallback = await unknownObjectFallback(payload, { memoryDir, sessionId, lexicon, classIntent: kindOfClassIntent, graph, observedAt, dateText }, cache);
     if (objectFallback) return objectFallback;
     // ADJECTIVE-MINT fallback: tried right after unknownObjectFallback
     // declines, so a grounded subject (static
@@ -5479,7 +5553,7 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
     // docblock for the exact narrowing rules (the "both sides ungrounded"
     // safety guard, and why this must be a standalone function rather than
     // nested inside unknownSubjectFallback).
-    const adjectiveFallback = await unknownAdjectiveFallback(payload, { memoryDir, sessionId, lexicon, graph }, cache);
+    const adjectiveFallback = await unknownAdjectiveFallback(payload, { memoryDir, sessionId, lexicon, graph, observedAt, dateText }, 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
@@ -5489,7 +5563,7 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
       const prop = wrapped.match(TEACH_PROPERTY_RE);
       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],
+          subject: prop[1], predicate: HAS_PROPERTY_PREDICATE, object: prop[2], observedAt, dateText,
         });
         if (stored) return stored;
       }
@@ -5591,12 +5665,15 @@ const NO_FOCUS_WHATS_IN_HERE_RE = /^what(?:'s|s|\s+is)\s+in\s+here\??$/i;
  *  ACE lexicon: an abstract "every X is a Y" invites a curious user to
  *  substitute intuitive-but-unknown words — "every cache is a thing" — which
  *  the closed lexicon then rejects; "every bug is an issue" parses and stores. */
-async function memorySummary(memoryDir, graph) {
+async function memorySummary(memoryDir, graph, uiContext = "cli") {
   const rows = memoryDir ? await memoryFacts(memoryDir) : [];
   if (!rows.length) {
+    const seedClause = uiContext === "browser"
+      ? 'teach me directly, e.g. "every bug is an issue"'
+      : 'run `tmct init` to seed a starter vocabulary, or teach me directly, e.g. "every bug is an issue"';
     const hook = moduleCountOf(graph) > 0
       ? 'ask about this codebase\'s structure (imports, calls, definitions), or teach me with "every X is a Y"'
-      : 'run `tmct init` to seed a starter vocabulary, or teach me directly, e.g. "every bug is an issue"';
+      : seedClause;
     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));
@@ -5779,7 +5856,7 @@ async function moduleOrientLane(query, { graph }) {
   return null;
 }
 
-async function metaLane(query, { graph, memoryDir, last = null, templates = null, vocabHint = null, focus = null }) {
+async function metaLane(query, { graph, memoryDir, last = null, templates = null, vocabHint = null, focus = null, uiContext = "cli" }) {
   // Preamble-peeled twin of `q`: a self-intro/greeting lead ("I'm new here,
   // what should I read first") wraps exactly the orientation questions this
   // lane owns, and the anchored META_ORIENT_RE can't see past it. Peeling
@@ -5787,10 +5864,10 @@ async function metaLane(query, { graph, memoryDir, last = null, templates = null
   const peeled = applyPreambleFrames(String(query).trim()).toLowerCase().replace(/[?.!]+$/, "").replace(/\s+/g, " ").trim();
   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" };
+    return { text: await memorySummary(memoryDir, graph, uiContext), via: "meta" };
   }
   if (peeled !== q && META_ORIENT_RE.test(peeled)) {
-    const text = orientationText(graph, templates, vocabHint);
+    const text = orientationText(graph, templates, vocabHint, uiContext);
     return { text: last?.answer === text ? META_ORIENT_REPEAT_ONELINER : text, via: "meta" };
   }
   if (META_ORIENT_RE.test(q)) {
@@ -5800,7 +5877,7 @@ async function metaLane(query, { graph, memoryDir, last = null, templates = null
     // reprints orientationText(graph) verbatim on every repeat, never
     // collapsing. Mirrors ORIENTATION_REPEAT_ONELINER's identity-check
     // pattern exactly, with its own distinct oneliner text.
-    const text = orientationText(graph, templates, vocabHint);
+    const text = orientationText(graph, templates, vocabHint, uiContext);
     return { text: last?.answer === text ? META_ORIENT_REPEAT_ONELINER : text, via: "meta" };
   }
   // A bare "what is in here" with NO standing focus — see
@@ -5815,7 +5892,7 @@ async function metaLane(query, { graph, memoryDir, last = null, templates = null
   if (!focus?.label) {
     const stripped = normalizeQuery(String(query)).trim().replace(/[?.!]+$/, "").trim();
     if (NO_FOCUS_WHATS_IN_HERE_RE.test(stripped)) {
-      const text = orientationText(graph, templates, vocabHint);
+      const text = orientationText(graph, templates, vocabHint, uiContext);
       return { text: last?.answer === text ? META_ORIENT_REPEAT_ONELINER : text, via: "meta" };
     }
   }
@@ -5961,7 +6038,7 @@ function nudgeName(captured, focus) {
  *  for the opinion gate: it must fire BEFORE the short-miss's "is a <thing> a
  *  <kind>" membership hint would (the caller runs this whole step before the
  *  short-miss rewrite). */
-function nudgeAnswer(query, focus, vocabHint = null) {
+function nudgeAnswer(query, focus, vocabHint = null, uiContext = "cli") {
   const q = String(query).trim().replace(/[?.!]+$/, "").replace(/\s+/g, " ");
   if (PERSONAL_ASSISTANT_NUDGE_RE.test(q)) {
     // A hardcoded "what is a dog" example here would be a lie in any UNSEEDED
@@ -5971,9 +6048,14 @@ function nudgeAnswer(query, focus, vocabHint = null) {
     // summary). vocabHint (threaded from runAsk/runTurn's own
     // hasSeededVocabulary check) is ALREADY the correct session-gated clause:
     // "what is a dog" when seeded, `tmct init` otherwise — reused verbatim
-    // instead of a second, ungated copy.
+    // instead of a second, ungated copy. Its own last-resort fallback (a
+    // session that passed no hint at all) still has to pick a remedy, so it
+    // splits on the surface for the same reason vocabExampleHint does.
+    const fallback = uiContext === "browser"
+      ? 'Teach me a fact, e.g. "every bug is an issue".'
+      : "Run `tmct init` to seed a starter vocabulary.";
     return "I don't have access to that — I'm a deterministic code/vocabulary assistant, not a general assistant. "
-      + `Ask me about code structure ("which modules import <name>"). ${vocabHint || 'Run `tmct init` to seed a starter vocabulary.'}`;
+      + `Ask me about code structure ("which modules import <name>"). ${vocabHint || fallback}`;
   }
   if (OPINION_NUDGE_RE.test(q)) {
     const name = focus?.label || "<name>";
@@ -6114,7 +6196,7 @@ async function presuppositionNudge(query, { graph, memoryDir }) {
             || (f.predicate === `tmct:${adjective}` && f.object === "true"))) || null;
       }
     }
-    lines.push(`${objEnt.label} ${adjective} — ${propHit ? `yes (source: ${propHit.provenance})` : "I have no fact saying so"}`);
+    lines.push(`${objEnt.label} ${adjective} — ${propHit ? `yes (source: ${citationProvenance(propHit.provenance)})` : "I have no fact saying so"}`);
   }
   const verdict = lines.join("; ");
   return { text: holds ? `${verdict}. ${subjEnt.label} does ${split.verb} ${objEnt.label}.` : `${verdict} — the premise doesn't hold.` };
@@ -6523,6 +6605,14 @@ function splitMetaPredicate(term) {
   return { subject: t, predicate: null };
 }
 
+// A peer-taught tag's `#node:<id>` segment keys the fact (PLAN_FACT.md) but is
+// never meant for a reader — strip it wherever provenance is cited in prose,
+// mirroring the same stable-node-id-is-not-shown rule chat-page-viz.mjs's own
+// node roster already applies.
+function citationProvenance(provenance) {
+  return provenance.replace(/#node:[0-9a-f]+/g, "");
+}
+
 /** 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, not "i learned: …" — that phrase over-claims and anthropomorphises
@@ -6534,7 +6624,7 @@ function splitMetaPredicate(term) {
  *  that it's lower-confidence, so a distinct, honest hedge ("possibly: …")
  *  applies here instead. Provenance stays VERBATIM in every case. */
 function renderFactLine(f) {
-  const cite = f.provenance ? ` (source: ${f.provenance})` : "";
+  const cite = f.provenance ? ` (source: ${citationProvenance(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}`;
@@ -6690,7 +6780,7 @@ function isaPolarityReply(hit, negHit) {
  *  inconsistency as a derivation — so neither side wins, same discipline as
  *  isaPolarityReply's both-sides verdict. */
 function isaInconsistencyRefusal(posFact, disjointFact) {
-  const cite = (f) => `${factPhrase(f)}${f.provenance ? ` (source: ${f.provenance})` : ""}`;
+  const cite = (f) => `${factPhrase(f)}${f.provenance ? ` (source: ${citationProvenance(f.provenance)})` : ""}`;
   return {
     text: `you've told me both ${cite(posFact)} and ${cite(disjointFact)} — together those contradict, and I won't derive an answer from an inconsistency. `
       + `To settle it, say "forget that ${posFact.subject} is ${indefiniteArticleFor(posFact.object)} ${posFact.object}".`,
@@ -6709,7 +6799,7 @@ function isaInconsistencyRefusal(posFact, disjointFact) {
  *  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 step = (f) => `${factPhrase(f)}${f.provenance ? ` (source: ${citationProvenance(f.provenance)})` : ""}`;
   const first = premises[0];
   const last = premises[premises.length - 1];
   return `${premises.map(step).join("; ")}; so ${first.subject} is a ${last.object}`;
@@ -7158,10 +7248,18 @@ const WHAT_USED_FOR_RE = /^what\s+(?:(?:can\s+be|is)\s+used\s+for|is\s+for)\s+(.
  *  fact subject named that, and falls through to the code-graph where lane
  *  unchanged. Consumed by factAnswer's (a-pre4) reader. */
 const WHERE_IS_FACT_RE = /^where(?:'s|\s+is|\s+are)\s+(.+?)(?:\s+now)?\s*[?.!]*$/i;
-/** The closed locative tail of a folded prepositional-verb predicate
- *  (mgx:rest-on, mgx:stand-on, mgx:sit-in, …) — what makes a taught fact a
- *  LOCATION answer rather than any arbitrary relation. */
-const LOCATIVE_FACT_PREDICATE_RE = /^mgx:[a-z]+-(?:on|in|at|inside|under|below|above|near|beside|behind|by)$/;
+/** "where does ann live[ now]" — the auxiliary-fronted sibling of
+ *  WHERE_IS_FACT_RE, over the same taught locative facts. The trailing verb
+ *  carries no meaning here (locativePreposition, imported from ask-vocab.mjs,
+ *  matches on the predicate's own folded preposition, not the query's
+ *  surface verb), so it is dropped rather than captured — group 1 is the
+ *  subject alone, same shape WHERE_IS_FACT_RE's reader already expects. */
+const WHERE_DOES_FACT_RE = /^where\s+(?:does|do|did)\s+(.+?)\s+[a-z][a-z'-]*(?:\s+now)?\s*[?.!]*$/i;
+// The closed locative tail of a folded prepositional-verb predicate
+// (mgx:rest-on, mgx:stand-on, mgx:sit-in, …) — what makes a taught fact a
+// LOCATION answer rather than any arbitrary relation — lives once, in
+// ask-vocab.mjs's LOCATIVE_PREPOSITIONS/locativePreposition; this file reads
+// it through locativePreposition rather than keeping its own copy.
 /** "what is on peg-a" / "what's on peg-a" — the reverse-by-OBJECT mirror of
  *  WHERE_IS_FACT_RE, over the same taught locative facts. The bare copula
  *  carries no verb to mint a predicate from, so the PREPOSITION is the anchor:
@@ -7248,7 +7346,7 @@ function renderIsaCite(chain, facts) {
     (f) => f.predicate === step.predicate && f.subject === step.subject && f.object === step.object,
   ));
   if (!steps.length || !steps.every(Boolean)) return null;
-  return steps.map((g) => `${factPhrase(g)}${g.provenance ? ` (source: ${g.provenance})` : ""}`).join("; ");
+  return steps.map((g) => `${factPhrase(g)}${g.provenance ? ` (source: ${citationProvenance(g.provenance)})` : ""}`).join("; ");
 }
 
 /** THE capability answer — every reader that asks "can X do Y" renders through
@@ -7636,7 +7734,7 @@ async function factAnswerReaders(memoryDir, query, envelope, miss, biasByBundle
       if (declined) return declined;
       const steps = order.slice(0, -1).map((n, i) => pairs.find((f) => f.subject === n && f.object === order[i + 1]));
       if (steps.every(Boolean)) {
-        const cite = steps.map((g) => `${factPhrase(g)}${g.provenance ? ` (source: ${g.provenance})` : ""}`).join("; ");
+        const cite = steps.map((g) => `${factPhrase(g)}${g.provenance ? ` (source: ${citationProvenance(g.provenance)})` : ""}`).join("; ");
         return { text: `${order[0]} — ${cite}; so ${order[0]} is the ${supWord} ${kindSingular}`, replace: true };
       }
     }
@@ -7649,11 +7747,11 @@ async function factAnswerReaders(memoryDir, query, envelope, miss, biasByBundle
   // after the code lane already missed, and takes over only when a locative
   // fact row for that exact subject exists — a real module answer, and every
   // no-fact miss, is untouched.
-  const whereQ = miss ? q.match(WHERE_IS_FACT_RE) : null;
+  const whereQ = miss ? (q.match(WHERE_IS_FACT_RE) || q.match(WHERE_DOES_FACT_RE)) : null;
   if (whereQ) {
     const variants = factTermVariants(normFactTerm, whereQ[1]);
     const hits = (await factRows(memoryDir, cache))
-      .filter((f) => LOCATIVE_FACT_PREDICATE_RE.test(f.predicate) && variants.has(f.subject));
+      .filter((f) => locativePreposition(f.predicate) !== null && variants.has(f.subject));
     if (hits.length) {
       const ranked = rankByBiasThenTrust(uniqueFacts(hits), biasByBundle);
       const lines = ranked.map(renderFactLine);
@@ -7677,7 +7775,7 @@ async function factAnswerReaders(memoryDir, query, envelope, miss, biasByBundle
     const prep = whatIsPrepQ[1].toLowerCase();
     const variants = factTermVariants(normFactTerm, whatIsPrepQ[2].replace(/^(?:an?|the)\s+/i, "").trim());
     const hits = (await factRows(memoryDir, cache)).filter(
-      (f) => LOCATIVE_FACT_PREDICATE_RE.test(f.predicate) && f.predicate.endsWith(`-${prep}`) && variants.has(f.object),
+      (f) => locativePreposition(f.predicate) === prep && variants.has(f.object),
     );
     if (hits.length) {
       const ranked = rankByBiasThenTrust(uniqueFacts(hits), biasByBundle);
@@ -8216,7 +8314,7 @@ async function factAnswerReaders(memoryDir, query, envelope, miss, biasByBundle
         if (!chain || chain.length < 2) return renderFactLine(f);
         const steps = chain.map(rowForStep);
         if (!steps.every(Boolean)) return renderFactLine(f);
-        const cite = steps.map((g) => `${factPhrase(g)}${g.provenance ? ` (source: ${g.provenance})` : ""}`).join("; ");
+        const cite = steps.map((g) => `${factPhrase(g)}${g.provenance ? ` (source: ${citationProvenance(g.provenance)})` : ""}`).join("; ");
         return `${renderFactLine(f)} — via: ${cite}`;
       });
       const shown = lines.slice(0, FACT_ANSWER_CAP);
@@ -9259,7 +9357,7 @@ async function factReadBackReaders(memoryDir, query, envelope, miss, graph = nul
                   const key = af.id || `${af.subject}|${af.predicate}|${af.object}`;
                   if (seenAlias.has(key)) continue;
                   seenAlias.add(key);
-                  parts.push(`${factPhrase(af)}${af.provenance ? ` (source: ${af.provenance})` : ""}`);
+                  parts.push(`${factPhrase(af)}${af.provenance ? ` (source: ${citationProvenance(af.provenance)})` : ""}`);
                 }
               }
               return `${node.entity} — ${parts.join("; ")}`;
@@ -9438,7 +9536,7 @@ async function factReadBackReaders(memoryDir, query, envelope, miss, graph = nul
           const kindEcho = stripTrailingDiscourseTag(isaAsk[2]).trim();
           const chain = [posFact, ...(objFact ? [objFact] : [])].map(renderFactLine).join("; ");
           return {
-            text: `no — ${chain}; and ${factPhrase(disjointFact)}${disjointFact.provenance ? ` (source: ${disjointFact.provenance})` : ""} `
+            text: `no — ${chain}; and ${factPhrase(disjointFact)}${disjointFact.provenance ? ` (source: ${citationProvenance(disjointFact.provenance)})` : ""} `
               + `— so ${isaSubject} can never be ${indefiniteArticleFor(kindEcho)} ${kindEcho}.`,
             replace: true,
           };
@@ -9794,7 +9892,7 @@ async function factReadBackReaders(memoryDir, query, envelope, miss, graph = nul
       const witness = findAcrossVariants(subjVariants, objVariants, (s, o) => proveCardinalityAtLeast(cardSubClassEdges, cardinalityRestrictionEdges, s, o, m, {}));
       if (witness) {
         const restrictionFact = rows.find((f) => f.predicate === CARD_SC_PREDICATE && f.subject === witness.viaClass && f.object === witness.viaRestriction);
-        const cite = restrictionFact?.provenance ? ` (source: ${restrictionFact.provenance})` : "";
+        const cite = restrictionFact?.provenance ? ` (source: ${citationProvenance(restrictionFact.provenance)})` : "";
         const kindWord = witness.kind === "exactly" ? "exactly" : "at least";
         const plural = (w, n) => `${w}${n === 1 ? "" : "s"}`;
         // Premise-derived trust for THIS
@@ -9843,7 +9941,7 @@ async function factReadBackReaders(memoryDir, query, envelope, miss, graph = nul
       const witness = findAcrossVariants(subjVariants, objVariants, (s, o) => proveMaxCardinalityZeroDenial(cardSubClassEdges, cardinalityRestrictionEdges, s, o, {}));
       if (witness) {
         const restrictionFact = rows.find((f) => f.predicate === CARD_SC_PREDICATE && f.subject === witness.viaClass && f.object === witness.viaRestriction);
-        const cite = restrictionFact?.provenance ? ` (source: ${restrictionFact.provenance})` : "";
+        const cite = restrictionFact?.provenance ? ` (source: ${citationProvenance(restrictionFact.provenance)})` : "";
         // Same discipline as the
         // cardinality-monotonicity reader just above (see its own comment).
         const cardPremiseTrusts = [
@@ -11506,12 +11604,6 @@ async function entityOfKindInText(graph, expectedClass, answerText) {
   return null;
 }
 
-/** A bare question → tmct_ask. When a focus is set AND the graph is in hand we
- *  call ask() directly to thread the focus as contextId (so a pronoun like "it"
- *  resolves to the focus) — building the SAME delimited string dispatchTool emits;
- *  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. */
 /** Load the taught domain for the plan lane: fact rows + rule rows compiled
  *  through src/domain.mjs. Fresh-loads memory (never the turn cache) because
  *  the caller may have just written snapshot rows this same turn. */
@@ -11539,15 +11631,15 @@ function actionLabel(name, subject, target) {
  *  sentence never says, and a preposition doesn't imply one — "on" reads as
  *  rest-on, stand-on, sit-on or lie-on with equal warrant, so any prep→verb
  *  table here would be invention. The taught facts answer instead: every
- *  locative fact (LOCATIVE_FACT_PREDICATE_RE's closed predicate tail) about a
- *  member of the goal's class whose preposition is the one typed contributes
- *  its verb. Returns the candidates, sorted. Exactly one is an answer; none or
- *  several is the caller's decline. */
+ *  locative fact (ask-vocab.mjs's locativePreposition, over its closed
+ *  predicate tail) about a member of the goal's class whose preposition is
+ *  the one typed contributes its verb. Returns the candidates, sorted.
+ *  Exactly one is an answer; none or several is the caller's decline. */
 function goalVerbsFromTaughtFacts(factRows, domain, { universal, term, prep }) {
   const subjects = new Set(universal ? domain?.classMembers?.[term] || [] : [term]);
   const verbs = new Set();
   for (const row of factRows || []) {
-    if (!LOCATIVE_FACT_PREDICATE_RE.test(row.predicate)) continue;
+    if (locativePreposition(row.predicate) === null) continue;
     if (!subjects.has(row.subject)) continue;
     const [factVerb, factPrep] = row.predicate.slice("mgx:".length).split("-");
     if (factPrep === prep) verbs.add(factVerb);
@@ -12577,7 +12669,7 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
   let answer;
   let envelope = null;
   try {
-    let text;
+    let content;
     if (graph?.individuals?.length || (graph && (focus?.id || prev.length))) {
       // Direct ask() whenever the caller HANDED US a graph with something in it.
       // The focus/prev pair is threaded through it (contextId so "it" binds, prev
@@ -12586,15 +12678,16 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
       // below reads the CONFIG's graph instead — which an in-process session (a
       // page's own world facts, say) has no file for. Gating on history alone
       // refused every cold turn against a perfectly good graph and only started
-      // answering once a focus happened to be set. Builds the SAME delimited
-      // envelope dispatchTool emits, so the parse below is identical either way.
+      // answering once a focus happened to be set.
       const { ask } = await import("../domain/ask.mjs");
       const r = ask(graph, askQuery, { contextId: effectiveContextId, prev });
-      text = `${r.content}${ASK_ENVELOPE_DELIM}${JSON.stringify(r.tmct_ask, null, 2)}`;
+      content = r.content;
+      envelope = r.tmct_ask;
     } else {
-      text = await dispatchTool("tmct_ask", { query: askQuery }, { config, source, tel });
+      const r = await dispatchToolStructured("tmct_ask", { query: askQuery }, { config, source, tel });
+      content = r.content;
+      envelope = r.data ?? null;
     }
-    const [content, envJson] = text.split(ASK_ENVELOPE_DELIM);
     // ask.mjs is shared with the web GUI surface (src/surfaces/web), whose
     // graph view really does have clickable nodes to select — its own
     // "click a node first, or name it directly" wording is correct THERE,
@@ -12609,11 +12702,10 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
       /needs a selected node to refer to — click a node first, or name it directly\.$/,
       "isn't resolved to anything yet — name the term directly, or ask a question that resolves one first.",
     );
-    if (envJson) { try { envelope = JSON.parse(envJson); } catch { envelope = null; } }
     // Typed discourse referents the answer established (the ask envelope's
     // additive `discourse` field, emitted beside the eval where the answer's
     // content is still typed) register into the session's record here — the
-    // one point both ask paths (direct call and dispatchTool) converge.
+    // one point both ask paths (direct call and dispatchToolStructured) converge.
     if (discourseHolder && Array.isArray(envelope?.discourse)) {
       for (const { lane, bound, ...spec } of envelope.discourse) {
         discourseHolder.record = registerReferent(discourseHolder.record, {
@@ -12832,7 +12924,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 (!handled && miss) {
-    const meta = await metaLane(query, { graph, memoryDir, last, templates, vocabHint, focus });
+    const meta = await metaLane(query, { graph, memoryDir, last, templates, vocabHint, focus, uiContext });
     if (meta) {
       // A lane may answer with a better-worded decline (the module-orient
       // residue guard) — still a miss in the turn record, like the isa
@@ -13228,7 +13320,7 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
     // 3 words with no STRUCT_WORDS token, so without this guard
     // isConversational would discard a correct, already-composed answer for
     // the generic orientation wall.
-    const orientation = orientationAnswer(templates, graph, vocabHint);
+    const orientation = orientationAnswer(templates, graph, vocabHint, uiContext);
     const repeat = last?.answer === orientation;
     answer = repeat ? ORIENTATION_REPEAT_ONELINER : orientation;
     via = "template"; handled = true;
@@ -13473,7 +13565,7 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
   // must never become a recallable answer. The opinion gate fires HERE, before the
   // short-miss's "is a <thing> a <kind>" membership hint could claim the line.
   if (miss && recordMiss && via === "composed") {
-    const nudged = nudgeAnswer(query, newFocus, vocabHint);
+    const nudged = nudgeAnswer(query, newFocus, vocabHint, uiContext);
     if (nudged) {
       answer = nudged; via = "miss";
       note(trace, "lane: (4c) CAPABILITY NUDGE — the question asked tmct to do something outside its scope (opinion/generation/risk-scoring)");
@@ -14324,22 +14416,34 @@ async function everySentenceTeaches(sentences, lexicon) {
   }
 }
 
-async function assertTurn(line, { memoryDir, sessionId, focus, lexicon = null, cache = null }) {
+async function assertTurn(line, { memoryDir, sessionId, focus, lexicon = null, cache = null, observedAt: observedAtIn = "", dateText: dateTextIn = "" }) {
   // A trailing "?" marks a question, and a question never writes — the ACE
   // fragment happily parses "dog have tail?" as the declarative it is not,
   // which stored a Fact at teach trust over a FLOW-0 vocabulary question.
   if (/\?\s*$/.test(String(line).trim())) return null;
   try {
+    // THE DATED TEACH FRAME — "<sentence> as of <date>". A caller that
+    // already resolved a date (teachLane, recursing into its own
+    // assertCandidates loop with the suffix already stripped) passes
+    // observedAt/dateText straight through; the standalone entry point (the
+    // top-level declarative-sentence dispatch in runTurn) probes `line`
+    // itself. Either way the ACE parse below runs on `probeLine` — the
+    // suffix-stripped text when a date was found, `line` unchanged otherwise
+    // — so an ordinary sentence's behavior never changes.
+    const suffix = observedAtIn ? null : datedTeachSuffix(line);
+    const probeLine = suffix ? suffix.stripped : line;
+    const observedAt = observedAtIn || suffix?.observedAt || "";
+    const dateText = dateTextIn || suffix?.dateText || "";
     const { parseAce, parseAceAmbiguous } = await import("../domain/grammar/ace.mjs");
     // A session handle carries its own loaded lexicon (createSession loads it once);
     // a bare runTurn (no handle) lazy-loads the cached core lexicon. The lexicon is
     // immutable, so sharing one reference across concurrent handles is re-entrant.
     let lex = lexicon;
     if (!lex) { const { loadLexicon } = await import("../domain/grammar/lexicon.mjs"); lex = loadLexicon(); }
-    const ambiguous = parseAceAmbiguous(line, lex);
+    const ambiguous = parseAceAmbiguous(probeLine, lex);
     if (ambiguous) {
       const { normFactTerm } = await import("../adapters/memory/core.mjs");
-      const answer = renderAmbiguousAssert(line, ambiguous, normFactTerm);
+      const answer = renderAmbiguousAssert(probeLine, ambiguous, normFactTerm);
       // Genuinely ambiguous — no single triple was committed, so the canonical
       // form is every surviving reading's own would-be triple set, same idiom
       // as ask.mjs's canonicalOf() for a parse-level tie.
@@ -14351,7 +14455,7 @@ async function assertTurn(line, { memoryDir, sessionId, focus, lexicon = null, c
       };
       return plainTurn(line, answer, { command: "assert", via: "assert", focus, canonical, goal: "teach/remember a new fact" });
     }
-    const parse = parseAce(line, lex);
+    const parse = parseAce(probeLine, lex);
     if (!parse || !parse.triples?.length || parse.residue?.length) return null;
     const { assertSentence } = await import("../domain/grammar/assert.mjs");
     const { normFactTerm, appendFact } = await import("../adapters/memory/core.mjs");
@@ -14368,10 +14472,11 @@ async function assertTurn(line, { memoryDir, sessionId, focus, lexicon = null, c
         { command: "assert", via: "teach-miss", miss: true, focus });
     }
     const ts = new Date().toISOString();
-    const res = await assertSentence(memoryDir, line, {
+    const res = await assertSentence(memoryDir, probeLine, {
       lexicon: lex,
       provenance: { source: "chat", sessionId, ts },
       appendFact,
+      ...(observedAt ? { observedAt } : {}),
     });
     if (!res || !res.ids?.length) return null;
     // A plain universal "every X is a Y" ALSO records the "every" quantifier
@@ -14379,12 +14484,13 @@ async function assertTurn(line, { memoryDir, sessionId, focus, lexicon = null, c
     // lane. Gated on the literal typed determiner: only "every" reads as a
     // class-level generalization. Best-effort: the base fact is already
     // durably stored either way, so a failure here is swallowed.
-    if (/^every\s+/i.test(String(line).trim())) {
+    if (/^every\s+/i.test(String(probeLine).trim())) {
       const triple = res.triples.find((t) => t.predicate === "rdfs:subClassOf");
       if (triple) {
         try {
           await appendFact(memoryDir, {
             subject: triple.subject, predicate: "rdfs:subClassOf", object: triple.object, quantifier: "every",
+            ...(observedAt ? { observedAt } : {}),
           });
         } catch { /* best-effort — the base fact is already stored either way */ }
       }
@@ -14416,7 +14522,10 @@ async function assertTurn(line, { memoryDir, sessionId, focus, lexicon = null, c
         if (para) paraphraseSuffix = ` (${para})`;
       } catch { /* best-effort — the literal confirmation above is already correct either way */ }
     }
-    const answer = `noted — remembered ${n} fact${n === 1 ? "" : "s"}: ${shown}${paraphraseSuffix}`;
+    // The dated-teach frame's own echo: the user typed the date, so the
+    // acknowledgment shows it was registered rather than silently dropped.
+    const dateSuffix = observedAt && dateText ? ` (as of ${dateText})` : "";
+    const answer = `noted — remembered ${n} fact${n === 1 ? "" : "s"}: ${shown}${paraphraseSuffix}${dateSuffix}`;
     // The canonical restatement of what was committed — `machine` is the same
     // fact(s) in the compact notation ask.mjs's canonicalOf() uses for
     // query-side parses, so both lanes share one consistent syntax.
@@ -15166,7 +15275,7 @@ async function dispatchTurn(input, { config, source = defaultSource, graph = nul
   const trace = narrate ? [] : null;
   // vocabHint: createSession computes this ONCE per session; a direct
   // runTurn() caller that doesn't pass one gets it computed here instead.
-  const resolvedVocabHint = vocabHint ?? vocabExampleHint(await hasSeededVocabulary(memoryDir));
+  const resolvedVocabHint = vocabHint ?? vocabExampleHint(await hasSeededVocabulary(memoryDir), uiContext);
   // The session's in-progress plan rides a mutable holder: the plan lane and
   // the PLAN NEXT block below write planHolder.state; every other path leaves
   // it untouched, and the caller re-threads whatever comes back.
@@ -15647,7 +15756,7 @@ async function dispatchTurn(input, { config, source = defaultSource, graph = nul
   }
   // Aggregate/count questions are answered mechanically off the loaded graph header,
   // BEFORE falling through to the ask engine (focus unchanged — a count names no entity).
-  const count = answerCount(graph, workingLine);
+  const count = answerCount(graph, workingLine, { uiContext });
   if (count != null) {
     // An "I can't count <noun>" from a bare kind may still be answerable from an
     // ASSERTED vocabulary fact ("every class is a type" → "how many types" = the
@@ -15714,9 +15823,18 @@ export async function hasSeededVocabulary(repo) {
  *  pair too: an abstract "every X is a Y" invites a curious user to fill X/Y
  *  with an intuitive-but-unknown word and hit the teach-miss dead-end right
  *  after being offered the pattern. "every bug is an issue" is confirmed to
- *  parse and store, so the offer resolves if copied verbatim. */
-export function vocabExampleHint(seeded) {
-  return seeded
-    ? 'Try "what is a dog" for general vocabulary.'
+ *  parse and store, so the offer resolves if copied verbatim.
+ *
+ *  `uiContext` picks the REMEDY the same way: a terminal session can run
+ *  `tmct init` against a real directory, a page has no filesystem and no argv,
+ *  so naming the command there sends the reader after something the surface
+ *  can't do. The teach pointer works on both, so the browser arm keeps only
+ *  that. This clause is threaded through runAsk as `vocabHint` and reused by
+ *  every dead-end that needs to name an exit, so one split here covers them
+ *  all rather than each miss carrying its own copy. */
+export function vocabExampleHint(seeded, uiContext = "cli") {
+  if (seeded) return 'Try "what is a dog" for general vocabulary.';
+  return uiContext === "browser"
+    ? 'Teach me directly, e.g. "every bug is an issue".'
     : 'Run `tmct init` to seed a starter vocabulary, or teach me directly, e.g. "every bug is an issue".';
 }