@polycode-projects/the-mechanical-code-talker 1.12.0 → 2.0.2

package/src/{chat.mjs → services/chat.mjs}

@@ -15,48 +15,55 @@
 // ENGINE is imported lazily and failure-tolerated, so a turn never crashes
 // (the one static ask.mjs import, classDisplayName, is a pure formatter).
 // createSession(…) is the SESSION SINK every shell shares (runChat's readline
-// loop, src/tui/app.mjs's Ink shell).
-
-import { join, dirname, resolve } from "node:path";
-import { createWriteStream } from "node:fs";
-import { mkdir, mkdtemp, readFile, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { createInterface } from "node:readline/promises";
-import { spawnSync } from "node:child_process";
-import { dispatchTool, loadGraph } from "./server.mjs";
-import { loadConfig, DEFAULT_GRAPH_REL } from "./config.mjs";
-import { resolveRuntimeConfig } from "./cli-args.mjs";
-import { parseEntities, edgesOfKind, renderAuthorCard, renderAuthorTouches, renderCommitAuthor, resolveSymbol, renderCompare } from "./codegraph.mjs";
-import { classDisplayName } from "./ask.mjs";
-import { SESSIONS_DIR_REL, appendSessionToGraph } from "./sessions.mjs";
-import { uuidv7 } from "./uuid.mjs";
-import { createTelemetry } from "./telemetry.mjs";
-import * as defaultSource from "./source.mjs";
-import { loadTemplates, render as renderTemplate } from "./corpus/templates.mjs";
-import { resolveExtensions, mergedLexiconExtra } from "./extensions.mjs";
-import { rankByBiasThenTrust } from "./memory/bias.mjs";
-import { HAS_A_PREDICATE } from "./memory/core.mjs";
+// loop, src/surfaces/tui/app.mjs's Ink shell).
+
+import { join, dirname } from "node:path";
+import { dispatchTool, loadGraph, TOOLS } from "../tools/server.mjs";
+import { ToolError } from "../adapters/config.mjs";
+import { parseEntities, edgesOfKind, moduleCountOf, renderAuthorCard, renderAuthorTouches, renderCommitAuthor, resolveSymbol, renderCompare } from "../domain/codegraph.mjs";
+import { classDisplayName } from "../domain/ask.mjs";
+import { uuidv7 } from "../adapters/uuid.mjs";
+import * as defaultSource from "../adapters/source.mjs";
+import { loadTemplates, render as renderTemplate } from "../adapters/corpus/templates.mjs";
+import { rankByBiasThenTrust } from "../domain/memory/bias.mjs";
+import { HAS_A_PREDICATE, loadMemory as loadMemoryStore, normFactPredicate, normFactTerm as normFactTermStatic, readFactRows as readStoredFactRows, readRuleRows as readStoredRuleRows } from "../adapters/memory/core.mjs";
+import {
+  CAPABILITY_REPORT_CAP, NEG_CAPABLE_OF_PREDICATE, capabilityBaseRate, capabilityExtension,
+  isNegatedPredicate, negatedPredicate, positivePredicate, resolveCapabilityPolarity,
+} from "../domain/memory/capability.mjs";
 import { finish, beginsWithVowelSound, grammarRules } from "./finish.mjs";
 import { splitSentences } from "./sentences.mjs";
 import {
   VERB_TO_KIND, WHERE_MARKERS, MENTION_MARKERS, ENTITY_TO_TYPE, PASSIVE_PARTICIPLE_TO_KIND,
-  stripTrailingScopeFiller, stripTrailingDiscourseTag, EDGE_NOUN_TO_METRIC, RELATIONS,
-} from "./ask-vocab.mjs";
-import { COUNTERFACTUAL_RE, correctMisspellings, applyPreambleFrames, normalizeQuery, stripFillerWords, escapeRegex, kindNounAnaphoraHint } from "./interpret/normalize.mjs";
-import { fuzzyMatchInSet, fuzzyBound } from "./interpret/fuzzy.mjs";
-import { pickPhrase } from "./answer-variants.mjs";
+  stripTrailingScopeFiller, stripTrailingDiscourseTag, EDGE_NOUN_TO_METRIC, RELATIONS, LIST_TRIGGERS,
+} from "../domain/ask-vocab.mjs";
+import { COUNTERFACTUAL_RE, correctMisspellings, applyPreambleFrames, expandContractions, normalizeQuery, stripFillerWords, escapeRegex, kindNounAnaphoraHint } from "../domain/interpret/normalize.mjs";
+import { setDefaultNlpAdapter } from "../domain/interpret/nlp-registry.mjs";
+import { setConstructionBanks } from "../domain/interpret/strategies/constructions.mjs";
+import { nlpAdapter } from "../adapters/ask-nlp.mjs";
+import { readConstructionFiles } from "../adapters/corpus/construction-banks.mjs";
+import { fuzzyMatchInSet, fuzzyBound } from "../domain/interpret/fuzzy.mjs";
+import { pickPhrase } from "../domain/answer-variants.mjs";
+
+// Composition: the chat surface supplies the domain parser's default lemma/POS
+// adapter (the browser bundle's ask-nlp stub carries no factory, so this is a
+// no-op there and the parser stays adapter-less) and the construction-grammar
+// banks (lazy — the TOML read happens on the first parse that needs them; the
+// bundle's constructions stub ignores the registration entirely).
+setDefaultNlpAdapter(nlpAdapter);
+setConstructionBanks(readConstructionFiles);
 
 // uuidv7 lives in ./uuid.mjs (shared with telemetry + the bench stamp); re-exported
 // here because callers/tests still import it from chat.mjs.
 export { uuidv7 };
 
