@polycode-projects/the-mechanical-code-talker 2.8.13 → 2.9.3

package/README.md

@@ -119,16 +119,22 @@ tmct> /exit
 ```
 
 **[Try it live in your browser →](https://polycode-projects.gitlab.io/the-mechanical-code-talker/)**
-is a real, interactive chat demo running client-side. Your browser runs the
-actual query engine, no server, no install. The page opens with a live chat
-you can talk to directly, then embeds the **memory ledger** (every fact as a
-readable sentence, drill by clicking the terms inside them), a Towers-of-Hanoi
-plan replayed move by move, and the two live games above — spider-fly and the
-text adventure — each with a link to open it full-screen.
+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 19,228 facts (the same nine bands as
+`npm run init:xl`, capped to a 22.8 MB download), the **memory ledger**
+(every fact as a readable sentence; drill by clicking the terms inside), a
+Towers-of-Hanoi plan replayed move by move, the spider-and-fly and
+text-adventure games, and a sprite gallery whose chat dock answers from
+1,033 generated sprite facts.
+The site hosts its own copy of wink-nlp, ships its assets precompressed,
+and a service worker precaches the big ones, so a second visit works
+offline. `tmct chat --render spider-fly|adventure|sprites [--output <path>]`
+writes any of the three view pages as one self-contained file.
 
 From a clone, two build scripts regenerate that demo so you can check it
-offline before it deploys. The example graph, the ledger page, and the
-engine copy land in `public/`. The in-page chat's query bundle is rebuilt
+offline before it deploys. The example graph, the chat seed, the pages, and
+the engine copy land in `public/`. The in-page chat's query bundle is rebuilt
 from the same `src/` the CLI runs:
 
 ```bash e2e cwd=repo
@@ -381,8 +387,7 @@ contradict each other it names the contradicting pair and stops rather than
 guessing on. Say `think of a number` to swap seats: tmct commits to a secret
 and answers your guesses honestly, reveals on request, and corrects you from
 its own record if you claim it already said `correct`. The behaviour is
-pinned by `test/corpus/games/guess-number.jsonl`, and the home page's demo
-rail plays the guesser side live in your browser.
+pinned by `test/corpus/games/guess-number.jsonl`.
 
 **A text adventure.** Say `start the adventure` (or `play ashcombe hall`)
 and tmct loads a small country-house mystery from a lazily-fetched worlds
@@ -426,15 +431,25 @@ Facts first, prose second; if neither pack carries the term, the turn is the
 same honest miss it always was, byte for byte. An unknown word, a parse
 failure, or an ambiguous reading never consults a pack at all. The gate and
 both fallbacks are pinned by `test/corpus/reference.jsonl` and the
-chat-lane tests beside it, and the home page demos the article path live.
+chat-lane tests beside it.
+
+Live Wikipedia is the opt-in third tier, off by default. Turn it on with
+`/wiki on` in a session, `--live-wikipedia` on the command line,
+`TMCT_LIVE_WIKIPEDIA=1`, or `tier = "tier3"` under `[corpus]` in `tmct.toml`.
+The browser chat page has the same switch ("ask Wikipedia when I don't
+know"). When it is on and both shipped packs miss, tmct makes two requests
+to en.wikipedia.org (a title search, then the page summary) and answers as a
+cited read-out, CC BY-SA, pinned to the revision it read (provenance
+`reference:wikipedia-live:<Title>@<revid>`). A failed lookup (no matching
+title, a timeout, a rate limit) leaves the honest miss byte-identical.
 
 ## How it remembers
 
 tmct's memory has two layers, both fed by every parsed request and response and
 by cleaned session logs:
 
-- an **always-loaded OWL-labelled JSON graph** on disk under `.tmct/` (local
-  artifact, never committed);
+- an **always-loaded OWL-labelled graph** on disk under `.tmct/`, a SQLite
+  file by default (local artifact, never committed);
 - **text blocks under a PageRank-style index**, pulled into context on
   relevance rather than loaded wholesale.
 
@@ -456,20 +471,19 @@ reasoning).
 
 ### Memory backends
 
