@polycode-projects/the-mechanical-code-talker 6.0.18 → 6.0.20

package/README.md

@@ -424,7 +424,7 @@ tmct> /exit
 **[Try it live in your browser →](https://tmct.polycode.co.uk/)**
 runs the actual query engine client-side. No server, no install. The landing
 page answers codebase questions live, and six more pages each ground their
-own domain: a full chat seeded with 63,470 facts (the same nine bands as
+own domain: a full chat seeded with 70,453 facts (the same eight bands as
 `npm run init:xl`), the
 **memory ledger** (every fact as a readable sentence; drill by clicking the
 terms inside), and a Towers-of-Hanoi **plan** replayed move by move. A 3D
@@ -580,7 +580,7 @@ question against the same entity always renders the same way.
 ```session cwd=repo
 $ node bin/tmct.mjs chat --repo examples/mini-webapp --ephemeral
 tmct> give me a detailed overview of how the Store works
-Attribute: prose_tokens = memory record store [mgx:hasProseTokens]. Attribute: doc = In-memory record store. [seon:hasDoc]. Other matches: src/core/store.mjs (Module), loadStore (Function), saveStore (Function), testLoadStore (Function).
+Attribute: prose_tokens = memory record store [mgx:hasProseTokens]. Attribute: doc = In-memory record store. [seon:hasDoc]. Store — Class (id: fn:src/core/store.mjs#Store).
 ```
 
 Programmatically, the same pipeline is `generateCompletion()`
@@ -1065,15 +1065,13 @@ provenance record. Most of its flags choose what gets seeded and where config is
   tmct init [--repo <abs>]     initialize a repo for tmct (default: cwd): .tmct/,
        [--force]               tmct.toml, .tmct/TOOLS.md (the cold-tool catalog),
                                tier-1 corpus seed, provenance record
-       [--corpus <id|path>]    also seed a corpus — a tier-2 manifest id (aws|python|java|
-                               general) or a jsonl file path — opt-in, offline, $0
+       [--corpus <id|path>]    also seed a corpus — a bundle name (code|conceptnet|child|
+                               namenet|general) or a jsonl file path — opt-in, offline, $0
        [--ontology <name|path>]  activate+seed an ontology bundle (a recognized name or a path)
        [--lexicon <name|path>]  activate a lexicon bundle (recognized name or a path;
                                merged read-time, never seeded — see mergedLexiconExtra)
        [--graph <path>]        set graph_file/graph_files in tmct.toml (repeatable)
        [--config <path>]       write to an alternate tmct.toml location
-       [--detect]              suggest a tier-2 corpus from the repo's manifests
-                               (pyproject.toml → python, pom.xml → java); never seeds unasked
        [--with-persona <name>]  write an explicit [extensions]/[bias] preset into tmct.toml
                                ("code" — today's implicit default, made explicit)
        [--persona-size <medium|large>]  grow the default "human" persona's fact count
@@ -1225,8 +1223,8 @@ row-backend table, or clears one; the deployed turn service reads the loaded
 bands per query:
 
 ```output:help:corpus
-  tmct corpus load <band> [--table <name>] [--source <path>] [--dry-run]  load a shared, read-only corpus band (wikidata-slice, wordnet-complete,
-       [--table <name>]        conceptnet-full) into a DynamoDB row-backend table from a jsonl of
+  tmct corpus load <band> [--table <name>] [--source <path>] [--dry-run]  load a shared, read-only corpus band (wordnet-complete, or a
+       [--table <name>]        consumer's own) into a DynamoDB row-backend table from a jsonl of
                                wire-row-shaped facts (default table from TMCT_DYNAMO_TABLE); a
                                source whose digest already matches the band's manifest is a no-op
        [--source <path>]       the band's jsonl (a scripts/corpus-bands/ build output, or any jsonl
@@ -1259,28 +1257,27 @@ once with `tmct init --memory-backend <...>` and every later `tmct chat` in that
 repo picks it up with no flag needed.
 ```
 
-`npm run init` in `package.json` chains one `init` and five `import --corpus`
-calls to combine every shipped bundle (human persona + seon + conceptnet +
-aws/python/java) into ~37,800 facts on the default sqlite backend, a working
+`npm run init` in `package.json` chains one `init` and two `import --corpus`
+calls to combine the human persona, the code domain pack and conceptnet
+into ~37,700 facts on the default sqlite backend, a working
 example to copy from (`init:large` is now just an alias for it). `npm run
 init:small` is the lighter variant: a bare `tmct init`, default persona only,
 no big corpora, 688 facts. It's what a first `npm run chat` in an
 uninitialized repo bootstraps automatically, so no init command is required
 just to start talking; running `init:small` explicitly (after `rm -rf
 tmct.toml .tmct`) gets you back to that same minimal state on purpose.
-`init:xl` starts from the large persona tier and adds the wordnet-xl corpus
-(~72,000 facts); `init:xxl` swaps wordnet-xl for the full WordNet slice plus
-namenet (~239,000 facts, the biggest committed vocabulary, so expect its
-imports to take a minute). The xl chain, spelled out:
+`init:xl` starts from the large persona tier and adds wordnet-xl, namenet and
+the child vocabulary pack (~127,000 facts); `init:xxl` swaps wordnet-xl for the
+full WordNet slice (~296,000 facts, the biggest committed vocabulary, so expect
+its imports to take a few minutes). The xl chain, spelled out:
 
 ```bash e2e heavy
 npx tmct init --persona-size large   # npm run init:xl runs this whole chain from a clone
-npx tmct import --corpus seon
+npx tmct import --corpus code
 npx tmct import --corpus conceptnet
-npx tmct import --corpus aws
-npx tmct import --corpus python
-npx tmct import --corpus java
-npx tmct import --corpus wordnet-xl  # init:xxl instead ends with wordnet-full and namenet
+npx tmct import --corpus wordnet-xl  # init:xxl uses wordnet-full here instead
+npx tmct import --corpus namenet
+npx tmct import --corpus child
 ```
 
 ### tmct.toml reference
@@ -1321,8 +1318,8 @@ capture_unknown_context = true   # keep the sentence around an unrecognized term
 unknown_context_limit = 200      # cap how many of those contexts are kept
 
 # One [extensions.<name>] table per bundle. A recognized name (human, seon,
-# conceptnet, human-medium, human-large, tier2-aws, tier2-python, tier2-java,
-# tier2-general, wordnet-xl, wordnet-full, namenet) overrides that bundle's
+# code, conceptnet, human-medium, human-large, tier2-general, wordnet-xl,
+# wordnet-full, namenet, child) overrides that bundle's
 # shipped defaults. Any other name declares a new bundle and must set `kind`.
 [extensions.human]
 active = true
@@ -1333,7 +1330,7 @@ active = true
 [extensions.conceptnet]
 active = true
 
-[extensions.tier2-aws]
+[extensions.tier2-general]
 active = true
 
 [extensions.my-custom-pack]

package/bin/tmct.mjs

@@ -407,7 +407,7 @@ async function repoRelative(repoRoot, p) {
 /** Resolve a `--corpus`/`--ontology`/`--lexicon` value to something
  *  activatePluggableInput can act on: either a RECOGNIZED name (a
  *  BUILTIN_EXTENSIONS entry of the matching kind; for `--corpus` specifically,
- *  also a tier-2 manifest id like "aws" — today's `--corpus <id>` contract,
+ *  also a tier-2 manifest id like "general" — today's `--corpus <id>` contract,
  *  preserved byte-for-byte) or a filesystem PATH, to be declared as a brand
  *  new `[extensions.<slug>]` entry. Throws the same clear "unknown --corpus"
  *  error the original tier-2-only implementation gave (naming the available
@@ -415,8 +415,13 @@ async function repoRelative(repoRoot, p) {
  *  disk write — callers resolve every pluggable input BEFORE calling
  *  initRepo, so a bad name/path touches nothing. */
 async function resolvePluggableInput(kind, nameOrPath, { repoRoot }) {
-  const { BUILTIN_EXTENSIONS } = await import("../src/services/extensions.mjs");
-  if (Object.prototype.hasOwnProperty.call(BUILTIN_EXTENSIONS, nameOrPath) && BUILTIN_EXTENSIONS[nameOrPath].kind === kind) {
+  const { BUILTIN_EXTENSIONS, isSeedableEntry } = await import("../src/services/extensions.mjs");
+  const builtin = Object.prototype.hasOwnProperty.call(BUILTIN_EXTENSIONS, nameOrPath)
+    ? BUILTIN_EXTENSIONS[nameOrPath]
+    : null;
+  // A domain pack carries a corpus alongside its vocabulary, so `--corpus <pack>`
+  // is the same ask as `--corpus <corpus>` and answers to the same flag.
+  if (builtin && (builtin.kind === kind || (kind === "corpus" && builtin.kind === "pack" && isSeedableEntry(builtin)))) {
     return { known: true, name: nameOrPath };
   }
   let manifestIds = null;
@@ -469,11 +474,10 @@ async function activatePluggableInput(repoRoot, resolved) {
   cfg.extensions = { ...(cfg.extensions || {}), [name]: newEntry };
   await writeConfig(repoRoot, cfg);
 
-  const { resolveExtensions, seedActiveCorpusEntries } = await import("../src/services/extensions.mjs");
+  const { resolveExtensions, seedActiveCorpusEntries, isSeedableEntry } = await import("../src/services/extensions.mjs");
   const { entries } = await resolveExtensions(repoRoot);
   const entry = entries.get(name);
-  const seedable = entry.kind === "corpus" || entry.kind === "ontology" || (entry.kind === "pack" && entry.corpusPath);
-  if (!seedable) {
+  if (!isSeedableEntry(entry)) {
     return `activated "${name}" (${entry.kind}) in tmct.toml — no corpus facts to seed for this kind.\n`;
   }
   // Backend-aware seeding (same split-brain bug fix as src/services/init.mjs's own
@@ -867,11 +871,8 @@ async function main() {
     // record provenance. Idempotent; --force rewrites config + re-records.
     //
     // TIERING POLICY: init is OFFLINE, $0 and TIER-1-ONLY by default (seon +
-    // conceptnet — src/services/extensions.mjs's BUILTIN_EXTENSIONS). A tier-2 domain/
-    // language corpus (corpus/tier2/: aws, python, java) is added ONLY when
-    // explicitly asked via `--corpus <id>`. The `--detect` auto-detect is a
-    // documented STUB: it inspects the repo's manifests (pyproject.toml → python,
-    // pom.xml → java) and SUGGESTS the matching corpus, but never seeds it unasked.
+    // conceptnet — src/services/extensions.mjs's BUILTIN_EXTENSIONS). A tier-2 domain
+    // corpus (corpus/tier2/) is added ONLY when explicitly asked via `--corpus <id>`.
     //
     // `--repo <abs>` (NEW): init used to always hardcode process.cwd() — the only
     // subcommand without a --repo flag. It now takes one like every other
@@ -1116,24 +1117,6 @@ async function main() {
 
     if (anyActivation) return;
 
-    if (rest.includes("--detect")) {
-      // AUTO-DETECT STUB (documented, non-seeding): map a build manifest to the
-      // tier-2 corpus that fits, and tell the operator how to add it. Kept a stub on
-      // purpose — the $0/offline default never expands the corpus without an ask.
-      const { access } = await import("node:fs/promises");
-      const has = (f) => access(resolvePath(repoRoot, f)).then(() => true, () => false);
-      const DETECT = [["pyproject.toml", "python"], ["pom.xml", "java"]];
-      const found = [];
-      for (const [file, id] of DETECT) if (await has(file)) found.push([file, id]);
-      if (!found.length) {
-        process.stdout.write("no tier-2 corpus auto-detected (looked for pyproject.toml → python, pom.xml → java).\n");
-      } else {
-        for (const [file, id] of found) {
-          process.stdout.write(`detected ${file} — run \`tmct init --corpus ${id}\` to add the ${id} tier-2 corpus (offline, $0).\n`);
-        }
-      }
-      return;
-    }
     return;
   }
 
@@ -1238,9 +1221,9 @@ async function main() {
     // `--memory-backend` is written FIRST, before any --corpus/--ontology/
     // --lexicon activation below — the same split-brain bug fix as `tmct
     // init`'s ordering: activatePluggableInput seeds into whichever backend
-    // tmct.toml names AT THE TIME it runs, so `tmct import --corpus aws
+    // tmct.toml names AT THE TIME it runs, so `tmct import --corpus general
     // --memory-backend sqlite` in one call must have the new backend on disk
-    // BEFORE the aws seed step, not after.
+    // BEFORE the seed step, not after.
     if (memoryBackendVal) {
       const { cfg } = await readConfigForRewrite(repoRoot);
       cfg.memory = { ...(cfg.memory || {}), backend: memoryBackendVal };
@@ -1440,7 +1423,7 @@ async function main() {
     const rest = process.argv.slice(3);
     const { resolveRuntimeConfig, strFlag } = await import("../src/services/cli-args.mjs");
     const { newsTurn, resolveNewsConfig, createNewsState } = await import("../src/services/news.mjs");
-    const { loadMemory, readFactRows, appendFacts, openMemoryBackend } = await import("../src/adapters/memory/core.mjs");
+    const { loadMemory, readFactRows, appendFacts, removeFacts, openMemoryBackend } = await import("../src/adapters/memory/core.mjs");
     // The same fetcher factory news.html's own session builds from
     // (src/surfaces/web/news-browser-entry.mjs) — real sources over Node's
     // own global fetch, each behind createNewsFetcher's courtesy gate so a
@@ -1453,7 +1436,7 @@ async function main() {
     // news facts must land in the store chat reads back.
     const backendChoice = String(process.env.TMCT_MEMORY_BACKEND || toml?.memory?.backend || "").trim().toLowerCase();
     const { dir: memoryDir, close: closeMemoryStore } = await openMemoryBackend(repo, backendChoice);
-    const store = { loadMemory, readFactRows, appendFacts };
+    const store = { loadMemory, readFactRows, appendFacts, removeFacts };
     const memory = await loadMemory(memoryDir);
     const rows = readFactRows(memory);
     // resolveNewsConfig unwraps `toml?.news` itself (the tmct.toml [news]

package/corpus/LICENSES.json

@@ -30,27 +30,6 @@
       "shareAlike": false,
       "notice": "corpus/namenet/LICENSE-NOTICE"
     },
-    {
-      "path": "corpus/tier2/aws.jsonl",
-      "upstream": "first-party (curated in corpus/tier2/generate.mjs)",
-      "license": "MPL-2.0",
-      "shareAlike": false,
-      "notice": "corpus/tier2/manifest.json"
-    },
-    {
-      "path": "corpus/tier2/python.jsonl",
-      "upstream": "first-party (curated in corpus/tier2/generate.mjs)",
-      "license": "MPL-2.0",
-      "shareAlike": false,
-      "notice": "corpus/tier2/manifest.json"
-    },
-    {
-      "path": "corpus/tier2/java.jsonl",
-      "upstream": "first-party (curated in corpus/tier2/generate.mjs)",
-      "license": "MPL-2.0",
-      "shareAlike": false,
-      "notice": "corpus/tier2/manifest.json"
-    },
     {
       "path": "corpus/tier2/general.jsonl",
       "upstream": "first-party (curated in corpus/tier2/generate.mjs)",

package/corpus/README.md

@@ -13,7 +13,7 @@ tmct's knowledge arrives in three tiers, distinguished by **when** it lands and
 | Tier | What | Ships in the package? | Lands when | Provenance |
 |---|---|---|---|---|
 | **1 — base** | the general English/tech ConceptNet slice + the response templates + the SE phrasebook — the vocabulary every tmct has out of the box | **yes**, committed here | `tmct init` seeds `.tmct/` from committed data (offline, $0) | `corpus:conceptnet /r/…` |
-| **2 — specialised** | LANGUAGE- or DOMAIN-specific fact sets (`aws`, `python`, `java`) plus one deliberately NON-code-domain "wider general-knowledge" bundle (`general`) so tmct can "expand into a concept for an applicable codebase" — or into a seed set that isn't code at all | **no** — selected per repo | activated via `src/services/extensions.mjs`'s `[extensions.tier2-<id>] active = true` (or `tmct init --corpus <id>`), inactive by default | `corpus:tier2-<id> /r/…` |
+| **2 — specialised** | DOMAIN-specific fact sets — today the deliberately NON-code-domain "wider general-knowledge" bundle (`general`) plus the `human` persona tiers — so tmct can "expand into a concept for an applicable codebase", or into a seed set that isn't code at all | **no** — selected per repo | activated via `src/services/extensions.mjs`'s `[extensions.tier2-<id>] active = true` (or `tmct init --corpus <id>`), inactive by default | `corpus:tier2-<id> /r/…` |
 | **3 — learned** | facts tmct writes from the actual conversation / the actual codebase it is pointed at | never committed | at runtime, into `.tmct/memory/` | `chat:…`, `codegraph:…` |
 
 **Offline / $0 is the default at every tier.** Tier-1 is committed. Tier-2's
@@ -42,7 +42,7 @@ notice}), guarded by `test/estate/corpus-licences.test.mjs`.
 | `conceptnet/README.md` | provenance, retrieval date, seed terms, filter rules, row counts | — | — |
 | `tier2/manifest.json` | tier-2: index of specialised corpuses (id, kind, description, source, sha256, size) | — | MPL-2.0 |
 | `tier2/generate.mjs` | tier-2: the curated-corpus generator + manifest writer (+ opt-in network-fetch path) | — | MPL-2.0 |
-| `tier2/{aws,python,java,general}.jsonl` | tier-2 SAMPLE corpuses — same fact shape as the tier-1 slice, loadable via the same path (`general` is the one deliberately non-code-domain bundle) | ~4-6 KB each | MPL-2.0 |
+| `tier2/general.jsonl` | a tier-2 SAMPLE corpus — same fact shape as the tier-1 slice, loadable via the same path, and deliberately non-code-domain | ~6 KB | MPL-2.0 |
 | `tier2/human.jsonl` | the DEFAULT active bundle: the everyday "human-world" persona, Small tier (664 facts) — hand-curated from Open English WordNet, bridged to Schema.org's top-level classes | ~80 KB | MPL-2.0 (hand-authored fact set; not a verbatim WordNet/Schema.org excerpt — see `tier2/generate.mjs`'s own header comment) |
 | `tier2/human-medium.jsonl` / `tier2/human-large.jsonl` | SIZE tiers of the SAME `human` bundle — each holds ONLY the facts that size adds beyond the previous one; both shipped INACTIVE by default, activated via `tmct init --persona-size medium\|large`. Built by `scripts/build-persona-tiers.mjs` from the same WordNet source, automatically curated (sense-ranked, blocklist/denylist-filtered) rather than hand-typed one at a time, given the scale (944 / ~12,000 facts) | ~111 KB / ~1.4 MB | MPL-2.0 (same "hand-authored in homage to the source's shape" basis as `human.jsonl`) |
 | `prose/sqlite/*.txt` | the frozen prose corpus, code half: plain-text extractions of 12 SQLite documentation pages | ~375 KB | **public domain** (see `prose/sqlite/LICENSE-NOTICE`) |
@@ -136,11 +136,9 @@ loads and seeds through the very same `loadSlice()`/`toFacts()` path as the
 tier-1 slice — `tier2/generate.mjs --verify` proves it (each sample loads and
 all its facts seed cleanly, no `ace=none` dead rows).
 
-The idea: a Python repo pulls the `python` corpus so tmct knows "a dict is a
-kind of hash table"; an AWS project pulls `aws` so it knows "S3 is object
-storage, a bucket is part of S3". Language terms unify onto the **shared CS
-concept vocabulary** (`list → array`, `hashmap → hash table`) so specialised
-knowledge connects to the tier-1 graph instead of floating apart.
+The idea: a repo pulls the bundle that matches what it is about, and that
+bundle's terms unify onto the **shared concept vocabulary** already in the
+tier-1 graph, so specialised knowledge connects instead of floating apart.
 
 **To add a corpus:** add an entry to `CORPUSES` in `tier2/generate.mjs` (a list
 of `[subject, relation, concept]` triples) and run `node tier2/generate.mjs
@@ -150,9 +148,9 @@ stays reviewable; a corpus too big to hand-curate is a `fetch` manifest entry
 (URL + sha256, opt-in network — `fetchCorpus()` is the reference downloader).
 
 **How tier-2 wires into `tmct init` (done — `src/services/extensions.mjs`):**
-`resolveExtensions(repoRoot)` ships all four tier-2 bundles as
-shipped-but-inactive `BUILTIN_EXTENSIONS` entries (`tier2-aws`/`tier2-python`/
-`tier2-java`/`tier2-general`); `[extensions.tier2-<id>] active = true` in
+`resolveExtensions(repoRoot)` ships every tier-2 bundle as a
+shipped-but-inactive `BUILTIN_EXTENSIONS` entry (`tier2-general`);
+`[extensions.tier2-<id>] active = true` in
 `tmct.toml` (or `tmct init --corpus <id>`) flips one on, and
 `seedActiveCorpusEntries` runs it through the exact same
 `loadSlice → toFacts → appendFacts` pipeline as tier-1, stamped
@@ -160,9 +158,8 @@ shipped-but-inactive `BUILTIN_EXTENSIONS` entries (`tier2-aws`/`tier2-python`/
 separate tier-2 code path. Idempotency is free (`seedMemory`'s content-hashed
 fact ids + pre-read skip). None of this touches `package.json` or the tier-1
 budget; tier-2 files are not shipped, so they do not count against the
-≤ 1.5 MB slice budget. Codebase auto-detection (a `requirements.txt` →
-`python`, a `pom.xml`/`build.gradle` → `java`, an AWS SDK dep → `aws`) is
-still unbuilt — activation today is config-only, never automatic.
+≤ 1.5 MB slice budget. Activation today is config-only: nothing reads a repo's
+own build manifests to pick a bundle for you.
 
 A term that would otherwise be silently dropped when a bundle is seeded (an
 `ace = "none"` relation like RelatedTo/HasContext, e.g. from a broader slice)

package/corpus/reference/manifest.json

@@ -19,7 +19,7 @@
       "max": 10485760
     },
     "shardsGzBytes": {
-      "used": 1224167,
+      "used": 1224158,
       "max": 3670016
     },
     "indexGzBytes": {
@@ -50,8 +50,8 @@
     },
     {
       "file": "shards/ref-01.jsonl.gz",
-      "bytes": 15202,
-      "sha256": "6615f30ae974f043c1ac4f52c9e12c358005272981c492295247bdb387f7941b"
+      "bytes": 15193,
+      "sha256": "86a07d6f3f9b5ab79ab206e157485d39bb25a996cf3d28d7ca014a45c4686eb8"
     },
     {
       "file": "shards/ref-02.jsonl.gz",
@@ -65,8 +65,8 @@
     },
     {
       "file": "shards/ref-04.jsonl.gz",
-      "bytes": 21046,
-      "sha256": "cb09cb6a691c1f14719104867502bb72db43852bdf7165b722fe546690ec9c16"
+      "bytes": 21042,
+      "sha256": "f8269b02dcbac4d2471043f7e2adc85394ffe61238202f19e54d47a7271943c4"
     },
     {
       "file": "shards/ref-05.jsonl.gz",
@@ -85,8 +85,8 @@
     },
     {
       "file": "shards/ref-08.jsonl.gz",
-      "bytes": 21630,
-      "sha256": "f013af59a737e87d1406ca5c19dc09012989fe3ce7d9c97adf6fb7d50ff63369"
+      "bytes": 21627,
+      "sha256": "21c9cab16fb50ae1183eb25ca9faf2e964b15c7c2220942c25a1567d5cad5428"
     },
     {
       "file": "shards/ref-09.jsonl.gz",
@@ -125,13 +125,13 @@
     },
     {
       "file": "shards/ref-10.jsonl.gz",
-      "bytes": 17990,
-      "sha256": "c980e844bc71638111fa3e8ae3c7ca5ebafdfcef74e86e252e1c6858c2778acc"
+      "bytes": 17987,
+      "sha256": "5a79227e9950e428a046fe580d07fb8529b19c5416fa756b754852f2edbca905"
     },
     {
       "file": "shards/ref-11.jsonl.gz",
-      "bytes": 17595,
-      "sha256": "e23ed0bd8fd1f939158705c2624869ef06b89ae5006e1364a7749ad7de1c2cc7"
+      "bytes": 17596,
+      "sha256": "628fb8699283c3e16703875f58a3bc7d06238477dd6974a2d76da91ad941a6d5"
     },
     {
       "file": "shards/ref-12.jsonl.gz",
@@ -160,8 +160,8 @@
     },
     {
       "file": "shards/ref-17.jsonl.gz",
-      "bytes": 19992,
-      "sha256": "ee32aaee2b3fa93085de06ef5fb613a43916de4eaa1efed24bb1e75788a2cbfb"
+      "bytes": 19993,
+      "sha256": "801799dd9b205e41658fc6074cf9021cab90c2c30e1fc00d0d9bca0d4cd07d76"
     },
     {
       "file": "shards/ref-18.jsonl.gz",
@@ -205,8 +205,8 @@
     },
     {
       "file": "shards/ref-20.jsonl.gz",
-      "bytes": 22867,
-      "sha256": "2d131116890dac85725dae54caf7cab62324881a637e354986bbe1bfba4c0ea7"
+      "bytes": 22871,
+      "sha256": "4f049ef6fb8488fc69eab9cfe826f8dc81cee4293c2f7b96d199752dbb7149ae"
     },
     {
       "file": "shards/ref-21.jsonl.gz",
@@ -230,8 +230,8 @@
     },
     {
       "file": "shards/ref-25.jsonl.gz",
-      "bytes": 20332,
-      "sha256": "3656dd63f53fcd502ab385f654488cf291bdb3464f90ca4322799dd569e65e35"
+      "bytes": 20328,
+      "sha256": "b7ccf2a15d8e9d3f274d35ec7f99d4eb543ed1484aa860c90ca14edaa56e6b4e"
     },
     {
       "file": "shards/ref-26.jsonl.gz",
@@ -265,8 +265,8 @@
     },
     {
       "file": "shards/ref-2c.jsonl.gz",
-      "bytes": 18088,
-      "sha256": "28326bc161c881c05bbed6aafaf3c227a3f0abbbc5f873aa62ea11d484b90c19"
+      "bytes": 18096,
+      "sha256": "0575e2fd83478d64e88f9691f0fbb57a9d913a9d64ace4b1f7f4689300ddbb98"
     },
     {
       "file": "shards/ref-2d.jsonl.gz",

package/corpus/tier2/generate.mjs

@@ -2,8 +2,8 @@
 // corpus/tier2/generate.mjs — the TIER-2 specialised-corpus generator + manifest
 // writer. NOT part of the product path — a maintainer tool. Offline, $0.
 //
-// Tier-2 corpuses are LANGUAGE- or DOMAIN-specific fact sets (aws, python,
-// java, …) that tmct fetches/generates into `.tmct/` at init time so it can
+// Tier-2 corpuses are DOMAIN-specific fact sets (general, human, …) that tmct
+// fetches/generates into `.tmct/` at init time so it can
 // "expand into a concept for an applicable codebase". They are NOT shipped in
 // the npm package the way the tier-1 ConceptNet slice is — they are opt-in,
 // selected per repo. See ../README.md for the full tier-1/2/3 policy.
@@ -39,143 +39,7 @@ const HERE = dirname(fileURLToPath(import.meta.url));
 // turns "/c/en/hash_table" into "hash table". Keep terms <= 3 words (the tier-1
 // quality-filter rule) — curated data is clean by construction.
 export const CORPUSES = {
-  aws: {
-    kind: "domain",
-    description: "Amazon Web Services core services and primitives (S3, Lambda, DynamoDB, EC2, IAM, SQS) mapped to general cloud/CS concepts.",
-    facts: [
-      ["aws", "/r/IsA", "cloud_platform"],
-      ["aws", "/r/IsA", "cloud"],
-      ["aws", "/r/CapableOf", "host_applications"],
-      // S3
-      ["s3", "/r/IsA", "object_storage"],
-      ["s3", "/r/IsA", "storage_service"],
-      ["s3", "/r/PartOf", "aws"],
-      ["s3", "/r/HasA", "bucket"],
-      ["s3", "/r/UsedFor", "storing_files"],
-      ["s3", "/r/CapableOf", "store_objects"],
-      ["bucket", "/r/IsA", "container"],
-      ["bucket", "/r/PartOf", "s3"],
-      ["bucket", "/r/UsedFor", "storing_objects"],
-      // Lambda
-      ["lambda", "/r/IsA", "compute_service"],
-      ["lambda", "/r/IsA", "function"],
-      ["lambda", "/r/PartOf", "aws"],
-      ["lambda", "/r/UsedFor", "running_code"],
-      ["lambda", "/r/CapableOf", "run_code"],
-      ["lambda", "/r/HasProperty", "serverless"],
-      // DynamoDB
-      ["dynamodb", "/r/IsA", "database"],
-      ["dynamodb", "/r/IsA", "nosql_database"],
-      ["dynamodb", "/r/PartOf", "aws"],
-      ["dynamodb", "/r/HasA", "table"],
-      ["dynamodb", "/r/UsedFor", "storing_data"],
-      ["dynamodb", "/r/HasProperty", "managed"],
-      // EC2
-      ["ec2", "/r/IsA", "compute_service"],
-      ["ec2", "/r/IsA", "virtual_machine"],
-      ["ec2", "/r/PartOf", "aws"],
-      ["ec2", "/r/HasA", "instance"],
-      ["ec2", "/r/UsedFor", "running_servers"],
-      // IAM
-      ["iam", "/r/IsA", "access_control"],
-      ["iam", "/r/PartOf", "aws"],
-      ["iam", "/r/UsedFor", "managing_permissions"],
-      ["iam", "/r/HasA", "role"],
-      ["iam", "/r/HasA", "policy"],
-      // SQS + queue
-      ["sqs", "/r/IsA", "message_queue"],
-      ["sqs", "/r/IsA", "queue"],
-      ["sqs", "/r/PartOf", "aws"],
-      ["sqs", "/r/UsedFor", "decoupling_services"],
-      ["queue", "/r/IsA", "data_structure"],
-    ],
-  },
-
-  python: {
-    kind: "language",
-    description: "Python language constructs and stdlib types mapped to the shared CS concept vocabulary (list->array, dict->hash table, …).",
-    facts: [
-      ["python", "/r/IsA", "programming_language"],
-      ["python", "/r/HasProperty", "interpreted"],
-      ["python", "/r/HasProperty", "dynamically_typed"],
-      ["python", "/r/UsedFor", "scripting"],
-      // built-in types → shared concepts
-      ["list", "/r/IsA", "array"],
-      ["list", "/r/IsA", "sequence"],
-      ["list", "/r/IsA", "data_structure"],
-      ["dict", "/r/IsA", "hash_table"],
-      ["dict", "/r/IsA", "dictionary"],
-      ["dict", "/r/IsA", "mapping"],
-      ["tuple", "/r/IsA", "sequence"],
-      ["tuple", "/r/HasProperty", "immutable"],
-      ["set", "/r/IsA", "collection"],
-      ["set", "/r/HasProperty", "unordered"],
-      ["str", "/r/IsA", "string"],
-      // language constructs
-      ["decorator", "/r/IsA", "function"],
-      ["decorator", "/r/UsedFor", "modifying_functions"],
-      ["generator", "/r/IsA", "iterator"],
-      ["generator", "/r/UsedFor", "lazy_evaluation"],
-      ["comprehension", "/r/IsA", "expression"],
-      ["comprehension", "/r/UsedFor", "building_collections"],
-      ["exception", "/r/IsA", "error"],
-      ["module", "/r/IsA", "file"],
-      ["package", "/r/IsA", "module"],
-      ["method", "/r/IsA", "function"],
-      // tooling / runtime
-      ["pip", "/r/IsA", "package_manager"],
-      ["pip", "/r/UsedFor", "installing_packages"],
-      ["gil", "/r/IsA", "lock"],
-      ["gil", "/r/PartOf", "interpreter"],
-      ["cpython", "/r/IsA", "interpreter"],
-    ],
-  },
-
-  java: {
-    kind: "language",
-    description: "Java language and JVM constructs mapped to the shared CS concept vocabulary (ArrayList->list, HashMap->hash table, …).",
-    facts: [
-      ["java", "/r/IsA", "programming_language"],
-      ["java", "/r/HasProperty", "compiled"],
-      ["java", "/r/HasProperty", "statically_typed"],
-      ["java", "/r/UsedFor", "building_applications"],
-      // types → shared concepts
-      ["arraylist", "/r/IsA", "list"],
-      ["arraylist", "/r/IsA", "data_structure"],
-      ["hashmap", "/r/IsA", "hash_table"],
-      ["hashmap", "/r/IsA", "dictionary"],
-      ["hashmap", "/r/IsA", "map"],
-      ["interface", "/r/IsA", "type"],
-      ["interface", "/r/IsA", "contract"],
-      ["class", "/r/IsA", "type"],
-      ["object", "/r/IsA", "instance"],
-      // JVM / runtime
-      ["jvm", "/r/IsA", "virtual_machine"],
-      ["jvm", "/r/UsedFor", "running_bytecode"],
-      ["jvm", "/r/CapableOf", "execute_bytecode"],
-      ["bytecode", "/r/IsA", "code"],
-      ["garbage_collector", "/r/PartOf", "jvm"],
-      ["garbage_collector", "/r/UsedFor", "freeing_memory"],
-      // packaging / tooling
-      ["jar", "/r/IsA", "archive"],
-      ["jar", "/r/IsA", "file"],
-      ["jar", "/r/UsedFor", "packaging_classes"],
-      ["maven", "/r/IsA", "build_tool"],
-      ["maven", "/r/IsA", "package_manager"],
-      ["gradle", "/r/IsA", "build_tool"],
-      // language features
-      ["thread", "/r/IsA", "process"],
-      ["thread", "/r/UsedFor", "concurrency"],
-      ["generics", "/r/UsedFor", "type_safety"],
-      ["annotation", "/r/IsA", "metadata"],
-      ["exception", "/r/IsA", "error"],
-      ["method", "/r/IsA", "function"],
-    ],
-  },
-
-  // The wider general-knowledge seed set: the
-  // three corpuses above are all code-domain-specific (a LANGUAGE or a cloud
-  // DOMAIN); this one deliberately is NOT — everyday-knowledge concepts (the
+  // The wider general-knowledge seed set: everyday-knowledge concepts (the
   // natural world, weather, food, common objects) with zero code-domain
   // framing, proving the extension-pack seam generalizes to a seed set that
   // isn't code at all (the operator's own framing: tmct's code specialization
@@ -14911,9 +14775,9 @@ export async function fetchCorpus(url, expectedSha) {
  * object (e.g. "treating_illness", "growing_into_a_plant") to also become a
  * parseable ACE noun, contradicting the "breadth over depth, no
  * over-modeling" discipline this whole batch was built under, and breaking
- * with EVERY other tier2 corpus's own long-standing precedent (aws.jsonl's
- * "object_storage"/"cloud_platform" concept objects were never lexicon
- * nouns either, and no such stricter check exists for them). The `lexicon`
+ * with EVERY other tier2 corpus's own long-standing precedent (general.jsonl's
+ * concept objects were never lexicon nouns either, and no such stricter check
+ * exists for them). The `lexicon`
  * sub-key's OWN declared words (the genuinely teachable/askable common
  * words this corpus's curation deliberately picked out) are what this
  * check verifies both ends of. */