@polycode-projects/the-mechanical-code-talker 1.0.6 → 1.0.8

package/README.md

@@ -17,7 +17,9 @@ tmct> /callers checkout
 tmct> /exit
 ```
 
-Home page: https://polycode-projects.gitlab.io/the-mechanical-code-talker/
+**[Try it live in your browser →](https://polycode-projects.gitlab.io/the-mechanical-code-talker/)**
+— a real, interactive chat demo running client-side: your browser runs the
+actual query engine against a small example codebase, no server, no install.
 
 ## How it interprets you
 

package/ROADMAP.md

@@ -12,87 +12,103 @@ mapped into them (item numbers retained for traceability); the seven sketches
 formerly held in `code-talker-ideas.txt` are folded into items 8–11 below and
 the file has been deleted.
 
-## Where we are now (2026-07-08)
+## Where we are now (2026-07-09)
 
-`npm test` green (**1055**). **v0.9.6, pushed** (0.8.2 → 0.9.6 across this session — see
-`HANDOVER.md` for the exact release chain).
-
-### Doing right now (5 background clusters, all worktree-isolated, merged sequentially as each lands)
-
-- **Cluster A** — Bug 6 (scoped-listing false-empty) + Bug 7 (modal-in-fuzzy-cascade) + the
-  chat-feel residual pair (items 1-2 of the trio's siblings) + `edgesOfKind` memoization +
-  ontology numeric-vocabulary declaration.
-- **Cluster B** — Bug 8 (goal-reasoner confident-wrong on off-domain requests) + refreshing
-  `PLAN_CAPABILITY_ROUTER.md`'s stale stage-5 status text.
-- **Cluster C** — `PLAN_CHAT_FEEL.md` item 6, the pronoun/temporal/discourse-count trio
-  (measured red sets from an earlier advisor tick; re-measured against the current graded pool
-  before any fix).
-- ~~**Cluster D** — `PLAN_CODE.md` Track 1~~ **shipped** (see "Now" below). Tracks 2-4 remain
-  unsigned-off and untouched.
-- **Cluster E** — `PLAN_INFERENCE_TESTING.md` Stage 1 (`cax-sco` rule) + Stage 2 (proof-chain
-  receipts) in `src/syllogise.mjs`, targeting the measured chat-A2 50% ceiling.
-
-Also in flight: playtest sprint rounds 4-8 (3/3 rounds so far shipped a real fix), the strategy
-advisor (restarted, 5-min re-arm).
+`npm test` green (**1245**). **v1.0.7, pushed** (0.9.11 → 1.0.0 → 1.0.7 across this session —
+see `HANDOVER.md` for the exact release chain and file:line detail).
 
 ### Now: shipped this session
 
-- **5 bugs fixed.** Recall half-match replay + staple-onto-wall; 4 wall-kindness gaps (orientation
-  blurb repeat, "thanks, `<clause>`" walls, a reexports vocabulary leak, `/describe` not surfacing
-  taught facts); grain-aware entity resolution (fixes the fuzzy-entity false-empty and a
-  function/module coverage contradiction); module-grain overview gap. Full list in `HANDOVER.md`.
-- **A new feature: predicate-based "find" queries.** "find me the payment class" now works:
-  type-filtered, fuzzy property-surface matching, with a narrow-then-broaden inheritance-aware
-  cascade and a boolean-fold generalization for compositional predicate queries. Design:
-  `archive/PLAN_PREDICATE_QUERIES.md`.
-- **Two research tracks landed as code.** The ontology plan's two inert synonym resources
-  (ConceptNet synonym/similar-to rows, phrasebook synonym families) are now wired into query-time
-  matching, and the disjointness premise set plus numeric vocabulary grew
-  (`PLAN_ontology-hierarchies.md`). The advanced-grammar plan's closed-frame subordination and
-  conditional support, plus presupposition honest-nudges, landed (`PLAN_ADVANCED_GRAMMAR.md`); the
-  graded pool grew 925 to 1075 cases across 6 new construction families (`chatbench/GRADED.md`).
-- **A new benchmark: infbench.** A 6-band classical-logic ladder (INF-A1..C2), mechanically
-  generated, first baseline in `INFBENCH_0.8.2.md`. Kernel A1/A2 clean; chat A1 100%, A2 exactly
-  50% (the cax-sco gap, now measured). The ladder gates at B1 (33%) because the disjointness proof
-  rule doesn't exist yet.
-- **A new demo** (`demo/agentic-loop-demo.mjs`) shows the zero-LLM deduce-plan-execute-compose loop
-  end to end, and surfaced a real goal-reasoner honesty gap (Bug 8, below).
-- **A session-loop fix.** A throwing turn no longer aborts a piped/non-interactive session.
-- **4 new plan docs.** `PLAN_ontology-hierarchies.md`, `PLAN_INFERENCE_TESTING.md` (revised so
-  infbench generation is mechanical, not hand-authored), `archive/PLAN_PREDICATE_QUERIES.md`, and
-  `PLAN_CODE.md` (new, program synthesis over tmct's closed DSLs, gated on explicit operator
-  sign-off per track — Track 1 signed off, see "Doing" above).
-- **`PLAN_TMCT_ECOSYSTEM_INTEGRATION.md`**, landed — a code-grounded tmct/bedrock-meter/marginalia
-  integration plan. Corrects a standing wrong assumption (the `/v1/messages` shim was believed
-  unmerged; it's been on `main` since 0.8.0) and confirms seonix has already fully migrated onto
-  tmct as a real dependency.
-- **A `/narrate` debug mode.** Opt-in (`/narrate on`, `--narrate`, `TMCT_NARRATE=1`) per-turn
-  decision narrative — which lane/pattern matched, results + sources, a deterministic goal
-  deduction — built for playtest-sprint debugging; zero cost when off (byte-identical regression
-  guard).
+- **1.0.0 — the first-run chat experience, rewritten.** The original trigger: a brand-new
+  `npm install` + bare `tmct chat` led with a "no code graph loaded" apology for *any* input,
+  including plain greetings and identity questions, even though the seeded ontology/lexicon
+  could already answer them. Root-caused to a 0.6.0-era design that over-applied its own honest
+  empty-graph orientation. Fixed: identity/capability-led responses (`I'm tmct — ...` before any
+  caveat), a real self-description + a distinct "no LLM involved" answer for the identity/AI-ID
+  family, provably-correct "try this" examples (a `vocabExampleHint` that only ever offers a term
+  confirmed to resolve in the session's actual seed state — the prior hint could silently lie
+  under `TMCT_NO_SEED=1`), and substantially broadened conversational recognition (dialect,
+  register, slang, elongation, a bounded-fuzzy-match typo layer) — all via curated closed-set
+  additions, not a generalized grammar rule, per the project's standing preference.
+- **The `SKILL_CHAT_PLAYTEST.md` dialogue-flow loop, run for real across 5 tiers.** Tier 0
+  (bootstrap/identity), Tier 1 (single touch + one drill-down), Tier 2 (drill-down chains with
+  anaphora), and Tier 4 (compositional & comparative) each closed in one pass; **Tier 3
+  (cross-concept & relation touches) took 7 passes** — cycles 3-9 progressively found and fixed a
+  recurring `resolveObject` substring-match weakness (a missing minimum-length floor let short
+  staccato connectives like "and"/"it" silently hijack the conversation's focus, producing
+  confidently WRONG answers on a *later* turn while looking honest) — patched three times
+  point-by-point before cycle 9 found and fixed the actual root cause in one place. Tier 5/6 not
+  yet started. The skill doc itself gained two new rules from real incidents this run: always
+  `mktemp -d` + exact-path cleanup for scratch fixtures (a wildcard `rm -rf /tmp/pt-*` cleanup
+  step got flagged by the harness's own safety policy — no damage, but a real cross-agent risk),
+  and never `chat --repo` the committed example fixture directly (dirties a checked-in file).
+- **A live, client-side chat demo on the GitLab Pages homepage.** Not a scripted/pre-recorded
+  fake — the real `src/ask.mjs` query engine runs in the visitor's browser (wink-nlp loaded from
+  `esm.sh`, an import-map shim working around 3 leaf files' Node-only static imports, zero
+  changes needed to the engine itself since it was already browser-clean pure JS). Boots with a
+  banner, replays a few real pre-verified Q&A turns as "history", asks one randomized (or
+  `?q=`-primed) question live, and — as of this session's last addition — has a genuine
+  interactive input box so a visitor can type their own questions and get real computed answers.
+  `?compact=1` for a minimal primed-link view; `window.tmctAnswer`/`tmctAsk`/`tmctParseEntities`
+  exposed for headless/Playwright consumers (curl/jq can never see it — no backend on GitLab
+  Pages, JS never executes for a plain HTTP client — documented plainly, not oversold).
+- **Operator-found bugs, fixed as they were found by hand-testing the shipped CLI**: relation-
+  specific vocabulary filtering ("what is a tree used for" was dumping every known relation
+  instead of filtering to UsedFor); a teach-lane "did you mean" suggestion that could echo back
+  the user's own input byte-identical (a missing a/an agreement check); out-of-domain small talk
+  ("what time is it") hitting the raw grammar wall instead of an honest nudge; a pronoun-subject
+  teach-lane gap that could silently store a bogus fact ("he is a module"); a closed-set
+  existence-question recognizer ("is there a class called X anywhere" was silently mis-answering
+  a *different* question — a relationship check — as if it were a verified existence negative);
+  "what else is X" repeating the primary definition verbatim instead of surfacing more; bare
+  "what is X" (no article) having no fact-lookup route at all, including for a fact the user had
+  *just* taught; and general verb-to-predicate teaching ("remember margo eats ribs" mints its own
+  predicate now, not just the closed is/has/are set — "has a" interoperates with the existing
+  ConceptNet-sourced `mgx:hasA` data).
+- **New-term teaching + quantifiers.** "redis is a cache" (a genuinely new term, not previously
+  in the closed ACE lexicon) is now teachable via a write-side-only fix — the read path already
+  worked generically over any subject string, including the existing 2-hop transitive `IsA` proof
+  chase. Plus four new phrasings ("some/a few Xs are Ys", "your X is a Y", bare "X is Y" as a
+  property assertion) and a stored-quantifier recall ("how many Xs are Ys" → "A few.").
+- **An always-on, short "Goal (inferred): ..." line** on every real structural/vocabulary answer
+  — distinct from the pre-existing opt-in `/narrate` full-trace mode, which stays as the deeper
+  debug tool. Two correctness bugs in the goal-deduction hook itself got fixed along the way
+  (a confidently wrong goal shown on failed teach attempts; a missing goal on relation-force
+  answers that resolve via a different path than the normal parse).
+- **Seonix's 17-round dogfooding backlog, triaged and Batch 1 shipped.** A sibling project
+  (seonix, consuming tmct as a real dependency) ran extensive dogfooding against both a synthetic
+  self-index and a real 27,929-module production estate, relaying findings via the inter-session
+  inbox. Triaged into 5 priority batches (4 items were already fixed by intervening work); Batch 1
+  (existence-query correctness) shipped. Batches 2-5 queued — see "Next" below.
+- **The version-bump policy, set then revised.** Tried "bump immediately after every push, hold
+  locally until the next batch" (to keep the published npm version always matching the last
+  pushed commit); reverted after it produced confusing "referencing a version that doesn't exist
+  yet" noise mid-session. Current policy: bump only at the moment of actually pushing, as part of
+  that same push. Recorded in `CLAUDE.md`.
 
 ### Next: the open follow-ups
 