-The default memory backend writes an OWL-labelled JSON file under `.tmct/`.
-Two more exist: `memory` keeps taught facts in the process only, nothing
-written to disk; `sqlite` persists them to a local SQLite file instead
-(`.tmct/memory/graph.sqlite`). `tmct init --memory-backend sqlite` writes the
-choice into `tmct.toml` and every later `tmct chat` in that repo picks it up.
-Precedence is `--memory-backend` flag > `TMCT_MEMORY_BACKEND` env >
-tmct.toml's `[memory] backend` > the default. A library caller sets the same
-thing directly: `runChat({ memoryBackend: "sqlite" })`.
+The default backend persists taught facts to a local SQLite file
+(`.tmct/memory/graph.sqlite`). A second backend, `memory`, keeps them in the
+process only and writes nothing to disk. `tmct init --memory-backend <name>`
+writes the choice into `tmct.toml` and every later `tmct chat` in that repo
+picks it up. Precedence is `--memory-backend` flag > `TMCT_MEMORY_BACKEND`
+env > tmct.toml's `[memory] backend` > the sqlite default. A library caller
+sets the same thing directly: `runChat({ memoryBackend: "memory" })`.
 
 Three init presets in `package.json` wrap the common setups. What each one
 runs (`--force` re-initializes the same directory):
 
 ```bash
-npx tmct init --memory-backend sqlite        # npm run init:sqlite
+npx tmct init                                # npm run init:sqlite — sqlite is already the default backend
 npx tmct init --force --with-persona human   # npm run init:persona:human — the default persona, made explicit
 npx tmct init --force --with-persona empty   # npm run init:persona:empty — no seeded vocabulary at all
 ```
@@ -577,16 +591,23 @@ Usage:
                                the final answer (teach state first, trigger last)
        [--render blocks]       with --prompt: when the final turn produced a plan,
                                write it as a self-contained animated page
-       [--output <path>]       the rendered page's path (default plan.html)
+       [--render spider-fly|adventure|sprites]  write that demo view as one self-contained
+                               page (no --prompt; the game pages inline their engine)
+       [--output <path>]       the rendered page's path (default plan.html for
+                               blocks, <archetype>.html for the views)
        [--narrate]             start with narrate mode on — a verbose, developer-facing
                                trace of decision points/matched pattern/results/goal per
                                turn, appended under a "--- narrate ---" marker (also
                                TMCT_NARRATE=1; toggle mid-session with /narrate on|off)
