@polycode-projects/the-mechanical-code-talker 1.5.4 → 1.8.3

package/src/extensions.mjs

@@ -5,23 +5,41 @@
 //
 //   resolveExtensions(repoRoot) → { entries: Map<name, ResolvedEntry>, biasByBundle }
 //
-// BUILTIN_EXTENSIONS ships the exact two bundles chat.mjs's bootstrap has
-// always seeded — `seon` and `conceptnet`, both active — plus four shipped-
-// but-INACTIVE tier-2 bundles (`tier2-aws` / `tier2-python` / `tier2-java` /
-// `tier2-general`). Activating one is a config-only edit (`tmct init --corpus
+// BUILTIN_EXTENSIONS' DEFAULT ACTIVE BUNDLE IS `human` (PLAN_SEED.md, the
+// persona flip): a fresh repo now seeds an everyday-world vocabulary (people,
+// places, objects, nature, time/events, body/food, mind — hand-curated from
+// Open English WordNet + Schema.org) rather than the old implicit code-domain
+// default. `seon` and `conceptnet` are SHIPPED but now INACTIVE — both are
+// equally code/tech-domain-biased (conceptnet's committed slice was filtered
+// via a tech-domain seed-term match, PLAN_SEED.md §2), so BOTH flip together,
+// not just seon — a repo that wants the old behavior asks for it explicitly
+// (`tmct init --with-persona code`, or `[extensions.seon]`/`[extensions.
+// conceptnet]` `active = true`). Four more shipped-but-INACTIVE tier-2 bundles
+// (`tier2-aws` / `tier2-python` / `tier2-java` / `tier2-general`) round out the
+// catalog. Activating any of these is a config-only edit (`tmct init --corpus
 // aws`, or a `[extensions.tier2-aws] active = true` in tmct.toml) — zero code
-// change. `tier2-general` (PLAN_AGENTS.md Phase 1) is deliberately NOT a
-// language/domain bundle like the other three — everyday-knowledge concepts
-// with zero code-domain framing, the "wider general-knowledge seed set"
-// bullet made real instead of just mechanically activatable.
+// change. `tier2-general`'s own 49-fact animal/weather set (PLAN_AGENTS.md
+// Phase 1) is superseded IN DEFAULT ROLE by `human`'s much larger
+// `human-nature` clump, but stays shipped/selectable on its own for a caller
+// that wants that narrow slice without the rest of the human persona.
+//
+// `human-medium`/`human-large` (also shipped-but-INACTIVE) are SIZE TIERS of
+// the SAME `human` bundle, not separate personas (PLAN_SEED.md §3) — each
+// holds only the facts that size adds beyond the previous one. Activated
+// together via `tmct init --persona-size medium|large` (bin/tmct.mjs), which
+// resolves them through this same registry.
 //
 // A `tmct.toml` may carry a top-level `[extensions]` table-of-tables
 // (`[extensions.tier2-aws]`, …): a RECOGNIZED name (one of the builtins above)
 // may override `active`/paths/etc; an UNRECOGNIZED name declares a brand new
-// host entry and MUST carry a `kind` (corpus | lexicon | templates | pack) — a
-// `pack` entry may combine any of corpus_path/lexicon_path/templates_path/
-// phrasebook_path under one `active` flag and one provenance name, the shape a
-// third-party vocabulary package hands tmct.
+// host entry and MUST carry a `kind` (corpus | lexicon | templates | pack |
+// ontology) — a `pack` entry may combine any of corpus_path/lexicon_path/
+// templates_path/phrasebook_path under one `active` flag and one provenance
+// name, the shape a third-party vocabulary package hands tmct. `ontology` is a
+// DISTINCT, nameable kind for an ontology bundle (as opposed to a plain
+// `corpus` bundle) — its `ontology_path` key is just an alias populating the
+// SAME internal `corpusPath` field a corpus entry uses, so every downstream
+// seeder/loader needs zero branching by kind name.
 //
 // A SEPARATE top-level `[bias]` table (flat: bundle-name → number) feeds
 // src/memory/bias.mjs's ranking — never nested under `[extensions.*]`.
@@ -45,7 +63,7 @@ import {
   toFacts,
 } from "./corpus/conceptnet.mjs";
 