-In priority order (full detail and measured targets in `HANDOVER.md`):
-
-1. **Bug 8 — FIXED.** A global-mode domain gate now requires the request itself (not just the
-   caller's declared toolset) to parse as a query about the deduced goal's domain, reusing
-   `ask.mjs`'s own grammar. Zero-hallucination baseline unchanged; independently re-verified.
-2. **Bug 6.** Scoped listing false-empty: "list modules in `<pkg>`" returns empty though the
-   unscoped lister shows matches. Found dogfooding a 191k-entity monorepo graph.
-3. **Bug 7.** A modal auxiliary ("should") survives the fuzzy-correction cascade and misreads as
-   "hold". The diagnosed fix is adding modals to `STOPWORDS`.
-4. ~~`PLAN_TMCT_ECOSYSTEM_INTEGRATION.md`~~ **shipped** — see "Now" above.
-5. ~~`PLAN_CODE.md` Track 1 sign-off~~ **signed off and shipped** — see "Now" above.
-6. **Still open**: the function-grain forward-shape gap (Bug C+D's grain resolution doesn't
-   cover the "forward" traversal shape), 8 remaining temporal red ids (each a distinct small
-   grammar gap), the un-flagged `C1:presupposition`/`C2:garden-path` regression, the
-   `edgesOfKind` by-subject/by-object endpoint indices (memoization itself is done). Full
-   detail in `HANDOVER.md`.
-7. **`SKILL_PLAYTEST_SPRINT.md`, in progress.** A capped, delegated, chained playtest loop (each
-   round a background chat session against `examples/mini-webapp`, appraised and fixed+shipped
-   live). Rounds 1-3 shipped 3 real fixes (0.9.3-0.9.5); cap raised from 3 to 8 rounds mid-run;
-   continuing.
+1. **Tier 5 (teach + recall + reasoning in dialogue) and Tier 6 (the messy real user)** — the
+   remaining two rungs of the dialogue-flow ladder, not yet run. Tier 5's territory substantially
+   overlaps functionality shipped this session (new-term teaching, quantifier recall) but hasn't
+   been run through the playtest loop's own dead-end-hunting discipline yet.
+2. **Seonix Batches 2-5** (full detail relayed via the inbox, triage summary in this session's
+   history): Batch 2 — "what is X" vs "what is a X" grammar-level minimal pair (the chat-layer
+   fact-lookup side is now fixed; the underlying `grammar.mjs` T5 template still requires the
+   article, left alone deliberately pending a closer look at why), a missing reverse-direction
+   "is X a superclass of Y" verb entry, "what is a `<noun phrase>`" swallowing the whole phrase
+   instead of extracting the head noun. Batch 3 — recurring wall patterns (purpose/identity
+   "whats X for/about", temporal qualifiers on Commit queries, onboarding/closing questions read
+   as literal search strings). Batch 4/5 — lower-priority, including a cross-graph disambiguation-
+   candidate-ranking weakness seonix evidenced 5 times independently but that doesn't reproduce on
+   tmct's own small fixture graph (needs a larger graph to chase).
+3. **General verb-to-predicate teaching's natural follow-up**: dedicated direct-question
+   recognition ("does margo eat ribs", "what does margo eat") — this session's work covers
+   teaching + generic retrieval, not verb-specific query phrasings.
+4. **The Tier-4 "of X" membership gap**: "public methods of TaskController" returns a genuine,
+   receipted empty because the class declares no methods of its own (they're inherited) —
+   extending membership queries to walk inheritance is a bigger structural change than a routing
+   fix, deliberately deferred.
 
 ### Later: deferred by design, staged inside each plan
 
@@ -112,6 +128,18 @@ their tables.
 
 ### History — what shipped in earlier releases
 
+**v0.9.12 → v1.0.7** (this session — the first-run UX rewrite + the 5-tier playtest sweep +
+the live browser demo): see "Where we are now" above for the full narrative; short form —
+1.0.0 shipped the identity/capability-led onboarding rewrite; 1.0.1-1.0.7 shipped, in order, the
+redis/new-term teaching + quantifier phrasings, the always-on Goal-inference line, a teach-lane
+pronoun-subject guard, three operator-found bugs (used-for filtering, teach-suggestion echo,
+out-of-domain small talk), Tier-0/1/2 playtest passes, Tier-3's 7-pass convergence (ending in a
+root-cause fix for the recurring substring-match focus-corruption bug), the diagnosed Tier-4
+compositional-fold fix, the live in-browser chat demo, Seonix Batch 1 (existence-query
+correctness), Tier 4's own playtest pass, and a final bundle ("what else is X", bare "what is X",
+general verb-to-predicate teaching). `npm test` 1055 → 1245 across the session, every commit
+green. Full commit-level detail in `HANDOVER.md`.
+
 **v0.8.2** (the chat-feel wave + rule-general C2): tier-1 CHATBENCH 334/334 (draw A) + 285/285
 (draw B), zero regressions; the cycle-1 hard-fail `gq-functions-call-fnalpha` flipped green.
 Landed recall hygiene, preamble/politeness frames, calls∪callsSymbol + grain/meta fallbacks, the

