@polycode-projects/the-mechanical-code-talker 1.9.2 → 1.10.0

package/src/interpret/strategies/keywords.mjs

@@ -1,7 +1,7 @@
-// interpret/strategies/keywords.mjs — strategy 2: keyword-spotting/decomposition,
-// extracted MOVE-only from ask.mjs (item 13). ELIZA's own mechanism: find the
-// keyword(s) anywhere in the text, decompose around them, tolerate reordering and
-// casual phrasing. Position-independent (no `^...$` anchor), so it tolerates
+// interpret/strategies/keywords.mjs — strategy 2: keyword-spotting/decomposition.
+// ELIZA's own mechanism: find the keyword(s) anywhere in the text, decompose
+// around them, tolerate reordering and casual phrasing. Position-independent
+// (no `^...$` anchor), so it tolerates
 // "what calls this" / "who invokes this" / "something executes this, where from"
 // — real phrasings the anchored grammar's fixed shapes don't cover.
 
@@ -13,11 +13,9 @@ import {
 import { STOPWORDS } from "../normalize.mjs";
 import { VOCAB_WORDS, eligibleForCanon, fuzzyVocabWord } from "../fuzzy.mjs";
 
-// Reversible-passive detection (Cycle 6, archive/PLAN_CYCLE_4.md): the passive auxiliaries that,
-// together with an agent-marking "by", flip the active reading, and the wh-words that
-// mark a QUESTIONED agent ("by which classes" / stranded "who is X tested by"). Bare
-// "do/does/did" are deliberately EXCLUDED — "which X do not <verb> Y" is a NEGATION, not
-// a passive, and must be left for the compositional complement frame.
+// Passive auxiliaries (with an agent-marking "by") that flip the active reading,
+// and the wh-words marking a questioned agent. Bare do/does/did are excluded —
+// that shape is a negation, not a passive.
 const PASSIVE_AUX = new Set(["is", "are", "was", "were", "be", "been", "being", "get", "gets", "got"]);
 const WH_WORDS = new Set(["which", "what", "who", "whom", "whose"]);
 const PLACEHOLDER_SET = new Set(PLACEHOLDER_NOUNS.map((w) => w.toLowerCase()));
@@ -42,38 +40,13 @@ export function findPhrase(lcWords, table, consumed = null) {
   return null;
 }
 
-/** Strategy 2: scan (already-normalized) text for a verb keyword anywhere,
- *  plus optional entity/modifier keywords anywhere, then split whatever's
- *  left (after removing the matched spans + stopwords) into the words BEFORE
- *  and AFTER the verb. Which side(s) are non-empty decides the shape —
- *  mirrors the three anchored shapes but by decomposition instead of a fixed
- *  template, so it tolerates reordering/casual phrasing the anchored regexes
- *  don't: text on BOTH sides ("does X import Y") -> ask{subject:before,
- *  object:after}; only AFTER the verb ("what calls this") -> reverse{object:
- *  after}; only BEFORE it ("what does X import") -> forward{object:before}.
- *  A lone context pronoun ("this"/"it"/"that"/"here") ending up as a resolved
- *  term is left as plain text — resolveTermOrContext (traverse-time)
- *  recognizes it against an optional contextId, so no separate flag is
- *  needed here. A misparse here costs nothing beyond an honest object-miss
- *  downstream (resolveObject never guesses).
- *
- *  Keyword matching is TIERED (two-level fuzzy work, 2026-07-02) — each lower
- *  tier fires ONLY when every tier above found no verb phrase at all, so an
- *  exact curated match can never be displaced:
- *    1. exact — the words as typed (post-normalization, which already applied
- *       the curated CONTRACTIONS/MISSPELLINGS/WRONG_WORDS corrections);
- *    2. lemma (only with the optional Node-side `nlp` adapter) — each eligible
- *       word is replaced by its wink lemma IF that lemma is itself a vocab word
- *       ("imported"/"importing" -> "import"), so inflections hit the curated
- *       phrases without enumerating them. Every verb family already stores its
- *       lemma form ("import", "call", "touch", "use", …), so a direct
- *       lemma-in-vocab check is the whole lookup — no reverse index needed;
- *    3. fuzzy (adapter-free; works in the inlined viewer too) — a word ≥4 chars
- *       matching nothing exactly may rewrite to a UNIQUE verb/modifier
- *       constituent within the bounded edit distance (see fuzzyVocabWord; ties
- *       are refused, entity nouns are never fuzzy targets).
- *  The canonicalized words drive PHRASE FINDING only — sideText always reads the
- *  ORIGINAL words, so a correction can never corrupt an object/subject term. */
+/** Strategy 2: find a verb keyword anywhere in the text, plus optional
+ *  entity/modifier keywords, then split what's left into words BEFORE and
+ *  AFTER the verb — both sides -> ask, after only -> reverse, before only ->
+ *  forward. Keyword matching is tiered (exact, then lemma, then fuzzy edit-
+ *  distance), each tier firing only when every tier above found nothing, so
+ *  an exact curated match can never be displaced. Canonicalized words drive
+ *  phrase finding only; sideText always reads the original words. */
 export function parseKeywordSpot(text, nlp = null) {
   // Strip a trailing "?" (mirrors the anchored templates' own `\??$`) and turn commas into
   // pauses/spaces — but NEVER strip a mid-word ".": object terms are routinely dotted file/module
@@ -81,12 +54,8 @@ export function parseKeywordSpot(text, nlp = null) {
   // must too or the two strategies would "disagree" over a period that was never part of the intent.
   const words = text.replace(/\?+\s*$/, "").replace(/,/g, " ").split(/\s+/).filter(Boolean);
   const lcWords = words.map((w) => w.toLowerCase());
-  // where/mentions shapes (2026-07-02 query families): "where is X [defined]" and
-  // "where is X mentioned" carry NO relation verb, so the verb-driven decomposition
-  // below can never reach them. Routed here by the "where" question word + marker —
-  // but ONLY when no relation verb exists anywhere in the sentence: "something
-  // executes this, where from" (an existing worked phrasing) has a verb, and its
-  // "where" is decorative, not a location question.
+  // where/mentions carry no relation verb, so only routed here when the sentence
+  // has no relation verb anywhere (otherwise "where" is merely decorative).
   if (lcWords.includes("where") && !findPhrase(lcWords, VERB_TO_KIND)) {
     const mention = lcWords.some((w) => MENTION_MARKERS.includes(w));
     const markers = new Set([...WHERE_MARKERS, ...MENTION_MARKERS]);
@@ -96,17 +65,10 @@ export function parseKeywordSpot(text, nlp = null) {
       return { shape: kind, entityType: null, modifier: "direct", kind, object: objText };
     }
   }
-  // has/have/had-changed carve-out (PLAN_CHAT_FEEL item 6 remainder): "has X
-  // changed" / "have X touched" / "had X ever been updated" — the present/past-
-  // perfect yes/no frame over the SAME touches-family verb the "when" branch below
-  // already answers ("when did X change"). Routed BEFORE the general verb-priority
-  // scan: "has"/"have"/"had" is ALSO a curated `defines` verb ("this module HAS
-  // three functions") and, sitting first in the sentence, would otherwise win that
-  // scan outright, misreading "has X changed" as a `defines` reverse-query over
-  // the object "X changed" — a confidently-wrong grain, not an honest miss. Gated
-  // on the sentence's OWN final word being a genuine touches verb (never a guess
-  // at which verb the sentence "really" means) — an ordinary defines question
-  // ("has app.mjs three functions") never ends in one, so this can't shadow it.
+  // has/have/had-changed carve-out ("has X changed"): routed before the general
+  // verb scan because has/have/had is ALSO the `defines` verb and would otherwise
+  // misread this as a defines query; gated on the sentence's own final word being
+  // a genuine touches verb.
   const PERFECT_AUX = new Set(["has", "have", "had"]);
   if (PERFECT_AUX.has(lcWords[0])) {
     let end = lcWords.length;
@@ -139,25 +101,17 @@ export function parseKeywordSpot(text, nlp = null) {
     if (verbHit) canonWords = fuzzyWords;
   }
   if (!verbHit && lcWords.includes("by")) {
-    // passive-participle rescue (Cycle 6): a participle whose kind is NOT a standalone
-    // active verb here ("defined" belongs to "is defined in"; bare "inherited" has no
-    // active key) still marks a passive when a passive auxiliary and an agent "by" are
-    // present. Consulted ONLY on this exact gate (aux + by), so the active grammar and
-    // the where-marker routing ("where is X defined") are never disturbed.
+    // A participle with no active verb entry still marks a passive when a passive
+    // auxiliary and an agent "by" are both present.
     for (let i = 0; i < lcWords.length; i += 1) {
       const k = PASSIVE_PARTICIPLE_TO_KIND[lcWords[i]];
       if (k && lcWords.slice(0, i).some((w) => PASSIVE_AUX.has(w))) { verbHit = { kind: k, start: i, end: i + 1 }; break; }
     }
   }
   if (!verbHit) return null;
-  // POS consumer (wink adapter, Node-side only): rescue the ONE decomposition this
-  // strategy provably mis-parses — a relation word used as a NOUN in a "the
-  // <imports> of <term>" nominal ("show the imports of walk.mjs" otherwise
-  // decomposes to ask{subject:"show"}; bare "the imports of walk.mjs" to the
-  // reverse shape, both wrong). The wink probe showed "import" is tagged NOUN even
-  // in genuine verb use ("which modules import walk.mjs"), so the POS signal is
-  // deliberately NOT a general verb veto — it only fires inside this exact
-  // det+NOUN+"of" frame, where the nominal reading is grammatically forced.
+  // POS rescue (Node-side only): a relation word used as a NOUN in a "the
+  // <imports> of <term>" frame would otherwise misparse; only fires inside this
+  // exact det+NOUN+"of" shape, since the same word tags NOUN in genuine verb use too.
   if (nlp && verbHit.end - verbHit.start === 1) {
     const i = verbHit.start;
     const det = lcWords[i - 1];
@@ -172,15 +126,8 @@ export function parseKeywordSpot(text, nlp = null) {
   const consumed = new Set();
   const mark = (hit) => { if (hit) for (let i = hit.start; i < hit.end; i += 1) consumed.add(i); };
   mark(verbHit);
-  // A redundant SAME-KIND verb immediately after the matched one ("what TESTS
-  // cover X" — "tests" is read as the relation trigger, but "cover" — also a
-  // `tests` verb, ask-vocab.mjs's own synonym list — is the word the sentence
-  // actually intends as the verb) would otherwise fall into afterText raw and
-  // corrupt the object ("cover src/core/model.mjs" instead of the module alone).
-  // Anchored to the exact position right after verbHit (never a general re-scan),
-  // and gated on matching the SAME kind, so this can only strip a genuine
-  // restatement, never eat a real object term. Found live: "what tests cover X",
-  // "which tests test X" both misparsed this way before this fix.
+  // A redundant same-kind verb restating the first ("what TESTS cover X") would
+  // otherwise corrupt the object; strip it, anchored right after verbHit.
   for (const [phrase, kind] of Object.entries(VERB_TO_KIND)) {
     if (kind !== verbHit.kind) continue;
     const pWords = phrase.split(" ");
@@ -204,39 +151,24 @@ export function parseKeywordSpot(text, nlp = null) {
   const entityType = entityHit ? ENTITY_TO_TYPE[canonWords.slice(entityHit.start, entityHit.end).join(" ")] : null;
   const modifier = modifierHit ? MODIFIER_TO_KIND[canonWords.slice(modifierHit.start, modifierHit.end).join(" ")] : "direct";
 
-  // when shape (2026-07-02 query families): "when did X change" / "when was X last
-  // touched" — the "when" question word turns a touches decomposition temporal.
-  // Only touches carries commit dates to answer with; a "when" next to any other
-  // relation verb falls through to the ordinary shapes (and their honest answers).
+  // "when" turns a touches decomposition temporal; other verbs fall through.
   if (kind === "touches" && lcWords.includes("when")) {
     const objText = beforeText || afterText;
     if (objText) return { shape: "when", entityType: null, modifier: "direct", kind: "touches", object: objText };
   }
 
-  // who-last shape (HANDOVER.md 2026-07-10 item 5): "who last touched X" / "who
-  // touched X last" used to fall into the ordinary reverse-list shape below and
-  // list EVERY touching commit's author, ignoring "last" entirely — the mirror
-  // gap of the "when" shape just above, which already answers a single newest
-  // commit. "who"/"last" are both STOPWORDS (normalize.mjs), so they never
-  // survive into beforeText/afterText either way — checked here, before they're
-  // stripped, the same way the "when" check above reads `lcWords` directly
-  // rather than the post-strip text.
+  // "who last touched X" would otherwise list every touching commit's author,
+  // ignoring "last" — checked directly against lcWords since both words are
+  // stopwords and wouldn't survive into beforeText/afterText.
   if (kind === "touches" && lcWords.includes("who") && lcWords.includes("last")) {
     const objText = beforeText || afterText;
     if (objText) return { shape: "whoLast", entityType: null, modifier: "direct", kind: "touches", object: objText };
   }
 
-  // reversible passive (Cycle 6, archive/PLAN_CYCLE_4.md): "PATIENT is VERBed BY AGENT" — an
-  // agent-marking "by" plus a passive auxiliary flips the active reading, so the AGENT
-  // (after "by") is the edge SUBJECT and the PATIENT the edge OBJECT. Object-first
-  // phrasing is otherwise read subject-first and the edge traversed backwards. Fires
-  // ONLY on a genuine agent "by": a passive auxiliary before the verb AND a standalone
-  // "by" NOT already swallowed into a multi-word verb phrase ("touched by"/"modified
-  // by" are single touches verbs, so their "by" is consumed and never triggers this) —
-  // an active query whose object merely contains a "by" token is untouched (the
-  // regression guard). The single NAMED role term becomes the object; whether the AGENT
-  // is named ("by b.test.mjs" → forward from the agent) or QUESTIONED ("by which
-  // classes" / a stranded "…tested by" → reverse over the patient) picks the direction.
+  // Reversible passive ("PATIENT is VERBed BY AGENT"): a passive auxiliary plus a
+  // standalone agent-marking "by" (not already swallowed into a multi-word verb
+  // phrase) flips subject/object; whether the agent is named or questioned picks
+  // forward vs. reverse.
   const byIdx = lcWords.indexOf("by");
   const hasPassiveAux = lcWords.slice(0, verbHit.start).some((w) => PASSIVE_AUX.has(w));
   if (byIdx >= 0 && !consumed.has(byIdx) && hasPassiveAux) {
@@ -263,13 +195,8 @@ export function parseKeywordSpot(text, nlp = null) {
   }
 
   if (beforeText && afterText) {
-    // REVERSE VERB SWAP (Seonix Batch 2 Fix 2): this decomposition assigns subject/
-    // object by POSITION (before the verb / after it), not by the verb's semantic
-    // direction — the same structural fact grammar.mjs's T1 "ask" template comment
-    // explains. "is X a superclass of Y" (or its bare "superclass" stem — see
-    // INHERITS_REVERSE_VERBS's own comment in ask-vocab.mjs) means the REVERSE of
-    // "is X a subclass of Y": swap once, here, at parse time, so evaluation always
-    // sees the equivalent forward-phrased question.
+    // A semantically-reverse verb ("superclass of") swaps subject/object, same as
+    // grammar.mjs's T1.
     const verbPhrase = canonWords.slice(verbHit.start, verbHit.end).join(" ");
     let subject = beforeText;
     let object = afterText;
@@ -277,31 +204,15 @@ export function parseKeywordSpot(text, nlp = null) {
     return { shape: "ask", entityType: null, modifier: "direct", kind, subject, object };
   }
   if (afterText) return { shape: "reverse", entityType, modifier, kind, object: afterText };
-  // "what is a kind of class" / "what inherits from function" (live-caught 2026-07-11
-  // follow-up to the ambiguousParse fix, commit 5c858bf): entityHit above is found
-  // ANYWHERE in the sentence and marked consumed before afterText is computed, so
-  // when the "kind of X"/"inherits X" idiom's object IS ITSELF one of the four
-  // code-graph entity-type nouns (class/function/method/module — ENTITY_TO_TYPE's
-  // own keys), the entity match swallows the ENTIRE post-verb span as a (wrong, in
-  // this shape) grain qualifier, leaving afterText empty and no candidate at all —
-  // the query silently fails to parse rather than answering or declining honestly.
-  // Scoped narrowly to kind==="inherits" (the one relation whose object is routinely
-  // a bare vocabulary noun with no further qualifier) and only when the ENTIRE
-  // post-verb span was consumed by the entity match (nothing else remains to be an
-  // object): re-read that span as the literal OBJECT text instead, entityType null
-  // (it names the thing being asked about here, not a grain filter on some other
-  // object). Every other kind/shape is unaffected — this never fires unless
-  // afterText is otherwise empty AND the sole cause is an entity-consumed span
-  // immediately after the verb.
+  // "what is a kind of class": when the object is itself an entity-type noun, the
+  // entity match swallows the whole post-verb span as a grain qualifier, leaving
+  // afterText empty — re-read that span as the object instead.
   if (kind === "inherits" && !beforeText && entityHit && entityHit.start === verbHit.end) {
     const entityText = canonWords.slice(entityHit.start, entityHit.end).join(" ");
     if (entityText) return { shape: "reverse", entityType: null, modifier, kind, object: entityText };
   }
-  // forward keeps the spotted entityType ("which modules did commit <sha> touch" is a
-  // forward decomposition — subject before the verb — whose asked grain would otherwise
-  // be lost); traverse() only consults it for the commit-as-subject grain selection,
-  // so plain forwards behave exactly as before. Modifier stays hardcoded: no forward
-  // closure traversal exists (see ask.mjs's modifierIsWired).
+  // forward keeps the spotted entityType (traverse()'s commit-as-subject grain
+  // selection); modifier stays hardcoded since no forward closure traversal exists.
   if (beforeText) return { shape: "forward", entityType, modifier: "direct", kind, object: beforeText };
   return null;
 }

package/src/interpret/strategies/noise-strip.mjs

@@ -1,45 +1,12 @@
-// interpret/strategies/noise-strip.mjs — the item-10 noise-tolerant fallback
-// strategy: strip filler/noise/stop words the closed grammar gives no meaning to,
-// then RE-RUN THE PARSE over what's left (the anchored grammar first, then the
-// keyword-spot decomposition — see the discipline notes). Rationale: the keyword-spot
-// strategy decomposes around the verb and a leading vocative/adverb lands in the
-// SUBJECT slot ("hey man which modules import X" -> ask{subject:"man"}), an
-// unresolvable term the relaxation cascade can only rescue when the true answer
-// is positive (it refuses to relax into a miss) — so a noise-wrapped question
-// whose honest answer is negative/empty dies as "couldn't resolve one of the
-// terms". Stripping the noise FIRST recovers the template parse and the same
-// honest answer the clean phrasing gets.
+// interpret/strategies/noise-strip.mjs — noise-tolerant fallback strategy:
+// strip filler/noise/stop words the closed grammar gives no meaning to, then
+// re-parse what's left (anchored templates first, then keyword-spot).
 //
-// Discipline (no behavior change to anything that already parses):
-//   · fires ONLY when the anchored grammar MISSES the text as-given — if a
-//     template already matches, the grammar owns the sentence, noise and all;
-//   · strips ONLY all-lowercase alphabetic tokens (a Capitalized/dotted/digit
-//     token names something) that are curated noise (FILLER_WORDS + the
-//     cascade's CASCADE_NOISE) or wink-flagged English stop words (ctx.nlp's
-//     isStopWord — the optional Node-only tier), and NEVER a word in KEEP: the
-//     grammar's own vocabulary, question scaffolding, and context pronouns;
-//   · returns a candidate ONLY when the stripped text then parses — first against
-//     the anchored TEMPLATES (the strictest parser), then (cycle-2 robustness,
-//     CHATBENCH_001 L1) against the keyword-spot decomposition over the SAME
-//     stripped text. The second tier exists because the clean phrasing of half
-//     the worked questions ("what calls fnAlpha") is itself a keyword-spot
-//     parse, not a template — so a noise-wrapped variant ("i was wondering what
-//     calls fnAlpha", "hey tmct, what calls fnAlpha thanks") could never be
-//     rescued by the template re-parse alone and died as "couldn't resolve one
-//     of the terms". The keyword-spot re-parse also swallows auxiliary-verb
-//     residue for free ("was what calls fnAlpha" → reverse{fnAlpha}): its
-//     decomposition filters STOPWORDS out of the subject/object sides, which is
-//     exactly where a stripped frame's "was"/"is" residue lands. Same cost
-//     bound as before: only curated-noise/stop-word tokens were removed, and a
-//     wrongly-stripped word can at worst cost an honest object-miss downstream
-//     (resolveObject never guesses), never manufacture an entity.
-//
-// Registered with its own class ("noise-stripped") at confidence 0.75: above
-// keyword-spot (0.7 — over noisy text its decomposition has provably swallowed
-// the noise into a term) and below the anchored grammar (0.9 — which anyway
-// gates this strategy off whenever it fires). A distinct class, so disagreement
-// with keyword-spot is a ranked winner + "if you mean X then …" alternate,
-// never a forced same-class ambiguity over a garbage subject.
+// Fires only when the anchored grammar misses the text as-given. Strips only
+// curated noise or wink-flagged stop words, never a word in KEEP (grammar
+// vocabulary, question scaffolding, context pronouns). Registered as its own
+// class ("noise-stripped") at confidence 0.75 — above keyword-spot, below the
+// anchored grammar.
 
 import {
   VERB_TO_KIND, ENTITY_TO_TYPE, MODIFIER_TO_KIND, META_MEANING_VERBS,
@@ -73,34 +40,11 @@ const KEEP = new Set([
  *  carried here too so the strategy stands alone) + the cascade's noise list. */
 const CURATED_NOISE = new Set([...wordsOf(FILLER_WORDS), ...wordsOf(CASCADE_NOISE)]);
 
-/** Words this pass keeps but flags as UNCERTAIN (PLAN_CONVERSATION.md Finding 2
- *  — the "store"/"keep" gap): wink's `isStopWord` is a generic English
- *  dictionary, not purpose-built for this codebase — it happens to flag
- *  "keep"/"put"/"get" but not their close synonyms "store"/"hold"/"place"/
- *  "save" sitting in the exact same no-relation-verb slot ("where would i
- *  keep/store a router"), so a KEPT word surviving the pass above is not
- *  necessarily real content. A curated synonym list was tried and rejected
- *  (see the file doc / PLAN_CONVERSATION.md): "store"/"hold"/"save" are
- *  exactly the words most likely to ALSO be a real identifier ("where does
- *  the store live" must not lose its subject). The general, non-curated
- *  signal that discriminates the two: wink's POS tagger, reading the WHOLE
- *  ORIGINAL sentence for real grammatical context (an isolated 2-word
- *  fragment like "store router" tags BOTH words NOUN — confirmed live; the
- *  same "store" in "where would i store a router" tags VERB, and in "where
- *  does the store live" tags NOUN — also confirmed live, so the isolated
- *  object phrase alone can never carry this signal; it must be read here,
- *  off the whole sentence, before the phrase is extracted).
- *
- *  A KEPT word wink tags VERB here is returned as `maybeNoise`, NOT stripped
- *  outright — this function has no graph to check a resolution against
- *  (interpret/pipeline.mjs's own documented boundary: "no graph access
- *  here"). The caller below turns this into a second candidate reading;
- *  ask.mjs's traverse() (where the graph lives) tries both and prunes the
- *  one that misses/ties in favor of the one that resolves cleanly —
- *  mirroring resolveObject's own grain-word retry (try a variant, keep it
- *  only on an unambiguous hit) and grammar/ace.mjs's parseAceAmbiguous
- *  ("keep only complete, valid parses"). Never guessed here; always pruned
- *  where the evidence (the graph) actually is. */
+/** Words this pass keeps but flags as UNCERTAIN: wink's generic isStopWord
+ *  misses light-verb synonyms ("store"/"hold" for "keep"/"put"), which are
+ *  also plausible real identifiers, so a whole-sentence POS tag (VERB here)
+ *  marks them `maybeNoise` rather than stripping them outright — the caller
+ *  tries both readings and ask.mjs's traverse() prunes using the graph. */
 function maybeVerbNoiseWords(words, kept, nlp) {
   if (!nlp || typeof nlp.posTags !== "function" || !kept.length) return [];
   const keptSet = new Set(kept.map((w) => w.toLowerCase()));
@@ -148,28 +92,13 @@ export const noiseStripStrategy = {
     if (parseAnchored(text)) return null; // the grammar owns the text as-given
     const { text: stripped, dropped, maybeNoise } = stripNoise(text, ctx.nlp || null);
     if (!dropped.length || !stripped) return null;
-    // tier 1: the anchored templates over the stripped text — the strictest
-    // re-parse, tried first so a template shape is never displaced by a looser
-    // decomposition of the same words. tier 2 (cycle-2, CHATBENCH_001 L1): the
-    // keyword-spot decomposition over the SAME stripped text — the parser the
-    // clean phrasing of non-template questions ("what calls fnAlpha") actually
-    // uses, so their noise-wrapped variants recover the identical honest answer
-    // (see the file doc for the discipline/cost argument).
+    // Re-parse: the anchored templates first, then keyword-spot (the parser
+    // that clean non-template phrasings like "what calls fnAlpha" already use).
     const parsed = parseAnchored(stripped) || parseKeywordSpot(stripped, ctx.nlp || null);
     if (!parsed) return null;
-    // Finding 2 extension (PLAN_CONVERSATION.md): a bare "where"/"mentions"
-    // question is the ONE shape with no explicit relation verb gating its
-    // object (every other decomposition in keywords.mjs requires a real
-    // VERB_TO_KIND match before it ever runs), so it's the only place an
-    // unlisted light verb ("store", "hold", …) can leak into the object
-    // phrase untouched. Scoped to exactly that shape — deliberately not a
-    // blanket change to stripNoise's shared criteria, per the file's own
-    // construction-scoping caveat. `altObject` rides along on the SAME
-    // single candidate (not a second strategy candidate — that would force
-    // mergeStrategyResults' pre-resolution ambiguousParse surface on every
-    // hit, before anyone has checked whether it's even real ambiguity);
-    // ask.mjs's traverse() is the one place both the alternate reading and
-    // the graph are available together to actually prune it.
+    // where/mentions has no relation verb gating its object, so it's the one shape
+    // an unlisted light verb can leak into untouched; `altObject` rides on the same
+    // candidate so ask.mjs's traverse() can prune using the graph.
     if (maybeNoise.length && (parsed.shape === "where" || parsed.shape === "mentions") && parsed.object) {
       const altObject = parsed.object.split(/\s+/).filter((w) => !maybeNoise.includes(w.toLowerCase())).join(" ").trim();
       if (altObject && altObject !== parsed.object) parsed.altObject = altObject;

package/src/memory/bias.mjs

@@ -1,40 +1,13 @@
-// memory/bias.mjs — bias-weighted fact ranking (extension-pack batch, Part 6).
-//
-// A small, PURE module, deliberately SEPARATE from trust.mjs's existing closed
-// 3-input computeTrust contract (many tests pin computeTrust's exact
-// signature; this module never touches it). Trust answers "how much do I
-// believe this fact"; bias answers a DIFFERENT question an operator asks
-// explicitly — "when two facts disagree, which BUNDLE do I prefer to hear
-// from first" (the worked example: is a class part of code, or part of a
-// school — a `[bias]` table lets an operator say "for MY repo, weight the
-// code-vocabulary bundle over the general-English one").
-//
-//   biasForSourceId(sourceId, biasByBundle)  "src:corpus:<name>" -> weight (default 1)
-//   biasForRow(row, biasByBundle)            max bias across row.sourceIds
-//   rankByBiasThenTrust(rows, biasByBundle)  stable: bias desc, trust desc, original order
-//
-// biasByBundle is the flat `{ bundleName: number }` table src/extensions.mjs's
-// resolveExtensions() reads out of tmct.toml's `[bias]` table — resolved ONCE
-// per chat session and threaded through, never re-read per turn.
-//
-// CRITICAL CONTRACT (the operator's own "disclosed, never dropped"
-// requirement): bias only REORDERS a hit list. It must NEVER drop, hide, or
-// silently prefer a lower-biased fact over a higher-trust one within the same
-// bias tier — every hit rankByBiasThenTrust is given still comes back out,
-// same length, same members, just reordered.
+// memory/bias.mjs — bias-weighted fact ranking, separate from trust.mjs's
+// computeTrust. `biasByBundle` is the `[bias]` table from tmct.toml. CRITICAL:
+// bias only REORDERS a hit list — it must never drop or hide one.
 
-/** A Fact's statedBy Source id is shaped "src:corpus:<bundleName>" for every
- *  corpus-kind Source (memory/core.mjs's own sourceIdFor — see its `corpus`
- *  case). Any other shape (operator/teach/provider/web/entailed Source ids,
- *  or a malformed/absent id) is NOT a corpus bundle and always ranks at the
- *  neutral bias of 1 — bias is a corpus-bundle-only concept, never a proxy
- *  for a different trust dimension. */
+/** Matches a corpus-kind Source id ("src:corpus:<bundleName>"); anything else
+ *  is not a corpus bundle and ranks at the neutral bias of 1. */
 const CORPUS_SOURCE_RE = /^src:corpus:(.+)$/;
 
-/** The bias weight of one Source id, resolved against `biasByBundle`. Default
- *  1 (neutral) for a non-corpus source id, an unconfigured bundle name, or a
- *  non-numeric configured value (never throws — a malformed `[bias]` entry is
- *  caught earlier, at resolveExtensions() load time). */
+/** The bias weight of one Source id, resolved against `biasByBundle` (default
+ *  1 when unconfigured or non-numeric; never throws). */
 export function biasForSourceId(sourceId, biasByBundle = {}) {
   const m = CORPUS_SOURCE_RE.exec(String(sourceId || ""));
   if (!m) return 1;
@@ -42,32 +15,16 @@ export function biasForSourceId(sourceId, biasByBundle = {}) {
   return typeof v === "number" && Number.isFinite(v) ? v : 1;
 }
 
-/** The bias weight of one fact ROW (readFactRows' shape: `{..., sourceIds}`)
- *  — the MAX bias across its (possibly several, corroborating) Sources, so a
- *  fact corroborated by both a neutral and a high-bias bundle ranks at the
- *  higher of the two, never averaged down. A row with no sourceIds (or an
- *  empty array) ranks at the neutral 1. */
+/** A fact row's bias: the MAX across its (possibly several) Sources, never
+ *  averaged down. No sourceIds -> neutral 1. */
 export function biasForRow(row, biasByBundle = {}) {
   const ids = Array.isArray(row?.sourceIds) ? row.sourceIds : [];
   if (!ids.length) return 1;
   return Math.max(...ids.map((id) => biasForSourceId(id, biasByBundle)));
 }
 
-/**
- * Rank fact rows by bias (desc), then trust (desc), then original relative
- * order (STABLE — Array.prototype.sort is stable in Node, reinforced here
- * with an explicit index tiebreak so the guarantee never depends on engine
- * internals). Every row that goes in comes back out — same length, same
- * members — this ONLY reorders, it never filters or drops a hit, honouring
- * the "disclosed, never dropped" contract every caller in chat.mjs relies on.
- *
- * With an empty/absent `biasByBundle` (the default, unconfigured case) every
- * row's bias is 1 — a true no-op tier, so the sort degrades to trust-desc,
- * ties broken by original order: BYTE-IDENTICAL to today's behaviour for any
- * caller that previously sorted by trust alone (or didn't sort at all and
- * every row happened to share the same trust, the common single-session
- * operator-taught case).
- */
+/** Rank fact rows by bias (desc), then trust (desc), then original order
+ *  (stable) — reorders only, never drops a row. */
 export function rankByBiasThenTrust(rows, biasByBundle = {}) {
   const list = Array.isArray(rows) ? rows : [];
   return list