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

package/src/grammar/ace.mjs

@@ -1,341 +1,27 @@
-// grammar/ace.mjs — tmct's deterministic ACE-OWL sub-fragment parser (ROADMAP
-// Phase 2, item 2). Implements the 8 controlled-English sentence patterns of
-// docs/references/schemas/ace-owl-fragment.md and nothing more: fitting the
-// grammar is a strong signal, missing it is a FEATURE — parseAce returns null
-// (or an empty-triples result carrying the unknown words as `residue`) and the
-// interpretation pipeline (src/interpret/) falls through to the tolerant
-// strategies. No NLP dependency: tokenization is whitespace + trailing
-// punctuation, morphology is the lexicon's suffix fold.
+// grammar/ace.mjs — thin re-export shim over @polycode-projects/ace-owl
+// (PLAN_OSS_ACE_PARSER.md / PLAN_AGENTS.md §3's "ace-owl open-source
+// extraction"). tmct's ACE-OWL sub-fragment parser — the 8 controlled-
+// English sentence patterns of docs/references/schemas/ace-owl-fragment.md
+// — is now the extracted package's ace.mjs (packages/ace-owl/src/ace.mjs);
+// this file exists ONLY to default `lexicon` to tmct's own namespace-bound
+// loadLexicon() (see ./lexicon.mjs), so every existing call site in this
+// repo (chat.mjs, grammar/assert.mjs, the grammar tests, …) that calls
+// `parseAce(sentence)` with no lexicon argument keeps getting "tmct:"-
+// prefixed triples, byte-identical to before the extraction.
 //
