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

package/ROADMAP.md

@@ -1052,19 +1052,25 @@ candidate for the plan's next spike, not a claimed result. Everything else is de
 plan's open questions, where the relevance problem is named as the open research risk it is.
 
 ### Open-source the ACE-OWL parser as a standalone library
-> **STATUS: deferred follow-up** — not yet started; still gated on the Phase 8 library-surface
-> work settling the extraction boundary. See `PLAN_OSS_ACE_PARSER.md`.
+> **STATUS: tried, reverted (2026-07-10).** A session extracted `ace.mjs`/`lexicon.mjs` into
+> `packages/ace-owl`, a new npm workspace, and pointed tmct's own `package.json` at it as a
+> registry dependency — but never published the package. That broke `npm install` for tmct
+> itself (`@polycode-projects/ace-owl` 404s on the public registry, since it only ever existed as
+> a local workspace symlink). Folded back into `src/grammar/` the same day, on operator
+> instruction, once the break was found. If this is worth doing again, publish the package FIRST
+> (or in the same change), never split the two steps across a batch. See `PLAN_OSS_ACE_PARSER.md`.
 
 *(Operator-specified 2026-07-05, from the dependency audit's publish-not-replace finding.)* The
 pure-JS, ESM, dependency-free ACE-OWL controlled-grammar parser (`src/grammar/ace.mjs` +
 `lexicon.mjs`) that turns controlled-English sentences into OWL-labelled triples is a RARE thing:
 the reference implementation (APE) is GPL + SWI-Prolog (native), so there is no permissive,
 browser-capable, npm-installable ACE→OWL parser in the JS ecosystem. tmct's is exactly that.
-Extract it to its own MPL-2.0 package (tmct depends on it back), so the wider RDF/OWL/semantic-web
-JS community gains a controlled-natural-language front-end that runs in the browser. Gated on the
-Repository Interface library-surface work (Phase 8) settling the extraction boundary; see
-`PLAN_OSS_ACE_PARSER.md`. Sibling publish-candidates (the bounded-Damerau fuzzy matcher, the
-PageRank+IDF block ranker) may follow the same path if there is demand.
+Extracting it to its own MPL-2.0 package (tmct depending on it back) would give the wider
+RDF/OWL/semantic-web JS community a controlled-natural-language front-end that runs in the
+browser — genuine value, but only once actually published; see `PLAN_OSS_ACE_PARSER.md` for the
+full design and the note above for what went wrong the first attempt. Sibling publish-candidates
+(the bounded-Damerau fuzzy matcher, the PageRank+IDF block ranker) are lower priority than getting
+this one right before trying another.
 
 ## Phase 10 — Conversational competence & onboarding (0.6.0 → 0.7.0)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polycode-projects/the-mechanical-code-talker",
-  "version": "1.5.2",
+  "version": "1.5.3",
   "private": false,
   "type": "module",
   "description": "The Mechanical Code Talker (tmct) — a tolerant, offline, $0 chat surface that guides you toward precision queries about a software repository. ELIZA/PARRY-style but domain-obsessed with code. No model calls; no codebase index of its own.",
@@ -36,9 +36,6 @@
   "engines": {
     "node": ">=24"
   },
-  "workspaces": [
-    "packages/*"
-  ],
   "bin": {
     "tmct": "./bin/tmct.mjs"
   },
@@ -71,7 +68,6 @@
     "access": "public"
   },
   "dependencies": {
-    "@polycode-projects/ace-owl": "^0.1.0",
     "ink": "^7.1.0",
     "react": "^19.2.7",
     "smol-toml": "^1.7.0",
@@ -83,6 +79,11 @@
     "chat": "node bin/tmct.mjs",
     "chat:repo": "node bin/tmct.mjs chat --repo",
     "init": "node bin/tmct.mjs init",
+    "init:persona:code": "node bin/tmct.mjs init --with-persona code",
+    "init:corpus:general": "node bin/tmct.mjs init --corpus general",
+    "init:corpus:aws": "node bin/tmct.mjs init --corpus aws",
+    "init:corpus:python": "node bin/tmct.mjs init --corpus python",
+    "init:corpus:java": "node bin/tmct.mjs init --corpus java",
     "memory": "node bin/tmct.mjs memory",
     "syllogise": "node bin/tmct.mjs syllogise",
     "example:mini": "node bin/tmct.mjs chat --repo examples/mini-webapp --ephemeral",

package/src/grammar/ace.mjs

@@ -1,27 +1,375 @@
-// 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.
+// 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.
 //
-// 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. */
+// parseAce(sentence, lexicon) → { pattern, triples, residue } | null
+//   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
+//            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
+// (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
+// 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);
+}
+
+/** 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;
+
+/** 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 ns = lexicon.ns;
+  const tokens = stripDet(tokensIn);
+  if (tokens.length === 1) {
+    const t = tokens[0];
+    const proper = lookupProperName(lexicon, t);
+    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: `${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 = `${ns}${adj.lemma}-${noun.lemma}`;
+      const extras = [
+        { 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: `${ns}${adj.lemma}`, kind: "rdfs:subClassOf" });
+      } else {
+        // data adjective: subclass-with-restriction on the boolean-ish property
+        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 || `${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" },
+        );
+      }
+      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(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: 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(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 || `${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: `${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]);
+  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(PATTERN_SOME_VALUES_FROM, [np1, np2, np3], [toks[thatIdx + 1]]);
+  if (np1.term == null || np2.term == null || np3.term == null) {
+    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, ns);
+  const k = "owl:someValuesFrom";
+  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 },
+    { 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 `${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; }
+  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(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 = `${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: `${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 },
+  ], { 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(lexicon, PATTERN_ADJECTIVE, np1, adj);
+  }
+  const np2 = resolveNP(lexicon, rest);
+  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(PATTERN_SUB_CLASS_OF, [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(PATTERN_DISJOINT_WITH, [np1, np2]);
+  if (np1.individual || np2.individual) return null;
+  return hit(PATTERN_DISJOINT_WITH, [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 ns = lexicon.ns;
+  const owner = resolveNP(lexicon, ownerToks);
+  if (headToks.length !== 1) return null;
+  const head = lookupNoun(lexicon, headToks[0]);
+  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 = `${ns}${head.lemma}`;
+  if ((head.property || "data") === "object") {
+    const value = resolveNP(lexicon, valueToks);
+    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(PATTERN_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(lexicon, PATTERN_ADJECTIVE, np1, adj);
+  }
+  const np2 = resolveNP(lexicon, rest);
+  if (np1.term == null || np2.term == null) {
+    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(PATTERN_TYPE_ASSERTION, [np1, np2], [
+      { subject: np1.term, predicate: "rdf:type", object: np2.term, kind: "rdf:type" },
+    ]);
+  }
+  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
+ *  under the library's own neutral DEFAULT_NS ("ex:") when the caller doesn't
+ *  supply one. */
 export function parseAce(sentence, lexicon = loadLexicon()) {
-  return parseAceLib(sentence, lexicon);
+  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);
 }

