@polycode-projects/the-mechanical-code-talker 1.10.14 → 1.11.0

package/src/chat.mjs

@@ -34,6 +34,7 @@ import { loadTemplates, render as renderTemplate } from "./corpus/templates.mjs"
 import { resolveExtensions, mergedLexiconExtra } from "./extensions.mjs";
 import { rankByBiasThenTrust } from "./memory/bias.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,
@@ -1539,6 +1540,10 @@ const BARE_DECLARATIVE_RE = /^(?:every |each |all |a |an )?[\w-]+(?: [\w-]+)? (?
 const COMPARATIVE_SRC = "(?:[a-z]+er|better|worse|(?:more|less)\\s+[a-z]+)";
 const COMPARATIVE_TEACH_RE = new RegExp(`^(?:the\\s+|an?\\s+)?([\\w'-]+(?:\\s+[\\w'-]+)?)\\s+(?:is|are)\\s+(${COMPARATIVE_SRC})\\s+than\\s+(.+)$`, "i");
 const COMPARATIVE_ASK_RE = new RegExp(`^(?:is|are)\\s+(.+?)\\s+(${COMPARATIVE_SRC})\\s+than\\s+(.+?)[?.!\\s]*$`, "i");
+/** The one closed preposition set shared by every frame that folds a
+ *  preposition into a minted predicate (the general-verb teach/query lanes
+ *  and the action-rule frames) — a single source so the set never forks. */
+const PREP_SRC = "on|in|at|onto|upon|under|over|beside|near|behind|above|below|inside|outside";
 /** Interrogative / auxiliary leads that make an "X is a Y"-shaped line a QUESTION
  *  ("what is a cache", "is a module a component"), never a teach declarative. */
 const QUESTION_LEAD_RE = /^(?:what|who|which|where|when|why|how|is|are|do|does|did|can|could|should|would|will|has|have)\b/i;
@@ -1755,6 +1760,86 @@ const FILTER_RULE_TEACH_RE =
 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;
 
+/** 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) sharing one rule name ("<verb> <prep>",
+ *  e.g. "move onto"). src/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
+ *  values; readers re-attach it. The class/role words are single tokens, the
+ *  preposition set is PREP_SRC, the comparative slot is COMPARATIVE_SRC. */
+const ACTION_SIGNATURE_TEACH_RE = new RegExp(
+  `^you\\s+can\\s+([a-z]+)\\s+an?\\s+([a-z][\\w-]*)\\s+(${PREP_SRC})\\s+an?\\s+([a-z][\\w-]*)[.!?]*$`, "i");
+const ACTION_PRECOND_NOTHING_RE = new RegExp(
+  `^to\\s+([a-z]+)\\s+an?\\s+([a-z][\\w-]*)\\s+(${PREP_SRC})\\s+an?\\s+([a-z][\\w-]*)\\s*,?\\s*nothing\\s+may\\s+([a-z]+)\\s+(${PREP_SRC})\\s+the\\s+([a-z][\\w-]*)[.!?]*$`, "i");
+const ACTION_PRECOND_COMPARATIVE_RE = new RegExp(
+  `^to\\s+([a-z]+)\\s+an?\\s+([a-z][\\w-]*)\\s+(${PREP_SRC})\\s+an?\\s+([a-z][\\w-]*)\\s*,?\\s*the\\s+([a-z][\\w-]*)\\s+must\\s+be\\s+(${COMPARATIVE_SRC})\\s+than\\s+the\\s+([a-z][\\w-]*)[.!?]*$`, "i");
+const ACTION_EFFECT_TEACH_RE = new RegExp(
+  `^([a-z]+ing)\\s+an?\\s+([a-z][\\w-]*)\\s+(${PREP_SRC})\\s+an?\\s+([a-z][\\w-]*)\\s+makes\\s+the\\s+([a-z][\\w-]*)\\s+([a-z]+)\\s+(${PREP_SRC})\\s+the\\s+([a-z][\\w-]*)[.!?]*$`, "i");
+/** "a disk renders as a block" — the render-template binding, an ordinary
+ *  Fact on the curated mgx:rendersAs predicate (camelCase, so the
+ *  general-verb preposition fold can never suffix it). */
+const RENDERS_AS_TEACH_RE = /^an?\s+([a-z][\w-]*)\s+renders\s+as\s+an?\s+([a-z][\w-]*)[.!?]*$/i;
+// Bare-copula instance membership: the subject MUST contain a hyphen
+// (disk-1, peg-a) — see bareTaxonomyTeach's reasoning.
+const INSTANCE_TYPE_TEACH_RE = /^([a-z][\w]*(?:-[\w]+)+)\s+is\s+an?\s+([a-z][\w-]+)[.!?]*$/i;
+// Bare article-led kind-of taxonomy: "a disk is a kind of game piece".
+const BARE_KINDOF_TEACH_RE = /^an?\s+([a-z][\w-]+)\s+is\s+a\s+kind\s+of\s+(?:an?\s+)?([a-z][\w-]+(?:\s+[a-z][\w-]+)?)([.!?]*)$/i;
+
+/** Verb → lemma via the prose adapter, degrading to the word itself. */
+async function verbLemma(word) {
+  const w = String(word || "").toLowerCase();
+  try {
+    const { proseLemma } = await import("./prose-nlp.mjs");
+    const lemma = proseLemma();
+    return lemma ? lemma(w) : w;
+  } catch { return w; }
+}
+
+/** 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
+ *  no question lead is a statement. Two closed shapes only:
+ *  - instance membership with a HYPHENATED subject ("disk-1 is a disk") —
+ *    hyphenated/numbered coinages are unambiguous individual names, so this
+ *    stays clear of the plain-word bare "X is a Y" declines the tier-5
+ *    fabrication fixes deliberately preserve;
+ *  - article-led "is a kind of" taxonomy with a multi-word object — the
+ *    infix is unambiguous taxonomy-teach intent and the ACE path can't parse
+ *    the two-word object; single-word objects stay with the ACE path. */
+async function bareTaxonomyTeach(line, { memoryDir, sessionId }) {
+  if (!memoryDir || QUESTION_LEAD_RE.test(line)) return null;
+  const inst = line.match(INSTANCE_TYPE_TEACH_RE);
+  if (inst) {
+    return teachFact(memoryDir, sessionId, {
+      subject: inst[1], predicate: "rdfs:subClassOf", object: inst[2],
+    });
+  }
+  const kindOf = line.match(BARE_KINDOF_TEACH_RE);
+  if (kindOf) {
+    // Defer to the ACE assert path exactly where it succeeds: a single-word
+    // object with no trailing punctuation ("a father is a kind of parent" —
+    // the pinned README transcript's shape, with its richer receipt). The ACE
+    // path dies on multi-word objects and on trailing punctuation (the
+    // period rides into term resolution), so those store here.
+    const singleWordObject = !/\s/.test(kindOf[2]);
+    const noTrailingPunct = kindOf[3] === "";
+    if (singleWordObject && noTrailingPunct) return null;
+    return teachFact(memoryDir, sessionId, {
+      subject: kindOf[1], predicate: "rdfs:subClassOf", object: kindOf[2],
+    });
+  }
+  return null;
+}
+// The plan lane's closed recognizer set. The goal frame is plan-lane state,
+// not a Rule — goals accumulate on the session's planState slot.
+const GOAL_TEACH_RE = new RegExp(
+  `^the\\s+goal\\s+is\\s+that\\s+(?:(every|each|all)\\s+)?([\\w-]+)\\s+([a-z]+s)\\s+(${PREP_SRC})\\s+([\\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;
+
 /** "<X> is <adjective>" — the property teach payload (wrapper-REQUIRED): a lazy
  *  subject and a single bare complement word. Never matches the "is a <noun>"
  *  membership shape (that stays the ACE grammar's), so "remember that cache is
@@ -2397,7 +2482,7 @@ async function subjectIsNounOrPropn(word) {
 // query is never shadowed. Reuses generalVerbTeach's own exclude guards and
 // generalVerbPredicate, plus the SAME adverb-skip, so the two never disagree. ----
 const GENERAL_VERB_YESNO_RE = new RegExp(`^(?:does|did)\\s+([\\w'-]+)\\s+${TEACH_ADVERB_SKIP_SRC}([a-z]+)\\s+(.+?)[?.!\\s]*$`, "i");
-const GENERAL_VERB_OPEN_RE = new RegExp(`^what\\s+(?:does|did)\\s+([\\w'-]+)\\s+${TEACH_ADVERB_SKIP_SRC}([a-z]+(?:\\s+(?:on|in|at|onto|upon|under|over|beside|near|behind|above|below|inside|outside))?)[?.!\\s]*$`, "i");
+const GENERAL_VERB_OPEN_RE = new RegExp(`^what\\s+(?:does|did)\\s+([\\w'-]+)\\s+${TEACH_ADVERB_SKIP_SRC}([a-z]+(?:\\s+(?:${PREP_SRC}))?)[?.!\\s]*$`, "i");
 /** GENERAL_VERB_EXCLUDE_RE was written for generalVerbTeach's fully-conjugated
  *  declarative verb ("X OWNS Y", "X MAINTAINS Y") — but "does/did X <verb> Y"
  *  captures the BARE INFINITIVE after do-support ("does X OWN Y", never "does X
@@ -2413,7 +2498,7 @@ const GENERAL_VERB_QUERY_EXCLUDE_RE = /^(?:be|own|maintain)$/i;
  *  minted predicate: "disk-1 rests on peg-a" stores mgx:rest-on with object
  *  "peg-a", never mgx:rest with the meaning-bearing "on" buried inside the
  *  object where no read-back can match it. */
-const GENERAL_VERB_PREP_RE = /^(on|in|at|onto|upon|under|over|beside|near|behind|above|below|inside|outside)\s+(.+)$/i;
+const GENERAL_VERB_PREP_RE = new RegExp(`^(${PREP_SRC})\\s+(.+)$`, "i");
 /** Fold a leading preposition from `objectRaw` into a minted mgx:<lemma>
  *  predicate. Curated predicates (mgx:hasA, mgx:capableOf — anything not the
  *  plain lowercase mint shape) are never suffixed. Returns {predicate,
@@ -2573,7 +2658,11 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
   // `are` payload — see the payload-construction block below), which leaves
   // whatever the structural grammar's own honest miss already said standing,
   // rather than overwriting it with a wrong-reason refusal.
-  if (pronounMatch && !(await hasMidSentenceInterrogative(pronounSrc))) {
+  // The action-signature frame is the ONE pronoun-led teach shape ("you can
+  // move a disk onto a peg") — the full-shape test keeps "you can fly"
+  // declining right here.
+  if (pronounMatch && !ACTION_SIGNATURE_TEACH_RE.test(pronounSrc)
+    && !(await hasMidSentenceInterrogative(pronounSrc))) {
     const pronoun = pronounMatch[1];
     return {
       text: `I can't store a fact about "${pronoun}" as a class — pronouns aren't things I can classify. `
@@ -2786,6 +2875,167 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
     } catch { /* malformed slots — fall through to the ordinary honest-miss cascade */ }
   }
 
+  // ACTION-RULE TEACH — the four action frames plus the render binding (see
+  // the ACTION_*_TEACH_RE docblock). Each sentence stores its own Rule
+  // individual under a shared "<verb> <prep>" name. A role word that names
+  // neither the taught subject class nor the literal "target" is an honest
+  // decline that RETURNS here — falling through would hand these shapes to
+  // the general-verb lane below, which would mint a garbage predicate from
+  // them (the silent-garble case this lane exists to prevent).
+  const actionLemma = verbLemma;
+  const actionRoleFor = (word, subjectClass) => {
+    const w = String(word || "").toLowerCase();
+    if (w === "target") return "target";
+    if (w === String(subjectClass || "").toLowerCase()) return "subject";
+    return null;
+  };
+
+  const actionSig = ownSrc.match(ACTION_SIGNATURE_TEACH_RE);
+  if (actionSig && memoryDir && !QUESTION_LEAD_RE.test(ownSrc) && !ownSrcMidQuestion) {
+    try {
+      const verb = await actionLemma(actionSig[1]);
+      const prep = actionSig[3].toLowerCase();
+      const { appendRule, RULE_KIND_ACTION_SIGNATURE } = await import("./memory/core.mjs");
+      const { id } = await appendRule(memoryDir, {
+        name: `${verb} ${prep}`,
+        kind: RULE_KIND_ACTION_SIGNATURE,
+        slots: { subjectClass: actionSig[2], targetClass: actionSig[4] },
+        provenance: teachProvenanceTag(sessionId, new Date().toISOString()),
+      });
+      if (id) {
+        return {
+          text: `noted — remembered: you can ${verb} a ${actionSig[2].toLowerCase()} ${prep} a ${actionSig[4].toLowerCase()}`,
+          via: "assert", miss: false,
+        };
+      }
+    } catch { /* malformed slots — fall through to the ordinary honest-miss cascade */ }
+  }
+
+  const precondNothing = ownSrc.match(ACTION_PRECOND_NOTHING_RE);
+  if (precondNothing && memoryDir && !QUESTION_LEAD_RE.test(ownSrc) && !ownSrcMidQuestion) {
+    const role = actionRoleFor(precondNothing[7], precondNothing[2]);
+    if (!role) {
+      return {
+        text: `I can't place "${precondNothing[7]}" in that rule — the last word must be "target" or the ${precondNothing[2]} itself (e.g. "nothing may ${precondNothing[5].toLowerCase()} ${precondNothing[6].toLowerCase()} the ${precondNothing[2]}").`,
+        via: "teach-miss", miss: true,
+      };
+    }
+    try {
+      const verb = await actionLemma(precondNothing[1]);
+      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 { id } = await appendRule(memoryDir, {
+        name: `${verb} ${prep}`,
+        kind: RULE_KIND_ACTION_PRECOND,
+        slots: {
+          shape: "no-incoming",
+          predicate: `${innerVerb}-${precondNothing[6].toLowerCase()}`,
+          role,
+          scope: scopeWord === "target" ? "any" : scopeWord,
+        },
+        provenance: teachProvenanceTag(sessionId, new Date().toISOString()),
+      });
+      if (id) {
+        return {
+          text: `noted — remembered: to ${verb} ${prep}, nothing may ${precondNothing[5].toLowerCase()} ${precondNothing[6].toLowerCase()} the ${role === "target" ? "target" : precondNothing[2].toLowerCase()}`,
+          via: "assert", miss: false,
+        };
+      }
+    } catch { /* malformed slots — fall through to the ordinary honest-miss cascade */ }
+  }
+
+  const precondComp = ownSrc.match(ACTION_PRECOND_COMPARATIVE_RE);
+  if (precondComp && memoryDir && !QUESTION_LEAD_RE.test(ownSrc) && !ownSrcMidQuestion) {
+    const role = actionRoleFor(precondComp[5], precondComp[2]);
+    const rightWord = precondComp[7].toLowerCase();
+    const otherOk = role === "subject"
+      ? (rightWord === "target" || rightWord === precondComp[4].toLowerCase())
+      : (role === "target" && rightWord === precondComp[2].toLowerCase());
+    if (!role || !otherOk) {
+      return {
+        text: `I can't place "${!role ? precondComp[5] : precondComp[7]}" in that rule — the compared words must be the ${precondComp[2]} and the target (e.g. "the ${precondComp[2]} must be smaller than the target").`,
+        via: "teach-miss", miss: true,
+      };
+    }
+    try {
+      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 { id } = await appendRule(memoryDir, {
+        name: `${verb} ${prep}`,
+        kind: RULE_KIND_ACTION_PRECOND,
+        slots: {
+          shape: "comparator",
+          predicate: `${precondComp[6].toLowerCase().replace(/\s+/g, "-")}-than`,
+          role,
+          scope: scopeWord === "target" ? "any" : scopeWord,
+        },
+        provenance: teachProvenanceTag(sessionId, new Date().toISOString()),
+      });
+      if (id) {
+        return {
+          text: `noted — remembered: to ${verb} ${prep}, the ${precondComp[5].toLowerCase()} must be ${precondComp[6].toLowerCase()} than the ${rightWord}`,
+          via: "assert", miss: false,
+        };
+      }
+    } catch { /* malformed slots — fall through to the ordinary honest-miss cascade */ }
+  }
+
+  const actionEffect = ownSrc.match(ACTION_EFFECT_TEACH_RE);
+  if (actionEffect && memoryDir && !QUESTION_LEAD_RE.test(ownSrc) && !ownSrcMidQuestion) {
+    const gerund = actionEffect[1].toLowerCase();
+    const verb = await actionLemma(gerund);
+    // An unreduced -ing form would mint a name ("moving onto") that can never
+    // match the signature's ("move onto") — decline rather than store a rule
+    // the interpreter can't collect.
+    if (verb === gerund || !gerund.startsWith(verb.slice(0, Math.min(3, verb.length)))) {
+      return {
+        text: `I can't reduce "${actionEffect[1]}" to its verb right now — the lemmatizer isn't available. Retry later, or teach the other rule sentences first.`,
+        via: "teach-miss", miss: true,
+      };
+    }
+    const subjectRole = actionRoleFor(actionEffect[5], actionEffect[2]);
+    const objectRole = actionRoleFor(actionEffect[8], actionEffect[2]);
+    if (!subjectRole || !objectRole || subjectRole === objectRole) {
+      return {
+        text: `I can't place "${!subjectRole ? actionEffect[5] : actionEffect[8]}" in that rule — the effect must relate the ${actionEffect[2]} and the target, once each (e.g. "makes the ${actionEffect[2]} rest on the target").`,
+        via: "teach-miss", miss: true,
+      };
+    }
+    try {
+      const prep = actionEffect[3].toLowerCase();
+      const effVerb = await actionLemma(actionEffect[6]);
+      const { appendRule, RULE_KIND_ACTION_EFFECT } = await import("./memory/core.mjs");
+      const { id } = await appendRule(memoryDir, {
+        name: `${verb} ${prep}`,
+        kind: RULE_KIND_ACTION_EFFECT,
+        slots: {
+          predicate: `${effVerb}-${actionEffect[7].toLowerCase()}`,
+          subjectRole,
+          objectRole,
+        },
+        provenance: teachProvenanceTag(sessionId, new Date().toISOString()),
+      });
+      if (id) {
+        return {
+          text: `noted — remembered: ${gerund} a ${actionEffect[2].toLowerCase()} ${prep} a ${actionEffect[4].toLowerCase()} makes the ${actionEffect[5].toLowerCase()} ${actionEffect[6].toLowerCase()} ${actionEffect[7].toLowerCase()} the ${actionEffect[8].toLowerCase()}`,
+          via: "assert", miss: false,
+        };
+      }
+    } catch { /* malformed slots — fall through to the ordinary honest-miss cascade */ }
+  }
+
+  const rendersAs = ownSrc.match(RENDERS_AS_TEACH_RE);
+  if (rendersAs && memoryDir && !QUESTION_LEAD_RE.test(ownSrc) && !ownSrcMidQuestion) {
+    const stored = await teachFact(memoryDir, sessionId, {
+      subject: rendersAs[1], predicate: "mgx:rendersAs", object: rendersAs[2],
+    });
+    if (stored) return stored;
+  }
+
   // "some Xs are Ys" / "a few Xs are Ys" — the plural class-
   // membership quantifier shape. ACE has no quantifier-phrase pattern at all
   // (parseAce never even attempts a fit), so this is ALWAYS a direct write,
@@ -2912,7 +3162,8 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
     if (comp) {
       const compPredicate = `mgx:${comp[2].toLowerCase().replace(/\s+/g, "-")}-than`;
       const stored = await teachFact(memoryDir, sessionId, {
-        subject: comp[1].trim(), predicate: compPredicate, object: comp[3].trim(),
+        subject: comp[1].trim(), predicate: compPredicate,
+        object: comp[3].trim().replace(/[.!?]+$/, ""),
       });
       if (stored) return stored;
     }
@@ -3733,6 +3984,7 @@ const FACT_PREDICATE_PHRASES = {
   "mgx:hasLastSubevent": "ends with",
   "mgx:hasPrerequisite": "requires",
   "mgx:ownedBy": "is owned by", // the teach lane's ownership frame ("Priya owns tasks.mjs")
+  "mgx:rendersAs": "renders as", // the render-template binding ("a disk renders as a block")
   "mgx:synonym": "means the same as",
   "mgx:antonym": "is the opposite of",
   "mgx:similarTo": "is similar to",
@@ -5029,7 +5281,7 @@ function inheritsChain(graph, startId) {
  *        "what kind of thing is an X" reports X's own type (subject-side first).
  *  Miss-only and run AFTER factAnswer returns null, so it never shadows the
  *  subject-side answer or a schema hit. Returns { text, replace:true } or null. */
-async function factReadBack(memoryDir, query, envelope, miss, graph = null, focusLabel = null, biasByBundle = {}, cache = null) {
+export async function factReadBack(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; }
@@ -7071,7 +7323,222 @@ async function entityOfKindInText(graph, expectedClass, answerText) {
  *  otherwise the unchanged dispatchTool path (which also yields the no-graph error).
  *  A hit updates the focus to the resolved object. Grammar miss / ToolError → a
  *  normal answer, never a crash. */
-async function runAsk(query, { config, source, graph, focus, last, templates, memoryDir, sessionId = "", lexicon = null, env, trace, vocabHint = null, tel = null, biasByBundle = {}, cache = null, vocabAntecedent = null }) {
+/** Load the taught domain for the plan lane: fact rows + rule rows compiled
+ *  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 payload = await loadMemory(memoryDir);
+  const factRows = readFactRows(payload);
+  const ruleRows = readRuleRows(payload);
+  const domain = compileDomain(factRows, ruleRows);
+  const state = stateFromFacts(factRows, domain);
+  return { factRows, ruleRows, domain, state };
+}
+
+/** Human label for a grounded action: name "move onto" + disk-1 + peg-c →
+ *  "move disk-1 onto peg-c". */
+function actionLabel(name, subject, target) {
+  const sp = String(name).split(/\s+/);
+  const verb = sp[0] || "move";
+  const prep = sp.slice(1).join(" ") || "onto";
+  return `${verb} ${subject} ${prep} ${target}`;
+}
+
+/** 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
+ *  three shapes. Mutates planHolder.state (the session's plan slot). */
+async function planLaneAnswer(query, { memoryDir, planHolder, sessionId = "", }) {
+  const q = String(query).trim();
+
+  const goalMatch = q.match(GOAL_TEACH_RE);
+  if (goalMatch) {
+    const { normFactTerm } = await import("./memory/core.mjs");
+    const verb = await verbLemma(goalMatch[3]);
+    if (!verb) {
+      return {
+        text: `I can't reduce "${goalMatch[3]}" to a verb for that goal — try the plain form (e.g. "rests").`,
+        via: "plan", deduced: "record the goal state for a later plan", note: "GOAL frame — verb lemma unavailable, honest decline",
+      };
+    }
+    const spec = {
+      universal: !!goalMatch[1],
+      term: normFactTerm(goalMatch[2]),
+      predicate: `${verb}-${goalMatch[4].toLowerCase()}`,
+      object: normFactTerm(goalMatch[5]),
+    };
+    const tail = q.replace(/^the\s+goal\s+is\s+that\s+/i, "").replace(/[.!?]+$/, "");
+    const prev = planHolder.state && Array.isArray(planHolder.state.goals) && !planHolder.state.done ? planHolder.state : null;
+    planHolder.state = {
+      goals: [...(prev?.goals ?? []), spec],
+      goalTexts: [...(prev?.goalTexts ?? []), 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.`,
+      via: "plan", deduced: "record the goal state for a later plan",
+      note: "GOAL frame — goal spec accumulated on the session plan slot",
+    };
+  }
+
+  const wantsSolve = PLAN_SOLVE_RE.test(q);
+  const wantsLegal = LEGAL_MOVES_RE.test(q);
+  if (!wantsSolve && !wantsLegal) return null;
+
+  let ctx;
+  try {
+    ctx = await loadPlanContext(memoryDir);
+  } catch (err) {
+    return { text: `I can't read the taught domain: ${err?.message ?? err}`, via: "plan", deduced: "plan a move sequence", note: "plan lane — domain load failed" };
+  }
+  const { domain, state, factRows } = ctx;
+  if (!domain.actions.length) {
+    return {
+      text: `no action rules taught yet — teach the game first (e.g. "you can move a disk onto a peg").`,
+      via: "plan", deduced: "plan a move sequence (no action rules yet)", note: "plan lane — honest decline: no action rules",
+    };
+  }
+  if (!state.length) {
+    return {
+      text: `no current state taught yet — state the board first (e.g. "disk-1 rests on peg-a").`,
+      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");
+
+  if (wantsLegal) {
+    let moves;
+    try {
+      moves = movesFromRules(state, domain);
+    } catch (err) {
+      if (err instanceof PlanBudgetError) {
+        return { text: `too many possible moves to enumerate here (${err.message}) — narrow the classes involved.`, via: "plan", deduced: "list the legal moves (budget exceeded)", note: "plan lane — budget decline" };
+      }
+      throw err;
+    }
+    if (!moves.length) {
+      return { text: "no legal moves from the current state.", via: "plan", deduced: "list the legal moves (none)", note: "plan lane — legal moves: none" };
+    }
+    const lines = moves.map((m, i) => `  ${i + 1}. ${actionLabel(m.action.name, m.action.subject, m.action.target)}`);
+    return {
+      text: `${moves.length} legal move${moves.length === 1 ? "" : "s"} from here:\n${lines.join("\n")}`,
+      via: "plan", deduced: "list the legal moves from the current state",
+      note: "plan lane — movesFromRules over the current snapshot, one ply, no search",
+    };
+  }
+
+  // "solve it" — the full search.
+  if (!planHolder.state?.goals?.length) {
+    return {
+      text: `no goal set yet — teach one first (e.g. "the goal is that every disk rests on peg-c").`,
+      via: "plan", deduced: "plan a move sequence (no goal yet)", note: "plan lane — honest decline: no goal",
+    };
+  }
+  const goals = planHolder.state.goals;
+  const goalText = planHolder.state.goalTexts.join("; ");
+  let isGoal;
+  try {
+    isGoal = compileGoal(goals, domain);
+  } 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");
+  let found;
+  try {
+    found = findActionPath(state, isGoal, (s) => movesFromRules(s, domain), { maxDepth: 300, stateKey: stateKeyFor });
+  } catch (err) {
+    if (err instanceof PlanBudgetError) {
+      return { text: `the search space is too large (${err.message}) — narrow the classes involved.`, via: "plan", deduced: "plan a move sequence (budget exceeded)", note: "plan lane — budget decline" };
+    }
+    throw err;
+  }
+  if (!found) {
+    return {
+      text: `no plan found within 300 moves from the current state to: ${goalText}.`,
+      via: "plan", deduced: "plan a move sequence (no path)", note: "plan lane — honest miss: findActionPath returned null",
+    };
+  }
+  const n = found.actions.length;
+  const actions = found.actions.map((a) => ({
+    name: a.name, subject: a.subject, target: a.target,
+    label: actionLabel(a.name, a.subject, a.target),
+  }));
+  const stepGoals = actions.map((a, i) =>
+    `${a.label} (step ${i + 1} of ${n}, working toward: ${goalText})`);
+  const renderHints = {};
+  const ordering = [];
+  for (const r of factRows) {
+    if (r.predicate === "mgx:rendersAs") renderHints[r.subject] = r.object;
+    else if (/-than$/.test(r.predicate)) ordering.push({ subject: r.subject, predicate: r.predicate, object: r.object });
+  }
+  const plan = {
+    actions, states: found.states, stepGoals,
+    goal: { text: goalText, specs: goals },
+    domain: { classMembers: domain.classMembers, ordering, renderHints },
+  };
+  planHolder.state = {
+    ...planHolder.state, actions, states: found.states, stepGoals, cursor: 0, done: false, goalText,
+  };
+  const ruleNames = [...new Set(domain.actions.map((a) => a.name))].join('", "');
+  const moveLines = actions.map((a, i) => `  ${i + 1}. ${a.label}`);
+  const text = n === 0
+    ? `the goal already holds — nothing to do.`
+    : `plan found — ${n} move${n === 1 ? "" : "s"} (shortest):\n${moveLines.join("\n")}\n\n` +
+      `because — you taught me the "${ruleNames}" rule${domain.actions.length === 1 ? "" : "s"}` +
+      `${ordering.length ? ` and ${ordering.length} ordering fact${ordering.length === 1 ? "" : "s"}` : ""}. ` +
+      `Say "next" to make move 1, or ask "what moves are legal now".`;
+  return {
+    text, via: "plan",
+    deduced: `plan a move sequence from the current state to the goal (${n} move${n === 1 ? "" : "s"})`,
+    note: "plan lane — compileDomain + findActionPath over the taught rules; plan held on the session slot",
+    plan,
+  };
+}
+
+/** Execute the active plan's next move: append the successor snapshot's rows
+ *  as @stepK facts, advance the cursor, and on the final step re-read the
+ *  store and confirm the goal from the WRITTEN facts (never assumed). */
+async function executePlanStep(planHolder, { memoryDir, sessionId = "" }) {
+  const ps = planHolder.state;
+  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");
+  for (const row of rows) {
+    await appendFact(memoryDir, {
+      subject: `${row.subject}@step${k}`, predicate: row.predicate, object: row.object,
+      provenance: `plan:${sessionId || "chat"}:step${k}`,
+    });
+  }
+  planHolder.state = { ...ps, cursor: k };
+  const boardLine = rows.map((r) => `${r.subject} ${predicatePhrase(r.predicate)} ${r.object}`).join("; ");
+  if (k < ps.actions.length) {
+    return {
+      text: `moved — ${action.label} (step ${k} of ${ps.actions.length}). board@step${k}: ${boardLine}`,
+      deduced: ps.stepGoals[k] ? ps.stepGoals[k] : `continue the plan (step ${k + 1} of ${ps.actions.length})`,
+    };
+  }
+  // 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 payload = await loadMemory(memoryDir);
+  const factRows = readFactRows(payload);
+  const domain = compileDomain(factRows, readRuleRows(payload));
+  const finalState = stateFromFacts(factRows, domain);
+  const holds = compileGoal(ps.goals, domain)(finalState);
+  planHolder.state = { ...planHolder.state, done: true };
+  return {
+    text: holds
+      ? `moved — ${action.label} (step ${k} of ${ps.actions.length}). board@step${k}: ${boardLine}\n\ndone — ${ps.goalText} (checked against board@step${k}'s written facts, not assumed).`
+      : `moved — ${action.label} (step ${k} of ${ps.actions.length}). board@step${k}: ${boardLine}\n\nBUT the goal does NOT hold against the written facts — the plan or the state drifted; re-teach the state and solve again.`,
+    deduced: holds ? `goal reached — ${ps.goalText} (${k} of ${k} steps)` : "plan finished but the goal check failed",
+  };
+}
+
+async function runAsk(query, { config, source, graph, focus, last, templates, memoryDir, sessionId = "", lexicon = null, env, trace, vocabHint = null, tel = null, biasByBundle = {}, cache = null, vocabAntecedent = null, planHolder = null }) {
   const ts = new Date().toISOString();
   // DISCOURSE ANAPHORA: a follow-up like "which of those are tested" / "count
   // them" filters or counts the PREVIOUS answer's entity set, threaded as
@@ -7300,6 +7767,23 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
       note(trace, `lane: (1) META/SELF — bare self/session question recognized, answered via="${meta.via}"`);
     }
   }
+  // (1p) PLAN — the goal/solve/legal-moves recognizers over taught action
+  // rules. Sits ABOVE the conversational catch-all: "solve it" is three
+  // short words and isConversational() would otherwise claim it into the
+  // orientation card before this lane ever ran.
+  let planResult = null;
+  if (!handled && miss && memoryDir && planHolder) {
+    const planLane = await planLaneAnswer(query, { memoryDir, planHolder, sessionId });
+    if (planLane) {
+      answer = planLane.text; via = planLane.via; recordMiss = false; handled = true;
+      if (planLane.plan) planResult = planLane.plan;
+      if (planLane.deduced) {
+        deduced = planLane.deduced;
+        note(trace, `goal: ${deduced} (revised — the plan lane answered)`);
+      }
+      note(trace, `lane: (1p) PLAN — ${planLane.note}`);
+    }
+  }
   // "what about X" with a genuine PRIOR turn to continue is exempt from the
   // conversational catch-all even when short/non-codeish: isConversational()
   // can't see that discourseRewrite/describeWrapperAnswer haven't had their
@@ -7833,7 +8317,7 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
   // `goal`: the SAME deduced string the debug trace's own "goal:" line
   // carries. Only runAsk ever sets this field, so the always-on goal line is
   // scoped to real ask-engine turns by construction.
-  return { answer, logLines, record, focus: newFocus, detail, effectiveQuery, goal: deduced };
+  return { answer, logLines, record, focus: newFocus, detail, effectiveQuery, goal: deduced, ...(planResult ? { plan: planResult } : {}) };
 }
 
 /** A non-ask, non-dispatch chat turn (count answer, /stats) — the same
@@ -8255,7 +8739,7 @@ function vocabAntecedentFrom(last) {
   return m ? m[1] : null;
 }
 
-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 } = {}) {
+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 } = {}) {
   const line = String(input ?? "").trim();
   // ONE fresh, empty cache for this turn only — every factRows() reader
   // reached from this call shares it, so the first reader computes
@@ -8297,7 +8781,11 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
   // vocabHint: createSession computes this ONCE per session; a direct
   // runTurn() caller that doesn't pass one gets it computed here instead.
   const resolvedVocabHint = vocabHint ?? vocabExampleHint(await hasSeededVocabulary(memoryDir));
-  const ctx = { config, source, graph, focus, last, memoryDir, sessionId, templates, env, lexicon, trace, narrate, vocabHint: resolvedVocabHint, tel, biasByBundle, cache: factRowsCache, vocabAntecedent };
+  // The session's in-progress plan rides a mutable holder: the plan lane and
+  // the PLAN NEXT block below write planHolder.state; every other path leaves
+  // it untouched, and the caller re-threads whatever comes back.
+  const planHolder = { state: planState };
+  const ctx = { config, source, graph, focus, last, memoryDir, sessionId, templates, env, lexicon, trace, narrate, vocabHint: resolvedVocabHint, tel, biasByBundle, cache: factRowsCache, vocabAntecedent, planHolder };
   // A DISPATCHED turn (count / slash-command / ask) becomes the new "last
   // answer" that why/say-more re-renders; a conversational turn does not.
   // Every dispatched turn's result passes through finish() here — the LAST
@@ -8338,6 +8826,21 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
   const convo = vocabAntecedent ? null : conversationalTurn(workingLine, ctx);
   if (convo) return withNarration(convo, trace, "casual/social — no graph intent");
 
+  // PLAN NEXT — "next"/"continue" with an ACTIVE plan executes the plan's
+  // next move as a snapshot write. Checked BEFORE the MORE_RE pager because
+  // MORE_RE owns the same words; with no active plan this block never fires
+  // and paging behaves exactly as before.
+  if (memoryDir && PLAN_NEXT_RE.test(workingLine)
+      && planHolder.state && !planHolder.state.done
+      && Array.isArray(planHolder.state.actions) && planHolder.state.cursor < planHolder.state.actions.length) {
+    const step = await executePlanStep(planHolder, { memoryDir, sessionId });
+    note(trace, `goal: ${step.deduced}`);
+    note(trace, "lane: PLAN NEXT — executed the active plan's next move as an @stepK snapshot write");
+    const rec = withLast(plainTurn(workingLine, step.text, { via: "plan", focus }), step.deduced);
+    rec.planState = planHolder.state;
+    return rec;
+  }
+
   // "more" — page the remainder of a previous long listing, if one is held. Gated on
   // an actual pending remainder so a bare "more" with nothing to continue falls through
   // to the ordinary path (an honest miss), never a pretend page.
@@ -8347,6 +8850,39 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
     return withLast(morePage(workingLine, ctx), "continue viewing a previous long listing");
   }
 
+  // Multi-sentence PLAN pre-split — one message carrying state sentences plus
+  // a goal/trigger ("disk-1 rests on disk-2. … the goal is that …. solve it.")
+  // runs each sentence as its own nested turn, threading focus/last/planState
+  // through, and answers with the final turn's result behind brief receipts.
+  if (!_noSplit && memoryDir) {
+    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) || LEGAL_MOVES_RE.test(lastSentence)) {
+        let f = focus; let l = last; let ps = planHolder.state;
+        const receipts = [];
+        let finalRec = null;
+        for (const sentence of sentences) {
+          const r = await runTurn(sentence, {
+            config, source, graph, focus: f, last: l, memoryDir, sessionId, env, lexicon,
+            narrate: false, vocabHint, tel, biasByBundle, planState: ps, _noSplit: true,
+          });
+          f = r.focus ?? f;
+          l = r.last ?? l;
+          if ("planState" in r) ps = r.planState;
+          finalRec = r;
+          receipts.push(String(r.answer ?? "").split("\n")[0]);
+        }
+        const receiptLines = receipts.slice(0, -1).map((t) => `• ${t}`).join("\n");
+        const combined = { ...finalRec, answer: receiptLines ? `${receiptLines}\n\n${finalRec.answer}` : finalRec.answer };
+        combined.planState = ps;
+        combined.focus = f;
+        combined.last = l;
+        return combined;
+      }
+    }
+  }
+
   if (workingLine.startsWith("/")) return withLast(await runCommand(workingLine, ctx), "use a specific tool/command directly");
   // Declarative ACE sentences ("every module is a artifact") ASSERT into tmct's
   // own memory and confirm — they are statements to remember, not graph queries.
@@ -8359,6 +8895,15 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
       note(trace, "lane: assertTurn — grammar/ace.mjs parseAce matched a full triple with no residue");
       return withLast(asserted, "teach/remember a new fact");
     }
+    // Bare declarative taxonomy (hyphenated-instance membership, article-led
+    // kind-of) — see bareTaxonomyTeach. Checked here because the ask engine
+    // would otherwise parse these statements as inherits QUESTIONS.
+    const taxonomy = await bareTaxonomyTeach(workingLine, ctx);
+    if (taxonomy) {
+      note(trace, "goal: teach/remember a new fact (bare declarative taxonomy)");
+      note(trace, "lane: bareTaxonomyTeach — hyphenated-instance or article-led kind-of declarative, stored before the ask engine could parse it as a question");
+      return withLast(plainTurn(workingLine, taxonomy.text, { via: taxonomy.via, miss: taxonomy.miss, focus }), "teach/remember a new fact");
+    }
   }
   // MEMORY-STORE counts first ("how many facts / utterances do you know") — the
   // memory graph owns Facts + Utterances, so these are answerable and consistent
@@ -8415,7 +8960,11 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
     note(trace, "lane: answerCount — a header-count aggregate question, answered mechanically off the graph header, never dispatched to the ask engine");
     return withLast(plainTurn(workingLine, count, { via: "count", focus }), "get a count of a graph kind");
   }
-  return withLast(await runAsk(workingLine, ctx), "unclear — no goal signal computed by the ask engine");
+  {
+    const rec = withLast(await runAsk(workingLine, ctx), "unclear — no goal signal computed by the ask engine");
+    rec.planState = planHolder.state;
+    return rec;
+  }
 }
 
 // ---- W3: seedMemory → bootstrap (first run in a graph-less repo) ----
@@ -8728,6 +9277,7 @@ export async function createSession({
   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 {
@@ -8737,6 +9287,7 @@ export async function createSession({
     // 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),
@@ -8748,7 +9299,7 @@ export async function createSession({
     async turn(line) {
       let result;
       try {
-        result = await runTurn(line, { config, source, graph, focus, last, memoryDir, sessionId, env, lexicon, narrate: narrateOn, vocabHint, tel, biasByBundle });
+        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);
@@ -8762,6 +9313,7 @@ export async function createSession({
       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;
@@ -8777,7 +9329,7 @@ export async function createSession({
       });
       await upsertGraph(record.ts);
       turns += 1;
-      return { answer, end: Boolean(end), prompt: promptFor(focus) };
+      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