package/package.json

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

package/src/ask.mjs

@@ -863,6 +863,18 @@ function parseSuperlative(w, lc, nlp) {
   for (let i = extIdx; i < lc.length; i += 1) {
     if (EDGE_NOUN_TO_METRIC[lc[i]]) { metric = EDGE_NOUN_TO_METRIC[lc[i]]; metricNoun = lc[i]; break; }
   }
+  // Fallback: a passive-verb-led phrasing puts the participle metric word BEFORE
+  // the extreme, not after ("which function IS CALLED the most" — cf. "which
+  // module is MOST imported", the already-supported order where the participle
+  // trails "most" and the forward scan above already catches it). Scan backward
+  // from just before the extreme, taking the CLOSEST metric word — the natural
+  // reading when one exists at all. Only a fallback (never overrides a forward
+  // hit), so it can't touch any phrasing that already resolves correctly today.
+  if (!metric) {
+    for (let i = extIdx - 1; i >= 0; i -= 1) {
+      if (EDGE_NOUN_TO_METRIC[lc[i]]) { metric = EDGE_NOUN_TO_METRIC[lc[i]]; metricNoun = lc[i]; break; }
+    }
+  }
   const connectivity = lc.includes("connected") || lc.slice(extIdx, extIdx + 2).join(" ") === "most connected"
     || ["largest", "biggest", "smallest"].includes(lc[extIdx]);
   if (!metric) {
@@ -1063,15 +1075,48 @@ function parseRelationalOrQualified(w, lc, nlp, depth) {
     const { blc } = dropLeadCopula(bw, bw.map((x) => x.toLowerCase()));
     return blc.length && blc.every((x) => QUALIFIERS[x]);
   });
+  // A bare "call X and call Y" / "call X but not Y" chain — verb+verb (or
+  // verb+bare-object), no qualifier, no "that" — is ALSO the compositional shape
+  // when branch0 leads with an explicit verb and every OTHER branch is either (a)
+  // an explicit repeat of that SAME mapped verb kind ("call loadStore and call
+  // saveStore" == calls(loadStore) ∩ calls(saveStore)) or (b) a bare object with NO
+  // verb of its own at all ("call saveStore but not loadStore" — "loadStore" alone
+  // inherits "call" via the SAME ellipsis-borrowing buildPredicateAtoms/the atoms
+  // loop below already do for OR-chains like "importing X or Y"; this only widens
+  // the GATE that lets that borrowing fire for and/but-not too). Deliberately
+  // narrower than "any verb+verb and": the compat-guarded bare case ("which classes
+  // extends Base and couples to logging") gives its SECOND branch its own DIFFERENT
+  // explicit verb (coupled-to, not inherits) and so fails case (a) and isn't bare
+  // for case (b) either — it still has no marker and correctly stays on the legacy
+  // ambiguous-parse path, untouched.
+  const sameVerbBranches = predWords.length > 0 ? splitBoolean(predLc, predWords).branches : [];
+  let sameVerbLed = false;
+  if (sameVerbBranches.length > 1) {
+    const firstBlc = sameVerbBranches[0].map((x) => x.toLowerCase());
+    const firstVh = findPhrase(firstBlc, VERB_TO_KIND);
+    if (firstVh && firstVh.start === 0) {
+      sameVerbLed = sameVerbBranches.slice(1).every((bw) => {
+        const blc = bw.map((x) => x.toLowerCase());
+        const vh = findPhrase(blc, VERB_TO_KIND);
+        return vh && vh.start === 0 ? vh.kind === firstVh.kind : !vh;
+      });
+    }
+  }
   // marker gate — the crux of backward-compat: without one of these, this is not a
   // compositional query and we must NOT hijack it from the existing parser.
-  if (!(quals.length || relFlag || membershipLed || gerundLed || boolQualLed)) return null;
+  if (!(quals.length || relFlag || membershipLed || gerundLed || boolQualLed || sameVerbLed)) return null;
 
   // empty predicate → a bare qualified class ("public methods")
   if (!predWords.length) {
     let base = { node: "allOfClass", entityType };
     if (!quals.length) return { node: "miss", reason: "nothing to filter or traverse" };
-    return { node: "qualifier", filters: quals, inner: base };
+    // entityType carried on the qualifier node itself too (not just `inner`) — a
+    // top-level "qualifier" AST has no dedicated evalComposite case, so it falls to
+    // the generic {compositeKind:"set", entityType: ast.entityType||null} catch-all;
+    // without this, a zero-match qualifier query ("public methods of X" with no
+    // public methods) rendered a bare "nothing in the index matches that." with no
+    // entity-kind receipt, same wall-shaped miss as a genuinely unrecognized query.
+    return { node: "qualifier", filters: quals, inner: base, entityType };
   }
 
   const subjPrefix = noun.placeholder ? "what" : `which ${entWord}`;
@@ -1111,7 +1156,9 @@ function parseRelationalOrQualified(w, lc, nlp, depth) {
   } else {
     result = { node: "boolean", entityType, atoms };
   }
-  if (quals.length) result = { node: "qualifier", filters: quals, inner: result };
+  // entityType carried on the qualifier wrapper too — see the identical comment on
+  // the empty-predicate qualifier node above; same catch-all-miss-receipt fix.
+  if (quals.length) result = { node: "qualifier", filters: quals, inner: result, entityType };
   return result;
 }
 