-/** Where session logs live, relative to the target repo. `.tmct/` is the repo's
- *  one artifact directory (gitignored, machine-local) — flip this single constant
- *  if the operator prefers a different location. */
-export const SESSION_LOG_DIR = ".tmct";
-
-/** The base (no-focus) prompt. With a focus set the shell shows `tmct(label)>`. */
-export const PROMPT = "tmct> ";
+// The session-orchestration cluster (createSession/runChat, the readline shell,
+// the log/sidecar writers, the graph upsert, the first-run seed bootstrap) lives
+// in the session layer so runTurn and the fact engine below stay free of
+// node:fs/child_process/os/readline. Re-exported here (services → services) so
+// every existing import site — bin, tui, server-http, index, tests — keeps
+// importing createSession/runChat/gitToplevel/SESSION_LOG_DIR/PROMPT from chat.mjs.
+export { createSession, runChat, gitToplevel, SESSION_LOG_DIR, PROMPT } from "./chat-session.mjs";
 
 /** dispatchTool("tmct_ask", …) returns the prose answer plus a delimited
  *  machine-readable envelope; the TUI shows the prose only. Reused verbatim
@@ -344,7 +351,16 @@ export function asBareCommand(line) {
   // not part of the search term, and counting it could wrongly reject an
   // otherwise-short query as "too long" ("search for the payment controller"
   // is 4 tokens WITH "for", 3 without).
-  const stripped = (fl === "search" || fl === "find") && restTokRaw[0]?.toLowerCase() === "for";
+  //
+  // "describe about X" takes the same strip for the same reason: "about" is
+  // filler between the command and its symbol, and left in it binds verbatim
+  // ("no entity matching symbol \"about a dog\"") because this path never
+  // reaches describeWrapperAnswer's own "^about " strip. A bare "describe
+  // about" keeps its argument — with nothing after it, "about" is all the user
+  // gave and dropping it would answer a command they didn't type.
+  const strippedFor = (fl === "search" || fl === "find") && restTokRaw[0]?.toLowerCase() === "for";
+  const strippedAbout = fl === "describe" && restTokRaw[0]?.toLowerCase() === "about" && restTokRaw.length > 1;
+  const stripped = strippedFor || strippedAbout;
   const restTok = stripped ? restTokRaw.slice(1) : restTokRaw;
   const rest = restTok.join(" ");
   const effectiveLine = stripped ? `${fl}${rest ? ` ${rest}` : ""}` : trimmed;
@@ -597,7 +613,7 @@ async function answerEdgeCount(graph, query) {
   const ind = graph.byId?.get?.(entity.id);
   if (!ind) return null;
   let degreeMetric;
-  try { ({ degreeMetric } = await import("./ask.mjs")); } catch { return null; }
+  try { ({ degreeMetric } = await import("../domain/ask.mjs")); } catch { return null; }
   const n = degreeMetric(graph, ind, metric);
   return `${n} ${edgeCountNoun(noun, n)}.`;
 }
@@ -615,7 +631,7 @@ async function countFromFacts(graph, memoryDir, query, biasByBundle = {}, cache
   const asked = m[1].toLowerCase();
   if (COUNT_NOUNS[asked]) return null; // a real graph kind — answerCount owns it
   let normFactTerm;
-  try { ({ normFactTerm } = await import("./memory/core.mjs")); } catch { return null; }
+  try { ({ normFactTerm } = await import("../adapters/memory/core.mjs")); } catch { return null; }
   const objVariants = factTermVariants(normFactTerm, asked);
   const isa = (await factRows(memoryDir, cache))
     .filter((f) => ISA_PREDICATES.has(f.predicate) && objVariants.has(f.object));
@@ -643,7 +659,7 @@ async function answerQuantifierRecall(memoryDir, query, biasByBundle = {}, cache
   const asked = m[1].toLowerCase();
   if (COUNT_NOUNS[asked]) return null; // a real graph-countable class — answerCount owns it
   let normFactTerm;
-  try { ({ normFactTerm } = await import("./memory/core.mjs")); } catch { return null; }
+  try { ({ normFactTerm } = await import("../adapters/memory/core.mjs")); } catch { return null; }
   const subjVariants = factTermVariants(normFactTerm, asked);
   const rows = (await factRows(memoryDir, cache)).filter((f) => ISA_PREDICATES.has(f.predicate) && subjVariants.has(f.subject));
   if (!rows.length) return null; // never heard of this subject at all — let answerCount own the shape
@@ -685,7 +701,7 @@ async function answerMemoryCount(memoryDir, query) {
   }
   if (!cls) return null;
   let loadMemory;
-  try { ({ loadMemory } = await import("./memory/core.mjs")); } catch { return null; }
+  try { ({ loadMemory } = await import("../adapters/memory/core.mjs")); } catch { return null; }
   let mem;
   try { mem = await loadMemory(memoryDir); } catch { return null; }
   const n = (mem.individuals || []).filter((i) => (i.class || "") === cls).length;
@@ -885,7 +901,92 @@ export function isConversational(query) {
   if (IDENTITY_PHRASES.some((re) => re.test(raw))) return true;
   if (aiIdentityMatch(raw)) return true;
   const codeish = looksCodeish(raw, q);
-  return q.split(/\s+/).filter(Boolean).length <= 3 && !codeish;
+  // The catch-all counts words, so a contraction decides the turn on
+  // punctuation alone: "what's on peg-a" counts 3 and gets the orientation
+  // card, "what is on peg-a" counts 4 and gets the answer. Write the
+  // contraction out for the count only.
+  //
+  // The count is the whole reason this is expandContractions and not
+  // normalizeQuery: the fuller pass strips filler, which takes the count DOWN,
+  // and sends "please describe a dog" and "tell me about a dog" to the card
+  // instead. `q` itself is left alone so the GREET/THANKS/OK_ACK membership
+  // above reads the text as typed, and looksCodeish reads `raw`.
+  return expandContractions(q).split(/\s+/).filter(Boolean).length <= 3 && !codeish;
+}
+
+/** The tmct tools dispatchTool can back (the set a tool-emitting caller may use).
+ *  A declared tool outside this set is never emitted — the request falls through
+ *  to a text answer. The COMMANDS map names the richer graph tools; TOOLS names
+ *  the hot catalog. Their union is what dispatchTool serves. */
+const BACKED_TOOLS = new Set([
+  ...TOOLS.map((t) => t.name),
+  ...Object.values(COMMANDS).map((s) => s.tool),
+]);
+
+/**
+ * Decide whether a user turn maps to a DECLARED, dispatch-backed graph-query
+ * tool, and bind its arguments. Deterministic, in-ethos (no NL guessing beyond
+ * the chat surface's own command routing):
+ *
+ *   1. A slash/bare command that names a tmct tool ("describe X", "/callers X",
+ *      "untested") → that tool with its argument bound from the exact arg key the
+ *      dispatchTool switch reads (COMMANDS above). Only when the tool is
+ *      declared by the caller.
+ *   2. Otherwise, a non-conversational structural question → tmct_ask{query:…},
+ *      when tmct_ask is declared. Small-talk (isConversational) never emits a
+ *      call — it falls through to a text answer.
+ *
+ * Returns { name, input } or null (→ answer as text).
+ */
+export function selectTool(text, declaredNames) {
+  const t = String(text || "").trim();
+  if (!t) return null;
+
+  // 1. explicit command form → a specific tool, argument bound
+  const cmdLine = t.startsWith("/") ? t : asBareCommand(t);
+  if (cmdLine) {
+    const [first, ...restTok] = cmdLine.replace(/^\//, "").split(/\s+/);
+    const spec = COMMANDS[String(first).toLowerCase()];
+    if (spec && declaredNames.has(spec.tool) && BACKED_TOOLS.has(spec.tool)) {
+      const input = {};
+      if (spec.arg) {
+        const val = restTok.join(" ").trim();
+        if (val) input[spec.arg] = val;
+        // an entity command with no argument can't bind a call — fall through
+        else if (!spec.optional) return askFallback(t, declaredNames);
+      }
+      return { name: spec.tool, input };
+    }
+  }
+
+  // 2. structural question → tmct_ask, unless it's small-talk
+  return askFallback(t, declaredNames);
+}
+
+/** The tmct_ask fallback: emit tmct_ask{query} for a non-conversational line when
+ *  the caller declared tmct_ask; otherwise null (→ text answer). */
+function askFallback(text, declaredNames) {
+  if (declaredNames.has("tmct_ask") && BACKED_TOOLS.has("tmct_ask") && !isConversational(text)) {
+    return { name: "tmct_ask", input: { query: text } };
+  }
+  return null;
+}
+
+/** The live tool-layer dependencies buildCapabilityPlanCtx (router/drive.mjs)
+ *  needs injected: the real dispatchTool, the ToolError classifier, the command
+ *  register, and the memory-store readers the taught world-goal lane reloads
+ *  per request. The router itself stays pure; every caller that wants the real
+ *  tool layer spreads these into its ctx build. */
+export function capabilityPlanDeps() {
+  return {
+    source: defaultSource,
+    dispatchTool,
+    isToolError: (e) => e instanceof ToolError,
+    selectTool,
+    loadMemory: loadMemoryStore,
+    readFactRows: readStoredFactRows,
+    readRuleRows: readStoredRuleRows,
+  };
 }
 
 /** Scoped exemption for the bare-meta-fact lane (2b/2c, further down this file)
@@ -907,6 +1008,25 @@ function isBareCamelCaseMetaQuestion(query) {
   return BARE_WHATIS_RE.test(raw) || IS_ADJECTIVE_YESNO_RE.test(raw);
 }
 
+/** The same scoped exemption for the WRAPPERLESS form, lane (2c) only: a bare
+ *  "TaskController" typed on its own. isBareCamelCaseMetaQuestion above needs a
+ *  "what is X" / "is X <adjective>" wrapper, so a bare CamelCase name still
+ *  stops at looksCodeish()'s `/[a-z][A-Z]/` branch while its lowercase twin
+ *  ("task") reaches the lane and answers.
+ *
+ *  A single unbroken word is the whole shape (2c looks the raw line up as a
+ *  label), and that shape is what keeps the exemption at the CamelCase reason
+ *  and nothing else: a path, a dotted ref, a `()` call or any multi-word
+ *  near-miss structural question ("what is import") can't be one bare word, and
+ *  every STRUCT_WORDS member is lowercase, so the CamelCase requirement leaves
+ *  them all where they are. Lane (2c) still only diverts on a real, unique
+ *  graph hit — an unknown CamelCase word answers exactly as it does now. */
+function isBareCamelCaseEntityName(query) {
+  const raw = String(query).trim();
+  if (!/^[A-Za-z][A-Za-z0-9]*$/.test(raw)) return false;
+  return /[a-z][A-Z]/.test(raw);
+}
+
 // ---- the response-template library (W1: templates → render path) ----
 // The WORDING of the conversational/orientation surfaces lives in
 // data/templates/responses.jsonl (corpus/templates.mjs) — the template library is
@@ -1358,13 +1478,7 @@ function conversationalTurn(line, ctx) {
 // gated and (for the lanes) only consulted on a would-miss, so ordinary graph
 // queries are never hijacked. ----
 
-/** Code entities (Modules) in the loaded graph — the "is there a code graph here"
- *  test. 0 means a graph-less bootstrap OR a graph.json with no code entities (the
- *  degenerate trap); both orient rather than over-promise. */
-export function moduleCountOf(graph) {
-  if (!graph || !Array.isArray(graph.individuals)) return 0;
-  return graph.individuals.filter((i) => (i.class || "") === "Module").length;
-}
+export { moduleCountOf };
 
 /** A KNOWN-empty code graph: a loaded graph object with 0 modules. A null graph
  *  (a bare runTurn that wasn't handed one) is "unknown", NOT empty — the empty
@@ -1589,7 +1703,7 @@ async function hasMidSentenceInterrogative(text) {
   }
   if (!whIdx.length) return false;
   try {
-    const { nlpAdapter } = await import("./ask-nlp.mjs");
+    const { nlpAdapter } = await import("../adapters/ask-nlp.mjs");
     const adapter = nlpAdapter();
     if (!adapter) return false; // no wink — no signal, never a false positive
     const tags = adapter.posTags(words);
@@ -1799,7 +1913,7 @@ const FILTER_RULE_TEACH_RE =
  *  independently captured and need not be identical to each other — only
  *  `m[1]`'s OWN name must recur at the end). Query side is a genuine
  *  KIND-CHANGE (reachability-SET enumeration via `findReachableSet`,
- *  src/planning.mjs) from the single-target search above — see the
+ *  src/domain/planning.mjs) from the single-target search above — see the
  *  RECURSIVE_LIST_ASK_RE query recognizer, below. */
 const RECURSIVE_RULE_TEACH_RE =
   /^an?\s+([a-z][\w-]*)\s+(?:is|are)\s+an?\s+([a-z][\w-]*),?\s+or\s+an?\s+([a-z][\w-]*)\s+of\s+an?\s+\1[.!?]*$/i;
@@ -1807,7 +1921,7 @@ const RECURSIVE_RULE_TEACH_RE =
 /** ACTION-RULE TEACH FRAMES — a world-mutating action taught one sentence at
  *  a time, each sentence its own Rule individual (kind action-signature /
  *  action-precond / action-effect / action-constraint) sharing one rule name ("<verb> <prep>",
- *  e.g. "move onto"). src/domain.mjs collects the family by name
+ *  e.g. "move onto"). src/domain/domain.mjs collects the family by name
  *  (findRulesByName) and grounds it over class members at plan time; nothing
  *  in the teach lane executes an action. Predicate slot values are stored
  *  BARE ("rest-on") because normFactTerm strips a mgx: prefix from slot
@@ -1830,7 +1944,7 @@ const ACTION_EFFECT_TEACH_RE = new RegExp(
  *  without the farmer" — the co-location CONSTRAINT sentence (kind
  *  action-constraint): after a move, <left> and <right> may not share a
  *  position unless <guard> is there too. All three trailing words name a
- *  class whose sole member src/domain.mjs binds at plan time. Disjoint from
+ *  class whose sole member src/domain/domain.mjs binds at plan time. Disjoint from
  *  the two precondition frames above by anchor phrase alone ("may not be
  *  with … without", never "nothing may" or "must be … than") — PREP_SRC has
  *  no "without", so the preposition captures can't collide either. */
@@ -1850,12 +1964,37 @@ const BARE_KINDOF_TEACH_RE = /^an?\s+([a-z][\w-]+)\s+is\s+a\s+kind\s+of\s+(?:an?
 async function verbLemma(word) {
   const w = String(word || "").toLowerCase();
   try {
-    const { proseLemma } = await import("./prose-nlp.mjs");
+    const { proseLemma } = await import("../adapters/prose-nlp.mjs");
     const lemma = proseLemma();
     return lemma ? lemma(w) : w;
   } catch { return w; }
 }
 
+/** Did the keyword strategy's edit-distance tier repair an INFLECTION of the
+ *  verb the user typed, or swap the verb for a different one?
+ *
+ *  Both come out of the same one-edit rewrite, but they are not the same
+ *  event. "used" -> "uses" and "imported" -> "imports" are the vocabulary's own
+ *  verb wearing a form the phrase list doesn't happen to spell out, so the
+ *  repaired sentence still asks what was typed. "rest" -> "test" and "during"
+ *  -> "using" are different verbs, so the repaired sentence asks something
+ *  else. A shared lemma separates the two: it holds for every inflection of one
+ *  verb and for no pair of distinct ones.
+ *
+ *  Wink's lemmatiser is the same optional adapter generalVerbPredicate mints
+ *  through. Without it there is no signal, so this reports false and the caller
+ *  declines — the conservative direction, matching every other optional-adapter
+ *  path here. */
+async function repairSharesLemma(from, to) {
+  const [a, b] = [String(from || "").toLowerCase(), String(to || "").toLowerCase()];
+  if (a === b) return true;
+  try {
+    const { proseLemma } = await import("../adapters/prose-nlp.mjs");
+    const lemma = proseLemma();
+    return lemma ? lemma(a) === lemma(b) : false;
+  } catch { return false; }
+}
+
 /** Pre-ask declarative taxonomy teaches. Checked BEFORE the ask engine: "a
  *  disk is a kind of game piece." otherwise parses as an inherits QUESTION
  *  and dies on term resolution, even though an article-led declarative with
@@ -1901,6 +2040,17 @@ const GOAL_TEACH_RE = new RegExp(
 // so the normalization is disclosed.
 const GOAL_TEACH_INFINITIVE_RE = new RegExp(
   `^(?:the\\s+goal\\s+is\\s+for|i\\s+want)\\s+(?:(every|each|all)\\s+)?([\\w-]+)\\s+to\\s+([a-z]+)\\s+(${PREP_SRC})\\s+([\\w-]+)[.!?]*$`, "i");
+// The verbless voicing of the same goal ("i want every disk on peg-b"): the
+// verb the other two voicings spell out is simply absent. Captures 1, 2, 4 and
+// 5 of the frames above, minus the verb — planLaneAnswer reads that off the
+// taught locative facts, and declines when they don't name exactly one.
+const GOAL_TEACH_VERBLESS_RE = new RegExp(
+  `^(?:the\\s+goal\\s+is\\s+for|i\\s+want)\\s+(?:(every|each|all)\\s+)?([\\w-]+)\\s+(${PREP_SRC})\\s+([\\w-]+)[.!?]*$`, "i");
+// The question mirror of the two action-signature teach frames ("can you move a
+// disk onto a peg?"). Both taught voicings mint ONE rule name (verb lemma +
+// preposition), so this one reader answers either.
+const ACTION_SIGNATURE_ASK_RE = new RegExp(
+  `^(?:can|could)\\s+you\\s+([a-z]+)\\s+an?\\s+([a-z][\\w-]*)\\s+(${PREP_SRC})\\s+an?\\s+([a-z][\\w-]*)[?.!]*$`, "i");
 const PLAN_SOLVE_RE = /^(?:solve\s+it|plan\s+the\s+moves|how\s+do\s+i\s+get(?:\s+from\s+here)?\s+to\s+the\s+goal)[?.!\s]*$/i;
 const LEGAL_MOVES_RE = /^what\s+moves\s+are\s+legal(?:\s+now)?[?.!\s]*$/i;
 const PLAN_NEXT_RE = /^(?:next|next\s+move|go\s+on|continue)[.!?\s]*$/i;
@@ -1930,7 +2080,7 @@ const teachProvenanceTag = (sessionId, ts) => `teach:chat${sessionId ? `:${sessi
  *  teach-miss text stands), never a crash. */
 async function teachFact(memoryDir, sessionId, { subject, predicate, object, quantifier = "" }) {
   try {
-    const { appendFact, normFactTerm } = await import("./memory/core.mjs");
+    const { appendFact, normFactTerm } = await import("../adapters/memory/core.mjs");
     const s = normFactTerm(subject);
     const o = normFactTerm(object);
     if (!s || !o) return null;
@@ -2030,7 +2180,7 @@ async function isGroundedByFact(term, memoryDir, cache = null) {
   if (!memoryDir) return false;
   const raw = String(term ?? "").trim();
   if (!raw) return false;
-  const { normFactTerm } = await import("./memory/core.mjs");
+  const { normFactTerm } = await import("../adapters/memory/core.mjs");
   const t = normFactTerm(raw);
   if (!t) return false;
   // TAUGHT-only (same discipline factReadBack's own cax-sco/scm-sco proof
@@ -2059,7 +2209,7 @@ async function isGroundedTerm(term, lex, memoryDir, cache = null) {
   const raw = String(term ?? "").trim();
   if (!raw) return false;
   if (GENERIC_ANCHOR_NOUNS.has(raw.toLowerCase())) return true;
-  const { classify } = await import("./grammar/lexicon.mjs");
+  const { classify } = await import("../domain/grammar/lexicon.mjs");
   if (classify(raw, lex)) return true;
   return isGroundedByFact(raw, memoryDir, cache);
 }
@@ -2089,7 +2239,7 @@ async function ungroundedPairHint(payload, lexicon, memoryDir, cache = null) {
   const m = String(payload).trim().match(UNKNOWN_SUBJECT_RE);
   if (!m) return "";
   const [, , subjectRaw, , objectRaw] = m;
-  const { loadLexicon } = await import("./grammar/lexicon.mjs");
+  const { loadLexicon } = await import("../domain/grammar/lexicon.mjs");
   const lex = lexicon || loadLexicon();
   if (await isGroundedTerm(subjectRaw, lex, memoryDir, cache)) return "";
   if (await isGroundedTerm(objectRaw, lex, memoryDir, cache)) return "";
@@ -2139,7 +2289,7 @@ async function unknownSubjectFallback(payload, { memoryDir, sessionId, lexicon }
   const m = String(payload).trim().match(UNKNOWN_SUBJECT_RE);
   if (!m) return null;
   const [, det, subjectRaw, verb, objectRaw] = m;
-  const { loadLexicon, lookupNoun, lookupAdjective, classify } = await import("./grammar/lexicon.mjs");
+  const { loadLexicon, lookupNoun, lookupAdjective, classify } = await import("../domain/grammar/lexicon.mjs");
   const lex = lexicon || loadLexicon();
   // A known X's own ACE miss is a real miss — never silently reinterpreted here.
   if (classify(subjectRaw, lex)) return null;
@@ -2235,7 +2385,7 @@ async function unknownSubjectFallback(payload, { memoryDir, sessionId, lexicon }
  *  decline) — matching every other optional-adapter path in this file. */
 async function objectReadsAsNonNoun(word) {
   try {
-    const { nlpAdapter } = await import("./ask-nlp.mjs");
+    const { nlpAdapter } = await import("../adapters/ask-nlp.mjs");
     const adapter = nlpAdapter();
     if (!adapter) return false;
     const [tag] = adapter.posTags([String(word || "")]);
@@ -2251,7 +2401,7 @@ async function unknownObjectFallback(payload, { memoryDir, sessionId, lexicon },
   if (!m) return null;
   const [, det, subjectRaw, verb, objectRaw] = m;
   if (!/^(?:every|each|all)$/i.test((det || "").trim())) return null; // class-level mint needs a real universal quantifier
-  const { loadLexicon, lookupNoun } = await import("./grammar/lexicon.mjs");
+  const { loadLexicon, lookupNoun } = await import("../domain/grammar/lexicon.mjs");
   const lex = lexicon || loadLexicon();
   const subjectGrounded = await isGroundedTerm(subjectRaw, lex, memoryDir, cache);
   if (!subjectGrounded) return null; // ungrounded subject isn't this fallback's asymmetry — never a guessed mint
@@ -2342,7 +2492,7 @@ async function unknownAdjectiveFallback(payload, { memoryDir, sessionId, lexicon
   const m = String(payload).trim().match(UNKNOWN_SUBJECT_RE);
   if (!m) return null;
   const [, , subjectRaw, , objectRaw] = m;
-  const { loadLexicon, lookupNoun, classify } = await import("./grammar/lexicon.mjs");
+  const { loadLexicon, lookupNoun, classify } = await import("../domain/grammar/lexicon.mjs");
   const lex = lexicon || loadLexicon();
   // Y already a known NOUN or a fact-grounded CLASS term — a genuine class-
   // membership sentence, unknownSubjectFallback/unknownObjectFallback's own
@@ -2385,8 +2535,37 @@ async function unknownAdjectiveFallback(payload, { memoryDir, sessionId, lexicon
 // A frequency/degree ADVERB commonly sits between a bare-name subject and the
 // real verb ("remember that TaskController usually needs review") — without
 // this skip it would mis-split VERB="usually", minting a nonsense predicate.
-const TEACH_ADVERB_SKIP_SRC = "(?:(?:usually|often|sometimes|rarely|never|always|typically|generally|"
+// Every word here is skippable because dropping it leaves the sentence's claim
+// intact: "usually needs review" and "needs review" assert the same relation at
+// different strengths, and tmct stores no strength. "never" is NOT one of them.
+// It reverses the claim, so skipping it stored the exact opposite of what the
+// sentence said ("tony never eats ribs" -> tony eats ribs) — a truthful teach
+// read back as a confident lie. It belongs to NEG_MARKER_SRC below.
+const TEACH_ADVERB_SKIP_SRC = "(?:(?:usually|often|sometimes|rarely|always|typically|generally|"
   + "occasionally|frequently|normally|regularly|commonly|mostly|currently|still|also|really|actually)\\s+)?";
+/** The negation markers a teach/query frame recognizes, in ONE place so the
+ *  teach side and the query side can never disagree about what negates a
+ *  sentence — the same discipline TEACH_ADVERB_SKIP_SRC is shared under. */
+const NEG_MARKER_SRC = "(?:cannot|can't|can not|does not|doesn't|do not|don't|never)";
+/** Split a leading negation marker off a teach payload, returning the POSITIVE
+ *  twin of the sentence plus the negation flag. Rewriting to the positive and
+ *  re-reading it through the ordinary frames is what keeps polarity out of the
+ *  parser: one recognizer, one predicate mint, one preposition fold, and the
+ *  prefix swaps at the very end (memory/capability.mjs).
+ *
+ *  The can-family rebuilds an explicit "can" so it lands on the SAME
+ *  mgx:capableOf the corpus's own /r/CapableOf data uses; the do-family and
+ *  "never" simply drop out, leaving the bare verb the mint already reads
+ *  ("fred does not eat kale" -> "fred eat kale", "tony never eats ribs" ->
+ *  "tony eats ribs"). */
+const GENERAL_VERB_NEGATION_RE = new RegExp(`^(.+?)\\s+(${NEG_MARKER_SRC})\\s+(.+)$`, "i");
+function splitTeachNegation(payload) {
+  const m = String(payload || "").trim().match(GENERAL_VERB_NEGATION_RE);
+  if (!m) return { payload: String(payload || "").trim(), negated: false };
+  const marker = m[2].toLowerCase();
+  const canFamily = /^can/.test(marker);
+  return { payload: `${m[1]} ${canFamily ? "can " : ""}${m[3]}`.trim(), negated: true };
+}
 const GENERAL_VERB_TEACH_RE = new RegExp(`^([\\w'-]+)\\s+${TEACH_ADVERB_SKIP_SRC}([a-z]+)\\s+(.+?)[.!?]*$`, "i");
 /** Determiners/quantifiers that make the FIRST token an article, not a real
  *  bare-name subject ("every controller…", "the cache…") — GENERAL_VERB_TEACH_RE
@@ -2395,6 +2574,28 @@ const GENERAL_VERB_TEACH_RE = new RegExp(`^([\\w'-]+)\\s+${TEACH_ADVERB_SKIP_SRC
  *  back to the is/are-specific frames above/below (their own territory) or an
  *  honest miss — never a guessed split. */
 const GENERAL_VERB_DETERMINER_RE = /^(?:every|each|all|some|a|an|the|your|my|our|their|his|her|its)$/i;
+/** The determiner-led sentence shape that can be read without guessing a verb
+ *  position: "the small disk rests on the middle disk". The single-token
+ *  subject bound above stands. Rather than lift it, this frame supplies the
+ *  verb-position knowledge it lacks: a closed PREP_SRC preposition must sit
+ *  immediately after the verb slot, which pins the verb by construction and so
+ *  lets the subject take a second token safely.
+ *
+ *  The pin does real work. Widen the subject without it (strip the determiner,
+ *  allow a greedy 2-token subject) and sentences that work today garble
+ *  silently. "margo eats ribs daily" binds subject="margo eats", verb="ribs".
+ *  "the small red disk rests on the middle disk" binds subject="small red",
+ *  verb="disk", storing a nonsense mgx:disk fact. No verb-slot gate catches
+ *  that one, because "disk" is not a closed-class word. With the preposition
+ *  pinned, both decline instead.
+ *
+ *  Costs the 3-token subject ("the small red disk …"), which declines. Nothing
+ *  in that sentence says which of its three leading words is the subject's
+ *  head, so a decline is the honest read. */
+const GENERAL_VERB_DETERMINER_TEACH_RE = new RegExp(
+  `^(?:the\\s+|an?\\s+)([\\w'-]+(?:\\s+[\\w'-]+)?)\\s+([a-z]+)\\s+(${PREP_SRC})\\s+(.+?)[.!?]*$`,
+  "i",
+);
 /** Verbs owned by an earlier, more specific recognizer in this lane — is/are
  *  (class-membership/property, above) and owns/maintains (ownership, above).
  *  generalVerbTeach declines outright on these so it can never race a more
@@ -2445,6 +2646,28 @@ const GENERAL_VERB_NOT_A_VERB_RE = new RegExp(
   "i",
 );
 
+/** The same failure family as GENERAL_VERB_NOT_A_VERB_RE just above, one slot
+ *  over: a LISTING IMPERATIVE's own verb sitting in the subject position.
+ *  "list modules in nope" fits GENERAL_VERB_TEACH_RE perfectly — subject
+ *  "list", verb "modules", object "in nope" — and stores a Fact whose
+ *  confirmation ("noted — remembered: list modules in nope") looks like a
+ *  successful teach for a sentence that was a query.
+ *
+ *  A POS gate can't hold this: subjectIsNounOrPropn already runs at the bare-
+ *  sentence call site and wink tags "list" NOUN, exactly as its own docblock
+ *  concedes. So this is a closed table for the same reason that one is —
+ *  seeded from the single-word LIST_TRIGGERS (ask-vocab.mjs), the set the
+ *  listing grammar itself reads, so the two can never disagree about which
+ *  words open a listing.
+ *
+ *  Costs "list contains three items", which becomes a miss. It already misses
+ *  in its natural determiner form ("the list contains three items"), and a
+ *  miss beats a stored garbage fact. */
+const GENERAL_VERB_IMPERATIVE_SUBJECT_RE = new RegExp(
+  `^(?:${LIST_TRIGGERS.filter((t) => !/\s/.test(t)).join("|")})$`,
+  "i",
+);
+
 /** The predicate a general-verb teach payload's VERB maps to. "has"/"have"
  *  special-cases onto the EXISTING mgx:hasA predicate (point 2) — the same
  *  one ConceptNet's own /r/HasA facts already use (FACT_PREDICATE_PHRASES),
@@ -2474,23 +2697,33 @@ async function generalVerbPredicate(verb) {
   // "can a X <verb>" reader finds it (same reasoning as HAS_A above).
   if (v === "can") return "mgx:capableOf";
   try {
-    const { proseLemma } = await import("./prose-nlp.mjs");
+    const { proseLemma } = await import("../adapters/prose-nlp.mjs");
     const lemma = proseLemma();
     const l = lemma ? lemma(v) : v;
     if (l === "have") return HAS_A_PREDICATE;
-    return `mgx:${l}`;
+    return normFactPredicate(`mgx:${l}`);
   } catch {
-    return `mgx:${v}`;
+    return normFactPredicate(`mgx:${v}`);
   }
 }
 
+/** The capability predicate at the polarity a recognized capability surface
+ *  carried: mgx:capableOf, or its mgxneg: twin. Routed through
+ *  generalVerbPredicate's own "can" case rather than naming mgx:capableOf
+ *  again, so every capability write in this file still mints from one place. */
+const capabilityPredicate = async (negated) => {
+  const p = await generalVerbPredicate("can");
+  return negated ? negatedPredicate(p) : p;
+};
+
 /** Recognize + resolve a general-verb teach payload into {subject, predicate,
  *  object}, or null when it doesn't fit the shape / names an excluded verb /
  *  is missing a real subject or object (point 6 — an honest decline, never a
  *  guess). Pure recognition + predicate mapping; the caller (teachLane) does
  *  the actual write via the shared teachFact. */
 async function generalVerbTeach(payload) {
-  const p = String(payload || "").trim();
+  const raw = String(payload || "").trim();
+  const { payload: p, negated } = splitTeachNegation(raw);
   // A genuine declarative assertion never ends in a question mark — "g day
   // mate, you alright?" (Priority 1, above) reaches this function with no
   // leading question-word signal left to catch it (it never matched a
@@ -2500,20 +2733,37 @@ async function generalVerbTeach(payload) {
   if (GENERAL_VERB_ANYWHERE_EXCLUDE_RE.test(p)) return null; // another frame's territory — stand down
   const m = p.match(GENERAL_VERB_TEACH_RE);
   if (!m) return null;
-  const [, subjectRaw, verbRaw, objectRaw] = m;
+  let [, subjectRaw, verbRaw, objectRaw] = m;
+  // A determiner in the subject slot means the single-token subject bound has
+  // bound the article and misread the real subject's second word as the verb
+  // ("the small disk rests on…" gives subject="the", verb="small"). Re-read it
+  // with the preposition pinning the verb; a sentence that frame can't pin
+  // declines here exactly as it always has.
+  if (GENERAL_VERB_DETERMINER_RE.test(subjectRaw)) {
+    const det = p.match(GENERAL_VERB_DETERMINER_TEACH_RE);
+    if (!det) return null; // not a bare-name subject, and no preposition to pin the verb
+    subjectRaw = det[1];
+    verbRaw = det[2];
+    // hand the preposition back to the shared fold below, so the minted
+    // predicate comes from the one place that mints it
+    objectRaw = `${det[3]} ${det[4]}`;
+  }
   const verb = verbRaw.toLowerCase();
   if (GENERAL_VERB_EXCLUDE_RE.test(verb)) return null; // owned by a more specific frame above
   if (GENERAL_VERB_NOT_A_VERB_RE.test(verb)) return null; // a closed-class word can never be the real verb
-  // "cannot" would mint a nonsense mgx:cannot fact whose read-back silently
-  // INVERTS the taught meaning — the vocabulary has no negative-capability
-  // predicate, so an honest decline is the only correct move.
-  if (verb === "cannot") return null;
-  if (GENERAL_VERB_DETERMINER_RE.test(subjectRaw)) return null; // not a bare-name subject
+  if (GENERAL_VERB_IMPERATIVE_SUBJECT_RE.test(subjectRaw)) return null; // an imperative's verb, not a subject
   const subject = subjectRaw.trim();
+  // The preposition folds on the POSITIVE predicate, and only then does the
+  // polarity prefix swap. Negating first would hand the fold an mgxneg: CURIE
+  // its /^mgx:[a-z]+$/ guard rejects, stranding "on water" inside the object of
+  // "a penguin cannot rest on water" — the very bug the fold exists to prevent.
   const folded = foldPrepositionIntoPredicate(await generalVerbPredicate(verb), objectRaw);
-  const object = folded.object.replace(/^an?\s+/i, "").trim();
+  // "the" strips alongside "a"/"an": the read-back side already strips a
+  // leading determiner off the queried term, so leaving it on here stores an
+  // object no question can match.
+  const object = folded.object.replace(/^(?:an?|the)\s+/i, "").trim();
   if (!subject || !object) return null; // no well-formed triple — honest decline (point 6)
-  return { subject, predicate: folded.predicate, object };
+  return { subject, predicate: negated ? negatedPredicate(folded.predicate) : folded.predicate, object };
 }
 
 /** Is `word` a genuine NOUN/PROPN, per wink-nlp's optional POS tagger
@@ -2531,7 +2781,7 @@ async function generalVerbTeach(payload) {
  *  this codebase. */
 async function subjectIsNounOrPropn(word) {
   try {
-    const { nlpAdapter } = await import("./ask-nlp.mjs");
+    const { nlpAdapter } = await import("../adapters/ask-nlp.mjs");
     const adapter = nlpAdapter();
     if (!adapter) return false;
     const [tag] = adapter.posTags([String(word || "")]);
@@ -2572,7 +2822,7 @@ async function matchRelationalVerbTeach(text) {
     if (GENERAL_VERB_DETERMINER_RE.test(head) || GENERAL_VERB_NOT_A_VERB_RE.test(head)) return null;
   }
   try {
-    const { nlpAdapter } = await import("./ask-nlp.mjs");
+    const { nlpAdapter } = await import("../adapters/ask-nlp.mjs");
     const adapter = nlpAdapter();
     if (!adapter) return null;
     const tags = adapter.posTags([...subjWords, verbRaw, ...objWords]);
@@ -2583,7 +2833,7 @@ async function matchRelationalVerbTeach(text) {
   }
   let base = strip;
   try {
-    const { proseLemma } = await import("./prose-nlp.mjs");
+    const { proseLemma } = await import("../adapters/prose-nlp.mjs");
     const lemma = proseLemma();
     if (lemma) {
       const l = lemma(verb);
@@ -2616,7 +2866,7 @@ async function bareTeachWrapperNudgeText(text) {
     if (GENERAL_VERB_DETERMINER_RE.test(head) || GENERAL_VERB_NOT_A_VERB_RE.test(head)) return null;
   }
   try {
-    const { nlpAdapter } = await import("./ask-nlp.mjs");
+    const { nlpAdapter } = await import("../adapters/ask-nlp.mjs");
     const adapter = nlpAdapter();
     if (!adapter) return null;
     const tags = adapter.posTags([subj, verbRaw, obj]);
@@ -2738,15 +2988,23 @@ function matchBareHabitualTeach(text) {
  *  here lets the teach lane's grounded-subject direct write catch a subject
  *  grounded only by a prior taught fact. Same closed verb-slot exclusions as
  *  the habitual shapes; a question lead ("can a wren sing") never reaches
- *  this — every call site is already QUESTION_LEAD-gated. */
+ *  this — every call site is already QUESTION_LEAD-gated.
+ *
+ *  Its NEGATIVE twin rides the same shape and returns `negated`: "a penguin
+ *  cannot fly" is the identical claim about the identical relation with the
+ *  polarity reversed, so reading it anywhere else would give the two surfaces
+ *  two chances to disagree. Only the can-family negates here — this is the
+ *  capability frame, and "penguins never fly" is a habitual surface that lands
+ *  on generalVerbTeach's own split instead. */
+const BARE_CAN_TEACH_RE = /^(?:an?\s+|every\s+|all\s+)?([\w-]+)\s+(can|cannot|can't|can not)\s+([a-z][\w-]*)[.!?]*$/i;
 function matchBareCanTeach(text) {
-  const m = String(text || "").trim().match(/^(?:an?\s+|every\s+|all\s+)?([\w-]+)\s+can\s+([a-z][\w-]*)[.!?]*$/i);
+  const m = String(text || "").trim().match(BARE_CAN_TEACH_RE);
   if (!m) return null;
   const subject = m[1].toLowerCase();
-  const verb = m[2].toLowerCase();
+  const verb = m[3].toLowerCase();
   if (STRUCT_WORDS.has(verb) || HABITUAL_VERB_EXCLUDE.has(verb) || GENERAL_VERB_NOT_A_VERB_RE.test(verb)) return null;
   if (GENERAL_VERB_DETERMINER_RE.test(subject) || GENERAL_VERB_NOT_A_VERB_RE.test(subject)) return null;
-  return { subject, verb };
+  return { subject, verb, negated: m[2].toLowerCase() !== "can" };
 }
 
 /** The "every X is a Y" rewrite of a declarative, for the "did you mean …"
@@ -2775,9 +3033,13 @@ function teachSuggestion(payload) {
 function habitualGroundingHintText(line, habitual) {
   const articleRule = grammarRules().find((r) => r.kind === "article");
   const article = articleRule && beginsWithVowelSound(habitual.subject, articleRule) ? "an" : "a";
+  // the promise must carry the sentence's OWN polarity — promising to remember
+  // that a penguin CAN fly, to someone who just said it cannot, is the same
+  // inversion the negative teach exists to stop, moved into the hint
+  const promise = habitual.negated ? `cannot ${habitual.verb}` : `can ${habitual.verb}`;
   return `I don't know "${habitual.subject}" yet, so I can't store "${line}" as a capability fact. `
     + `Ground it first — say "every ${habitual.subject} is a thing" — then say "${line}" again `
-    + `and I'll remember that ${article} ${habitual.subject} can ${habitual.verb}.`;
+    + `and I'll remember that ${article} ${habitual.subject} ${promise}.`;
 }
 
 /** PRONOUN-SUBJECT GUARD: "remember you are a womble" and the literal "every
@@ -2810,7 +3072,12 @@ function habitualGroundingHintText(line, habitual) {
  *  grammatical category error regardless of the verb — keeping the guard
  *  ahead of every teach recognizer (copula AND general-verb alike) the same
  *  way it already stood ahead of teachSuggestion/unknownSubjectFallback. */
-const TEACH_PRONOUN_RE = /^(?:every\s+|each\s+|all\s+|some\s+|a few\s+|a\s+|an\s+)?(you|i|it|they|he|she|we)\s+\S+/i;
+const TEACH_PRONOUNS = Object.freeze(["you", "i", "it", "they", "he", "she", "we"]);
+const TEACH_PRONOUN_RE = new RegExp(`^(?:every\\s+|each\\s+|all\\s+|some\\s+|a few\\s+|a\\s+|an\\s+)?(${TEACH_PRONOUNS.join("|")})\\s+\\S+`, "i");
+/** The same closed set, read as a whole-word membership test: a pronoun is no
+ *  more a legal fact subject when a reader LIFTS one out of a prior answer than
+ *  when a teach frame offers one. */
+const isTeachPronoun = (s) => TEACH_PRONOUNS.includes(String(s || "").trim().toLowerCase());
 
 /** RETRACTION / NEGATION of an already-taught subClassOf fact: "X is not a Y"
  *  (tolerating the same "kind/type of" infix every other teach shape in this
@@ -2820,7 +3087,7 @@ const TEACH_PRONOUN_RE = /^(?:every\s+|each\s+|all\s+|some\s+|a few\s+|a\s+|an\s
  *  UNKNOWN_SUBJECT_RE's own subject width), never a general negation grammar.
  *  See the RETRACTION block's own comment in teachLane (below) for why a
  *  regex match here is only a TRIGGER, never itself proof a fact existed to
- *  retract — retractSubClassOf (src/syllogise.mjs) is the actual authority. */
+ *  retract — retractSubClassOf (src/domain/syllogise.mjs) is the actual authority. */
 const RETRACT_NOT_A_RE = /^(?:a\s+|an\s+)?([\w-]+(?:\s+[\w-]+)?)\s+(?:(?:is|are)\s+not|isn't|aren't)\s+(?:an?\s+)?(?:(?:kind|type)\s+of\s+)?([\w-]+)$/i;
 /** "forget (that) X is a Y" — the second closed retraction phrasing. Never
  *  wrapped by TEACH_RE ("forget" isn't one of its
@@ -2881,8 +3148,26 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
   // keeping recognition exactly as closed as the shapes it's equivalent to.
   const stripPossessiveNamedInstance = (s) =>
     (s == null ? s : s.replace(/^my\s+[a-z][\w-]*\s+([\w'-]+\s+(?:is|are)\s+.+)$/i, "$1"));
-  const raw = stripKindOf(stripYour(stripPossessiveNamedInstance(rawInput)));
-  const wrapped = stripKindOf(stripYour(stripPossessiveNamedInstance(wrappedInput)));
+  // "disk-2's bigger than disk-1" — the contracted copula. Written out it is
+  // the comparative frame's own sentence ("disk-2 is bigger than disk-1"), but
+  // contracted the "is" is invisible: GENERAL_VERB_ANYWHERE_EXCLUDE_RE can't
+  // see the copula it would have stood down for, so the general-verb frame
+  // takes the sentence first and mints a nonsense mgx:big fact reading back
+  // "disk-2's bigs than disk-1". Expanding it here, alongside the other
+  // surface rewrites, puts the sentence in front of the frame that owns it.
+  //
+  // The lookahead needs BOTH a comparative AND "than", and that pairing is the
+  // whole guard. A comparative alone is not a discriminator: COMPARATIVE_SRC's
+  // "[a-z]+er" matches father, mother, brother, sister and owner, so an
+  // expansion anchored on it turns "ahab is john's father" into "ahab is john
+  // is father" and destroys both genitive frames. Their role slot is a bare
+  // noun that ends the sentence, so it can never be followed by "than".
+  const expandComparativeContraction = (s) => (s == null ? s : s.replace(
+    new RegExp(`\\b([\\w-]+)'s(?=\\s+${COMPARATIVE_SRC}\\s+than\\b)`, "i"), "$1 is",
+  ));
+  const surfaces = (s) => expandComparativeContraction(stripKindOf(stripYour(stripPossessiveNamedInstance(s))));
+  const raw = surfaces(rawInput);
+  const wrapped = surfaces(wrappedInput);
 
   // CONJUNCTION PRE-PASS — "ahab is male and is the father of john": two
   // facts about ONE subject stated in one sentence. Split at the top-level
@@ -2981,7 +3266,7 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
   }
 
   // RETRACTION — "X is not a Y" / "forget that X is a Y": wires the
-  // data-layer retraction primitive (retractSubClassOf, src/syllogise.mjs) up
+  // data-layer retraction primitive (retractSubClassOf, src/domain/syllogise.mjs) up
   // to chat-level phrasing. Tried here, right after the pronoun guard, so a
   // pronoun subject ("it is not an animal") still falls to that
   // guard's own decline first (TEACH_PRONOUN_RE matches ANY verb after the
@@ -3017,8 +3302,11 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
   if (retractMatch) {
     const retractSubject = retractMatch[1].trim();
     const retractObject = retractMatch[2].trim();
-    const { retractSubClassOf } = await import("./syllogise.mjs");
-    const result = await retractSubClassOf(memoryDir, retractSubject, retractObject);
+    const { retractSubClassOf } = await import("../domain/syllogise.mjs");
+    const { loadMemory: loadMemForRetract, readFactRows: readRowsForRetract, removeFacts } = await import("../adapters/memory/core.mjs");
+    const result = await retractSubClassOf(memoryDir, retractSubject, retractObject, {
+      store: { loadMemory: loadMemForRetract, readFactRows: readRowsForRetract, removeFacts },
+    });
     if (result.found) {
       const extra = result.count - 1; // beyond the target fact itself
       return {
@@ -3147,7 +3435,7 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
   const compose2 = ownSrc.match(COMPOSE2_RULE_TEACH_RE);
   if (compose2 && memoryDir && !QUESTION_LEAD_RE.test(ownSrc) && !ownSrcMidQuestion) {
     try {
-      const { appendRule, RULE_KIND_COMPOSE2 } = await import("./memory/core.mjs");
+      const { appendRule, RULE_KIND_COMPOSE2 } = await import("../adapters/memory/core.mjs");
       const { id } = await appendRule(memoryDir, {
         name: compose2[1],
         kind: RULE_KIND_COMPOSE2,
@@ -3172,7 +3460,7 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
   const filterRule = ownSrc.match(FILTER_RULE_TEACH_RE);
   if (filterRule && memoryDir && !QUESTION_LEAD_RE.test(ownSrc) && !ownSrcMidQuestion) {
     try {
-      const { appendRule, RULE_KIND_FILTER } = await import("./memory/core.mjs");
+      const { appendRule, RULE_KIND_FILTER } = await import("../adapters/memory/core.mjs");
       const { id } = await appendRule(memoryDir, {
         name: filterRule[1],
         kind: RULE_KIND_FILTER,
@@ -3201,7 +3489,7 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
   const recursiveRule = ownSrc.match(RECURSIVE_RULE_TEACH_RE);
   if (recursiveRule && memoryDir && !QUESTION_LEAD_RE.test(ownSrc) && !ownSrcMidQuestion) {
     try {
-      const { appendRule, RULE_KIND_RECURSIVE } = await import("./memory/core.mjs");
+      const { appendRule, RULE_KIND_RECURSIVE } = await import("../adapters/memory/core.mjs");
       const { id } = await appendRule(memoryDir, {
         name: recursiveRule[1],
         kind: RULE_KIND_RECURSIVE,
@@ -3237,7 +3525,7 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
     try {
       const verb = await actionLemma(actionSig[1]);
       const prep = actionSig[3].toLowerCase();
-      const { appendRule, RULE_KIND_ACTION_SIGNATURE } = await import("./memory/core.mjs");
+      const { appendRule, RULE_KIND_ACTION_SIGNATURE } = await import("../adapters/memory/core.mjs");
       const { id } = await appendRule(memoryDir, {
         name: `${verb} ${prep}`,
         kind: RULE_KIND_ACTION_SIGNATURE,
@@ -3262,7 +3550,7 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
     if (verb !== participle && participle.startsWith(verb.slice(0, Math.min(3, verb.length)))) {
       try {
         const prep = actionSigPassive[3].toLowerCase();
-        const { appendRule, RULE_KIND_ACTION_SIGNATURE } = await import("./memory/core.mjs");
+        const { appendRule, RULE_KIND_ACTION_SIGNATURE } = await import("../adapters/memory/core.mjs");
         const { id } = await appendRule(memoryDir, {
           name: `${verb} ${prep}`,
           kind: RULE_KIND_ACTION_SIGNATURE,
@@ -3293,7 +3581,7 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
       const prep = precondNothing[3].toLowerCase();
       const innerVerb = await actionLemma(precondNothing[5]);
       const scopeWord = precondNothing[4].toLowerCase();
-      const { appendRule, RULE_KIND_ACTION_PRECOND } = await import("./memory/core.mjs");
+      const { appendRule, RULE_KIND_ACTION_PRECOND } = await import("../adapters/memory/core.mjs");
       const { id } = await appendRule(memoryDir, {
         name: `${verb} ${prep}`,
         kind: RULE_KIND_ACTION_PRECOND,
@@ -3331,7 +3619,7 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
       const verb = await actionLemma(precondComp[1]);
       const prep = precondComp[3].toLowerCase();
       const scopeWord = precondComp[4].toLowerCase();
-      const { appendRule, RULE_KIND_ACTION_PRECOND } = await import("./memory/core.mjs");
+      const { appendRule, RULE_KIND_ACTION_PRECOND } = await import("../adapters/memory/core.mjs");
       const { id } = await appendRule(memoryDir, {
         name: `${verb} ${prep}`,
         kind: RULE_KIND_ACTION_PRECOND,
@@ -3357,7 +3645,7 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
     try {
       const verb = await actionLemma(actionConstraint[1]);
       const prep = actionConstraint[3].toLowerCase();
-      const { appendRule, RULE_KIND_ACTION_CONSTRAINT } = await import("./memory/core.mjs");
+      const { appendRule, RULE_KIND_ACTION_CONSTRAINT } = await import("../adapters/memory/core.mjs");
       const { id } = await appendRule(memoryDir, {
         name: `${verb} ${prep}`,
         kind: RULE_KIND_ACTION_CONSTRAINT,
@@ -3398,7 +3686,7 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
     // A subject word naming neither the subject class nor "target" is
     // CLASS-BOUND: a companion that travels with every move ("ferrying a
     // passenger onto a bank makes the FARMER stand on the target"). Stored as
-    // the bare class word; compileDomain (src/domain.mjs) requires the class
+    // the bare class word; compileDomain (src/domain/domain.mjs) requires the class
     // to have exactly one member at plan time, so a typo'd word fails loudly
     // there rather than silently minting a role here.
     const subjectRole = namedSubjectRole ?? subjectWord.toLowerCase();
@@ -3412,7 +3700,7 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
     try {
       const prep = actionEffect[3].toLowerCase();
       const effVerb = await actionLemma(actionEffect[6]);
-      const { appendRule, RULE_KIND_ACTION_EFFECT } = await import("./memory/core.mjs");
+      const { appendRule, RULE_KIND_ACTION_EFFECT } = await import("../adapters/memory/core.mjs");
       const { id } = await appendRule(memoryDir, {
         name: `${verb} ${prep}`,
         kind: RULE_KIND_ACTION_EFFECT,
@@ -3461,7 +3749,7 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
     const quantifier = someMatch[1].toLowerCase();
     const subject = singularizeSurface(someMatch[2]);
     const object = singularizeSurface(someMatch[3]);
-    const { loadLexicon, lookupNoun } = await import("./grammar/lexicon.mjs");
+    const { loadLexicon, lookupNoun } = await import("../domain/grammar/lexicon.mjs");
     const lex = lexicon || loadLexicon();
     if (lookupNoun(lex, object)) {
       const stored = await teachFact(memoryDir, sessionId, {
@@ -3528,7 +3816,13 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
     // (wink's honest fallback for any unrecognized token, not a real signal),
     // which would otherwise mis-store it as a fact instead of leaving it for
     // the structural grammar's own typo-tolerant retry to answer for real.
-    const subjectWord = raw.match(/^([\w'-]+)/)?.[1];
+    // A determiner-led sentence opens with the article, which never POS-tags as
+    // a noun, so the first word is the wrong word to gate on. When the
+    // pinned-preposition frame can identify a real subject, POS-check the head
+    // of THAT subject — the same word generalVerbTeach will store — and leave
+    // every other sentence reading its first word exactly as before.
+    const detLed = raw.match(GENERAL_VERB_DETERMINER_TEACH_RE);
+    const subjectWord = detLed ? detLed[1].split(/\s+/).pop() : raw.match(/^([\w'-]+)/)?.[1];
     if (subjectWord && (await subjectIsNounOrPropn(subjectWord))) {
       // A PLURAL explicit-capability surface ("wrens can hum") whose
       // SINGULAR is a grounded term stores under the singular first — the
@@ -3540,10 +3834,10 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
       const canSingular = canShape ? singularizeSurface(canShape.subject) : null;
       if (canShape && canSingular !== canShape.subject) {
         let canLex = lexicon;
-        if (!canLex) { const { loadLexicon } = await import("./grammar/lexicon.mjs"); canLex = loadLexicon(); }
+        if (!canLex) { const { loadLexicon } = await import("../domain/grammar/lexicon.mjs"); canLex = loadLexicon(); }
         if (await isGroundedTerm(canSingular, canLex, memoryDir, cache)) {
           const stored = await teachFact(memoryDir, sessionId, {
-            subject: canSingular, predicate: await generalVerbPredicate("can"), object: canShape.verb,
+            subject: canSingular, predicate: await capabilityPredicate(canShape.negated), object: canShape.verb,
           });
           if (stored) return stored;
         }
@@ -3608,7 +3902,7 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
     const habitualTeach = matchBareHabitualTeach(payload) || matchBareCanTeach(payload);
     if (habitualTeach) {
       let habLex = lexicon;
-      if (!habLex) { const { loadLexicon } = await import("./grammar/lexicon.mjs"); habLex = loadLexicon(); }
+      if (!habLex) { const { loadLexicon } = await import("../domain/grammar/lexicon.mjs"); habLex = loadLexicon(); }
       // The singular is preferred so an explicit plural surface ("penguins
       // can swim") stores under the same spelling the grounding fact (and
       // every query-side variant fold) uses; a proper noun that only looks
@@ -3616,7 +3910,7 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
       for (const subj of new Set([singularizeSurface(habitualTeach.subject), habitualTeach.subject])) {
         if (await isGroundedTerm(subj, habLex, memoryDir, cache)) {
           const stored = await teachFact(memoryDir, sessionId, {
-            subject: subj, predicate: await generalVerbPredicate("can"), object: habitualTeach.verb,
+            subject: subj, predicate: await capabilityPredicate(habitualTeach.negated), object: habitualTeach.verb,
           });
           if (stored) return stored;
         }
@@ -3686,9 +3980,9 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
   let unknown = [];
   if (memoryDir) {
     try {
-      const { parseAce } = await import("./grammar/ace.mjs");
+      const { parseAce } = await import("../domain/grammar/ace.mjs");
       let lex = lexicon;
-      if (!lex) { const { loadLexicon } = await import("./grammar/lexicon.mjs"); lex = loadLexicon(); }
+      if (!lex) { const { loadLexicon } = await import("../domain/grammar/lexicon.mjs"); lex = loadLexicon(); }
       for (const cand of assertCandidates(payload)) {
         const parse = parseAce(cand, lex);
         if (parse?.residue?.length) { unknown = [...new Set(parse.residue.map((w) => String(w).toLowerCase()))]; break; }
@@ -4168,7 +4462,7 @@ async function presuppositionNudge(query, { graph, memoryDir }) {
     let propHit = null;
     if (memoryDir) {
       let normFactTerm;
-      try { ({ normFactTerm } = await import("./memory/core.mjs")); } catch { normFactTerm = null; }
+      try { ({ normFactTerm } = await import("../adapters/memory/core.mjs")); } catch { normFactTerm = null; }
       if (normFactTerm) {
         const facts = await memoryFacts(memoryDir);
         const subjMatches = (f) => normFactTerm(f.subject) === normFactTerm(entityTerm);
@@ -4211,18 +4505,6 @@ const ORIENTATION_REPEAT_ONELINER = "still the same overview — /help lists eve
  *  independent repeat-suppression sites can never be confused with one another. */
 const META_ORIENT_REPEAT_ONELINER = "still the same overview — /stats for the full one, /help for commands.";
 
-// ---- repo-root resolution: default the target to the GIT ROOT, not raw cwd ----
-
-/** The git top-level for `cwd`, or null if not in a repo (or git is unavailable).
- *  Injected into runChat so tests exercise repo resolution without a real git tree. */
-export function gitToplevel(cwd = process.cwd()) {
-  try {
-    const r = spawnSync("git", ["rev-parse", "--show-toplevel"], { cwd, encoding: "utf8" });
-    if (r.status === 0) { const p = String(r.stdout || "").trim(); return p || null; }
-  } catch { /* git missing / not a repo — fall back to cwd */ }
-  return null;
-}
-
 /** Resolve a free-text term to a single graph entity via the ask engine's own
  *  tiered resolver — {id,label} on a UNIQUE hit, null on a miss/ambiguity/no graph.
  *  Lazy + failure-tolerated (see the file docblock): the worst case is a turn that
@@ -4234,7 +4516,7 @@ export function gitToplevel(cwd = process.cwd()) {
 async function resolveEntity(graph, term) {
   if (!graph || !term) return null;
   try {
-    const { resolveObject } = await import("./ask.mjs");
+    const { resolveObject } = await import("../domain/ask.mjs");
     const r = resolveObject(graph, term);
     if (r?.match?.id && !r.ambiguous) return { id: r.match.id, label: r.match.label };
   } catch { /* tolerated */ }
@@ -4253,6 +4535,7 @@ export async function helpText() {
     ["/focus <symbol>", "set the current focus (reused by 'it'/'this' and no-arg entity commands)"],
     ["/plan <request>", "the capability router: plan+execute a compound or maintenance-goal request (\"of the modules impacted by X, which are untested\", \"what most needs a test\")"],
     ["/capabilities", "what /plan can plan over: the built-in graph tools plus your taught actions"],
+    ["/syllogise <term>", "work out and remember what follows from the facts about a term (needed for chains longer than 2 hops)"],
     ["/narrate on|off", "verbose developer/debug mode: decision points, matched pattern, results+sources, goal per turn"],
     ["/help", "this list"],
     ["/exit", "leave the session (also Ctrl+C / Ctrl+D)"],
@@ -4260,7 +4543,7 @@ export async function helpText() {
   const w = Math.max(...rows.map(([a]) => a.length));
   const lines = rows.map(([a, b]) => `  ${a.padEnd(w)}  ${b}`);
   let shapes;
-  try { const { rephraseHint } = await import("./ask.mjs"); shapes = rephraseHint(); }
+  try { const { rephraseHint } = await import("../domain/ask.mjs"); shapes = rephraseHint(); }
   catch {
     // "touch" dropped from this cross-product for the same reason rephraseHint() drops it
     // (ask.mjs) — Module/Function/Class is never the subject of a touch edge, only Commit.
@@ -4279,7 +4562,7 @@ export async function helpText() {
 
 /** The conservative relevance floor a folded-session block must clear (the
  *  retrieveBlocks idf×(1+rank) score) before an honest ask-miss is answered from
- *  memory. Calibrated in the small-corpus regime (test/wiring-recall.test.mjs):
+ *  memory. Calibrated in the small-corpus regime (test/tools/wiring-recall.test.mjs):
  *  a genuine re-ask scores ~4, a frame-word coincidence ~1. */
 export const RECALL_MIN_SCORE = 2.0;
 
@@ -4389,7 +4672,7 @@ async function bestQaPair(blockText, query, graph) {
  *  Lazy + failure-tolerated (chat.mjs ethos): a broken store degrades to null. */
 async function recallFromBlocks(memoryDir, query, graph) {
   try {
-    const { retrieveBlocks } = await import("./memory/blocks.mjs");
+    const { retrieveBlocks } = await import("../adapters/memory/blocks.mjs");
     const hits = await retrieveBlocks(memoryDir, query, RECALL_TOP_K);
     const best = hits[0];
     if (!best || best.score < RECALL_MIN_SCORE || !best.text) return null;
@@ -4464,9 +4747,40 @@ function thirdPersonSingularSurface(lemma) {
   if (/(?:s|x|z|ch|sh|o)$/i.test(w)) return `${w}es`;
   return `${w}s`;
 }
+/** The INVERSE of thirdPersonSingularSurface — "eats" -> "eat", "flies" ->
+ *  "fly", "has" -> "have". Do-support wants the bare infinitive after it
+ *  ("does not EAT", never "does not eats"), and so does every derived
+ *  forward yes/no reader ("does X cause Y"), so both fold through this one
+ *  function and can never drift apart on a verb. */
+function baseVerbSurface(verb) {
+  const w = String(verb || "");
+  if (/^has$/i.test(w)) return "have";
+  if (/[a-z]ies$/i.test(w) && !/[aeiou]ies$/i.test(w)) return `${w.slice(0, -3)}y`;
+  if (/(?:s|x|z|ch|sh|o)es$/i.test(w)) return w.slice(0, -2);
+  return w.replace(/s$/i, "");
+}
 function predicatePhrase(predicate) {
   if (FACT_PREDICATE_PHRASES[predicate]) return FACT_PREDICATE_PHRASES[predicate];
   const p = String(predicate || "");
+  // NEGATIVE polarity renders as its own positive phrase, negated — ONE branch
+  // for every predicate that can carry a polarity, curated or minted. The
+  // negative twins are deliberately absent from FACT_PREDICATE_PHRASES: the
+  // TRAILING_PREDICATE_MARKERS / REVERSE_PREDICATE_MARKERS /
+  // FORWARD_YESNO_MARKERS families all derive their vocabulary from that table,
+  // so an entry there would auto-mint readers for "what cannot X" and
+  // "does X cannot Y" that nobody wrote and nothing pins.
+  // The three surface shapes split exactly as FORWARD_YESNO_MARKERS splits
+  // them, for the same reason: a modal, a copula and a plain verb take
+  // different negations, and nothing else does.
+  const positive = positivePredicate(p);
+  if (positive) {
+    const phrase = predicatePhrase(positive);
+    if (phrase === "can") return "cannot";
+    if (phrase === "can be") return "cannot be";
+    if (phrase === "is" || phrase.startsWith("is ")) return `is not${phrase.slice(2)}`;
+    const [head, ...tail] = phrase.split(" ");
+    return ["does not", baseVerbSurface(head), ...tail].join(" ");
+  }
   // a comparative renders as its copula surface: mgx:smaller-than ->
   // "is smaller than" (never a 3sg fold — "smallers" isn't a word)
   const comp = /^mgx:([a-z]+(?:-[a-z]+)*)-than$/i.exec(p);
@@ -4569,7 +4883,7 @@ function renderIsaChain(premises) {
  *  object, provenance} rows. Lazy + failure-tolerated: no memory → []. */
 async function memoryFacts(memoryDir) {
   try {
-    const { loadMemory } = await import("./memory/core.mjs");
+    const { loadMemory } = await import("../adapters/memory/core.mjs");
     const m = await loadMemory(memoryDir);
     const out = [];
     for (const ind of m.individuals || []) {
@@ -4602,7 +4916,7 @@ async function memoryFacts(memoryDir) {
 async function factRows(memoryDir, cache = null) {
   if (cache?.rows) return cache.rows;
   try {
-    const { loadMemory, readFactRows } = await import("./memory/core.mjs");
+    const { loadMemory, readFactRows } = await import("../adapters/memory/core.mjs");
     const rows = readFactRows(await loadMemory(memoryDir));
     if (cache) { cache.rows = rows; cache.reloads = (cache.reloads || 0) + 1; }
     return rows;
@@ -4714,7 +5028,7 @@ async function synonymIndex() {
     if (!index.get(tb).some((e) => e.variant === ta)) index.get(tb).push({ variant: ta, source });
   };
   try {
-    const { loadSlice, loadMap, termText } = await import("./corpus/conceptnet.mjs");
+    const { loadSlice, loadMap, termText } = await import("../adapters/corpus/conceptnet.mjs");
     const [assertions, map] = await Promise.all([loadSlice(), loadMap()]);
     const SINGLE_WORD_RE = /^[a-z]+$/;
     for (const a of assertions) {
@@ -4727,7 +5041,7 @@ async function synonymIndex() {
     }
   } catch { /* corpus unavailable — degrade gracefully */ }
   try {
-    const { loadPhrasebook } = await import("./corpus/templates.mjs");
+    const { loadPhrasebook } = await import("../adapters/corpus/templates.mjs");
     const { synonyms } = await loadPhrasebook();
     for (const family of synonyms) {
       for (let i = 0; i < family.length; i += 1) {
@@ -4817,7 +5131,7 @@ function matchGenitiveWhoAsk(q) {
  *  the same naive plural fold SOME_A_FEW_RE's own teach-side surface already
  *  uses elsewhere in this file), `m[2]` = the start entity ("ahab"). Dispatch
  *  lives in factReadBack's own (a0.5) block, below — findRuleByName +
- *  findReachableSet (src/planning.mjs), never a yes/no answer. */
+ *  findReachableSet (src/domain/planning.mjs), never a yes/no answer. */
 const RECURSIVE_LIST_ASK_RE = /^list\s+(?:the\s+|all\s+)?([a-z][\w-]*)\s+of\s+([\w'-]+(?:\s+[A-Z][\w'-]*)?)[?.!\s]*$/i;
 
 /** "is a module a component" — the yes/no vocabulary form the graph grammar
@@ -4825,6 +5139,14 @@ const RECURSIVE_LIST_ASK_RE = /^list\s+(?:the\s+|all\s+)?([a-z][\w-]*)\s+of\s+([
 const ISA_ASK_RE = /^(?:is|are)\s+(?:an?\s+)?(.+?)\s+(?:a\s+kind\s+of|a\s+type\s+of|an?)\s+(.+?)[?.!\s]*$/i;
 const ISA_PREDICATES = new Set(["rdfs:subClassOf", "rdf:type"]);
 
+/** How far the isa ladder's miss text probes for a chain it can name a
+ *  recovery for. Purely a REPORTING reach: the live chases answer within their
+ *  own hop bounds and this never widens them, it only tells the miss whether
+ *  "/syllogise <term>" would find anything. findIsaChain's own default, since
+ *  the probe wants the search's natural reach rather than a second opinion
+ *  about how deep is worth walking. */
+const DEEP_CHAIN_PROBE_HOPS = 6;
+
 /** "why is TaskController a handler" / "explain how you know TaskController is
  *  a handler" — the syllogise-verified proof render (the isaAsk block below,
  *  which cites the graph inherits-bridge / taught-fact chase / entailed
@@ -4915,6 +5237,16 @@ const WHERE_IS_FACT_RE = /^where(?:'s|\s+is|\s+are)\s+(.+?)(?:\s+now)?\s*[?.!]*$
  *  (mgx:rest-on, mgx:stand-on, mgx:sit-in, …) — what makes a taught fact a
  *  LOCATION answer rather than any arbitrary relation. */
 const LOCATIVE_FACT_PREDICATE_RE = /^mgx:[a-z]+-(?:on|in|at|inside|under|below|above|near|beside|behind|by)$/;
+/** "what is on peg-a" / "what's on peg-a" — the reverse-by-OBJECT mirror of
+ *  WHERE_IS_FACT_RE, over the same taught locative facts. The bare copula
+ *  carries no verb to mint a predicate from, so the PREPOSITION is the anchor:
+ *  it's captured here and matched against the folded predicate's own tail, so
+ *  "what is on peg-a" can only ever answer with a fact that really says "on"
+ *  (a "-under" row is a different claim, never this question's answer).
+ *  Consumed by factAnswer's (a-pre5) reader, which diverts only on a real
+ *  stored hit — "what is on the roadmap" finds no such fact and falls through
+ *  to the ordinary BARE_WHATIS_RE handling untouched. */
+const WHAT_IS_PREP_FACT_RE = new RegExp(`^what(?:'s|\\s+is|\\s+are)\\s+(${PREP_SRC})\\s+(.+?)\\s*[?.!]*$`, "i");
 
 // CAN_ASK_RE's remaining paraphrase-ladder siblings, all over the same
 // mgx:capableOf facts:
@@ -4937,6 +5269,152 @@ const DO_VERB_ASK_RE = /^(?:do|does)\s+(all\s+|every\s+)?(?:an?\s+|the\s+)?([\w'
 const WHAT_CAN_VERB_RE = /^what\s+can\s+(?!be\s)(.+?)[?.!\s]*$/i;
 const WHICH_KIND_CAN_RE = /^(?:which|what)\s+([\w'-]+(?:\s+[\w'-]+)*?)\s+can\s+(.+?)[?.!\s]*$/i;
 
+/** The negative surface of a yes/no question asks the SAME question as its
+ *  positive twin — "can't a penguin fly" and "can a penguin fly" both want the
+ *  polarity of penguin's flight, and a reader that answered them differently
+ *  would be disagreeing with itself in one session. So the negation is stripped
+ *  here and the ordinary reader answers, carrying whatever polarity the facts
+ *  actually hold. A question with no negation in it comes back byte-identical,
+ *  so every existing surface reads exactly as it always has.
+ *
+ *  Applied ONLY inside the capability + general-verb readers, never to `q` at
+ *  large: "is a task not an animal" is the retraction lane's copula surface,
+ *  and this must never reach it.
+ *
+ *  Those readers match this surface INSTEAD of the raw question, never as a
+ *  fallback after it. A lazy subject slot happily swallows the negation word
+ *  itself — "do penguins not fly" binds subject "penguins not" and matches — so
+ *  trying the raw question first would take a garbage bind over the good one. */
+function positiveQuestionSurface(q) {
+  const s = String(q || "")
+    .replace(/^(?:can't|cannot|can not)\s+/i, "can ")
+    .replace(/^(?:doesn't|does not)\s+/i, "does ")
+    .replace(/^(?:don't|do not)\s+/i, "do ")
+    .replace(/^(?:didn't|did not)\s+/i, "did ")
+    .replace(/\s+(?:not|never)\s+/i, " ");
+  return s.replace(/\s+/g, " ").trim();
+}
+
+/** Cite an isa chain the way (b3b) already cites one — each step as its own
+ *  phrase plus verbatim source. Shared so the inherited-capability answers and
+ *  the reverse-by-kind listing can never describe the same chain two ways. */
+function renderIsaCite(chain, facts) {
+  const steps = (chain || []).map((step) => facts.find(
+    (f) => f.predicate === step.predicate && f.subject === step.subject && f.object === step.object,
+  ));
+  if (!steps.length || !steps.every(Boolean)) return null;
+  return steps.map((g) => `${factPhrase(g)}${g.provenance ? ` (source: ${g.provenance})` : ""}`).join("; ");
+}
+
+/** THE capability answer — every reader that asks "can X do Y" renders through
+ *  this one function, over the one resolver. Five readers with five local
+ *  polarity filters would drift, and the drift is invisible: each would answer
+ *  confidently from one side while a negative it never looked at sat in the
+ *  store. "do penguins fly" and "can a penguin fly" must not disagree inside a
+ *  single session.
+ *
+ *  Returns null when the store holds no capability claim about the subject at
+ *  either specificity. The caller then keeps its own honest-miss text, and
+ *  falls to capabilityBaseRateReply only once that has nothing either: a
+ *  subject with capability facts of its own ("a dog can bark") is better
+ *  answered by citing them than by reciting what other animals do.
+ */
+function capabilityReply(subjectText, objectText, facts, { maxHops = 3 } = {}) {
+  const subj = factTermVariants(normFactTermStatic, subjectText);
+  const obj = factTermVariants(normFactTermStatic, objectText);
+  const r = resolveCapabilityPolarity(subj, obj, facts, { maxHops });
+
+  const viaChain = (chain) => {
+    const cite = chain && chain.length ? renderIsaCite(chain, facts) : null;
+    return cite ? ` — via: ${cite}` : "";
+  };
+
+  // both polarities at the same specificity: the disagreement is between the
+  // SOURCES, not inside the knowledge, so both are true statements about who
+  // said what. Report them and pick nothing.
+  if (r.verdict === "both") {
+    const lines = [...r.negative, ...r.positive].map(renderFactLine).join("\n");
+    return {
+      text: `I have both, at the same level of detail — my sources disagree, so I won't pick:\n${lines}`,
+      replace: true,
+      miss: true,
+    };
+  }
+
+  if (r.verdict === "yes" || r.verdict === "no") {
+    const winner = r.verdict === "no" ? r.negative[0] : r.positive[0];
+    let text = `${r.verdict} — ${renderFactLine(winner)}${viaChain(r.chain)}`;
+    // a direct fact beat a general default: say WHAT it overrides, or the
+    // answer silently contradicts what the same store says about the class
+    if (r.overrides) {
+      text += `. That overrides what I know about ${r.overrides.fact.subject} generally: ${renderFactLine(r.overrides.fact)}`;
+    }
+    return { text, replace: true };
+  }
+
+  return null;
+}
+
+/** Nothing is known about the subject's capability. Report the CLASS it belongs
+ *  to and how that class's other kinds split, then STOP — neither yes nor no.
+ *  That is the only reading of "birds fly" that survives a penguin.
+ *
+ *  Two axes, in order: the class base rate, and — when the class yields nothing
+ *  either way — the predicate's own extension ("but I do know 3 things that can
+ *  fly"). The pivot excludes the class itself: "I don't know if a penguin can
+ *  fly, but I know birds can" is circular, not informative.
+ *
+ *  Returns null unless the subject has a known class. Without one there is no
+ *  base rate to report and no reason to believe the subject is a real term at
+ *  all — an unresolved "it" belongs to the pronoun lane, not here.
+ */
+function capabilityBaseRateReply(subjectText, objectText, facts, { maxHops = 3 } = {}) {
+  const subj = factTermVariants(normFactTermStatic, subjectText);
+  const obj = factTermVariants(normFactTermStatic, objectText);
+  const baseRate = capabilityBaseRate(subj, obj, facts, { maxHops });
+  if (!baseRate) return null;
+  const lead = `${subjectText} is a kind of ${baseRate.klass}`;
+  const opener = `I don't know if ${subjectText} can ${objectText}.`;
+
+  if (baseRate.positive.length || baseRate.negative.length) {
+    // The split accounts for EVERY kind it counted — three ways, positive,
+    // negative and unknown. Say 5 and split only 4 and the arithmetic lies
+    // about what the store knows. The count is a fact about the kinds it has
+    // seen; "most birds fly" would be a claim about the ones it has not.
+    const split = [
+      `${baseRate.positive.length} can ${objectText}`,
+      `${baseRate.negative.length} cannot`,
+      `${baseRate.unknown.length} I have nothing on`,
+    ].join(", ");
+    const named = [...baseRate.positive, ...baseRate.negative]
+      .slice(0, CAPABILITY_REPORT_CAP)
+      .map((s) => renderFactLine(s.fact));
+    return {
+      text: `${opener} ${lead}, and of the ${baseRate.kinds} kind${baseRate.kinds === 1 ? "" : "s"} of ${baseRate.klass} I know, ${split}.\n${named.join("\n")}`,
+      replace: true,
+      miss: true,
+    };
+  }
+
+  const extension = capabilityExtension(obj, facts, { exclude: new Set([...subj, baseRate.klass]) });
+  if (extension.length) {
+    const shown = extension.slice(0, CAPABILITY_REPORT_CAP);
+    const rest = extension.slice(shown.length);
+    return {
+      text: `${opener} ${lead}, and nothing I know about ${baseRate.klass} says whether one can ${objectText}. I do know ${extension.length} thing${extension.length === 1 ? "" : "s"} that can ${objectText}${rest.length ? ` (first ${shown.length} shown)` : ""}:\n${shown.map(renderFactLine).join("\n")}`,
+      replace: true,
+      miss: true,
+      ...(rest.length ? { pending: { items: rest.map(renderFactLine), noun: "facts" } } : {}),
+    };
+  }
+
+  return {
+    text: `${opener} ${lead}, but nothing I remember says whether any kind of ${baseRate.klass} can ${objectText}.`,
+    replace: true,
+    miss: true,
+  };
+}
+
 /** SUPERLATIVE over TAUGHT COMPARATIVES — "which disk is smallest" / "what is
  *  the smallest disk" answered from the mgx:<comparative>-than facts the
  *  comparative teach frame mints ("disk-1 is smaller than disk-2"). The
@@ -5013,7 +5491,7 @@ const FORWARD_YESNO_MARKERS = Object.entries(FACT_PREDICATE_PHRASES)
       re = new RegExp(`^(?:is|are)\\s+(?:an?\\s+|the\\s+)?(.+?)\\s+${rest}\\s+(?:an?\\s+|the\\s+)?(.+?)[?.!\\s]*$`, "i");
     } else {
       const [head, ...tail] = phrase.split(" ");
-      const base = [head.replace(/s$/, ""), ...tail].map(escapeRegex).join("\\s+");
+      const base = [baseVerbSurface(head), ...tail].map(escapeRegex).join("\\s+");
       re = new RegExp(`^(?:does|do)\\s+(?:an?\\s+|the\\s+)?(.+?)\\s+${base}\\s+(?:an?\\s+|the\\s+)?(.+?)[?.!\\s]*$`, "i");
     }
     return { predicate, phrase, re };
@@ -5054,7 +5532,7 @@ function uniqueFacts(rows) {
  *  graph's Facts. Returns { text, replace } — `replace:false` means the engine's
  *  own (schema-docs) answer stands and the fact lines are appended under it —
  *  or null when memory holds nothing relevant (misses stay unchanged).
- *  Exported so src/memory-ask-browser-entry.mjs
+ *  Exported so src/surfaces/web/memory-ask-browser-entry.mjs
  *  can re-export it for `tmct viz`'s embedded "Ask the graph" panel — the ONLY
  *  reason this is `export` rather than module-private; the function's own
  *  behavior is unchanged (same signature, same logic, answers identically in
@@ -5069,8 +5547,8 @@ function uniqueFacts(rows) {
  *  deducible (withDeducedGoal, below) — the ledger page's chat dock renders
  *  it as its own "Goal (inferred)" line; every other consumer reads named
  *  fields and is unaffected. */
-export async function factAnswer(memoryDir, query, envelope, miss, biasByBundle = {}, cache = null) {
-  return withDeducedGoal(await factAnswerReaders(memoryDir, query, envelope, miss, biasByBundle, cache), envelope, query);
+export async function factAnswer(memoryDir, query, envelope, miss, biasByBundle = {}, cache = null, focusLabel = null) {
+  return withDeducedGoal(await factAnswerReaders(memoryDir, query, envelope, miss, biasByBundle, cache, focusLabel), envelope, query);
 }
 
 /** Attach the additive `goal` field to a fact reader's return: the same
@@ -5098,9 +5576,9 @@ function withDeducedGoal(res, envelope, query) {
   return goal ? { ...res, goal } : res;
 }
 
-async function factAnswerReaders(memoryDir, query, envelope, miss, biasByBundle = {}, cache = null) {
+async function factAnswerReaders(memoryDir, query, envelope, miss, biasByBundle = {}, cache = null, focusLabel = null) {
   let normFactTerm;
-  try { ({ normFactTerm } = await import("./memory/core.mjs")); } catch { return null; }
+  try { ({ normFactTerm } = await import("../adapters/memory/core.mjs")); } catch { return null; }
   const q = String(query).trim();
 
   // (a-pre) "what is used for riding" / "what can be used for riding" / "what
@@ -5241,6 +5719,31 @@ async function factAnswerReaders(memoryDir, query, envelope, miss, biasByBundle
     }
   }
 
+  // (a-pre5) "what is on peg-a" over the SAME taught locative facts as
+  // (a-pre4), asked by OBJECT instead of by subject. The general-verb reverse
+  // reader ("what rests on peg-a") can't take this shape: it needs a surface
+  // verb to mint a predicate from, and the bare copula has none. So the
+  // captured preposition anchors the lookup instead — see
+  // WHAT_IS_PREP_FACT_RE. Hit-gated the same way every reader in this cascade
+  // is: it returns only when a locative row with that exact preposition and
+  // object exists, so a plain vocabulary question keeps its own answer.
+  const whatIsPrepQ = q.match(WHAT_IS_PREP_FACT_RE);
+  if (whatIsPrepQ) {
+    const prep = whatIsPrepQ[1].toLowerCase();
+    const variants = factTermVariants(normFactTerm, whatIsPrepQ[2].replace(/^(?:an?|the)\s+/i, "").trim());
+    const hits = (await factRows(memoryDir, cache)).filter(
+      (f) => LOCATIVE_FACT_PREDICATE_RE.test(f.predicate) && f.predicate.endsWith(`-${prep}`) && variants.has(f.object),
+    );
+    if (hits.length) {
+      const ranked = rankByBiasThenTrust(uniqueFacts(hits), biasByBundle);
+      const lines = ranked.map(renderFactLine);
+      const shown = lines.slice(0, FACT_ANSWER_CAP);
+      const rest = lines.slice(FACT_ANSWER_CAP);
+      const extra = rest.length ? `\n…and ${rest.length} more — say 'more' to see them.` : "";
+      return { text: shown.join("\n") + extra, replace: true, ...(rest.length ? { pending: { items: rest, noun: "facts" } } : {}) };
+    }
+  }
+
   // (a) meta-shaped questions ("what is a module", "what does cache mean") — the
   // parsed object term, matched against fact SUBJECTS; consulted for hits (append
   // alongside the schema-docs answer) and misses (facts answer alone) alike.
@@ -5330,14 +5833,25 @@ async function factAnswerReaders(memoryDir, query, envelope, miss, biasByBundle
     const compWord = compAsk[2].toLowerCase().replace(/\s+/g, "-");
     const compPredicate = `mgx:${compWord}-than`;
     const facts = await memoryFacts(memoryDir);
-    const subj = factTermVariants(normFactTerm, compAsk[1].replace(/^(?:an?|the)\s+/i, "").trim());
-    const obj = factTermVariants(normFactTerm, compAsk[3].replace(/^(?:an?|the)\s+/i, "").trim());
+    // Either side may be a context pronoun ("is it bigger than peg-a", "is
+    // peg-a bigger than that"), resolved against the standing focus the same
+    // way the property and relation lanes below resolve theirs. With no focus
+    // to bind to, the pronoun stays literal and the honest can't-confirm below
+    // stands — the lane never picks a subject the session hasn't named.
+    const compTerm = (raw) => {
+      const t = raw.replace(/^(?:an?|the)\s+/i, "").trim();
+      return focusLabel && IS_ADJECTIVE_PRONOUN_RE.test(t) ? focusLabel : t;
+    };
+    const subjTerm = compTerm(compAsk[1]);
+    const objTerm = compTerm(compAsk[3]);
+    const subj = factTermVariants(normFactTerm, subjTerm);
+    const obj = factTermVariants(normFactTerm, objTerm);
     const hit = facts.find((f) => f.predicate === compPredicate && subj.has(f.subject) && obj.has(f.object));
     if (hit) return { text: `yes — ${renderFactLine(hit)}`, replace: true };
     const known = facts.filter((f) => f.predicate === compPredicate && (subj.has(f.subject) || subj.has(f.object)));
     const shown = known.length ? ` I do know: ${known.slice(0, 3).map(renderFactLine).join("; ")}.` : "";
     return {
-      text: `I can't confirm that — nothing I remember compares them that way.${shown} If it's true, teach me: "${compAsk[1].trim()} is ${compAsk[2].toLowerCase()} than ${compAsk[3].trim()}".`,
+      text: `I can't confirm that — nothing I remember compares them that way.${shown} If it's true, teach me: "${subjTerm} is ${compAsk[2].toLowerCase()} than ${objTerm}".`,
       replace: true,
       miss: true,
     };
@@ -5392,23 +5906,22 @@ async function factAnswerReaders(memoryDir, query, envelope, miss, biasByBundle
     return null; // no remembered fact — the honest miss stands (never a guessed "no")
   }
 
-  // (b2) "can a dog bark" — yes iff a remembered mgx:capableOf fact says so.
-  // Mirrors the ISA_ASK_RE block just above almost verbatim (same memoryFacts
-  // single-hit lookup, same "never a guessed no" discipline).
-  const can = q.match(CAN_ASK_RE);
+  // (b2) "can a dog bark" — the polarity of a capability, resolved through the
+  // ONE resolver every capability reader in this file shares (see
+  // capabilityReply). Mirrors the ISA_ASK_RE block just above on the "never a
+  // guessed no" discipline: a "no" here is a REMEMBERED negative, never the
+  // absence of a positive.
+  const can = positiveQuestionSurface(q).match(CAN_ASK_RE);
   if (can) {
-    const facts = await memoryFacts(memoryDir);
-    const subj = factTermVariants(normFactTerm, can[1]);
-    const obj = factTermVariants(normFactTerm, can[2]);
-    const hit = facts.find(
-      (f) => f.predicate === "mgx:capableOf" && subj.has(f.subject) && obj.has(f.object),
-    );
-    if (hit) return { text: `yes — ${renderFactLine(hit)}`, replace: true };
+    const facts = await factRows(memoryDir, cache);
+    const reply = capabilityReply(can[1], can[2], facts);
+    if (reply) return reply;
     // A KNOWN subject with capability facts, none matching: an honest,
     // specific miss citing what it CAN do — the same closer the is-a ladder
     // answers with, instead of the misleading structural parse wall. An
     // unknown subject still declines. Never a guessed "no": absence of a
     // capableOf fact proves nothing.
+    const subj = factTermVariants(normFactTerm, can[1]);
     const knownCan = facts.filter((f) => f.predicate === "mgx:capableOf" && subj.has(f.subject));
     if (knownCan.length) {
       const shown = knownCan.slice(0, 3).map(renderFactLine).join("; ");
@@ -5421,7 +5934,9 @@ async function factAnswerReaders(memoryDir, query, envelope, miss, biasByBundle
         miss: true,
       };
     }
-    return null;
+    // nothing about the subject at all — report the class base rate, and answer
+    // neither yes nor no
+    return capabilityBaseRateReply(can[1], can[2], facts);
   }
 
   // (b2b) "does a dog have a tail" — yes iff a remembered mgx:hasA fact says
@@ -5447,22 +5962,22 @@ async function factAnswerReaders(memoryDir, query, envelope, miss, biasByBundle
   // (falls through instead): the shape is looser than (b2)'s, so a do-lead
   // question some later reader owns must keep its turn. The can't-confirm
   // branch is additionally miss-gated for the same reason.
-  const doAsk = q.match(DO_VERB_ASK_RE);
+  const doAsk = positiveQuestionSurface(q).match(DO_VERB_ASK_RE);
   if (doAsk) {
-    const facts = await memoryFacts(memoryDir);
+    const facts = await factRows(memoryDir, cache);
     const universal = !!doAsk[1];
     const subj = factTermVariants(normFactTerm, doAsk[2]);
     const obj = factTermVariants(normFactTerm, doAsk[3]);
-    const hit = facts.find(
-      (f) => f.predicate === "mgx:capableOf" && subj.has(f.subject) && obj.has(f.object),
-    );
-    if (hit && universal) {
+    // the SAME resolver (b2) answers through, so "do penguins fly" and "can a
+    // penguin fly" can never disagree in one session
+    const reply = capabilityReply(doAsk[2], doAsk[3], facts);
+    if (reply && universal) {
       return {
-        text: `I can't speak for all ${doAsk[2]} — what I remember is generic, not universal. I do know: ${renderFactLine(hit)}.`,
+        text: `I can't speak for all ${doAsk[2]} — what I remember is generic, not universal. ${reply.text}.`,
         replace: true,
       };
     }
-    if (hit) return { text: `yes — ${renderFactLine(hit)}`, replace: true };
+    if (reply) return reply;
     if (miss) {
       const knownCan = facts.filter((f) => f.predicate === "mgx:capableOf" && subj.has(f.subject));
       if (knownCan.length) {
@@ -5473,6 +5988,8 @@ async function factAnswerReaders(memoryDir, query, envelope, miss, biasByBundle
           miss: true,
         };
       }
+      const base = capabilityBaseRateReply(doAsk[2], doAsk[3], facts);
+      if (base) return base;
     }
   }
 
@@ -5482,7 +5999,12 @@ async function factAnswerReaders(memoryDir, query, envelope, miss, biasByBundle
   const canDo = q.match(WHAT_CAN_DO_RE);
   if (canDo) {
     const variants = factTermVariants(normFactTerm, canDo[1]);
-    const hits = (await factRows(memoryDir, cache)).filter((f) => f.predicate === "mgx:capableOf" && variants.has(f.subject));
+    // BOTH polarities. Filtering to the positive would silently omit what the
+    // store explicitly says the subject CANNOT do, which reads as "I don't
+    // know" for something it knows outright. renderFactLine spells the polarity
+    // ("a penguin cannot fly"), so the two never blur together in the list.
+    const hits = (await factRows(memoryDir, cache))
+      .filter((f) => (f.predicate === "mgx:capableOf" || f.predicate === NEG_CAPABLE_OF_PREDICATE) && variants.has(f.subject));
     if (!hits.length) return null;
     const ranked = rankByBiasThenTrust(uniqueFacts(hits), biasByBundle);
     const lines = ranked.map(renderFactLine);
@@ -5508,9 +6030,16 @@ async function factAnswerReaders(memoryDir, query, envelope, miss, biasByBundle
     const kindVariants = factTermVariants(normFactTerm, whichCan[1]);
     const verbVariants = factTermVariants(normFactTerm, whichCan[2]);
     const facts = await factRows(memoryDir, cache);
-    const capable = uniqueFacts(facts.filter((f) => f.predicate === "mgx:capableOf" && verbVariants.has(f.object)));
+    // A subject the store explicitly says CANNOT do this is not an answer to
+    // "which birds can fly", even when a corpus row also says it can: the
+    // direct negative is the more specific claim, and listing penguin here
+    // while "can a penguin fly" answers "no" would be the same session
+    // contradicting itself. The resolver decides, so the two agree by
+    // construction.
+    const capable = uniqueFacts(facts.filter((f) => f.predicate === "mgx:capableOf" && verbVariants.has(f.object)))
+      .filter((f) => resolveCapabilityPolarity(new Set([f.subject]), verbVariants, facts).verdict === "yes");
     if (capable.length) {
-      const { findIsaChain, SUBCLASS_PREDICATE: SC_PRED, TYPE_PREDICATE: TYPE_PRED } = await import("./syllogise.mjs");
+      const { findIsaChain, SUBCLASS_PREDICATE: SC_PRED, TYPE_PREDICATE: TYPE_PRED } = await import("../domain/syllogise.mjs");
       const subClassRows = facts.filter((f) => f.predicate === SC_PRED);
       const typeRows = facts.filter((f) => f.predicate === TYPE_PRED);
       const subClassEdges = subClassRows.map((f) => [f.subject, f.object]);
@@ -5550,7 +6079,9 @@ async function factAnswerReaders(memoryDir, query, envelope, miss, biasByBundle
   const canVerb = q.match(WHAT_CAN_VERB_RE);
   if (canVerb && canVerb[1].trim().split(/\s+/).at(-1)?.toLowerCase() !== "do") {
     const verbVariants = factTermVariants(normFactTerm, canVerb[1]);
-    const hits = (await factRows(memoryDir, cache)).filter((f) => f.predicate === "mgx:capableOf" && verbVariants.has(f.object));
+    // same polarity discipline as (b3b): a subject with a direct negative is
+    // not an answer to "what can fly"
+    const hits = capabilityExtension(verbVariants, await factRows(memoryDir, cache));
     if (hits.length) {
       const ranked = rankByBiasThenTrust(uniqueFacts(hits), biasByBundle);
       const lines = ranked.map(renderFactLine);
@@ -5706,7 +6237,7 @@ async function factAnswerReaders(memoryDir, query, envelope, miss, biasByBundle
     // above. A hit REFUSES the whole answer (every belief about a
     // contradictory subject is suspect, not just the clashing pair) rather
     // than silently answering from a memory that's already inconsistent.
-    const { findConsistencyViolations, TYPE_PREDICATE: CONS_TYPE_PREDICATE, SUBCLASS_PREDICATE: CONS_SC_PREDICATE, DISJOINT_PREDICATE: CONS_DISJOINT_PREDICATE } = await import("./syllogise.mjs");
+    const { findConsistencyViolations, TYPE_PREDICATE: CONS_TYPE_PREDICATE, SUBCLASS_PREDICATE: CONS_SC_PREDICATE, DISJOINT_PREDICATE: CONS_DISJOINT_PREDICATE } = await import("../domain/syllogise.mjs");
     const consIsTaught = (f) => !f.provenance?.includes("corpus:") && !f.provenance?.includes("web:");
     const consTypeEdges = rows.filter((f) => f.predicate === CONS_TYPE_PREDICATE && consIsTaught(f)).map((f) => [f.subject, f.object]);
     const consSubClassEdges = rows.filter((f) => f.predicate === CONS_SC_PREDICATE && consIsTaught(f)).map((f) => [f.subject, f.object]);
@@ -5794,7 +6325,7 @@ async function whatElseAnswer(memoryDir, query, last) {
   const term = m[1].trim();
   if (!term) return null;
   let normFactTerm;
-  try { ({ normFactTerm } = await import("./memory/core.mjs")); } catch { return null; }
+  try { ({ normFactTerm } = await import("../adapters/memory/core.mjs")); } catch { return null; }
   const variants = factTermVariants(normFactTerm, term);
   const hits = (await memoryFacts(memoryDir)).filter((f) => variants.has(f.subject));
   const picture = pickPhrase("full-picture", term.toLowerCase(), "the full picture");
@@ -5835,7 +6366,7 @@ async function synonymFactAnswer(memoryDir, query, envelope) {
   const term = metaTermOf(query, envelope);
   if (!term) return null;
   let normFactTerm;
-  try { ({ normFactTerm } = await import("./memory/core.mjs")); } catch { return null; }
+  try { ({ normFactTerm } = await import("../adapters/memory/core.mjs")); } catch { return null; }
   const facts = await memoryFacts(memoryDir);
   for (const { variant, source } of await synonymsOf(term)) {
     const variants = factTermVariants(normFactTerm, variant);
@@ -5860,11 +6391,11 @@ const TOLD_ABOUT_RE = /^what\s+(?:did|have)\s+(?:i|we|you)\s+(?:told|tell|said|s
 const KIND_OF_RE = /^what\s+kind\s+of\s+(?:thing|class|type|category|entity)?\s*(?:is|are)\s+(?:an?\s+)?(.+?)[?.!\s]*$/i;
 /** "does every <N1> have at least <m> <N2>" — cardinality monotonicity: a
  *  class's OWN declared exactly/min cardinality restriction proves "at least
- *  m" for any queried m <= n (src/syllogise.mjs's proveCardinalityAtLeast). */
+ *  m" for any queried m <= n (src/domain/syllogise.mjs's proveCardinalityAtLeast). */
 const CARD_AT_LEAST_ASK_RE = /^does\s+every\s+(.+?)\s+have\s+at\s+least\s+(\d+)\s+(.+?)[?.!\s]*$/i;
 /** "does a/an <N1> have a/an <N2>" — a declared max-cardinality-0 restriction
  *  proves the class-level "no" directly
- *  (src/syllogise.mjs's proveMaxCardinalityZeroDenial). Both readers FALL
+ *  (src/domain/syllogise.mjs's proveMaxCardinalityZeroDenial). Both readers FALL
  *  THROUGH ON A MISS (no unconditional decline, unlike isaAsk's own closing
  *  `return null`): "does SUBJ have OBJ" is broad enough to otherwise collide
  *  with GENERAL_VERB_YESNO_RE below and a few unclear max0 cases — a miss
@@ -6056,7 +6587,7 @@ export async function factReadBack(memoryDir, query, envelope, miss, graph = nul
 async function factReadBackReaders(memoryDir, query, envelope, miss, graph = null, focusLabel = null, biasByBundle = {}, cache = null) {
   if (!miss) return null;
   let normFactTerm;
-  try { ({ normFactTerm } = await import("./memory/core.mjs")); } catch { return null; }
+  try { ({ normFactTerm } = await import("../adapters/memory/core.mjs")); } catch { return null; }
   const q = String(query).trim();
   // DIRECT STRUCTURAL CHECK: "is X a Y"
   // naming a real code-graph inheritance edge needs NO taught fact at all — the
@@ -6218,7 +6749,7 @@ async function factReadBackReaders(memoryDir, query, envelope, miss, graph = nul
     const object = relAsk[3].trim();
     if (subject && !ISA_IDIOM_ROLE_WORDS.has(relationName)) {
       const aliasTrees = buildAliasSubClassTrees(rows);
-      const { findIsaChain: chaseAlias } = await import("./syllogise.mjs");
+      const { findIsaChain: chaseAlias } = await import("../domain/syllogise.mjs");
       // Shared alias-chase substrate (item 2): every stored Fact whose
       // predicate resolves — directly, or via a taught (or, failing that,
       // general-knowledge) rdfs:subClassOf chain over relation-NAME strings
@@ -6261,9 +6792,10 @@ async function factReadBackReaders(memoryDir, query, envelope, miss, graph = nul
       // `relationFactsFor`/`renderFactLine`/`factPhrase`/`factTermVariants`/
       // `byTrust`/`rows`/`HAS_PROPERTY_PREDICATE` are this block's own local
       // closures/constants, threaded through explicitly.
-      const { loadMemory, findRuleByName, resolveRelationChase } = await import("./memory/core.mjs");
+      const { loadMemory, findRuleByName, resolveRelationChase } = await import("../adapters/memory/core.mjs");
+      const { findActionPath } = await import("../domain/planning.mjs");
       const memory = await loadMemory(memoryDir);
-      const relationChaseHelpers = { relationFactsFor, renderFactLine, factPhrase, factTermVariants, byTrust, rows, HAS_PROPERTY_PREDICATE };
+      const relationChaseHelpers = { relationFactsFor, renderFactLine, factPhrase, factTermVariants, byTrust, rows, HAS_PROPERTY_PREDICATE, findActionPath };
       const hit = await resolveRelationChase(memory, relationName, subject, object, relationChaseHelpers);
       if (hit) return { text: `yes — ${hit.citation.join("; ")}`, replace: true };
       // A bare `return null` on any miss here would be wrong — the
@@ -6310,7 +6842,7 @@ async function factReadBackReaders(memoryDir, query, envelope, miss, graph = nul
     const object = IS_ADJECTIVE_PRONOUN_RE.test(rawObject) ? (focusLabel || null) : rawObject;
     if (object && !ISA_IDIOM_ROLE_WORDS.has(relationName)) {
       const aliasTreesWho = buildAliasSubClassTrees(rows);
-      const { findIsaChain: chaseAliasWho } = await import("./syllogise.mjs");
+      const { findIsaChain: chaseAliasWho } = await import("../domain/syllogise.mjs");
       // Same candidate-list shape as (a0)'s own relationFactsFor — every
       // stored Fact whose predicate resolves, directly or via a taught (or
       // general-knowledge) rdfs:subClassOf chain over relation-NAME
@@ -6331,7 +6863,7 @@ async function factReadBackReaders(memoryDir, query, envelope, miss, graph = nul
         }
         return out;
       };
-      const { loadMemory: loadMemWho, findRuleByName: findRuleByNameWho, resolveRelationChaseReverse } = await import("./memory/core.mjs");
+      const { loadMemory: loadMemWho, findRuleByName: findRuleByNameWho, resolveRelationChaseReverse } = await import("../adapters/memory/core.mjs");
       const memoryWho = await loadMemWho(memoryDir);
       // Generic REVERSE relation-NAME resolver — the mirror image of (a0)'s
       // resolveRelationChase: given a relation/rule name and a FIXED OBJECT,
@@ -6344,7 +6876,8 @@ async function factReadBackReaders(memoryDir, query, envelope, miss, graph = nul
       // `relationFactsForWho`/`renderFactLine`/`factPhrase`/
       // `factTermVariants`/`byTrust`/`rows`/`HAS_PROPERTY_PREDICATE` are this
       // block's own local closures/constants, threaded through explicitly.
-      const relationChaseHelpersWho = { relationFactsFor: relationFactsForWho, renderFactLine, factPhrase, factTermVariants, byTrust, rows, HAS_PROPERTY_PREDICATE };
+      const { findReachableSet } = await import("../domain/planning.mjs");
+      const relationChaseHelpersWho = { relationFactsFor: relationFactsForWho, renderFactLine, factPhrase, factTermVariants, byTrust, rows, HAS_PROPERTY_PREDICATE, findReachableSet };
       const hits = await resolveRelationChaseReverse(memoryWho, relationName, object, relationChaseHelpersWho);
       if (hits.length) {
         const lines = hits.map((h) => `${h.subject} — ${h.citation.join("; ")}`);
@@ -6377,7 +6910,7 @@ async function factReadBackReaders(memoryDir, query, envelope, miss, graph = nul
   // enumeration (every node ever reached), not single-target search.
   // Dispatches to a `recursive`-kind taught Rule via the SAME "what kind of
   // thing is this name" lookup (findRuleByName) the yes/no dispatcher uses,
-  // then calls findReachableSet (src/planning.mjs) seeded from baseCase's taught edges for
+  // then calls findReachableSet (src/domain/planning.mjs) seeded from baseCase's taught edges for
   // the start entity, stepping via recStep's edges at every further hop.
   // Renders each result with its own derivation path, mirroring the yes/no
   // chain-citation style above (renderFactLine + interleaved alias-fact
@@ -6390,7 +6923,7 @@ async function factReadBackReaders(memoryDir, query, envelope, miss, graph = nul
     if (subject) {
       const {
         loadMemory, findRuleByName, RULE_KIND_PROP: ruleKindProp, RULE_KIND_RECURSIVE: recKind,
-      } = await import("./memory/core.mjs");
+      } = await import("../adapters/memory/core.mjs");
       const memory = await loadMemory(memoryDir);
       const rule = findRuleByName(memory, ruleName);
       const ruleKind = rule?.attributes?.find((a) => a.prop === ruleKindProp)?.value;
@@ -6400,7 +6933,7 @@ async function factReadBackReaders(memoryDir, query, envelope, miss, graph = nul
         const startEntity = normFactTerm(subject);
         if (baseCase && recStep && startEntity) {
           const aliasTreesList = buildAliasSubClassTrees(rows);
-          const { findIsaChain: chaseAlias } = await import("./syllogise.mjs");
+          const { findIsaChain: chaseAlias } = await import("../domain/syllogise.mjs");
           // Same alias-chase substrate the yes/no dispatcher's own
           // relationFactsFor uses (re-derived here rather than shared across
           // the two `if` blocks, which never run in the same call — one
@@ -6430,7 +6963,7 @@ async function factReadBackReaders(memoryDir, query, envelope, miss, graph = nul
           // (this is also what makes a genuine cycle in the taught edges —
           // e.g. two individuals mutually taught as each other's parent —
           // terminate safely: the cyclic-back node is already `seen`).
-          const { findReachableSet } = await import("./planning.mjs");
+          const { findReachableSet } = await import("../domain/planning.mjs");
           const applyActions = (state) => {
             const relName = state.hop === 0 ? baseCase : recStep;
             return relationFactsForList(relName)
@@ -6482,8 +7015,17 @@ async function factReadBackReaders(memoryDir, query, envelope, miss, graph = nul
     // INSTANCE BRIDGE below would otherwise answer yes. Same stripTrailingDiscourseTag
     // fix, applied here too.
     const objVariants = factTermVariants(normFactTerm, stripTrailingDiscourseTag(isaAsk[2]));
-    const subjCandidates = new Set(factTermVariants(normFactTerm, isaAsk[1]));
-    const noun = await entityClassNoun(graph, isaAsk[1]);
+    // "is that an animal" — the subject slot takes a context pronoun like every
+    // other reader in this file, resolved against the session's standing focus
+    // through IS_ADJECTIVE_PRONOUN_RE (the same set/swap the property, relation
+    // and ownership lanes above already use). With no focus standing, the
+    // pronoun stays literal and the lane keeps its existing decline — the miss
+    // below reads it as a pronoun and suppresses the "I don't know it at all"
+    // wording, which is still the right answer with nothing to bind to.
+    const isaSubject = focusLabel && IS_ADJECTIVE_PRONOUN_RE.test(isaAsk[1].trim())
+      ? focusLabel : isaAsk[1];
+    const subjCandidates = new Set(factTermVariants(normFactTerm, isaSubject));
+    const noun = await entityClassNoun(graph, isaSubject);
     if (noun) for (const v of factTermVariants(normFactTerm, noun)) subjCandidates.add(v);
     const hit = isa
       .filter((f) => subjCandidates.has(f.subject) && objVariants.has(f.object))
@@ -6494,7 +7036,7 @@ async function factReadBackReaders(memoryDir, query, envelope, miss, graph = nul
     // "controller ⊑ handler" composes with a graph "TaskController inherits
     // Controller" so "is TaskController a handler" answers yes, naming BOTH
     // sources (the graph edge + the taught fact with its provenance).
-    const ent = await resolveEntity(graph, isaAsk[1]);
+    const ent = await resolveEntity(graph, isaSubject);
     if (ent) {
       const bridgeSubjects = new Map(); // fact-term variant → the superclass label as spelled in the graph
       for (const sup of inheritsChain(graph, ent.id)) {
@@ -6529,7 +7071,7 @@ async function factReadBackReaders(memoryDir, query, envelope, miss, graph = nul
     //     technically-true-per-ConceptNet "yes" that has nothing to do with
     //     what the OPERATOR taught; only operator/teach/entailed-sourced isa
     //     facts are chased, matching "TAUGHT" in the gap's own name.
-    const { findIsaChain, SUBCLASS_PREDICATE: SC_PREDICATE, TYPE_PREDICATE: RDF_TYPE_PREDICATE } = await import("./syllogise.mjs");
+    const { findIsaChain, SUBCLASS_PREDICATE: SC_PREDICATE, TYPE_PREDICATE: RDF_TYPE_PREDICATE } = await import("../domain/syllogise.mjs");
     const isTaught = isOperatorTaught;
     const chainSubClassRows = isa.filter((f) => f.predicate === SC_PREDICATE && isTaught(f));
     const chainTypeRows = isa.filter((f) => f.predicate === RDF_TYPE_PREDICATE && isTaught(f));
@@ -6578,7 +7120,7 @@ async function factReadBackReaders(memoryDir, query, envelope, miss, graph = nul
     // answer "no" from absence-of-membership rather than decline; anything
     // this chase can't connect through a stated disjointness falls through
     // to the honest miss below, never a guessed "no".
-    const { deriveDisjointViolations, DISJOINT_PREDICATE } = await import("./syllogise.mjs");
+    const { deriveDisjointViolations, DISJOINT_PREDICATE } = await import("../domain/syllogise.mjs");
     const disjointRows = rows.filter((f) => f.predicate === DISJOINT_PREDICATE && isTaught(f));
     // NEGATED membership — "is a dog not a cat". ISA_ASK_RE captures the
     // subject as "dog not" (the "not" glues onto the subject because the
@@ -6591,7 +7133,14 @@ async function factReadBackReaders(memoryDir, query, envelope, miss, graph = nul
     // shape. Deliberately shallow — no chain chases on the negated side; a
     // negative proved through a multi-hop positive chain stays an honest
     // miss rather than a guess.
-    const negSubject = isaAsk[1].match(/^(.*\S)\s+not$/i);
+    // The pronoun swap above can't see this shape — the trailing "not" rides
+    // inside the subject capture ("is that not a cat"), so the bare subject
+    // resolves against the focus here instead, on the same terms.
+    const negSubjectMatch = isaSubject.match(/^(.*\S)\s+not$/i);
+    const negSubject = negSubjectMatch && [
+      negSubjectMatch[0],
+      focusLabel && IS_ADJECTIVE_PRONOUN_RE.test(negSubjectMatch[1].trim()) ? focusLabel : negSubjectMatch[1],
+    ];
     if (negSubject) {
       const negSubjVariants = factTermVariants(normFactTerm, negSubject[1]);
       const negObjVariants = objVariants;
@@ -6646,7 +7195,7 @@ async function factReadBackReaders(memoryDir, query, envelope, miss, graph = nul
     const {
       deriveSomeValuesFromApplication, ON_PROPERTY_PREDICATE, SOME_VALUES_FROM_PREDICATE,
       deriveSomeValuesFromSubsumption, ENTAILED_SCM_SVF_PROVENANCE, SCM_SVF_RULE_CONFIDENCE, entailedTrustFrom,
-    } = await import("./syllogise.mjs");
+    } = await import("../domain/syllogise.mjs");
     const onPropertyRows = rows.filter((f) => f.predicate === ON_PROPERTY_PREDICATE && isTaught(f));
     const someValuesFromRows = rows.filter((f) => f.predicate === SOME_VALUES_FROM_PREDICATE && isTaught(f));
     if (onPropertyRows.length && someValuesFromRows.length) {
@@ -6675,7 +7224,7 @@ async function factReadBackReaders(memoryDir, query, envelope, miss, graph = nul
       }
       // LIVE scm-svf1 PROOF CHASE (W3C OWL 2 RL Table 9's scm-svf1 — distinct
       // from scm-svf2, which needs rdfs:subPropertyOf, which the ACE grammar
-      // can't teach at all — see src/syllogise.mjs's own header comment): every
+      // can't teach at all — see src/domain/syllogise.mjs's own header comment): every
       // strategy above missed — two INDEPENDENTLY taught someValuesFrom
       // restrictions sharing the SAME property, whose filler classes are
       // themselves ⊑-related, license a restriction-to-restriction ⊑ fact
@@ -6691,7 +7240,7 @@ async function factReadBackReaders(memoryDir, query, envelope, miss, graph = nul
         const enlargedSubClassEdges = chainSubClassEdges.concat(svfSubsumption.map((d) => [d.subject, d.object]));
         // The SAME `min(premiseTrusts) x
         // ruleConfidence` discipline syllogise()'s own batch pass now applies
-        // to scm-svf1 (src/syllogise.mjs), computed here for this LIVE,
+        // to scm-svf1 (src/domain/syllogise.mjs), computed here for this LIVE,
         // read-only chase — each restriction's own onProperty/someValuesFrom
         // scaffolding trust plus the y1⊑y2 subClassOf premise that licensed
         // the comparison (always present, mirroring syllogise()'s own
@@ -6700,8 +7249,8 @@ async function factReadBackReaders(memoryDir, query, envelope, miss, graph = nul
         // syllogise()'s batch pass uses.
         const restrictionByRid = new Map(restrictionEdges.map((r) => [r.restriction, r]));
         const svfTrustByTriple = new Map();
-        for (const f of rows) svfTrustByTriple.set(`${f.subject}${f.predicate}${f.object}`, f.trust);
-        const svfPremiseTrust = (s, p, o) => svfTrustByTriple.get(`${s}${p}${o}`);
+        for (const f of rows) svfTrustByTriple.set(`${f.subject}\0${f.predicate}\0${f.object}`, f.trust);
+        const svfPremiseTrust = (s, p, o) => svfTrustByTriple.get(`${s}\0${p}\0${o}`);
         const svfTrustOf = new Map(); // "c1\0c2" -> computed trust, for the synthetic row below
         for (const d of svfSubsumption) {
           const r1 = restrictionByRid.get(d.subject);
@@ -6714,7 +7263,7 @@ async function factReadBackReaders(memoryDir, query, envelope, miss, graph = nul
             svfPremiseTrust(d.viaY1, SC_PREDICATE, d.viaY2),
           ].filter((t) => typeof t === "number");
           const t = entailedTrustFrom(premiseTrusts, SCM_SVF_RULE_CONFIDENCE);
-          if (t !== null) svfTrustOf.set(`${d.subject}${d.object}`, t);
+          if (t !== null) svfTrustOf.set(`${d.subject}\0${d.object}`, t);
         }
         // A derived restriction⊑restriction edge has no underlying stored
         // Fact row to cite (it's a schema-level conclusion, not a taught
@@ -6731,7 +7280,7 @@ async function factReadBackReaders(memoryDir, query, envelope, miss, graph = nul
           return derived
             ? {
               subject: derived.subject, predicate: SC_PREDICATE, object: derived.object, provenance: ENTAILED_SCM_SVF_PROVENANCE,
-              trust: svfTrustOf.get(`${derived.subject}${derived.object}`),
+              trust: svfTrustOf.get(`${derived.subject}\0${derived.object}`),
             }
             : undefined;
         };
@@ -6763,14 +7312,30 @@ async function factReadBackReaders(memoryDir, query, envelope, miss, graph = nul
     // with the graph entity's class noun (the CLASS↔INSTANCE bridge), and
     // filtering on it here would cite facts about that noun ("class ⊑
     // component") as if they were facts about the asked subject ("Widget").
-    const directSubjVariants = factTermVariants(normFactTerm, isaAsk[1]);
+    const directSubjVariants = factTermVariants(normFactTerm, isaSubject);
     const knownSubjectIsa = isa.filter((f) => directSubjVariants.has(f.subject)).sort(byTrust);
-    const subjectWord = isaAsk[1].trim();
+    const subjectWord = isaSubject.trim();
     const kindWord = stripTrailingDiscourseTag(isaAsk[2]).trim();
+    // A REPORTING probe, never an answer: re-run the same rooted search at
+    // findIsaChain's own default reach to learn whether a chain exists that
+    // the live chases above simply don't walk. The answer stays a miss either
+    // way — this only decides which recovery the miss can honestly name.
+    //
+    // Naming /syllogise unconditionally would be a lie whenever no such chain
+    // exists, and telling someone to teach a fact that already follows from
+    // what they taught is the mirror lie. The probe reads the SAME taught
+    // edge lists the chases use, and /syllogise closes over a superset of
+    // them, so a chain found here is one it can really materialize.
+    const deeperChainExists = [...subjCandidates].some(
+      (subj) => findIsaChain(subj, objVariants, chainTypeEdges, chainSubClassEdges, { maxHops: DEEP_CHAIN_PROBE_HOPS }),
+    );
     if (knownSubjectIsa.length) {
       const shown = knownSubjectIsa.slice(0, 3).map(renderFactLine).join("; ");
+      const recovery = deeperChainExists
+        ? `The facts to settle it are here, but the chain is longer than I follow while answering. Run "/syllogise ${subjectWord}", then ask me again.`
+        : `If it's true, teach me: "${subjectWord} is a kind of ${kindWord}".`;
       return {
-        text: `I can't confirm that — nothing I remember says ${subjectWord} is a ${kindWord}. I do know: ${shown}. If it's true, teach me: "${subjectWord} is a kind of ${kindWord}".`,
+        text: `I can't confirm that — nothing I remember says ${subjectWord} is a ${kindWord}. I do know: ${shown}. ${recovery}`,
         replace: true,
         miss: true, // still a MISS in the turn record — honest wording, not an answer
       };
@@ -6792,7 +7357,7 @@ async function factReadBackReaders(memoryDir, query, envelope, miss, graph = nul
 
   // (a1c-i) CARDINALITY MONOTONICITY — "does every X have at least N Y" over
   // a TAUGHT exactly/min cardinality restriction (pattern-5,
-  // src/grammar/ace.mjs's parseCardinality).
+  // src/domain/grammar/ace.mjs's parseCardinality).
   // FALLS THROUGH ON A MISS (see CARD_AT_LEAST_ASK_RE's own doc comment) —
   // never an unconditional decline, unlike isaAsk's own closing `return null`.
   const cardAtLeast = q.match(CARD_AT_LEAST_ASK_RE);
@@ -6801,7 +7366,7 @@ async function factReadBackReaders(memoryDir, query, envelope, miss, graph = nul
     const {
       SUBCLASS_PREDICATE: CARD_SC_PREDICATE, ON_PROPERTY_PREDICATE: CARD_ON_PROPERTY_PREDICATE,
       buildCardinalityRestrictions, proveCardinalityAtLeast, CARDINALITY_RULE_CONFIDENCE, entailedTrustFrom,
-    } = await import("./syllogise.mjs");
+    } = await import("../domain/syllogise.mjs");
     const isTaughtCard = isOperatorTaught;
     const cardSubClassEdges = isa.filter((f) => f.predicate === CARD_SC_PREDICATE && isTaughtCard(f)).map((f) => [f.subject, f.object]);
     const cardRows = rows.filter((f) => (f.predicate === CARD_ON_PROPERTY_PREDICATE || CARDINALITY_ROW_PREDICATES.has(f.predicate)) && isTaughtCard(f));
@@ -6817,7 +7382,7 @@ async function factReadBackReaders(memoryDir, query, envelope, miss, graph = nul
         const kindWord = witness.kind === "exactly" ? "exactly" : "at least";
         const plural = (w, n) => `${w}${n === 1 ? "" : "s"}`;
         // Premise-derived trust for THIS
-        // rule's answer (src/syllogise.mjs's CARDINALITY_RULE_CONFIDENCE doc
+        // rule's answer (src/domain/syllogise.mjs's CARDINALITY_RULE_CONFIDENCE doc
         // comment explains why there is no persisted Fact for it to attach
         // to) — the restriction's OWN scaffolding rows (onProperty/kind/
         // onClass, all keyed to witness.viaRestriction), the declaring
@@ -6851,7 +7416,7 @@ async function factReadBackReaders(memoryDir, query, envelope, miss, graph = nul
     const {
       SUBCLASS_PREDICATE: CARD_SC_PREDICATE, ON_PROPERTY_PREDICATE: CARD_ON_PROPERTY_PREDICATE,
       buildCardinalityRestrictions, proveMaxCardinalityZeroDenial, CAX_MAXC0_RULE_CONFIDENCE, entailedTrustFrom,
-    } = await import("./syllogise.mjs");
+    } = await import("../domain/syllogise.mjs");
     const isTaughtCard = isOperatorTaught;
     const cardSubClassEdges = isa.filter((f) => f.predicate === CARD_SC_PREDICATE && isTaughtCard(f)).map((f) => [f.subject, f.object]);
     const cardRows = rows.filter((f) => (f.predicate === CARD_ON_PROPERTY_PREDICATE || CARDINALITY_ROW_PREDICATES.has(f.predicate)) && isTaughtCard(f));
@@ -7062,7 +7627,7 @@ async function factReadBackReaders(memoryDir, query, envelope, miss, graph = nul
       // attempt, never a replacement: on no chain either, this falls through
       // to the ordinary property-miss handling just below, unchanged.
       {
-        const { findIsaChain: chaseAdj, SUBCLASS_PREDICATE: SC_PREDICATE_ADJ, TYPE_PREDICATE: TYPE_PREDICATE_ADJ } = await import("./syllogise.mjs");
+        const { findIsaChain: chaseAdj, SUBCLASS_PREDICATE: SC_PREDICATE_ADJ, TYPE_PREDICATE: TYPE_PREDICATE_ADJ } = await import("../domain/syllogise.mjs");
         const isTaughtAdj = isOperatorTaught;
         const chainSubClassRowsAdj = rows.filter((f) => f.predicate === SC_PREDICATE_ADJ && isTaughtAdj(f));
         const chainTypeRowsAdj = rows.filter((f) => f.predicate === TYPE_PREDICATE_ADJ && isTaughtAdj(f));
@@ -7139,7 +7704,12 @@ async function factReadBackReaders(memoryDir, query, envelope, miss, graph = nul
   // to the ordinary honest-miss cascade instead of fabricating a "no". Open
   // form lists every stored fact row for {subject, predicate} regardless of
   // object.
-  const genYN = q.match(GENERAL_VERB_YESNO_RE);
+  // The negation strips first, so "does fred not eat kale" and "doesn't fred
+  // eat kale" reach the SAME predicate lookup as "does fred eat kale" and the
+  // stored polarity — positive or negative — is what answers. The teach side
+  // strips through splitTeachNegation over the same NEG_MARKER_SRC, so the two
+  // sides can never disagree about what negates a sentence.
+  const genYN = positiveQuestionSurface(q).match(GENERAL_VERB_YESNO_RE);
   if (genYN && !GENERAL_VERB_ANYWHERE_EXCLUDE_RE.test(q)) {
     const [, subjectRaw, verbRaw, objectRaw] = genYN;
     const verb = verbRaw.toLowerCase();
@@ -7154,10 +7724,31 @@ async function factReadBackReaders(memoryDir, query, envelope, miss, graph = nul
         const predicate = folded.predicate;
         const subjVariants = factTermVariants(normFactTerm, subject);
         const objVariants = factTermVariants(normFactTerm, object);
+        // BOTH polarities are looked up under one predicate pair: a stored
+        // negative answers "no" as confidently as a positive answers "yes",
+        // and neither is ever inferred from the other's absence.
+        const polar = [predicate, negatedPredicate(predicate)];
         const hit = rows
-          .filter((f) => f.predicate === predicate && subjVariants.has(f.subject) && objVariants.has(f.object))
+          .filter((f) => polar.includes(f.predicate) && subjVariants.has(f.subject) && objVariants.has(f.object))
           .sort(byTrust)[0];
-        if (hit) return { text: `yes — ${renderFactLine(hit)}`, replace: true, generalVerbQuery: true };
+        if (hit) {
+          const verdict = isNegatedPredicate(hit.predicate) ? "no" : "yes";
+          return { text: `${verdict} — ${renderFactLine(hit)}`, replace: true, generalVerbQuery: true };
+        }
+        // A KNOWN subject under the SAME relation, no row matching this
+        // object: an honest, specific miss citing what the subject IS
+        // remembered to relate to, instead of the generic structural wall.
+        // Still never a guessed "no" — the text declines to confirm and says
+        // what it does know, and `miss: true` keeps it out of recall.
+        const sameRelation = rows.filter((f) => polar.includes(f.predicate) && subjVariants.has(f.subject));
+        if (sameRelation.length) {
+          const shown = sameRelation.slice(0, 3).map(renderFactLine).join("; ");
+          return {
+            text: `I can't confirm that — nothing I remember says ${factPhrase({ subject, predicate, object })}. I do know: ${shown}.`,
+            replace: true,
+            miss: true,
+          };
+        }
         return null; // no remembered fact — the honest miss stands (never a guessed "no")
       }
     }
@@ -7175,7 +7766,11 @@ async function factReadBackReaders(memoryDir, query, envelope, miss, graph = nul
         let predicate = await generalVerbPredicate(verb);
         if (verbPrep && /^mgx:[a-z]+$/.test(predicate)) predicate = `${predicate}-${verbPrep}`;
         const subjVariants = factTermVariants(normFactTerm, subject);
-        const hits = rankByBiasThenTrust(rows.filter((f) => f.predicate === predicate && subjVariants.has(f.subject)), biasByBundle);
+        // both polarities: "what does fred eat" should surface a remembered
+        // "fred does not eat kale" rather than miss on it — renderFactLine
+        // spells the polarity out, so the list can't be misread
+        const polar = [predicate, negatedPredicate(predicate)];
+        const hits = rankByBiasThenTrust(rows.filter((f) => polar.includes(f.predicate) && subjVariants.has(f.subject)), biasByBundle);
         if (hits.length) return { ...renderMany(hits), generalVerbQuery: true };
       }
     }
@@ -7265,7 +7860,7 @@ async function factReadBackReaders(memoryDir, query, envelope, miss, graph = nul
  *  nothing about this subject. */
 async function describedFacts(memoryDir, label, biasByBundle = {}, cache = null) {
   let normFactTerm;
-  try { ({ normFactTerm } = await import("./memory/core.mjs")); } catch { return null; }
+  try { ({ normFactTerm } = await import("../adapters/memory/core.mjs")); } catch { return null; }
   const rows = await factRows(memoryDir, cache);
   if (!rows.length) return null;
   const variants = factTermVariants(normFactTerm, label);
@@ -7296,8 +7891,8 @@ let corpusPromise = null; // the local slice as renderable rows, one load per pr
 function localCorpus() {
   if (!corpusPromise) {
     corpusPromise = (async () => {
-      const { loadSlice, loadMap, termText } = await import("./corpus/conceptnet.mjs");
-      const { normFactTerm } = await import("./memory/core.mjs");
+      const { loadSlice, loadMap, termText } = await import("../adapters/corpus/conceptnet.mjs");
+      const { normFactTerm } = await import("../adapters/memory/core.mjs");
       const [assertions, map] = await Promise.all([loadSlice(), loadMap()]);
       const rows = [];
       for (const a of assertions) {
@@ -7321,7 +7916,7 @@ function localCorpus() {
  *  where the tier-3 network lookup would attach — see CORPUS_LOOKUP_FLAG). */
 async function corpusAside(term) {
   try {
-    const { normFactTerm } = await import("./memory/core.mjs");
+    const { normFactTerm } = await import("../adapters/memory/core.mjs");
     const variants = factTermVariants(normFactTerm, term);
     const rows = (await localCorpus()).filter((r) => variants.has(r.key));
     if (!rows.length) return null;
@@ -7340,7 +7935,8 @@ const RECALL_ASK_RE = /^what (?:did|have) (?:i|we) (?:ask(?:ed)?(?: you)?|talk(?
  *  uuidv7s, so a plain sort is chronological). Null when nothing is folded yet. */
 async function recallSummary(memoryDir) {
   try {
-    const { loadBlockIndex, BLOCKS_DIR_REL } = await import("./memory/blocks.mjs");
+    const { loadBlockIndex, BLOCKS_DIR_REL } = await import("../adapters/memory/blocks.mjs");
+    const { readFile } = await import("node:fs/promises");
     const index = await loadBlockIndex(memoryDir);
     const id = Object.keys(index.blocks).sort().at(-1);
     if (!id) return null;
@@ -7428,6 +8024,28 @@ function discourseRewrite(query, last) {
   // that happens to contain "it"/"this"/"that" as a substring (whole-word
   // boundaries only).
   if (PRONOUN_IN_QUERY_RE.test(prevQ)) return prevQ.replace(PRONOUN_IN_QUERY_RE, () => newSubj);
+  // TOPIC SHIFT after a plain vocabulary question: "what is a dog" -> "what
+  // about cats" means "what is a cat". Such a prior query has neither a
+  // NAME_TOKEN nor a pronoun for the two rules above to swap, so both decline
+  // and the turn used to reach the wall.
+  //
+  // The gate is the PRIOR turn's own shape (BARE_WHATIS_RE — a plain "what
+  // is/are X"), never a looser reading of the new term. Widening NAME_TOKEN_RE
+  // to cover ordinary words would look like the same fix and is not: it would
+  // let "what about cats" rewrite "which modules import Widget" by swapping
+  // "modules", answering a question nobody asked.
+  //
+  // vagueTouchTermOf owns the "what about X" surface already, so the term
+  // comes from there rather than a second parse — it strips the article that
+  // WHAT_ABOUT_RE's own capture keeps ("what about a cat" -> "cat", not "a
+  // cat"). It reads the "what about"/"tell me about"/"explain" surfaces only,
+  // so the staccato swap ("and Widget") declines here and keeps the behaviour
+  // it has today. singularizeSurface matches the stored singular; facts are
+  // stored one way and "cats" would find nothing.
+  if (BARE_WHATIS_RE.test(prevQ)) {
+    const term = vagueTouchTermOf(query);
+    if (term) return `what is a ${singularizeSurface(term)}`;
+  }
   return null;
 }
 
@@ -7483,6 +8101,35 @@ function existentialAnythingRewrite(query) {
   return m ? `what ${m[1].trim()}` : null;
 }
 
+/** REVERSE CLEFT "what/who is it that <verb-phrase>" -> "what/who <verb-phrase>",
+ *  the closed sibling of EXISTENTIAL_ANYTHING_RE just above and the same trade:
+ *  a textual rewrite onto the ALREADY-CORRECT "what <verb> X" shape, no new
+ *  capability.
+ *
+ *  The "it that" here is pure scaffolding. A reverse cleft names no contrasted
+ *  element — "what is it that calls loadStore" asks exactly what "what calls
+ *  loadStore" asks, so dropping the frame loses nothing. Without the rewrite
+ *  parseKeywordSpot finds the verb, splits the text around it, and the leftover
+ *  "it that" survives the STOPWORDS filter (which carries "what"/"is" but not
+ *  "it"/"that") to become the subject — so the turn asks about an entity named
+ *  "it that" and misses.
+ *
+ *  The FORWARD cleft "is it X that calls Y" is deliberately left alone. It DOES
+ *  name a contrasted element ("it is X, not something else"), it already answers
+ *  correctly, and it discriminates: "is it createTask that calls saveStore" ->
+ *  yes, "is it loadStore that calls saveStore" -> no. Flattening that shape
+ *  would throw the contrast away for nothing.
+ *
+ *  The "that <verb-phrase>" tail is mandatory, exactly as it is for
+ *  EXISTENTIAL_ANYTHING_RE. A bare "what is it" has no tail and keeps its own
+ *  path, and "what time is it" never opens with "what is it" at all, so the
+ *  personal-assistant decline is untouched. */
+const REVERSE_CLEFT_RE = /^(what|who)\s+(?:is|was)\s+it\s+that\s+(.+?)\s*\??$/i;
+function reverseCleftRewrite(query) {
+  const m = REVERSE_CLEFT_RE.exec(String(query || "").trim());
+  return m ? `${m[1].toLowerCase()} ${m[2].trim()}` : null;
+}
+
 // ---- curated SEON definitions (corpus/seon/definitions.jsonl) ----
 // A "what is a <term>" for a LEXICON term prefers the curated one-sentence
 // definition, cited via:"corpus/seon" — but only when this repo carries the
@@ -7494,8 +8141,9 @@ let seonDefsPromise = null;
 function seonDefinitions() {
   if (!seonDefsPromise) {
     seonDefsPromise = (async () => {
-      const { SEON_DEFINITIONS_FILE } = await import("./corpus/conceptnet.mjs");
-      const { normFactTerm } = await import("./memory/core.mjs");
+      const { SEON_DEFINITIONS_FILE } = await import("../adapters/corpus/conceptnet.mjs");
+      const { normFactTerm } = await import("../adapters/memory/core.mjs");
+      const { readFile } = await import("node:fs/promises");
       const raw = await readFile(SEON_DEFINITIONS_FILE, "utf8");
       const map = new Map();
       for (const line of raw.split("\n")) {
@@ -7520,7 +8168,8 @@ let seonRelsPromise = null;
 function relationDefinitions() {
   if (!seonRelsPromise) {
     seonRelsPromise = (async () => {
-      const { SEON_DEFINITIONS_FILE } = await import("./corpus/conceptnet.mjs");
+      const { SEON_DEFINITIONS_FILE } = await import("../adapters/corpus/conceptnet.mjs");
+      const { readFile } = await import("node:fs/promises");
       const relFile = join(dirname(SEON_DEFINITIONS_FILE), "relations.jsonl");
       const raw = await readFile(relFile, "utf8");
       const map = new Map();
@@ -7543,7 +8192,7 @@ function relationDefinitions() {
  *  — NOT grammar.mjs's structural T5 template, which keeps its article MANDATORY
  *  on purpose (a bare "what is <anything>" would also swallow "what is the
  *  meaning of this codebase", an existing, deliberately honest grammar-miss
- *  regression — test/ask.test.mjs pins it null; see T5's own docblock). That
+ *  regression — test/tools/ask.test.mjs pins it null; see T5's own docblock). That
  *  collision risk is a STRUCTURAL-PARSE concern (T5's tail becomes the literal
  *  graph-query object); it doesn't apply here: this regex only extracts a
  *  SUBJECT STRING to look up against the memory Facts store / curated lexicon —
@@ -7611,12 +8260,12 @@ async function curatedDefinitionAnswer(query, envelope, { memoryDir, lexicon })
   const term = metaTermOf(query, envelope);
   if (!term) return null;
   let normFactTerm;
-  try { ({ normFactTerm } = await import("./memory/core.mjs")); } catch { return null; }
+  try { ({ normFactTerm } = await import("../adapters/memory/core.mjs")); } catch { return null; }
   // lexicon-noun gate: the curated defs are keyed on SE lexicon terms only.
   let lex = lexicon;
   try {
-    if (!lex) { const { loadLexicon } = await import("./grammar/lexicon.mjs"); lex = loadLexicon(); }
-    const { lookupNoun } = await import("./grammar/lexicon.mjs");
+    if (!lex) { const { loadLexicon } = await import("../domain/grammar/lexicon.mjs"); lex = loadLexicon(); }
+    const { lookupNoun } = await import("../domain/grammar/lexicon.mjs");
     if (!lookupNoun(lex, term)) return null;
   } catch { return null; }
   const def = (await seonDefinitions()).get(normFactTerm(term));
@@ -7793,7 +8442,7 @@ async function describeGrainRescue(graph, term) {
   const expectedClass = ENTITY_TO_TYPE[grainWord.toLowerCase()];
   if (!head?.trim() || !expectedClass) return null;
   try {
-    const { resolveObject } = await import("./ask.mjs");
+    const { resolveObject } = await import("../domain/ask.mjs");
     const r = resolveObject(graph, head.trim(), { expectedClass });
     if (r?.match?.id && !r.ambiguous) return { id: r.match.id, label: r.match.label };
   } catch { /* tolerated */ }
@@ -7926,7 +8575,7 @@ async function compareAnswer(query, { graph, config, source }) {
 
 /** DETAILED-SUMMARY / EXPLAIN-IN-DETAIL closed phrasings — "give me a detailed
  *  summary of how the task system works" / "explain in detail how X works" /
- *  "give me a detailed overview of X", wired to src/completions/'s extractive
+ *  "give me a detailed overview of X", wired to src/domain/completions/'s extractive
  *  multi-sentence pipeline below. Two closed shapes (DETAILED_HOW_WORKS_RE
  *  tried first, more specific); distinct from DESCRIBE_WRAPPER_RE, which
  *  neither anchors on "give me"/"explain ... in detail". */
@@ -7936,9 +8585,9 @@ const DETAILED_HOW_WORKS_RE =
 const DETAILED_OVERVIEW_RE =
   /^(?:(?:can|could|would)\s+you\s+(?:please\s+)?|please\s+)?give\s+me\s+a\s+detailed\s+(?:overview|summary|explanation)\s+of\s+(.+?)\s*\??$/i;
 
-/** THE COMPLETIONS RESCUE — wires src/completions/'s extractive, cited,
+/** THE COMPLETIONS RESCUE — wires src/domain/completions/'s extractive, cited,
  *  groundedness-checked multi-sentence pipeline (generateCompletion(),
- *  src/completions/complete.mjs) into live chat dispatch. Tried in runAsk
+ *  src/domain/completions/complete.mjs) into live chat dispatch. Tried in runAsk
  *  ONLY after (4d) DESCRIBE-WRAPPER RESCUE has already declined, and only for
  *  an EXPLICIT detailed/multi-sentence request (DETAILED_HOW_WORKS_RE /
  *  DETAILED_OVERVIEW_RE, above). Honest by construction: generateCompletion()
@@ -7959,13 +8608,13 @@ async function completionsRescueAnswer(query, { memoryDir, graph }) {
   term = term.replace(/^(?:the|a|an)\s+/i, "").trim();
   if (!term) return null;
   try {
-    const { generateCompletion } = await import("./completions/complete.mjs");
+    const { generateCompletion } = await import("./completions.mjs");
     // createCompletionsGraphAdapter wraps the SAME graph object this turn
     // already has in scope plus this repo's already-loaded Fact store, so
     // broadSearch can search live graph/memory content, not just saved
     // memory blocks.
-    const { createCompletionsGraphAdapter } = await import("./completions/graph-adapter.mjs");
-    const { loadMemory } = await import("./memory/core.mjs");
+    const { createCompletionsGraphAdapter } = await import("./completions.mjs");
+    const { loadMemory } = await import("../adapters/memory/core.mjs");
     const memory = await loadMemory(memoryDir);
     const graphService = createCompletionsGraphAdapter(graph, memory);
     const result = await generateCompletion(memoryDir, term, { query: term, graph, memory, graphService });
@@ -7987,7 +8636,7 @@ async function relationForceAnswer(query, envelope, { graph, config, source, tem
   const rawTerm = relationTermOf(query, envelope);
   if (!rawTerm) return null;
   let composeRelation; let RELATION_TERM;
-  try { ({ composeRelation, RELATION_TERM } = await import("./concept.mjs")); }
+  try { ({ composeRelation, RELATION_TERM } = await import("../domain/concept.mjs")); }
   catch { return null; }
   const term = String(rawTerm).toLowerCase();
   const kind = RELATION_TERM[term];
@@ -8026,8 +8675,8 @@ async function conceptForceAnswer(query, envelope, { graph, config, source, memo
   if (!rawTerm) return null;
   let normFactTerm; let composeConcept; let CONCEPT_CLASS;
   try {
-    ({ normFactTerm } = await import("./memory/core.mjs"));
-    ({ composeConcept, CONCEPT_CLASS } = await import("./concept.mjs"));
+    ({ normFactTerm } = await import("../adapters/memory/core.mjs"));
+    ({ composeConcept, CONCEPT_CLASS } = await import("../domain/concept.mjs"));
   } catch { return null; }
   const term = normFactTerm(rawTerm);
   if (!CONCEPT_CLASS[term]) return null; // not an enumerable code concept — ordinary path owns it
@@ -8081,7 +8730,7 @@ async function entityOfKindInText(graph, expectedClass, answerText) {
     if (seen.has(key)) continue;
     seen.add(key);
     try {
-      const { resolveObject } = await import("./ask.mjs");
+      const { resolveObject } = await import("../domain/ask.mjs");
       const r = resolveObject(graph, tok, { expectedClass });
       if (r?.match?.id && !r.ambiguous) return { id: r.match.id, label: r.match.label };
     } catch { /* tolerated — falls through to the next token */ }
@@ -8099,8 +8748,8 @@ async function entityOfKindInText(graph, expectedClass, answerText) {
  *  through src/domain.mjs. Fresh-loads memory (never the turn cache) because
  *  the caller may have just written snapshot rows this same turn. */
 async function loadPlanContext(memoryDir) {
-  const { loadMemory, readFactRows, readRuleRows } = await import("./memory/core.mjs");
-  const { compileDomain, stateFromFacts } = await import("./domain.mjs");
+  const { loadMemory, readFactRows, readRuleRows } = await import("../adapters/memory/core.mjs");
+  const { compileDomain, stateFromFacts } = await import("../domain/domain.mjs");
   const payload = await loadMemory(memoryDir);
   const factRows = readFactRows(payload);
   const ruleRows = readRuleRows(payload);
@@ -8118,6 +8767,32 @@ function actionLabel(name, subject, target) {
   return `${verb} ${subject} ${prep} ${target}`;
 }
 
+/** Which verb does a verbless locative goal ("every disk on peg-b") mean? The
+ *  sentence never says, and a preposition doesn't imply one — "on" reads as
+ *  rest-on, stand-on, sit-on or lie-on with equal warrant, so any prep→verb
+ *  table here would be invention. The taught facts answer instead: every
+ *  locative fact (LOCATIVE_FACT_PREDICATE_RE's closed predicate tail) about a
+ *  member of the goal's class whose preposition is the one typed contributes
+ *  its verb. Returns the candidates, sorted. Exactly one is an answer; none or
+ *  several is the caller's decline. */
+function goalVerbsFromTaughtFacts(factRows, domain, { universal, term, prep }) {
+  const subjects = new Set(universal ? domain?.classMembers?.[term] || [] : [term]);
+  const verbs = new Set();
+  for (const row of factRows || []) {
+    if (!LOCATIVE_FACT_PREDICATE_RE.test(row.predicate)) continue;
+    if (!subjects.has(row.subject)) continue;
+    const [factVerb, factPrep] = row.predicate.slice("mgx:".length).split("-");
+    if (factPrep === prep) verbs.add(factVerb);
+  }
+  return [...verbs].sort();
+}
+
+/** Do two goal specs state the same goal? Every field is already normalized
+ *  (normFactTerm on the terms, a lemma + a lowercased preposition on the
+ *  predicate), so equality on the four scalars is the whole comparison. */
+const sameGoalSpec = (a, b) =>
+  a.universal === b.universal && a.term === b.term && a.predicate === b.predicate && a.object === b.object;
+
 /** THE PLAN LANE — the closed goal/solve/legal-moves recognizers over the
  *  taught action rules (PLAN_HANOI's chat surface). Returns
  *  { text, via, deduced, note, plan? } or null when the query is none of the
@@ -8125,10 +8800,78 @@ function actionLabel(name, subject, target) {
 async function planLaneAnswer(query, { memoryDir, planHolder, sessionId = "", }) {
   const q = String(query).trim();
 
+  // "can you move a disk onto a peg?" — read the taught action signatures back.
+  // Answered HERE rather than beside the other capability readers because
+  // CAN_ASK_RE would otherwise claim the query first, bind the verb to "peg",
+  // find no mgx:capableOf row and miss.
+  const capabilityAsk = q.match(ACTION_SIGNATURE_ASK_RE);
+  if (capabilityAsk) {
+    const { loadMemory, readRuleRows } = await import("../adapters/memory/core.mjs");
+    const { actionFamilies, capabilityFromActionRules } = await import("../domain/router/taught.mjs");
+    // The same lemma authority the teach lane mints the rule name through, so
+    // either taught voicing is found by either asked voicing.
+    const familyName = `${await verbLemma(capabilityAsk[1])} ${capabilityAsk[3].toLowerCase()}`;
+    const subjectClass = capabilityAsk[2].toLowerCase();
+    const targetClass = capabilityAsk[4].toLowerCase();
+    const asked = actionLabel(familyName, `a ${subjectClass}`, `a ${targetClass}`);
+    let family = null;
+    try {
+      family = actionFamilies(readRuleRows(await loadMemory(memoryDir))).get(familyName) || null;
+    } catch { /* an unreadable store reads back like an empty one */ }
+    if (!family) {
+      return {
+        text: `no — nothing you taught me says you can ${asked}. Teach it with "you can ${asked}."`,
+        via: "plan", deduced: "check whether a taught action rule covers an action",
+        note: `CAPABILITY frame — no "${familyName}" action rule in the store, honest decline`,
+      };
+    }
+    const classesFor = (slot) =>
+      capabilityFromActionRules(familyName, family).parameters.find((p) => p.name === slot)?.classes.filter(Boolean) || [];
+    const subjectClasses = classesFor("subject");
+    const targetClasses = classesFor("target");
+    const signature = `subject: ${subjectClasses.join("|") || "?"}, target: ${targetClasses.join("|") || "?"}`;
+    if (!subjectClasses.includes(subjectClass) || !targetClasses.includes(targetClass)) {
+      return {
+        text: `no — the "${familyName}" rule you taught me covers ${signature}, and nothing you taught me says you can ${asked}.`,
+        via: "plan", deduced: "check whether a taught action rule covers an action",
+        note: `CAPABILITY frame — the "${familyName}" family is taught but covers ${signature}, honest decline`,
+      };
+    }
+    return {
+      text: `yes — you can ${asked}. You taught me the "${familyName}" rule (${signature}).`,
+      via: "plan", deduced: "check whether a taught action rule covers an action",
+      note: `CAPABILITY frame — the taught "${familyName}" family covers ${signature}`,
+    };
+  }
+
   const thatGoal = q.match(GOAL_TEACH_RE);
-  const goalMatch = thatGoal || q.match(GOAL_TEACH_INFINITIVE_RE);
+  let goalMatch = thatGoal || q.match(GOAL_TEACH_INFINITIVE_RE);
+  // The verbless voicing carries every capture but the verb, so it folds into
+  // the frame below once the store names the verb — same spec, same
+  // confirmation, same fold as its verbed twin.
+  const verblessGoal = goalMatch ? null : q.match(GOAL_TEACH_VERBLESS_RE);
+  if (verblessGoal) {
+    const { normFactTerm } = await import("../adapters/memory/core.mjs");
+    const { factRows, domain } = await loadPlanContext(memoryDir);
+    const prep = verblessGoal[3].toLowerCase();
+    const quantified = `${verblessGoal[1] ? `${verblessGoal[1].toLowerCase()} ` : ""}${verblessGoal[2].toLowerCase()}`;
+    const stated = `${quantified} ${prep} ${verblessGoal[4].toLowerCase()}`;
+    const verbs = goalVerbsFromTaughtFacts(factRows, domain, {
+      universal: !!verblessGoal[1], term: normFactTerm(verblessGoal[2]), prep,
+    });
+    if (verbs.length !== 1) {
+      return {
+        text: verbs.length
+          ? `"${stated}" leaves the verb out, and what you taught me leaves it open — ${verbs.map((v) => `"${v} ${prep}"`).join(" and ")} both fit. Say which one, e.g. "i want ${quantified} to ${verbs[0]} ${prep} ${verblessGoal[4].toLowerCase()}".`
+          : `"${stated}" leaves the verb out, and nothing you taught me says what ${quantified} does ${prep} anything. Name the verb, e.g. "the goal is that every disk rests on peg-c".`,
+        via: "plan", deduced: "record the goal state for a later plan",
+        note: `GOAL frame — the verbless voicing's "${prep}" matched ${verbs.length} taught locative verbs, honest decline`,
+      };
+    }
+    goalMatch = [verblessGoal[0], verblessGoal[1], verblessGoal[2], verbs[0], verblessGoal[3], verblessGoal[4]];
+  }
   if (goalMatch) {
-    const { normFactTerm } = await import("./memory/core.mjs");
+    const { normFactTerm } = await import("../adapters/memory/core.mjs");
     const verb = await verbLemma(goalMatch[3]);
     if (!verb) {
       return {
@@ -8148,16 +8891,31 @@ async function planLaneAnswer(query, { memoryDir, planHolder, sessionId = "", })
       // own "done — …" line and the confirmation read identically either way.
       : `${goalMatch[1] ? `${goalMatch[1].toLowerCase()} ` : ""}${goalMatch[2].toLowerCase()} ${verb}s ${goalMatch[4].toLowerCase()} ${goalMatch[5].toLowerCase()}`;
     const prev = planHolder.state && Array.isArray(planHolder.state.goals) && !planHolder.state.done ? planHolder.state : null;
+    const heldGoals = prev?.goals ?? [];
+    const heldTexts = prev?.goalTexts ?? [];
+    // Restating a goal you already set is one goal, not two. The spec is four
+    // normalized scalars, so the same goal in either voicing ("the goal is
+    // that …" / "the goal is to …") compiles to the identical object and a
+    // deep-equal catches it. Folded in the STORE, not at the read: deduping in
+    // "solve it" would leave the duplicate sitting in planHolder.state and
+    // leave "(N goals held)" saying something untrue.
+    //
+    // goals and goalTexts move in LOCKSTEP — "solve it" joins goalTexts by
+    // index to describe the specs it compiled, so dropping one without the
+    // other misaligns the plan's own account of what it is solving for.
+    const alreadyHeld = heldGoals.some((g) => sameGoalSpec(g, spec));
     planHolder.state = {
-      goals: [...(prev?.goals ?? []), spec],
-      goalTexts: [...(prev?.goalTexts ?? []), tail],
+      goals: alreadyHeld ? heldGoals : [...heldGoals, spec],
+      goalTexts: alreadyHeld ? heldTexts : [...heldTexts, tail],
       actions: null, states: null, stepGoals: null, cursor: 0, done: false,
     };
     const n = planHolder.state.goals.length;
     return {
-      text: `noted — the goal is that ${tail}.${n > 1 ? ` (${n} goals held)` : ""} Say "solve it" when the state is taught.`,
+      text: `${alreadyHeld ? "already noted" : "noted"} — the goal is that ${tail}.${n > 1 ? ` (${n} goals held)` : ""} Say "solve it" when the state is taught.`,
       via: "plan", deduced: "record the goal state for a later plan",
-      note: "GOAL frame — goal spec accumulated on the session plan slot",
+      note: alreadyHeld
+        ? "GOAL frame — the same goal spec was already held, so it folded onto the existing one"
+        : "GOAL frame — goal spec accumulated on the session plan slot",
     };
   }
 
@@ -8184,7 +8942,7 @@ async function planLaneAnswer(query, { memoryDir, planHolder, sessionId = "", })
       via: "plan", deduced: "plan a move sequence (no state yet)", note: "plan lane — honest decline: empty state",
     };
   }
-  const { movesFromRules, stateKeyFor, compileGoal, PlanBudgetError } = await import("./domain.mjs");
+  const { movesFromRules, stateKeyFor, compileGoal, PlanBudgetError } = await import("../domain/domain.mjs");
 
   if (wantsLegal) {
     let moves;
@@ -8222,7 +8980,7 @@ async function planLaneAnswer(query, { memoryDir, planHolder, sessionId = "", })
   } catch (err) {
     return { text: `I can't compile that goal: ${err?.message ?? err}`, via: "plan", deduced: "plan a move sequence (uncompilable goal)", note: "plan lane — goal compile decline" };
   }
-  const { findActionPath } = await import("./planning.mjs");
+  const { findActionPath } = await import("../domain/planning.mjs");
   let found;
   try {
     found = findActionPath(state, isGoal, (s) => movesFromRules(s, domain), { maxDepth: 300, stateKey: stateKeyFor });
@@ -8283,7 +9041,7 @@ async function executePlanStep(planHolder, { memoryDir, sessionId = "" }) {
   const k = ps.cursor + 1;
   const action = ps.actions[ps.cursor];
   const rows = ps.states[k];
-  const { appendFact, loadMemory, readFactRows } = await import("./memory/core.mjs");
+  const { appendFact, loadMemory, readFactRows } = await import("../adapters/memory/core.mjs");
   for (const row of rows) {
     await appendFact(memoryDir, {
       subject: `${row.subject}@step${k}`, predicate: row.predicate, object: row.object,
@@ -8299,8 +9057,8 @@ async function executePlanStep(planHolder, { memoryDir, sessionId = "" }) {
     };
   }
   // Final step: confirm the goal against the store, from the written facts.
-  const { compileDomain, stateFromFacts, compileGoal } = await import("./domain.mjs");
-  const { readRuleRows } = await import("./memory/core.mjs");
+  const { compileDomain, stateFromFacts, compileGoal } = await import("../domain/domain.mjs");
+  const { readRuleRows } = await import("../adapters/memory/core.mjs");
   const payload = await loadMemory(memoryDir);
   const factRows = readFactRows(payload);
   const domain = compileDomain(factRows, readRuleRows(payload));
@@ -8381,7 +9139,7 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
       // binds) OR the previous turn produced a set to refer back to (thread it as
       // `prev` for the anaphora node). Builds the SAME delimited envelope dispatchTool
       // emits, so the parse below is identical either way.
-      const { ask } = await import("./ask.mjs");
+      const { ask } = await import("../domain/ask.mjs");
       const r = ask(graph, askQuery, { contextId: effectiveContextId, prev });
       text = `${r.content}${ASK_ENVELOPE_DELIM}${JSON.stringify(r.tmct_ask, null, 2)}`;
     } else {
@@ -8633,7 +9391,7 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
       ? null : (matchBareHabitualTeach(bareLine) || matchBareCanTeach(bareLine));
     if (pm || habitual) {
       try {
-        const { loadLexicon, lookupNoun } = await import("./grammar/lexicon.mjs");
+        const { loadLexicon, lookupNoun } = await import("../domain/grammar/lexicon.mjs");
         const lex = loadLexicon();
         if (pm) {
           const s = singularizeSurface(pm[1].toLowerCase());
@@ -8657,7 +9415,7 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
             } else {
               habitualGroundingHint = habitualGroundingHintText(
                 bareLine.replace(/[.!?]+\s*$/, ""),
-                { subject: subjects[subjects.length - 1], verb: habitual.verb },
+                { ...habitual, subject: subjects[subjects.length - 1] },
               );
             }
           }
@@ -8691,7 +9449,7 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
     const relTerm = relationTermOf(String(query), envelope);
     if (relTerm) {
       try {
-        const { RELATION_TERM } = await import("./concept.mjs");
+        const { RELATION_TERM } = await import("../domain/concept.mjs");
         isVagueRelationTouch = !!RELATION_TERM[relTerm.toLowerCase()];
       } catch { /* leave false — the ordinary path decides */ }
     }
@@ -8742,7 +9500,7 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
   let bareMetaHit = null;
   if ((isConversationalCandidate || isBareCamelCaseWhatisCandidate) && (bareWhatisShape || isAdjectiveShape || reversePredicateShape || capabilityAskShape)) {
     if (memoryDir) {
-      bareMetaHit = (await factAnswer(memoryDir, gateQuery, envelope, miss, biasByBundle, cache))
+      bareMetaHit = (await factAnswer(memoryDir, gateQuery, envelope, miss, biasByBundle, cache, newFocus?.label))
         ?? (await factReadBack(memoryDir, gateQuery, envelope, miss, graph, newFocus?.label, biasByBundle, cache));
       // An honest-miss return never diverts the gate — EXCEPT the capability
       // family's can't-confirm, which names the subject's real capabilities
@@ -8766,7 +9524,7 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
     if (!bareMetaHit && graph) {
       const term = metaTermOf(gateQuery, envelope);
       if (term) {
-        const { metaFallbackEntityAnswer } = await import("./ask.mjs");
+        const { metaFallbackEntityAnswer } = await import("../domain/ask.mjs");
         const fallback = metaFallbackEntityAnswer(graph, term);
         if (fallback) bareMetaHit = { text: fallback.text, replace: true };
       }
@@ -8778,11 +9536,20 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
   // lookup and "divert only on a REAL, UNIQUE hit" discipline: it only
   // returns non-null for an EXACT label match, so ordinary small talk is
   // unaffected.
-  if (!bareMetaHit && isConversationalCandidate && graph) {
-    const { metaFallbackEntityAnswer } = await import("./ask.mjs");
+  //
+  // `isBareCamelCaseEntityCandidate` ORs in for THIS lane the way
+  // isBareCamelCaseWhatisCandidate does for (2b) — a bare "TaskController" is
+  // excluded from isConversationalCandidate solely by the CamelCase transition,
+  // while a bare "task" reaches the lane. Same base gate and same
+  // `!vocabAntecedent`, so it's never looser than the gate it joins.
+  const isBareCamelCaseEntityCandidate = conversationalCandidateBaseGate && !vocabAntecedent
+    && isBareCamelCaseEntityName(query);
+  if (!bareMetaHit && (isConversationalCandidate || isBareCamelCaseEntityCandidate) && graph) {
+    const { metaFallbackEntityAnswer } = await import("../domain/ask.mjs");
     const fallback = metaFallbackEntityAnswer(graph, String(query).trim());
     if (fallback) bareMetaHit = { text: fallback.text, replace: true };
   }
+  const coldPronounDecline = focus?.label ? null : coldPronounDeclineText(query);
   if (bareMetaHit) {
     answer = bareMetaHit.replace ? bareMetaHit.text : `${answer}\n${bareMetaHit.text}`;
     // Same discipline as lane (3): a fact-lane return flagged `miss` is an
@@ -8809,6 +9576,16 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
     via = "teach-miss"; handled = true;
     note(trace, "lane: (2) BARE TEACH NUDGE — a bare name-verb-name declarative stays wrapper-required; suggested the remember-that form");
     note(trace, "goal: teach/remember a new fact (wrapper required for the bare form)");
+  } else if (isConversationalCandidate && coldPronounDecline) {
+    // A subject-position pronoun with no antecedent anywhere: no vocabulary
+    // subject bound upstream, and no code focus for it to mean either. The
+    // orientation card would introduce the tool; naming the pronoun says what
+    // actually went wrong. Still a miss in the record — honest wording, not an
+    // answer.
+    answer = coldPronounDecline;
+    via = "template"; handled = true;
+    note(trace, "lane: (2) COLD PRONOUN — a subject pronoun with no antecedent bound and no focus standing; named the pronoun instead of the orientation card");
+    note(trace, "goal: resolve a pronoun to a subject (nothing named yet)");
   } else if (isConversationalCandidate) {
     // A conversational miss (a greeting, "what can you do", a very short non-code
     // line) gets the friendly orientation (module-aware: empty → --repo/tmct init).
@@ -8845,10 +9622,10 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
     // normalization-mangled text reach readers whose guards were written for
     // the raw surface (the pronoun-subject identity family).
     const normalizedForFacts = envelope ? null : normalizeQuery(String(query));
-    const fact = (await factAnswer(memoryDir, query, envelope, miss, biasByBundle, cache))
+    const fact = (await factAnswer(memoryDir, query, envelope, miss, biasByBundle, cache, newFocus?.label))
       ?? (await factReadBack(memoryDir, query, envelope, miss, graph, newFocus?.label, biasByBundle, cache))
       ?? (normalizedForFacts && normalizedForFacts !== String(query).trim()
-        ? (await factAnswer(memoryDir, normalizedForFacts, envelope, miss, biasByBundle, cache))
+        ? (await factAnswer(memoryDir, normalizedForFacts, envelope, miss, biasByBundle, cache, newFocus?.label))
           ?? (await factReadBack(memoryDir, normalizedForFacts, envelope, miss, graph, newFocus?.label, biasByBundle, cache))
         : null);
     if (fact) {
@@ -9061,7 +9838,7 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
       }
     }
   }
-  // (4e) COMPLETIONS RESCUE — wires src/completions/'s extractive
+  // (4e) COMPLETIONS RESCUE — wires src/domain/completions/'s extractive
   // multi-sentence pipeline in as a genuine last-resort lane, tried ONLY here,
   // after EVERY lane above has already declined; this lane only fires for an
   // EXPLICIT "detailed summary/overview of how X works" phrasing, a shape
@@ -9070,8 +9847,8 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
     const completed = await completionsRescueAnswer(query, { memoryDir, graph });
     if (completed) {
       answer = completed.text; via = "completion"; recordMiss = false;
-      note(trace, "lane: (4e) COMPLETIONS RESCUE — a \"detailed summary/overview of how X works\" phrasing matched, answered via src/completions/'s extractive multi-sentence pipeline (generateCompletion())");
-      note(trace, "source: src/completions/complete.mjs generateCompletion() (broadSearch + groupHits + rankSentences + inferRelations + pruneCompletion + finish())");
+      note(trace, "lane: (4e) COMPLETIONS RESCUE — a \"detailed summary/overview of how X works\" phrasing matched, answered via src/domain/completions/'s extractive multi-sentence pipeline (generateCompletion())");
+      note(trace, "source: src/domain/completions/complete.mjs generateCompletion() (broadSearch + groupHits + rankSentences + inferRelations + pruneCompletion + finish())");
       note(trace, "goal: produce a grounded, cited, multi-sentence account of the subject (not a single fact/definition)");
     }
   }
@@ -9096,6 +9873,37 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
       }
     }
   }
+  // (4g) FUZZY-VERB DECLINE — the keyword strategy's bounded-edit-distance
+  // tier rewrites ANY word within one edit of a graph verb, with no check that
+  // the typed word is real English: "rest" reads as "test", "during" as
+  // "using", "bigger" as "trigger", "behave" as "have", "ball" as "call".
+  // Whatever the repaired sentence traverses to answers a DIFFERENT question,
+  // and it does not read like one — "does store.mjs rest on app.mjs" comes
+  // back "No — no tests edge found", and a reader takes the No. So name the
+  // rewrite and refuse, dropping both halves of the receipt with it (a receipt
+  // for a question nobody asked is the same wrong answer in smaller type).
+  //
+  // Tried HERE, after every rescue lane above has already declined, for the
+  // same reason (4d)/(4e)/(4f) are: a repaired sentence some other lane can
+  // answer keeps that answer untouched. This only ever replaces the repaired
+  // parse's OWN standing reply.
+  //
+  // A real English word never reaches here: the repair tier's own collision table
+  // (src/domain/real-word-collisions.json) refuses it before any distance is
+  // measured, so "rest" misses as itself. What is left for this lane is a NON-word
+  // that repaired onto a verb whose lemma differs from the word it came from —
+  // "impotr" still repairs to "import" and answers, because they share one.
+  if (miss && recordMiss && via === "composed" && envelope?.parsed?.fuzzyVerb) {
+    const { from, to } = envelope.parsed.fuzzyVerb;
+    if (!(await repairSharesLemma(from, to))) {
+      answer = `I read "${from}" as "${to}", which asks a different question — so I won't answer it. `
+        + `"${from}" isn't a relation I record. Say the relation you mean, or /help for the query shapes I read.`;
+      via = "miss";
+      canonical = null;
+      deduced = null;
+      note(trace, `lane: (4g) FUZZY-VERB DECLINE — "${from}" only became a verb through the edit-distance repair tier ("${to}"), and the two words are different verbs, so the repaired sentence's graph answer is dropped rather than shown as an answer to what was typed`);
+    }
+  }
   // (5) #1 SHORT TAILORED MISS — replace ONLY the engine's full grammar cheat-sheet
   // wall (WALL_MISS_RE). Receipt-bearing misses keep their specific wording.
   // WALL KINDNESS: a second consecutive wall collapses to a one-liner whose
@@ -9124,11 +9932,14 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
     // without a resolveEntity(graph) gate: it's inherently a MEMORY question,
     // so "nothing yet, teach me" is appropriate even when X is also a real
     // graph entity.
-    const knowAboutTerm = String(query).trim().match(KNOW_ABOUT_RE)?.[1]?.trim();
-    const offerTerm = knowAboutTerm || metaTermOf(query, envelope);
+    // Contraction-expanded, so "what's X" earns the same offer "what is X"
+    // does. Both shapes below anchor on the written-out copula.
+    const offerSrc = expandContractions(String(query).trim());
+    const knowAboutTerm = offerSrc.match(KNOW_ABOUT_RE)?.[1]?.trim();
+    const offerTerm = knowAboutTerm || metaTermOf(offerSrc, envelope);
     if (offerTerm) {
       let normFactTerm;
-      try { ({ normFactTerm } = await import("./memory/core.mjs")); } catch { normFactTerm = null; }
+      try { ({ normFactTerm } = await import("../adapters/memory/core.mjs")); } catch { normFactTerm = null; }
       if (normFactTerm) {
         const cleanTerm = normFactTerm(offerTerm);
         const ent = knowAboutTerm ? null : await resolveEntity(graph, offerTerm);
@@ -9265,6 +10076,7 @@ const GOAL_BY_COMMAND = {
   exports: GOAL_BY_KIND.reexports,
   arch: "understand the overall architecture (package/module boundaries)",
   capabilities: "see what /plan can plan over — built-in query tools and taught actions",
+  syllogise: "materialize the entailed facts that follow from what's remembered about one term",
 };
 
 /** A slash-command → the mapped tool (or the /help, /focus, /narrate, unknown
@@ -9312,7 +10124,7 @@ async function runCommand(line, { config, source, graph, focus, memoryDir, trace
     note(trace, "goal: inspect tmct's memory store (facts/utterances/sessions)");
     if (!memoryDir) return mk("no memory store here — /memory works inside a repo session.", { miss: true });
     try {
-      const { inspectMemory } = await import("./memory/inspect.mjs");
+      const { inspectMemory } = await import("../adapters/memory/inspect.mjs");
       return mk(await inspectMemory(memoryDir, { verbose: /^(?:-v|--verbose|verbose)$/i.test(argText) }));
     } catch (e) {
       return mk(String(e?.message || e), { miss: true }); // a broken store reads as its own clean error
@@ -9334,14 +10146,14 @@ async function runCommand(line, { config, source, graph, focus, memoryDir, trace
   // so listing them means reading the rules, not the registry).
   if (name === "capabilities") {
     note(trace, "goal: see what /plan can plan over — built-in query tools and taught actions");
-    const { declaredCapabilityNames } = await import("./router/drive.mjs");
-    const { actionFamilies, capabilityFromActionRules } = await import("./router/taught.mjs");
+    const { declaredCapabilityNames } = await import("../domain/router/drive.mjs");
+    const { actionFamilies, capabilityFromActionRules } = await import("../domain/router/taught.mjs");
     const lines = [`read-only graph tools: ${declaredCapabilityNames().join(", ")}`];
     let families = new Map();
     if (memoryDir) {
       try {
-        const { loadMemory } = await import("./memory/core.mjs");
-        families = actionFamilies(await loadMemory(memoryDir));
+        const { loadMemory, readRuleRows } = await import("../adapters/memory/core.mjs");
+        families = actionFamilies(readRuleRows(await loadMemory(memoryDir)));
       } catch { /* an unreadable store lists like an empty one */ }
     }
     if (!families.size) {
@@ -9359,7 +10171,58 @@ async function runCommand(line, { config, source, graph, focus, memoryDir, trace
     return mk(lines.join("\n"));
   }
 
-  // /plan <request> — the capability router (src/router/*): plan+execute a
+  // /syllogise <term> — forward-chain what's remembered about <term> into
+  // entailed facts and WRITE them to the store, so a chain too long for the
+  // live isa ladder to walk becomes a single stored step it can read.
+  //
+  // This is the one chat surface that writes derived facts. Every live chase
+  // in this file is read-only on purpose, and that stays true: a slash command
+  // is an explicit request, not the hot path an ordinary question runs down.
+  // Nothing here is a guess — each written fact carries `entailed:*`
+  // provenance, a justification citing its premises, and a trust discounted
+  // below the premises it rode.
+  //
+  // The term is an ARGUMENT rather than the session focus, and the two are
+  // different things wearing the same name: this focus is a set of class
+  // TERM strings, while chat's `focus` is a {id,label} code-graph entity, so
+  // passing the standing focus here would be a category error. Omitting it
+  // is worse than useless — a whole-store pass on a real store spends the
+  // budget on facts nobody asked about and can be truncated before it reaches
+  // the term you cared about. /plan is the precedent: a command that takes an
+  // argument and honestly refuses without one.
+  if (name === "syllogise") {
+    note(trace, "goal: materialize the entailed facts that follow from what's remembered about one term");
+    if (!memoryDir) return mk("no memory store here — /syllogise works inside a repo session.", { miss: true });
+    if (!argText) {
+      return mk('/syllogise needs a term, e.g. `/syllogise poodle` — it closes over what I remember about that term.', { miss: true });
+    }
+    try {
+      const { syllogise } = await import("../domain/syllogise.mjs");
+      const { loadMemory, readFactRows, appendFacts, normFactTerm } = await import("../adapters/memory/core.mjs");
+      const res = await syllogise(memoryDir, {
+        focus: [...factTermVariants(normFactTerm, argText)],
+        store: { loadMemory, readFactRows, appendFacts },
+      });
+      note(trace, `result: derived ${res.count} entailed fact(s) (depth ${res.depth}, budget ${res.budget})`);
+      if (!res.count) {
+        return mk(`nothing new follows from what I remember about "${argText}" — no entailed facts derived (depth ${res.depth}, budget ${res.budget}).`, { miss: true });
+      }
+      const lines = [`derived ${res.count} entailed fact(s) from what I remember about "${argText}":`];
+      for (const d of res.derived) lines.push(`  ${d.subject} ${d.rule} ${d.object} (via ${d.via})`);
+      // A truncated pass that still can't answer the question is worse than no
+      // offer at all, so the budget wall is stated rather than left implied by
+      // a count that happens to equal it.
+      if (res.truncated) {
+        lines.push(`budget of ${res.budget} reached — more may follow; run \`tmct syllogise --budget <n>\` for a wider pass.`);
+      }
+      lines.push("These are derived, not taught — /memory shows each one's provenance and premises.");
+      return mk(lines.join("\n"));
+    } catch (e) {
+      return mk(String(e?.message || e), { miss: true }); // a broken store reads as its own clean error
+    }
+  }
+
+  // /plan <request> — the capability router (src/domain/router/*): plan+execute a
   // compound ("of the modules impacted by X, which are untested", "assess X
   // and then check Y") or maintenance-goal ("what most needs a test") request
   // over the SAME read-only graph-query tools the other commands dispatch.
@@ -9368,8 +10231,8 @@ async function runCommand(line, { config, source, graph, focus, memoryDir, trace
     note(trace, "goal: plan/execute a compound or maintenance-goal request over the graph (the capability router)");
     if (!argText) return mk("/plan needs a request, e.g. `/plan of the modules impacted by X, which are untested`.", { miss: true });
     if (!graph) return mk("no graph loaded — /plan needs a code graph to plan over.", { miss: true });
-    const { buildCapabilityPlanCtx, runCapabilityPlan, declaredCapabilityNames } = await import("./router/drive.mjs");
-    const planCtx = await buildCapabilityPlanCtx({ config, source, tel, graph, memoryDir });
+    const { buildCapabilityPlanCtx, runCapabilityPlan, declaredCapabilityNames } = await import("../domain/router/drive.mjs");
+    const planCtx = await buildCapabilityPlanCtx({ ...capabilityPlanDeps(), config, source, tel, graph, memoryDir });
     try {
       const result = await runCapabilityPlan(argText, declaredCapabilityNames(), planCtx);
       if (result.refused) {
@@ -9396,7 +10259,7 @@ async function runCommand(line, { config, source, graph, focus, memoryDir, trace
 
   const spec = COMMANDS[name];
   if (!spec) {
-    note(trace, `pattern: /${name} is not a registered command (see COMMANDS in src/chat.mjs)`);
+    note(trace, `pattern: /${name} is not a registered command (see COMMANDS in src/services/chat.mjs)`);
     return mk(`unknown command /${name} — type /help for the list of commands.`, { miss: true });
   }
   note(trace, `goal: ${spec.help}`);
@@ -9489,15 +10352,15 @@ function renderAmbiguousAssert(line, ambiguous, normFactTerm) {
  *  the unchanged parseAce path below. */
 async function assertTurn(line, { memoryDir, sessionId, focus, lexicon = null, cache = null }) {
   try {
-    const { parseAce, parseAceAmbiguous } = await import("./grammar/ace.mjs");
+    const { parseAce, parseAceAmbiguous } = await import("../domain/grammar/ace.mjs");
     // A session handle carries its own loaded lexicon (createSession loads it once);
     // a bare runTurn (no handle) lazy-loads the cached core lexicon. The lexicon is
     // immutable, so sharing one reference across concurrent handles is re-entrant.
     let lex = lexicon;
-    if (!lex) { const { loadLexicon } = await import("./grammar/lexicon.mjs"); lex = loadLexicon(); }
+    if (!lex) { const { loadLexicon } = await import("../domain/grammar/lexicon.mjs"); lex = loadLexicon(); }
     const ambiguous = parseAceAmbiguous(line, lex);
     if (ambiguous) {
-      const { normFactTerm } = await import("./memory/core.mjs");
+      const { normFactTerm } = await import("../adapters/memory/core.mjs");
       const answer = renderAmbiguousAssert(line, ambiguous, normFactTerm);
       // Genuinely ambiguous — no single triple was committed, so the canonical
       // form is every surviving reading's own would-be triple set, same idiom
@@ -9512,12 +10375,13 @@ async function assertTurn(line, { memoryDir, sessionId, focus, lexicon = null, c
     }
     const parse = parseAce(line, lex);
     if (!parse || !parse.triples?.length || parse.residue?.length) return null;
-    const { assertSentence } = await import("./grammar/assert.mjs");
-    const { normFactTerm, appendFact } = await import("./memory/core.mjs");
+    const { assertSentence } = await import("../domain/grammar/assert.mjs");
+    const { normFactTerm, appendFact } = await import("../adapters/memory/core.mjs");
     const ts = new Date().toISOString();
     const res = await assertSentence(memoryDir, line, {
       lexicon: lex,
       provenance: { source: "chat", sessionId, ts },
+      appendFact,
     });
     if (!res || !res.ids?.length) return null;
     // A plain universal "every X is a Y" ALSO records the "every" quantifier
@@ -9547,7 +10411,7 @@ async function assertTurn(line, { memoryDir, sessionId, focus, lexicon = null, c
     let paraphraseSuffix = "";
     if (res.triples.length === 1 && res.triples[0].predicate === SUBCLASS_PREDICATE) {
       try {
-        const { paraphraseVerifiedSubClass } = await import("./paraphrase.mjs");
+        const { paraphraseVerifiedSubClass } = await import("../domain/paraphrase.mjs");
         // Normalized (same normFactTerm cleanup `shown` above already applies)
         // so the generated paraphrase text reads like "cache is a kind of
         // component", never a raw lexicon-prefixed form like "tmct:cache".
@@ -9668,19 +10532,68 @@ function rewriteUsesAsBaseFrame(text) {
   return null;
 }
 
+/** The pronouns runTurn's vocabulary binding accepts in SUBJECT position, and
+ *  the shapes that put one there. The set is CONTEXT_WORDS — this file's own
+ *  closed anaphor table, the one isPronoun and every focus-resolving reader
+ *  already trust — plus the plural "they", which the fact readers take as a
+ *  bare subject the same way. Only "here" is left out: it stands for a PLACE
+ *  ("what's in here" = this repo), never for the thing a fact is about, so
+ *  binding it to a subject would be a category error.
+ *
+ *  The lead itself is what keeps this to subject position: the pronoun must
+ *  directly follow the opening auxiliary ("can it bark") or "what is/are" WITH
+ *  a continuation ("what is it used for"), so an idiom carrying a trailing
+ *  dummy pronoun ("what time is it") and the bare "what is it" never rewrite. */
+const VOCAB_PRONOUN_LEAD_SUBJECTS = Object.freeze([...CONTEXT_WORDS].filter((w) => w !== "here").concat("they"));
+const VOCAB_PRONOUN_LEAD_RE = new RegExp(
+  `^((?:is|are|can|could|does|do)\\s+|what\\s+(?:is|are)\\s+)(${VOCAB_PRONOUN_LEAD_SUBJECTS.join("|")})\\b(\\s+\\S.*)?$`, "i",
+);
+
+/** The decline for a subject-position pronoun with nothing to bind it to —
+ *  "can it bark" as the very first thing said, before anything named a dog.
+ *  Returns the text, or null when the shape isn't a cold pronoun.
+ *
+ *  The vocabulary binding above already declines this correctly (no `last`
+ *  subject, so no substitution), and the fact readers then decline too, since
+ *  no row has "it" as its subject. What was left was the generic orientation
+ *  card, which introduces the tool and answers a question nobody asked. Name
+ *  the pronoun instead: the sentence was fine, it just arrived with nothing
+ *  behind it.
+ *
+ *  The example is the "<name>" placeholder nudgeAnswer's own no-focus pronoun
+ *  branch uses, not a real term. A concrete "what is a dog" would claim a
+ *  vocabulary an unseeded session doesn't have, and a seeding/teaching hint
+ *  belongs to the shapes that are ABOUT teaching — this shape is a question
+ *  whose subject went missing, and inviting a teach here reads as an offer to
+ *  store a fact about the pronoun itself. */
+function coldPronounDeclineText(query) {
+  const m = String(query || "").trim().match(VOCAB_PRONOUN_LEAD_RE);
+  // The bare "what is it" carries no predicate to answer, so it keeps the
+  // orientation card the same way the binding above leaves it alone.
+  if (!m || (/^what/i.test(m[1]) && !m[3])) return null;
+  return `not sure what "${m[2].toLowerCase()}" refers to yet — name the subject directly, e.g. "what is a <name>".`;
+}
+
 /** The subject of the LAST turn's first fact line, for vocabulary pronoun
  *  binding ("what is a dog" → "can it bark"). Fact answers render rigidly —
  *  "<subject> <phrase> <object> (source: …)", optionally behind a "yes — "/
  *  "no — "/"you told me: " prefix — so a 1–2 word leading subject followed
  *  by a phrase-table verb is extractable without any NLP. Anything else
  *  (code answers, walls, conversational text) returns null and no
- *  substitution happens. */
+ *  substitution happens.
+ *
+ *  A pronoun never binds. An honest miss opens first-person ("I can't confirm
+ *  that — …"), which fits the subject+verb shape exactly, so without the
+ *  isTeachPronoun check the miss lends "I" to the next turn and "is it an
+ *  animal" is looked up as "is I an animal". A pronoun is no more a fact
+ *  subject here than in the teach frames TEACH_PRONOUNS already guards. */
 function vocabAntecedentFrom(last) {
   const first = String(last?.answer || "").split("\n")[0]
     .replace(/^(?:yes|no) — /i, "")
     .replace(/^you told me: /i, "");
   const m = first.match(/^([a-z][\w'-]*(?:\s+[a-z][\w'-]*)?)\s+(?:is|are|has|can|causes|wants|requires|involves|means|begins|ends)\b/i);
-  return m ? m[1] : null;
+  if (!m || isTeachPronoun(m[1]) || isPronoun(m[1])) return null;
+  return m[1];
 }
 
 export async function runTurn(input, { config, source = defaultSource, graph = null, focus = null, last = null, memoryDir = null, sessionId = "", env = process.env, lexicon = null, narrate = false, vocabHint = null, tel = null, biasByBundle = {}, factRowsCache: injectedFactRowsCache = null, planState = null, _noSplit = false } = {}) {
@@ -9701,6 +10614,14 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
   // doesn't match one of the four discontiguous shapes.
   const baseFrameRewrite = rewriteUsesAsBaseFrame(preRewriteLine);
   const frameLine = baseFrameRewrite || preRewriteLine;
+  // The reverse cleft's "it" is scaffolding, so it has to go before the
+  // vocabulary pronoun binding below reads that same "it" as a referring
+  // pronoun and binds the last turn's subject to it ("what is it that calls
+  // loadStore" -> "what is dog that calls loadStore" after "what is a dog").
+  // The pronoun lead's own guard only spares the BARE "what is it", so this
+  // shape has to stop existing before that match runs at all.
+  const cleftRewrite = reverseCleftRewrite(frameLine);
+  const cleftLine = cleftRewrite || frameLine;
   // VOCABULARY pronoun antecedent — "what is a dog" then "can it bark". The
   // code-graph focus mechanism only ever binds {id,label} GRAPH entities, so
   // in a vocabulary conversation "it" resolved to nothing and the question
@@ -9709,17 +10630,13 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
   // ONLY when no code focus is standing (a graph session's own pronoun
   // resolution is untouched), the turn looks like a fact question, and the
   // LAST answer's own first fact line names a subject to bind to.
-  // Anchored to SUBJECT position only: the pronoun must directly follow the
-  // opening auxiliary ("can it bark") or "what is/are" WITH a continuation
-  // ("what is it used for") — so idioms carrying a trailing dummy pronoun
-  // ("what time is it") and the bare "what is it" are never rewritten.
-  const pronounLead = frameLine.match(/^((?:is|are|can|could|does|do)\s+|what\s+(?:is|are)\s+)(?:it|they)\b(\s+\S.*)?$/i);
+  const pronounLead = cleftLine.match(VOCAB_PRONOUN_LEAD_RE);
   const vocabAntecedent = (!focus?.id && memoryDir && pronounLead
-    && !(/^what/i.test(pronounLead[1]) && !pronounLead[2]))
+    && !(/^what/i.test(pronounLead[1]) && !pronounLead[3]))
     ? vocabAntecedentFrom(last) : null;
   const workingLine = vocabAntecedent
-    ? `${pronounLead[1]}${vocabAntecedent}${pronounLead[2] || ""}`
-    : frameLine;
+    ? `${pronounLead[1]}${vocabAntecedent}${pronounLead[3] || ""}`
+    : cleftLine;
   const templates = await chatTemplates(); // failure-tolerated: null degrades, never throws
   const trace = narrate ? [] : null;
   // vocabHint: createSession computes this ONCE per session; a direct
@@ -9802,7 +10719,8 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
     const sentences = splitSentences(workingLine);
     if (sentences.length > 1) {
       const lastSentence = sentences[sentences.length - 1];
-      if (PLAN_SOLVE_RE.test(lastSentence) || GOAL_TEACH_RE.test(lastSentence) || GOAL_TEACH_INFINITIVE_RE.test(lastSentence) || LEGAL_MOVES_RE.test(lastSentence)) {
+      if (PLAN_SOLVE_RE.test(lastSentence) || GOAL_TEACH_RE.test(lastSentence) || GOAL_TEACH_INFINITIVE_RE.test(lastSentence)
+        || GOAL_TEACH_VERBLESS_RE.test(lastSentence) || LEGAL_MOVES_RE.test(lastSentence)) {
         let f = focus; let l = last; let ps = planHolder.state;
         const receipts = [];
         let finalRec = null;
@@ -9928,45 +10846,20 @@ export const SEED_PREFER = ["rdfs:subClassOf", "rdf:type", "mgx:usedFor", "mgx:p
  *  corpus seed, so re-runs skip without even reading the slice. */
 export const SEED_MARKER_REL = join(".tmct", "memory", "corpus-seed.json");
 
-/** Bootstrap <repo> for tmct on a graph-less first run: delegates to the FULL
- *  `initRepo(repo, {persona: PERSONA_PRESETS.human, env})` — the exact same
- *  function `tmct init` calls — so a library consumer gets the SAME
- *  first-run experience: real `.tmct/` scaffold, a written `tmct.toml`,
- *  `.tmct/init.json` provenance, not just a seed marker. `initRepo` only
- *  writes `tmct.toml` when absent, and only (re)seeds when the marker is
- *  absent, so a repeat call after a prior CLI `tmct init` is a safe no-op.
- *  Returns `initRepo`'s own `seedResult` on a fresh seed, null when
- *  skipped/failed. */
-async function seedBootstrapMemory(repo, env = process.env) {
-  try {
-    const { initRepo, PERSONA_PRESETS } = await import("./init.mjs");
-    const result = await initRepo(repo, { persona: PERSONA_PRESETS.human, env });
-    return result.seeded ? result.seedResult : null;
-  } catch {
-    return null; // repo/corpus unavailable — bootstrap proceeds unseeded
-  }
-}
-
-/** The seed banner line — renders every `perBundle` entry that actually
- *  appended facts this run, in the entries' own fixed order (seon,
- *  conceptnet, then the rest sorted by name), joined with " + ". No bundle
- *  is privileged as one of "the first two" — a single active bundle renders
- *  with no " + " at all. */
-function seedBannerLine(seeded) {
-  const clauses = Object.entries(seeded.perBundle || {})
-    .filter(([, r]) => r && r.appended > 0)
-    .map(([name, r]) => `${r.appended} ${name}`);
-  return `seeded ${seeded.appended} starter facts (${clauses.join(" + ")}) — /memory to inspect`;
-}
-
 /** Whether THIS repo's memory actually carries the corpus seed — the marker is
  *  authoritative regardless of whether the CURRENT run or an earlier one did
  *  the seeding. The one signal every "try this vocabulary example" surface
- *  must check before offering a term-specific query — see vocabExampleHint. */
-async function hasSeededVocabulary(repo) {
+ *  must check before offering a term-specific query — see vocabExampleHint.
+ *  Used both here (runTurn's per-call vocabHint fallback) and by the session
+ *  layer's createSession; the readFile is imported lazily so this module stays
+ *  free of a static node:fs import. */
+export async function hasSeededVocabulary(repo) {
   if (!repo) return false;
-  try { await readFile(join(repo, SEED_MARKER_REL), "utf8"); return true; }
-  catch { return false; }
+  try {
+    const { readFile } = await import("node:fs/promises");
+    await readFile(join(repo, SEED_MARKER_REL), "utf8");
+    return true;
+  } catch { return false; }
 }
 
 /** A "try this" vocabulary-example clause that's PROVABLY correct in the session
@@ -9981,376 +10874,8 @@ async function hasSeededVocabulary(repo) {
  *  with an intuitive-but-unknown word and hit the teach-miss dead-end right
  *  after being offered the pattern. "every bug is an issue" is confirmed to
  *  parse and store, so the offer resolves if copied verbatim. */
-function vocabExampleHint(seeded) {
+export function vocabExampleHint(seeded) {
   return seeded
     ? 'Try "what is a dog" for general vocabulary.'
     : 'Run `tmct init` to seed a starter vocabulary, or teach me directly, e.g. "every bug is an issue".';
 }
-
-/** Trim a focus label for the prompt so a long module path can't run the line off. */
-const shortLabel = (l) => { const s = String(l); return s.length > 40 ? "…" + s.slice(-39) : s; };
-const promptFor = (focus) => (focus ? `tmct(${shortLabel(focus.label)})> ` : PROMPT);
-
-/**
- * The SESSION SINK — everything a chat shell (readline below, the Ink TUI, any
- * future surface) must share so the on-disk session contract stays identical
- * no matter what draws the screen: repo/config resolution + the one-time
- * graph load, the transcript log + structured sidecar with per-turn
- * writeLog → writeSidecar → upsertGraph sequencing (ORDER IS LOAD-BEARING:
- * the memory side-write recovers each turn's ANSWER by re-reading the
- * transcript, so the log line must be flushed before the graph upsert), and
- * opt-in telemetry + end-of-session close.
- *
- * The returned object IS the caller-owned session handle — created here,
- * disposed by the caller (`close()`, idempotent), with NO process-global
- * state. Two handles never clobber each other (each owns its own
- * focus/lastAnswer/streams/sessionId).
- *
- * Returns { repo, config, graph, lexicon, memoryDir, moduleCount, version, sessionId,
- * logFile, sidecarFile, bannerLines, empty, focus, lastAnswer, turns, promptFor(),
- * turn(line), close() }. `turn(line)` runs one dispatched turn through runTurn and the
- * full sink sequencing, returning { answer, end, prompt }; `close()` is idempotent.
- */
-export async function createSession({
-  repoPath,
-  graphPaths,
-  configPath,
-  source = defaultSource,
-  env = process.env,
-  cwd = process.cwd(),
-  gitRoot = gitToplevel,
-  ephemeral = false,
-  narrate = false,
-  // The storage-backend seam: "file" (default) keeps memoryDir a plain
-  // repo-path string (Backend A). "memory" selects Backend B (zero disk I/O,
-  // session-scoped). "sqlite" selects Backend C (a live node:sqlite
-  // connection, lazily imported only when chosen). This is `tmct chat
-  // --memory-backend <...>`'s already-resolved value; full precedence (this
-  // param > TMCT_MEMORY_BACKEND env > tmct.toml > "default") resolved below.
-  memoryBackend = null,
-} = {}) {
-  // EPHEMERAL mode (--ephemeral, or TMCT_EPHEMERAL=1): read the target graph but
-  // write NOTHING back into it. The shipped examples run this way so a demo never
-  // dirties the committed code graph (`npm run example:mini` used to fold a session
-  // into examples/*/.tmct/graph.json and rewrite it). We still read config.graphFile
-  // for structure; only the WRITE base (logs, memory, sessions) is diverted to an OS
-  // temp dir and the read-time graph upsert is suppressed.
-  ephemeral = ephemeral || /^(1|true|yes)$/i.test(String(env.TMCT_EPHEMERAL || ""));
-  // NARRATE mode (--narrate, or TMCT_NARRATE=1): start the session with
-  // narrate mode already on. Session-scoped and mutable — `/narrate on|off`
-  // flips it turn-to-turn (see `turn()` below). Default OFF.
-  let narrateOn = narrate || /^(1|true|yes)$/i.test(String(env.TMCT_NARRATE || ""));
-  // Graph resolution order (delegates to src/cli-args.mjs's
-  // resolveRuntimeConfig): explicit --graph path(s) win outright; then --repo
-  // (never silently redirected by env); then TMCT_GRAPH_FILE env; then
-  // tmct.toml's graph_file at the resolved repo root; then git root; then cwd.
-  // Defaults to the GIT ROOT, not raw cwd, so running from a nested package
-  // dir doesn't index only that package.
-  let repo;
-  let config;
-  // tmct.toml's normalized knobs, captured alongside `config` — used below
-  // for the memory-backend precedence. `null` when no tmct.toml was readable.
-  let toml = null;
-  const explicitGraphs = (graphPaths || []).filter(Boolean);
-  if (explicitGraphs.length) {
-    repo = repoPath || gitRoot(cwd) || cwd;
-    const resolvedGraphs = explicitGraphs.map((p) => resolve(cwd, p));
-    config = resolvedGraphs.length > 1
-      ? { graphFile: resolvedGraphs[0], graphFiles: resolvedGraphs }
-      : { graphFile: resolvedGraphs[0] };
-    try {
-      const argv = ["--repo", repo];
-      if (configPath) argv.push("--config", configPath);
-      ({ toml } = await resolveRuntimeConfig({ argv, cwd, env: {}, gitRoot }));
-    } catch { toml = null; }
-  } else if (repoPath) {
-    repo = repoPath;
-    // env is deliberately withheld from resolveRuntimeConfig here (passed as
-    // {}), so its own env-beats-repo-default tier can never fire.
-    const argv = ["--repo", repoPath];
-    if (configPath) argv.push("--config", configPath);
-    ({ config, toml } = await resolveRuntimeConfig({ argv, cwd, env: {}, gitRoot }));
-  } else {
-    const root = gitRoot(cwd);
-    repo = root || cwd;
-    const envGraph = env.TMCT_GRAPH_FILE && String(env.TMCT_GRAPH_FILE).trim();
-    if (envGraph) {
-      config = loadConfig(env, cwd);
-      try {
-        const argv = [];
-        if (configPath) argv.push("--config", configPath);
-        ({ toml } = await resolveRuntimeConfig({ argv, cwd, env: {}, gitRoot }));
-      } catch { toml = null; }
-    } else {
-      const argv = [];
-      if (configPath) argv.push("--config", configPath);
-      ({ config, toml } = await resolveRuntimeConfig({ argv, cwd, env, gitRoot }));
-    }
-  }
-
-  // Ephemeral: keep config.graphFile pointing at the READ graph, but divert the
-  // write base (repo → logs/memory/sessions) to a throwaway temp dir. The committed
-  // target is never touched; the demo's memory simply doesn't persist across runs.
-  if (ephemeral) repo = await mkdtemp(join(tmpdir(), "tmct-ephemeral-"));
-
-  // Load the graph once up front — the banner needs the module count, and focus/`it`
-  // resolution and contextId threading need it in hand. A missing artifact loads as
-  // the empty bootstrap graph (source.mjs) — the banner says so; never an error.
-  const graph = parseEntities(await source.fetchEntities(config));
-  const moduleCount = graph.individuals.filter((i) => (i.class || "") === "Module").length;
-  const { version } = JSON.parse(await readFile(new URL("../package.json", import.meta.url), "utf8"));
-
-  // Resolve this handle's extension entries + bias table ONCE per session —
-  // no new per-turn I/O. Failure-tolerated: a malformed tmct.toml degrades to
-  // the shipped builtins with an empty bias table, never an error.
-  let extEntries = null;
-  let biasByBundle = {};
-  try { ({ entries: extEntries, biasByBundle } = await resolveExtensions(repo)); }
-  catch { extEntries = null; biasByBundle = {}; }
-
-  // Load this handle's lexicon once, MERGED with any active lexicon/pack
-  // extension entries (ascending-bias merge order so a higher-bias bundle's
-  // same-lemma entry wins deterministically). Failure-tolerated — a broken
-  // lexicon degrades to the lazy per-turn load inside assertTurn.
-  let lexicon = null;
-  try {
-    const { loadLexicon } = await import("./grammar/lexicon.mjs");
-    const extra = extEntries ? await mergedLexiconExtra(extEntries, biasByBundle) : null;
-    lexicon = loadLexicon(extra ?? undefined);
-  } catch { lexicon = null; }
-
-  // Opt-in telemetry (default OFF → null → the sink's `tel?.record` is a no-op, and
-  // nothing is written). The conversational session log + sidecar above stay the
-  // authoritative chat record; this is the machine-readable query telemetry.
-  const tel = createTelemetry({ env, config, surface: "chat" });
-
-  const sessionId = uuidv7();
-  const logDir = join(repo, SESSION_LOG_DIR);
-  const sessionsDir = join(repo, SESSIONS_DIR_REL);
-  await mkdir(logDir, { recursive: true });
-  await mkdir(sessionsDir, { recursive: true });
-  const logFile = join(logDir, `session-${sessionId}.log`);
-  const sidecarFile = join(sessionsDir, `session-${sessionId}.jsonl`);
-  const stream = createWriteStream(logFile, { flags: "a" });
-  const sidecar = createWriteStream(sidecarFile, { flags: "a" });
-  // Awaited writes: each chunk is handed to the OS before the turn completes, so a
-  // killed session keeps everything up to the last completed turn — in both files.
-  const flush = (s, text) =>
-    new Promise((resolve, reject) => s.write(text, (e) => (e ? reject(e) : resolve())));
-  const writeLog = (text) => flush(stream, text);
-  const writeSidecar = (obj) => flush(sidecar, JSON.stringify(obj) + "\n");
-
-  const startIso = new Date().toISOString();
-  await writeLog(`# tmct chat ${version} — session started ${startIso} — repo ${repo}\n\n`);
-  await writeSidecar({ type: "session", id: sessionId, started: startIso, repo, tmctVersion: version });
-
-  // Read-time graph upsert (sessions.mjs): after every turn, the session becomes /
-  // stays a first-class Session individual in graph.json (crash-safe: turn n is in
-  // the graph before turn n+1 runs). Best-effort — a re-index or vanished
-  // artifact mid-session must degrade the recording, never kill the chat.
-  const turnRecords = [];
-  const upsertGraph = async (ended) => {
-    if (ephemeral) return; // a demo/read-only session never writes back to the graph
-    if (!turnRecords.length) return; // a zero-turn session never pollutes the graph
-    try { await appendSessionToGraph(config.graphFile, { id: sessionId, started: startIso, ended, turns: turnRecords }); }
-    catch { /* best-effort — see above */ }
-  };
-
-  // `memoryDir` is the opaque token every memory/core.mjs call in this file
-  // threads through unchanged. Backend A (default) keeps it the plain repo
-  // string; Backend B/C swap in a handle instead. Precedence — CLI flag > env
-  // > tmct.toml > default.
-  const backendChoice = String(memoryBackend || env.TMCT_MEMORY_BACKEND || toml?.memory?.backend || "").trim().toLowerCase();
-  // openMemoryBackend is the ONE shared resolver for this seam — init.mjs's
-  // corpus seed calls the exact same function, so a repo's seeded facts and
-  // its chat-taught facts always land in the same backend.
-  const { openMemoryBackend } = await import("./memory/core.mjs");
-  const { dir: memoryDir, close: closeMemoryStore } = await openMemoryBackend(repo, backendChoice);
-
-  const empty = graph.individuals.length === 0;
-  // W3: FIRST RUN in a graph-less repo seeds a capped ConceptNet slice into
-  // .tmct/memory so vocabulary questions ("what is a cache?") have something
-  // honest to stand on from turn one. Guarded three ways: only the empty
-  // bootstrap (a fixture/provider graph never seeds), only once (the marker),
-  // and never when TMCT_NO_SEED=1 opts out.
-  //
-  // Known Backend B/C limitation: seedBootstrapMemory/hasSeededVocabulary and
-  // sessions.mjs's own per-turn utterance mirror all resolve their marker
-  // file / repoDir directly off the STRING `repo` path, not the actual
-  // Backend B/C handle — so W3 seeding is skipped for a non-default backend,
-  // and a Backend B/C session's Utterance/Session individuals still land in
-  // an ordinary Backend-A .tmct/memory/graph.json. Taught FACTS themselves
-  // are unaffected: only the conversational transcript mirror leaks onto
-  // disk, never the facts.
-  let seeded = null;
-  if (empty && backendChoice === "" && String(env.TMCT_NO_SEED || "") !== "1") {
-    seeded = await seedBootstrapMemory(repo, env);
-  }
-  // vocabHint: computed ONCE per session (not per-turn — see runTurn's own
-  // per-call fallback for direct/library callers). `seeded` is only truthy when
-  // THIS run performed the seeding; a repo seeded by an EARLIER run (or `tmct
-  // init`) still needs the marker check, so this covers both — see
-  // hasSeededVocabulary's docblock.
-  const vocabSeeded = Boolean(seeded) || (await hasSeededVocabulary(repo));
-  const vocabHint = vocabExampleHint(vocabSeeded);
-  // #3/#5: 0 modules means no code graph to answer structure questions from —
-  // whether the graph file is absent (empty bootstrap) OR present with no code
-  // entities (the degenerate trap). Both get orienting, non-over-promising banner
-  // + greeting messaging rather than a silent dead-end.
-  const noCodeGraph = moduleCount === 0;
-  const bannerLines = [
-    noCodeGraph
-      // No code graph: honest, orienting messaging — never an error before the prompt.
-      ? `tmct chat — ${repo} — no code graph loaded — ${empty ? "starting empty" : "graph has no code entities"}; ` +
-        `the conversation is remembered to ${DEFAULT_GRAPH_REL} — log ${logFile}`
-      : `tmct chat — ${repo} — ${moduleCount} module(s) — log ${logFile}`,
-    // the honest seed line appears ONLY on the run that actually seeded — the count
-    // is the TOTAL appended, split into the curated SEON ontology + the ConceptNet band
-    // (+ any other active extension bundle, e.g. an activated tier-2 corpus).
-    ...(seeded ? [seedBannerLine(seeded)] : []),
-    // no code graph → point at how to GET one (a graph producer / --repo / the shipped
-    // example), and at what IS answerable now — `vocabHint` is only ever a term
-    // confirmed to resolve in THIS session's actual seed state (see vocabExampleHint),
-    // never a hardcoded example that might not have been seeded. tmct reads graphs;
-    // it never indexes code itself.
-    ...(noCodeGraph ? [`for code structure, point me at a .tmct/graph.json with --repo <path> or try \`npm run example:mini\` (tmct reads graphs, it doesn't index code). ${vocabHint}`] : []),
-    "pass --repo <path> to target a different repo",
-    "ask a question, or /help for commands (/stats for an overview) — /exit to leave",
-  ];
-
-  let turns = 0;
-  let focus = null; // the current focus entity ({id,label}) — threaded turn to turn
-  let last = null;  // the last dispatched answer ({query,answer,detail}) — why/say-more re-renders it
-  let planState = null; // the in-progress plan (goals/moves/cursor) — cleared by completion or a fresh goal, never by an aside
-  let closed = false;
-
-  return {
-    repo, config, graph, lexicon, memoryDir, moduleCount, version, sessionId,
-    logFile, sidecarFile, bannerLines, empty, biasByBundle,
-    // Mutable between-turn state — read-only to the caller, so a shell can render the
-    // prompt/expand-hint without reaching into runTurn's threading.
-    get focus() { return focus; },
-    get lastAnswer() { return last; },
-    get planState() { return planState; },
-    get turns() { return turns; },
-    get narrate() { return narrateOn; },
-    promptFor: () => promptFor(focus),
-
-    /** One dispatched turn through the FULL sink sequencing (writeLog → writeSidecar
-     *  → telemetry → upsertGraph, in that exact order). Returns { answer, end, prompt }.
-     *  A throwing runTurn must never abort the session: a piped/non-interactive
-     *  driver has no other chance to see this turn's answer. */
-    async turn(line) {
-      let result;
-      try {
-        result = await runTurn(line, { config, source, graph, focus, last, memoryDir, sessionId, env, lexicon, narrate: narrateOn, vocabHint, tel, biasByBundle, planState });
-      } catch (e) {
-        const ts = new Date().toISOString();
-        const message = e instanceof Error ? e.message : String(e);
-        await writeLog(`${ts}\n> ${line}\nerror: ${message}\n`);
-        const errorRecord = { type: "error", ts, query: line, error: message };
-        await writeSidecar(errorRecord);
-        turnRecords.push(errorRecord);
-        turns += 1;
-        return { answer: `Something went wrong answering that (${message}). Try rephrasing, or /help.`, end: false, prompt: promptFor(focus) };
-      }
-      const { answer, logLines, record, focus: nextFocus, last: nextLast, end, narrate: nextNarrate } = result;
-      focus = nextFocus;
-      last = nextLast;
-      if ("planState" in result) planState = result.planState;
-      // /narrate on|off (runCommand) rides the turn RESULT the same way a focus
-      // update does — apply it to this handle's session-scoped state.
-      if (typeof nextNarrate === "boolean") narrateOn = nextNarrate;
-      await writeLog(logLines.join("\n") + "\n");
-      await writeSidecar(record);
-      turnRecords.push(record);
-      // One telemetry line per dispatched turn (OFF by default → no-op). query.raw is
-      // the user's line; `tool` the slash-command if any; count the cited entity ids.
-      tel?.record({
-        tool: record.command,
-        query: { raw: line },
-        response: { count: (record.answeredIds || []).length, node_ids: record.answeredIds || [] },
-      });
-      await upsertGraph(record.ts);
-      turns += 1;
-      return { answer, end: Boolean(end), prompt: promptFor(focus), plan: result.plan ?? null };
-    },
-
-    /** End-of-session close: end lines in both artifacts, the final graph upsert
-     *  (which also triggers the memory fold), stream flush, the Backend C
-     *  connection close (a no-op for Backend A/B). Idempotent. */
-    async close() {
-      if (closed) return;
-      closed = true;
-      const endIso = new Date().toISOString();
-      await writeLog(`${endIso}\n> /exit\nsession end ${endIso}\n`);
-      await writeSidecar({ type: "end", ts: endIso });
-      await upsertGraph(endIso);
-      await new Promise((resolve) => stream.end(resolve));
-      await new Promise((resolve) => sidecar.end(resolve));
-      await closeMemoryStore();
-    },
-  };
-}
-
-/**
- * The interactive readline shell over createSession — the `--plain` surface and
- * the scripted-test surface. Streams are injectable so tests run sessions
- * without a TTY. A repo with NO graph artifact is not an error: the session
- * starts from the empty bootstrap graph (the banner says so honestly) and the
- * first turn's fold-in creates .tmct/graph.json from the conversation itself.
- * Returns { logFile, sidecarFile, turns } once the session ends.
- */
-export async function runChat({
-  repoPath,
-  graphPaths,
-  configPath,
-  input = process.stdin,
-  output = process.stdout,
-  source = defaultSource,
-  env = process.env,
-  cwd = process.cwd(),
-  gitRoot = gitToplevel,
-  ephemeral = false,
-  narrate = false,
-  memoryBackend = null,
-} = {}) {
-  // createSession's first-run seed (~2-3s) produces ZERO output until it fully
-  // resolves, which otherwise reads as `npm run chat` hanging with total silence.
-  output.write("tmct — starting…\n");
-  const session = await createSession({ repoPath, graphPaths, configPath, source, env, cwd, gitRoot, ephemeral, narrate, memoryBackend });
-
-  const dim = (s) => (env.NO_COLOR || !output.isTTY ? s : `\x1b[2m${s}\x1b[0m`);
-  for (const line of session.bannerLines) output.write(dim(line) + "\n");
-
-  const rl = createInterface({ input, output, prompt: PROMPT });
-  rl.on("SIGINT", () => rl.close()); // Ctrl+C behaves like /exit (clean close, log flushed)
-  let closed = false;
-  rl.on("close", () => { closed = true; });
-  const prompt = () => { if (!closed) rl.prompt(); }; // input may end while a turn is in flight
-
-  prompt();
-  // try/finally: session.close() is the ONLY code path that writes end-markers and
-  // flushes the log/sidecar write streams (stream.end()/sidecar.end()) — an
-  // unhandled throw anywhere in the loop body must still reach it, or a
-  // piped/non-interactive run can lose buffered writes outright, not just this
-  // turn's data. session.turn() now catches its own errors (see createSession),
-  // so this is defense in depth for anything else that might throw here.
-  try {
-    for await (const raw of rl) { // Ctrl+D / closed stdin ends the iteration cleanly
-      const line = raw.trim();
-      if (line === "/exit") break;
-      if (line) {
-        const { answer, end, prompt: nextPrompt } = await session.turn(line);
-        output.write(answer + "\n");
-        rl.setPrompt(nextPrompt);
-        if (end) break; // a conversational "bye"/"goodbye" — clean end, same as /exit
-      }
-      prompt();
-    }
-  } finally {
-    rl.close();
-    await session.close();
-  }
-  return { logFile: session.logFile, sidecarFile: session.sidecarFile, turns: session.turns };
-}