@polycode-projects/the-mechanical-code-talker 1.4.1 → 1.5.3

package/src/grammar/ace.mjs

@@ -8,8 +8,7 @@
 // punctuation, morphology is the lexicon's suffix fold.
 //
 // parseAce(sentence, lexicon) → { pattern, triples, residue } | null
-//   pattern  one of: subClassOf | typeAssertion | relation | someValuesFrom |
-//            cardinality | disjointWith | possessive | adjective
+//   pattern  one of the PATTERNS below (also exported individually).
 //   triples  [{ subject, predicate, object, kind, n? }] — OWL-labelled string
 //            triples shaped for src/memory/core.mjs's appendFact (which
 //            normalizes subject/object via normFactTerm: "tmct:module" is
@@ -22,19 +21,39 @@
 // Term style: classes/individuals are `tmct:<lexeme>` CURIEs (lexicon lemma
 // for nouns, canonical spelling for proper names, the literal token for
 // code-shaped references like chat.mjs); predicates are the OWL/RDF(S)
-// vocabulary terms or the lexicon verb's tmct:<3sg> predicate. Restriction
-// and intersection class expressions get READABLE deterministic node names
-// (tmct:some-imports-test, tmct:module-that-imports-test) instead of blank
-// nodes, so the same sentence always re-emits the same triples and appendFact
-// stays idempotent. An intersection is flattened to repeated
-// owl:intersectionOf triples (one per member) — the flat-JSON stand-in for an
-// RDF list, documented in ontology/tmct-core.ttl.
+// vocabulary terms or the lexicon verb's tmct:<3sg> predicate
+// (lexicon.mjs's predicateOf). Restriction and intersection class
+// expressions get READABLE deterministic node names (tmct:some-imports-test,
+// tmct:module-that-imports-test) instead of blank nodes, so the same
+// sentence always re-emits the same triples and appendFact stays idempotent.
+// An intersection is flattened to repeated owl:intersectionOf triples (one
+// per member) — the flat-JSON stand-in for an RDF list, documented in
+// ontology/tmct-core.ttl. `lexicon.ns` is always "tmct:" here (lexicon.mjs's
+// DEFAULT_NS) — every term this module mints is namespaced off `lexicon.ns`
+// rather than a hardcoded literal purely so a caller can supply its own
+// already-namespaced lexicon (extensions.mjs's mergedLexiconExtra); tmct
+// itself only ever runs one namespace.
 
 import {
   loadLexicon, lookupNoun, lookupVerb, lookupAdjective, lookupProperName,
   predicateOf, numberOf, classify,
 } from "./lexicon.mjs";
 
+export const PATTERN_SUB_CLASS_OF = "subClassOf";
+export const PATTERN_TYPE_ASSERTION = "typeAssertion";
+export const PATTERN_RELATION = "relation";
+export const PATTERN_SOME_VALUES_FROM = "someValuesFrom";
+export const PATTERN_CARDINALITY = "cardinality";
+export const PATTERN_DISJOINT_WITH = "disjointWith";
+export const PATTERN_POSSESSIVE = "possessive";
+export const PATTERN_ADJECTIVE = "adjective";
+
+/** The pattern field's full domain, in the README's table order. */
+export const PATTERNS = Object.freeze([
+  PATTERN_SUB_CLASS_OF, PATTERN_TYPE_ASSERTION, PATTERN_RELATION, PATTERN_SOME_VALUES_FROM,
+  PATTERN_CARDINALITY, PATTERN_DISJOINT_WITH, PATTERN_POSSESSIVE, PATTERN_ADJECTIVE,
+]);
+
 const DET = new Set(["a", "an", "the"]);
 // A token SHAPED like a code reference (a path, file, symbol or CURIE) is an
 // individual by form — a deterministic tokenizer rule, not a guess: declared
@@ -53,7 +72,15 @@ export function tokenize(sentence) {
     .filter(Boolean);
 }
 
-const local = (term) => String(term).replace(/^tmct:/, "");
+/** Strip a lexicon's own namespace prefix off a term, for use inside a
+ *  synthesized deterministic node name (so "${ns}some-${ns}imports-${ns}test"
+ *  reads as "${ns}some-imports-test"). A term outside the lexicon's own
+ *  namespace (a rare cross-namespace reference) is returned unchanged. */
+function local(lexicon, term) {
+  const s = String(term);
+  const ns = lexicon.ns;
+  return ns && s.startsWith(ns) ? s.slice(ns.length) : s;
+}
 
 const stripDet = (tokens) =>
   tokens.length > 1 && DET.has(tokens[0].toLowerCase()) ? tokens.slice(1) : tokens;
