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

package/README.md

@@ -18,12 +18,12 @@ tmct> /exit
 ```
 
 **[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
+is 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
 
-Every message runs through **multiple concurrent interpretation strategies** —
+Every message runs through **multiple concurrent interpretation strategies**:
 a grammar parse, keyword picking, noise-word removal, fuzzy matching. Their
 results are grouped by class:
 
@@ -32,10 +32,20 @@ results are grouped by class:
   *"if you mean X then …"* so ambiguity is shown, never silently resolved.
 
 One of the strategies is an **ACE-inspired controlled grammar**: when your
-text fits the controlled fragment, tmct emits OWL-labelled triples from it —
-statements it can store, retrieve, and answer from later. Text that doesn't
-fit the grammar still gets the tolerant strategies; nothing is rejected for
-being loose, fuzzy, or misspelled.
+text fits the controlled fragment, tmct emits OWL-labelled triples from it.
+Those triples are statements it can store, retrieve, and answer from later.
+Text that doesn't fit the grammar still gets the tolerant strategies; nothing
+is rejected for being loose, fuzzy, or misspelled.
+
+**Everyday question shapes.** Bare "what is Commit" (no article) now resolves
+like "what is a commit" for tmct's own vocabulary. "What's model.mjs for" and
+"what's model.mjs about" answer like "what does model.mjs do". "Is Base a
+superclass of Widget" is read as the reverse of "is Widget a subclass of
+Base", the same relationship either way round. "Recent commits" and "the last
+commit" resolve to real dated history, not a literal string miss. Polite or
+indirect framing reaches the same capability as a direct request: "I'd like
+you to remember X" teaches like bare "remember X"; "please tell me about X"
+and "search for X" describe and find exactly as their direct forms do.
 
 **Negation and passive.** "Which modules do *not* import X?" computes a bounded
 **set complement** over the graph, and an honestly empty result stays a miss
@@ -59,36 +69,41 @@ breaks"). It flags a question whose premise doesn't hold, too: "why does X
 still import Y" when it no longer does.
 
 **Response finishing.** Before an answer is printed it is segmented into typed
-spans — prose versus *protected* entities, paths, numbers, code, provenance, and
-receipts — and a small data-driven grammar pass runs on the prose spans only,
+spans: prose versus *protected* entities, paths, numbers, code, provenance, and
+receipts. A small data-driven grammar pass then runs on the prose spans only,
 under a guard that proves the protected spans came through byte-for-byte. Today
 that pass fixes the a/an article defect; broader voice and agreement rules are
 implemented but parked until they earn their place on the benchmark.
 
+A frozen regression suite plays out full multi-turn dialogues built from these
+phrasings, at every complexity level this project defines, from a single
+question up to a messy, typo-ridden real user. Tier-by-tier detail is in
+`HANDOVER.md` and `ROADMAP.md`.
+
 ## How it guides you
 
-When you touch a **concept** without asking a precise question — "what is a
-class", "what about imports", "what calls are there" — tmct answers in three
+When you touch a **concept** without asking a precise question, like "what is a
+class", "what about imports", or "what calls are there", tmct answers in three
 bands instead of dead-ending:
 
 1. the **definition** (a plain-English one-liner: *"A class is a template that
    defines the structure and behaviour of objects."* / *"To import is to bring
    another module's definitions into the current one."*);
-2. **real instances from your graph** — *"In this codebase, for example: Record,
+2. **real instances from your graph**: *"In this codebase, for example: Record,
    Task and User (10 classes)"*, or actual edges *"src/core/store.mjs imports
    src/core/model.mjs (18 import edges)"*;
-3. **guided follow-ups** — two or three concrete next questions, each one
+3. **guided follow-ups**: two or three concrete next questions, each one
    *pre-checked against your graph* so every suggestion is guaranteed to resolve:
    *"Want to go deeper? Try: which classes inherit from Record / what does Task
    contain / where is User defined"*.
 
 It fires for both **noun** concepts (class, module, function, method) and
-**relation** concepts (imports, calls, contains, inherits, tests), and only when
-tmct genuinely knows the concept *and* has instances of it — otherwise the honest
-miss stands. The effect is a conversation that drills down from a vague opener to
-a useful answer without ever hitting a wall. Natural phrasings are routed to the
-capability you meant: *"what functions are in Task"* → its members, *"what
-defined saveStore"* → where it's defined.
+**relation** concepts (imports, calls, contains, inherits, tests), and only
+when tmct genuinely knows the concept *and* has instances of it. Otherwise the
+honest miss stands. The effect is a conversation that drills down from a vague
+opener to a useful answer without ever hitting a wall. Natural phrasings are
+routed to the capability you meant: *"what functions are in Task"* → its
+members, *"what defined saveStore"* → where it's defined.
 
 ## How it remembers
 
@@ -100,22 +115,26 @@ by cleaned session logs:
 - **text blocks under a PageRank-style index**, pulled into context on
   relevance rather than loaded wholesale.
 
-With no graph at all, tmct starts empty and remembers what you tell it — the
+With no graph at all, tmct starts empty and remembers what you tell it. The
 `.tmct/` graph is created from the conversation. On a first run it seeds the
 committed vocabulary so it knows what it's talking about from turn one: a curated
 **SEON** software ontology plus the whole filtered **ConceptNet slice**
-(CC-BY-SA 4.0) — every term carries an English definition, so "what is a cache?"
+(CC-BY-SA 4.0). Every term carries an English definition, so "what is a cache?"
 answers offline, from disk, on turn one. `--ephemeral` (used by the shipped
 `npm run example:*` demos) reads a graph but writes nothing back.
 
+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".
+
 ### Provenance and trust
 
 Every fact and text block records **where it came from and when**. Sources are
-first-class individuals — operator chat, a curated corpus, a provider graph, a
-web scrape, a rule-derived entailment — and a fact links back to *all* of them
+first-class individuals: operator chat, a curated corpus, a provider graph, a
+web scrape, a rule-derived entailment. A fact links back to *all* of them
 (`mgx:derivedFrom` / `mgx:statedBy` / `mgx:canonicalisedFrom`), timestamped with
 `mgx:createdAt`. From those links tmct computes a **deterministic, explainable
-trust score** — a source-type prior combined with corroboration (how many
+trust score**: a source-type prior combined with corroboration (how many
 independent sources agree) and recency. It is never hand-set, always traceable
 to its inputs. Retrieval then ranks by **relevance × trust**, so a corroborated,
 operator-stated fact outranks a lone web scrape on the same question. When two
@@ -126,7 +145,7 @@ provenance** rather than silently picking a winner.
 
 `tmct syllogise [--depth n] [--budget n]` is an offline, bounded, deterministic
 batch that forward-chains the memory's `rdfs:subClassOf` closure into new
-**entailed** facts — pre-deriving what the trusted sources already imply. It runs
+**entailed** facts, pre-deriving what the trusted sources already imply. It runs
 once automatically after seeding and on demand; the entailed facts are
 **low-trust and retractable** (never outranking a stated fact) and this never runs
 on the chat's hot path.
@@ -140,9 +159,9 @@ on the chat's hot path.
   *calculation* surfaced as prose ("there are a lot of tests for a codebase of
   that size"). It is deterministic, explainable, and cheap. Even its forward-chaining
   entailment (`tmct syllogise`) is mechanical OWL rule materialization applied
-  offline, rule-by-rule and retractable — not an LLM. There is **no LLM anywhere
+  offline, rule-by-rule and retractable, not an LLM. There is **no LLM anywhere
   in the product**. (An LLM-as-judge exists only in the offline eval harness
-  that tunes tmct — see `SKILL_TUNING_CYCLE.md` — never in the product path.)
+  that tunes tmct, see `SKILL_TUNING_CYCLE.md`, never in the product path.)
 - **It never guesses silently.** When it cannot resolve your question it says
   so and nudges you toward a query it *can* answer.
 
@@ -162,7 +181,7 @@ Inside the chat: `/help` lists commands, `/memory` inspects what tmct remembers
 
 `tmct init` is the onboarding surface for the repository interface below: it
 creates the `.tmct/` directory, writes the externalized `tmct.toml`
-configuration, seeds the tier-1 corpus, and records provenance — a host package
+configuration, seeds the tier-1 corpus, and records provenance. A host package
 or a bare user gets a working install in one command.
 
 > Install-size note: tmct depends on wink-nlp's deterministic English language
@@ -170,7 +189,7 @@ or a bare user gets a working install in one command.
 
 ### Try it on an example graph
 
-tmct *consumes* a code graph at `<repo>/.tmct/graph.json` — it does not build
+tmct *consumes* a code graph at `<repo>/.tmct/graph.json`; it does not build
 one. Two ready-made example graphs ship in `examples/` so you can see it answer
 real questions with no setup:
 
@@ -190,7 +209,7 @@ which modules import src/core/model.mjs
 what tests cover src/handlers/tasks.mjs
 ```
 
