@polycode-projects/the-mechanical-code-talker 1.8.14 → 1.8.15

package/README.md

@@ -79,6 +79,12 @@ the connecting sentence itself, citing both sources. The `source: ace:chat:…`
 part is a real provenance receipt. Every fact tmct stores records where it
 came from and when (more on that below).
 
+The first `tell()` call above replies too: `noted — remembered 1 fact:
+controller rdfs:subClassOf handler (controller is a type of handler)`. The
+part in parentheses is a paraphrase. tmct generates it and checks it against
+its own inference rules before showing it, so it never just guesses at
+prose.
+
 ```
 $ tmct
 tmct> what talks to the payment module?
@@ -188,6 +194,23 @@ exactly. It checks the type itself and its subclasses first. Only if nothing
 matches there does it widen to a related type, and when it does, it says so
 plainly rather than presenting the looser match as exact.
 
+**Comparing two things.** "compare TaskController and UserController" or "how
+is TaskController different from UserController" lines up both entities'
+shared and differing edges side by side: *"Comparing TaskController and
+UserController (both Class): inherits [seon:hasSuperType]: TaskController (1)
+-> Controller; UserController (1) -> Controller"*. Every row is a real edge
+or attribute from the graph, never a hand-written diff.
+
+**Up-refining to a containing module.** A class rarely has its own
+symbol-precise commit or import record. "who touched TaskController" answers
+from its containing module's real history instead of a confident-looking but
+wrong "nothing touched it".
+
+**Following a list.** tmct remembers the last list it gave you. After
+"which modules import src/core/model.mjs", "which of those are tested" or
+"how many of those" resolves "those"/"them" against that list, not a fresh,
+unresolved pronoun.
+
 **Synonyms and everyday phrasing.** tmct matches many of the words people
 actually use for the same idea, from a curated synonym list plus a filtered
 ConceptNet slice. A slightly different word for the same concept still
@@ -242,6 +265,11 @@ longer, multi-sentence account instead of one line. Every sentence in it is
 lifted from a real graph edge, attribute, or taught fact — never generated
 free text.
 
+The wording varies a little too. A small, curated, deterministic pool swaps a
+handful of connector words, like "defined in", "located in", or "found in".
+The same fact doesn't read identically for every entity, but the same
+question against the same entity always renders the same way.
+
 ```
 $ node bin/tmct.mjs chat --repo examples/mini-webapp --ephemeral
 tmct> give me a detailed overview of how the Store works
@@ -314,8 +342,8 @@ from the environment. There's no CLI flag yet — this is a library-level
 option for now, newer and less exercised than the default backend.
 
 Teaching isn't limited to the ACE grammar's fixed shapes. Tell tmct an
-arbitrary fact, like "margo eats ribs", and it mints a fact you can later ask
-about directly: "what does margo eat", or "does margo eat ribs".
+arbitrary fact, like "margo really eats ribs", and it mints a fact you can
+later ask about directly: "what does margo eat", or "does margo eat ribs".
 
 New vocabulary compounds as you teach it. "redis is a cache" mints "redis" as
 a class-level concept even though it was never in the built-in lexicon, and a
@@ -326,6 +354,10 @@ to ground one side first. Quantified teaching works too: "some functions are
 risky" stores the quantifier, and a later "how many functions are risky"
 answers "A few."
 
+Once you've taught a few facts, "how many facts are there" counts them back.
+That's the same count phrasing a code graph answers "how many classes are
+there" with, just now reading tmct's own memory.
+
 ### Provenance and trust
 
 Every fact and text block records **where it came from and when**. Sources are

package/package.json

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

package/src/chat.mjs