+       [--live-wikipedia]      start with the live Wikipedia supplement on — a question
+                               nothing local can answer also tries en.wikipedia.org,
+                               cited (network; also TMCT_LIVE_WIKIPEDIA=1 or tmct.toml
+                               corpus tier3; toggle mid-session with /wiki on|off)
        [--plain]               force the plain readline shell (the default when
                                stdin/stdout is not a terminal)
        [--memory-backend <default|memory|sqlite>]  storage backend for taught facts this
                                session (CLI flag > TMCT_MEMORY_BACKEND env > tmct.toml's
-                               [memory] backend > "default", the flat .tmct/ JSON file)
+                               [memory] backend > sqlite, .tmct/memory/graph.sqlite)
 ```
 
 `tmct memory` is the CLI-side view of the same data the `/memory` chat command shows:
@@ -742,14 +763,15 @@ TMCT_GRAPH_FILE env > tmct.toml graph_file/graph_files > --repo-derived
 "repo_path" fills the --repo tier when the flag is absent.
 
 Memory-backend precedence (chat; see src/services/chat.mjs createSession): --memory-backend
-flag > TMCT_MEMORY_BACKEND env > tmct.toml [memory] backend > "default" (the flat
-.tmct/ JSON file). Set it once with `tmct init --memory-backend <...>` and every
-later `tmct chat` in that repo picks it up with no flag needed.
+flag > TMCT_MEMORY_BACKEND env > tmct.toml [memory] backend > sqlite (the built-in
+default, .tmct/memory/graph.sqlite); "memory" keeps the store in-process only. Set it
+once with `tmct init --memory-backend <...>` and every later `tmct chat` in that
+repo picks it up with no flag needed.
 ```
 
 `npm run init:large` in `package.json` chains one `init` and five `import --corpus`
 calls to combine every shipped bundle (human persona + seon + conceptnet +
-aws/python/java) into ~7,380 facts on the default flat-JSON backend, a working
+aws/python/java) into ~7,380 facts on the default sqlite backend, a working
 example to copy from. `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

package/bin/tmct.mjs

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env -S node --disable-warning=ExperimentalWarning
 // tmct — The Mechanical Code Talker. The headline entry is CHAT: a bare
 // invocation drops you into a tolerant, offline, $0 prompt that guides you
 // toward precision queries about a repository (ELIZA/PARRY-style, but obsessed
@@ -34,6 +34,18 @@
 // static import here costs `tmct --help` nothing.
 import { renderUsage, unknownInvocationMessage } from "../src/domain/cli-verbs.mjs";
 
+// The default memory backend rides node:sqlite, which Node still ships behind
+// an ExperimentalWarning. The shebang and the package.json scripts both pass
+// --disable-warning=ExperimentalWarning, but a direct `node bin/tmct.mjs`
+// (spawnSync, some CI shells) bypasses both — so replace the default warning
+// printer with one that swallows exactly that warning and re-prints everything
+// else in Node's own format.
+process.removeAllListeners("warning");
+process.on("warning", (warning) => {
+  if (warning?.name === "ExperimentalWarning" && /sqlite/i.test(String(warning?.message || ""))) return;
+  process.stderr.write(`(node:${process.pid}) ${warning?.name || "Warning"}: ${warning?.message || warning}\n`);
+});
+
 const HELP = `tmct — The Mechanical Code Talker
 
 A tolerant, offline, $0 chat that guides you toward precision queries about a
@@ -51,9 +63,10 @@ TMCT_GRAPH_FILE env > tmct.toml graph_file/graph_files > --repo-derived
 "repo_path" fills the --repo tier when the flag is absent.
 
 Memory-backend precedence (chat; see src/services/chat.mjs createSession): --memory-backend
-flag > TMCT_MEMORY_BACKEND env > tmct.toml [memory] backend > "default" (the flat
-.tmct/ JSON file). Set it once with \`tmct init --memory-backend <...>\` and every
-later \`tmct chat\` in that repo picks it up with no flag needed.
+flag > TMCT_MEMORY_BACKEND env > tmct.toml [memory] backend > sqlite (the built-in
+default, .tmct/memory/graph.sqlite); "memory" keeps the store in-process only. Set it
+once with \`tmct init --memory-backend <...>\` and every later \`tmct chat\` in that
+repo picks it up with no flag needed.
 `;
 
 const argv = process.argv.slice(2);
@@ -503,6 +516,86 @@ async function appendGraphFiles(repoRoot, graphPaths) {
   await writeConfig(repoRoot, cfg);
 }
 