-The **polyglot** graph shows the language-neutral idea — Java, Python and C#
+The **polyglot** graph shows the language-neutral idea: Java, Python and C#
 entities all typed to the same `seon:Class` / `seon:Method` / `seon:Module`
 concepts, so one query reasons across every language at once:
 
@@ -254,9 +273,9 @@ naming, license, and memory model were reset to the vision above. See
 
 **MPL-2.0.** Free for commercial use; if you modify the covered files and
 distribute them, you must publish those files' source under the MPL with
-attribution — the copyleft is file-level, not project-level. See `LICENSE`.
+attribution. The copyleft is file-level, not project-level. See `LICENSE`.
 
-Corpus data carries its own licenses, separate from the code: the planned
-ConceptNet slice is **CC-BY-SA 4.0** and will ship with its own notice.
+Corpus data carries its own licenses, separate from the code: the shipped
+ConceptNet slice is **CC-BY-SA 4.0**, with its own notice alongside it.
 
 © Polycode Limited.

package/ROADMAP.md

@@ -14,101 +14,188 @@ the file has been deleted.
 
 ## Where we are now (2026-07-09)
 
-`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
-
-- **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
+The full `SKILL_CHAT_PLAYTEST.md` dialogue-flow tier ladder is complete, tiers 0 through 6.
+Tiers 0, 1, 2, and 4 each closed in one pass. Tier 3 took 7 passes to track down a recurring
+`resolveObject` substring-match weakness. Tiers 5 and 6 each ran the full 5-cycle cap and each
+turned up one genuinely important correctness bug alongside a batch of routing fixes. Full
+per-cycle detail is in `HANDOVER.md`'s "The dialogue-flow playtest loop" section.
+
+`npm test` is green at **1355** (up from 1258 at the start of this session). v1.0.7 is
+published (0.9.11 → 1.0.0 → 1.0.7 across an earlier session; the exact release chain and
+file:line detail are in `HANDOVER.md`). Nothing has pushed since, so the local version sits at
+1.0.9 per the bump-at-push-time policy.
+
+Test count across the session's later stretch:
+
+| Work | `npm test` |
+| --- | --- |
+| Playtest-freeze verification pass (Tiers 0/1/2/4 + operator bugs A-F, chat-tested live and frozen as regressions) | 1299 → 1303 |
+| `resolveObject` tier-3 derivational-stem bridge, closing the one dead-end the freeze pass found | 1303 → 1307 |
+| Tier 5 (teach + recall + reasoning in dialogue), 5 cycles | 1307 → 1328 |
+| Tier 6 (the messy real user), 5 cycles, run alongside a background test-suite health pass | 1328 → 1345 |
+| Compound-name resolution (multi-word queries to joined-token symbol names) | 1345 → 1352 |
+| Vocabulary-growth mirror fix — known-subject/unknown-object mint (`unknownObjectFallback`), so new terms compound turn over turn | 1352 → 1355 |
+
+### Shipped this session
+
+- **Tier 5** found 12 routing/recognition fixes across teach and recall: article/head-word gaps
+  in "what do you know about X", an adverb mis-parsed as a verb in general-verb teach, passive
+  ownership phrasing, a quantified-property mis-teach, missing yes/no readers for taught facts, a
+  silently-null teach path, past-tense property support, a leading hedge-adverb gap. The final
+  cycle also caught a real correctness bug: "is the validate module deprecated" confidently
+  answered off an unrelated "logger module" fact, through a word-overlap fallback with no
+  exclusion for common code-noun suffixes like "module". New `test/chatflow-tier5.test.mjs` (21
+  cases).
+- **Tier 6**, the last rung of the ladder, found 23 routing/recognition fixes: a grain-word
+  resolution ambiguity ("the logger module" tying a Module against a same-stem Class); five new
+  closed preamble frames in `interpret/normalize.mjs` for topic-switch, self-interruption,
+  acknowledgement, hedge-adverb, and browsing discourse markers, chaining correctly when several
+  stack together; bare "inherits"/"inherit" alongside its sibling "extends"; a dozen more
+  vague-opener idioms; dialect and register gaps like "yeah nah", "howdy pardner", "aight", "no
+  worries". It also caught one important bug: "is the logger module tested" answered a
+  fabricated "I don't know that yet" even though the structural engine had already computed the
+  real, honest answer. An over-eager property-adjective matcher discarded it whenever a real
+  graph-computed parse already existed. New `test/chatflow-tier6.test.mjs` (17 cases).
+- **A test-suite health pass**, run in the background alongside Tier 6: batched `syllogise()`'s
+  per-fact writes via `appendFacts`; let two chatbench plumbing tests opt out of the corpus seed
+  (`TMCT_NO_SEED`); added a shared once-per-process seeded-fixture builder
+  (`test/helpers/seeded-fixture.mjs`) for tests that only consume seeded content; replaced a
+  hand-rolled copy of `WALL_MISS_RE` with the real export; and extracted a shared session-driver
+  helper (`test/helpers/session.mjs`), replacing 11 near-duplicate `drive()`/`driveSession()`
+  implementations. Full detail is in `HANDOVER.md`'s "Test-suite health pass" entry.
+- **Compound-name resolution**, from the operator's own worked example: "the payment system" now
+  finds `PaymentSystem`, `payment-system`, a compound path like
+  `westfield-payment-system/src/MyCode.cs`, and an interface-style name like
+  `IPaymentSystemImpl.cs`. `resolveObject` (`src/ask.mjs`) gained a multi-word compound-term
+  tier, the same shape as the existing single-word basename-exact/prefix-suffix (`9dde2b3`) and
+  derivational-stem (`6e2d96b`) tiers, gated to require an explicit separator in the candidate
+  label so a pure-camelCase identifier still falls to tier 4's prose fallback unaffected (this
+  protects a frozen "total price" → `calculateTotalPrice` test). New
+  `test/ask-compound-resolve.test.mjs` (7 cases). Full detail is in `HANDOVER.md`'s
+  "Compound-name resolution addendum" entry.
+- **The first-run chat experience, rewritten (1.0.0).** A brand-new `npm install` plus a bare
+  `tmct chat` used to lead with a "no code graph loaded" apology for any input, including plain
+  greetings, even though the seeded ontology/lexicon could already answer them. This was a
+  0.6.0-era design over-applying its own honest empty-graph orientation. The fix: identity/
+  capability-led responses ("I'm tmct — ..." before any caveat), a real self-description and a
+  distinct "no LLM involved" answer for the identity/AI-ID family, provably-correct "try this"
+  examples (a `vocabExampleHint` that only offers a term confirmed to resolve in the session's
+  actual seed state), and broadened conversational recognition (dialect, register, slang,
+  elongation, a bounded-fuzzy typo layer). All of it landed as curated closed-set additions, per
+  the project's standing preference over general grammar rules.
+- **The dialogue-flow playtest loop, tiers 0-4.** Tier 0 (bootstrap/identity), Tier 1 (single
+  touch plus one drill-down), Tier 2 (drill-down chains with anaphora), and Tier 4
+  (compositional and comparative) each closed in one pass. Tier 3 (cross-concept and relation
+  touches) took 7 passes: cycles 3-9 progressively found and fixed a recurring `resolveObject`
+  substring-match weakness, where a missing minimum-length floor let short staccato connectives
+  like "and"/"it" silently hijack the conversation's focus and produce confidently wrong answers
+  on a later turn while the triggering turn still looked honest. It took three point-by-point
+  patches before cycle 9 found and fixed the actual root cause in one place. The skill doc itself
+  gained two rules from real incidents this run: always `mktemp -d` plus exact-path cleanup for
+  scratch fixtures, and never `chat --repo` the committed example fixture directly.
+- **A live, client-side chat demo on the GitLab Pages homepage.** The real `src/ask.mjs` query
+  engine runs directly in the visitor's browser as a live demo, not a scripted replay. wink-nlp
+  loads from `esm.sh`, an import-map shim works around 3 leaf files' Node-only static imports, and
+  the engine itself needed no changes since it was already browser-clean pure JS. It 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`.
+  `?q=`-primed) question live, and gives the visitor a genuine interactive input box to type
+  their own questions and get real computed answers. `?compact=1` gives a minimal primed-link
+  view; `window.tmctAnswer`/`tmctAsk`/`tmctParseEntities` are exposed for headless/Playwright
+  consumers. There's no backend on GitLab Pages, so plain `curl`/`jq` never sees a computed
+  answer, which is stated plainly in the code rather than oversold.
+- **Operator-found bugs, fixed as they turned up in hand-testing the shipped CLI.** Relation-
+  specific vocabulary filtering (an ask like "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 the user's own input byte-for-byte (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 misreporting a relationship check as a verified
+  existence negative; "what else is X" repeating the primary definition 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, and "has a" interoperates with
+  the existing ConceptNet-sourced `mgx:hasA` data).
+- **Six more operator-found bugs (A-F), from a later manual chat-testing pass.** A malformed
+  "haves soup" render for past-tense "had" (a lemma fix); a broken "count soup" message when no
+  code graph is loaded; "what is in your memory" (bare, and "... about X") falling to the
+  structural miss instead of the memory summary/fact-lookup lanes. The "about X" form now also
+  walks transitive subtypes of X over taught (never corpus-noise) isa facts; a closed-set
+  indirect-request wrapper ("I want you to search for Widget") that used to be swallowed whole by
+  the general-verb teach recognizer, now stripped centrally before dispatch, plus a "search for
+  X"/"tell me X" (no "about") phrasing fix; and a `GOAL_BY_COMMAND` table that gives every
+  slash-command dispatch its own honest "Goal (inferred): ..." line. Full detail per bug is in
+  `HANDOVER.md`'s "Operator-found bugs A-F" entry.
+- **General verb-to-predicate teaching's query-side follow-up.** A taught general-verb fact now
+  answers direct questions too: "does margo eat ribs" → yes, "did margo eat ribs" → yes, "does
+  margo eat cake" → an honest no, "what does margo eat" → lists ribs. It reuses the same has/have
+  predicate bridge the teach side already had.
+- **New-term teaching and quantifiers.** "redis is a cache" (a genuinely new term, not
+  previously in the closed ACE lexicon) is now teachable through 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 or vocabulary
+  answer, distinct from the pre-existing opt-in `/narrate` full-trace mode. Two correctness bugs
+  in the goal-deduction hook itself got fixed along the way: a confidently wrong goal shown on
+  failed teach attempts, and a missing goal on relation-force answers that resolve through a
+  different path than the normal parse.
+- **Seonix's 17-round dogfooding backlog, triaged and worked through.** Seonix, a sibling
+  project consuming tmct as a real dependency, ran extensive dogfooding against both a synthetic
+  self-index and a real 27,929-module production estate, and relayed the findings over the
+  inter-session inbox. The backlog was triaged into 5 priority batches (4 items were already
+  fixed by intervening work). **Batch 1** (existence-query correctness) shipped first. **Batch
+  2**: bare "what is Commit" now parses (article optional, restricted to `ENTITY_TO_TYPE`'s
+  closed vocabulary); a reverse `inherits` verb family ("is X a superclass/parent class of Y")
+  swaps subject and object at parse time to agree with the existing forward phrasing; a curated
+  trailing-scope-filler strip ("what is a Module in this graph" → "Module") works at both the
+  grammar and chat-fact-lookup layers. **Batch 3**: purpose/identity phrasing ("whats X for/
+  about") joins "what does X do"; bare "recent/latest/newest commits" render a real dated list
+  instead of a false find-miss, and "the last/latest/most recent commit" as a query subject
+  substitutes the actual newest Commit before parsing; onboarding/closing phrasings beyond the
+  original closed set get the orientation nudge; present-tense cochange phrasing ("changes with")
+  joins the past-tense form. **Batch 4/5**: the cross-graph disambiguation-ranking weakness never
+  reproduced on tmct's own tiny example fixtures, so a new committed fixture graph
+  (`test/fixtures/large-scale/`, vendored commander.js + express.js source) was built to
+  reproduce it. It surfaced an exact basename match losing to a same-directory sibling that only
+  shared a component; fixed in `resolveObject`'s tier-3 scoring, where a new exact/prefix/suffix
+  basename tier now outranks the length-normalized overlap fallback. Separately, "which functions
+  call X and test Y" (two different, both-recognized relation verbs joined by "and") used to fall
+  to the legacy `ambiguousParse` path; the marker gate now also opens when every later
+  "and"-branch names its own single-word recognized verb, composing a real set intersection,
+  narrowly scoped so the pre-existing "which classes extends Base and couples to logging" compat
+  case stays exactly as closed as before. Still open: cochange phrasing variants, and a single,
+  not independently reverified "multi-root" substring over-match.
+- **The Tier-4 "of X" membership gap, walked through inheritance.** "public methods of
+  TaskController" used to return a genuine-looking but incomplete empty when the class declared
+  no members of its own but inherited real ones from a superclass. `src/ask.mjs`'s membership
+  eval now tries the owner's own (qualifier-filtered) members first, and only walks
+  `ancestorsOf` nearest-first when that's empty and the class participates in `inherits`. An
+  inherited answer is disclosed out loud ("… has no own methods — inherited from Controller:
+  …"), never silently presented as the owner's own.
+- **The version-bump policy, set then revised.** The session first tried bumping immediately
+  after every push and holding the bump locally until the next batch shipped, to keep the
+  published npm version matching the last pushed commit. That produced confusing "referencing a
+  version that doesn't exist yet" noise, so it was reverted mid-session. Current policy, recorded
+  in `CLAUDE.md`: bump only at the moment of actually pushing, as part of that same push.
 
 ### Next: the open follow-ups
 
-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.
+1. **Judged CHATBENCH re-run.** Not run this session. This session's changes touch answer text
+   on judged surfaces again (onboarding/identity responses, teach-lane wording, new relation
+   phrasings), so the next judged pass needs to re-derive its stale set from answer-text diffs,
+   not assume anything carries over from the 0.8.2-era baseline still on record.
+2. **The reverse-`inherits` verb family's "the"-definite forms** from Seonix Batch 2 ("is the
+   superclass of") aren't wired into `VERB_TO_KIND` yet. Doing so leaked the bare word "the"
+   into `ask.mjs`'s CONTENT_VOCAB and broke the relaxation cascade's noise-strip tests, so it
+   needs a CONTENT_VOCAB fix first.
+3. **Seonix Batch 4/5's remaining items**: cochange phrasing variants, and the single,
+   not-independently-reverified "multi-root" substring over-match noted above.
+4. **Extend compound-symbol matching to `/describe`'s own resolver.** The compound-name
+   resolution above only covers `resolveObject` (`src/ask.mjs`); `/describe`'s own resolver
+   (`resolveSymbol` in `codegraph.mjs`) is a separate, stricter, pre-existing resolver that
+   doesn't share `resolveObject`'s tiered scoring, so "describe the payment system" doesn't
+   benefit yet. Not a regression, just not yet covered.
 
 ### Later: deferred by design, staged inside each plan
 
@@ -116,7 +203,9 @@ Each plan doc stages its own later phases; this list just points to them rather
 their tables.
 
 - **infbench stages 1-5** (`PLAN_INFERENCE_TESTING.md` §4). The disjointness proof rule (unlocks
-  B1), proof-chain materialization, cardinality entailment, consistency checking.
+  B1), proof-chain materialization, cardinality entailment, consistency checking. The repeatable
+  measure/gate/advance cycle for this ladder is now also captured as an invokable skill,
+  `SKILL_INFERENCE_TESTING.md`.
 - **Advanced-grammar tracks b/d/e** (`PLAN_ADVANCED_GRAMMAR.md`). The constructions not landed
   this wave: stacked modality/passive, implicit arguments, and the rest of the CEFR inventory
   audit table.
@@ -874,6 +963,37 @@ Features we have deliberately shaped seams for but will not build until the phas
 earned them. **Not everything below is deferred for the same reason** — the design horizon,
 stated explicitly (2026-07-08 research pass):
 
+### Future direction: a genuine planning/agentic loop (flagged 2026-07-09, research pass done, not implemented)
+
+The operator's own framing, explicitly out of scope for the routing-level `GOAL_BY_COMMAND`/
+Goal-inference generalization this session shipped (HANDOVER's Bug F point 5, which only labels
+an already-computed answer's intent — it never plans ahead of one): infer the goal, read the
+relevant subgraph, reason about candidate action-paths and their effects, pick the next step,
+execute, repeat.
+
+Two companion research docs (2026-07-09, design only, zero code shipped) scope this against
+minimal benchmark domains before anything domain-general is attempted:
+- `PLAN_HANOI.md` — the OPEN-LOOP case (a whole solution path is computable up front from the
+  start state). Recommends representing state as taught facts in the memory store (not the
+  read-only, provider-owned code graph), a new `restsOn` edge encoding stack order, and genuine
+  bounded state-space search — reusing `syllogise.mjs`'s `findIsaChain` (already, in shape, a
+  bounded rooted BFS path search) — over hard-coding Hanoi's known closed-form recursive solution,
+  so the result is an actual generalizable planner, not a Hanoi-shaped trick.
+- `PLAN_GUESS_NUMBER.md` — the CLOSED-LOOP case ("I am thinking of a number," both as guesser —
+  belief-interval bisection over repeated higher/lower observations — and as thinker — tmct holds
+  a secret and gives honest feedback, no search needed). Recommends a new parallel session-state
+  slot (`game`) threaded through `createSession`/`runTurn` exactly the way `focus` already is,
+  kept deliberately separate from the `pending` pagination field since a game must survive an
+  aside mid-play, unlike a listing remainder.
+
+Both docs converge on the SAME one genuinely new primitive neither doc found already built
+anywhere in tmct: something that computes a SUCCESSOR STATE (apply a chosen action, produce the
+next graph/belief to reason over) — every existing traversal (`ancestorsOf`, `computeFind`,
+`findIsaChain` itself) is read-only. That primitive, plus a still-open recognition question (how
+tmct notices "the user wants goal-directed action" at all, and whether multi-step execution needs
+confirmation before running) is the real next-session scope — a dedicated design/implementation
+session, not a routing fix.
+
 ### The design horizon
 
 **Before the horizon — known-how, not-yet-built, no research risk.** Sequencing or engineering

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polycode-projects/the-mechanical-code-talker",
-  "version": "1.0.8",
+  "version": "1.2.0",
   "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.",