package/src/grammar/lexicon-core.json

@@ -0,0 +1,302 @@
+{
+  "comment": "tmct's starter software-domain lexicon (ROADMAP Phase 2, item 2). Every word the ACE-OWL sub-fragment parser (src/grammar/ace.mjs) is allowed to understand is DECLARED here — tmct never guesses a word's category. Nouns may declare a possessive property typing ('data' or 'object', pattern 7); adjectives MUST declare a type ('subclass' forms a class, 'data' asserts a boolean-ish datatype property, pattern 8); verbs may declare a preposition ('depend' + 'on' → dependsOn). Extend via loadLexicon(extra) with this same shape.",
+  "nouns": {
+    "module": {},
+    "class": {},
+    "function": {},
+    "method": {},
+    "attribute": {},
+    "variable": {},
+    "constant": {},
+    "test": {},
+    "suite": {},
+    "service": {},
+    "repository": {},
+    "branch": {},
+    "commit": {},
+    "tag": {},
+    "release": {},
+    "package": {},
+    "library": {},
+    "framework": {},
+    "api": {},
+    "endpoint": {},
+    "route": {},
+    "handler": {},
+    "controller": {},
+    "model": {},
+    "view": {},
+    "template": {},
+    "component": {},
+    "interface": {},
+    "type": {},
+    "category": {},
+    "kind": {},
+    "artifact": {},
+    "routine": {},
+    "part": {},
+    "helper": {},
+    "operation": {},
+    "change": {},
+    "schema": {},
+    "database": {},
+    "table": {},
+    "query": {},
+    "index": { "plural": "indices" },
+    "cache": {},
+    "queue": {},
+    "worker": {},
+    "job": {},
+    "task": {},
+    "bug": {},
+    "defect": {},
+    "issue": {},
+    "ticket": {},
+    "feature": {},
+    "requirement": {},
+    "specification": {},
+    "document": {},
+    "developer": {},
+    "engineer": {},
+    "user": {},
+    "visitor": {},
+    "team": {},
+    "project": {},
+    "codebase": {},
+    "file": {},
+    "directory": {},
+    "folder": {},
+    "line": {},
+    "symbol": {},
+    "identifier": {},
+    "comment": {},
+    "docstring": {},
+    "string": {},
+    "number": {},
+    "list": {},
+    "array": {},
+    "graph": {},
+    "node": {},
+    "edge": {},
+    "triple": {},
+    "fact": {},
+    "ontology": {},
+    "lexicon": {},
+    "grammar": {},
+    "sentence": {},
+    "utterance": {},
+    "session": {},
+    "response": {},
+    "request": {},
+    "question": {},
+    "answer": {},
+    "error": {},
+    "exception": {},
+    "warning": {},
+    "log": {},
+    "metric": {},
+    "benchmark": {},
+    "pipeline": {},
+    "build": {},
+    "deployment": {},
+    "environment": {},
+    "config": {},
+    "configuration": {},
+    "setting": {},
+    "option": {},
+    "flag": {},
+    "argument": {},
+    "parameter": {},
+    "value": {},
+    "result": {},
+    "output": {},
+    "input": {},
+    "server": {},
+    "client": {},
+    "protocol": {},
+    "message": {},
+    "event": {},
+    "hook": {},
+    "plugin": {},
+    "script": {},
+    "tool": {},
+    "command": {},
+    "prompt": {},
+    "token": {},
+    "parser": {},
+    "compiler": {},
+    "linter": {},
+    "formatter": {},
+    "runtime": {},
+    "process": {},
+    "thread": {},
+    "loop": {},
+    "statement": {},
+    "expression": {},
+    "keyword": {},
+    "scope": {},
+    "callback": {},
+    "promise": {},
+    "iterator": {},
+    "generator": {},
+    "unit": {},
+    "risk": {},
+    "prototype": {},
+    "milestone": {},
+    "sprint": {},
+    "backlog": {},
+    "roadmap": {},
+    "phase": {},
+    "pattern": {},
+    "smell": {},
+    "coverage": {},
+    "mock": {},
+    "stub": {},
+    "fixture": {},
+    "assertion": {},
+    "snapshot": {},
+    "regression": {},
+    "migration": {},
+    "refactor": {},
+    "review": {},
+    "merge": {},
+    "license": { "property": "data" },
+    "version": { "property": "data" },
+    "name": { "property": "data" },
+    "path": { "property": "data" },
+    "size": { "property": "data" },
+    "status": { "property": "data" },
+    "language": { "property": "data" },
+    "extension": { "property": "data" },
+    "churn": { "property": "data" },
+    "impact": { "property": "data" },
+    "complexity": { "property": "data" },
+    "latency": { "property": "data" },
+    "duration": { "property": "data" },
+    "frequency": { "property": "data" },
+    "severity": { "property": "data" },
+    "owner": { "property": "object" },
+    "maintainer": { "property": "object" },
+    "author": { "property": "object" },
+    "reviewer": { "property": "object" },
+    "parent": { "property": "object" },
+    "dependency": { "property": "object" }
+  },
+  "verbs": {
+    "import": {},
+    "call": {},
+    "test": {},
+    "contain": {},
+    "extend": {},
+    "use": {},
+    "depend": { "prep": "on" },
+    "rely": { "prep": "on" },
+    "inherit": { "prep": "from" },
+    "belong": { "prep": "to" },
+    "point": { "prep": "to" },
+    "implement": {},
+    "override": {},
+    "export": {},
+    "define": {},
+    "declare": {},
+    "reference": {},
+    "invoke": {},
+    "wrap": {},
+    "mock": {},
+    "cover": {},
+    "document": {},
+    "describe": {},
+    "modify": {},
+    "touch": {},
+    "fix": {},
+    "break": {},
+    "introduce": {},
+    "deprecate": {},
+    "replace": {},
+    "own": {},
+    "maintain": {},
+    "review": {},
+    "merge": {},
+    "revert": {},
+    "deploy": {},
+    "run": {},
+    "execute": {},
+    "load": {},
+    "parse": {},
+    "emit": {},
+    "validate": {},
+    "log": {},
+    "throw": {},
+    "catch": {},
+    "create": {},
+    "delete": {},
+    "update": {},
+    "expose": {},
+    "consume": {},
+    "produce": {},
+    "generate": {},
+    "configure": {},
+    "install": {},
+    "publish": {},
+    "release": {},
+    "ship": {},
+    "watch": {},
+    "trigger": {},
+    "build": {},
+    "write": {},
+    "read": {},
+    "have": {}
+  },
+  "adjectives": {
+    "legacy": { "type": "subclass" },
+    "internal": { "type": "subclass" },
+    "external": { "type": "subclass" },
+    "public": { "type": "subclass" },
+    "private": { "type": "subclass" },
+    "abstract": { "type": "subclass" },
+    "static": { "type": "subclass" },
+    "async": { "type": "subclass" },
+    "experimental": { "type": "subclass" },
+    "stable": { "type": "subclass" },
+    "core": { "type": "subclass" },
+    "shared": { "type": "subclass" },
+    "global": { "type": "subclass" },
+    "local": { "type": "subclass" },
+    "generated": { "type": "subclass" },
+    "standalone": { "type": "subclass" },
+    "primary": { "type": "subclass" },
+    "secondary": { "type": "subclass" },
+    "deprecated": { "type": "data" },
+    "fast": { "type": "data" },
+    "slow": { "type": "data" },
+    "large": { "type": "data" },
+    "small": { "type": "data" },
+    "flaky": { "type": "data" },
+    "tested": { "type": "data" },
+    "documented": { "type": "data" },
+    "buggy": { "type": "data" },
+    "broken": { "type": "data" },
+    "green": { "type": "data" },
+    "deterministic": { "type": "data" },
+    "pure": { "type": "data" },
+    "empty": { "type": "data" },
+    "stale": { "type": "data" }
+  },
+  "properNames": [
+    "tmct",
+    "Node",
+    "npm",
+    "JavaScript",
+    "TypeScript",
+    "Python",
+    "Java",
+    "Git",
+    "GitHub",
+    "GitLab",
+    "ESLint",
+    "Linux",
+    "macOS",
+    "Windows",
+    "Polycode"
+  ]
+}