+/** Build one game page's browser engine bundle into a throwaway dir and
+ *  return its text for inlining. The bundle builders live in scripts/ and
+ *  need esbuild — a git checkout with dev dependencies, not the npm package —
+ *  so an unbuildable engine is a clear refusal here, never a written page
+ *  that hangs at "loading the engine". */
+async function buildEngineBundleJs(builderFile) {
+  const { mkdtemp, readFile, rm } = await import("node:fs/promises");
+  const { tmpdir } = await import("node:os");
+  const { join } = await import("node:path");
+  let build;
+  try {
+    ({ main: build } = await import(new URL(`../scripts/${builderFile}`, import.meta.url).href));
+  } catch {
+    throw new Error(
+      `this render inlines the page's engine bundle, and its builder (scripts/${builderFile}) `
+      + "isn't available here — run it from a git checkout with dev dependencies installed (npm install)",
+    );
+  }
+  const dir = await mkdtemp(join(tmpdir(), "tmct-render-"));
+  try {
+    const { outPath } = await build(dir);
+    return await readFile(outPath, "utf8");
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+}
+
+/** `--render spider-fly|adventure|sprites [--output <path>]` — write that demo
+ *  view as ONE self-contained file: build-time data read here in Node (the
+ *  same reads scripts/build-demo-site.mjs does for the deployed site), and,
+ *  for the two game pages, the engine bundle built fresh and inlined instead
+ *  of linked as a sibling — so the written file opens from file:// alone. */
+async function writeStandaloneViewPage(archetype, rest) {
+  const { strFlag } = await import("../src/services/cli-args.mjs");
+  const { writeFile } = await import("node:fs/promises");
+  const { resolve: resolvePath } = await import("node:path");
+  const outPath = resolvePath(process.cwd(), strFlag(rest, ["--output", "--out"], `${archetype}.html`));
+  let html;
+  if (archetype === "sprites") {
+    const { readSpriteTemplateFiles } = await import("../src/adapters/corpus/sprite-template-files.mjs");
+    const { readSpriteLargeTemplateFiles } = await import("../src/adapters/corpus/sprite-large-template-files.mjs");
+    const { loadSpriteOntologyFactRows, renderSpriteCatalogHtml } = await import("../src/services/sprite-catalog-viz.mjs");
+    html = renderSpriteCatalogHtml({
+      iconTemplates: readSpriteTemplateFiles(),
+      largeTemplates: readSpriteLargeTemplateFiles(),
+      factRows: await loadSpriteOntologyFactRows(),
+    });
+  } else if (archetype === "spider-fly") {
+    const engineBundleJs = await buildEngineBundleJs("build-spider-fly-bundle.mjs");
+    // The large sprite tier, same as the site build: the only tier the
+    // emotion-carrying spider/fly templates exist in. Missing (e.g. outside
+    // this checkout) reads as [], and every agent falls back to the flat
+    // built-in registry.
+    const { readSpriteLargeTemplateFiles } = await import("../src/adapters/corpus/sprite-large-template-files.mjs");
+    const { renderSpiderFlyHtml } = await import("../src/services/spider-fly-viz.mjs");
+    html = renderSpiderFlyHtml({ spriteTemplates: readSpriteLargeTemplateFiles(), engineBundleJs });
+  } else {
+    const engineBundleJs = await buildEngineBundleJs("build-adventure-bundle.mjs");
+    const { getWorldsPackProvider } = await import("../src/adapters/corpus/worlds-pack.mjs");
+    const world = await getWorldsPackProvider().load("ashcombe-hall");
+    if (!world) {
+      throw new Error("the ashcombe-hall world isn't in the worlds pack (corpus/worlds/) — run `npm run gen:worlds-pack` first");
+    }
+    const { readSpriteTemplateFiles } = await import("../src/adapters/corpus/sprite-template-files.mjs");
+    const { renderAdventureHtml } = await import("../src/services/adventure-viz.mjs");
+    html = renderAdventureHtml({
+      worldPayload: {
+        name: world.name,
+        facts: world.facts.map((f) => ({ subject: f.subject, predicate: f.predicate, object: f.object })),
+        rules: world.rules.map((r) => ({ name: r.name, ruleKind: r.ruleKind, slots: r.slots })),
+        opening: world.meta?.opening || "",
+      },
+      spriteTemplates: readSpriteTemplateFiles(),
+      engineBundleJs,
+    });
+  }
+  await writeFile(outPath, html, "utf8");
+  process.stdout.write(`wrote ${outPath} (${(Buffer.byteLength(html, "utf8") / 1024).toFixed(0)} KB, self-contained)\n`);
+}
+
 async function main() {
   const mode = process.argv[2];
 
@@ -520,6 +613,11 @@ async function main() {
     // session with the verbose developer/debug narrate mode already on. Default
     // OFF; `/narrate on`/`/narrate off` also toggles it mid-session.
     const narrate = rest.includes("--narrate");
+    // `--live-wikipedia` (or TMCT_LIVE_WIKIPEDIA=1 / tmct.toml corpus tier3,
+    // both read inside createSession): start with the live Wikipedia
+    // supplement on. Default OFF; `/wiki on`/`/wiki off` toggles it
+    // mid-session.
+    const liveReference = rest.includes("--live-wikipedia");
     // `--graph <path>` (repeatable) / `--config <path>` (src/services/cli-args.mjs): threaded
     // through as the new top tier of createSession's graph-resolution order (above
     // TMCT_GRAPH_FILE — see chat.mjs's own docblock at createSession). Omitted from
@@ -549,17 +647,23 @@ async function main() {
     // FINAL turn's answer prints to stdout, and the process exits. Piped stdin
     // stays the interactive fallback.
     const prompt = strFlag(rest, ["--prompt"]);
-    // `--render <archetype> [--output <path>]` — after a one-shot --prompt whose
-    // final turn produced a plan, write the self-contained animated plan page
-    // (src/services/plan-viz.mjs). Requires --prompt: interactive chat has no single
-    // final turn to render.
+    // `--render <archetype> [--output <path>]` — write one standalone page.
+    // "blocks" is the animated plan replay (src/services/plan-viz.mjs) and
+    // requires --prompt: interactive chat has no single final turn to render.
+    // The demo views (spider-fly / adventure / sprites) take no prompt — their
+    // data is read at render time, and the two game pages inline a freshly
+    // built engine bundle so the file opens from file:// with no siblings.
     let renderArchetype;
     try {
-      renderArchetype = enumFlag(rest, ["--render"], ["blocks"]);
+      renderArchetype = enumFlag(rest, ["--render"], ["blocks", "spider-fly", "adventure", "sprites"]);
     } catch (e) {
       process.stderr.write(`tmct: ${e?.message || e}\n`);
       process.exit(2);
     }
+    if (renderArchetype && renderArchetype !== "blocks") {
+      await writeStandaloneViewPage(renderArchetype, rest);
+      return;
+    }
     if (renderArchetype && !prompt) {
       process.stderr.write("tmct: --render needs --prompt (a one-shot turn whose plan it renders)\n");
       process.exit(1);
@@ -567,7 +671,7 @@ async function main() {
     if (prompt) {
       const { createSession } = await import("../src/services/chat.mjs");
       const { splitSentences } = await import("../src/services/sentences.mjs");
-      const session = await createSession({ repoPath, ephemeral, narrate, ...extra });
+      const session = await createSession({ repoPath, ephemeral, narrate, liveReference, ...extra });
       let finalAnswer = "";
       let finalPlan = null;
       let parts;
@@ -609,10 +713,10 @@ async function main() {
     const plain = rest.includes("--plain") || !process.stdin.isTTY || !process.stdout.isTTY;
     if (plain) {
       const { runChat } = await import("../src/services/chat.mjs");
-      await runChat({ repoPath, ephemeral, narrate, ...extra });
+      await runChat({ repoPath, ephemeral, narrate, liveReference, ...extra });
     } else {
       const { runTui } = await import("../src/surfaces/tui/app.mjs");
-      await runTui({ repoPath, ephemeral, narrate, ...extra });
+      await runTui({ repoPath, ephemeral, narrate, liveReference, ...extra });
     }
     return;
   }
@@ -626,9 +730,24 @@ async function main() {
     const rest = process.argv.slice(3);
     const verbose = rest.includes("--verbose") || rest.includes("-v");
     const { resolveRuntimeConfig } = await import("../src/services/cli-args.mjs");
-    const { inspectMemory } = await import("../src/adapters/memory/inspect.mjs");
-    const { repo } = await resolveRuntimeConfig({ argv: rest });
-    process.stdout.write(await inspectMemory(repo, { verbose }) + "\n");
+    const { renderMemory } = await import("../src/adapters/memory/inspect.mjs");
+    const { loadMemory, openMemoryBackend } = await import("../src/adapters/memory/core.mjs");
+    const { loadBlockIndex } = await import("../src/adapters/memory/blocks.mjs");
+    const { repo, toml } = await resolveRuntimeConfig({ argv: rest });
+    // Same backend resolution as chat's createSession, minus the (nonexistent
+    // here) CLI-flag tier: env > tmct.toml > the sqlite default — so this verb
+    // inspects the store a chat session in this repo actually writes.
+    const backendChoice = String(process.env.TMCT_MEMORY_BACKEND || toml?.memory?.backend || "").trim().toLowerCase();
+    const { dir: memoryDir, close: closeMemoryStore } = await openMemoryBackend(repo, backendChoice);
+    try {
+      const memory = await loadMemory(memoryDir);
+      // The folded-block index is file-backed beside the session logs, not part
+      // of the memory store — read it off the repo path directly.
+      const blocks = await loadBlockIndex(repo);
+      process.stdout.write(renderMemory({ memory, blocks }, { verbose }) + "\n");
+    } finally {
+      await closeMemoryStore();
+    }
     return;
   }
 
@@ -1023,14 +1142,23 @@ async function main() {
     };
     const { resolveRuntimeConfig } = await import("../src/services/cli-args.mjs");
     const { syllogise, DEFAULT_MAX_ENVIRONMENTS } = await import("../src/domain/syllogise.mjs");
-    const { loadMemory, readFactRows, appendFacts, loadSyllogiseState, saveSyllogiseState } = await import("../src/adapters/memory/core.mjs");
-    const { repo } = await resolveRuntimeConfig({ argv: rest });
-    const res = await syllogise(repo, {
-      depth: numFlag("--depth", 32), budget: numFlag("--budget", 50),
-      maxEnvironments: numFlag("--max-environments", DEFAULT_MAX_ENVIRONMENTS),
-      full: rest.includes("--full"),
-      store: { loadMemory, readFactRows, appendFacts, loadSyllogiseState, saveSyllogiseState },
-    });
+    const { loadMemory, readFactRows, appendFacts, loadSyllogiseState, saveSyllogiseState, openMemoryBackend } = await import("../src/adapters/memory/core.mjs");
+    const { repo, toml } = await resolveRuntimeConfig({ argv: rest });
+    // Same env > tmct.toml > default backend resolution as `tmct memory` — the
+    // entailed 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);
+    let res;
+    try {
+      res = await syllogise(memoryDir, {
+        depth: numFlag("--depth", 32), budget: numFlag("--budget", 50),
+        maxEnvironments: numFlag("--max-environments", DEFAULT_MAX_ENVIRONMENTS),
+        full: rest.includes("--full"),
+        store: { loadMemory, readFactRows, appendFacts, loadSyllogiseState, saveSyllogiseState },
+      });
+    } finally {
+      await closeMemoryStore();
+    }
     process.stdout.write(
       `tmct syllogise — derived ${res.count} entailed fact(s) (mode ${res.mode}${res.mode === "delta" ? `, Δ${res.deltaSize}` : ""}, depth ${res.depth}, budget ${res.budget})`
       + (res.environmentsAdded > 0 ? `, ${res.environmentsAdded} alternate environment(s) recorded` : "")
@@ -1074,12 +1202,22 @@ async function main() {
     const focus = strFlag(rest, ["--focus"]);
     const term = strFlag(rest, ["--term"]); // seeds via normFactTerm; --focus wins when both are given
     const outPath = resolve(process.cwd(), strFlag(rest, ["--output", "--out"], "ledger.html"));
-    const { repo } = await resolveRuntimeConfig({ argv: rest });
-    const data = await computeLedgerData(repo, {
-      ...(focus ? { focus } : {}),
-      ...(!focus && term ? { term } : {}),
-      ...(rowLimit != null ? { rowLimit } : {}),
-    });
+    const { repo, toml } = await resolveRuntimeConfig({ argv: rest });
+    // Same env > tmct.toml > default backend resolution as `tmct memory` — the
+    // ledger must render the store chat actually wrote.
+    const { openMemoryBackend } = await import("../src/adapters/memory/core.mjs");
+    const backendChoice = String(process.env.TMCT_MEMORY_BACKEND || toml?.memory?.backend || "").trim().toLowerCase();
+    const { dir: memoryDir, close: closeMemoryStore } = await openMemoryBackend(repo, backendChoice);
+    let data;
+    try {
+      data = await computeLedgerData(memoryDir, {
+        ...(focus ? { focus } : {}),
+        ...(!focus && term ? { term } : {}),
+        ...(rowLimit != null ? { rowLimit } : {}),
+      });
+    } finally {
+      await closeMemoryStore();
+    }
     // readMemoryAskBundle never throws; an empty string renders the page with
     // an honest "chat unavailable" note instead of the dock (e.g. a fresh
     // checkout before the bundle's first build).
@@ -1198,12 +1336,18 @@ async function main() {
       process.stderr.write("tmct plan: needs a request, e.g. `tmct plan \"of the modules impacted by X, which are untested\"`\n");
       process.exit(2);
     }
-    const { repo, config } = await resolveRuntimeConfig({ argv: rest });
+    const { repo, config, toml } = await resolveRuntimeConfig({ argv: rest });
     const { buildCapabilityPlanCtx, runCapabilityPlan, declaredCapabilityNames } = await import("../src/domain/router/drive.mjs");
     const { capabilityPlanDeps } = await import("../src/services/chat.mjs");
+    // Same env > tmct.toml > default backend resolution as `tmct memory` — the
+    // taught world/rule records the planner registers live in the store chat
+    // wrote them to.
+    const { openMemoryBackend } = await import("../src/adapters/memory/core.mjs");
+    const backendChoice = String(process.env.TMCT_MEMORY_BACKEND || toml?.memory?.backend || "").trim().toLowerCase();
+    const { dir: memoryDir, close: closeMemoryStore } = await openMemoryBackend(repo, backendChoice);
     let ctx;
     try {
-      ctx = await buildCapabilityPlanCtx({ ...capabilityPlanDeps(), config, memoryDir: repo });
+      ctx = await buildCapabilityPlanCtx({ ...capabilityPlanDeps(), config, memoryDir });
     } catch (e) {
       process.stderr.write(`tmct plan: could not load the graph — ${e?.message || e}\n`);
       process.exit(1);
@@ -1256,6 +1400,7 @@ async function main() {
       }
     } finally {
       for (const dispose of ctx.disposers || []) dispose();
+      await closeMemoryStore();
     }
     return;
   }

package/corpus/LICENSES.json

@@ -135,6 +135,13 @@
       "shareAlike": false,
       "notice": "LICENSE"
     },
+    {
+      "path": "corpus/sprites/",
+      "upstream": "first-party (mechanically generated by scripts/gen-sprite-facts.mjs from this repository's own hand-authored sprite templates, data/sprites/ and data/sprites-large/)",
+      "license": "MPL-2.0",
+      "shareAlike": false,
+      "notice": "LICENSE"
+    },
     {
       "path": "corpus/generated/ace-surface-variants.jsonl",
       "upstream": "mechanically generated from Open English WordNet / SemCor example sentences (CC-BY-4.0) and corpus/prose/, which includes CC-BY-SA-4.0 Wikipedia text",