@polycode-projects/the-mechanical-code-talker 0.9.8 → 0.9.10

package/ROADMAP.md

@@ -27,8 +27,8 @@ the file has been deleted.
 - **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 (GOAL_RULE/PHRASING_FRAMES synthesis) — operator
-  sign-off given this session; Tracks 2-4 remain unsigned-off and untouched.
+- ~~**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.
 
@@ -82,13 +82,13 @@ In priority order (full detail and measured targets in `HANDOVER.md`):
    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`.** A separate concurrent session is drafting this
-   3-part tmct/bedrock-meter/marginalia integration plan. Check for completion and finalize.
-5. **`PLAN_CODE.md`'s sign-off decision.** Track 1 (rule/frame synthesis) is the lowest-risk
-   candidate; decide with the operator whether to greenlight it.
-6. Smaller chat-feel residuals from the 0.8.2 confirmation playtest, the Track-1 trio (pronoun,
-   temporal, discourse-count, measured red sets), and `edgesOfKind` memoization for monorepo-scale
-   latency. (The version bump plus push is done — see "Now" above.)
+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;

package/package.json

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

@@ -157,6 +157,12 @@ export const RELATIONS = {
       "change alongside", "shares commits with", "share commits with",
       "tends to change together with", "tend to change together with",
       "moves together with", "move together with",
+      // Track-1 trio (temporal lever): the bare "changed/change together with" form
+      // (no "tends to"/"tend to" prefix) was missing outright — "which modules
+      // changed together with X" fell through to the "touch(ed)" verb instead (a
+      // Commit->Module kind, structurally unable to match a Module subject), always
+      // producing a confidently-empty answer regardless of real cochange data.
+      "changed together with", "change together with", "changes together with",
     ],
   },
   reexports: {

package/src/ask.mjs

@@ -2159,6 +2159,21 @@ export function traverse(graph, parsed, { contextId = null, prev = null } = {})
   // Module individuals and a FINER entityType was asked for do we refine via `defines`
   // (imports) — never blindly treat an edge's subject id as if it were always a module id.
   let edges = kindsFor(kind).flatMap((k) => edgesOfKind(graph, k)).filter((e) => e.object === gObjMatch.id);
+  // cochange (Module<->Module, mgx:changeCoupledWith) is a SYMMETRIC relation but
+  // stored as ONE directed edge per pair (extractor convention, not a meaningful
+  // subject/object direction) — "which modules cochange with X" must also match
+  // when X is the STORED SUBJECT of the pair, reading the OTHER endpoint (Track-1
+  // trio, temporal lever). Flip subject<->object on that side so the subjects-
+  // collection loop below (which reads e.subject) picks up the partner uniformly;
+  // the object-side match above is untouched, so an existing non-empty answer is
+  // byte-identical.
+  if (kind === "cochange") {
+    edges = edges.concat(
+      kindsFor(kind).flatMap((k) => edgesOfKind(graph, k))
+        .filter((e) => e.subject === gObjMatch.id)
+        .map((e) => ({ ...e, subject: e.object, object: e.subject })),
+    );
+  }
   let extNote = "";
   if (!edges.length && gObjMatch.class) {
     // Unresolved ext:<Name> endpoints with the SAME name as the resolved entity:

package/src/chat.mjs

@@ -2478,13 +2478,26 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
       note(trace, `lane: (1) META/SELF — bare self/session question recognized, answered via="${meta.via}"`);
     }
   }
-  if (!handled && miss && isConversational(query)) {
+  if (!handled && miss && !envelope?.parsed && isConversational(query)) {
     // 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
     // reaches the composed-only wall-shortening gate below, so a second
     // identical orientation-class turn used to repeat the full blurb verbatim —
     // collapse to a one-liner on that repeat, mirroring WALL_REPEAT_ONELINER.
+    //
+    // `!envelope?.parsed` (Track-1 trio, pronoun/focus binding — "biggest movable
+    // mass"): isConversational() is a TEXT-ONLY heuristic (≤3 words, no code-ish
+    // token) — it has no way to know the query already compiled to a real
+    // structural AST shape. A pronoun-shortened follow-up ("who touched it"/
+    // "that"/"this") is exactly 3 words and "touched" isn't in STRUCT_WORDS, so
+    // isConversational used to fire AFTER ask() had already parsed the reverse
+    // "touches" shape, resolved the pronoun off the focus, run the traversal, and
+    // composed an honest (possibly empty) answer — discarding that correct answer
+    // for the generic orientation wall. When envelope.parsed stood, the query WAS
+    // structural (by construction, not word-count guesswork); its own composed
+    // answer — hit, honest empty, or "it needs a referent" — is always more
+    // truthful than the orientation card.
     const orientation = orientationAnswer(templates, graph);
     const repeat = last?.answer === orientation;
     answer = repeat ? ORIENTATION_REPEAT_ONELINER : orientation;

package/src/router/goal-reasoner.mjs

@@ -164,9 +164,16 @@ export function backwardChainGoal(topic) {
  *  The caller REFUSES on zero matches (the open-world goal-generation seam) and
  *  on more than one (an ambiguous meta-goal — arbitration between meta-goals is
  *  undeclared, so guessing one would be an invented goal). */
-export function applicableRules(declaredTools, focus, mode) {
+// `ruleSet` defaults to the real, shipped GOAL_RULES — every existing caller
+// (driver-goal.mjs, this module's own goalReason, every test) is unaffected.
+// The override exists ONLY for PLAN_CODE.md Track 1 (§1.4): the synthesis
+// oracle clones a CANDIDATE rule into its own array and runs it through this
+// SAME trusted function — never a re-derivation — to check it decides
+// applicability exactly like a hand-written rule would. synthbench/ is the
+// only caller that ever passes a non-default ruleSet.
+export function applicableRules(declaredTools, focus, mode, ruleSet = GOAL_RULES) {
   const declared = Array.isArray(declaredTools) ? declaredTools : [];
-  return GOAL_RULES.filter((rule) =>
+  return ruleSet.filter((rule) =>
     rule.modes.includes(mode)
     && (mode !== "scoped" || (focus != null && focus.class === rule.focusClass))
     && rule.subGoals.every((topic) => {
@@ -255,8 +262,14 @@ export function dropCondition(intention, observed, mode, focus, focusClass) {
  *  the keystone module globally) or an HONEST REFUSE at the open-world
  *  goal-generation seam.
  *
- *  ctx: { dispatch(name,input)->{ok,result}, resolve(term)->{match,ambiguous} }. */
-export async function goalReason(request, tools, ctx, { driver = "goal-0.8.1" } = {}) {
+ *  ctx: { dispatch(name,input)->{ok,result}, resolve(term)->{match,ambiguous} }.
+ *
+ *  `ruleSet` defaults to the real, shipped GOAL_RULES (every product call site
+ *  omits it). PLAN_CODE.md Track 1's synthesis oracle (synthbench/rules/
+ *  oracle.mjs) is the one caller that overrides it, with a CLONED array
+ *  holding a candidate rule — the candidate then runs through this exact same
+ *  meta-loop a hand-written rule does, never a parallel re-implementation. */
+export async function goalReason(request, tools, ctx, { driver = "goal-0.8.1", ruleSet = GOAL_RULES } = {}) {
   const declared = Array.isArray(tools) ? tools : [];
 
   // STEP 1 — deduce the goal scope from the DECLARED model + a bound focus,
@@ -267,8 +280,8 @@ export async function goalReason(request, tools, ctx, { driver = "goal-0.8.1" }
 
   // The open-world goal-generation seam, named honestly: a resolved focus whose
   // class NO declared goal-rule scopes is REFUSED, never given an invented goal.
-  if (focus && !GOAL_RULES.some((r) => r.focusClass === focus.class)) {
-    const covered = [...new Set(GOAL_RULES.map((r) => r.focusClass))].join("/");
+  if (focus && !ruleSet.some((r) => r.focusClass === focus.class)) {
+    const covered = [...new Set(ruleSet.map((r) => r.focusClass))].join("/");
     return refuse(`open-world: no declared goal-rule covers a ${focus.class} focus (the declared goal-rules are ${covered}-scoped) — escalate`, driver);
   }
 
@@ -276,7 +289,7 @@ export async function goalReason(request, tools, ctx, { driver = "goal-0.8.1" }
   // 0 applicable rules => the same open-world seam (nothing declared grounds the
   // request's scope in this toolset); >1 => an AMBIGUOUS meta-goal (arbitration
   // between meta-goals is undeclared) — both are honest refusals, never a guess.
-  const applicable = applicableRules(declared, focus, mode);
+  const applicable = applicableRules(declared, focus, mode, ruleSet);
 
   // THE GLOBAL-MODE DOMAIN GATE (Bug 8 fix, see the module header). SCOPED mode
   // already proved relevance via a bound graph entity; GLOBAL mode has not, so