@polycode-projects/the-mechanical-code-talker 4.0.1 → 4.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polycode-projects/the-mechanical-code-talker",
-  "version": "4.0.1",
+  "version": "4.1.1",
   "private": false,
   "type": "module",
   "description": "The Mechanical Code Talker (tmct) — a tolerant, offline, $0 chat surface that guides you toward precision queries about a software repository. ELIZA/PARRY-style but domain-obsessed with code. No model calls; indexes a repo on request (tmct index) or reads any producer's graph.",

package/src/adapters/memory/core.mjs

@@ -172,6 +172,26 @@ export function createInMemoryStore() {
   return { backend: BACKEND_MEMORY, payload: emptyMemory() };
 }
 
+/** Assign `seedPayload` onto `memoryDir`'s own payload — spread over the
+ *  store's own (possibly empty) payload rather than replacing it outright,
+ *  so a partial seed (individuals and objectProperties only) still carries
+ *  the classes/prefixes scaffolding the write path recounts, and a later
+ *  teach turn works regardless of what the seed carries. A no-op when
+ *  `seedPayload` is null/undefined — a browser session with nothing to seed
+ *  keeps its own fresh empty payload untouched. */
+export function applySeedPayload(memoryDir, seedPayload) {
+  if (seedPayload) memoryDir.payload = { ...memoryDir.payload, ...seedPayload };
+}
+
+/** A structurally independent copy of a memory payload — `structuredClone`
+ *  where available, falling back to a JSON round-trip for an environment
+ *  without it. Returns null for a null/undefined `payload`, so a caller can
+ *  seed a fresh session with "no seed yet" rather than an empty object. */
+export function cloneMemoryPayload(payload) {
+  if (!payload) return null;
+  try { return structuredClone(payload); } catch { return JSON.parse(JSON.stringify(payload)); }
+}
+
 // ---- Backend C — SQLite: a live node:sqlite connection, per-row
 // INSERT/REPLACE/DELETE diffed against what's already stored (write cost
 // proportional to what changed, not total store size). Reads are cached on

package/src/domain/ask-vocab.mjs

@@ -189,6 +189,77 @@ export const RELATIONS = {
   },
 };
 