package/src/grammar/lexicon.mjs

@@ -1,45 +1,217 @@
-// 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.
+// 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).
 //
-// 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) {
-  return aceOwl.loadLexicon(extra, TMCT_NS);
-}
-
-/** 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(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. */
+// 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.
+//
+// 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,
+// "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");
+
+/** 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",
+  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 ("import"→imports,
+ *  "rely"→relies, "catch"→catches, "have"→has) — the predicate spelling. */
+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
+ *  (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 `${ns}${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));
+  }
+}
+
+// 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).
+ *  `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(),
+    nounPlurals: new Map(),
+    verbs: new Map(),
+    adjectives: new Map(),
+    properNames: new Map(), // lowercased → canonical spelling
+    ns,
+  };
+  ingest(lex, raw);
+  if (extra) {
+    ingest(lex, extra);
+    return lex;
+  }
+  coreCacheByNs.set(ns, lex);
+  return lex;
+}
+
+/** 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;
+}
+
+/** 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. */
 export function classify(word, lexicon = loadLexicon()) {
-  return aceOwl.classify(word, lexicon);
+  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, lexicon.ns), ...(verb.prep ? { prep: verb.prep } : {}) };
+  }
+  const adj = lookupAdjective(lexicon, lower);
+  if (adj) return { pos: "adjective", type: adj.type, lemma: adj.lemma };
+  return null;
 }