@@ -1537,7 +1584,8 @@ function evalBoolean(graph, ast, opts) {
 function evalAnaphora(graph, ast, opts) {
   const prev = opts && opts.prev;
   if (!Array.isArray(prev) || !prev.length) return { compositeMiss: true, reason: "no-prev", matches: [] };
-  let items = prev.map((id) => graph.byId.get(id)).filter(Boolean);
+  const baseItems = prev.map((id) => graph.byId.get(id)).filter(Boolean);
+  let items = baseItems;
   const f = ast.filter;
   if (f && f.type === "qual") {
     items = items.filter((ind) => f.filters.every((q) => qualHolds(graph, ind, QUALIFIERS[q])));
@@ -1554,7 +1602,14 @@ function evalAnaphora(graph, ast, opts) {
     }
   }
   // a count over a prior set names the entity kind when the survivors share a class.
-  const common = items.length && items.every((x) => x.class === items[0].class) ? items[0].class : null;
+  // When the filter narrows a real prior set down to ZERO, fall back to the PRIOR
+  // set's own class (still shared, pre-filter) so the honest-empty render still
+  // names what was checked ("nothing in the index matches that (methods)."
+  // instead of a bare, kind-less "nothing in the index matches that.") — the
+  // filter genuinely found no survivors, but the entity kind it filtered is not
+  // itself unknown, so the miss shouldn't read as if it were.
+  const sameClass = (list) => (list.length && list.every((x) => x.class === list[0].class) ? list[0].class : null);
+  const common = items.length ? sameClass(items) : sameClass(baseItems);
   if (ast.mode === "count") return { compositeKind: "count", count: items.length, entityType: common, matches: [] };
   return { compositeKind: "set", matches: items, entityType: common };
 }

package/src/chat.mjs

@@ -1266,6 +1266,12 @@ const HAS_PROPERTY_PREDICATE = "mgx:hasProperty";
 // "some/a few Xs are Ys" shape) stay obviously in that same family rather than
 // re-typing the CURIE string at each call site.
 const SUBCLASS_PREDICATE = "rdfs:subClassOf";
+// Bug 3 (2026-07-09): the SAME "has a" predicate ConceptNet's own /r/HasA
+// facts already use (FACT_PREDICATE_PHRASES, conceptnet-map.toml) — named
+// here too so generalVerbTeach's "has"/"have" special case (below) stays
+// obviously in that same family, interoperable with corpus HasA data on the
+// read side, rather than minting a redundant mgx:has.
+const HAS_A_PREDICATE = "mgx:hasA";
 
 /** "<Name> owns/maintains <X>" — the ownership teach declarative. <Name> is one
  *  or two name tokens, <X> one code-ish token (a path, a file, a symbol). The
@@ -1299,7 +1305,7 @@ async function teachFact(memoryDir, sessionId, { subject, predicate, object, qua
       provenance: teachProvenanceTag(sessionId, new Date().toISOString()),
       ...(quantifier ? { quantifier } : {}),
     });
-    const phrase = FACT_PREDICATE_PHRASES[predicate] || predicate;
+    const phrase = predicatePhrase(predicate);
     return { text: `noted — remembered: ${s} ${phrase} ${o}`, via: "assert", miss: false };
   } catch {
     return null;
@@ -1398,6 +1404,111 @@ async function unknownSubjectFallback(payload, { memoryDir, sessionId, lexicon }
   return null; // Y unknown too — decline honestly, never guess
 }
 
+// ---- BUG 3 (2026-07-09, operator-authorized generalizing — "I don't know
+// where that ban came from, overturn it. build it."): general verb-to-
+// predicate teaching. "remember tony has a hat" / "remember margo eats ribs"
+// used to fall straight through teachLane returning null (not even this
+// lane's own honest miss text) because the ONLY verbs the lane recognized at
+// all were is/are (class-membership/property) and owns/maintains
+// (ownership) — a sentence with any OTHER verb never matched a single
+// recognizer, and fell to the STRUCTURAL code-graph grammar, which of course
+// can't resolve an arbitrary proper noun as a code entity (confusing,
+// wrong-context miss text, and sometimes a confidently WRONG "Goal
+// (inferred)" line — runAsk's own teach-lane goal deduction fixes that half).
+//
+// RECOGNITION stays exactly as CLOSED as every other frame in this lane:
+// wrapper-REQUIRED (teachLane only ever calls generalVerbTeach on `wrapped`,
+// i.e. only inside an already "remember/note/…"-triggered payload — a bare
+// "tony has a hat" is never silently reified, same discipline
+// TEACH_PROPERTY_RE already uses), and only a well-formed <subject> <verb>
+// <object> triple matches AT ALL (point 6 — a missing/unparseable object
+// still declines honestly, never a guess). What's generalized is ONLY the
+// PREDICATE a recognized shape maps to, never what counts as a recognized
+// shape — the same "recognition closed, mapping generalized" split the
+// operator explicitly authorized over this dispatch's default "prefer
+// templates" guidance. ----
+
+/** <subject> (ONE bare word — a name, "tony"/"margo") <verb> (one lowercase
+ *  word) <object> (the rest). Deliberately bounded to a SINGLE-TOKEN subject
+ *  with no leading determiner — not the lazy/greedy multi-word subject the
+ *  is/are frames elsewhere in this lane tolerate. Reasoning (found live while
+ *  building this): without real verb-position knowledge, a positional regex
+ *  over an ARBITRARY-length subject is genuinely ambiguous — "every
+ *  controller is a handler" would just as happily (mis)parse as
+ *  subject="every", verb="controller", object="is a handler" as it would the
+ *  intended reading. Bounding the subject to one bare word removes that
+ *  ambiguity for exactly the shape this mechanism targets (a name-like
+ *  subject, per the operator's own examples); a determiner/quantifier-led or
+ *  multi-word subject simply doesn't match here and honestly declines
+ *  (point 6) rather than risk a wrong split — the is/are-specific frames
+ *  elsewhere in this lane already own that broader territory. */
+const GENERAL_VERB_TEACH_RE = /^([\w'-]+)\s+([a-z]+)\s+(.+?)[.!?]*$/i;
+/** Determiners/quantifiers that make the FIRST token an article, not a real
+ *  bare-name subject ("every controller…", "the cache…") — GENERAL_VERB_TEACH_RE
+ *  would otherwise happily bind them as a 1-token subject and misread the
+ *  REAL subject's second word as the verb. Declining here hands the sentence
+ *  back to the is/are-specific frames above/below (their own territory) or an
+ *  honest miss — never a guessed split. */
+const GENERAL_VERB_DETERMINER_RE = /^(?:every|each|all|some|a|an|the|your|my|our|their|his|her|its)$/i;
+/** Verbs owned by an earlier, more specific recognizer in this lane — is/are
+ *  (class-membership/property, above) and owns/maintains (ownership, above).
+ *  generalVerbTeach declines outright on these so it can never race a more
+ *  specific frame for the same sentence; a genuine miss on one of THESE verbs
+ *  stays that frame's own honest miss, never silently reinterpreted here. */
+const GENERAL_VERB_EXCLUDE_RE = /^(?:is|are|am|owns|maintains)$/i;
+/** Whole-payload safety net (defense in depth alongside the single-token
+ *  subject bound above): if "is"/"are"/"am"/"owns"/"maintains" appears
+ *  ANYWHERE in the sentence — not just at the guessed verb position — this
+ *  is territory another frame in this lane already owns (or will, in the
+ *  is/are payload block right after this one runs), so generalVerbTeach
+ *  stands down entirely rather than risk a positional misread of a longer
+ *  copula/ownership sentence it was never meant to parse. */
+const GENERAL_VERB_ANYWHERE_EXCLUDE_RE = /\b(?:is|are|am|owns|maintains)\b/i;
+
+/** The predicate a general-verb teach payload's VERB maps to. "has"/"have"
+ *  special-cases onto the EXISTING mgx:hasA predicate (point 2) — the same
+ *  one ConceptNet's own /r/HasA facts already use (FACT_PREDICATE_PHRASES),
+ *  so a taught "X has a Y" fact reads back interoperably with corpus HasA
+ *  data, rather than minting a redundant mgx:has. Any OTHER verb mints
+ *  mgx:<lemma> (point 3a) — proseLemma, the wink-nlp lemmatiser this
+ *  codebase already loads elsewhere (prose-nlp.mjs), canonicalizes "eats"/
+ *  "ate"/"eating" alike onto the same mgx:eat predicate; when the optional
+ *  wink model isn't installed, proseLemma degrades to null (its own
+ *  documented contract) and this falls back to the verb AS TYPED — still a
+ *  perfectly storable/retrievable predicate, just not cross-inflection
+ *  canonicalized. Never a hand-curated per-verb table entry required. */
+async function generalVerbPredicate(verb) {
+  const v = String(verb || "").toLowerCase();
+  if (v === "has" || v === "have") return HAS_A_PREDICATE;
+  try {
+    const { proseLemma } = await import("./prose-nlp.mjs");
+    const lemma = proseLemma();
+    return `mgx:${lemma ? lemma(v) : v}`;
+  } catch {
+    return `mgx:${v}`;
+  }
+}
+
+/** Recognize + resolve a general-verb teach payload into {subject, predicate,
+ *  object}, or null when it doesn't fit the shape / names an excluded verb /
+ *  is missing a real subject or object (point 6 — an honest decline, never a
+ *  guess). Pure recognition + predicate mapping; the caller (teachLane) does
+ *  the actual write via the shared teachFact. */
+async function generalVerbTeach(payload) {
+  const p = String(payload || "").trim();
+  if (GENERAL_VERB_ANYWHERE_EXCLUDE_RE.test(p)) return null; // another frame's territory — stand down
+  const m = p.match(GENERAL_VERB_TEACH_RE);
+  if (!m) return null;
+  const [, subjectRaw, verbRaw, objectRaw] = m;
+  const verb = verbRaw.toLowerCase();
+  if (GENERAL_VERB_EXCLUDE_RE.test(verb)) return null; // owned by a more specific frame above
+  if (GENERAL_VERB_DETERMINER_RE.test(subjectRaw)) return null; // not a bare-name subject
+  const subject = subjectRaw.trim();
+  const object = objectRaw.replace(/^an?\s+/i, "").trim();
+  if (!subject || !object) return null; // no well-formed triple — honest decline (point 6)
+  const predicate = await generalVerbPredicate(verb);
+  return { subject, predicate, object };
+}
 
 /** Sentence forms to try asserting for a teach payload: the payload as-is, and
  *  (if it carries no determiner) its "every …" universal — the ACE-OWL shape the
@@ -1448,8 +1559,19 @@ function teachSuggestion(payload) {
  *  double as legitimate demonstrative entity references elsewhere in this
  *  file (DESCRIBE_PRONOUN_RE, NEGATION_PRONOUN_RE et al.), and a claim about
  *  a demonstrated entity ("that is a bug", pointing at something real) is a
- *  much closer call than "every you is a womble" — not this bug's territory. */
-const TEACH_PRONOUN_RE = /^(?:every\s+|each\s+|all\s+|some\s+|a few\s+|a\s+|an\s+)?(you|i|it|they|he|she|we)\s+(?:is|are|am)\b/i;
+ *  much closer call than "every you is a womble" — not this bug's territory.
+ *
+ *  WIDENED (Bug 3, 2026-07-09): the verb group used to be the closed
+ *  is/are/am copula set — correct while pronoun subjects could only ever
+ *  reach a class-membership/property claim, but Bug 3's generalVerbTeach
+ *  (below) opens a SECOND way a pronoun subject can reach the store, via ANY
+ *  verb ("remember you has a hat", "remember he eats ribs"). A pronoun is
+ *  just as invalid a fact subject under a general verb as it is under "is" —
+ *  this is a grammatical category error regardless of the verb — so the verb
+ *  slot now matches ANY word, not just the copula three, keeping the guard
+ *  ahead of every teach recognizer (copula AND general-verb alike) the same
+ *  way it already stood ahead of teachSuggestion/unknownSubjectFallback. */
+const TEACH_PRONOUN_RE = /^(?:every\s+|each\s+|all\s+|some\s+|a few\s+|a\s+|an\s+)?(you|i|it|they|he|she|we)\s+\S+/i;
 
 async function teachLane(query, { memoryDir, sessionId = "", lexicon = null }) {
   const rawInput = String(query).trim();
@@ -1522,6 +1644,24 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null }) {
     }
   }
 
+  // GENERAL VERB-TO-PREDICATE TEACH (Bug 3) — "remember <Subject> <verb>
+  // <Object>" where <verb> is neither is/are (handled below via the ACE/
+  // unknown-subject/property paths) nor owns/maintains (handled above).
+  // Wrapper-REQUIRED (`wrapped`, not `raw`) — see generalVerbTeach's own
+  // docblock for why this keeps recognition exactly as closed as every other
+  // frame in this lane. Tried before the is/are `payload` block below so a
+  // non-copula verb never falls through this function returning null with no
+  // miss text at all (the ORIGINAL bug: "remember tony has a hat" never even
+  // reached this lane's own honest-miss cascade, landing on the structural
+  // grammar's wrong-context wall instead).
+  if (wrapped && memoryDir && !QUESTION_LEAD_RE.test(wrapped)) {
+    const gv = await generalVerbTeach(wrapped);
+    if (gv) {
+      const stored = await teachFact(memoryDir, sessionId, gv);
+      if (stored) return stored;
+    }
+  }
+
   let payload = null;
   if (wrapped && /\b(?:is|are)\b/i.test(wrapped)) payload = wrapped;
   else if (BARE_DECLARATIVE_RE.test(raw) && !QUESTION_LEAD_RE.test(raw)) payload = raw;
@@ -2241,7 +2381,33 @@ const FACT_PREDICATE_PHRASES = {
   "mgx:hasPrerequisite": "requires",
   "mgx:ownedBy": "is owned by", // the teach lane's ownership frame ("Priya owns tasks.mjs")
 };
-const factPhrase = (f) => `${f.subject} ${FACT_PREDICATE_PHRASES[f.predicate] || f.predicate} ${f.object}`;
+
+/** Bug 3 (2026-07-09) point 3b: the MECHANICAL fallback for a predicate this
+ *  table has no curated entry for — specifically generalVerbTeach's minted
+ *  "mgx:<lemma>" predicates ("mgx:eat", "mgx:drive", …), which by design have
+ *  no per-verb table row (that would be the anti-pattern the operator's
+ *  dispatch explicitly called out to avoid). Reconstructs the naive third-
+ *  person-singular surface form so "margo mgx:eat ribs" still renders as the
+ *  natural "margo eats ribs" — the mechanical INVERSE of singularizeSurface's
+ *  own naive -s/-es/-ies fold used elsewhere in this file, same accepted-
+ *  limitation trade (no real morphology; a handful of doubly-irregular verbs
+ *  render slightly off but never wrong-MEANING). "has"/"have" never reach
+ *  this fallback — generalVerbPredicate special-cases them onto the CURATED
+ *  mgx:hasA entry above before a predicate is ever minted. Any OTHER unknown
+ *  predicate (not the "mgx:<lemma>" shape — e.g. a stray/foreign CURIE) still
+ *  renders verbatim, unchanged from before this fix. */
+function thirdPersonSingularSurface(lemma) {
+  const w = String(lemma || "");
+  if (/[a-z]y$/i.test(w) && !/[aeiou]y$/i.test(w)) return `${w.slice(0, -1)}ies`;
+  if (/(?:s|x|z|ch|sh|o)$/i.test(w)) return `${w}es`;
+  return `${w}s`;
+}
+function predicatePhrase(predicate) {
+  if (FACT_PREDICATE_PHRASES[predicate]) return FACT_PREDICATE_PHRASES[predicate];
+  const m = /^mgx:([a-z]+)$/i.exec(String(predicate || ""));
+  return m ? thirdPersonSingularSurface(m[1]) : predicate;
+}
+const factPhrase = (f) => `${f.subject} ${predicatePhrase(f.predicate)} ${f.object}`;
 
 // ---- BUG 1 fix (2026-07-08): "what is a tree used for" filters to JUST the
 // UsedFor facts, instead of grammar.mjs's meta-whatis template's lazy tail
@@ -2458,10 +2624,12 @@ async function factAnswer(memoryDir, query, envelope, miss) {
   // alongside the schema-docs answer) and misses (facts answer alone) alike.
   // When the engine produced NO parse at all (the empty-bootstrap graph
   // short-circuits before parsing), the meta FORM is recognized directly on a
-  // miss — same required-article discipline as the grammar's own T5 template.
+  // miss — via BARE_WHATIS_RE (chat.mjs's own fact-lookup discipline, article
+  // OPTIONAL — see that regex's docblock for why this is safe to loosen here
+  // even though the structural grammar's T5 keeps the article mandatory).
   let metaTerm = envelope?.parsed?.shape === "meta" ? envelope.parsed.object : null;
   if (!metaTerm && miss && !envelope?.parsed) {
-    const m = q.match(/^what\s+(?:is|are)\s+an?\s+(.+?)[?.!\s]*$/i)
+    const m = q.match(BARE_WHATIS_RE)
       || q.match(/^what\s+(?:does|do)\s+(.+?)\s+means?[?.!\s]*$/i);
     if (m) metaTerm = m[1];
   }
@@ -2527,6 +2695,83 @@ async function factAnswer(memoryDir, query, envelope, miss) {
   return null;
 }
 
+// ---- BUG 1 fix (2026-07-09): "what else is X" repeated the SAME primary
+// definition sentence verbatim, byte-identical to a plain "what is X" turn
+// right before it. Root cause: "what else is a function" is NOT itself a
+// recognized shape anywhere in this file — ask()'s own relaxation cascade
+// (relaxParse, ask.mjs: NOISE-STRIP then DROP-UNMATCHED) quietly treats
+// "else" as an unmatched leftover token once the anchored grammar misses the
+// sentence as typed, drops it, and re-parses the survivor as the ORDINARY
+// "what is a function" meta shape — a real, non-miss answer, so relaxParse
+// happily accepts it. By the time curatedDefinitionAnswer/factAnswer see the
+// query, "else" is already gone and there is nothing left to distinguish a
+// follow-up asking for MORE from the original question. whatElseAnswer is
+// recognized FIRST, off the RAW query text (never the relaxed envelope), so
+// it always gets first look regardless of what the ask engine's own parse
+// collapsed the sentence to. ----
+
+/** "what else is/are X" / "what else about X" / "what else do you know about
+ *  X" — the follow-up shape asking for information BEYOND whatever the
+ *  primary answer already said. Two separate anchors (not one alternation)
+ *  because the "is/are" copula form and the "about" form take the article
+ *  differently ("what else is a function" vs "what else about the cache").
+ *  The negative lookahead on the "is/are" form excludes "what else is
+ *  in/inside X" — that's a DIFFERENT, already-working feature (normalize.mjs
+ *  PHRASING_FRAMES rewrites it to "what does X contain", a members-of-class
+ *  query, tested by chatflow-tier1-single-touch.test.mjs); without this
+ *  exclusion this lane's own raw-text-first priority (it runs BEFORE ask()'s
+ *  pipeline even gets a look) would wrongly swallow that idiom as a
+ *  vocabulary-term lookup for the literal term "in X". */
+const WHAT_ELSE_IS_RE = /^what\s+else\s+(?:is|are)\s+(?!in\b|inside\b)(?:an?\s+)?(.+?)[?.!\s]*$/i;
+const WHAT_ELSE_ABOUT_RE = /^what\s+else\s+(?:do\s+you\s+know\s+)?about\s+(?:an?\s+|the\s+)?(.+?)[?.!\s]*$/i;
+
+/** "what else is X" — surface remembered facts about X BEYOND the primary
+ *  curated (corpus/seon) prose definition, which is itself never a Facts row
+ *  (it comes from a separate prose file, seonDefinitions() — see
+ *  curatedDefinitionAnswer) — so every subject-side fact this returns is
+ *  genuinely additional information, never a repeat of the definition
+ *  sentence. Reuses factAnswer's own subject-scan machinery (memoryFacts +
+ *  factTermVariants + renderFactLine + the SAME FACT_ANSWER_CAP/'more'-paging
+ *  convention as factAnswer/factReadBack), just filtered/framed differently.
+ *
+ *  Honest "nothing more" fallback (never a spurious repeat) in TWO cases: (a)
+ *  the term carries no facts at all — there is nothing to add beyond the
+ *  definition; (b) every fact line this would show ALREADY appears verbatim
+ *  in the immediately-preceding turn's answer (`last.answer`) — meaning the
+ *  primary answer was itself an exhaustive fact listing (via:"fact", not a
+ *  curated prose definition), so "what else" truly has nothing new to say.
+ *  That second check reuses this codebase's own established repeat-detection
+ *  discipline (comparing rendered lines against `last.answer` bytes — see
+ *  ORIENTATION_REPEAT_ONELINER/WALL_REPEAT_ONELINER for the same pattern). */
+async function whatElseAnswer(memoryDir, query, last) {
+  if (!memoryDir) return null;
+  const q = String(query).trim();
+  const m = q.match(WHAT_ELSE_IS_RE) || q.match(WHAT_ELSE_ABOUT_RE);
+  if (!m) return null;
+  const term = m[1].trim();
+  if (!term) return null;
+  let normFactTerm;
+  try { ({ normFactTerm } = await import("./memory/core.mjs")); } catch { return null; }
+  const variants = factTermVariants(normFactTerm, term);
+  const hits = (await memoryFacts(memoryDir)).filter((f) => variants.has(f.subject));
+  const nothingMore = {
+    text: `That's everything I know about "${term}" — /memory to see the full picture.`,
+    replace: true,
+  };
+  if (!hits.length) return nothingMore;
+  const lines = hits.map(renderFactLine);
+  const prevAnswer = String(last?.answer || "");
+  if (lines.every((l) => prevAnswer.includes(l))) return nothingMore;
+  const shown = lines.slice(0, FACT_ANSWER_CAP);
+  const rest = lines.slice(FACT_ANSWER_CAP);
+  const extra = rest.length ? `\n…and ${rest.length} more — say 'more' to see them.` : "";
+  return {
+    text: `Beyond that, here's what else I know about "${term}":\n${shown.join("\n")}${extra}`,
+    replace: true,
+    ...(rest.length ? { pending: { items: rest, noun: "facts" } } : {}),
+  };
+}
+
 /** Ontology plan tracks (a)+(b) (PLAN_ontology-hierarchies.md §3): a LAST-
  *  RESORT query-time synonym expansion for a "what is a X"-shaped term with NO
  *  direct facts. Deliberately run where the caller runs it (runAsk, after
@@ -3058,13 +3303,34 @@ function relationDefinitions() {
   return seonRelsPromise;
 }
 
-/** The meta term a "what is a X" / "what does X mean" / "define X" question asks
- *  about — from the parse when present, else recognized directly (same required-
- *  article discipline as the grammar's T5). Null when the line isn't such a form. */
+/** BUG 2 fix (2026-07-09): "what is a/an <term>" with the article made OPTIONAL,
+ *  for the FACT-LOOKUP path only (metaTermOf/factAnswer's own bare-form fallback)
+ *  — NOT grammar.mjs's structural T5 template, which keeps its article MANDATORY
+ *  on purpose (a bare "what is <anything>" would also swallow "what is the
+ *  meaning of this codebase", an existing, deliberately honest grammar-miss
+ *  regression — test/ask.test.mjs pins it null; see T5's own docblock). That
+ *  collision risk is a STRUCTURAL-PARSE concern (T5's tail becomes the literal
+ *  graph-query object); it doesn't apply here: this regex only extracts a
+ *  SUBJECT STRING to look up against the memory Facts store / curated lexicon —
+ *  a miss (no fact, no lexicon entry) is silently absorbed by the caller and
+ *  falls through to the ordinary honest-miss cascade, exactly like today's
+ *  mandatory-article miss does. Root cause this fixes: "what is john" (no
+ *  article) never matched the old mandatory-article regex at all, so a freshly
+ *  taught "john rdfs:subClassOf function" fact was invisible to "what is john"
+ *  even though "what is a john" (or "what is john used for") would have found
+ *  it — the fact-lookup path is a low-collision subject lookup, not a structural
+ *  parse, so loosening it here is safe. */
+const BARE_WHATIS_RE = /^what\s+(?:is|are)\s+(?:an?\s+)?(.+?)[?.!\s]*$/i;
+
+/** The meta term a "what is a X" / "what is X" / "what does X mean" / "define X"
+ *  question asks about — from the parse when present, else recognized directly
+ *  via BARE_WHATIS_RE (article optional — see its own docblock for why that's
+ *  safe here even though the grammar's own T5 keeps the article mandatory).
+ *  Null when the line isn't such a form. */
 function metaTermOf(query, envelope) {
   if (envelope?.parsed?.shape === "meta" && envelope.parsed.object) return envelope.parsed.object;
   const q = String(query).trim();
-  const m = q.match(/^what\s+(?:is|are)\s+an?\s+(.+?)[?.!\s]*$/i)
+  const m = q.match(BARE_WHATIS_RE)
     || q.match(/^what\s+(?:does|do)\s+(?:an?\s+)?(.+?)\s+means?[?.!\s]*$/i)
     || q.match(/^define\s+(?:an?\s+)?(.+?)[?.!\s]*$/i);
   return m ? m[1].trim() : null;
@@ -3603,6 +3869,27 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
   // facts/recall (a fact EXTENDS a non-miss schema hit too — NOT miss-gated),
   // (4) TEACH lane (would-miss), (5) the short tailored miss (would-miss).
   let handled = false;
+  // (0) BUG 1 fix (2026-07-09): "what else is X" — recognized off the RAW
+  // query text, before every other lane below (all of which read `envelope`,
+  // already relaxed/reparsed by ask()'s own noise-strip cascade — "else" is
+  // exactly the kind of unmatched token that cascade silently drops, which is
+  // why a plain factAnswer/curatedDefinitionAnswer lookup used to answer
+  // "what else is X" with the byte-identical primary definition, as if
+  // repeating it were new information). via is set to a value NONE of the
+  // downstream `via === "composed"/"fact"/"corpus/seon"` gates match, so a
+  // hit here is final — curatedDefinitionAnswer/conceptForceAnswer never get
+  // a chance to re-answer with the same primary definition afterward.
+  if (memoryDir) {
+    const whatElse = await whatElseAnswer(memoryDir, query, last);
+    if (whatElse) {
+      answer = whatElse.text; via = "fact:what-else"; recordMiss = false; handled = true;
+      if (whatElse.pending) factPending = whatElse.pending;
+      deduced = "surface additional remembered facts beyond the primary definition";
+      note(trace, "lane: (0) WHAT ELSE — \"what else is/about X\" recognized off the raw query, before the relaxation cascade could quietly drop \"else\" and reduce it to a plain \"what is X\"");
+      note(trace, "source: .tmct/memory Facts (see /memory for provenance per line)");
+      note(trace, `goal: ${deduced} (revised — the raw \"what else\" phrasing was recognized directly, not the relaxed/reparsed envelope)`);
+    }
+  }
   // (1) #2 META/SELF: bare self/session questions ("what do you know", "what is this
   // 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.
@@ -3702,7 +3989,37 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
       } catch { /* leave false — the ordinary path decides */ }
     }
   }
