@polycode-projects/the-mechanical-code-talker 2.7.9 → 2.7.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polycode-projects/the-mechanical-code-talker",
-  "version": "2.7.9",
+  "version": "2.7.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/domain/grammar/ace.mjs

@@ -502,7 +502,15 @@ const VERB_SYNONYMS = new Map([
 // consumed whole before any shorter prefix inside it gets a chance to match.
 const VERB_SYNONYM_MAX_PREFIX = Math.max(...[...VERB_SYNONYMS.keys()].map((k) => k.split(" ").length));
 
-const VERB_FUZZY_CANDIDATES = [...new Set([...IMPERATIVE_VERBS, ...VERB_SYNONYMS.values()])];
+// Every leading SURFACE word the exact tiers below recognise as the start of
+// a command: a bare IMPERATIVE_VERBS word, or the first token of any
+// VERB_SYNONYMS key (single- or multi-word alike — "pick", "have", "chat" are
+// each only ever a key's own first word, never a key on their own, so they'd
+// otherwise have nothing to fuzzy-repair a typo onto). Corrects the SURFACE
+// word, not the canonical verb, so the existing exact-match tiers below (in
+// particular the multi-word prefix loop) still resolve the rest of the phrase
+// after repair — "hav a look at" -> "have a look at" -> examine, not just "look".
+const VERB_SURFACE_WORDS = [...new Set([...IMPERATIVE_VERBS, ...[...VERB_SYNONYMS.keys()].map((k) => k.split(" ")[0])])];
 const IMPERATIVE_FUZZY_BOUND = 1; // this project's existing distance-1 tolerance elsewhere (interpret/fuzzy.mjs)
 
 // A small, hand-checked exemption (same idiom as this file's own
@@ -513,31 +521,48 @@ const IMPERATIVE_FUZZY_BOUND = 1; // this project's existing distance-1 toleranc
 // Checked against this repo's own WordNet corpus, not guessed.
 const NEVER_FUZZY_VERB = new Set(["walk", "wake", "make"]);
 
-/** Resolve the leading verb token(s) to a canonical, recognised verb: the
- *  2-token VERB_SYNONYMS prefix FIRST (so "talk to"/"look at" resolve as
- *  themselves rather than as the bare exact verbs "talk"/"look" they'd
- *  otherwise short-circuit on, leaving their "to"/"at" stranded in the object
- *  phrase), then an exact IMPERATIVE_VERBS match, then the 1-token
- *  VERB_SYNONYMS form, then a bounded fuzzy typo repair against the same
- *  vocabulary. `consumed` is how many leading tokens the match ate (1, or 2
- *  for a two-word synonym phrase); `corrected` is non-null only for the
- *  fuzzy tier. Null when nothing at all recognises the leading token(s). */
-function resolveImperativeVerb(toks) {
+/** The three deterministic (non-fuzzy) tiers: a 2+-token VERB_SYNONYMS prefix
+ *  FIRST (so "talk to"/"look at" resolve as themselves rather than as the
+ *  bare exact verbs "talk"/"look" they'd otherwise short-circuit on, leaving
+ *  their "to"/"at" stranded in the object phrase), then an exact
+ *  IMPERATIVE_VERBS match, then the 1-token VERB_SYNONYMS form. `consumed` is
+ *  how many leading tokens the match ate. Null when none of the three match. */
+function exactImperativeVerb(toks) {
   const first = toks[0].toLowerCase();
   const lower = toks.map((t) => t.toLowerCase());
   for (let n = Math.min(VERB_SYNONYM_MAX_PREFIX, toks.length); n >= 2; n -= 1) {
     const hit = VERB_SYNONYMS.get(lower.slice(0, n).join(" "));
-    if (hit) return { verb: hit, consumed: n, corrected: null };
+    if (hit) return { verb: hit, consumed: n };
   }
-  if (IMPERATIVE_VERBS.has(first)) return { verb: first, consumed: 1, corrected: null };
+  if (IMPERATIVE_VERBS.has(first)) return { verb: first, consumed: 1 };
   const oneHit = VERB_SYNONYMS.get(first);
-  if (oneHit) return { verb: oneHit, consumed: 1, corrected: null };
-  if (NEVER_FUZZY_VERB.has(first)) return null;
-  const fuzzyHit = fuzzyMatchInSet(first, VERB_FUZZY_CANDIDATES, IMPERATIVE_FUZZY_BOUND);
-  if (fuzzyHit) return { verb: fuzzyHit, consumed: 1, corrected: { from: first, to: fuzzyHit } };
+  if (oneHit) return { verb: oneHit, consumed: 1 };
   return null;
 }
 
+/** Resolve the leading verb token(s) to a canonical, recognised verb: the
+ *  three exact tiers above, failing that a bounded fuzzy TYPO repair
+ *  (distance <= 1, via the existing interpret/fuzzy.mjs matcher) of the
+ *  leading token against every recognised surface word, single- or
+ *  multi-word idiom alike, then the exact tiers retried against the
+ *  corrected token — so a typo'd idiom lead word ("hav a look at") is
+ *  repaired to its real word first ("have a look at") and still resolves the
+ *  whole idiom, not just a bare-verb guess. Only the fuzzy tier is a
+ *  correction of an ERROR rather than a recognised alternate wording, so only
+ *  it is reported back on the command (`corrected`) for the caller to name in
+ *  its response — a synonym executes silently, a typo fix does not. */
+function resolveImperativeVerb(toks) {
+  const exact = exactImperativeVerb(toks);
+  if (exact) return { ...exact, corrected: null };
+  const first = toks[0].toLowerCase();
+  if (NEVER_FUZZY_VERB.has(first)) return null;
+  const fixedFirst = fuzzyMatchInSet(first, VERB_SURFACE_WORDS, IMPERATIVE_FUZZY_BOUND);
+  if (!fixedFirst) return null;
+  const retried = exactImperativeVerb([fixedFirst, ...toks.slice(1)]);
+  if (!retried) return null;
+  return { ...retried, corrected: { from: first, to: fixedFirst } };
+}
+
 /** Resolve one imperative object phrase to its bare lexicon term. */
 function imperativeNP(lexicon, tokens) {
   const np = resolveNP(lexicon, tokens);

package/src/services/adventure.mjs

@@ -91,6 +91,15 @@ async function openAdventure(opening, { planHolder, memoryDir, sessionId, env, c
       note: "ADVENTURE — opening declined: the world's shard failed to load",
     };
   }
+  // A world sharing this pack but shaped for a different game entirely (e.g.
+  // spider-fly, which has no player-controlled entity at all — its board is
+  // reusable static content, and player/spider/fly individuals are minted
+  // fresh by that game's own opener, never shipped in the pack) has no
+  // starting player placement. Decline cleanly rather than load a broken
+  // adventure session — the same "not necessarily an adventure ask at all"
+  // fallthrough an unrecognized name already gets, so whichever lane DOES
+  // own this name gets a chance to claim it instead.
+  if (!payload.facts.some((f) => f.subject === "player")) return null;
 
   const tag = worldProvenanceTag(world);
   await appendFacts(memoryDir, payload.facts.map((f) => ({

package/src/services/spider-fly-turn.mjs

@@ -26,12 +26,14 @@ import { appendFacts, appendRule, loadMemory, readFactRows } from "../adapters/m
 // ---- recognizers: the closed opening/stop/tick/address set -------------------
 
 // The opener names the game without requiring a specific phrasing order —
-// "watch the spider and the fly" / "play spider and fly" / "start the
-// spider game" all match. Closed vocabulary only (watch/play/start/begin,
-// spider, fly, game) — no general "start X" grammar, matching this
-// project's standing preference and adventure.mjs's own opener style.
+// "watch the spider and the fly" / "play spider and fly" / "play spider fly"
+// (the "and" is optional — playtests/PLAYTEST_LOG_006.md found it's a
+// natural drop) / "start the spider game" all match. Closed vocabulary only
+// (watch/play/start/begin, spider, fly, game) — no general "start X"
+// grammar, matching this project's standing preference and adventure.mjs's
+// own opener style.
 const SPIDER_FLY_OPEN_RE =
-  /^(?:let'?s\s+)?(?:watch|play|start|begin)\s+(?:the\s+)?spider(?:\s+and\s+(?:the\s+)?fly)?(?:\s+game)?[.!?\s]*$/i;
+  /^(?:let'?s\s+)?(?:watch|play|start|begin)\s+(?:the\s+)?spider(?:\s+(?:and\s+)?(?:the\s+)?fly)?(?:\s+game)?[.!?\s]*$/i;
 // "stop watching" is this game's own stop word (there's nothing to "play" in
 // the sense of typing moves — you watch, or address an agent), kept
 // alongside "stop playing" so either reads naturally depending on how the

package/src/surfaces/web/memory-ask-browser.bundle.js

@@ -21709,7 +21709,7 @@ ${codeblock}`, options);
   });
 
   // src/domain/grammar/ace.mjs
-  var PATTERN_SUB_CLASS_OF, PATTERN_TYPE_ASSERTION, PATTERN_RELATION, PATTERN_SOME_VALUES_FROM, PATTERN_CARDINALITY, PATTERN_DISJOINT_WITH, PATTERN_POSSESSIVE, PATTERN_ADJECTIVE, PATTERN_CAPABILITY, PATTERNS, IMPERATIVE_VERBS, VERB_SYNONYMS, VERB_SYNONYM_MAX_PREFIX, VERB_FUZZY_CANDIDATES;
+  var PATTERN_SUB_CLASS_OF, PATTERN_TYPE_ASSERTION, PATTERN_RELATION, PATTERN_SOME_VALUES_FROM, PATTERN_CARDINALITY, PATTERN_DISJOINT_WITH, PATTERN_POSSESSIVE, PATTERN_ADJECTIVE, PATTERN_CAPABILITY, PATTERNS, IMPERATIVE_VERBS, VERB_SYNONYMS, VERB_SYNONYM_MAX_PREFIX, VERB_SURFACE_WORDS;
   var init_ace2 = __esm({
     "src/domain/grammar/ace.mjs"() {
       init_lexicon();
@@ -21758,7 +21758,7 @@ ${codeblock}`, options);
         ["shut", "close"]
       ]);
       VERB_SYNONYM_MAX_PREFIX = Math.max(...[...VERB_SYNONYMS.keys()].map((k) => k.split(" ").length));
-      VERB_FUZZY_CANDIDATES = [.../* @__PURE__ */ new Set([...IMPERATIVE_VERBS, ...VERB_SYNONYMS.values()])];
+      VERB_SURFACE_WORDS = [.../* @__PURE__ */ new Set([...IMPERATIVE_VERBS, ...[...VERB_SYNONYMS.keys()].map((k) => k.split(" ")[0])])];
     }
   });