-export const EXTENSION_KINDS = Object.freeze(["corpus", "lexicon", "templates", "pack"]);
+export const EXTENSION_KINDS = Object.freeze(["corpus", "lexicon", "templates", "pack", "ontology"]);
 
 // The definitional-band-first predicate order chat.mjs's bootstrap has always
 // passed for the ConceptNet seed (SEED_PREFER) — re-declared here (not
@@ -57,15 +75,20 @@ const CONCEPTNET_PREFER = ["rdfs:subClassOf", "rdf:type", "mgx:usedFor", "mgx:pa
  *  accidentally mutate a module-level singleton. */
 function builtinExtensions() {
   return {
+    // WAS active:true (the implicit code-domain default) — now opt-in.
+    // PLAN_SEED.md §2: re-activate explicitly (`tmct init --with-persona
+    // code`, or `[extensions.seon] active = true`) for the old behavior.
     seon: {
       kind: "corpus",
-      active: true,
+      active: false,
       corpusPath: SEON_CONCEPTS_FILE,
       provenancePrefix: "corpus:seon",
     },
+    // WAS active:true — now opt-in too, not just seon (PLAN_SEED.md §2: the
+    // committed slice is itself tech-domain-filtered, equally biased).
     conceptnet: {
       kind: "corpus",
-      active: true,
+      active: false,
       corpusPath: CONCEPTNET_SLICE_FILE,
       provenancePrefix: "corpus:conceptnet",
       // matches chat.mjs's seedBootstrapMemory exactly: uncapped, definitional
@@ -73,6 +96,40 @@ function builtinExtensions() {
       limit: undefined,
       prefer: CONCEPTNET_PREFER,
     },
+    // NEW — the default active bundle (PLAN_SEED.md). Everyday-world
+    // vocabulary: people, places, objects, nature, time/events, body/food,
+    // mind, plus the human-base/human-bridge scaffolding connecting WordNet's
+    // and Schema.org's independently-built taxonomies (PLAN_SEED.md §3, §8).
+    human: {
+      kind: "corpus",
+      active: true,
+      corpusPath: join(TIER2_DIR, "human.jsonl"),
+      provenancePrefix: "corpus:human",
+    },
+    // NEW — Medium/Large SIZE tiers of the SAME `human` bundle (PLAN_SEED.md
+    // §3), not separate personas: each file holds ONLY the facts that size
+    // adds beyond the previous one (Medium beyond Small, Large beyond
+    // Medium), so activating them is purely ADDITIVE alongside `human`
+    // (never a replacement for it). Both ship INACTIVE — Small stays the
+    // unconditional default — and are activated together via `tmct init
+    // --persona-size medium|large` (bin/tmct.mjs), which resolves them
+    // through this SAME BUILTIN_EXTENSIONS lookup and the ordinary
+    // `--corpus <id>` activation seam (activatePluggableInput). "large"
+    // activates BOTH human-medium and human-large (Large's facts are
+    // Medium's plus its own — both bundles must be active to reach the
+    // full ~13,600-fact total).
+    "human-medium": {
+      kind: "corpus",
+      active: false,
+      corpusPath: join(TIER2_DIR, "human-medium.jsonl"),
+      provenancePrefix: "corpus:human-medium",
+    },
+    "human-large": {
+      kind: "corpus",
+      active: false,
+      corpusPath: join(TIER2_DIR, "human-large.jsonl"),
+      provenancePrefix: "corpus:human-large",
+    },
     "tier2-aws": {
       kind: "corpus",
       active: false,
@@ -118,6 +175,9 @@ export function validateExtensionEntry(name, entry) {
   if (entry.kind === "corpus" && !entry.corpusPath) {
     throw new Error(`extension "${name}": a "corpus" entry needs corpus_path`);
   }
+  if (entry.kind === "ontology" && !entry.corpusPath) {
+    throw new Error(`extension "${name}": an "ontology" entry needs ontology_path`);
+  }
   if (entry.kind === "lexicon" && !entry.lexiconPath) {
     throw new Error(`extension "${name}": a "lexicon" entry needs lexicon_path`);
   }
@@ -154,6 +214,7 @@ function mergeExtensionEntry(name, builtin, override, repoRoot) {
   };
   const paths = [
     ["corpus_path", "corpusPath"],
+    ["ontology_path", "corpusPath"], // alias: an "ontology" entry's own path key, same internal field as "corpus"
     ["lexicon_path", "lexiconPath"],
     ["templates_path", "templatesPath"],
     ["phrasebook_path", "phrasebookPath"],
@@ -184,9 +245,13 @@ function mergeExtensionEntry(name, builtin, override, repoRoot) {
  *     table (default {} — every bundle then ranks at bias 1, see bias.mjs).
  * No `tmct.toml` (or one with no `[extensions]`/`[bias]` tables) resolves to
  * exactly today's implicit seon+conceptnet default, byte-identical.
+ *
+ * `configFile` (optional): an explicit tmct.toml path override — `tmct extend
+ * --validate <dir> --config <path>` — read INSTEAD of `<repoRoot>/tmct.toml`;
+ * `repoRoot` still anchors every resource path (unchanged).
  */
-export async function resolveExtensions(repoRoot) {
-  const raw = repoRoot ? await loadTomlConfig(repoRoot) : null;
+export async function resolveExtensions(repoRoot, { configFile } = {}) {
+  const raw = repoRoot ? await loadTomlConfig(repoRoot, configFile ? { file: configFile } : {}) : null;
   const defs = builtinExtensions();
   const rawExtensions = (raw && raw.extensions && typeof raw.extensions === "object") ? raw.extensions : {};
   const rawBias = (raw && raw.bias && typeof raw.bias === "object") ? raw.bias : {};
@@ -216,12 +281,19 @@ export async function resolveExtensions(repoRoot) {
 
 // ---- Part 2: the unified corpus loader loop ---------------------------------
 
-/** Seed every ACTIVE `corpus`-kind entry (in the Map's own fixed order — seon,
+/** Seed every ACTIVE `corpus`/`ontology`-kind entry, plus any ACTIVE `pack`-kind
+ *  entry that declares a `corpusPath` (in the Map's own fixed order — seon,
  *  conceptnet, then the rest sorted by name) into `repo`'s memory, ONE
  *  seedMemory() call per bundle. Shared by chat.mjs's first-run bootstrap,
  *  `tmct init`'s seed step and `tmct init --corpus <id>` — so all three read
  *  the SAME loop instead of three independent hardcoded call sites.
  *
+ *  BUGFIX (this batch): a `pack`-kind entry's `corpusPath` used to be silently
+ *  skipped here despite this module's own docblock claiming pack entries
+ *  combine corpus_path/lexicon_path/etc — a pack's corpus facts never made it
+ *  into memory. Fixed by seeding any active pack entry that declares a
+ *  corpusPath, alongside corpus/ontology entries.
+ *
  *  FAILURE-TOLERANT per bundle (init.mjs's own doctrine: a missing/broken
  *  corpus degrades to "not seeded", never a crash): one bad third-party pack's
  *  seedMemory throw is CAUGHT and recorded as `perBundle[name].error` — logged
@@ -235,7 +307,16 @@ export async function seedActiveCorpusEntries(repo, entries) {
   let skipped = 0;
   let total = 0;
   for (const [name, entry] of entries instanceof Map ? entries : new Map()) {
-    if (entry.kind !== "corpus" || !entry.active) continue;
+    // PLAN_SEED.md §2 bug fix: a "pack"-kind entry with its own corpusPath
+    // combines corpus/lexicon/templates under one active flag (this module's
+    // own docblock says so) but was previously never actually seeded here —
+    // only bare `kind: "corpus"` entries were. Broadened, not narrowed: every
+    // existing `kind: "corpus"`/`kind: "ontology"` entry (seon/conceptnet/
+    // human/tier2-*) behaves identically to before; only a pack entry that
+    // DOES carry a corpusPath newly qualifies.
+    if (!entry.active) continue;
+    const seedable = entry.kind === "corpus" || entry.kind === "ontology" || (entry.kind === "pack" && entry.corpusPath);
+    if (!seedable) continue;
     try {
       const res = await seedMemory(repo, {
         slicePath: entry.corpusPath,

package/src/grammar/ace.mjs

@@ -39,6 +39,11 @@ import {
   predicateOf, numberOf, classify,
 } from "./lexicon.mjs";
 
+// "a"/"an" are the only ACE determiners that are grammatically SINGULAR-ONLY —
+// "the" and a bare/no determiner are number-neutral (see resolveNP's
+// singularOnly below, and lexicon.mjs's lookupNoun doc for what this prunes).
+const SINGULAR_ONLY_DET = new Set(["a", "an"]);
+
 export const PATTERN_SUB_CLASS_OF = "subClassOf";
 export const PATTERN_TYPE_ASSERTION = "typeAssertion";
 export const PATTERN_RELATION = "relation";
@@ -89,22 +94,29 @@ const stripDet = (tokens) =>
  *  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). */
+ *  pattern-8 adjective triples (subclass axioms / hasValue restriction).
+ *
+ *  `singularOnly` is grammatical-agreement pruning (see lexicon.mjs's
+ *  lookupNoun doc): true only when the ORIGINAL (pre-strip) phrase opened
+ *  with "a"/"an" — the one signal that a singular-plural-fold collision
+ *  (die/dice, person/people, tooth/teeth) can be resolved by, rather than
+ *  silently committing to whichever the lexicon happens to fold to first. */
 function resolveNP(lexicon, tokensIn) {
   const ns = lexicon.ns;
+  const singularOnly = tokensIn.length > 1 && SINGULAR_ONLY_DET.has(tokensIn[0].toLowerCase());
   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);
+    const noun = lookupNoun(lexicon, t, { singularOnly });
     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]);
+    const noun = lookupNoun(lexicon, tokens[1], { singularOnly });
     if (adj && noun) {
       const term = `${ns}${adj.lemma}-${noun.lemma}`;
       const extras = [
@@ -178,6 +190,76 @@ function parseRelation(lexicon, toks, lower) {
   return null;
 }
 
+// ---- ambiguity: breadth-first candidate parses, dead ends pruned, survivors
+// surfaced rather than guessed (the operator's own framing — see
+// PLAN_DID_YOU_SEE_HER_DUCK.md's Origin section). parseRelation just above is
+// UNCHANGED — it is still the greedy, first-verb-position-wins fast path
+// every existing caller keeps using, so every single-reading sentence (the
+// overwhelming majority) is completely unaffected. parseRelationHits and
+// parseAceAmbiguous below are a separate, ADDITIVE scan that a caller opts
+// into only when it wants to know whether more than one reading survives. ----
+
+/** Pattern 3 — EVERY verb-position split, not just the first: for each token
+ *  index that lookupVerb recognizes, resolve both sides and keep it ONLY if
+ *  it is a complete, valid parse (a genuine hit — a missOrNull/null split is
+ *  a dead end, pruned here rather than surfaced as "ambiguity"). Duplicate
+ *  logic with parseRelation is deliberate: parseRelation must stay byte-for-
+ *  byte unchanged for every existing caller, so this is a standalone reader,
+ *  not a refactor of shared internals. */
+function parseRelationHits(lexicon, toks, lower) {
+  const hits = [];
+  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) continue; // dead end
+    hits.push({
+      i,
+      verbLemma: verb.lemma,
+      subject: np1.term,
+      object: np2.term,
+      result: hit(PATTERN_RELATION, [np1, np2], [
+        { subject: np1.term, predicate: predicateOf(verb, lexicon.ns), object: np2.term, kind: "owl:ObjectProperty" },
+      ]),
+    });
+  }
+  return hits;
+}
+
+/** Public ambiguity surface: parse `sentence` and, ONLY when more than one
+ *  independent, COMPLETE relation-pattern reading survives (parseRelationHits
+ *  above), return them all, each labeled by the token it read as the verb.
+ *  Returns null for the overwhelming majority of sentences: anything not
+ *  relation-shaped (mirrors parseAce's own dispatch gate exactly, so this
+ *  only ever fires on a sentence parseAce would ALSO route to parseRelation),
+ *  and any relation-shaped sentence with 0 or 1 surviving readings — the
+ *  ordinary parseAce path is authoritative and untouched either way. */
+export function parseAceAmbiguous(sentence, lexicon = loadLexicon()) {
+  const toks = tokenize(sentence);
+  if (toks.length < 4) return null; // 3 tokens: exactly one verb position is even possible
+  const lower = toks.map((t) => t.toLowerCase());
+  if (lower[0] === "every" || lower[0] === "no") return null;
+  if (/'s$/.test(lower[0]) && lower[0].length > 2) return null;
+  if (lower[0] === "the" && lower.includes("of") && lower.includes("is")) return null;
+  if (lower.indexOf("is") > 0) return null;
+  const hits = parseRelationHits(lexicon, toks, lower);
+  if (hits.length < 2) return null;
+  return {
+    pattern: PATTERN_RELATION,
+    sentence,
+    readings: hits.map(({ i, verbLemma, subject, object, result }) => ({
+      i, verbLemma, subject, object, ...result,
+    })),
+  };
+}
+
 /** 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) {