-// parseAce(sentence, lexicon) → { pattern, triples, residue } | null
-//   pattern  one of: subClassOf | typeAssertion | relation | someValuesFrom |
-//            cardinality | disjointWith | possessive | adjective
-//   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
-//            stored as "module"; the predicate keeps its vocabulary casing).
-//   residue  [] on a clean parse; the unknown tokens when the sentence FITS a
-//            pattern structurally but uses undeclared words (triples is then
-//            empty — feeds the pipeline's "if you mean X…" surround).
-//   null     the sentence does not fit the fragment at all.
-//
-// 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.
-
-import {
-  loadLexicon, lookupNoun, lookupVerb, lookupAdjective, lookupProperName,
-  predicateOf, numberOf, classify,
-} from "./lexicon.mjs";
-
-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
-// proper names cover words; this covers chat.mjs, src/ask.mjs, Foo#bar.
-const CODE_REF = /[./\\#:@]/;
-
-/** Whitespace tokenizer: curly quotes normalized, commas/semicolons dropped,
- *  ONE trailing punctuation run stripped (so "chat.mjs." keeps its dots). */
-export function tokenize(sentence) {
-  return String(sentence ?? "")
-    .replace(/[‘’]/g, "'")
-    .replace(/[,;]/g, " ")
-    .replace(/[?!.]+\s*$/, "")
-    .trim()
-    .split(/\s+/)
-    .filter(Boolean);
-}
-
-const local = (term) => String(term).replace(/^tmct:/, "");
-
-const stripDet = (tokens) =>
-  tokens.length > 1 && DET.has(tokens[0].toLowerCase()) ? tokens.slice(1) : tokens;
-
-/** Resolve a 1–2 word noun phrase: PROPERNAME | code-ref | NOUN | ADJ NOUN.
- *  Returns { term, individual, extras, unknown } — `term` null on a miss with
- *  the undeclared tokens in `unknown` (empty `unknown` = structurally
- *  unparseable phrase → the caller returns a hard null). `extras` carries the
- *  pattern-8 adjective triples (subclass axioms / hasValue restriction). */
-function resolveNP(lexicon, tokensIn) {
-  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: [] };
-    const noun = lookupNoun(lexicon, t);
-    if (noun) return { term: `tmct:${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 extras = [
-        { subject: term, predicate: "rdfs:subClassOf", object: `tmct:${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" });
-      } else {
-        // data adjective: subclass-with-restriction on the boolean-ish property
-        const r = `tmct: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:hasValue", object: adj.value ?? "true", kind: "owl:hasValue" },
-          { subject: term, predicate: "rdfs:subClassOf", object: r, kind: "owl:hasValue" },
-        );
-      }
-      return { term, individual: false, noun, extras, unknown: [] };
-    }
-    // only genuinely undeclared words are residue — a declared word in the
-    // wrong slot ("GitLab pipeline") is a structural miss, not an unknown
-    const unknown = tokens.filter((t) => !classify(t, lexicon));
-    return { term: null, individual: false, extras: [], unknown };
-  }
-  // 0 or 3+ tokens: not a fragment NP. Name the undeclared words if any.
-  return { term: null, individual: false, extras: [], unknown: tokens.filter((t) => !classify(t, lexicon)) };
-}
-
-/** The shared miss result: a structural fit with undeclared words returns the
- *  pattern + residue (triples empty); a fit with only declared-but-unusable
- *  phrasing returns null — the honest fall-through either way. */
-function missOrNull(pattern, nps, extraUnknown = []) {
-  const residue = [...extraUnknown, ...nps.flatMap((np) => np.unknown)];
-  return residue.length ? { pattern, triples: [], residue } : null;
-}
-
-const hit = (pattern, nps, triples, more = {}) => ({
-  pattern,
-  triples: [...nps.flatMap((np) => np.extras), ...triples],
-  residue: [],
-  ...more,
-});
-
-/** Pattern 3 — "N1 VERB N2" / "PROPERNAME VERBs PROPERNAME" → object-property
- *  assertion. Also the no-declared-verb 3-token shape: both ends resolvable →
- *  residue names the middle token (the future "if you mean X…" hook). */
-function parseRelation(lexicon, toks, lower) {
-  for (let i = 1; i < toks.length - 1; i += 1) {
-    const verb = lookupVerb(lexicon, lower[i]);
-    if (!verb) continue;
-    let objStart = i + 1;
-    if (verb.prep) {
-      if (lower[objStart] !== verb.prep) continue;
-      objStart += 1;
-      if (objStart >= toks.length) continue;
-    }
-    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" },
-    ]);
-  }
-  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]] };
-  }
-  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) {
-  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" },
-    ]);
-  }
-  const predicate = np1.individual ? "rdf:type" : "rdfs:subClassOf";
-  return hit(pattern, [np1], [
-    { subject: np1.term, predicate, object: `tmct:${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 isIdx = lower.indexOf("is", thatIdx + 2);
-  if (isIdx < 0 || thatIdx + 1 >= isIdx) return null;
-  const verb = lookupVerb(lexicon, lower[thatIdx + 1]);
-  const np1 = resolveNP(lexicon, toks.slice(1, thatIdx));
-  let objStart = thatIdx + 2;
-  if (verb?.prep) {
-    if (lower[objStart] !== verb.prep) return null;
-    objStart += 1;
-  }
-  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 (np1.term == null || np2.term == null || np3.term == null) {
-    return missOrNull("someValuesFrom", [np1, np2, np3]);
-  }
-  if (np1.individual || np2.individual || np3.individual) return null; // class-level pattern only
-  const pred = predicateOf(verb);
-  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], [
-    { 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 },
-    { subject: inter, predicate: "owl:intersectionOf", object: np1.term, kind: k },
-    { subject: inter, predicate: "owl:intersectionOf", object: r, kind: k },
-    { subject: inter, predicate: "rdfs:subClassOf", object: np3.term, kind: k },
-  ]);
-}
-
-/** 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). */
-function parseCardinality(lexicon, toks, lower, hasIdx) {
-  let kind = null;
-  let nIdx = -1;
-  if (lower[hasIdx + 1] === "at" && lower[hasIdx + 2] === "least") { kind = "owl:minCardinality"; nIdx = hasIdx + 3; }
-  else if (lower[hasIdx + 1] === "at" && lower[hasIdx + 2] === "most") { kind = "owl:maxCardinality"; nIdx = hasIdx + 3; }
-  else if (lower[hasIdx + 1] === "exactly") { kind = "owl:cardinality"; nIdx = hasIdx + 2; }
-  else return null;
-  const n = numberOf(lower[nIdx]);
-  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.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], [
-    { subject: r, predicate: "rdf:type", object: "owl:Restriction", kind },
-    { subject: r, predicate: "owl:onProperty", object: "tmct: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 },
-  ], { n });
-}
-
-/** Patterns 1, 4, 5 and 8's "every …" arm. */
-function parseEvery(lexicon, toks, lower) {
-  const thatIdx = lower.indexOf("that");
-  if (thatIdx > 1) return parseRestriction(lexicon, toks, lower, thatIdx);
-  const hasIdx = lower.indexOf("has");
-  if (hasIdx > 1 && (lower[hasIdx + 1] === "at" || lower[hasIdx + 1] === "exactly")) {
-    return parseCardinality(lexicon, toks, lower, hasIdx);
-  }
-  const isIdx = lower.indexOf("is");
-  if (isIdx <= 1 || isIdx === toks.length - 1) return null;
-  const np1 = resolveNP(lexicon, toks.slice(1, isIdx));
-  const rest = toks.slice(isIdx + 1);
-  if (rest.length === 1) {
-    const adj = lookupAdjective(lexicon, rest[0]);
-    if (adj) return adjectiveCopula("adjective", np1, adj);
-  }
-  const np2 = resolveNP(lexicon, rest);
-  if (np1.term == null || np2.term == null) return missOrNull("subClassOf", [np1, np2]);
-  if (np1.individual || np2.individual) return null; // "every X is chat.mjs" — not the fragment
-  return hit("subClassOf", [np1, np2], [
-    { subject: np1.term, predicate: "rdfs:subClassOf", object: np2.term, kind: "rdfs:subClassOf" },
-  ]);
-}
-
-/** Pattern 6 — "no N1 is a N2" → owl:disjointWith. */
-function parseDisjoint(lexicon, toks, lower) {
-  const isIdx = lower.indexOf("is");
-  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.individual || np2.individual) return null;
-  return hit("disjointWith", [np1, np2], [
-    { subject: np1.term, predicate: "owl:disjointWith", object: np2.term, kind: "owl:disjointWith" },
-  ]);
-}
-
-/** Pattern 7 — "N1's N2 is VALUE" / "the N2 of N1 is VALUE": data or object
- *  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 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 (!valueToks.length) return null;
-  const predicate = `tmct:${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], [
-      { subject: owner.term, predicate, object: value.term, kind: "owl:ObjectProperty" },
-    ]);
-  }
-  return hit("possessive", [owner], [
-    { subject: owner.term, predicate, object: valueToks.join(" "), kind: "owl:DatatypeProperty" },
-  ]);
-}
-
-function parsePossessive(lexicon, toks, lower) {
-  const ownerRaw = toks[0].replace(/'s$/i, "");
-  const isIdx = lower.indexOf("is");
-  if (isIdx < 2 || !ownerRaw) return null;
-  return buildPossessive(lexicon, [ownerRaw], toks.slice(1, isIdx), toks.slice(isIdx + 1));
-}
-
-function parseOfForm(lexicon, toks, lower) {
-  const ofIdx = lower.indexOf("of");
-  const isIdx = lower.indexOf("is", ofIdx + 1);
-  if (ofIdx < 2 || isIdx < ofIdx + 2) return null;
-  return buildPossessive(lexicon, toks.slice(ofIdx + 1, isIdx), toks.slice(1, ofIdx), toks.slice(isIdx + 1));
-}
-
-/** Patterns 2 (class assertion), 1's bare-copula variant, and 8's copula arm. */
-function parseCopula(lexicon, toks, lower, isIdx) {
-  const np1 = resolveNP(lexicon, toks.slice(0, isIdx));
-  const rest = toks.slice(isIdx + 1);
-  if (!rest.length) return null;
-  if (rest.length === 1) {
-    const adj = lookupAdjective(lexicon, rest[0]);
-    if (adj) return adjectiveCopula("adjective", np1, adj);
-  }
-  const np2 = resolveNP(lexicon, rest);
-  if (np1.term == null || np2.term == null) {
-    return missOrNull(np1.individual ? "typeAssertion" : "subClassOf", [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], [
-      { subject: np1.term, predicate: "rdf:type", object: np2.term, kind: "rdf:type" },
-    ]);
-  }
-  return hit("subClassOf", [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. */
+// tokenize() has no lexicon/namespace dependency at all, so it re-exports
+// unchanged. See packages/ace-owl/README.md for the parser's full contract
+// (pattern table, triple shape, the null-is-a-feature miss discipline).
+import { parseAce as parseAceLib, tokenize } from "@polycode-projects/ace-owl";
+import { loadLexicon } from "./lexicon.mjs";
+
+export { tokenize };
+
+/** parseAce(sentence, lexicon?) — `lexicon` defaults to this module's own
+ *  loadLexicon() (the "tmct:"-namespaced core), not the package's neutral
+ *  default. Every other call site (grammar/assert.mjs, chat.mjs, tests) is
+ *  free to pass its own already-namespaced lexicon (e.g. from
+ *  extensions.mjs's mergedLexiconExtra) exactly as before. */
 export function parseAce(sentence, lexicon = loadLexicon()) {
-  const toks = tokenize(sentence);
-  if (toks.length < 3) return null;
-  const lower = toks.map((t) => t.toLowerCase());
-  if (lower[0] === "every") return parseEvery(lexicon, toks, lower);
-  if (lower[0] === "no") return parseDisjoint(lexicon, toks, lower);
-  if (/'s$/.test(lower[0]) && lower[0].length > 2) return parsePossessive(lexicon, toks, lower);
-  if (lower[0] === "the" && lower.includes("of") && lower.includes("is")) {
-    return parseOfForm(lexicon, toks, lower);
-  }
-  const isIdx = lower.indexOf("is");
-  if (isIdx > 0) return parseCopula(lexicon, toks, lower, isIdx);
-  return parseRelation(lexicon, toks, lower);
+  return parseAceLib(sentence, lexicon);
 }

package/src/grammar/lexicon.mjs

@@ -1,202 +1,45 @@
-// 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 — thin re-export shim over @polycode-projects/ace-owl
+// (PLAN_OSS_ACE_PARSER.md / PLAN_AGENTS.md §3's "ace-owl open-source
+// extraction"). The declared lexicon behind tmct's ACE-OWL sub-fragment
+// parser now lives in the extracted package (packages/ace-owl/src/
+// lexicon.mjs) — this file exists ONLY to bind the package's neutral,
+// caller-supplied namespace to tmct's own "tmct:" CURIE prefix, so every
+// consumer in this repo (chat.mjs, extensions.mjs, the grammar/ontology
+// tests, …) gets BYTE-IDENTICAL behaviour to before the extraction, with a
+// single shared implementation instead of two copies drifting apart.
 //
-// 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 — 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.
-//
-// Morphology is deliberately tiny and deterministic (no NLP dependency): a
-// suffix-fold for plurals/3rd-person-singular ("repositories"→repository,
-// "relies"→rely, "classes"→class, "uses"→use) plus an optional declared
-// irregular `plural` ("indices"). Anything the fold can't reach is simply not
-// in the lexicon — honest, not clever.
-
-import { readFileSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-import { dirname, join } from "node:path";
-
-const CORE_FILE = join(dirname(fileURLToPath(import.meta.url)), "lexicon-core.json");
-
-/** Determiner tokens the grammar consumes (pattern table's every/a/no…). */
-export const DETERMINERS = Object.freeze({
-  every: "universal",
-  a: "indefinite",
-  an: "indefinite",
-  the: "definite",
-  no: "negative",
-});
-
-/** The cardinality quantifier phrases (pattern 5) → the OWL term they select. */
-export const QUANTIFIERS = Object.freeze({
-  "at least": "owl:minCardinality",
-  "at most": "owl:maxCardinality",
-  exactly: "owl:cardinality",
-});
-
-const NUMBER_WORDS = Object.freeze({
-  one: 1, two: 2, three: 3, four: 4, five: 5,
-  six: 6, seven: 7, eight: 8, nine: 9, ten: 10,
-});
-
-/** Parse a cardinality count token: a digit run or a small number word. */
-export function numberOf(word) {
-  const w = String(word ?? "").trim().toLowerCase();
-  if (/^\d+$/.test(w)) return Number(w);
-  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). */
-export function thirdPerson(base) {
-  const b = String(base);
-  if (b === "have") return "has";
-  if (/[^aeiou]y$/.test(b)) return `${b.slice(0, -1)}ies`;
-  if (/(s|x|z|ch|sh)$/.test(b)) return `${b}es`;
-  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) {
-  if (verbEntry.predicate) return verbEntry.predicate;
-  const prep = verbEntry.prep ? verbEntry.prep[0].toUpperCase() + verbEntry.prep.slice(1) : "";
-  return `tmct:${thirdPerson(verbEntry.lemma)}${prep}`;
-}
-
-/** Deterministic singular/base-form candidates for a surface word, most
- *  specific first: as-is, -ies→y, -(s|x|z|ch|sh)es→stem, -s→stem. The FIRST
- *  candidate found in the relevant map wins ("classes"→class before "classe";
- *  "uses"→"us" misses, "use" hits). */
-function foldCandidates(word) {
-  const w = String(word);
-  const out = [w];
-  if (w.length > 4 && /[a-z]ies$/.test(w)) out.push(`${w.slice(0, -3)}y`);
-  if (/(ses|xes|zes|ches|shes)$/.test(w)) out.push(w.slice(0, -2));
-  if (/[a-z]s$/.test(w) && !/ss$/.test(w)) out.push(w.slice(0, -1));
-  if (w === "has") out.push("have");
-  return out;
-}
-
-const NOUN_PROPERTY_TYPES = new Set(["data", "object"]);
-const ADJECTIVE_TYPES = new Set(["subclass", "data"]);
-
-/** Merge one raw lexicon block ({nouns, verbs, adjectives, properNames}) into
- *  the lookup maps, validating the declared typings (bad declarations throw —
- *  a lexicon that lies would make the grammar guess). */
-function ingest(lex, raw = {}) {
-  for (const [lemma, e] of Object.entries(raw.nouns || {})) {
-    const entry = { lemma, ...(e || {}) };
-    if (entry.property && !NOUN_PROPERTY_TYPES.has(entry.property)) {
-      throw new Error(`lexicon noun "${lemma}": property must be "data" or "object", got ${JSON.stringify(entry.property)}`);
-    }
-    lex.nouns.set(lemma, entry);
-    if (entry.plural) lex.nounPlurals.set(entry.plural, lemma);
-  }
-  for (const [lemma, e] of Object.entries(raw.verbs || {})) {
-    lex.verbs.set(lemma, { lemma, ...(e || {}) });
-  }
-  for (const [lemma, e] of Object.entries(raw.adjectives || {})) {
-    const entry = { lemma, ...(e || {}) };
-    if (!ADJECTIVE_TYPES.has(entry.type)) {
-      throw new Error(`lexicon adjective "${lemma}": type must be "subclass" or "data", got ${JSON.stringify(entry.type)}`);
-    }
-    lex.adjectives.set(lemma, entry);
-  }
-  for (const name of raw.properNames || []) {
-    lex.properNames.set(String(name).toLowerCase(), String(name));
-  }
-}
-
-let coreCache = null;
-
-/** 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). */
+// Everything else (morphology, classify(), the committed starter vocabulary)
+// is the package's — see packages/ace-owl/README.md for the full API and
+// packages/ace-owl/src/lexicon-core.json for the vocabulary itself (also the
+// canonical copy now; this repo no longer carries its own lexicon-core.json).
+import * as aceOwl from "@polycode-projects/ace-owl";
+
+export const TMCT_NS = "tmct:";
+
+export const {
+  DETERMINERS, QUANTIFIERS, numberOf, thirdPerson,
+  lookupNoun, lookupVerb, lookupAdjective, lookupProperName,
+} = aceOwl;
+
+/** loadLexicon(extra) — bound to tmct's own "tmct:" namespace, so the
+ *  no-extra call stays the same cached, byte-identical lexicon it always
+ *  was (see ace-owl's loadLexicon(extra, ns) — ns defaults to the package's
+ *  own neutral "ex:" when not passed, which tmct never wants). */
 export function loadLexicon(extra) {
-  if (!extra && coreCache) return coreCache;
-  const raw = JSON.parse(readFileSync(CORE_FILE, "utf8"));
-  const lex = {
-    nouns: new Map(),
-    nounPlurals: new Map(),
-    verbs: new Map(),
-    adjectives: new Map(),
-    properNames: new Map(), // lowercased → canonical spelling
-  };
-  ingest(lex, raw);
-  if (extra) {
-    ingest(lex, extra);
-    return lex;
-  }
-  coreCache = lex;
-  return lex;
+  return aceOwl.loadLexicon(extra, TMCT_NS);
 }
 
-/** Noun lookup with plural folding; returns the entry ({lemma, property?}) or null. */
-export function lookupNoun(lexicon, word) {
-  const w = String(word ?? "").toLowerCase();
-  const irregular = lexicon.nounPlurals.get(w);
-  if (irregular) return lexicon.nouns.get(irregular) ?? null;
-  for (const cand of foldCandidates(w)) {
-    const hit = lexicon.nouns.get(cand);
-    if (hit) return hit;
-  }
-  return null;
-}
-
-/** Verb lookup with 3sg folding; returns the entry ({lemma, prep?, predicate?}) or null. */
-export function lookupVerb(lexicon, word) {
-  const w = String(word ?? "").toLowerCase();
-  for (const cand of foldCandidates(w)) {
-    const hit = lexicon.verbs.get(cand);
-    if (hit) return hit;
-  }
-  return null;
-}
-
-/** Adjective lookup (exact lemma); returns {lemma, type, property?, value?} or null. */
-export function lookupAdjective(lexicon, word) {
-  return lexicon.adjectives.get(String(word ?? "").toLowerCase()) ?? null;
-}
-
-/** Proper-name lookup, case-insensitive; returns the CANONICAL spelling or null. */
-export function lookupProperName(lexicon, word) {
-  return lexicon.properNames.get(String(word ?? "").toLowerCase()) ?? null;
+/** predicateOf(verbEntry) — bound to tmct's own "tmct:" namespace, same
+ *  reasoning as loadLexicon above. */
+export function predicateOf(verbEntry) {
+  return aceOwl.predicateOf(verbEntry, TMCT_NS);
 }
 
-/** Classify one word (or a two-word quantifier phrase) against the lexicon.
- *  Returns {pos, type?, …} or null for an undeclared word. Priority when a
- *  word is declared in several categories (e.g. "test" noun+verb): closed-class
- *  tokens, then properName > noun > verb > adjective — the grammar itself
- *  disambiguates by position, this is the standalone answer. */
+/** classify(word, lexicon?) — re-exported with `lexicon` re-defaulted to
+ *  THIS module's own loadLexicon() (the "tmct:"-namespaced core), not the
+ *  package's neutral default; every no-lexicon call site (chat.mjs,
+ *  grammar/ace.mjs's own resolveNP, the grammar tests) must keep seeing
+ *  "tmct:"-prefixed verb predicates in the classification it returns. */
 export function classify(word, lexicon = loadLexicon()) {
-  const w = String(word ?? "").trim();
-  if (!w) return null;
-  const lower = w.toLowerCase();
-  if (DETERMINERS[lower]) return { pos: "determiner", type: DETERMINERS[lower] };
-  if (QUANTIFIERS[lower]) return { pos: "quantifier", type: QUANTIFIERS[lower] };
-  const n = numberOf(lower);
-  if (n != null) return { pos: "number", type: "cardinal", value: n };
-  const proper = lookupProperName(lexicon, w);
-  if (proper) return { pos: "properName", type: "individual", canonical: proper };
-  const noun = lookupNoun(lexicon, lower);
-  if (noun) {
-    return noun.property
-      ? { pos: "noun", type: `${noun.property}-property`, lemma: noun.lemma, property: noun.property }
-      : { pos: "noun", type: "class", lemma: noun.lemma };
-  }
-  const verb = lookupVerb(lexicon, lower);
-  if (verb) {
-    return { pos: "verb", type: "objectProperty", lemma: verb.lemma, predicate: predicateOf(verb), ...(verb.prep ? { prep: verb.prep } : {}) };
-  }
-  const adj = lookupAdjective(lexicon, lower);
-  if (adj) return { pos: "adjective", type: adj.type, lemma: adj.lemma };
-  return null;
+  return aceOwl.classify(word, lexicon);
 }

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