+// ---- world relations: the predicates a WORLD graph stores about its own
+// individuals, as opposed to RELATIONS above, which is a code vocabulary —
+// a module imports a module, a commit touches a file, and none of its verbs
+// name where a thing is or how it feels. A game board, a burrow and a manor
+// all record those, in the same `mgx:` predicates, so the words for them are
+// curated once here.
+//
+// Each entry is keyed by its stored predicate and carries the LISTING NOUNS a
+// question reaches it by ("the locations of…", "the moods of…") plus `reads`,
+// the third-person phrase one subject's answer is written in. No `verbs` list
+// and no VERB_TO_KIND entry: these answer a listing over a named set, not the
+// "does X <verb> Y" shapes RELATIONS' verbs compile to, and folding them in
+// would put "is in" into the code grammar's own verb table. ----
+
+export const WORLD_RELATIONS = Object.freeze({
+  placement: Object.freeze({
+    predicate: "mgx:currently-in",
+    comment: "individual -> place: where the subject is right now.",
+    nouns: Object.freeze(["location", "locations", "position", "positions", "place", "places", "whereabouts", "room", "rooms"]),
+    reads: "is in",
+  }),
+  mood: Object.freeze({
+    predicate: "mgx:feels",
+    comment: "individual -> mood word: how the subject feels right now.",
+    nouns: Object.freeze(["mood", "moods", "feeling", "feelings", "emotion", "emotions"]),
+    reads: "feels",
+  }),
+  mass: Object.freeze({
+    predicate: "mgx:mass",
+    comment: "individual -> number: the subject's current mass.",
+    nouns: Object.freeze(["mass", "masses", "weight", "weights"]),
+    reads: "has mass",
+  }),
+});
+
+/** listing noun -> WORLD_RELATIONS key ("locations" -> "placement"). */
+export const WORLD_NOUN_TO_RELATION = Object.freeze(Object.fromEntries(
+  Object.entries(WORLD_RELATIONS).flatMap(([token, { nouns }]) => nouns.map((n) => [n, token])),
+));
+
+/** Every stored world predicate, for a caller projecting fact rows into a
+ *  graph `ask` can traverse. */
+export const WORLD_PREDICATES = Object.freeze(
+  Object.values(WORLD_RELATIONS).map((r) => r.predicate),
+);
+
+// The regular English 3rd-person-singular suffix rule (the same regular
+// -s/-es/-ies shape src/domain/inflect.mjs's own `pluralOf` applies to a
+// noun) — not imported from there, since inflect.mjs sits downstream of
+// interpret/normalize.mjs, which imports THIS module: importing it back
+// here would be a real circular dependency, not just a style choice.
+function thirdPersonSingular(w) {
+  if (/(?:[sxz]|ch|sh)$/i.test(w)) return `${w}es`;
+  if (/[^aeiou]y$/i.test(w)) return `${w.slice(0, -1)}ies`;
+  return `${w}s`;
+}
+
+/** The third-person-singular sentence phrase for a stored relation `kind`
+ *  ("inherits" -> "inherits from", "cochange" -> "co-changes with"), derived
+ *  from RELATIONS' own `bare` infinitive rather than a second hand-curated
+ *  verb table. A symbol-grain kind ("callsSymbol", "touchesSymbol") reads its
+ *  coarse sibling's phrase; an unrecognized kind falls back to a plain
+ *  camelCase split. */
+export function phraseForRelation(kind) {
+  const key = String(kind || "");
+  const entry = RELATIONS[key] || (key.endsWith("Symbol") && RELATIONS[key.slice(0, -6)]) || null;
+  if (!entry) return key.replace(/([a-z0-9])([A-Z])/g, "$1 $2").toLowerCase();
+  const [head, ...rest] = entry.bare.split(" ");
+  return [thirdPersonSingular(head), ...rest].join(" ");
+}
+
 /** The closed set of reverse `inherits` verb phrasings a strategy checks to
  *  decide whether to swap subject/object. The three "the"-definite forms are
  *  named here but not reachable through VERB_TO_KIND (see above). */

package/src/domain/ask.mjs

@@ -26,6 +26,7 @@ import {
   PASSIVE_PARTICIPLE_TO_KIND, GENERIC_AGENT_WORDS, REDUCED_RELATIVE_CLAUSES,
   AGGREGATE_TRIGGERS, LIST_TRIGGERS, SUPERLATIVE_EXTREMES, EDGE_NOUN_TO_METRIC, METRIC_IMPLIES_ENTITY, ANAPHORA_TRIGGERS,
   MEMBERSHIP_KINDS, CASCADE_NOISE, CASCADE_SYNONYMS, HELP_TRIGGERS,
+  WORLD_RELATIONS, WORLD_NOUN_TO_RELATION, WORLD_PREDICATES,
   stripTrailingScopeFiller,
 } from "./ask-vocab.mjs";
 import { expandContractions, normalizeQuery, applyNegationFrames, applyPhrasingFrames, matchNegationSet, STOPWORDS, splitWords, wordsOf, escapeRegex } from "./interpret/normalize.mjs";
@@ -2135,6 +2136,7 @@ function evalComposite(graph, ast, opts = {}) {
     return { compositeKind: "count", count: evalSet(graph, ast.base, opts).length, entityType: ast.entityType, matches: [] };
   }
   if (ast.node === "list") return { compositeKind: "list", matches: evalSet(graph, ast.base, opts), entityType: ast.entityType, scoped: ast.scoped };
+  if (ast.node === "worldRelation") return evalWorldRelation(graph, ast);
   if (ast.node === "superlative") return evalSuperlative(graph, ast);
   if (ast.node === "temporal") return evalTemporal(graph, ast, opts);
   if (ast.node === "recentCommits") return evalRecentCommits(graph);
@@ -2292,6 +2294,20 @@ function renderComposite(parsed, result, graph) {
       : "";
     return { content: `${compositeList(result.matches)}${hint}.`, miss: false, ambiguous: false, matches: result.matches };
   }
