@polycode-projects/the-mechanical-code-talker 4.0.0 → 4.1.0

package/src/domain/grammar/ace.mjs

@@ -28,7 +28,7 @@
 
 import {
   loadLexicon, lookupNoun, lookupVerb, lookupAdjective, lookupProperName,
-  predicateOf, numberOf, classify,
+  predicateOf, numberOf, classify, OF_CLASSIFIER_HEADS, OF_PARTITIVE_HEADS,
 } from "./lexicon.mjs";
 import { fuzzyMatchInSet } from "../interpret/fuzzy.mjs";
 
@@ -85,7 +85,15 @@ function local(lexicon, term) {
 const stripDet = (tokens) =>
   tokens.length > 1 && DET.has(tokens[0].toLowerCase()) ? tokens.slice(1) : tokens;
 
-/** Resolve a 1–2 word noun phrase: PROPERNAME | code-ref | NOUN | ADJ NOUN.
+/** A token a compound noun phrase may be built out of: a plain word (never a
+ *  code-shaped ref, a number or a CURIE) that is not a DECLARED proper name —
+ *  a name in a compound slot ("GitLab pipeline") is a structural miss, not a
+ *  compound. Shared by both compound arms of resolveNP below. */
+const compoundableWord = (lexicon, token) =>
+  /^[a-z][a-z'-]*$/i.test(token) && !lookupProperName(lexicon, token);
+
+/** Resolve a noun phrase: PROPERNAME | code-ref | NOUN | ADJ NOUN | NOUN NOUN
+ *  | NOUN of NOUN (the last two opt-in, see `allowCompound`).
  *  Returns { term, individual, extras, unknown } — `term` null on a miss with
  *  the undeclared tokens in `unknown` (empty `unknown` = structurally
  *  unparseable phrase → the caller returns a hard null). `extras` carries the
@@ -149,8 +157,7 @@ function resolveNP(lexicon, tokensIn, { allowCompound = false } = {}) {
     // DECLARED proper name in either slot ("GitLab pipeline") keeps the
     // structural miss below — a name in the wrong slot, not a compound.
     if (allowCompound
-      && !lookupProperName(lexicon, tokens[0]) && !lookupProperName(lexicon, tokens[1])
-      && /^[a-z][a-z'-]*$/i.test(tokens[0]) && /^[a-z][a-z'-]*$/i.test(tokens[1])) {
+      && compoundableWord(lexicon, tokens[0]) && compoundableWord(lexicon, tokens[1])) {
       const n0 = lookupNoun(lexicon, tokens[0], { singularOnly: false });
       const n1 = lookupNoun(lexicon, tokens[1], { singularOnly });
       if (n0 && n1) {
@@ -162,6 +169,35 @@ function resolveNP(lexicon, tokensIn, { allowCompound = false } = {}) {
     const unknown = tokens.filter((t) => !classify(t, lexicon));
     return { term: null, individual: false, extras: [], unknown };
   }
+  // "NOUN of NOUN" is ONE compound noun ("unit of work", "chain of command",
+  // "conflict of interest"), joined with its own "of" the same way two plain
+  // nouns are joined with a space, so the taught fact and the query side
+  // unify on one term. Opt-in through the same `allowCompound` gate and the
+  // same compoundableWord shape test as the two-noun arm above; the head noun
+  // leads, so an "a"/"an" agrees with IT.
+  //
+  // Which "of" this claims is decided by the head, against the two closed
+  // of-frame vocabularies in lexicon.mjs — the same ones the fact extractor
+  // reads. A CLASSIFIER head is a rewrite of the inner noun rather than a
+  // compound ("a kind of dog" is a dog), and a PARTITIVE head states quantity
+  // or composition rather than a class ("a piece of cake", "a lot of dogs");
+  // both decline here and land on the miss below. The relational reading is
+  // pattern 7's and is claimed before any of this: parseAce routes "the N of N
+  // is VALUE" to parseOfForm, so "the version of tmct is 0.2.0" never reaches
+  // a copula split at all. An inner determiner is likewise out of the shape —
+  // "a piece of the cake" is four tokens and no compound noun carries one.
+  if (tokens.length === 3 && allowCompound && tokens[1].toLowerCase() === "of"
+    && compoundableWord(lexicon, tokens[0]) && compoundableWord(lexicon, tokens[2])) {
+    const head = tokens[0].toLowerCase();
+    const inner = tokens[2].toLowerCase();
+    if (!OF_CLASSIFIER_HEADS.has(head) && !OF_PARTITIVE_HEADS.has(head)) {
+      const headNoun = lookupNoun(lexicon, head, { singularOnly });
+      const innerNoun = lookupNoun(lexicon, inner, { singularOnly: false });
+      if (headNoun && innerNoun) {
+        return { term: `${ns}${head} of ${inner}`, individual: false, noun: headNoun, extras: [], unknown: [] };
+      }
+    }
+  }
   // 0 or 3+ tokens: not a fragment NP. Name the undeclared words if any.
   return { term: null, individual: false, extras: [], unknown: tokens.filter((t) => !classify(t, lexicon)) };
 }

package/src/domain/grammar/lexicon-core.json

@@ -9448,7 +9448,8 @@
     "danger": {},
     "push": {},
     "refusal": {},
-    "tooling": {}
+    "tooling": {},
+    "trelvox": {}
   },
   "verbs": {
     "import": {},

package/src/domain/grammar/lexicon.mjs

@@ -43,6 +43,24 @@ export const QUANTIFIERS = Object.freeze({
   exactly: "owl:cardinality",
 });
 
+// The two closed head vocabularies that say what an "of" between two nouns is
+// DOING, so every reader of the of-frame decides it the same way instead of
+// each growing its own list. A CLASSIFIER head reads THROUGH to the inner noun
+// — "a kind of dog" is a dog, "a type of mammal" is a mammal — so the phrase
+// is a rewrite of the inner noun, never a term of its own. A PARTITIVE head
+// states quantity or composition — "a piece of cake", "a lot of dogs", "a body
+// of ice" — so the phrase names no class at all. Anything else ("unit of
+// work", "chain of command") is a compound noun the of belongs to.
+/** Of-frame heads that read through to the inner noun. */
+export const OF_CLASSIFIER_HEADS = Object.freeze(new Set([
+  "type", "kind", "sort", "form", "class", "variety", "species", "breed", "genus",
+]));
+/** Of-frame heads that state quantity or composition, not a class. */
+export const OF_PARTITIVE_HEADS = Object.freeze(new Set([
+  "body", "mass", "group", "collection", "set", "series", "number", "amount",
+  "piece", "part", "lot", "pair", "bunch", "pile",
+]));
+
 const NUMBER_WORDS = Object.freeze({
   one: 1, two: 2, three: 3, four: 4, five: 5,
   six: 6, seven: 7, eight: 8, nine: 9, ten: 10,

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/reference-pack.mjs

@@ -35,25 +35,49 @@ export function isReferenceIndexEntry(e) {
     && Number.isInteger(e.r) && e.r > 0;
 }
 
-/** A shard row: {term, title, text, summary, url, revid, isa?}. */
+/** A shard row: {term, title, text, summary, url, revid, isa?, source?,
+ *  licence?}. `source`/`licence` are optional per-entry overrides of the
+ *  citation's source name and licence line (renderReferenceAnswer, below) —
+ *  absent on every real Simple English Wikipedia row the build pipeline
+ *  emits, present only on a hand-added synthetic entry (e.g. a demo/test
+ *  term) whose citation must name its OWN real source, not Wikipedia's. */
 export function isReferenceArticleRow(row) {
   if (!row || typeof row !== "object") return false;
   for (const field of ["term", "title", "text", "summary", "url"]) {
     if (typeof row[field] !== "string" || !row[field]) return false;
   }
   if (!Number.isInteger(row.revid) || row.revid <= 0) return false;
-  if (row.isa !== undefined && (typeof row.isa !== "string" || !row.isa)) return false;
+  for (const field of ["isa", "source", "licence"]) {
+    if (row[field] !== undefined && (typeof row[field] !== "string" || !row[field])) return false;
+  }
   return true;
 }
 
+/** The default citation source/licence — every article the build pipeline
+ *  (scripts/fetch-reference-pack.mjs) emits from the pinned Simple English
+ *  Wikipedia dump carries neither field, so this is what renderReferenceAnswer
+ *  falls back to for the overwhelming majority of rows. */
+export const DEFAULT_REFERENCE_SOURCE = "Simple English Wikipedia";
+export const DEFAULT_REFERENCE_LICENCE = "CC BY-SA 4.0";
+
 /** The cited answer for a clean miss the pack could ground: the article's
- *  summary with its title, licence and revision-pinned URL always visible,
- *  then the grain cue. Without the cue a reader has to recognize the source
- *  name to tell this apart from a fact read out of their own graph — both
- *  answer the same "what is X" question in the same voice. */
+ *  summary with its title, licence and source always visible, then the grain
+ *  cue. Without the cue a reader has to recognize the source name to tell
+ *  this apart from a fact read out of their own graph — both answer the same
+ *  "what is X" question in the same voice.
+ *
+ *  The source/licence line reads the article's OWN `source`/`licence` fields
+ *  when present, falling back to the Wikipedia defaults otherwise — every
+ *  real pack row renders byte-identically to before this existed. Wikipedia's
+ *  revision-pinned `?oldid=` query is a convention of that source alone, so it
+ *  is only appended when the article is citing the default source; a
+ *  non-Wikipedia entry's own `url` is shown bare. */
 export function renderReferenceAnswer(term, article) {
+  const source = article.source ?? DEFAULT_REFERENCE_SOURCE;
+  const licence = article.licence ?? DEFAULT_REFERENCE_LICENCE;
+  const url = source === DEFAULT_REFERENCE_SOURCE ? `${article.url}?oldid=${article.revid}` : article.url;
   return `${term} — ${article.summary} (source: reference article "${article.title}", `
-    + `Simple English Wikipedia, CC BY-SA 4.0 — ${article.url}?oldid=${article.revid})`
+    + `${source}, ${licence} — ${url})`
     + ` ${GENERAL_VOCABULARY_CUE}`;
 }
 

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

package/src/domain/router/resolver.mjs

@@ -11,15 +11,20 @@
 // grammar doesn't carry, and a rescue path when the NL parse selects an out-of-set
 // capability).
 //
-// Entity binding is delegated to `resolveObject` (ask.mjs); an ambiguous or no-match term
-// is an honest refuse, never a guess.
+// Entity binding is delegated to `resolveObject` (ask.mjs) for code-graph slots, and to
+// `resolveMemoryTerm` (below) for a slot whose registry kind is KINDS.MemoryTerm — the
+// conversational-memory graph's own binding oracle. An ambiguous or no-match term is an
+// honest refuse, never a guess, on both paths.
 
 import { parseQuery } from "../ask.mjs";
 import { SUPERLATIVE_EXTREMES } from "../ask-vocab.mjs";
 import { buildSkosConceptView } from "../skos-view.mjs";
+import { normFactTerm } from "../hash.mjs";
 import { edgesOfKind } from "../codegraph.mjs";
+import { EXPRESSION_PALETTE } from "../sprite-expressions.mjs";
+import { sizeScaleFor } from "../sprite-size.mjs";
 import {
-  capabilities, capabilityByName, preconditionsOf, effectsOf, PRECOND,
+  capabilities, capabilityByName, parametersOf, preconditionsOf, effectsOf, PRECOND, KINDS, MEMORY_KINDS,
 } from "./registry.mjs";
 import { hallucinationsIn } from "./call-validator.mjs";
 
@@ -64,6 +69,25 @@ export const UNMAPPED_KINDS = Object.freeze({
 // via resolveMemoryTerm, the memory-graph sibling of resolveObject's code-graph binding.
 export const NOT_NL_REACHABLE = Object.freeze({});
 
+/** The property predicate sprite-size.mjs reads a size word off. Used to PROBE
+ *  its own closed scale table instead of restating it here: a word is a size
+ *  word exactly when it moves the scale away from 1. */
+const SIZE_FACT_PREDICATE = "mgx:hasProperty";
+
+/** The sprite frame's two OPTIONAL slots, read straight out of the request.
+ *  Both vocabularies are the real ones — sprite-expressions.mjs's own palette
+ *  and sprite-size.mjs's own scale table (probed, not copied) — so a word
+ *  either module gains is a word this frame gains. A request naming neither
+ *  fills neither, and the sprite resolves plain. */
+function spriteSlots(request) {
+  const slots = {};
+  for (const word of String(request).toLowerCase().match(/[a-z]+/g) || []) {
+    if (!slots.expression && Object.hasOwn(EXPRESSION_PALETTE, word)) slots.expression = word;
+    if (!slots.size && sizeScaleFor([{ predicate: SIZE_FACT_PREDICATE, object: word }]) !== 1) slots.size = word;
+  }
+  return slots;
+}
+
 // ---- imperative intent FRAMES (fills what the relational grammar and command register
 // both miss). regex -> { topic, arg | noArg }. Ordered: first match wins.
 export const FRAMES = Object.freeze([
@@ -86,10 +110,19 @@ export const FRAMES = Object.freeze([
   { re: /\bsignature\b/i, topic: "signature", arg: "symbol" },
   // tmct_related: the SKOS synonym/related-concept surface over the memory graph
   // — "another word for X" / "a synonym for X" / "synonyms of X" / "what's
-  // related to X". `arg: "term"` is the one memory-graph-bound slot in this
-  // table (see resolveMemoryTerm below); every other frame's arg binds against
-  // the code graph via ctx.resolve.
+  // related to X". Its `term` slot is declared KINDS.MemoryTerm in the registry,
+  // so resolveOne binds it through resolveMemoryTerm (below) rather than the
+  // code graph's resolveObject — the registry kind, not this table, decides.
   { re: /\bsynonyms?\b|\banother\s+word\s+for\b|\brelated\s+(?:words?|concepts?|to)\b/i, topic: "related", arg: "term" },
+  // tmct_sprite: the sprite surface over the memory graph's own world facts —
+  // "the large sprite for a happy spider", "what does a hungry fly look like",
+  // "show me the spider icon". Its `class` slot is the second KINDS.MemoryTerm
+  // one, so it binds the same way tmct_related's `term` does. `slots` is what
+  // makes this frame different: it fills the two OPTIONAL args itself.
+  {
+    re: /\bsprite\b|\bicon\b|\bavatar\b|\bpicture\s+of\b|\bwhat\s+does\s+.+\s+look\s+like\b/i,
+    topic: "sprite", arg: "class", slots: spriteSlots,
+  },
   { re: /\bdescribe\b|\bexplain\b|what\s+is\b|tell\s+me\s+about\b|definition\s+of\b/i, topic: "description", arg: "symbol" },
   { re: /\bsearch\b|\bfind\b|look\s+for\b/i, topic: "matches", arg: "query" },
 ]);
@@ -132,13 +165,17 @@ const STOP = new Set([
   "untested", "blast", "radius", "change", "changes", "changing", "reach", "reaches", "affect", "affects",
   "explain", "edge", "edges", "graph", "outgoing", "site", "sites", "invoke", "invokes", "run", "runs", "execute", "executes",
   "word", "words", "another", "synonym", "synonyms", "related", "relate", "relates", "like", "concept", "concepts",
+  "sprite", "sprites", "icon", "icons", "avatar", "avatars", "picture", "pictures", "image", "images", "looks",
 ]);
 
 /** Pull one entity token from a request (imperative-frame slot-filling). Prefer a
- *  path/dotted/CamelCase token, else the last non-stopword identifier. "" if none. */
-export function extractEntity(request) {
+ *  path/dotted/CamelCase token, else the last non-stopword identifier. "" if none.
+ *  `alreadyBound` holds the words a frame's own slot-filler has already claimed
+ *  (the sprite frame's expression/size), so they can't also be read as the entity. */
+export function extractEntity(request, alreadyBound = null) {
   const tokens = String(request).match(/[A-Za-z_][A-Za-z0-9_./-]*/g) || [];
-  const pool = tokens.filter((t) => !STOP.has(t.toLowerCase()));
+  const claimed = alreadyBound || new Set();
+  const pool = tokens.filter((t) => !STOP.has(t.toLowerCase()) && !claimed.has(t.toLowerCase()));
   const strong = pool.filter((t) => /[./]/.test(t) || /^[A-Z][a-z]/.test(t) || /\.[a-z]+$/.test(t));
   const pick = strong.length ? strong : pool;
   return pick.length ? pick[pick.length - 1] : "";
@@ -187,13 +224,14 @@ export function mapFrame(request) {
     const cap = backwardChain(f.topic);
     if (!cap) continue;
     if (f.noArg) return { name: cap.name, noArg: true, topic: f.topic, source: "frame", why: [`imperative frame => goal (knows ${f.topic})`, `backward-chain => ${cap.name}`] };
-    const term = f.arg === "query" ? searchQuery(request) : extractEntity(request);
-    // memoryTerm: this slot binds against the memory graph's SKOS concept view
-    // (resolveMemoryTerm below), not the code graph resolveObject resolves
-    // every other frame's arg against — "term" is the one param kind this is
-    // true for (tmct_related's own memory-facts-gated param).
+    // A frame's own OPTIONAL slots, filled from the request's vocabulary before
+    // the entity is read, so a word a slot claimed can't also be read as the entity.
+    const slots = f.slots ? f.slots(request) : null;
+    const term = f.arg === "query"
+      ? searchQuery(request)
+      : extractEntity(request, slots ? new Set(Object.values(slots)) : null);
     return {
-      name: cap.name, arg: f.arg, term, topic: f.topic, source: "frame", memoryTerm: f.arg === "term",
+      name: cap.name, arg: f.arg, term, topic: f.topic, source: "frame", slots,
       why: [`imperative frame => goal (knows ${f.topic} ?${f.arg})`, `backward-chain => ${cap.name}`],
     };
   }
@@ -215,24 +253,41 @@ export function commandCapability(request, declaredNames, selectTool) {
   return { name: sel.name, input, source: "command", why: [`command register: "${String(request).trim().split(/\s+/)[0]}" => ${sel.name}`] };
 }
 
-/** Resolve a term against the memory graph's SKOS concept view
- *  (skos-view.mjs's buildSkosConceptView) — the memory-graph sibling of
- *  resolveObject, for a param whose precondition is memory-facts rather than
- *  a code-graph `resolves`. Same `{ match, ambiguous }` shape resolveObject
- *  returns, so resolveOne's generic binding step treats both the same way:
- *  `match.label` is the RAW queried term (not the concept's canonicalised
- *  prefLabel), because tmct_related's own lookup (relatedForTerm) re-derives
- *  the concept from whatever term it's given — the bound call should carry
- *  what the user actually asked about. No code-graph fallback: a term the
- *  store holds no synonym/related facts for is an honest miss, never a guess.
- *  `rows` is a loadMemory+readFactRows payload — the same trust-bearing rows
- *  skosRelatedAnswer (chat.mjs) and tmct_related (the tool handler) read. */
+/** Resolve a term against the conversational-memory graph — the memory-graph
+ *  sibling of resolveObject, for a slot whose registry kind is KINDS.MemoryTerm.
+ *  Two tiers, tried in order, both EXACT after normFactTerm (no fuzzy tier — a
+ *  near-miss is a miss, never a guess):
+ *    1. "memory-concept" — the SKOS concept view (skos-view.mjs) mints a
+ *       concept for the term, i.e. the store holds synonym/related facts for it;
+ *    2. "memory-fact-term" — the term appears as the subject or object of any
+ *       stored fact row (a world-fact term: a room, a game agent, a taught
+ *       individual).
+ *  Same `{ match, ambiguous }` shape resolveObject returns, so resolveOne's
+ *  generic binding step treats both oracles the same way: `match.label` is the
+ *  RAW queried term (not a canonicalised prefLabel), because a memory tool's
+ *  own lookup (e.g. relatedForTerm) re-derives its rows from whatever term it's
+ *  given — the bound call should carry what the user actually asked about. No
+ *  code-graph fallback: a term the store holds no facts for at all is an honest
+ *  miss. `rows` is a loadMemory+readFactRows payload — the same trust-bearing
+ *  rows skosRelatedAnswer (chat.mjs) and the memory tool handlers read. */
 export function resolveMemoryTerm(rows, term) {
   const t = String(term || "").trim();
   if (!t) return { match: null };
   const view = buildSkosConceptView(rows);
-  if (!view.conceptIdForTerm(t)) return { match: null };
-  return { match: { label: t, class: "skos:Concept" }, ambiguous: false, tier: "memory-concept" };
+  if (view.conceptIdForTerm(t)) return { match: { label: t, class: "skos:Concept" }, ambiguous: false, tier: "memory-concept" };
+  const n = normFactTerm(t);
+  if (n && rows.some((r) => normFactTerm(r.subject) === n || normFactTerm(r.object) === n)) {
+    return { match: { label: t, class: KINDS.MemoryTerm }, ambiguous: false, tier: "memory-fact-term" };
+  }
+  return { match: null };
+}
+
+/** True when capability `capName`'s slot with arg key `arg` is declared a
+ *  memory-graph kind (KINDS.MemoryTerm) — the registry-driven switch between
+ *  the two binding oracles: resolveMemoryTerm for memory slots, the code
+ *  graph's resolveObject for everything else. */
+export function isMemoryTermSlot(capName, arg) {
+  return parametersOf(capName).some((p) => p.arg === arg && MEMORY_KINDS.includes(p.kind));
 }
 
 // ---- the full single-call resolver (async — binds + grounds) -----------------
@@ -328,27 +383,29 @@ export async function resolveOne(request, declaredNames, ctx, { execute = true }
   if (!declared.has(pick.name)) return REFUSE(`selected ${pick.name} but it is not in the declared toolset`);
 
   // A command pick already carries a bound input; an NL/frame pick carries a raw term
-  // we bind via resolveObject (code graph) or, for a memoryTerm slot, resolveMemoryTerm
-  // (the memory graph's SKOS concept view) — the two binding oracles never mix on one pick.
+  // we bind via resolveObject (code graph) or, for a KINDS.MemoryTerm slot (the
+  // registry's own declaration, read through isMemoryTermSlot), resolveMemoryTerm —
+  // the two binding oracles never mix on one pick.
   let input = pick.input ? { ...pick.input } : {};
   let resolved = null;
   if (!pick.input && !pick.noArg) {
     const term = String(pick.term || "").trim();
     if (!term) return REFUSE(`the ${pick.topic} intent named no entity to bind`);
-    const r = pick.memoryTerm
+    const memoryBound = isMemoryTermSlot(pick.name, pick.arg);
+    const r = memoryBound
       ? (ctx.resolveMemoryTerm ? await ctx.resolveMemoryTerm(term) : { match: null })
       : (ctx.resolve ? ctx.resolve(term) : { match: { label: term }, ambiguous: false });
     if (!r || !r.match) {
-      return REFUSE(pick.memoryTerm
-        ? `"${term}" has no synonym/related facts in the memory graph (honest miss)`
+      return REFUSE(memoryBound
+        ? `the memory graph holds no facts mentioning "${term}" (honest miss)`
         : `"${term}" does not resolve to any graph entity (honest miss)`);
     }
     // A tied read: either resolveObject's own score-tie (r.ambiguous), or a same-tier
     // candidate the graph's own `tests` edge ties to the match (a source module and
     // its test module — a grain neither side's raw score alone reveals as tied).
-    // resolveMemoryTerm's SKOS concept view has no code-graph tests-edge notion, so the
-    // sibling tie-check only applies on the code-graph resolution path.
-    const sibling = (!pick.memoryTerm && !r.ambiguous)
+    // resolveMemoryTerm's exact-match tiers have no code-graph tests-edge notion, so
+    // the sibling tie-check only applies on the code-graph resolution path.
+    const sibling = (!memoryBound && !r.ambiguous)
       ? (r.candidates || []).find((c) => testModuleTie(ctx.graph, r.match, c))
       : null;
     if (r.ambiguous || sibling) {
@@ -360,10 +417,15 @@ export async function resolveOne(request, declaredNames, ctx, { execute = true }
       return REFUSE(`"${term}" is ambiguous (${pool.map((m) => m.label).join(", ")}) — narrow it`, extra);
     }
     resolved = r.match;
-    input = { [pick.arg]: r.match.label };
-    why = [...why, pick.memoryTerm
-      ? `resolveMemoryTerm: "${term}" mints a memory-graph SKOS concept (tier ${r.tier})`
+    // The frame's own optional slots ride alongside the bound entity — declared
+    // params of the same capability, so hallucinationsIn still validates them.
+    input = { [pick.arg]: r.match.label, ...(pick.slots || {}) };
+    why = [...why, memoryBound
+      ? `resolveMemoryTerm: "${term}" binds in the memory graph (${r.match.class || "?"}, tier ${r.tier})`
       : `resolveObject: "${term}" => ${r.match.label} (${r.match.class || "?"}, tier ${r.tier})`];
+    if (pick.slots && Object.keys(pick.slots).length) {
+      why = [...why, `frame slots bound from the request's own vocabulary: ${Object.entries(pick.slots).map(([k, v]) => `${k}=${v}`).join(", ")}`];
+    }
   }
 
   const call = { name: pick.name, input };