@polycode-projects/the-mechanical-code-talker 0.9.9 → 0.9.11

package/ROADMAP.md

@@ -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;
@@ -650,13 +650,45 @@ outward from high-trust premises (the provenance primitive) toward novel, releva
 timestamping each so recency and novelty stay computable. The mechanics are the easy half
 (bounded forward chaining materializes entailments; backward chaining from frequent query shapes
 pre-derives likely answers). **The residual hard half is still the FRAME PROBLEM / relevance
-realization — unsolved in the general case and not pretended otherwise;** trust+novelty+relevance
-are the tractable approximation, not a solution. The plan's job is
-to make it TRACTABLE in tmct's narrow, closed world, not to solve it: usefulness is approximated
-from what the system actually gets asked (query-shape frequency), what connects to recent focus,
-what a cheap forward step yields that isn't already stored, and a hard
-budget (inference is bounded, its output trust-scored via the provenance primitive, and anything
-speculative is retractable and never outranks a stated fact). Everything else is deferred to the
+realization — unsolved in the general case and not pretended otherwise.** This is not one problem
+but two, of different hardness (full literature + citations in `PLAN_CAPABILITY_ROUTER.md`'s "The
+open-world boundary" section):
+
+- **The frame-*axiom* problem — solved, inside a declared world.** McCarthy & Hayes named it in
+  1969 ("Some Philosophical Problems from the Standpoint of Artificial Intelligence", *Machine
+  Intelligence* 4); Reiter's 1991 successor-state axioms and Kowalski & Sergot's 1986 event
+  calculus (*New Generation Computing* 4(1)) both solve the narrow reading — stating what changes
+  without enumerating what doesn't — inside a **declared** effect/predicate model. That's exactly
+  the OWL base the Syllogist forward-chains over: the axioms and rules are declared, so applying
+  them is mechanical, bounded, and already shipped (`src/syllogise.mjs`).
+- **The relevance-*bounding* problem — genuinely open, and possibly not just unbuilt.** Given the
+  unbounded set of entailments a rich KB licenses, which ones are worth materializing *before
+  anyone asks* — without an oracle telling the pass what matters? That is McCarthy's deeper,
+  unsolved reading, and it has no known algorithm. It is also, independently, the central problem
+  a live cognitive-science literature has converged on: Vervaeke, Lillicrap & Richards ("Relevance
+  Realization and the Emerging Framework in Cognitive Science", *Journal of Logic and Computation*
+  22(1):79–99, 2012) frame it as the pervasive problem cognitive science keeps rediscovering: Jaeger,
+  Riedl, Djedovic, Vervaeke & Walsh ("Naturalizing relevance realization: why agency and cognition
+  are fundamentally not computational", *Frontiers in Psychology*, 2024) go further and argue —
+  contestably, but rigorously, not as a popular-science claim — that relevance realization
+  *cannot* be an algorithmic process at all, by an analogy to Gödelian incompleteness. Take that as
+  a live, unresolved argument, not a proof: the honest position is that tmct doesn't know whether
+  this is "hard" or "impossible", and says so.
+
+trust+novelty+relevance (query-shape frequency, recent-focus connectivity, a hard depth/budget
+cap) are the **tractable approximation** the plan actually ships — a proxy for relevance, not a
+solution to it, and openly so. **A speculative angle, still respecting no-LLM-in-product:** the
+same bounded-region trick sketched for the router's open-world goal recognition
+(`PLAN_CAPABILITY_ROUTER.md`) applies here. Instead of trying to bound relevance globally (the
+open problem above), bound it *per query-shape*: a query shape already declares which
+predicates/fluents it touches — it's how `parseQuery` resolves it — so restricting speculative
+forward-chaining to premises reachable within N hops of an **observed** query shape's declared
+predicates is a *structurally*-bounded relevance filter, not a learned or statistical one. It is
+narrower than "what's relevant in general" (that stays open) but might be enough to keep
+materialization from drifting into computing entailments nobody will ever ask about — trading
+"relevant to anyone" (unsolved) for "relevant to what this system has actually been asked"
+(a proxy, but a principled, deterministic one). This has not been built or measured; it is a
+candidate for the plan's next spike, not a claimed result. Everything else is deferred to the
 plan's open questions, where the relevance problem is named as the open research risk it is.
 
 ### Open-source the ACE-OWL parser as a standalone library
@@ -811,7 +843,57 @@ critical build path:
 ## Phase LATER — recognized, deferred, not now
 
 Features we have deliberately shaped seams for but will not build until the phases above have
-earned them:
+earned them. **Not everything below is deferred for the same reason** — the design horizon,
+stated explicitly (2026-07-08 research pass):
+
+### The design horizon
+
+**Before the horizon — known-how, not-yet-built, no research risk.** Sequencing or engineering
+debt: the technique exists (in tmct's own prior work or the wider literature), building it is a
+matter of scheduling and effort, not discovery. Everything shipped this session lives here, plus:
+tone-of-voice adaptation (below — deliberately dropped by design choice, not unsolved);
+tier-4 learn-on-miss (below — prerequisites not yet met, not research-blocked); `PLAN_CODE.md`
+Tracks 2–4 (mutation search/repair, JS/HTML/CSS synthesis — APR and CEGIS are established
+techniques); `PLAN_OSS_ACE_PARSER.md` (pure extraction/packaging); OWL 2 RL forward-chaining and
+DL tableau consistency checking (`PLAN_INFERENCE_TESTING.md` stages 3–5 — the W3C's own OWL 2 RL
+profile is a published, complete rule table; Pellet/HermiT/RDFox/Jena are real production
+reasoners built on solved theory); RETE/incremental forward-chaining (same doc — Forgy 1982 is a
+citable, portable algorithm); contingent/conformant planning under initial-state uncertainty
+(`PLAN_CAPABILITY_ROUTER.md` — Bonet & Geffner 2000, Hoffmann & Brafman 2006, Petrick & Bacchus
+2002 all have working algorithms); ordinary closed-domain anaphora resolution (`nextFocus`,
+already shipped, plus a real theoretical grounding available in Grosz/Joshi/Weinstein's centering
+theory, 1995).
+
+**After the horizon — genuinely unsolved in the field, or abandoned by the field in favor of
+approaches tmct's no-LLM ethos rules out.** Named as real research targets, with citations, not
+stop signs (full detail + full citation lists in each owning doc):
+- **The frame problem / relevance realization** — the open-world planning boundary
+  (`PLAN_CAPABILITY_ROUTER.md`'s "The open-world boundary" section; this doc's tier-5 Syllogist
+  paragraph below). McCarthy & Hayes 1969 named it; Jaeger, Riedl, Djedovic, Vervaeke & Walsh
+  (2024) argue it may not be algorithmically solvable in the general case at all. Speculative
+  angle recorded: bounded (N+1) goal recognition — recognize declared goal 1..N, or reject to an
+  explicit "escalate" class, via parse-shape membership (the same mechanism Bug 8's domain gate
+  already uses) — not published anywhere found.
+- **Symbolic (non-neural) dependency parsing at real coverage** — `PLAN_ADVANCED_GRAMMAR.md`
+  track (c). Largely abandoned by mainstream NLP research once neural parsers won CoNLL
+  2017/2018, not disproven at any fixed data budget. Speculative angle: a hand-built,
+  closed-vocabulary disjunct/category dictionary (Link Grammar/CCG-style) scoped only to tmct's
+  own closed relation vocabulary, registered as another additive interpretation strategy.
+- **Winograd-hard commonsense coreference** — `PLAN_ADVANCED_GRAMMAR.md` track (g). Genuinely
+  open without either massive statistical priors (ruled out) or a full commonsense KB (Cyc's
+  decades-long cautionary history). Speculative angle: tmct's own closed, complete graph makes a
+  *narrow slice* of Winograd-shaped ambiguity a graph-query-filtering problem rather than
+  open-domain commonsense reasoning — explicitly not the same as solving Winograd.
+- **Bounded, incremental, trust-tiered, retraction-safe justification tracking** —
+  `PLAN_INFERENCE_TESTING.md`'s stage-3/4/5 discussion. Doyle's JTMS (1979) and de Kleer's ATMS
+  (1986) solve retraction; DRed/RDFox's Backward-Forward solve incremental Datalog maintenance;
+  nobody has published the specific combination with tmct's multi-trust-tier, hard-budget
+  requirement. Speculative angle: an ATMS-lite extension to `syllogise.mjs`'s currently-flat
+  provenance tag, sketched but unbuilt.
+
+Every item above is honestly labeled speculative — a direction recorded so it isn't
+re-discovered from scratch, not a committed build plan. None of it is scheduled; the phases above
+this line are still the actual near-term work.
 
 ### Tone-of-voice adaptation (dropped from Phase 6, 2026-07-05)
 Per-voice synonym/phrase substitution over prose spans. Dropped because tmct's protected-span

package/package.json

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

@@ -1530,6 +1530,23 @@ function renderFactLine(f) {
   return `i learned: ${factPhrase(f)}${cite}`;
 }
 
+/** PROOF-CHAIN RECEIPT (PLAN_INFERENCE_TESTING.md §4 stage 2; ROADMAP L788's
+ *  "renderable as a chain of thought in words"): render an ordered list of
+ *  premise Fact rows as one continuous argument — "cache is a kind of store;
+ *  store is a kind of component; so redis.mjs is a component" — each premise
+ *  cited via the SAME factPhrase + "(source: …)" convention renderFactLine
+ *  uses, just without its "you told me"/"i learned" framing (a chain reads as
+ *  one derivation, not a list of standalone recollections). The conclusion
+ *  clause is spelled directly from the first premise's subject and the last
+ *  premise's object — sound for any chain length, though today's only caller
+ *  (the live cax-sco/scm-sco chase below) ever passes exactly two. */
+function renderIsaChain(premises) {
+  const step = (f) => `${factPhrase(f)}${f.provenance ? ` (source: ${f.provenance})` : ""}`;
+  const first = premises[0];
+  const last = premises[premises.length - 1];
+  return `${premises.map(step).join("; ")}; so ${first.subject} is a ${last.object}`;
+}
+
 /** Read every reified Fact out of the memory graph as plain {subject, predicate,
  *  object, provenance} rows. Lazy + failure-tolerated: no memory → []. */
 async function memoryFacts(memoryDir) {
@@ -1892,6 +1909,40 @@ async function factReadBack(memoryDir, query, envelope, miss, graph = null) {
         };
       }
     }
+    // LIVE cax-sco / scm-sco PROOF CHASE (PLAN_INFERENCE_TESTING.md INF-A2,
+    // §4 stage 1): a direct isa fact and the graph inherits-bridge both
+    // missed — chase a chain over TWO TAUGHT isa-family facts (§1's PARTIAL
+    // note: "cax-sco over two TAUGHT facts is NOT implemented"; the band's own
+    // "Rules needed" column: "⊑-chain of length 2") via syllogise.mjs's
+    // findIsaChain, a rooted proof search built on the SAME two rule kernels,
+    // LIVE and READ-ONLY (nothing is written — the offline `tmct syllogise`
+    // batch pass, materializing the same two rules with `entailed:*`
+    // provenance, is the persisting counterpart). Deliberately narrow, twice
+    // over, to stay exactly in INF-A2's scope and not silently answer bands
+    // this stage doesn't (yet) certify:
+    //   - maxHops:2 — a longer taught chain is INF-B2's multi-hop +
+    //     proof-chain-materialization territory (§4 stage 2 proper), which
+    //     INFBENCH pins as an honest ceiling until it lands — answering
+    //     "yes" there today would be graded FABRICATION, not credit.
+    //   - CORPUS-sourced edges excluded — the bulk background corpus band
+    //     (trust 0.7) can coincidentally chain two unrelated classes into a
+    //     technically-true-per-ConceptNet "yes" that has nothing to do with
+    //     what the OPERATOR taught; only operator/teach/entailed-sourced isa
+    //     facts are chased, matching "TAUGHT" in the gap's own name.
+    const { findIsaChain, SUBCLASS_PREDICATE: SC_PREDICATE, TYPE_PREDICATE: RDF_TYPE_PREDICATE } = await import("./syllogise.mjs");
+    const isTaught = (f) => !f.sourceTypes?.includes("corpus") && !f.sourceTypes?.includes("web");
+    const chainSubClassRows = isa.filter((f) => f.predicate === SC_PREDICATE && isTaught(f));
+    const chainTypeRows = isa.filter((f) => f.predicate === RDF_TYPE_PREDICATE && isTaught(f));
+    const chainSubClassEdges = chainSubClassRows.map((f) => [f.subject, f.object]);
+    const chainTypeEdges = chainTypeRows.map((f) => [f.subject, f.object]);
+    const factForStep = (step) => (step.predicate === SC_PREDICATE ? chainSubClassRows : chainTypeRows)
+      .find((f) => f.subject === step.subject && f.object === step.object);
+    for (const subj of subjCandidates) {
+      const chain = findIsaChain(subj, objVariants, chainTypeEdges, chainSubClassEdges, { maxHops: 2 });
+      if (!chain) continue;
+      const premises = chain.map(factForStep);
+      if (premises.every(Boolean)) return { text: `yes — ${renderIsaChain(premises)}`, replace: true };
+    }
     return null; // no remembered fact — the honest miss stands (never a guessed "no")
   }
 
@@ -2478,13 +2529,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;