+  // One sentence per subject, in id order, in the world's own words — the
+  // subject's id, the relation's `reads` phrase, and the stored object
+  // verbatim. Nothing is derived: an empty set is the honest miss, never a
+  // sentence about a subject the world has no row for.
+  if (result.compositeKind === "worldRelation") {
+    const asked = listJoin(result.askedClasses);
+    const noun = WORLD_RELATIONS[result.relation].nouns[1];
+    if (!result.pairs.length) {
+      return { content: `no ${noun} on record for ${asked} in this graph.`, miss: true, ambiguous: false, matches: [] };
+    }
+    const reads = WORLD_RELATIONS[result.relation].reads;
+    const sentences = result.pairs.map((p) => `${p.subject.label || p.subject.id} ${reads} ${p.object}`);
+    return { content: `${sentences.join("; ")}.`, miss: false, ambiguous: false, matches: result.matches };
+  }
   // A non-empty inherited result is disclosed out loud ("X has no own <kind>
   // — inherited from <ancestor>: …"), never silently presented as the owner's own.
   if (result.compositeKind === "membership") {
@@ -4403,6 +4419,148 @@ function dynamicClassQuery(graph, query) {
   return listM ? { node: "list", entityType, base, scoped: false } : { node: "count", entityType, base };
 }
 
+// ---- world-relation listing: "list the locations of flies and spiders", the
+// plural, multi-class form of a question a world graph can already answer. A
+// listing over ONE world predicate (ask-vocab.mjs's WORLD_RELATIONS) filtered
+// to one or more subject CLASSES, resolved dynamically against whatever
+// classes actually have an individual in this graph — so a world's own
+// taxonomy needs no entry in the closed code-graph noun table, exactly as the
+// count/list fallback above resolves its class noun. Fires only once the
+// normal cascade has already produced an honest miss, and misses honestly
+// itself when any asked class has no individual here. ----
+
+// A class list: "flies and spiders", "spiders, flies and eggs". Each part must
+// be a single bare noun — a phrase with anything else in it is a restrictor
+// this shape can't honour, so it declines rather than dropping it.
+function parseWorldClassList(graph, text) {
+  const parts = String(text || "").split(/\s*,\s*|\s+and\s+/i).map((s) => s.trim()).filter(Boolean);
+  if (!parts.length) return null;
+  const asked = [];
+  const classes = [];
+  for (const part of parts) {
+    const word = part.replace(/^(?:all\s+)?(?:the\s+)?/i, "").trim();
+    if (!/^[a-z][a-z'-]*$/i.test(word)) return null;
+    const cls = resolveDynamicClass(graph, word);
+    if (!cls) return null;
+    asked.push(word.toLowerCase());
+    classes.push(cls);
+  }
+  return { asked: [...new Set(asked)], classes: [...new Set(classes)] };
+}
+
+const WORLD_LISTING_RE = new RegExp(
+  `^(?:${LIST_TRIGGERS_SORTED.map(escapeRegex).join("|")})\\s+(?:all\\s+)?(?:the\\s+)?([a-z][a-z'-]*)\\s+(?:of|for)\\s+(.+?)[?.!\\s]*$`,
+  "i",
+);
+// "where are the flies and spiders" — the same listing said the natural way.
+// Singular too ("where is the spider"): the class list resolves either way, and
+// with only the code-graph `where` lane to fall back on the answer would be
+// "no recorded code location" for a subject whose cell this graph plainly
+// holds. A phrase that isn't a bare class noun ("where is auth.mjs defined")
+// fails parseWorldClassList and keeps the definition-site reading.
+const WORLD_WHERE_RE = /^where(?:'s|\s+is|\s+are)\s+(?:all\s+)?(?:the\s+)?(.+?)[?.!\s]*$/i;
+
+/** Compile "<list trigger> the <world-relation noun> of <class> and <class>"
+ *  (or "where are the <class> and <class>") into a world-relation listing AST,
+ *  or null when this isn't that shape. */
+function worldRelationQuery(graph, query) {
+  const q = String(query || "").trim();
+  const listM = q.match(WORLD_LISTING_RE);
+  const relation = listM ? WORLD_NOUN_TO_RELATION[listM[1].toLowerCase()] : "placement";
+  if (!relation) return null;
+  const subjectText = listM ? listM[2] : q.match(WORLD_WHERE_RE)?.[1];
+  if (!subjectText) return null;
+  const resolved = parseWorldClassList(graph, subjectText);
+  if (!resolved) return null;
+  return {
+    node: "worldRelation",
+    relation,
+    predicate: WORLD_RELATIONS[relation].predicate,
+    classes: resolved.classes,
+    askedClasses: resolved.asked,
+  };
+}
+
+const normalizePredicate = (p) => String(p || "").toLowerCase();
+
+function evalWorldRelation(graph, ast) {
+  const wanted = new Set(ast.classes);
+  const latest = new Map();
+  for (const group of graph?.relations || []) {
+    if (normalizePredicate(group.prop) !== ast.predicate && normalizePredicate(group.predicate) !== ast.predicate) continue;
+    // A world appends a fresh row per turn rather than rewriting one, so the
+    // LAST edge for a subject is its current value — the same last-wins fold
+    // every world's own state reader applies to its rows.
+    for (const edge of group.edges || []) {
+      const subject = graph.byId?.get(edge.subject);
+      if (subject && wanted.has(subject.class)) latest.set(edge.subject, { subject, object: edge.object });
+    }
+  }
+  const pairs = [...latest.values()].sort((a, b) => String(a.subject.id).localeCompare(String(b.subject.id)));
+  return {
+    compositeKind: "worldRelation",
+    relation: ast.relation,
+    askedClasses: ast.askedClasses,
+    pairs,
+    matches: pairs.map((p) => p.subject),
+  };
+}
+
+// A world writes each turn's facts against a stamped subject ("spider-1@turn3",
+// "player@step7") and folds them back onto the base id, newest stamp winning —
+// spider-fly.mjs's foldSpiderFlyState and domain.mjs's foldWorldState both do
+// exactly this. An unstamped row is the world's own starting value, stamp 0.
+const WORLD_SNAPSHOT_RE = /^(.+)@(?:turn|step)(\d+)$/;
+
+function splitWorldSnapshot(term) {
+  const m = WORLD_SNAPSHOT_RE.exec(String(term ?? ""));
+  return m ? { base: m[1], stamp: Number(m[2]) } : { base: String(term ?? ""), stamp: 0 };
+}
+
+/** Project plain world fact rows (`{subject, predicate, object}`, the shape
+ *  memory/core.mjs's readFactRows returns) into the `{individuals,
+ *  objectProperties}` payload parseEntities consumes, so a page holding a live
+ *  world can hand `ask` a graph of it instead of an empty one. Only the
+ *  WORLD_PREDICATES rows are carried: a board's own geometry (every cell and
+ *  every exit) is thousands of rows no natural-language listing asks for.
+ *  Turn-stamped rows are folded onto their base subject, so the graph carries
+ *  each subject's CURRENT value and never a stale one from an earlier turn.
+ *
+ *  A subject's class comes from its own `rdf:type` row when the world states
+ *  one; `classOf(id)` is the fallback for a world that names its individuals
+ *  by convention instead (spider-fly's "spider-1" is a spider because of its
+ *  id). Returning null from `classOf` drops the subject — that is the seam a
+ *  caller filters through, so "which subjects still count as live" stays a
+ *  rule of the world module rather than of this projection. Pure. */
+export function worldRelationGraphPayload(rows, { classOf = () => null } = {}) {
+  const declaredClass = new Map();
+  for (const row of rows || []) {
+    if (row?.predicate === "rdf:type" && row.subject && row.object) {
+      declaredClass.set(splitWorldSnapshot(row.subject).base, String(row.object));
+    }
+  }
+  const wanted = new Set(WORLD_PREDICATES);
+  const individuals = new Map();
+  const newest = new Map();
+  for (const row of rows || []) {
+    if (!row?.subject || !wanted.has(row.predicate)) continue;
+    const { base, stamp } = splitWorldSnapshot(row.subject);
+    const cls = declaredClass.get(base) || classOf(base);
+    if (!cls) continue;
+    const key = `${row.predicate}${base}`;
+    const prior = newest.get(key);
+    if (prior && prior.stamp > stamp) continue;
+    individuals.set(base, { id: base, label: base, class: cls });
+    newest.set(key, { stamp, predicate: row.predicate, subject: base, object: splitWorldSnapshot(row.object).base });
+  }
+  const groups = new Map();
+  for (const edge of newest.values()) {
+    if (!groups.has(edge.predicate)) groups.set(edge.predicate, { prop: edge.predicate, predicate: edge.predicate, examples: [] });
+    groups.get(edge.predicate).examples.push({ subject: edge.subject, object: edge.object });
+  }
+  return { individuals: [...individuals.values()], objectProperties: [...groups.values()] };
+}
+
 // Matches T5's own bare-object capture (grammar.mjs meta-whatis), reused below to
 // extract the term for the article-insertion fallback rather than duplicating it.
 const BARE_META_WHATIS_RE = /^what\s+(?:is|are)\s+(?:an?\s+)?(.+?)[?.!\s]*$/i;
@@ -4447,6 +4605,16 @@ export function ask(graph, query, { contextId = null, nlp = undefined, prev = nu
       if (!dynRendered.miss) { parsed = dyn; result = dynResult; rendered = dynRendered; relaxed = null; }
     }
   }
+  // World-relation listing ("list the locations of flies and spiders"), on the
+  // same terms: only after an honest miss, and only when it answers for real.
+  if (rendered.miss && !rendered.ambiguous) {
+    const world = worldRelationQuery(graph, query);
+    if (world) {
+      const worldResult = traverse(graph, world, { contextId, prev });
+      const worldRendered = render(world, worldResult, graph);
+      if (!worldRendered.miss) { parsed = world; result = worldResult; rendered = worldRendered; relaxed = null; }
+    }
+  }
   // Bare "what is X" (no article) meta fallback, narrow to ask() and never
   // touching the outer `parsed` even on a miss — chat.mjs's own gates key off
   // `!envelope.parsed`, so populating it here would steal turns from lanes

package/src/domain/game-config.mjs

@@ -143,6 +143,17 @@ export function mudMassDrainPerTurn(mudConfig, characterId) {
   return Number.isFinite(drain) ? drain : 0;
 }
 
+/** The mass denominator a spider-and-fly class's HUD bar and sprite
+ *  expression both scale against — "how full" reads the same on either. `cls`
+ *  is "spider" or "fly"; any other class (an egg, or a class this world adds
+ *  later) has no denominator and gets null, never a guessed number. `config`
+ *  is the page's own `{ maxSpiderMass, maxFlyMass }` pair. Pure. */
+export function massScaleFor(cls, config) {
+  if (cls === "spider") return config?.maxSpiderMass ?? null;
+  if (cls === "fly") return config?.maxFlyMass ?? null;
+  return null;
+}
+
 /**
  * Fold a normalized tmct.toml's `games`/`planning` tables (the raw sparse
  * pass-through src/adapters/toml-config.mjs's normalizeConfig produces —

package/src/domain/mud-facts.mjs

@@ -0,0 +1,15 @@
+// mud-facts.mjs — the one `mgx:is-predator` reader shared across the
+// client/server boundary: mud-turn.mjs (the server-side turn engine, deciding
+// which rooms to route an animal away from) and mud-viz.mjs (the client-facing
+// view, deciding which room to draw a pounce against) each asked "which
+// subject does the world mark dangerous" their own way, over the exact same
+// filter. One reader here, so the two never drift apart on what counts as a
+// predator.
+
+/** Every subject the world marks `mgx:is-predator` true, in fact-row order.
+ *  Pure. */
+export function predatorSubjects(rows) {
+  return (rows || [])
+    .filter((r) => r.predicate === "mgx:is-predator" && r.object === "true")
+    .map((r) => r.subject);
+}

package/src/domain/router/drive.mjs

@@ -31,7 +31,7 @@
 import { resolveOne, backwardChainWorld, resolveMemoryTerm } from "./resolver.mjs";
 import { plan, isMultiStep, decompose, MAX_STEPS } from "./planner.mjs";
 import { goalReason } from "./goal-reasoner.mjs";
-import { capabilities } from "./registry.mjs";
+import { capabilities, preconditionsOf, PRECOND } from "./registry.mjs";
 import { registerTaughtActions } from "./taught.mjs";
 import { intersect, fallbackIfEmpty, guardIfEmpty, memberIndividuals, membersReaching, resultSetOf } from "./results.mjs";
 import { resolveObject } from "../ask.mjs";
@@ -288,23 +288,49 @@ export async function runCapabilityPlan(request, tools, ctx) {
  *  same store, re-reading it per request via ctx.readTaughtStore. The new
  *  registrations' unregister disposers ride the ctx as `ctx.disposers`; the
  *  caller runs them when the ctx is done. The same `memoryDir` also opens
- *  `ctx.resolveMemoryTerm` — resolveOne's binding oracle for a memoryTerm slot
- *  (tmct_related's `term`), re-reading the store's fact rows per request
+ *  `ctx.resolveMemoryTerm` — resolveOne's binding oracle for a KINDS.MemoryTerm
+ *  slot (tmct_related's `term`), re-reading the store's fact rows per request
  *  through resolveMemoryTerm (resolver.mjs), the memory-graph sibling of
- *  `resolve` above. */
+ *  `resolve` above.
+ *
+ *  MEMORY-ONLY MODE: pass a `memoryDir` with no `graph` and no `source`, and
+ *  the ctx builds with no code graph at all — the shape of a page that lives on
+ *  the memory graph alone. `resolve` then misses every term (a code-graph slot
+ *  refuses honestly at binding), dispatch refuses any capability whose
+ *  preconditions need a loaded code graph, and the memory lanes — MemoryTerm
+ *  binding, the taught world-goal simulation — carry the whole ctx. `config`
+ *  (if any) is still handed to dispatchTool so a memory-store tool can derive
+ *  its backend. A call with no graph, no source and no memoryDir is a wiring
+ *  error and throws. */
 export async function buildCapabilityPlanCtx({
-  config, source, tel = null, graph = null, memoryDir = null,
+  config, source = null, tel = null, graph = null, memoryDir = null,
   dispatchTool, isToolError = () => false, selectTool = null,
   loadMemory = null, readFactRows = null, readRuleRows = null,
 } = {}) {
-  const g = graph || parseEntities(await source.fetchEntities(config));
-  const resolve = (term) => resolveObject(g, term);
+  const g = graph || (source ? parseEntities(await source.fetchEntities(config)) : null);
+  if (!g && !(memoryDir && loadMemory)) {
+    throw new Error("buildCapabilityPlanCtx: pass a graph, a source to load one, or a memoryDir (memory-only mode)");
+  }
+  const resolve = g ? (term) => resolveObject(g, term) : () => ({ match: null, ambiguous: false, candidates: [] });
+  const needsCodeGraph = (name) => preconditionsOf(name).some((p) => p.pred === PRECOND.graphLoaded);
   const dispatch = async (name, input) => {
+    if (!g && needsCodeGraph(name)) {
+      return { ok: false, error: `${name} queries the code graph, and this memory-only context has none loaded` };
+    }
     try {
-      const text = await dispatchTool(name, input, { config, source, tel });
+      // `source ?? undefined` so a memory-only caller's explicit null never
+      // suppresses dispatchTool's own default source for a tool that loads.
+      // `memoryBackend` hands a memory-reading tool the SAME open store this
+      // ctx binds its MemoryTerm slots against, so binding and dispatch can
+      // never answer from two different stores — and so a store that was never
+      // derived from a config (a browser page's in-memory one) is reachable at
+      // all.
+      const text = await dispatchTool(name, input, {
+        config, source: source ?? undefined, tel, memoryBackend: memoryDir ?? undefined,
+      });
       const primary = input && (input.symbol ?? input.module ?? input.class ?? input.query);
       const resolved = primary ? resolve(String(primary)).match : null;
-      const result = resultSetOf(g, name, input, resolved);
+      const result = g ? resultSetOf(g, name, input, resolved) : [];
       return { ok: true, text, resolved, result };
     } catch (e) {
       if (isToolError(e)) return { ok: false, error: e.message };

package/src/domain/router/registry.mjs

@@ -26,16 +26,25 @@ export const VOCAB = Object.freeze({
 
 // Parameter entity-KINDS — the seon/mgx classes a slot ranges over. `Query` and
 // `Kind`/`Package` are free-text / enum slots (no graph resolution); the rest
-// name a graph entity the resolver must prove RESOLVES before the call fires.
+// name a graph entity the resolver must prove RESOLVES before the call fires —
+// code-graph kinds through resolveObject (ask.mjs), MemoryTerm through
+// resolveMemoryTerm (resolver.mjs), the conversational-memory sibling oracle.
 export const KINDS = Object.freeze({
   Symbol: "seon:CodeEntity", // any code symbol: function/method/class/module/attribute
   Module: "mgx:Module", // SEON has no JS-module class (its nearest are Namespace/main:File); owned
   Class: "seon:ClassType", // SEON's real class for a class definition
+  MemoryTerm: "mgx:MemoryTerm", // owned: a conversational-memory term (a minted skos:Concept or a world-fact subject/object) — binds in the memory graph, never the code graph
   Query: "cap:FreeText", // lexical search string — no resolution precondition
   Kind: "cap:KindFilter", // enum: function|class|method|… (search filter)
   Package: "cap:PackageName", // optional architecture-scope filter
 });
 
+// The kinds that bind in the conversational-memory graph (resolveMemoryTerm)
+// rather than the code graph (resolveObject). A consumer that walks KINDS for
+// code-graph-resolvable classes (e.g. the synthbench enumerator's focus
+// classes) must exclude these — a memory term is never a code-graph focus.
+export const MEMORY_KINDS = Object.freeze([KINDS.MemoryTerm]);
+
 // Precondition PREDICATE tags (the small closed vocabulary a precondition uses).
 export const PRECOND = Object.freeze({
   graphLoaded: "cap:graph-loaded", // a graph artifact is present + parseable
@@ -87,7 +96,8 @@ function capability({ name, label, question, params = [], preconditions = [], ad
 // callees/tests/history/… take `symbol`; impact/exports take `module`; members/
 // subclasses take `class`; search takes `query` (+ optional kind/name/decorator);
 // architecture takes an optional `package`; untested takes nothing; related
-// takes `term` (a memory-graph concept term).
+// takes `term` (a memory-graph concept term); sprite takes `class` (a memory-graph
+// term) plus optional `expression`/`size`.
 
 const CAPABILITIES = Object.freeze([
   capability({
@@ -187,10 +197,20 @@ const CAPABILITIES = Object.freeze([
   }),
   capability({
     name: "tmct_related", label: "related", question: "a term's synonyms and related concepts (the SKOS view over the conversational-memory graph)",
-    params: [param("term", KINDS.Query, { note: "a concept term, matched against memory relation facts rather than resolved in the code graph" })],
-    preconditions: [memoryFacts()],
+    params: [param("term", KINDS.MemoryTerm, { note: "a concept term, matched against memory relation facts rather than resolved in the code graph" })],
+    preconditions: [memoryFacts(), resolves("term", KINDS.MemoryTerm)],
     add: [knows("related", "term")],
   }),
+  capability({
+    name: "tmct_sprite", label: "sprite", question: "the sprite for a class, with the expression and size asked for",
+    params: [
+      param("class", KINDS.MemoryTerm, { arg: "class", note: "a world class, matched against the memory graph's own fact rows rather than resolved in the code graph" }),
+      param("expression", KINDS.Kind, { required: false, note: "one of sprite-expressions.mjs's palette words, carried as an mgx:feels fact" }),
+      param("size", KINDS.Kind, { required: false, note: "a taught mgx:hasProperty size word, resolved to a render scale — not a template tier" }),
+    ],
+    preconditions: [memoryFacts(), resolves("class", KINDS.MemoryTerm)],
+    add: [knows("sprite", "class")],
+  }),
 ]);
 
 // The live capability set: the built-in frozen array is the seed; registration