@@ -4879,6 +4879,34 @@ const HAS_METHOD_OPEN_RE = /^what\s+methods\s+does\s+([\w'-]+)\s+have[?.!\s]*$/i
  *  cascade/orientation nudge that already handles it. */
 const IS_ADJECTIVE_YESNO_RE = /^(?:is|are|was|were)\s+(.+?)\s+([A-Za-z][\w-]*)[?.!\s]*$/i;
 const IS_ADJECTIVE_PRONOUN_RE = /^(?:it|this|that)$/i;
+/** BENCHMARK_CONVERSATION_1.8.14.md persona-sweep (2026-07-12), highest cross-
+ *  persona signal in the run (4 independent personas): IS_ADJECTIVE_YESNO_RE's
+ *  subject capture is unbounded/unrestricted (see its own docblock above), so
+ *  a pronoun-subject IDENTITY question ("are you happy", "are you like
+ *  chatgpt", "are you secretly ChatGPT or GPT-4") backtracks the pronoun
+ *  itself (plus any trailing filler word up to the last token) into the
+ *  SUBJECT capture — factReadBack then treats "you"/"you like"/"you secretly
+ *  chatgpt or" as a literal fact subject and offers to teach a fact ABOUT the
+ *  pronoun ("remember that you is happy"), exactly the grammatical category
+ *  error TEACH_PRONOUN_RE (above, chat.mjs:2648) was already built to reject
+ *  on the teach-lane side. Same pronoun set (you|i|they|he|she|we) reused
+ *  here, checked at the START of the subject capture only (not anchored to
+ *  the whole capture — a pronoun subject can carry trailing words, "you
+ *  like"/"you secretly … or", the same way TEACH_PRONOUN_RE's own `\s+\S+`
+ *  tail allows). "it" is deliberately EXCLUDED from this set, unlike
+ *  TEACH_PRONOUN_RE — IS_ADJECTIVE_PRONOUN_RE (just above) already gives "it"
+ *  its own correct, wanted behavior (anaphoric resolution against the
+ *  session's current FOCUS, "is it deprecated" → resolves off focusLabel),
+ *  which this guard must not shadow. Every call site below is expected to
+ *  test rawSubject (post-trim, pre-lowercasing) against this BEFORE treating
+ *  the match as a fact-subject candidate, and to fall through (never offer
+ *  unknownAdjectiveOffer, never attempt a fact lookup) on a hit — the same
+ *  "decline, don't misroute" discipline the rest of this reader already
+ *  follows for an honest miss, letting the query continue to whatever
+ *  handles identity/small-talk questions (isConversational's IDENTITY_PHRASES/
+ *  AI_IDENTITY_PHRASES/FEELINGS_PHRASES closed sets, or its own ≤3-word
+ *  catch-all) instead. */
+const IS_ADJECTIVE_YESNO_PRONOUN_SUBJECT_RE = /^(?:you|i|they|he|she|we)\b/i;
 /** The TEACH-OFFER for a subject IS_ADJECTIVE_YESNO_RE resolved but has no
  *  fact about at all (Tier-5 playtest, cycle 2) — the offered "remember that
  *  X is Y" phrasing is verified in-state: TEACH_PROPERTY_RE's own subject
@@ -5050,7 +5078,17 @@ async function factReadBack(memoryDir, query, envelope, miss, graph = null, focu
         // already stood; "is the checkout flow deprecated" (this branch's own
         // ORIGINAL T8 target — "deprecated" has no structural meaning at all)
         // has no envelope.parsed to defer to, so it is untouched.
-        if (subject && !/^there\b/i.test(subject) && !envelope?.parsed) {
+        // Pronoun-subject guard (BENCHMARK_CONVERSATION_1.8.14.md persona-sweep,
+        // 2026-07-12) — see IS_ADJECTIVE_YESNO_PRONOUN_SUBJECT_RE's own docblock
+        // above IS_ADJECTIVE_YESNO_RE: "are you happy"/"are you like chatgpt"
+        // backtrack a pronoun subject in here exactly like any other adjective
+        // subject, so without this check unknownAdjectiveOffer would wrongly
+        // offer to teach a fact about the literal pronoun. Checked on rawSubject
+        // (before the IS_ADJECTIVE_PRONOUN_RE focus-resolution swap above, which
+        // only ever fires for "it"/"this"/"that" — never a personal pronoun like
+        // "you", so `subject` itself would already carry the pronoun verbatim).
+        if (subject && !/^there\b/i.test(subject) && !envelope?.parsed
+          && !IS_ADJECTIVE_YESNO_PRONOUN_SUBJECT_RE.test(rawSubject)) {
           return unknownAdjectiveOffer(subject, emptyIsAdj[2].trim().toLowerCase());
         }
       }
@@ -5816,7 +5854,18 @@ async function factReadBack(memoryDir, query, envelope, miss, graph = null, focu
   const isAdj = qHedge.match(IS_ADJECTIVE_YESNO_RE);
   if (isAdj) {
     const rawSubject = isAdj[1].trim();
-    const subject = IS_ADJECTIVE_PRONOUN_RE.test(rawSubject) ? (focusLabel || null) : rawSubject;
+    // Pronoun-subject guard (BENCHMARK_CONVERSATION_1.8.14.md persona-sweep,
+    // 2026-07-12) — see IS_ADJECTIVE_YESNO_PRONOUN_SUBJECT_RE's own docblock
+    // above IS_ADJECTIVE_YESNO_RE: "are you happy"/"are you like chatgpt"/
+    // "are you secretly ChatGPT or GPT-4" backtrack a personal-pronoun
+    // subject in here just like any other adjective subject. Forcing
+    // `subject` to null (the SAME "nothing to resolve" shape a bare "it"/
+    // "this"/"that" with no standing focus already produces just below) lets
+    // this whole reader decline HONESTLY — no fact lookup, no teach-offer —
+    // and fall through to whatever handles identity/small-talk questions
+    // instead, rather than special-casing a return here.
+    const subject = IS_ADJECTIVE_YESNO_PRONOUN_SUBJECT_RE.test(rawSubject) ? null
+      : IS_ADJECTIVE_PRONOUN_RE.test(rawSubject) ? (focusLabel || null) : rawSubject;
     const adjective = isAdj[2].trim().toLowerCase();
     if (subject) {
       const subjVariants = factTermVariants(normFactTerm, subject);