@polycode-projects/the-mechanical-code-talker 1.11.6 → 2.0.1

package/bin/tmct.mjs

@@ -10,16 +10,18 @@
 //   tmct cli digest '{…json}'              → architecture map + per-module context bundles
 //   tmct --help                            → this help
 //
-// On a real terminal, chat is the full-screen Ink TUI (src/tui/app.mjs);
+// On a real terminal, chat is the full-screen Ink TUI (src/surfaces/tui/app.mjs);
 // `--plain` — or a non-TTY stdin/stdout (pipes, scripts, the test suite) —
 // gets the classic readline shell. BOTH run the same session sink
-// (src/chat.mjs createSession), so logs, sidecars and graph memory are
+// (src/services/chat.mjs createSession), so logs, sidecars and graph memory are
 // identical either way.
 //
 // The `cli` arms (digest / tmct_locate / any-tool fallback) are the carried,
 // de-emphasized non-chat modes, folded in here from the former bin/cli.mjs.
 // The graph artifact lives at <repo_path>/.tmct/graph.json; the tools (run
-// with cwd = that repo) load it by default. No flags, no config files.
+// with cwd = that repo) load it by default. The `cli` arms resolve it through
+// the same --graph/--repo/env/tmct.toml chain every other subcommand shares
+// (src/services/cli-args.mjs resolveRuntimeConfig).
 //
 // tmct began as a whole-package lift of an earlier chat surface (see README
 // provenance): internal module filenames and symbols were kept to preserve the
@@ -35,7 +37,7 @@ Usage:
   tmct                         interactive chat (the headline surface)
   tmct chat [--repo <abs>]     chat over a specific repo's graph
        [--graph <path>]        explicit graph file (repeatable — multiple graphs merge;
-                               see src/graph-merge.mjs); wins over --repo/TMCT_GRAPH_FILE/tmct.toml
+                               see src/adapters/graph-merge.mjs); wins over --repo/TMCT_GRAPH_FILE/tmct.toml
        [--config <path>]       an alternate tmct.toml location (a file or a directory)
        [--ephemeral]           read the graph but write nothing back (demo/read-only)
        [--prompt "<text>"]     one-shot: run the prompt's sentences as turns and print
@@ -56,7 +58,8 @@ Usage:
        [--config <path>]       folded blocks (the /memory chat command, from the shell)
        [--verbose]
   tmct init [--repo <abs>]     initialize a repo for tmct (default: cwd): .tmct/,