-  if (!handled && miss && !envelope?.parsed && isConversational(query) && !isWhatAboutContinuation && !isDescribePronounContinuation && !isExplainTouch && !isStaccatoNegation && !isVagueRelationTouch && !isStaccatoComparative && !isStaccatoPronounNoFocus) {
+  const isConversationalCandidate = !handled && miss && !envelope?.parsed && isConversational(query) && !isWhatAboutContinuation && !isDescribePronounContinuation && !isExplainTouch && !isStaccatoNegation && !isVagueRelationTouch && !isStaccatoComparative && !isStaccatoPronounNoFocus;
+  // BUG 2 fix (2026-07-09): "what is X" with NO article ("what is john") is BOTH
+  // conversational-shaped (≤3 words, no code-ish token — isConversational() would
+  // claim it) AND a legitimate bare meta/fact-lookup form (BARE_WHATIS_RE —
+  // metaTermOf's own docblock explains why the article is safe to make optional on
+  // this fact-lookup path specifically). Root cause: grammar.mjs's T5 template
+  // requires the article, so envelope.parsed stays null for the bare form — which
+  // is exactly isConversationalCandidate's own `!envelope?.parsed` gate — so
+  // isConversational used to win the race unconditionally, and a freshly taught
+  // "john is a function" fact became invisible the moment its own subject was
+  // asked back about bare ("what is john" fell to the generic capability-
+  // orientation card, byte-identical to asking about a term tmct had never heard
+  // of). Diverts ONLY when a REAL fact actually resolves for the bare term —
+  // never a speculative reroute: a bare "what is up"/"what is wrong" with nothing
+  // behind it falls straight through to the SAME orientation card as before,
+  // exactly like every other isConversationalCandidate exemption above (each one
+  // guarantees a real answer before it defers, never stranding the turn on a
+  // worse outcome — see isStaccatoPronounNoFocus's own docblock for the same
+  // discipline).
+  let bareMetaHit = null;
+  if (isConversationalCandidate && memoryDir && BARE_WHATIS_RE.test(String(query).trim())) {
+    bareMetaHit = (await factAnswer(memoryDir, query, envelope, miss))
+      ?? (await factReadBack(memoryDir, query, envelope, miss, graph));
+  }
+  if (bareMetaHit) {
+    answer = bareMetaHit.replace ? bareMetaHit.text : `${answer}\n${bareMetaHit.text}`;
+    via = "fact"; recordMiss = false; handled = true;
+    if (bareMetaHit.pending) factPending = bareMetaHit.pending;
+    note(trace, "lane: (2b) BARE META FACT — \"what is X\" (no article) resolved to a remembered fact before the conversational catch-all could claim it");
+    note(trace, "source: .tmct/memory Facts (see /memory for provenance per line)");
+  } else if (isConversationalCandidate) {
     // A conversational miss (a greeting, "what can you do", a very short non-code
     // line) gets the friendly orientation (module-aware: empty → --repo/tmct init).
     // Bug B1 (0.8.2 follow-up): this branch carries via:"template" and never
@@ -3861,7 +4178,21 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
     if (taught) {
       answer = taught.text; via = taught.via; recordMiss = taught.miss;
       note(trace, `lane: (4) TEACH — TEACH_RE/OWNS_TEACH_RE/BARE_DECLARATIVE_RE matched, ${taught.miss ? "but the payload could not be stored" : "reified into .tmct/memory"}`);
-      note(trace, "goal: teach/remember a new fact");
+      // Goal-line fix (Bug 3 point 4, 2026-07-09): `deduced` was computed WAY
+      // above, straight off envelope.parsed alone (deduceGoalFromParsed) —
+      // the structural grammar has no business parsing a teach-shaped
+      // sentence at all ("remember tony has a hat" isn't a code-graph
+      // question), so whatever it landed on there was either confidently
+      // WRONG (a stray structural template matched part of the sentence and
+      // deduced an unrelated GOAL_BY_KIND entry, e.g. "locate what a
+      // module/class defines") or silently absent (no parse stood). Every
+      // successfully-RECOGNIZED teach attempt (`taught` stood — whether it
+      // went on to STORE or to its own honest teach-miss text) gets the SAME
+      // honest, consistent goal line here instead — the same "revise off the
+      // LANE that actually answered, not the raw structural parse"
+      // discipline the relation-force fix above already uses.
+      deduced = "teach/remember a new fact";
+      note(trace, `goal: ${deduced} (revised — the teach lane recognized this shape where the raw structural parse never should have)`);
     }
   }
   // (4b) #4 AUTHOR lane (0.8.2 WS4) — "who is <Name>", "what did <Name> touch",