@@ -64,33 +91,34 @@ const stripDet = (tokens) =>
  *  unparseable phrase → the caller returns a hard null). `extras` carries the
  *  pattern-8 adjective triples (subclass axioms / hasValue restriction). */
 function resolveNP(lexicon, tokensIn) {
+  const ns = lexicon.ns;
   const tokens = stripDet(tokensIn);
   if (tokens.length === 1) {
     const t = tokens[0];
     const proper = lookupProperName(lexicon, t);
-    if (proper) return { term: `tmct:${proper}`, individual: true, extras: [], unknown: [] };
-    if (CODE_REF.test(t)) return { term: `tmct:${t}`, individual: true, extras: [], unknown: [] };
+    if (proper) return { term: `${ns}${proper}`, individual: true, extras: [], unknown: [] };
+    if (CODE_REF.test(t)) return { term: `${ns}${t}`, individual: true, extras: [], unknown: [] };
     const noun = lookupNoun(lexicon, t);
-    if (noun) return { term: `tmct:${noun.lemma}`, individual: false, noun, extras: [], unknown: [] };
+    if (noun) return { term: `${ns}${noun.lemma}`, individual: false, noun, extras: [], unknown: [] };
     return { term: null, individual: false, extras: [], unknown: [t] };
   }
   if (tokens.length === 2) {
     const adj = lookupAdjective(lexicon, tokens[0]);
     const noun = lookupNoun(lexicon, tokens[1]);
     if (adj && noun) {
-      const term = `tmct:${adj.lemma}-${noun.lemma}`;
+      const term = `${ns}${adj.lemma}-${noun.lemma}`;
       const extras = [
-        { subject: term, predicate: "rdfs:subClassOf", object: `tmct:${noun.lemma}`, kind: "rdfs:subClassOf" },
+        { subject: term, predicate: "rdfs:subClassOf", object: `${ns}${noun.lemma}`, kind: "rdfs:subClassOf" },
       ];
       if (adj.type === "subclass") {
         // the adjective itself denotes a class: legacy-module ⊑ module, ⊑ legacy
-        extras.push({ subject: term, predicate: "rdfs:subClassOf", object: `tmct:${adj.lemma}`, kind: "rdfs:subClassOf" });
+        extras.push({ subject: term, predicate: "rdfs:subClassOf", object: `${ns}${adj.lemma}`, kind: "rdfs:subClassOf" });
       } else {
         // data adjective: subclass-with-restriction on the boolean-ish property
-        const r = `tmct:has-${adj.lemma}`;
+        const r = `${ns}has-${adj.lemma}`;
         extras.push(
           { subject: r, predicate: "rdf:type", object: "owl:Restriction", kind: "owl:hasValue" },
-          { subject: r, predicate: "owl:onProperty", object: adj.property || `tmct:${adj.lemma}`, kind: "owl:hasValue" },
+          { subject: r, predicate: "owl:onProperty", object: adj.property || `${ns}${adj.lemma}`, kind: "owl:hasValue" },
           { subject: r, predicate: "owl:hasValue", object: adj.value ?? "true", kind: "owl:hasValue" },
           { subject: term, predicate: "rdfs:subClassOf", object: r, kind: "owl:hasValue" },
         );
@@ -136,38 +164,40 @@ function parseRelation(lexicon, toks, lower) {
     }
     const np1 = resolveNP(lexicon, toks.slice(0, i));
     const np2 = resolveNP(lexicon, toks.slice(objStart));
-    if (np1.term == null || np2.term == null) return missOrNull("relation", [np1, np2]);
-    return hit("relation", [np1, np2], [
-      { subject: np1.term, predicate: predicateOf(verb), object: np2.term, kind: "owl:ObjectProperty" },
+    if (np1.term == null || np2.term == null) return missOrNull(PATTERN_RELATION, [np1, np2]);
+    return hit(PATTERN_RELATION, [np1, np2], [
+      { subject: np1.term, predicate: predicateOf(verb, lexicon.ns), object: np2.term, kind: "owl:ObjectProperty" },
     ]);
   }
   const content = toks.filter((t) => !DET.has(t.toLowerCase()));
   if (content.length === 3 && !classify(content[1], lexicon)) {
     const np1 = resolveNP(lexicon, [content[0]]);
     const np2 = resolveNP(lexicon, [content[2]]);
-    if (np1.term != null && np2.term != null) return { pattern: "relation", triples: [], residue: [content[1]] };
+    if (np1.term != null && np2.term != null) return { pattern: PATTERN_RELATION, triples: [], residue: [content[1]] };
   }
   return null;
 }
 
 /** Pattern 8 (copula arm) — "X is ADJ": data adjective → datatype-property
  *  assertion; subclass adjective → rdf:type (individual) / rdfs:subClassOf. */
-function adjectiveCopula(pattern, np1, adj) {
+function adjectiveCopula(lexicon, pattern, np1, adj) {
+  const ns = lexicon.ns;
   if (np1.term == null) return missOrNull(pattern, [np1]);
   if (adj.type === "data") {
     return hit(pattern, [np1], [
-      { subject: np1.term, predicate: adj.property || `tmct:${adj.lemma}`, object: adj.value ?? "true", kind: "owl:DatatypeProperty" },
+      { subject: np1.term, predicate: adj.property || `${ns}${adj.lemma}`, object: adj.value ?? "true", kind: "owl:DatatypeProperty" },
     ]);
   }
   const predicate = np1.individual ? "rdf:type" : "rdfs:subClassOf";
   return hit(pattern, [np1], [
-    { subject: np1.term, predicate, object: `tmct:${adj.lemma}`, kind: predicate },
+    { subject: np1.term, predicate, object: `${ns}${adj.lemma}`, kind: predicate },
   ]);
 }
 
 /** Pattern 4 — "every N1 that VERBs a N2 is a N3" → someValuesFrom restriction:
  *  (N1 ⊓ ∃VERB.N2) ⊑ N3, flattened onto readable deterministic node names. */
 function parseRestriction(lexicon, toks, lower, thatIdx) {
+  const ns = lexicon.ns;
   const isIdx = lower.indexOf("is", thatIdx + 2);
   if (isIdx < 0 || thatIdx + 1 >= isIdx) return null;
   const verb = lookupVerb(lexicon, lower[thatIdx + 1]);
@@ -179,16 +209,16 @@ function parseRestriction(lexicon, toks, lower, thatIdx) {
   }
   const np2 = resolveNP(lexicon, toks.slice(objStart, isIdx));
   const np3 = resolveNP(lexicon, toks.slice(isIdx + 1));
-  if (!verb) return missOrNull("someValuesFrom", [np1, np2, np3], [toks[thatIdx + 1]]);
+  if (!verb) return missOrNull(PATTERN_SOME_VALUES_FROM, [np1, np2, np3], [toks[thatIdx + 1]]);
   if (np1.term == null || np2.term == null || np3.term == null) {
-    return missOrNull("someValuesFrom", [np1, np2, np3]);
+    return missOrNull(PATTERN_SOME_VALUES_FROM, [np1, np2, np3]);
   }
   if (np1.individual || np2.individual || np3.individual) return null; // class-level pattern only
-  const pred = predicateOf(verb);
+  const pred = predicateOf(verb, ns);
   const k = "owl:someValuesFrom";
-  const r = `tmct:some-${local(pred)}-${local(np2.term)}`;
-  const inter = `tmct:${local(np1.term)}-that-${local(pred)}-${local(np2.term)}`;
-  return hit("someValuesFrom", [np1, np2, np3], [
+  const r = `${ns}some-${local(lexicon, pred)}-${local(lexicon, np2.term)}`;
+  const inter = `${ns}${local(lexicon, np1.term)}-that-${local(lexicon, pred)}-${local(lexicon, np2.term)}`;
+  return hit(PATTERN_SOME_VALUES_FROM, [np1, np2, np3], [
     { subject: r, predicate: "rdf:type", object: "owl:Restriction", kind: k },
     { subject: r, predicate: "owl:onProperty", object: pred, kind: k },
     { subject: r, predicate: "owl:someValuesFrom", object: np2.term, kind: k },
@@ -199,9 +229,10 @@ function parseRestriction(lexicon, toks, lower, thatIdx) {
 }
 
 /** Pattern 5 — "every N has at least|at most|exactly n N2" → cardinality
- *  restriction on tmct:has (owl:onClass records the counted class — the
- *  qualified-form question is noted in docs/references/schemas/owl2-vocabulary.md). */
+ *  restriction on `${ns}has` (owl:onClass records the counted class — the
+ *  qualified-form question is left as a documented open point, see README). */
 function parseCardinality(lexicon, toks, lower, hasIdx) {
+  const ns = lexicon.ns;
   let kind = null;
   let nIdx = -1;
   if (lower[hasIdx + 1] === "at" && lower[hasIdx + 2] === "least") { kind = "owl:minCardinality"; nIdx = hasIdx + 3; }
@@ -212,13 +243,13 @@ function parseCardinality(lexicon, toks, lower, hasIdx) {
   if (n == null || nIdx + 1 >= toks.length) return null;
   const np1 = resolveNP(lexicon, toks.slice(1, hasIdx));
   const np2 = resolveNP(lexicon, toks.slice(nIdx + 1));
-  if (np1.term == null || np2.term == null) return missOrNull("cardinality", [np1, np2]);
+  if (np1.term == null || np2.term == null) return missOrNull(PATTERN_CARDINALITY, [np1, np2]);
   if (np1.individual || np2.individual) return null;
   const tag = { "owl:minCardinality": "min", "owl:maxCardinality": "max", "owl:cardinality": "exactly" }[kind];
-  const r = `tmct:${tag}-${n}-${local(np2.term)}`;
-  return hit("cardinality", [np1, np2], [
+  const r = `${ns}${tag}-${n}-${local(lexicon, np2.term)}`;
+  return hit(PATTERN_CARDINALITY, [np1, np2], [
     { subject: r, predicate: "rdf:type", object: "owl:Restriction", kind },
-    { subject: r, predicate: "owl:onProperty", object: "tmct:has", kind },
+    { subject: r, predicate: "owl:onProperty", object: `${ns}has`, kind },
     { subject: r, predicate: kind, object: String(n), kind, n },
     { subject: r, predicate: "owl:onClass", object: np2.term, kind },
     { subject: np1.term, predicate: "rdfs:subClassOf", object: r, kind },
@@ -239,12 +270,12 @@ function parseEvery(lexicon, toks, lower) {
   const rest = toks.slice(isIdx + 1);
   if (rest.length === 1) {
     const adj = lookupAdjective(lexicon, rest[0]);
-    if (adj) return adjectiveCopula("adjective", np1, adj);
+    if (adj) return adjectiveCopula(lexicon, PATTERN_ADJECTIVE, np1, adj);
   }
   const np2 = resolveNP(lexicon, rest);
-  if (np1.term == null || np2.term == null) return missOrNull("subClassOf", [np1, np2]);
+  if (np1.term == null || np2.term == null) return missOrNull(PATTERN_SUB_CLASS_OF, [np1, np2]);
   if (np1.individual || np2.individual) return null; // "every X is chat.mjs" — not the fragment
-  return hit("subClassOf", [np1, np2], [
+  return hit(PATTERN_SUB_CLASS_OF, [np1, np2], [
     { subject: np1.term, predicate: "rdfs:subClassOf", object: np2.term, kind: "rdfs:subClassOf" },
   ]);
 }
@@ -255,9 +286,9 @@ function parseDisjoint(lexicon, toks, lower) {
   if (isIdx <= 1 || isIdx === toks.length - 1) return null;
   const np1 = resolveNP(lexicon, toks.slice(1, isIdx));
   const np2 = resolveNP(lexicon, toks.slice(isIdx + 1));
-  if (np1.term == null || np2.term == null) return missOrNull("disjointWith", [np1, np2]);
+  if (np1.term == null || np2.term == null) return missOrNull(PATTERN_DISJOINT_WITH, [np1, np2]);
   if (np1.individual || np2.individual) return null;
-  return hit("disjointWith", [np1, np2], [
+  return hit(PATTERN_DISJOINT_WITH, [np1, np2], [
     { subject: np1.term, predicate: "owl:disjointWith", object: np2.term, kind: "owl:disjointWith" },
   ]);
 }
@@ -266,21 +297,22 @@ function parseDisjoint(lexicon, toks, lower) {
  *  property assertion per the possessive noun's DECLARED typing (undeclared
  *  typing defaults to data — a literal value is the honest floor). */
 function buildPossessive(lexicon, ownerToks, headToks, valueToks) {
+  const ns = lexicon.ns;
   const owner = resolveNP(lexicon, ownerToks);
   if (headToks.length !== 1) return null;
   const head = lookupNoun(lexicon, headToks[0]);
-  if (!head) return missOrNull("possessive", [owner], [headToks[0]]);
-  if (owner.term == null) return missOrNull("possessive", [owner]);
+  if (!head) return missOrNull(PATTERN_POSSESSIVE, [owner], [headToks[0]]);
+  if (owner.term == null) return missOrNull(PATTERN_POSSESSIVE, [owner]);
   if (!valueToks.length) return null;
-  const predicate = `tmct:${head.lemma}`;
+  const predicate = `${ns}${head.lemma}`;
   if ((head.property || "data") === "object") {
     const value = resolveNP(lexicon, valueToks);
-    if (value.term == null) return missOrNull("possessive", [owner, value]);
-    return hit("possessive", [owner, value], [
+    if (value.term == null) return missOrNull(PATTERN_POSSESSIVE, [owner, value]);
+    return hit(PATTERN_POSSESSIVE, [owner, value], [
       { subject: owner.term, predicate, object: value.term, kind: "owl:ObjectProperty" },
     ]);
   }
-  return hit("possessive", [owner], [
+  return hit(PATTERN_POSSESSIVE, [owner], [
     { subject: owner.term, predicate, object: valueToks.join(" "), kind: "owl:DatatypeProperty" },
   ]);
 }
@@ -306,25 +338,27 @@ function parseCopula(lexicon, toks, lower, isIdx) {
   if (!rest.length) return null;
   if (rest.length === 1) {
     const adj = lookupAdjective(lexicon, rest[0]);
-    if (adj) return adjectiveCopula("adjective", np1, adj);
+    if (adj) return adjectiveCopula(lexicon, PATTERN_ADJECTIVE, np1, adj);
   }
   const np2 = resolveNP(lexicon, rest);
   if (np1.term == null || np2.term == null) {
-    return missOrNull(np1.individual ? "typeAssertion" : "subClassOf", [np1, np2]);
+    return missOrNull(np1.individual ? PATTERN_TYPE_ASSERTION : PATTERN_SUB_CLASS_OF, [np1, np2]);
   }
   if (np2.individual) return null; // "chat.mjs is sessions.mjs" — identity is not in the fragment
   if (np1.individual) {
-    return hit("typeAssertion", [np1, np2], [
+    return hit(PATTERN_TYPE_ASSERTION, [np1, np2], [
       { subject: np1.term, predicate: "rdf:type", object: np2.term, kind: "rdf:type" },
     ]);
   }
-  return hit("subClassOf", [np1, np2], [
+  return hit(PATTERN_SUB_CLASS_OF, [np1, np2], [
     { subject: np1.term, predicate: "rdfs:subClassOf", object: np2.term, kind: "rdfs:subClassOf" },
   ]);
 }
 
 /** Parse one sentence against the 8-pattern ACE-OWL sub-fragment. See the file
- *  header for the result contract; `lexicon` defaults to the committed core. */
+ *  header for the result contract; `lexicon` defaults to the committed core
+ *  under the library's own neutral DEFAULT_NS ("ex:") when the caller doesn't
+ *  supply one. */
 export function parseAce(sentence, lexicon = loadLexicon()) {
   const toks = tokenize(sentence);
   if (toks.length < 3) return null;

package/src/grammar/lexicon.mjs

@@ -1,16 +1,21 @@
-// grammar/lexicon.mjs — the declared lexicon behind tmct's ACE-OWL sub-fragment
-// (ROADMAP Phase 2, item 2; docs/references/schemas/ace-owl-fragment.md).
+// grammar/lexicon.mjs — the declared lexicon behind tmct's ACE-OWL
+// sub-fragment parser (ROADMAP Phase 2, item 2; see ace.mjs). The lexicon is
+// LOAD-BEARING: the grammar is only deterministic because every noun, verb
+// (with any preposition), adjective (with its declared type) and proper name
+// is DECLARED — the parser never guesses a word's category. Undeclared words
+// route a sentence out of the grammar (a miss is a feature, not a bug — see
+// ace.mjs).
 //
-// The lexicon is LOAD-BEARING: the grammar (grammar/ace.mjs) is only
-// deterministic because every noun, verb (with any preposition), adjective
-// (with its declared type) and proper name is DECLARED — tmct never guesses a
-// word's category. Undeclared words route a sentence out of the grammar
-// strategy (a miss is a feature: the interpretation pipeline falls through to
-// the tolerant strategies).
+// Data lives in lexicon-core.json (plain, diffable), tmct's starter
+// software-domain vocabulary. Extend it via loadLexicon(extra) with the same
+// JSON shape (extensions.mjs's mergedLexiconExtra); extra entries win on
+// conflict.
 //
-// Data lives in lexicon-core.json (plain, diffable — the item-4/7 format
-// discipline), a starter software-domain vocabulary. Callers extend it via
-// loadLexicon(extra) with the same JSON shape; user entries win on conflict.
+// Namespace: every lexicon carries a `.ns` field (the CURIE prefix ace.mjs
+// stamps onto every term it mints) — always "tmct:" here (DEFAULT_NS).
+// ace.mjs and predicateOf() read it off the lexicon rather than hardcoding
+// the prefix inline, purely so a caller can supply its own already-namespaced
+// lexicon; tmct itself only ever runs the one namespace.
 //
 // Morphology is deliberately tiny and deterministic (no NLP dependency): a
 // suffix-fold for plurals/3rd-person-singular ("repositories"→repository,
@@ -24,6 +29,9 @@ import { dirname, join } from "node:path";
 
 const CORE_FILE = join(dirname(fileURLToPath(import.meta.url)), "lexicon-core.json");
 
+/** The CURIE namespace every tmct lexicon mints terms under. */
+export const DEFAULT_NS = "tmct:";
+
 /** Determiner tokens the grammar consumes (pattern table's every/a/no…). */
 export const DETERMINERS = Object.freeze({
   every: "universal",
@@ -52,9 +60,8 @@ export function numberOf(word) {
   return NUMBER_WORDS[w] ?? null;
 }
 
-/** 3rd-person-singular surface form of a verb lemma — the predicate spelling
- *  ("import"→imports, "rely"→relies, "catch"→catches, "have"→has), matching
- *  the code graph's 3sg relation-kind convention (ask.mjs §verbs). */
+/** 3rd-person-singular surface form of a verb lemma ("import"→imports,
+ *  "rely"→relies, "catch"→catches, "have"→has) — the predicate spelling. */
 export function thirdPerson(base) {
   const b = String(base);
   if (b === "have") return "has";
@@ -63,12 +70,14 @@ export function thirdPerson(base) {
   return `${b}s`;
 }
 
-/** The URI-style predicate a verb entry emits: a declared override, or
- *  tmct:<3sg lemma> with any preposition camel-appended ("depend on"→tmct:dependsOn). */
-export function predicateOf(verbEntry) {
+/** The URI-style predicate a verb entry emits: a declared override
+ *  (verbEntry.predicate, namespace-independent), or `${ns}<3sg lemma>` with
+ *  any preposition camel-appended ("depend on" → `${ns}dependsOn`). `ns`
+ *  defaults to DEFAULT_NS for a caller that doesn't thread one through. */
+export function predicateOf(verbEntry, ns = DEFAULT_NS) {
   if (verbEntry.predicate) return verbEntry.predicate;
   const prep = verbEntry.prep ? verbEntry.prep[0].toUpperCase() + verbEntry.prep.slice(1) : "";
-  return `tmct:${thirdPerson(verbEntry.lemma)}${prep}`;
+  return `${ns}${thirdPerson(verbEntry.lemma)}${prep}`;
 }
 
 /** Deterministic singular/base-form candidates for a surface word, most
@@ -115,13 +124,18 @@ function ingest(lex, raw = {}) {
   }
 }
 
-let coreCache = null;
+// Cache keyed by namespace — a no-extra load is immutable at runtime and
+// cached per-ns, so two consumers requesting different namespaces (or the
+// same one repeatedly) each get a stable, shared lexicon object.
+const coreCacheByNs = new Map();
 
 /** Load the lexicon: the committed core vocabulary, optionally merged with a
  *  caller-supplied `extra` block of the same JSON shape (extra entries win).
- *  The no-extra result is cached (the JSON is committed, immutable at runtime). */
-export function loadLexicon(extra) {
-  if (!extra && coreCache) return coreCache;
+ *  `ns` (default DEFAULT_NS) is stamped onto the returned lexicon as `.ns` —
+ *  the CURIE prefix ace.mjs mints new terms under. The no-extra result is
+ *  cached per-ns (the JSON is committed, immutable at runtime). */
+export function loadLexicon(extra, ns = DEFAULT_NS) {
+  if (!extra && coreCacheByNs.has(ns)) return coreCacheByNs.get(ns);
   const raw = JSON.parse(readFileSync(CORE_FILE, "utf8"));
   const lex = {
     nouns: new Map(),
@@ -129,13 +143,14 @@ export function loadLexicon(extra) {
     verbs: new Map(),
     adjectives: new Map(),
     properNames: new Map(), // lowercased → canonical spelling
+    ns,
   };
   ingest(lex, raw);
   if (extra) {
     ingest(lex, extra);
     return lex;
   }
-  coreCache = lex;
+  coreCacheByNs.set(ns, lex);
   return lex;
 }
 
@@ -194,7 +209,7 @@ export function classify(word, lexicon = loadLexicon()) {
   }
   const verb = lookupVerb(lexicon, lower);
   if (verb) {
-    return { pos: "verb", type: "objectProperty", lemma: verb.lemma, predicate: predicateOf(verb), ...(verb.prep ? { prep: verb.prep } : {}) };
+    return { pos: "verb", type: "objectProperty", lemma: verb.lemma, predicate: predicateOf(verb, lexicon.ns), ...(verb.prep ? { prep: verb.prep } : {}) };
   }
   const adj = lookupAdjective(lexicon, lower);
   if (adj) return { pos: "adjective", type: adj.type, lemma: adj.lemma };

package/src/interpret/pipeline.mjs

@@ -34,6 +34,15 @@ import { noiseStripStrategy } from "./strategies/noise-strip.mjs";
 // ace-less registry instead of throwing over an undeclared identifier. (ACE is
 // async-only anyway, so the sync parseQuery path the viewer uses never ran it.)
 import { aceStrategy } from "./strategies/ace.mjs";
+// Optional Node-only construction-grammar bank (PLAN_ADVANCED_GRAMMAR.md track
+// (d)) — same viewer-bundle boundary as ACE and the wink adapter: the loader
+// reads its committed TOML data via Node fs/path (interpret/strategies/
+// constructions.mjs), so an inlining viewer bundle strips this import too; the
+// same `typeof` guard below degrades to a constructions-less registry instead
+// of throwing over an undeclared identifier (test/ask-nlp.test.mjs's "viewer
+// bundle without wink" test proves the boundary — its bundled file list never
+// includes this strategy file, matching ace.mjs's own exclusion there).
+import { constructionsStrategy } from "./strategies/constructions.mjs";
 import { mergeStrategyResults } from "./merge.mjs";
 // Optional Node-only wink adapter — same viewer-bundle boundary as ask.mjs: an
 // inlining bundle strips this import and the `typeof` read below degrades to
@@ -52,9 +61,21 @@ import { nlpAdapter } from "../ask-nlp.mjs";
  *  adds declarative-fragment reach to interpret() while leaving the sync spine
  *  byte-stable (see strategies/ace.mjs for the full rationale). The `typeof` guard
  *  mirrors the nlpAdapter degradation: a stripped ACE import (viewer bundle) leaves
- *  the identifier undeclared, so the registry is ace-less there instead of a crash. */
+ *  the identifier undeclared, so the registry is ace-less there instead of a crash.
+ *  interpret/strategies/constructions.mjs (PLAN_ADVANCED_GRAMMAR.md track (d)) is
+ *  the construction-grammar template bank — data-driven (data/templates/
+ *  constructions/*.toml), registered as its own additive, own-class
+ *  ("construction") strategy at grammar-level confidence (0.9) so it outranks a
+ *  same-text keyword-spot guess outright instead of colliding with it (see that
+ *  file's header for why: keyword-spot mis-parses the genitive/compound surface
+ *  forms this bank exists to fix). Sync (unlike ACE), so it participates on the
+ *  parseQuery path too, not just interpret(). */
 // eslint-disable-next-line no-undef
-const OPTIONAL_STRATEGIES = typeof aceStrategy !== "undefined" ? [aceStrategy] : [];
+const OPTIONAL_STRATEGIES = [
+  ...(typeof aceStrategy !== "undefined" ? [aceStrategy] : []),
+  // eslint-disable-next-line no-undef
+  ...(typeof constructionsStrategy !== "undefined" ? [constructionsStrategy] : []),
+];
 export const STRATEGIES = [grammarStrategy, keywordSpotStrategy, noiseStripStrategy, ...OPTIONAL_STRATEGIES];
 
 /** The documented normalization pre-pass: whitespace-collapse + the §3.5