-       [--force]               tmct.toml, tier-1 corpus seed, provenance record
+       [--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
        [--ontology <name|path>]  activate+seed an ontology bundle (a recognized name or a path)
@@ -109,22 +112,26 @@ Usage:
        [--repo <abs>]          query tool calls for a compound or maintenance-goal
        [--graph <path>]        request ("of the modules impacted by X, which are
        [--config <path>]       untested", "what most needs a test") — a real STRIPS/
-       [--tools <a,b,...>]     PDDL planner (src/router/*), never a guessed call.
+       [--tools <a,b,...>]     PDDL planner (src/domain/router/*), never a guessed call.
        [--json]                Prints the grounded step sequence + composed answer,
                                or an honest "no plan found". --tools restricts the
                                declared toolset; --json prints the full loop result.
   tmct cli <tool> '{…}'        invoke a graph tool directly (carry-over, de-emphasized)
+       [--repo <abs>]          the repo to answer from; the payload's "repo_path" says
+       [--graph <path>]        the same thing. --graph names the graph file outright
+       [--config <path>]       (repeatable), --config an alternate tmct.toml
   tmct cli digest '{…}'        architecture map + per-module context bundles
   tmct --help                  show this help
 
 On a terminal, chat opens the full-screen TUI; piped input gets the plain shell.
 In chat: /help lists slash-commands; /exit leaves. Session log → <repo>/.tmct/session-<id>.log.
 
-Shared graph-path precedence (chat/serve; see src/cli-args.mjs): --graph flag(s) >
+Shared graph-path precedence (chat/serve/cli; see src/services/cli-args.mjs): --graph flag(s) >
 TMCT_GRAPH_FILE env > tmct.toml graph_file/graph_files > --repo-derived
-<repo>/.tmct/graph.json > git-root/cwd default.
+<repo>/.tmct/graph.json > git-root/cwd default. On the \`cli\` route, a payload's
+"repo_path" fills the --repo tier when the flag is absent.
 
-Memory-backend precedence (chat; see src/chat.mjs createSession): --memory-backend
+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.
@@ -175,7 +182,7 @@ async function runDigest(args, { dispatchTool, buildContextBundle, source, confi
   let modules = Array.isArray(args.modules) ? args.modules.slice(0, DIGEST_MODULE_CAP) : [];
   let autoSelected = null; // for the header, when `query` drove selection
   if (!modules.length && args.query) {
-    const graph = parseEntities(await source.fetchEntities(configFor(repoPath)));
+    const graph = parseEntities(await source.fetchEntities(await configFor(repoPath)));
     // SHIPPED DEFAULT (0.5.0): the digest's query-mode auto-locate resolves literal-mention ON
     // (a fresh invocation with no tmct.toml), disable-able via `literal_mention:false`. Kept in
     // lockstep with the `tmct_locate` handler so `cli digest '{query}'` ≡ `cli tmct_locate` for the
@@ -196,7 +203,7 @@ async function runDigest(args, { dispatchTool, buildContextBundle, source, confi
   // not just the primary + 2 trimmed secondaries. Tests whether maximal injection re-bloats.
   const max = Boolean(args.max);
   const secondaryCap = max ? modules.length : DIGEST_SECONDARY_CAP;
-  const config = configFor(repoPath);
+  const config = await configFor(repoPath);
   const body = [];
   let effTier = "NONE"; // largest tier emitted across all modules
   let topup = false;    // whether any module's auto-sizing escalated above TINY
@@ -247,18 +254,23 @@ async function runDigest(args, { dispatchTool, buildContextBundle, source, confi
  *  Imports are lazy so `tmct --help` and chat startup never pay for the tool
  *  stack. */
 async function runCliMode() {
-  const [, sub, payload] = process.argv.slice(2);
-  const { join } = await import("node:path");
-  const { dispatchTool, buildContextBundle } = await import("../src/server.mjs");
-  const { loadConfig, DEFAULT_GRAPH_REL } = await import("../src/config.mjs");
-  const source = await import("../src/source.mjs");
-  const codegraph = await import("../src/codegraph.mjs");
+  const rest = process.argv.slice(2);
+  const [, sub, payload] = rest;
+  const { dispatchTool, buildContextBundle } = await import("../src/tools/server.mjs");
+  const source = await import("../src/adapters/source.mjs");
+  const codegraph = await import("../src/domain/codegraph.mjs");
   const { parseEntities, searchModulesRanked } = codegraph;
-
-  /** Build a config pointed at a specific repo's artifact (for `cli` sub-commands that
-   *  take a repo_path), or fall back to the cwd-derived default. */
-  const configFor = (repoPath) =>
-    repoPath ? { graphFile: join(repoPath, DEFAULT_GRAPH_REL) } : loadConfig();
+  const { resolveRuntimeConfig, strFlag } = await import("../src/services/cli-args.mjs");
+
+  /** Resolve this invocation's graph through the SAME precedence chain every other
+   *  subcommand uses (--graph flag(s) > TMCT_GRAPH_FILE > tmct.toml > --repo-derived),
+   *  so a passed --graph/--repo is honoured instead of silently answering from the cwd.
+   *  A payload's `repo_path` is this route's own way of naming the repo, so it fills the
+   *  --repo tier when the flag itself is absent. */
+  const configFor = async (repoPath) => {
+    const argv = repoPath && !strFlag(rest, ["--repo"]) ? [...rest, "--repo", repoPath] : rest;
+    return (await resolveRuntimeConfig({ argv })).config;
+  };
 
   // digest mode: architecture map + per-module context bundles → stdout
   if (sub === "digest") {
@@ -281,7 +293,7 @@ async function runCliMode() {
       process.stderr.write("tmct: tmct_locate expects a JSON arg, e.g. '{\"query\":\"…\",\"repo_path\":\"/abs\"}'\n");
       process.exit(2);
     }
-    const config = configFor(args.repo_path);
+    const config = await configFor(args.repo_path);
     try {
       const graph = parseEntities(await source.fetchEntities(config));
       // B016 recall-lever flags (LOCATE-phase, per-arm; output byte-identical when absent).
@@ -320,7 +332,7 @@ async function runCliMode() {
       process.stderr.write(`tmct: ${sub} expects a JSON arg, e.g. '{"symbol":"<name>"}'\n`);
       process.exit(2);
     }
-    const config = configFor(args.repo_path);
+    const config = await configFor(args.repo_path);
     try {
       const text = await dispatchTool(sub, args, { config });
       process.stdout.write(text + "\n");
@@ -340,7 +352,7 @@ async function runCliMode() {
 // Both `tmct init --corpus/--ontology/--lexicon` and the new `tmct import` verb
 // funnel through the SAME two-step seam: resolvePluggableInput (name/id/path →
 // a resolved descriptor) then activatePluggableInput (write tmct.toml + seed via
-// src/extensions.mjs's unified loop) — one seam instead of three near-duplicate
+// src/services/extensions.mjs's unified loop) — one seam instead of three near-duplicate
 // hand-rolled call sites.
 
 /** Read `repoRoot`'s current tmct.toml (if any) into the shape init.mjs's
@@ -348,8 +360,8 @@ async function runCliMode() {
  *  write it straight back without losing every other already-written key.
  *  Mirrors `tmct init --corpus`'s original inline config-merge exactly. */
 async function readConfigForRewrite(repoRoot) {
-  const { defaultConfig } = await import("../src/init.mjs");
-  const { loadTomlConfig } = await import("../src/toml-config.mjs");
+  const { defaultConfig } = await import("../src/services/init.mjs");
+  const { loadTomlConfig } = await import("../src/adapters/toml-config.mjs");
   const raw = await loadTomlConfig(repoRoot);
   const cfg = { ...defaultConfig() };
   if (raw?.graph_file !== undefined) cfg.graphFile = String(raw.graph_file);
@@ -367,7 +379,7 @@ async function readConfigForRewrite(repoRoot) {
 }
 
 async function writeConfig(repoRoot, cfg) {
-  const { renderTomlConfig, CONFIG_FILE } = await import("../src/init.mjs");
+  const { renderTomlConfig, CONFIG_FILE } = await import("../src/services/init.mjs");
   const { writeFile } = await import("node:fs/promises");
   const { join: joinPath } = await import("node:path");
   await writeFile(joinPath(repoRoot, CONFIG_FILE), renderTomlConfig(cfg));
@@ -431,14 +443,14 @@ 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/extensions.mjs");
+  const { BUILTIN_EXTENSIONS } = await import("../src/services/extensions.mjs");
   if (Object.prototype.hasOwnProperty.call(BUILTIN_EXTENSIONS, nameOrPath) && BUILTIN_EXTENSIONS[nameOrPath].kind === kind) {
     return { known: true, name: nameOrPath };
   }
   let manifestIds = null;
   if (kind === "corpus") {
     const { readFile } = await import("node:fs/promises");
-    const { TIER2_MANIFEST_FILE } = await import("../src/corpus/conceptnet.mjs");
+    const { TIER2_MANIFEST_FILE } = await import("../src/adapters/corpus/conceptnet.mjs");
     try {
       const manifest = JSON.parse(await readFile(TIER2_MANIFEST_FILE, "utf8"));
       const corpuses = manifest.corpuses || [];
@@ -465,7 +477,7 @@ async function resolvePluggableInput(kind, nameOrPath, { repoRoot }) {
 /** Activate one resolvePluggableInput() result in `repoRoot`'s tmct.toml and —
  *  for corpus/ontology-kind entries (or a pack-kind entry with a corpusPath) —
  *  seed it via the SAME unified loop every other bundle uses
- *  (src/extensions.mjs's seedActiveCorpusEntries). A lexicon/templates-kind
+ *  (src/services/extensions.mjs's seedActiveCorpusEntries). A lexicon/templates-kind
  *  entry only activates (merged read-time via mergedLexiconExtra, never
  *  seeded — matching today's behavior for those kinds). Returns a
  *  human-readable status line for stdout. */
@@ -485,14 +497,14 @@ async function activatePluggableInput(repoRoot, resolved) {
   cfg.extensions = { ...(cfg.extensions || {}), [name]: newEntry };
   await writeConfig(repoRoot, cfg);
 
-  const { resolveExtensions, seedActiveCorpusEntries } = await import("../src/extensions.mjs");
+  const { resolveExtensions, seedActiveCorpusEntries } = 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) {
     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/init.mjs's own
+  // Backend-aware seeding (same split-brain bug fix as src/services/init.mjs's own
   // corpus seed, found in review): `cfg.memory.backend` already reflects
   // tmct.toml as it stands RIGHT NOW (readConfigForRewrite, above) — which,
   // for a `tmct init --corpus X --memory-backend sqlite` / `tmct import
@@ -501,7 +513,7 @@ async function activatePluggableInput(repoRoot, resolved) {
   // before running any activation). Resolved via the SAME openMemoryBackend
   // createSession/initRepo use, so this bundle's facts land in the store a
   // later `tmct chat` will actually read.
-  const { openMemoryBackend } = await import("../src/memory/core.mjs");
+  const { openMemoryBackend } = await import("../src/adapters/memory/core.mjs");
   const backendChoice = String(cfg.memory?.backend || "").trim().toLowerCase();
   if (backendChoice === "memory") {
     return `activated "${name}" (${entry.kind}) in tmct.toml — seeding skipped (memory backend is in-process only, nothing would persist past this command).\n`;
@@ -519,7 +531,7 @@ async function activatePluggableInput(repoRoot, resolved) {
   }
   if (resolved.manifestEntry) {
     // Preserve the ORIGINAL `--corpus <tier2-id>` wording byte-for-byte
-    // (test/init-cli.test.mjs asserts on this exact shape).
+    // (e2e/init-cli.test.mjs asserts on this exact shape).
     return `seeded tier-2 corpus "${resolved.manifestEntry.id}" (${resolved.manifestEntry.kind}) — ${seeded.appended} fact(s) added`
       + `${seeded.skipped ? `, ${seeded.skipped} already present` : ""}. Source: corpus/tier2/${resolved.manifestEntry.file} (${resolved.manifestEntry.license}). `
       + `Activated in tmct.toml — future \`tmct init\`/chat sessions seed it automatically.\n`;
@@ -529,6 +541,21 @@ async function activatePluggableInput(repoRoot, resolved) {
     + `Activated in tmct.toml — future \`tmct init\`/chat sessions seed it automatically.\n`;
 }
 
+/** Write `repoRoot`/.tmct/TOOLS.md — the cold-tool catalog, rendered from the tool
+ *  definitions with THIS executable's own absolute path in every worked invocation, so
+ *  the copied line runs as-is. Returns the path written. */
+async function writeToolsCatalog(repoRoot) {
+  const { renderToolsCatalog } = await import("../src/tools/catalog.mjs");
+  const { mkdir, writeFile } = await import("node:fs/promises");
+  const { resolve: resolvePath } = await import("node:path");
+  const { fileURLToPath } = await import("node:url");
+  const dir = resolvePath(repoRoot, ".tmct");
+  await mkdir(dir, { recursive: true });
+  const catalogPath = resolvePath(dir, "TOOLS.md");
+  await writeFile(catalogPath, renderToolsCatalog(fileURLToPath(import.meta.url)), "utf8");
+  return catalogPath;
+}
+
 /** `--graph <path>` (repeatable) APPENDS to `repoRoot`'s tmct.toml
  *  `graph_files` array — a DIFFERENT, purely additive operation from
  *  activatePluggableInput (no extensions-bundle activation). Each path is
@@ -574,17 +601,17 @@ 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");
-    // `--graph <path>` (repeatable) / `--config <path>` (src/cli-args.mjs): threaded
+    // `--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
     // the call entirely when absent, so a plain `tmct chat [--repo]` invocation is
     // byte-identical to before these flags existed.
-    const { repeatedFlag, strFlag, enumFlag } = await import("../src/cli-args.mjs");
+    const { repeatedFlag, strFlag, enumFlag } = await import("../src/services/cli-args.mjs");
     const graphPaths = repeatedFlag(rest, ["--graph"]);
     const configPath = strFlag(rest, ["--config"]);
     // `--memory-backend <default|memory|sqlite>`: the CLI's top tier of
     // createSession's memoryBackend precedence (CLI flag > TMCT_MEMORY_BACKEND
-    // env > tmct.toml's [memory] backend > built-in default — src/cli-args.mjs's
+    // env > tmct.toml's [memory] backend > built-in default — src/services/cli-args.mjs's
     // shared precedence order, resolved inside createSession itself). Omitted
     // when absent so the lower tiers still apply unchanged.
     let memoryBackend;
@@ -605,7 +632,7 @@ async function main() {
     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/plan-viz.mjs). Requires --prompt: interactive chat has no single
+    // (src/services/plan-viz.mjs). Requires --prompt: interactive chat has no single
     // final turn to render.
     let renderArchetype;
     try {
@@ -619,8 +646,8 @@ async function main() {
       process.exit(1);
     }
     if (prompt) {
-      const { createSession } = await import("../src/chat.mjs");
-      const { splitSentences } = await import("../src/sentences.mjs");
+      const { createSession } = await import("../src/services/chat.mjs");
+      const { splitSentences } = await import("../src/services/sentences.mjs");
       const session = await createSession({ repoPath, ephemeral, narrate, ...extra });
       let finalAnswer = "";
       let finalPlan = null;
@@ -640,7 +667,7 @@ async function main() {
           process.exitCode = 1;
           return;
         }
-        const { renderPlanHtml } = await import("../src/plan-viz.mjs");
+        const { renderPlanHtml } = await import("../src/services/plan-viz.mjs");
         const { writeFile } = await import("node:fs/promises");
         const { resolve: resolvePath } = await import("node:path");
         const outPath = resolvePath(process.cwd(), strFlag(rest, ["--output", "--out"], "plan.html"));
@@ -662,10 +689,10 @@ async function main() {
     // drive the same createSession sink — only the drawing differs.
     const plain = rest.includes("--plain") || !process.stdin.isTTY || !process.stdout.isTTY;
     if (plain) {
-      const { runChat } = await import("../src/chat.mjs");
+      const { runChat } = await import("../src/services/chat.mjs");
       await runChat({ repoPath, ephemeral, narrate, ...extra });
     } else {
-      const { runTui } = await import("../src/tui/app.mjs");
+      const { runTui } = await import("../src/surfaces/tui/app.mjs");
       await runTui({ repoPath, ephemeral, narrate, ...extra });
     }
     return;
@@ -673,14 +700,14 @@ async function main() {
 
   if (mode === "memory") {
     // `tmct memory` — the /memory chat command from the shell: same renderer
-    // (src/memory/inspect.mjs). Repo resolution now goes through the shared
-    // resolveRuntimeConfig (src/cli-args.mjs) — --repo > git root > cwd, same
+    // (src/adapters/memory/inspect.mjs). Repo resolution now goes through the shared
+    // resolveRuntimeConfig (src/services/cli-args.mjs) — --repo > git root > cwd, same
     // as before, plus a (currently inert but accepted) `--config` for symmetry
     // with every other subcommand. No `--graph`: memory reads no code graph.
     const rest = process.argv.slice(3);
     const verbose = rest.includes("--verbose") || rest.includes("-v");
-    const { resolveRuntimeConfig } = await import("../src/cli-args.mjs");
-    const { inspectMemory } = await import("../src/memory/inspect.mjs");
+    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");
     return;
@@ -692,7 +719,7 @@ 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/extensions.mjs's BUILTIN_EXTENSIONS). A tier-2 domain/
+    // 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,
@@ -702,9 +729,9 @@ async function main() {
     // subcommand without a --repo flag. It now takes one like every other
     // subcommand, defaulting to cwd exactly as before when absent.
     const rest = process.argv.slice(3);
-    const { strFlag, repeatedFlag, enumFlag } = await import("../src/cli-args.mjs");
+    const { strFlag, repeatedFlag, enumFlag } = await import("../src/services/cli-args.mjs");
     const { resolve: resolvePath } = await import("node:path");
-    const { initRepo, PERSONA_PRESETS } = await import("../src/init.mjs");
+    const { initRepo, PERSONA_PRESETS } = await import("../src/services/init.mjs");
 
     const repoFlag = strFlag(rest, ["--repo"]);
     const repoRoot = repoFlag ? resolvePath(process.cwd(), repoFlag) : process.cwd();
@@ -717,9 +744,9 @@ async function main() {
     // `--memory-backend <default|memory|sqlite>` (PLAN_SEED.md §6's storage-backend
     // seam, now reachable from `tmct init`): validated BEFORE touching disk, same
     // discipline as every other pluggable input below. Written into tmct.toml's
-    // `[memory] backend` (src/init.mjs's renderTomlConfig); chat.mjs's
+    // `[memory] backend` (src/services/init.mjs's renderTomlConfig); chat.mjs's
     // createSession reads it back at CLI-flag > TMCT_MEMORY_BACKEND env >
-    // tmct.toml > default precedence (src/cli-args.mjs's shared precedence order).
+    // tmct.toml > default precedence (src/services/cli-args.mjs's shared precedence order).
     let memoryBackendVal;
     try {
       memoryBackendVal = enumFlag(rest, ["--memory-backend"], ["default", "memory", "sqlite"]);
@@ -833,6 +860,10 @@ async function main() {
     const res = await initRepo(repoRoot, { force: forceFlag, persona: personaPreset, memoryBackend: memoryBackendVal });
     process.stdout.write(res.message + "\n");
 
+    // The cold tools carry no resident schema, so the initialized repo gets the catalog
+    // on disk: one copy-paste Bash invocation per tool, rewritten on every init.
+    process.stdout.write(`cold-tool catalog: ${await writeToolsCatalog(repoRoot)}\n`);
+
     // `--corpus`/`--ontology`/`--lexicon` now mean "activate this bundle and
     // PERSIST that into tmct.toml" — so a second `tmct init` (or the next chat
     // bootstrap) remembers the choice, unlike the old ad hoc path, which had
@@ -907,7 +938,7 @@ async function main() {
     // additive operation (appendGraphFiles) — it grows tmct.toml's graph_files
     // array, never activates an extensions bundle.
     const rest = process.argv.slice(3);
-    const { strFlag, repeatedFlag, enumFlag } = await import("../src/cli-args.mjs");
+    const { strFlag, repeatedFlag, enumFlag } = await import("../src/services/cli-args.mjs");
     const { resolve: resolvePath } = await import("node:path");
 
     const repoFlag = strFlag(rest, ["--repo"]);
@@ -982,7 +1013,7 @@ async function main() {
     // Any declined sentence exits non-zero: a half-taught game plans wrongly
     // or not at all with no visible cause otherwise.
     if (fileVal) {
-      const { importDefinitionFile } = await import("../src/import-file.mjs");
+      const { importDefinitionFile } = await import("../src/services/import-file.mjs");
       try {
         const result = await importDefinitionFile(repoRoot, fileVal);
         process.stdout.write(result.report + "\n");
@@ -1000,7 +1031,7 @@ async function main() {
     // (the shape a package like seonix/marginalia ships) BEFORE it's activated
     // in any repo's tmct.toml. Reuses existing throw-loudly primitives
     // (loadSlice/loadMap/toFacts, loadLexicon, loadTemplates) via
-    // src/extensions.mjs's validateExtensionPack — never invents new
+    // src/services/extensions.mjs's validateExtensionPack — never invents new
     // shape-checking logic. `<dir>` must carry its own tmct.toml declaring one
     // or more `[extensions.<name>]` host entries (the SAME [extensions] table
     // shape a repo's own tmct.toml uses) naming the resource(s) to validate;
@@ -1014,7 +1045,7 @@ async function main() {
       process.exit(2);
     }
     const { resolve: resolvePath } = await import("node:path");
-    const { strFlag } = await import("../src/cli-args.mjs");
+    const { strFlag } = await import("../src/services/cli-args.mjs");
     const target = resolvePath(process.cwd(), dirArg);
     // `--config <path>` (optional): an alternate tmct.toml to validate against,
     // INSTEAD of `<target>/tmct.toml` — `target` still anchors every resource
@@ -1030,7 +1061,7 @@ async function main() {
       try { isDir = (await stat(abs)).isDirectory(); } catch { /* missing path — treat as a file target */ }
       configFile = isDir ? resolvePath(abs, "tmct.toml") : abs;
     }
-    const { resolveExtensions, BUILTIN_EXTENSIONS, validateExtensionPack } = await import("../src/extensions.mjs");
+    const { resolveExtensions, BUILTIN_EXTENSIONS, validateExtensionPack } = await import("../src/services/extensions.mjs");
     let entries;
     try {
       ({ entries } = await resolveExtensions(target, configFile ? { configFile } : {}));
@@ -1064,7 +1095,7 @@ async function main() {
     // `tmct syllogise` — the explicit speculative-inference batch (never on the chat
     // hot path): forward-chain the memory's rdfs:subClassOf closure into bounded,
     // low-trust, retractable entailed facts. Same repo resolution as `memory` —
-    // resolveRuntimeConfig (src/cli-args.mjs): --repo > git root > cwd. Also
+    // resolveRuntimeConfig (src/services/cli-args.mjs): --repo > git root > cwd. Also
     // accepts `--config` for symmetry (syllogise reads no code graph either).
     const rest = process.argv.slice(3);
     const numFlag = (name, dflt) => {
@@ -1072,10 +1103,14 @@ async function main() {
       const v = j !== -1 ? Number(rest[j + 1]) : NaN;
       return Number.isFinite(v) ? v : dflt;
     };
-    const { resolveRuntimeConfig } = await import("../src/cli-args.mjs");
-    const { syllogise } = await import("../src/syllogise.mjs");
+    const { resolveRuntimeConfig } = await import("../src/services/cli-args.mjs");
+    const { syllogise } = await import("../src/domain/syllogise.mjs");
+    const { loadMemory, readFactRows, appendFacts } = 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) });
+    const res = await syllogise(repo, {
+      depth: numFlag("--depth", 32), budget: numFlag("--budget", 50),
+      store: { loadMemory, readFactRows, appendFacts },
+    });
     process.stdout.write(
       `tmct syllogise — derived ${res.count} entailed fact(s) (subClassOf closure, depth ${res.depth}, budget ${res.budget})`
       + (res.truncated ? " — budget reached, more available" : "") + "\n",
@@ -1099,8 +1134,8 @@ async function main() {
       process.exitCode = 1;
       return;
     }
-    const { strFlag, resolveRuntimeConfig } = await import("../src/cli-args.mjs");
-    const { computeLedgerData, renderLedgerHtml, readMemoryAskBundle } = await import("../src/ledger-viz.mjs");
+    const { strFlag, resolveRuntimeConfig } = await import("../src/services/cli-args.mjs");
+    const { computeLedgerData, renderLedgerHtml, readMemoryAskBundle } = await import("../src/services/ledger-viz.mjs");
     const { writeFile } = await import("node:fs/promises");
     const { resolve } = await import("node:path");
     const limitIdx = rest.indexOf("--limit");
@@ -1155,12 +1190,12 @@ async function main() {
       );
       return;
     }
-    const { strFlag, resolveRuntimeConfig } = await import("../src/cli-args.mjs");
+    const { strFlag, resolveRuntimeConfig } = await import("../src/services/cli-args.mjs");
     const host = strFlag(rest, ["--host"], "127.0.0.1");
     const portRaw = strFlag(rest, ["--port"]);
     const port = portRaw !== undefined && Number.isFinite(Number(portRaw)) ? Number(portRaw) : 8787;
-    const { startServer } = await import("../src/server-http.mjs");
-    // Graph-path precedence (src/cli-args.mjs, shared with `chat`): --graph
+    const { startServer } = await import("../src/surfaces/http/server-http.mjs");
+    // Graph-path precedence (src/services/cli-args.mjs, shared with `chat`): --graph
     // flag(s) > TMCT_GRAPH_FILE env > tmct.toml graph_file/graph_files >
     // --repo-derived <repo>/.tmct/graph.json > git-root/cwd default. This
     // REPLACES serve's old cwd-only default (loadConfig had no git-root
@@ -1179,7 +1214,7 @@ async function main() {
   }
 
   if (mode === "plan") {
-    // `tmct plan "<request>"` — the capability router (src/router/*), surfaced
+    // `tmct plan "<request>"` — the capability router (src/domain/router/*), surfaced
     // for real: a STRIPS/PDDL-style planner over the SAME read-only graph-query
     // tools chat/serve dispatch. A single-shot request ("who calls X") resolves
     // directly; a compound request ("of the modules impacted by X, which are
@@ -1214,7 +1249,7 @@ async function main() {
       );
       return;
     }
-    const { strFlag, resolveRuntimeConfig } = await import("../src/cli-args.mjs");
+    const { strFlag, resolveRuntimeConfig } = await import("../src/services/cli-args.mjs");
     const toolsFlag = strFlag(rest, ["--tools"]);
     const jsonFlag = rest.includes("--json");
     // The request is every argv token that isn't a recognized flag or its value,
@@ -1234,7 +1269,19 @@ async function main() {
       process.exit(2);
     }
     const { repo, config } = await resolveRuntimeConfig({ argv: rest });
-    const { buildCapabilityPlanCtx, runCapabilityPlan, declaredCapabilityNames } = await import("../src/router/drive.mjs");
+    const { buildCapabilityPlanCtx, runCapabilityPlan, declaredCapabilityNames } = await import("../src/domain/router/drive.mjs");
+    const { capabilityPlanDeps } = await import("../src/services/chat.mjs");
+    let ctx;
+    try {
+      ctx = await buildCapabilityPlanCtx({ ...capabilityPlanDeps(), config, memoryDir: repo });
+    } catch (e) {
+      process.stderr.write(`tmct plan: could not load the graph — ${e?.message || e}\n`);
+      process.exit(1);
+    }
+    // The toolset is read AFTER the ctx build: the memory store's taught:
+    // capability records only register there, so both the default toolset and
+    // an explicit --tools list (e.g. --tools "taught:move onto") see them —
+    // and a world goal refuses when its taught record is outside the toolset.
     const declared = declaredCapabilityNames();
     let tools = declared;
     if (toolsFlag) {
@@ -1245,17 +1292,6 @@ async function main() {
         process.exit(2);
       }
     }
-    let ctx;
-    try {
-      ctx = await buildCapabilityPlanCtx({ config, memoryDir: repo });
-    } catch (e) {
-      process.stderr.write(`tmct plan: could not load the graph — ${e?.message || e}\n`);
-      process.exit(1);
-    }
-    // The default (no --tools) toolset is re-read AFTER the ctx build: the
-    // memory store's taught: capability records only register there, and a
-    // world goal refuses when its taught record is outside the toolset.
-    if (!toolsFlag) tools = declaredCapabilityNames();
     try {
       const result = await runCapabilityPlan(request, tools, ctx);
       if (jsonFlag) {

package/corpus/LICENSES.json

@@ -0,0 +1,118 @@
+{
+  "version": 1,
+  "description": "Machine-readable licence rollup for the committed corpus and data files. One entry per corpus family; `notice` names the human-readable attribution file. Guarded by test/estate/corpus-licences.test.mjs.",
+  "entries": [
+    {
+      "path": "corpus/conceptnet/slice.jsonl",
+      "upstream": "ConceptNet 5.7.0 assertions dump (conceptnet.io, Commonsense Computing Initiative)",
+      "license": "CC-BY-SA-4.0",
+      "shareAlike": true,
+      "notice": "corpus/conceptnet/LICENSE-NOTICE"
+    },
+    {
+      "path": "corpus/seon/",
+      "upstream": "first-party (hand-authored for tmct; named in homage to SEON, no SEON content copied)",
+      "license": "MPL-2.0",
+      "shareAlike": false,
+      "notice": "corpus/seon/LICENSE-NOTICE"
+    },
+    {
+      "path": "corpus/wordnet/",
+      "upstream": "Open English WordNet (globalwordnet/english-wordnet, a continuation of Princeton WordNet)",
+      "license": "CC-BY-4.0",
+      "shareAlike": false,
+      "notice": "corpus/wordnet/LICENSE-NOTICE"
+    },
+    {
+      "path": "corpus/namenet/namenet.jsonl",
+      "upstream": "Open English Namenet (globalwordnet/english-namenet; declares no explicit licence of its own — CC-BY-4.0 is this repository's conservative label, see the notice)",
+      "license": "CC-BY-4.0",
+      "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)",
+      "license": "MPL-2.0",
+      "shareAlike": false,
+      "notice": "corpus/tier2/manifest.json"
+    },
+    {
+      "path": "corpus/tier2/human.jsonl",
+      "upstream": "first-party fact set (hand-curated; vocabulary informed by Open English WordNet and Schema.org, not a verbatim excerpt)",
+      "license": "MPL-2.0",
+      "shareAlike": false,
+      "notice": "corpus/tier2/manifest.json"
+    },
+    {
+      "path": "corpus/tier2/human-medium.jsonl",
+      "upstream": "first-party fact set (automatically curated from the same Open English WordNet source as human.jsonl)",
+      "license": "MPL-2.0",
+      "shareAlike": false,
+      "notice": "corpus/tier2/manifest.json"
+    },
+    {
+      "path": "corpus/tier2/human-large.jsonl",
+      "upstream": "first-party fact set (automatically curated from the same Open English WordNet source as human.jsonl)",
+      "license": "MPL-2.0",
+      "shareAlike": false,
+      "notice": "corpus/tier2/manifest.json"
+    },
+    {
+      "path": "corpus/tier2/human-examples.jsonl",
+      "upstream": "Open English WordNet inline example sentences, reproduced verbatim",
+      "license": "CC-BY-4.0",
+      "shareAlike": false,
+      "notice": "corpus/tier2/manifest.json"
+    },
+    {
+      "path": "corpus/tier2/human-examples-medium.jsonl",
+      "upstream": "Open English WordNet inline example sentences, reproduced verbatim",
+      "license": "CC-BY-4.0",
+      "shareAlike": false,
+      "notice": "corpus/tier2/manifest.json"
+    },
+    {
+      "path": "corpus/tier2/human-examples-large.jsonl",
+      "upstream": "Open English WordNet inline examples plus a SemCor-derived supplement (Brown Corpus text re-tagged to modern OEWN senses)",
+      "license": "CC-BY-4.0",
+      "shareAlike": false,
+      "notice": "corpus/tier2/manifest.json"
+    },
+    {
+      "path": "corpus/generated/ace-surface-variants.jsonl",
+      "upstream": "mechanically generated from Open English WordNet / SemCor example sentences and this repository's own docs prose",
+      "license": "CC-BY-4.0",
+      "shareAlike": false,
+      "notice": "corpus/generated/manifest.json"
+    },
+    {
+      "path": "data/",
+      "upstream": "first-party (tmct response templates, phrasebook and game data)",
+      "license": "MPL-2.0",
+      "shareAlike": false,
+      "notice": "LICENSE"
+    }
+  ]
+}