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

package/README.md

@@ -127,6 +127,15 @@ 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".
 
+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
+later "every cache is a store" does the same for "store," the other way
+round, as long as one side of the sentence is already grounded. tmct never
+mints a fact between two totally ungrounded terms; it declines and nudges you
+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."
+
 ### Provenance and trust
 
 Every fact and text block records **where it came from and when**. Sources are

package/ROADMAP.md

@@ -35,6 +35,126 @@ Test count across the session's later stretch:
 | 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 |
+| `findActionPath` (`src/planning.mjs`) — generic bounded on-demand-successor state-space search, `PLAN_HANOI.md`'s Phase 2 kernel, proven against a small toy graph; not wired into chat, Hanoi itself not started | 1355 → 1361 |
+
+**INFBENCH re-measured against 1.2.0** (measurement-only dispatch, 2026-07-09): `INFBENCH_1.2.0.md`
+confirms chat/INF-A2 now closes to 100% (the cax-sco/proof-chase win the STATUS banner above already
+claimed) but also finds chat/INF-C1 has flipped from an honest ceiling to a genuine 93%-fabrication
+regression, traced to the new general-verb-to-predicate query lane answering "no" on an absent fact
+instead of declining — a real correctness bug, separate from and cheaper than the still-gating
+INF-B1 (`cax-dw`) work.
+
+**INF-C1 fabrication FIXED (2026-07-09, follow-up dispatch)**: `GENERAL_VERB_YESNO_RE`'s no-hit
+branch (`src/chat.mjs`) now declines (`null`) instead of asserting a confident "no" when no taught
+fact matches the queried subject/predicate/object triple, falling through to the ordinary
+honest-miss cascade — same convention as `WHO_OWNS_RE`'s own no-hit branch. Re-ran `npm run
+infbench`: chat/INF-C1 is back to **93% completion / 0% fabrication**, its `0.8.2`-era honest
+ceiling, exactly as predicted (up from `1.2.0`'s 0% completion / 93% fabrication). Everything else
+in the ladder is unchanged — still gated at INF-B1 (33% completion), unaffected by this fix.
+`npm test` 1361 → 1362 (this fix's own contribution; see `HANDOVER.md` for the combined total
+alongside the concurrent Rule-storage dispatch).
+
+**`PLAN_TAUGHT_RELATIONS.md`** (research/design, 2026-07-09, nothing implemented): scopes teaching
+tmct brand-new relations and rules through ordinary chat (a Prolog-style family tree — father,
+parent, grandparent, descendant — none of it hardcoded, all of it taught), reusing
+`findActionPath` for the hop-counted relation chase and a new sibling kernel, `findReachableSet`,
+for open-ended enumeration. Live-testing while designing it surfaced real, already-shipped gaps:
+the "is a kind of" teach phrasing isn't accepted anywhere today, a "parent" example in the original
+scoping conversation only worked by an accidental lexicon collision, and a wrapped property-teach
+shape (`TEACH_PROPERTY_RE`) has no groundedness check at all, unlike the newer subject/object
+mint-fallback pair's explicit discipline. See `HANDOVER.md` for the full finding list; this is
+next-session pickup material, not yet started.
+
+**`PLAN_TAUGHT_RELATIONS.md` Phase 3 — DONE (2026-07-09)**: the Rule storage foundation landed in
+`src/memory/core.mjs` (`RULE_CLASS`, `appendRule`, `findRuleByName`) — pure plumbing, zero
+`chat.mjs` change, reusing the existing Source/trust pipeline unmodified. `npm test` 1361 → 1371.
+Phase 4 (compose2 query-side wiring) is next in that plan's build order.
+
+**`PLAN_TAUGHT_RELATIONS.md` Phase 1 — DONE (2026-07-09)**: Item 1 (relational fact teach,
+`RELATION_FACT_TEACH_RE` — "ahab is the father of john" mints an ordinary Fact via
+`generalVerbPredicate`, reused verbatim) and Item 5 (adjective-mint, `unknownAdjectiveFallback` —
+"the cache is bespoke" / "TaskController is bespoke" mint `mgx:hasProperty`) both landed in
+`src/chat.mjs`. Query-side readback for Item 1 needed zero new machinery ("what do you know about
+X" / "does X <role> Y" both already confirm it); Item 5's own groundedness guard needed tightening
+beyond the original design to avoid reopening the pinned "module is banana" regression — see
+`PLAN_TAUGHT_RELATIONS.md`'s "Phase 1 — DONE" note for the full adjustment, plus a sharper,
+live-confirmed restatement of that doc's Verification finding 4 (`isConversational`'s ≤3-word gate
+pre-empts the teach lane entirely for a short bare sentence, not just its decline text — flagged,
+not fixed, still out of scope). `npm test` 1371 → 1377.
+
+**`PLAN_TAUGHT_RELATIONS.md` Phase 6, KERNEL half — DONE (2026-07-09)**: `findReachableSet`
+(`src/planning.mjs`), a sibling of `findActionPath` with no `isGoal` at all — every state reachable
+from the start within `maxDepth` is a result, not just one goal. Shares only the frontier-seeding
+step with `findActionPath`; the expand loops stayed independent (halting/accumulation semantics
+differ enough to make a shared core more complex, not less). Proven against a toy graph with a real
+cycle and a same-length two-path convergence. `test/planning.test.mjs`, 5 new tests. The WIRING half
+(teach-shape recognizer + query-dispatcher branch, both in `chat.mjs`) is deliberately deferred,
+kernel-only per this task's own scoping — see `PLAN_TAUGHT_RELATIONS.md`/`HANDOVER.md` for detail.
+
+**`PLAN_TAUGHT_RELATIONS.md` Phase 2 — DONE (2026-07-09)**: closes Item 1's own live-found
+query-side gap ("is ahab the father of john" now resolves directly) and Item 2 (relation alias/union
+query-side chase — a taught "father ⊑ parent" alias lets "is ahab a parent of john" resolve off the
+father fact). One new recognizer (`RELATION_FACT_YESNO_RE`) and one new local helper
+(`relationFactsFor`) in `factReadBack`, tried BEFORE `ISA_ASK_RE` gets a chance at the overlapping
+shape. The teach-side "kind of"/"type of" fix (`stripKindOf`) is a genuine one-liner.
+`test/chat-taught-relations.test.mjs` (new file), 4 tests. `npm test` 1382 → 1386. Phase 4 (compose2
+rule, next in this plan's build order) reuses `relationFactsFor` as its own per-hop edge lookup.
+
+**`PLAN_TAUGHT_RELATIONS.md` Phase 4 — DONE (2026-07-09)**: Item 3 (fixed-hop `compose2` composition
+rule — "a grandparent is a parent of a parent" teaches a Rule, and "is ahab a grandparent of
+ishmael" resolves via a hop-counted `findActionPath` search over the taught father facts,
+alias-chased through "parent" via Phase 2's own `relationFactsFor`). The hop-counting discipline
+(`{ entity, hopsTaken }` state, `isGoal` requiring exactly 2 hops) is live-verified load-bearing: a
+1-hop and a 3-hop path through the SAME father/parent edges both correctly decline in the same store
+where the genuine 2-hop pair resolves yes. Full family-tree chain (two father facts + the alias + the
+compose2 rule) live-verified end-to-end via the piped CLI. `test/chat-taught-relations.test.mjs`
+extended with 5 more tests (9 total). `npm test` 1386 → 1391.
+
+**`PLAN_TAUGHT_RELATIONS.md` Phase 5 — DONE (2026-07-09)**: Item 4 (property-filtered composition
+rule — "a grandfather is a grandparent who is male" teaches a `filter`-kind Rule). Required
+refactoring Phase 2/4's `relAsk` dispatcher's three inline steps into one recursive closure,
+`resolveRelationChase`, so a filter rule's base resolves GENERICALLY — the function calling itself —
+whether the base is a plain taught relation or another Rule (e.g. compose2), never assuming which.
+A hit requires both the base chase to resolve AND the subject to carry the taught property
+(`mgx:hasProperty`); live-verified both failure modes separately (base fails outright vs. base holds
+but the property filter correctly excludes the candidate) plus a filter whose base is a plain
+relation (not a compose2 rule at all), proving the genericity. `test/chat-taught-relations.test.mjs`
+extended with 4 more tests (13 total). `npm test` 1391 → 1395.
+
+**`PLAN_TAUGHT_RELATIONS.md` Phase 6 — DONE (2026-07-09), WIRING half — the plan's build is now
+COMPLETE, all six items.** Item 6 (recursive/reachability rule — "a descendant is a parent, or a
+parent of a descendant" teaches a `recursive`-kind Rule; "list the descendants of ahab" enumerates
+the full reachability set via `findReachableSet`, the kernel half already shipped, reused unchanged).
+The query side is the one genuine kind-change among all six items (a reachability-SET enumeration,
+not a yes/no chase), landed as a sibling of Phase 5's `resolveRelationChase` rather than a fourth
+branch inside it — mirroring `findActionPath`/`findReachableSet`'s own sibling split at the kernel
+level. Cycle safety (two individuals mutually taught as each other's parent) and a malformed
+self-reference teach attempt (guarded for free by the teach regex's own backreference) both
+live-verified. `test/chat-taught-relations.test.mjs` extended with 5 more tests, including one
+comprehensive ALL-SIX-items integration test (18 total). `npm test` 1395 → 1400. **Nothing remains
+outstanding from `PLAN_TAUGHT_RELATIONS.md`'s original six-item scope.**
+
+**INFBENCH re-measured against 1.3.1** (measurement-only dispatch, 2026-07-09): `INFBENCH_1.3.1.md`
+finds the ladder unchanged, byte-for-byte, since `1.3.0` — the four `PLAN_TAUGHT_RELATIONS.md`
+phases that completed the plan (alias/union, `compose2`, property-filter, recursive/reachability
+wiring) don't touch any band, confirmed by a zero-diff row comparison of both runs' raw product
+files plus a direct check that no INFBENCH case's premises/query ever reach the new relational-teach
+phrasing. Still gated at INF-B1 (33% completion), unchanged for a fourth consecutive measured
+version — an honest, expected result given the new surface and the ladder measure different things.
+
+**`PLAN_TAUGHT_RELATIONS.md` live-testing follow-up — DONE (2026-07-09)**: the operator live-tested
+the full family-tree example end-to-end and found two real gaps, both fixed in `src/chat.mjs`. Gap 1:
+a recognized-but-unsatisfied relational query used to fall to the GENERIC structural wall instead of
+naming the relation — fixed by distinguishing "relation/rule name never taught" from "name known, this
+pair's chase came up short" right in the `(a0)` block, each with its own specific decline text. Gap 2:
+the REVERSE query shape ("who is the grandparent of john") didn't exist at all — new recognizer
+`RELATION_WHO_ASK_RE` + a new `(a0.2)` block in `factReadBack`, re-deriving `resolveRelationChase`'s
+same resolution logic (direct/alias/compose2/filter) walked backward from the object, reusing
+`findReachableSet` unmodified for the compose2 reverse hop-chase. Live-verified the operator's own
+repro exactly: "who is the grandparent of ishmael" → ahab (full 2-hop derivation cited); "who is the
+grandparent of john" → an honest empty (never a wrong guess). `test/chat-taught-relations.test.mjs`
+extended with 8 more tests (26 total). `npm test` 1400 → 1408, zero regressions. **Nothing remains
+outstanding from `PLAN_TAUGHT_RELATIONS.md`.**
 
 ### Shipped this session
 
@@ -63,6 +183,17 @@ Test count across the session's later stretch:
   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.
+- **Vocabulary-growth mirror fix.** New vocabulary used to grow one-directionally only: "redis is
+  a cache" could mint the unknown subject "redis" because the object "cache" was already a known
+  noun, but the reverse ("every cache is a store," subject known, object unknown) declined
+  outright. Added `unknownObjectFallback`, gated on a genuine universal quantifier ("every"/"each"/
+  "all") so it can't reopen the general lexicon bypass the existing bare/"a" shapes rely on. A term
+  minted by either direction now grounds a later sentence exactly like a lexicon word, using
+  taught-only groundedness checks that deliberately exclude the bulk ConceptNet corpus seed (the
+  corpus mentions ordinary English words constantly and must never silently count as "grounded").
+  When both sides are totally ungrounded, tmct still declines, but now with an actionable grounding
+  nudge instead of a bare "I couldn't store that." New coverage in
+  `test/chat-teach-quantifier.test.mjs`.
 - **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
@@ -985,14 +1116,22 @@ minimal benchmark domains before anything domain-general is attempted:
   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
+- `PLAN_TAUGHT_RELATIONS.md` — teaching tmct brand-new relations and rules through ordinary chat
+  (a taught Prolog-style family tree, none of the kinship vocabulary hardcoded), the first of the
+  three to need a successor function SYNTHESIZED from data the user taught in an earlier turn,
+  rather than hand-written per domain the way Hanoi's `legalMoves` and guess-number's
+  interval-update rule are. Its own enumeration capability ("list the descendants of X," no fixed
+  goal) needs a genuine new sibling kernel, `findReachableSet`, since `findActionPath` only ever
+  searches toward one goal.
+
+All three docs converged on the one genuinely new primitive none of them 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.
+`findIsaChain` itself) is read-only. That primitive now exists (`findActionPath`, `src/planning.mjs`,
+shipped this session — see "Shipped this session" above), proven against a small toy graph but not
+wired into any of the three domains yet. The remaining next-session scope is that wiring, 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.
 
 ### The design horizon
 

package/package.json

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