@polycode-projects/the-mechanical-code-talker 1.12.0 → 2.0.1

package/src/domain/interpret/nlp-registry.mjs

@@ -0,0 +1,20 @@
+// interpret/nlp-registry.mjs — the default lemma/POS adapter slot. The domain
+// parser never imports the wink adapter; a composition point (chat.mjs,
+// server.mjs, index.mjs) registers ask-nlp.mjs's factory here at load time.
+// Nothing registered (the browser bundle, a pure-domain unit test) means
+// defaultNlp() is null — the same adapter-less tier the old
+// `typeof nlpAdapter === "function"` guard selected.
+
+let defaultAdapterFactory = null;
+
+/** Register the process-default adapter FACTORY (ask-nlp.mjs's nlpAdapter —
+ *  a function returning the { lemma, isStopWord, posTags } adapter or null). */
+export function setDefaultNlpAdapter(factory) {
+  defaultAdapterFactory = factory;
+}
+
+/** The default lemma/POS adapter instance, or null when no factory is
+ *  registered (or the registered one reports the deps unavailable). */
+export function defaultNlp() {
+  return typeof defaultAdapterFactory === "function" ? defaultAdapterFactory() : null;
+}

package/src/{interpret → domain/interpret}/normalize.mjs

@@ -8,7 +8,7 @@
 import {
   CONTRACTIONS, MISSPELLINGS, WRONG_WORDS, G_DROP, FILLER_WORDS,
   NEGATION_FRAMES, COMMIT_CONTENT_FRAMES, VERB_TO_KIND, ENTITY_TO_TYPE,
-  TRAILING_SCOPE_FILLER,
+  TRAILING_SCOPE_FILLER, TRAILING_TEMPORAL_ADVERBS,
 } from "../ask-vocab.mjs";
 
 export function escapeRegex(s) {
@@ -337,15 +337,35 @@ export function applyConditionalFrames(text) {
  *  force lowercase — object/subject terms (module/class names) are
  *  meaningfully cased, and every substitution already matches
  *  case-insensitively. */
+/** The contraction table applied on its own — "what's on peg-a" -> "what is on
+ *  peg-a". normalizeQuery's first pass, lifted out for callers that count words
+ *  and need "what's" counted as the two it stands for, without the filler strip
+ *  that would take words back off. Pure and idempotent. */
+export function expandContractions(text) {
+  return String(text || "").replace(CONTRACTION_RE, (m) => CONTRACTIONS[m.toLowerCase()]);
+}
+
+/** "where is disk-1 now" -> "where is disk-1". A locative question's answer is the
+ *  same with the adverb or without it, so the word carries nothing to read — but
+ *  the where template's term capture runs to the end of the string and binds it,
+ *  which then shows up in the receipt as part of the term. Stripped here, in the
+ *  shared pre-pass, so both parse strategies see one string and cannot disagree
+ *  about where the term ends. Anchored to "where is/are/was/were" and to the end:
+ *  a term of the same name elsewhere in a question is untouched. */
+const WHERE_TRAILING_TEMPORAL_RE = new RegExp(
+  `^(where\\s+(?:is|are|was|were)\\s+.+?)\\s+(?:${TRAILING_TEMPORAL_ADVERBS.map(escapeRegex).join("|")})(\\s*[?.!]*)$`,
+  "i",
+);
+
 export function normalizeQuery(text) {
-  let q = String(text || "");
-  q = q.replace(CONTRACTION_RE, (m) => CONTRACTIONS[m.toLowerCase()]);
+  let q = expandContractions(text);
   q = q.replace(MISSPELLING_RE, (m) => MISSPELLINGS[m.toLowerCase()]);
   q = q.replace(WRONG_WORD_RE, (m) => WRONG_WORDS[m.toLowerCase()]);
   q = q.replace(W_SLASH_RE, "with");
   q = q.replace(FOR_DIGIT_THANKS_RE, (_, w) => `${w} for`);
   q = q.replace(FOR_DIGIT_EXAMPLE_RE, (_, w) => `for ${w}`);
   q = q.replace(KIND_NOUN_ANAPHORA_RE, (_, pron) => pron);
+  q = q.replace(WHERE_TRAILING_TEMPORAL_RE, "$1$2");
   q = q.replace(G_DROP, "$1ing");
   q = applyPreambleFrames(q);
   // self-correction runs before subordination/conditional: a false start can
@@ -495,12 +515,22 @@ export function applyPhrasingFrames(text) {
 // <verb> Y") and returns a descriptor, distinct from the rhetorical
 // double-negative rewriter above (which REMOVES negation instead of
 // preserving it as a set operation).
+// The modal negations ("which X cannot <verb> Y", "which X can't <verb> Y")
+// ride the same shape: the graph only records what IS, so the nearest
+// answerable reading of a modal negation is the same factual complement "do
+// not" asks for. Leaving them out doesn't produce a miss — a later strategy
+// reads the modal as filler and answers with the POSITIVE set, the exact
+// inverse of the question. The fused forms are matched HERE rather than
+// expanded in the shared CONTRACTIONS table because that table also feeds the
+// teach lane, where "a penguin cannot fly" is a negative capability teach with
+// its own grounding gate; rewriting it upstream diverted it past that gate.
 const NEGATION_SET_RE = new RegExp(
   "^(?:which|what|who|list|show(?:\\s+me)?|find|give\\s+me)?\\s*(?:the\\s+|all\\s+)?"
   + "([a-z][a-z-]*)\\s+"
   + "(?:(?:that|which|who)\\s+)?"
-  + "(?:(?:do|does|did|are|is|was|were|have|has)\\s+)?"
-  + "not\\s+(.+)$",
+  + "(?:(?:do|does|did|are|is|was|were|have|has|can|could|will|would|should)\\s+not"
+  + "|cannot|can't|won't|couldn't|shouldn't|wouldn't"
+  + "|not)\\s+(.+)$",
   "i",
 );
 

package/src/{interpret → domain/interpret}/pipeline.mjs

@@ -19,7 +19,7 @@ import { noiseStripStrategy } from "./strategies/noise-strip.mjs";
 import { aceStrategy } from "./strategies/ace.mjs";
 import { constructionsStrategy } from "./strategies/constructions.mjs";
 import { mergeStrategyResults } from "./merge.mjs";
-import { nlpAdapter } from "../ask-nlp.mjs";
+import { defaultNlp } from "./nlp-registry.mjs";
 
 /** Registered strategies, in precedence order: grammar + keyword-spot (shared
  *  "graph-query" class), noise-strip (fires only when the anchored grammar
@@ -43,10 +43,6 @@ export function normalizeInput(input) {
   return { raw, text, changed: text !== raw };
 }
 
-function defaultNlp() {
-  return typeof nlpAdapter === "function" ? nlpAdapter() : null;
-}
-
 /** Synchronous strategy run (ask.mjs's parseQuery path). Skips a Promise-
  *  returning strategy and drops a throwing one; returns results in precedence order. */
 export function runStrategiesSync(text, ctx = {}, strategies = STRATEGIES) {

package/src/{interpret → domain/interpret}/strategies/ace.mjs

@@ -1,5 +1,5 @@
 // interpret/strategies/ace.mjs — the ACE-OWL controlled-fragment grammar
-// (src/grammar/ace.mjs) wired into the pipeline as an additive strategy: its
+// (src/domain/grammar/ace.mjs) wired into the pipeline as an additive strategy: its
 // own class ("ace-fact"), so a clean parse surfaces as an alternate, never
 // displacing a graph-query winner.
 

package/src/{interpret → domain/interpret}/strategies/constructions.mjs

@@ -1,58 +1,24 @@
 // interpret/strategies/constructions.mjs — construction-grammar template
-// banks, loaded as DATA from data/templates/constructions/*.toml (pattern ->
-// AST skeleton, slot types validated against RELATIONS/ENTITY_TO_TYPE),
-// registered as its own additive class ("construction") so a match outranks
-// a same-text keyword-spot guess rather than colliding with it.
+// banks (pattern -> AST skeleton, slot types validated against
+// RELATIONS/ENTITY_TO_TYPE), registered as their own additive class
+// ("construction") so a match outranks a same-text keyword-spot guess rather
+// than colliding with it.
 //
-// Loader is synchronous, cached once per process, and defensive: a missing
-// directory, unparseable TOML, or invalid entry is silently dropped, never
-// thrown.
-
-import { readFileSync, readdirSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-import { join, dirname } from "node:path";
-import { parse as parseToml } from "smol-toml";
+// The banks are DATA that rides in from outside: a composition point
+// (chat.mjs, server.mjs, index.mjs) reads data/templates/constructions/*.toml
+// through corpus/construction-banks.mjs and registers the raw tables here via
+// setConstructionBanks — this strategy never touches the filesystem. Compile
+// is cached once per registration and defensive: an invalid entry is silently
+// dropped, never thrown; no registration means an empty bank (the strategy
+// simply never fires).
 
 import { RELATIONS, ENTITY_TO_TYPE } from "../../ask-vocab.mjs";
 import { escapeRegex } from "../normalize.mjs";
 
-const STRATEGY_DIR = dirname(fileURLToPath(import.meta.url));
-/** The construction-bank directory (data, not code) — every *.toml file inside
- *  is loaded, in filename order, so a future bank is a new committed file, not
- *  an edit to this loader. */
-export const CONSTRUCTIONS_DIR = join(STRATEGY_DIR, "..", "..", "..", "data", "templates", "constructions");
-
 const VALID_KINDS = new Set(Object.keys(RELATIONS));
 const VALID_ENTITY_TYPES = new Set(Object.values(ENTITY_TO_TYPE));
 const VALID_SHAPES = new Set(["ask", "reverse", "forward", "where", "when", "meta", "mentions"]);
 
-/** Read every *.toml file in `dir` (sorted, deterministic) and return the raw
- *  parsed tables concatenated: {relations:[...], constructions:[...]}. A
- *  missing directory or an unparseable file is DEFENSIVE (per-file: a broken
- *  file is skipped, not fatal to the others) — callers get whatever validly
- *  parsed, never a thrown error from a data-authoring mistake. */
-export function readConstructionFiles(dir = CONSTRUCTIONS_DIR) {
-  let files;
-  try {
-    files = readdirSync(dir).filter((f) => f.endsWith(".toml")).sort();
-  } catch {
-    return { relations: [], constructions: [] };
-  }
-  const relations = [];
-  const constructions = [];
-  for (const file of files) {
-    let parsed;
-    try {
-      parsed = parseToml(readFileSync(join(dir, file), "utf8"));
-    } catch {
-      continue; // one malformed file never takes the others down
-    }
-    if (Array.isArray(parsed.relation)) relations.push(...parsed.relation);
-    if (Array.isArray(parsed.construction)) constructions.push(...parsed.construction);
-  }
-  return { relations, constructions };
-}
-
 /** Validate + index the raw [[relation]] rows into noun -> {kind, entityType}.
  *  Closed-vocabulary validation: `kind` MUST be
  *  one of RELATIONS' own keys and `entityType` (when present) MUST be one of
@@ -122,24 +88,36 @@ export function buildConstructionTemplates(constructions, agentNounTable) {
   return out;
 }
 
+let bankSource = null; // raw tables, or a () => raw-tables loader
 let bankCache = null;
 
+/** Register the raw construction tables ({relations, constructions}) or a
+ *  lazy loader returning them (corpus/construction-banks.mjs's
+ *  readConstructionFiles, in the live wiring). Re-registering invalidates the
+ *  compiled cache. */
+export function setConstructionBanks(source) {
+  bankSource = source ?? null;
+  bankCache = null;
+}
+
 /** The cached, compiled construction bank (relations table + runnable
- *  templates), loaded once per process. Defensive: any failure anywhere in the
- *  load/validate/compile chain degrades to an empty bank (the strategy simply
- *  never fires) rather than crashing the pipeline that imports this module. */
-export function constructionBank(dir = CONSTRUCTIONS_DIR) {
-  if (bankCache !== null && dir === CONSTRUCTIONS_DIR) return bankCache;
+ *  templates), compiled once per registration. Defensive: any failure
+ *  anywhere in the load/validate/compile chain degrades to an empty bank (the
+ *  strategy simply never fires) rather than crashing the pipeline that
+ *  imports this module. */
+export function constructionBank() {
+  if (bankCache !== null) return bankCache;
   let bank;
   try {
-    const { relations, constructions } = readConstructionFiles(dir);
+    const raw = typeof bankSource === "function" ? bankSource() : bankSource;
+    const { relations, constructions } = raw || { relations: [], constructions: [] };
     const agentNounTable = buildAgentNounTable(relations);
     const templates = buildConstructionTemplates(constructions, agentNounTable);
     bank = { agentNounTable, templates };
   } catch {
     bank = { agentNounTable: {}, templates: [] };
   }
-  if (dir === CONSTRUCTIONS_DIR) bankCache = bank;
+  bankCache = bank;
   return bank;
 }
 

package/src/{interpret → domain/interpret}/strategies/keywords.mjs

@@ -92,14 +92,20 @@ export function parseKeywordSpot(text, nlp = null) {
     verbHit = findPhrase(lemmaWords, VERB_TO_KIND);
     if (verbHit) canonWords = lemmaWords;
   }
-  let fuzzyVerb = false;
+  let fuzzyVerb = null;
   if (!verbHit) {
     // tier 3: bounded-edit-distance rewrite toward verb/modifier keywords only
     // ("impotr" -> "import"); ≥4-char words only — below that the bound covers
     // half of English (and "and" is 1 edit from the "land in" constituent).
     const fuzzyWords = lcWords.map((w) => (w.length >= 4 && eligibleForCanon(w) ? fuzzyVocabWord(w) || w : w));
     verbHit = findPhrase(fuzzyWords, VERB_TO_KIND);
-    if (verbHit) { canonWords = fuzzyWords; fuzzyVerb = true; }
+    if (verbHit) {
+      canonWords = fuzzyWords;
+      const offset = lcWords.slice(verbHit.start, verbHit.end)
+        .findIndex((w, i) => w !== fuzzyWords[verbHit.start + i]);
+      const at = verbHit.start + Math.max(offset, 0);
+      fuzzyVerb = { from: lcWords[at], to: fuzzyWords[at] };
+    }
   }
   if (!verbHit && lcWords.includes("by")) {
     // A participle with no active verb entry still marks a passive when a passive
@@ -111,8 +117,10 @@ export function parseKeywordSpot(text, nlp = null) {
   }
   if (!verbHit) return null;
   // A tier-3 verb is a REPAIR, not a reading — downstream consumers (the teach
-  // lane's canonical receipt) need to know the difference, so it rides the AST.
-  const stamp = (ast) => (fuzzyVerb ? { ...ast, fuzzyVerb: true } : ast);
+  // lane's canonical receipt, and the chat surface's fuzzy-verb decline) need
+  // to know the difference AND which word was rewritten, so {from, to} rides
+  // the AST.
+  const stamp = (ast) => (fuzzyVerb ? { ...ast, fuzzyVerb } : ast);
   // 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.
@@ -171,31 +179,28 @@ export function parseKeywordSpot(text, nlp = null) {
 
   // 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.
+  // phrase) splits the sentence into a patient before "by" and an agent after it.
+  // How many of the two the sentence actually names picks the shape: both named
+  // is the yes/no ask, agent alone reads forward from the agent, patient alone
+  // reads reverse over the patient.
   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) {
-    const roleWords = [];
-    for (let i = 0; i < words.length; i += 1) {
-      const w = lcWords[i];
-      if (consumed.has(i) || STOPWORDS.has(w) || w === "by" || PASSIVE_AUX.has(w)
-        || WH_WORDS.has(w) || PLACEHOLDER_SET.has(w)) continue;
-      roleWords.push(words[i]);
-    }
-    const object = roleWords.join(" ").trim();
-    if (object) {
-      // the first meaningful token after "by" (skipping only articles) decides direction:
-      // a wh-word or nothing → the agent is questioned (reverse over the named patient);
-      // a named token → the agent is given (forward from it).
-      let nextAfterBy = null;
-      for (let i = byIdx + 1; i < lcWords.length; i += 1) {
-        if (lcWords[i] === "the" || lcWords[i] === "a" || lcWords[i] === "an") continue;
-        nextAfterBy = lcWords[i]; break;
-      }
-      const agentNamed = nextAfterBy != null && !WH_WORDS.has(nextAfterBy) && !ENTITY_TO_TYPE[nextAfterBy];
-      return stamp({ shape: agentNamed ? "forward" : "reverse", entityType, modifier, kind, object });
-    }
+    const roleText = (from, to) => words
+      .slice(from, to)
+      .filter((_, j) => {
+        const i = from + j;
+        const w = lcWords[i];
+        return !consumed.has(i) && !STOPWORDS.has(w) && w !== "by" && !PASSIVE_AUX.has(w)
+          && !WH_WORDS.has(w) && !PLACEHOLDER_SET.has(w);
+      })
+      .join(" ")
+      .trim();
+    const patient = roleText(0, byIdx);
+    const agent = roleText(byIdx + 1, words.length);
+    if (patient && agent) return stamp({ shape: "ask", entityType: null, modifier: "direct", kind, subject: agent, object: patient });
+    if (agent) return stamp({ shape: "forward", entityType, modifier, kind, object: agent });
+    if (patient) return stamp({ shape: "reverse", entityType, modifier, kind, object: patient });
   }
 
   if (beforeText && afterText) {
@@ -215,6 +220,23 @@ export function parseKeywordSpot(text, nlp = null) {
     const entityText = canonWords.slice(entityHit.start, entityHit.end).join(" ");
     if (entityText) return stamp({ shape: "reverse", entityType: null, modifier, kind, object: entityText });
   }
+  // Bare passive ("was X touched", "is X imported"): a passive auxiliary before a
+  // participle, with no agent tail, makes X the PATIENT, so the active forward
+  // read below would answer a question nobody asked. The participle is looked up
+  // in lcWords rather than canonWords because the lemma tier rewrites it away
+  // ("imported" -> "import"); that same lookup is what leaves the present
+  // progressive ("what is X importing") on the active path, since a gerund is no
+  // participle. "touches" answers as a when-question, matching what "has X been
+  // touched" already says — one question must not get two answers.
+  if (beforeText && !afterText && hasPassiveAux && verbHit.end - verbHit.start === 1
+    && PASSIVE_PARTICIPLE_TO_KIND[lcWords[verbHit.start]]) {
+    // A patient of more than one token is the wreckage of a clause no tier here
+    // parses. Resolving past it would cite a confident answer to a question
+    // nobody asked, so this declines and the sentence misses honestly.
+    if (beforeText.split(/\s+/).length > 1) return null;
+    if (kind === "touches") return stamp({ shape: "when", entityType: null, modifier: "direct", kind, object: beforeText });
+    return stamp({ shape: "reverse", entityType, modifier, kind, object: beforeText });
+  }
   // forward keeps the spotted entityType (traverse()'s commit-as-subject grain
   // selection); modifier stays hardcoded since no forward closure traversal exists.
   if (beforeText) return stamp({ shape: "forward", entityType, modifier: "direct", kind, object: beforeText });

package/src/domain/memory/capability.mjs

@@ -0,0 +1,235 @@
+// memory/capability.mjs — negative facts, and capability read across
+// rdfs:subClassOf with a specificity override. The Tweety problem: birds fly,
+// penguins are birds, penguins do not fly.
+//
+// This is DEFEASIBLE inheritance, and it is deliberately NOT OWL. OWL's
+// cls-svf1/scm-svf1 propagate owl:someValuesFrom restrictions; mgx:capableOf is
+// a flat property assertion on a punned class, and OWL does not carry that down
+// a subclass edge at all. Nothing here should be routed through syllogise.mjs's
+// rule engine, because the conclusion is non-monotonic: a later, more specific
+// fact retracts it. The chase reads at query time and writes nothing, so an
+// override never has to un-say a materialised entailment.
+//
+// Polarity lives IN the predicate, under its own prefix. It cannot live in a
+// separate property: factIdForTriple content-addresses (subject, predicate,
+// object), so a positive and a negative sharing one predicate would hash to the
+// same id, merge into one Fact, and union their mgx:statedBy edges — the source
+// indexing that lets two sources disagree without either being deleted.
+//
+// Pure and import-free of core.mjs, exactly like trust.mjs beside it.
+
+import { findIsaChain, SUBCLASS_PREDICATE, TYPE_PREDICATE } from "../syllogise.mjs";
+
+/** The negative-polarity CURIE prefix. A separate prefix, never an
+ *  "mgx:not-<lemma>" mint: chat.mjs's predicatePhrase reads "mgx:not-fly" as
+ *  lemma "not" plus tail "fly" and renders "nots fly", and its preposition fold
+ *  is guarded on /^mgx:[a-z]+$/, which a hyphenated mint fails — so
+ *  "a penguin cannot rest on water" would strand "on water" inside the object
+ *  where no read-back can match it. */
+export const NEG_PREDICATE_PREFIX = "mgxneg:";
+const POSITIVE_PREDICATE_PREFIX = "mgx:";
+
+/** Swap an mgx: predicate onto its negative twin. Applied AFTER the preposition
+ *  fold, so mgx:rest-on becomes mgxneg:rest-on and the object keeps nothing
+ *  meaning-bearing inside it. */
+export function negatedPredicate(predicate) {
+  const p = String(predicate || "");
+  if (!p.startsWith(POSITIVE_PREDICATE_PREFIX)) return p;
+  return NEG_PREDICATE_PREFIX + p.slice(POSITIVE_PREDICATE_PREFIX.length);
+}
+
+/** The inverse: mgxneg:capableOf -> mgx:capableOf, or null for any predicate
+ *  that isn't negative at all. */
+export function positivePredicate(predicate) {
+  const p = String(predicate || "");
+  if (!p.startsWith(NEG_PREDICATE_PREFIX)) return null;
+  return POSITIVE_PREDICATE_PREFIX + p.slice(NEG_PREDICATE_PREFIX.length);
+}
+
+export const isNegatedPredicate = (predicate) => String(predicate || "").startsWith(NEG_PREDICATE_PREFIX);
+
+export const CAPABLE_OF_PREDICATE = "mgx:capableOf";
+export const NEG_CAPABLE_OF_PREDICATE = negatedPredicate(CAPABLE_OF_PREDICATE);
+
+/** How many rows a base-rate or extension report lists before it stops, and the
+ *  order it lists them in. One constant each, in one place, so the verbosity of
+ *  every case-4 answer is tuned by editing two lines. */
+export const CAPABILITY_REPORT_CAP = 6;
+export const byTrustThenName = (a, b) => (b.trust || 0) - (a.trust || 0) || String(a.subject).localeCompare(String(b.subject));
+
+const asSet = (v) => (v instanceof Set ? v : new Set(Array.isArray(v) ? v : [v]));
+
+const isaEdgesOf = (facts) => ({
+  typeEdges: facts.filter((f) => f.predicate === TYPE_PREDICATE).map((f) => [f.subject, f.object]),
+  subClassEdges: facts.filter((f) => f.predicate === SUBCLASS_PREDICATE).map((f) => [f.subject, f.object]),
+});
+
+/** The shortest isa chain from any spelling of `subjects` up to `target`, or
+ *  null. The chase is corpus-INCLUSIVE on purpose, and that is a considered
+ *  difference from the is-a ladder's own taught-only chase. The ladder excludes
+ *  corpus edges because a coincidental ConceptNet chain answering "is X a Y"
+ *  would be fabrication. Here the premise being chased to — "bird can fly" — is
+ *  itself corpus data on a fresh install, so a taught-only chase would find
+ *  nothing to inherit and the whole feature would never fire. */
+function shortestChainTo(subjects, target, typeEdges, subClassEdges, maxHops) {
+  let best = null;
+  for (const s of subjects) {
+    if (s === target) return [];
+    const chain = findIsaChain(s, new Set([target]), typeEdges, subClassEdges, { maxHops });
+    if (chain && (!best || chain.length < best.length)) best = chain;
+  }
+  return best;
+}
+
+/**
+ * Does `subject` have `object` as a capability? Pure over already-fetched Fact
+ * rows ({subject, predicate, object, provenance, trust}).
+ *
+ * Returns { verdict, hops, positive, negative, chain, overrides, baseRate }:
+ *   verdict "yes"  — the winning rank is positive only
+ *   verdict "no"   — the winning rank is negative only
+ *   verdict "both" — the winning rank holds both polarities; report the sources
+ *                    and pick NOTHING
+ *   verdict "none" — nothing is known; `baseRate` carries the class split
+ * `hops` is 0 for a fact directly about the subject, else the chain length.
+ * `overrides` names the more general default a direct answer beat, so case 2
+ * can say what it is overriding instead of silently winning.
+ *
+ * SPECIFICITY IS CHAIN LENGTH, AND IT OUTRANKS TRUST UNCONDITIONALLY. The
+ * candidates are sorted by hop count first and trust only second, so trust can
+ * never reorder across ranks — it only ever breaks a tie inside one. Trust
+ * looks like it solves this for free (SOURCE_PRIOR puts entailed 0.3 under
+ * teach 0.95, so a taught negative already outranks a derived positive) but
+ * that is luck: flip the sources — the corpus says penguins cannot fly, a
+ * visitor taught that birds can — and trust alone answers that penguins fly.
+ */
+export function resolveCapabilityPolarity(subject, object, facts, { maxHops = 3 } = {}) {
+  const subjects = asSet(subject);
+  const objects = asSet(object);
+  const rows = Array.isArray(facts) ? facts : [];
+  const { typeEdges, subClassEdges } = isaEdgesOf(rows);
+
+  const carriers = rows.filter(
+    (f) => (f.predicate === CAPABLE_OF_PREDICATE || f.predicate === NEG_CAPABLE_OF_PREDICATE) && objects.has(f.object),
+  );
+
+  const candidates = [];
+  for (const fact of carriers) {
+    const polarity = fact.predicate === NEG_CAPABLE_OF_PREDICATE ? "negative" : "positive";
+    if (subjects.has(fact.subject)) {
+      candidates.push({ fact, polarity, hops: 0, chain: null });
+      continue;
+    }
+    const chain = shortestChainTo(subjects, fact.subject, typeEdges, subClassEdges, maxHops);
+    if (chain && chain.length) candidates.push({ fact, polarity, hops: chain.length, chain });
+  }
+
+  if (!candidates.length) {
+    return {
+      verdict: "none", hops: 0, positive: [], negative: [], chain: null, overrides: null,
+      baseRate: capabilityBaseRate(subjects, objects, rows, { maxHops }),
+    };
+  }
+
+  // hop count first, trust only within a rank — the whole point of the design
+  candidates.sort((a, b) => a.hops - b.hops || (b.fact.trust || 0) - (a.fact.trust || 0));
+  const hops = candidates[0].hops;
+  const winning = candidates.filter((c) => c.hops === hops);
+  const positive = winning.filter((c) => c.polarity === "positive").map((c) => c.fact);
+  const negative = winning.filter((c) => c.polarity === "negative").map((c) => c.fact);
+
+  // the beaten default: the closest OPPOSITE-polarity claim further up the
+  // chain, so a direct answer can name what it overrides
+  const answered = negative.length && !positive.length ? "negative" : "positive";
+  const beaten = candidates.find((c) => c.hops > hops && c.polarity !== answered) || null;
+
+  return {
+    verdict: positive.length && negative.length ? "both" : (negative.length ? "no" : "yes"),
+    hops,
+    positive,
+    negative,
+    chain: candidates[0].chain,
+    overrides: beaten ? { fact: beaten.fact, chain: beaten.chain } : null,
+    baseRate: null,
+  };
+}
+
+/**
+ * Nothing is known about the subject, so report the CLASS it belongs to and how
+ * that class's other kinds split — never a yes or a no.
+ *
+ * The subject is excluded from its own base rate: you do not cite ostrich as
+ * evidence about ostrich. The denominator is the subclass count, and the split
+ * is three-way (positive, negative, unknown) so it accounts for every kind it
+ * counted. Say 5 and split only 4 and the arithmetic lies about what you know.
+ *
+ * The sample is never generalised to the population. "of the 4 kinds of bird I
+ * know" is a count this can prove; "most birds fly" is a claim about birds it
+ * has never seen.
+ *
+ * Returns null when the subject belongs to no known class.
+ */
+export function capabilityBaseRate(subject, object, facts, { maxHops = 3 } = {}) {
+  const subjects = asSet(subject);
+  const objects = asSet(object);
+  const rows = Array.isArray(facts) ? facts : [];
+  const isaRows = rows.filter((f) => f.predicate === SUBCLASS_PREDICATE || f.predicate === TYPE_PREDICATE);
+
+  const parents = isaRows.filter((f) => subjects.has(f.subject)).map((f) => f.object);
+  if (!parents.length) return null;
+  const klass = parents[0];
+
+  const siblings = [...new Set(
+    isaRows.filter((f) => f.object === klass && !subjects.has(f.subject)).map((f) => f.subject),
+  )];
+
+  const capabilityOf = (name) => {
+    const hit = rows.find(
+      (f) => f.subject === name && objects.has(f.object)
+        && (f.predicate === CAPABLE_OF_PREDICATE || f.predicate === NEG_CAPABLE_OF_PREDICATE),
+    );
+    if (!hit) return { name, polarity: "unknown", fact: null };
+    return { name, polarity: hit.predicate === NEG_CAPABLE_OF_PREDICATE ? "negative" : "positive", fact: hit };
+  };
+
+  const split = siblings.map(capabilityOf);
+  const { typeEdges, subClassEdges } = isaEdgesOf(rows);
+  return {
+    klass,
+    kinds: siblings.length,
+    positive: split.filter((s) => s.polarity === "positive"),
+    negative: split.filter((s) => s.polarity === "negative"),
+    unknown: split.filter((s) => s.polarity === "unknown"),
+    chain: shortestChainTo(subjects, klass, typeEdges, subClassEdges, maxHops),
+  };
+}
+
+/**
+ * Every subject the memory says CAN do `object` — the predicate's extension.
+ * Backs both the "what can fly" listing and the case-4 pivot ("I don't know if
+ * a penguin can fly, but I do know 3 things that can fly").
+ *
+ * A subject only lists if the RESOLVER says yes, not merely if a positive row
+ * exists. A subject the store explicitly says cannot do this is not an answer
+ * here, even when a corpus row also says it can — otherwise this listing and
+ * "can a penguin fly" would contradict each other over the same facts.
+ *
+ * `exclude` drops the subject and the class already reported on: pivoting to an
+ * extension whose only member IS the class being asked about is circular, not
+ * informative.
+ */
+export function capabilityExtension(object, facts, { exclude = [], maxHops = 3 } = {}) {
+  const objects = asSet(object);
+  const skip = asSet(exclude);
+  const rows = Array.isArray(facts) ? facts : [];
+  const seen = new Set();
+  const out = [];
+  for (const f of rows) {
+    if (f.predicate !== CAPABLE_OF_PREDICATE || !objects.has(f.object)) continue;
+    if (skip.has(f.subject) || seen.has(f.subject)) continue;
+    seen.add(f.subject);
+    if (resolveCapabilityPolarity(new Set([f.subject]), objects, rows, { maxHops }).verdict !== "yes") continue;
+    out.push(f);
+  }
+  return out.sort(byTrustThenName);
+}

package/src/domain/memory/fold.mjs

@@ -0,0 +1,54 @@
+// memory/fold.mjs — the pure cleaning rules a session log passes through on its
+// way into the text-block corpus: pair each turn with its answer prose, drop
+// slash-commands, filler and misses, and render what survives as corpus text.
+//
+// Pure by construction — the reading, writing and speculative pass live in
+// services/fold.mjs, which calls cleanSessionText below.
+
+import { turnKey } from "./session-turns.mjs";
+
+/** Conversational filler a transcript doesn't need: greetings, thanks, byes,
+ *  bare acknowledgements. Catches the one-liners chat.mjs did NOT flag
+ *  `conversational` (e.g. typed straight at an older tmct). */
+const FILLER_RE = new RegExp(
+  "^(?:(?:hi|hiya|hello|hey|yo|howdy)(?:\\s+there)?|good\\s*(?:morning|afternoon|evening)|" +
+    "thanks(?:\\s+(?:a\\s+lot|so\\s+much))?|thank\\s*you|thx|ty|cheers|" +
+    "ok(?:ay)?|cool|nice|great|sure|yes|no|yep|nope|" +
+    "bye(?:\\s+bye)?|goodbye|see\\s*(?:ya|you)|later)[\\s!.?,]*$",
+  "i",
+);
+
+const squash = (s) => String(s ?? "").replace(/\s+/g, " ").trim();
+
+/** The grammar wall's opening line. Source of truth: chat.mjs's WALL_MISS_RE —
+ *  repeated here as a one-line local anchor so the memory layer stays decoupled
+ *  from the chat surface. Checked on squashed (single-line) answer text. */
+const WALL_ANSWER_RE = /^couldn't parse this as a graph question\. Try:/;
+/** chat.mjs's recall frame preamble. An answer carrying it is a REPLAY of an
+ *  earlier session (possibly with the wall appended below it), never fresh
+ *  content — folding it would nest recalls-of-recalls. */
+const RECALL_PREAMBLE_RE = /you asked about this before/;
+
+/**
+ * Clean one parsed session record into corpus text (pure). `answers` is
+ * parseSessionLog()'s Map (may be empty — a vanished transcript degrades to
+ * question-only lines, honestly, rather than losing the session).
+ * Returns "" when nothing survives.
+ */
+export function cleanSessionText(record, answers = new Map()) {
+  const parts = [];
+  for (const t of record?.turns || []) {
+    const query = squash(t?.query);
+    if (!query) continue;
+    if (t.command || query.startsWith("/")) continue; // slash-commands + their outputs
+    if (t.conversational || FILLER_RE.test(query)) continue; // greetings/thanks/bye
+    if (t.miss) continue; // honest-miss boilerplate is not corpus content
+    const answer = squash(answers.get(turnKey(t.ts, t.query)));
+    // Belt-and-braces recall hygiene: even when a turn was NOT recorded as a
+    // miss, a grammar-wall answer or a recall replay never re-enters the
+    // corpus — re-folding also cleans stores poisoned by older builds.
+    if (WALL_ANSWER_RE.test(answer) || RECALL_PREAMBLE_RE.test(answer)) continue;
+    parts.push(answer ? `Q: ${query}\nA: ${answer}` : `Q: ${query}`);
+  }
+  return parts.join("\n");
+}

package/src/domain/memory/session-turns.mjs

@@ -0,0 +1,7 @@
+// The pure key both session artifacts agree on: the transcript parser writes it
+// and the fold's cleaner reads it, so it lives where each can legally import it.
+
+/** Key a transcript answer by its turn: ts + query (ts alone can collide when
+ *  two instant turns land in the same millisecond). The separator is NUL so it
+ *  cannot occur in either half. */
+export const turnKey = (ts, query) => `${ts}\0${query}`;