@polycode-projects/the-mechanical-code-talker 2.11.6 → 2.11.10

package/src/services/chat.mjs

@@ -4233,7 +4233,7 @@ async function teachExclusionReason(sentence) {
 }
 export { teachExclusionReason };
 
-async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cache = null, planHolder = null, graph = null }) {
+async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cache = null, planHolder = null, graph = null, gameConfig = DEFAULT_GAME_CONFIG }) {
   // A closed discourse-marker preamble ahead of a teach sentence ("howdy
   // pardner, remember that TaskController is fragile") would otherwise
   // corrupt TEACH_RE's own match, so strip it first. applyPreambleFrames is
@@ -4349,7 +4349,7 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
   if (memoryDir && !QUESTION_LEAD_RE.test(conjSrc) && /\s+and\s+/i.test(conjSrc)
     && !(await hasMidSentenceInterrogative(conjSrc))) {
     const rewrap = (half) => (wrapped != null ? `remember that ${half}` : half);
-    const recurse = (half) => teachLane(rewrap(half), { memoryDir, sessionId, lexicon, cache, planHolder });
+    const recurse = (half) => teachLane(rewrap(half), { memoryDir, sessionId, lexicon, cache, planHolder, gameConfig });
     const stripNoted = (t) => String(t).replace(/^noted — remembered(?:\s+\d+\s+facts?)?:\s*/i, "").trim();
     const shared = conjSrc.match(/^(.+?)\s+and\s+((?:is|are|has|have|can)\b.+)$/i);
     const sharedSubject = shared ? shared[1].match(/^(.+?)\s+(?:is|are|has|have|can)\b/i)?.[1]?.trim() : null;
@@ -4569,13 +4569,15 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
     }
   }
 
-  // MID-PLAN BOARD TEACH — a locative fact about a piece the LIVE plan's
-  // moves touch is declined naming the plan, never accepted-then-ignored:
-  // the plan's board rides @step snapshots, so a base-fact write here would
-  // be confirmed ("noted — remembered") and then contradicted by the very
-  // next "next". Scoped to the locative teach shape over the plan's own
-  // pieces; every other teach (new vocabulary, new pieces, rules) is
-  // untouched, and with no live plan nothing changes at all.
+  // MID-PLAN BOARD TEACH — a locative fact about a piece the LIVE plan's moves
+  // touch is accepted and the plan is re-searched from the moved board, never
+  // confirmed-then-contradicted by the next move. The change is written as a
+  // NEW whole-board @step snapshot layer (never a base fact — a base write here
+  // would sit under the standing snapshots and trip the contradictory-board
+  // check on the next solve), then the goal is re-searched from the board as it
+  // now stands. Scoped to the locative teach shape over the plan's own pieces;
+  // every other teach (new vocabulary, new pieces, rules) is untouched, and
+  // with no live plan nothing changes at all.
   {
     const livePlan = planHolder?.state && !planHolder.state.done
       && Array.isArray(planHolder.state.actions) && planHolder.state.actions.length
@@ -4583,13 +4585,49 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
     const boardSrc = (wrapped ?? raw).replace(/[.!?]+\s*$/, "");
     const board = livePlan ? boardSrc.match(BOARD_TEACH_LOCATIVE_RE) : null;
     if (board && memoryDir && !QUESTION_LEAD_RE.test(boardSrc)) {
-      const { normFactTerm } = await import("../adapters/memory/core.mjs");
+      const { normFactTerm, appendFact } = await import("../adapters/memory/core.mjs");
       const planPieces = new Set(livePlan.actions.flatMap((a) => [normFactTerm(a.subject), normFactTerm(a.target)]));
       if (planPieces.has(normFactTerm(board[1])) || planPieces.has(normFactTerm(board[4]))) {
+        const { maxSnapshotStep } = await import("../domain/domain.mjs");
+        const { factRows, domain, state } = await loadPlanContext(memoryDir);
+        // The single-placement change over the current fold: same subject and
+        // predicate, new object. Written as the whole mutated board under a
+        // fresh @step layer, so stateFromFacts reads it as the live board and no
+        // base fact is left to contradict the next solve.
+        const subject = normFactTerm(board[1]);
+        const predicate = `mgx:${board[2].toLowerCase()}-${board[3].toLowerCase()}`;
+        const object = normFactTerm(board[4]);
+        const mutated = state.filter((r) => !(r.subject === subject && r.predicate === predicate));
+        mutated.push({ subject, predicate, object });
+        const layer = maxSnapshotStep(factRows, domain) + 1;
+        for (const r of mutated) {
+          await appendFact(memoryDir, {
+            subject: `${r.subject}@step${layer}`, predicate: r.predicate, object: r.object,
+            provenance: `plan:${sessionId || "chat"}:teach-replan:step${layer}`,
+          });
+        }
         const at = livePlan.cursor > 0 ? `step ${livePlan.cursor} of ${livePlan.actions.length}` : `0 of ${livePlan.actions.length} moves made`;
+        const goalText = livePlan.goalText ?? livePlan.goalTexts?.join("; ") ?? "the held goal";
+        const remembered = `noted — remembered: "${board[0]}".`;
+        const replan = await solveHeldGoals({ memoryDir, planHolder, gameConfig });
+        if (replan.plan) {
+          const moves = replan.plan.actions.map((a, i) => `${i + 1}. ${a.label}`).join("; ");
+          return {
+            text: `${remembered} That changes the board the live plan was standing on (${at}, toward: ${goalText}), so I replanned from the board as it now stands: ${moves}. Say "next" to make move 1.`,
+            via: "plan", miss: false,
+          };
+        }
+        // The write STANDS, but nothing reaches the goal from the moved board:
+        // the old plan is dropped (goals kept, plan reset) and the failed replan
+        // is named, never a silent success.
+        const maxDepth = gameConfig?.planning?.maxDepth ?? DEFAULT_GAME_CONFIG.planning.maxDepth;
+        planHolder.state = {
+          goals: livePlan.goals, goalTexts: livePlan.goalTexts,
+          actions: null, states: null, stepGoals: null, cursor: 0, done: false,
+        };
         return {
-          text: `a plan is live (${at}, toward: ${livePlan.goalText ?? livePlan.goalTexts?.join("; ") ?? "the held goal"}) — I won't change the board mid-plan: the plan's moves write board@step snapshots, and "${board[0]}" would sit under them, silently contradicted by the next move. Say "forget the goal" first, re-teach the board, then "solve it" to replan.`,
-          via: "teach-miss", miss: true,
+          text: `${remembered} That changes the board the live plan was standing on (${at}, toward: ${goalText}) — from this new board no plan reaches the goal within ${maxDepth} moves, so the old plan is dropped. Re-teach the board or say "forget the goal".`,
+          via: "plan", miss: false,
         };
       }
     }
@@ -5405,6 +5443,17 @@ const MODULE_ORIENT_RE = new RegExp(`^what\\s+does\\s+(.+?)\\s+do${TRAILING_ADVE
  *  ending safe — a syntactic match against a term that isn't a real entity
  *  simply falls through unchanged, same as every other lane in this file. */
 const MODULE_ORIENT_SVO_RE = new RegExp(`^what\\s+(.+?)\\s+does${TRAILING_ADVERB_RE}\\??$`, "i");
+/** "whats X do" / "what's X do" / "what is X do" — the CONTRACTED phrasing of
+ *  "what does X do", where the auxiliary collapses into the "what's"/"whats"
+ *  opener and "do" trails the term. MODULE_ORIENT_RE's own "does BEFORE the
+ *  term" anchor never sees it, and MODULE_ORIENT_SVO_RE needs a literal "what "
+ *  (with a space) so the bare "whats" spelling escapes that too. Safe to end
+ *  this loosely because the lane's exact-unique resolveEntity gate below is
+ *  still the sole authority — same argument as MODULE_ORIENT_SVO_RE: a term
+ *  that is not a real unique entity (a pronoun subject "whats it do", a
+ *  non-word) simply declines. The "what(?:'s|s|\s+is)" opener mirrors
+ *  MODULE_PURPOSE_RE's tolerance for the apostrophe-less "whats" contraction. */
+const MODULE_ORIENT_IS_DO_RE = new RegExp(`^what(?:'s|s|\\s+is)\\s+(.+?)\\s+do${TRAILING_ADVERB_RE}\\??$`, "i");
 // Purpose/identity phrasing: "whats X for"/"what's X
 // about"/"what is X for", the sibling of "what does X do" that asks for the
 // SAME module-grain overview. Deliberately does NOT claim the literal noun
@@ -5474,7 +5523,7 @@ async function moduleOrientLane(query, { graph }) {
   // (stripFillerWords already eats "please"/"could you" as filler; the politeness
   // regex only adds the "explain [to me]" wrapper on top).
   q = stripFillerWords(applyPreambleFrames(correctMisspellings(q))).replace(MODULE_ORIENT_POLITENESS_RE, "");
-  const m = q.match(MODULE_ORIENT_RE) || q.match(MODULE_PURPOSE_OF_RE) || q.match(MODULE_PURPOSE_RE) || q.match(MODULE_ORIENT_SVO_RE);
+  const m = q.match(MODULE_ORIENT_RE) || q.match(MODULE_PURPOSE_OF_RE) || q.match(MODULE_PURPOSE_RE) || q.match(MODULE_ORIENT_SVO_RE) || q.match(MODULE_ORIENT_IS_DO_RE);
   // "what does src/core/store.mjs do" already reached the overview; the bare
   // path and "what is <path>" did not, so the same module answered one
   // phrasing and walled two. Both are claimed here rather than in ask.mjs,
@@ -8526,7 +8575,19 @@ async function factReadBackReaders(memoryDir, query, envelope, miss, graph = nul
         }
       }
     }
-    return null;
+    // An isa-shaped FIRST turn on a pristine store falls THROUGH to the isa
+    // reader below rather than taking the empty-store bail-out: that reader's
+    // body tolerates rows=[] end-to-end (every derived array is empty) and
+    // lands on the specific "I don't know X at all yet — teach me" closer, so
+    // the very first "is X a Y" no longer hits the generic grammar wall just
+    // because nothing has been taught yet. The graph inherits-bridge above
+    // already answers the code-entity direct/converse cases before this point.
+    // A leading "there" subject is existential ("is there a class called X"),
+    // which ISA_ASK_RE also matches but a LATER existence lane owns and answers
+    // better — it keeps the bail-out, mirroring this block's own emptyIsAdj
+    // "there" exclusion above. Every OTHER empty-store shape keeps the bail-out.
+    const fallThroughIsa = qHedge.match(ISA_ASK_RE) || matchWhyIsa(q);
+    if (!((fallThroughIsa && !/^there\b/i.test(fallThroughIsa[1].trim())) || CONFIRM_TAG_RE.test(q))) return null;
   }
   const isa = rows.filter((f) => ISA_PREDICATES.has(f.predicate));
   const byTrust = (a, b) => b.trust - a.trust;
@@ -9997,6 +10058,14 @@ const STACCATO_LEAKED_CONNECTIVES = new Set(["and", "also", "so", "then", "now"]
  *  named `edithistory`) is never mistaken for the pronoun. */
 const PRONOUN_IN_QUERY_RE = new RegExp(`\\b(?:${[...CONTEXT_WORDS].join("|")})\\b`, "i");
 
+/** The referring pronouns an EMBEDDED "what about X, <wh-clause>" swap replaces
+ *  — CONTEXT_WORDS (it/this/that/here) plus the personal pronouns
+ *  PRONOUN_IN_QUERY_RE deliberately omits (he/she/they/them): the embedded
+ *  clause's own subject/object, not a prior-turn antecedent, so a subject
+ *  pronoun like "he" that never appears in a code-graph query still has to be
+ *  swappable here. */
+const EMBEDDED_PRONOUN_RE = /\b(?:it|this|that|here|he|she|they|them)\b/i;
+
 /** DISCOURSE CONTINUATION: "what about X" carries the PRIOR
  *  turn's question shape across the turn boundary — re-asking it with X in place of
  *  the previous subject/object. Returns the reconstructed query (parsed like any
@@ -10007,6 +10076,32 @@ function discourseRewrite(query, last) {
   let newSubj;
   if (m) {
     newSubj = m[1].trim();
+    // An embedded question spliced into the "what about" subject ("what about
+    // the store, what it do") must NEVER be substituted into the prior turn's
+    // shape — that inherits the prior turn's DIRECTION onto a question asking
+    // the opposite ("who uses store.mjs" then "…what it do" would answer "who
+    // uses the store"). Split on the interior wh-clause and re-read the
+    // remainder against a CLOSED micro-set; a clause outside it is an honest
+    // miss, never the prior-turn substitution below. A comma NOT followed by a
+    // wh-word ("what about the store, please") never matches and keeps its
+    // ordinary swap.
+    const embedded = newSubj.match(/^(.+?),\s*(what|who|which|where|how)\b\s*(.*)$/i);
+    if (embedded) {
+      const embSubj = embedded[1].trim();
+      const wh = embedded[2].toLowerCase();
+      const rest = embedded[3].trim();
+      // "what [it/this/that/he/she] do(es)" → the module overview of the new
+      // subject, which MODULE_ORIENT_RE serves verbatim.
+      if (wh === "what" && /^(?:he|she|it|this|that)?\s*do(?:es)?$/i.test(rest)) {
+        return `what does ${embSubj} do`;
+      }
+      // A wh-clause carrying its OWN pronoun ("what does it call") → swap that
+      // pronoun for the new subject and ask the clause standalone.
+      if (EMBEDDED_PRONOUN_RE.test(rest)) {
+        return `${wh} ${rest.replace(EMBEDDED_PRONOUN_RE, () => embSubj)}`;
+      }
+      return null;
+    }
   } else {
     const sm = String(query).match(STACCATO_SWAP_RE);
     const cand = sm?.[1]?.trim();
@@ -11243,14 +11338,16 @@ async function planLaneAnswer(query, { memoryDir, planHolder, sessionId = "", ga
   const wantsSolve = PLAN_SOLVE_RE.test(q);
   const wantsLegal = LEGAL_MOVES_RE.test(q);
   if (!wantsSolve && !wantsLegal) return null;
+  if (wantsSolve) return solveHeldGoals({ memoryDir, planHolder, gameConfig });
 
+  // "what moves are legal now" — one ply off the current board, no search.
   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;
+  const { domain, state } = 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").`,
@@ -11263,30 +11360,55 @@ async function planLaneAnswer(query, { memoryDir, planHolder, sessionId = "", ga
       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/domain.mjs");
-
-  if (wantsLegal) {
-    let moves;
-    try {
-      moves = movesFromRules(state, domain, { scope: "taught" });
-    } 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 { movesFromRules, PlanBudgetError } = await import("../domain/domain.mjs");
+  let moves;
+  try {
+    moves = movesFromRules(state, domain, { scope: "taught" });
+  } 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" };
     }
-    const lines = moves.map((m, i) => `  ${i + 1}. ${actionLabel(m.action.name, m.action.subject, m.action.target)}`);
+    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",
+  };
+}
+
+/** Search the taught rules for a shortest sequence to the held goal(s) from the
+ *  CURRENT board fold (the newest @stepK snapshot, else the taught board).
+ *  Mints the plan onto planHolder.state and returns the plan-found reply on
+ *  success; on any missing precondition or an unreachable goal it returns the
+ *  matching honest decline and leaves planHolder.state untouched. Shared by the
+ *  plan lane's "solve it" and by the two drift sites that re-search after the
+ *  board moves under a live plan. */
+async function solveHeldGoals({ memoryDir, planHolder, gameConfig = DEFAULT_GAME_CONFIG }) {
+  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: `${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",
+      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",
     };
   }
-
-  // "solve it" — the full search.
+  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, maxSnapshotStep } = await import("../domain/domain.mjs");
   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").`,
@@ -11403,8 +11525,13 @@ async function planLaneAnswer(query, { memoryDir, planHolder, sessionId = "", ga
   // instead of an honest miss — see PLAN_WHY_SHORTEST_RE's own call site.
   const becauseText = `you taught me the "${ruleNames}" rule${domain.actions.length === 1 ? "" : "s"}`
     + `${ordering.length ? ` and ${ordering.length} ordering fact${ordering.length === 1 ? "" : "s"}` : ""}.`;
+  // The snapshot layer a fresh plan's step writes stack ABOVE: 0 on an
+  // untouched board, K after a prior plan left @stepK rows standing. Without it
+  // a replan's step 1 would write @step1 below the standing @stepK layer and be
+  // read as stale by stateFromFacts (which prefers the newest snapshot).
+  const stepBase = maxSnapshotStep(factRows, domain);
   planHolder.state = {
-    ...planHolder.state, actions, states: found.states, stepGoals, cursor: 0, done: false, goalText, becauseText,
+    ...planHolder.state, actions, states: found.states, stepGoals, cursor: 0, done: false, goalText, becauseText, stepBase,
   };
   const moveLines = actions.map((a, i) => `  ${i + 1}. ${a.label}`);
   // A piece with no taught position is an ASSUMPTION the plan silently makes
@@ -11440,23 +11567,27 @@ async function planLaneAnswer(query, { memoryDir, planHolder, sessionId = "", ga
 /** 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 = "" }) {
+async function executePlanStep(planHolder, { memoryDir, sessionId = "", gameConfig = DEFAULT_GAME_CONFIG }) {
   const ps = planHolder.state;
   const k = ps.cursor + 1;
+  // The snapshot index the board rows are written under: it stacks above any
+  // layer standing when the plan was minted (stepBase), while k stays the plan's
+  // own 1-of-N move counter. On a fresh board stepBase is 0 and snap === k.
+  const snap = (ps.stepBase ?? 0) + k;
   const action = ps.actions[ps.cursor];
   const rows = ps.states[k];
   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,
-      provenance: `plan:${sessionId || "chat"}:step${k}`,
+      subject: `${row.subject}@step${snap}`, predicate: row.predicate, object: row.object,
+      provenance: `plan:${sessionId || "chat"}:step${snap}`,
     });
   }
   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}`,
+      text: `moved — ${action.label} (step ${k} of ${ps.actions.length}). board@step${snap}: ${boardLine}`,
       deduced: ps.stepGoals[k] ? ps.stepGoals[k] : `continue the plan (step ${k + 1} of ${ps.actions.length})`,
     };
   }
@@ -11468,12 +11599,31 @@ async function executePlanStep(planHolder, { memoryDir, sessionId = "" }) {
   const domain = compileDomain(factRows, readRuleRows(payload));
   const finalState = stateFromFacts(factRows, domain);
   const holds = compileGoal(ps.goals, domain, { scope: "taught" })(finalState);
+  const movedLine = `moved — ${action.label} (step ${k} of ${ps.actions.length}). board@step${snap}: ${boardLine}`;
+  if (holds) {
+    planHolder.state = { ...planHolder.state, done: true };
+    return {
+      text: `${movedLine}\n\ndone — ${ps.goalText} (checked against board@step${snap}'s written facts, not assumed).`,
+      deduced: `goal reached — ${ps.goalText} (${k} of ${k} steps)`,
+    };
+  }
+  // The final board doesn't reach the goal — the plan or the board drifted.
+  // Before settling for the miss, re-search from the board as it now stands: a
+  // found plan is disclosed and held (never a silent success), a miss keeps the
+  // honest failure and names the failed replan.
+  const replan = await solveHeldGoals({ memoryDir, planHolder, gameConfig });
+  if (replan.plan) {
+    const moves = replan.plan.actions.map((a, i) => `${i + 1}. ${a.label}`).join("; ");
+    return {
+      text: `${movedLine}\n\nBUT the goal does NOT hold against the written facts — the state drifted, so I replanned from board@step${snap}: ${moves}. Say "next" to continue.`,
+      deduced: "plan finished but the goal check failed — replanned from the drifted board",
+    };
+  }
+  const maxDepth = gameConfig?.planning?.maxDepth ?? DEFAULT_GAME_CONFIG.planning.maxDepth;
   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",
+    text: `${movedLine}\n\nBUT the goal does NOT hold against the written facts — the plan or the state drifted; re-teach the state and solve again — I looked for a new plan from board@step${snap} and found none within ${maxDepth} moves.`,
+    deduced: "plan finished but the goal check failed",
   };
 }
 
@@ -12091,6 +12241,16 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
   const staccatoSwapMatch = String(query).match(STACCATO_SWAP_RE);
   const isStaccatoSwap = !!(last?.query && staccatoSwapMatch && NAME_TOKEN_RE.test(staccatoSwapMatch[1]?.trim() || ""));
   const isWhatAboutContinuation = !!(last?.query && WHAT_ABOUT_RE.test(String(query))) || isStaccatoSwap;
+  // A bare vague-touch OPENER ("wat about validate", "tell me about store.mjs")
+  // whose term resolves to a UNIQUE graph entity is a genuine describe request,
+  // not small talk — defer past the conversational card so describeWrapperAnswer
+  // (4d, below) serves its module/entity overview. Distinct from
+  // isWhatAboutContinuation above, which needs a prior turn: this fires on the
+  // FIRST turn too, and covers the "tell me about"/"explain" surfaces
+  // vagueTouchTermOf reads. resolveEntity already declines on ambiguity, so an
+  // ambiguous or unknown term ("wat about xyzzy") keeps today's orientation card.
+  const vagueTouchTerm = graph ? vagueTouchTermOf(String(query)) : null;
+  const isVagueTouchResolvable = !!(vagueTouchTerm && await resolveEntity(graph, vagueTouchTerm));
   // Same exemption for "describe it"/"tell me about that" — needs the SAME
   // deferral to reach describeWrapperAnswer's focus-aware pronoun resolution.
   // Gated on an actual standing focus, same honest-decline discipline as
@@ -12202,7 +12362,7 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
       } catch { /* leave false — the ordinary path decides */ }
     }
   }
-  const conversationalCandidateBaseGate = !handled && miss && !envelope?.parsed && !isWhatAboutContinuation && !isDescribePronounContinuation && !isExplainTouch && !isStaccatoNegation && !isVagueRelationTouch && !isStaccatoComparative && !isStaccatoPronounNoFocus && !isPluralMembershipTeach && !isBareRelationalVerbTeach;
+  const conversationalCandidateBaseGate = !handled && miss && !envelope?.parsed && !isWhatAboutContinuation && !isVagueTouchResolvable && !isDescribePronounContinuation && !isExplainTouch && !isStaccatoNegation && !isVagueRelationTouch && !isStaccatoComparative && !isStaccatoPronounNoFocus && !isPluralMembershipTeach && !isBareRelationalVerbTeach;
   // A turn whose pronoun was bound to a vocabulary antecedent is PROVABLY a
   // fact question ("can it bark" → "can dog bark") — never conversational,
   // however short. Without this, the substituted 3-worder still trips
@@ -12594,7 +12754,7 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
   // (4) #2 TEACH lane — a teach-shaped would-miss nothing above answered: route to
   // memory, or say what CAN be remembered (LOUD), never the wall / a silent drop.
   if (miss && recordMiss && via === "composed") {
-    const taught = await teachLane(query, { memoryDir, sessionId, lexicon, cache, planHolder, graph });
+    const taught = await teachLane(query, { memoryDir, sessionId, lexicon, cache, planHolder, graph, gameConfig });
     if (taught) {
       answer = taught.text; via = taught.via; recordMiss = taught.miss;
       if (!taught.miss) dialogueLaneOverride = "teach";
@@ -14437,7 +14597,7 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
   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 });
+    const step = await executePlanStep(planHolder, { memoryDir, sessionId, gameConfig: resolvedGameConfig });
     note(trace, `goal: ${step.deduced}`);
     note(trace, "lane: PLAN NEXT — executed the active plan's next move as an @stepK snapshot write");
     const stepTurn = plainTurn(workingLine, step.text, { via: "plan", focus });

package/src/services/extensions.mjs

@@ -256,9 +256,14 @@ export async function resolveExtensions(repoRoot, { configFile } = {}) {
  *
  *  FAILURE-TOLERANT per bundle: one bad third-party pack's seedMemory throw is caught and
  *  recorded as `perBundle[name].error` while every other bundle still seeds normally.
- *  Returns `{ appended, skipped, total, perBundle: { name: {appended,skipped,total,error?} } }`. */
-export async function seedActiveCorpusEntries(repo, entries) {
+ *  Returns `{ appended, skipped, total, perBundle: { name: {appended,skipped,total,error?} } }`.
+ *
+ *  `opts.captureUnknownContext`/`opts.unknownContextLimit` (both optional) forward to
+ *  every seedMemory call unchanged — the tmct.toml `[seed]` knob (toml-config.mjs)
+ *  applies uniformly across whichever bundles are active, not per-bundle. */
+export async function seedActiveCorpusEntries(repo, entries, opts = {}) {
   const { seedMemory } = await import("../adapters/corpus/conceptnet.mjs");
+  const { captureUnknownContext, unknownContextLimit } = opts;
   const perBundle = {};
   let appended = 0;
   let skipped = 0;
@@ -274,6 +279,8 @@ export async function seedActiveCorpusEntries(repo, entries) {
         provenancePrefix: entry.provenancePrefix,
         limit: entry.limit,
         prefer: entry.prefer,
+        captureUnknownContext,
+        unknownContextLimit,
       });
       perBundle[name] = { appended: res.appended, skipped: res.skipped, total: res.total };
       appended += res.appended;

package/src/services/extract-facts.mjs

@@ -106,6 +106,18 @@ const OPTIMISTIC_SKIP = new Set([
   "our", "my", "your", "some", "any", "one", "kind", "sort", "type", "of",
 ]);
 const OPTIMISTIC_ENTITY_HOPS = 4;
+// Crossing any of these while scanning for a copula's entities voids the isa
+// read — the noun on the far side belongs to a different clause or to a
+// prepositional complement, not to "X is a Y".
+const COPULA_FRAME_BLOCKERS = new Set(["VERB", "AUX", "ADP", "SCONJ", "CCONJ"]);
+// Of-chain handling on a copula object: classifier heads read through to the
+// real class; partitive containers state composition and yield no isa.
+const COPULA_OF_READ_THROUGH = new Set(["type", "kind", "sort", "form", "class", "variety", "species", "breed", "genus"]);
+// Naming periphrases stay copular: "can be termed as a name", "is known as",
+// "is defined as" — the participle + "as" carries the same class claim the
+// bare copula does, unlike any other verb after "is".
+const COPULA_NAMING_PARTICIPLES = new Set(["termed", "known", "defined", "described", "referred", "called", "classified"]);
+const COPULA_PARTITIVE_HEADS = new Set(["body", "mass", "group", "collection", "set", "series", "number", "amount", "piece", "part", "lot", "pair", "bunch", "pile"]);
 
 /** Fold an entity surface to its stored key: a lexicon noun's lemma, else the
  *  word's own normFactTerm (the optimistic tier mints unlisted content nouns
@@ -128,22 +140,77 @@ function optimisticTriplesPos(sentence, lexicon, nlp) {
     values = doc.tokens().out(nlp.its.value);
     pos = doc.tokens().out(nlp.its.pos);
   } catch { return []; }
-  const nearestEntity = (idx, step) => {
+  // A found noun is read as its whole contiguous NOUN/PROPN run, head-lemma
+  // folded — "a string instrument" is the class "string instrument", never
+  // its modifier "string"; a single-word run keeps the plain lemma fold.
+  const isNounish = (i) => pos[i] === "NOUN" || pos[i] === "PROPN";
+  const entityRunAt = (i) => {
+    let lo = i;
+    let hi = i;
+    while (lo - 1 >= 0 && isNounish(lo - 1)) lo -= 1;
+    while (hi + 1 < values.length && isNounish(hi + 1)) hi += 1;
+    if (lo === hi) return foldEntity(values[i], lexicon);
+    const head = lookupNoun(lexicon, String(values[hi]).toLowerCase());
+    return normFactTerm([...values.slice(lo, hi), head ? head.lemma : values[hi]].join(" "));
+  };
+  const nearestEntity = (idx, step, blocked = null) => {
     for (let i = idx + step; i >= 0 && i < values.length; i += step) {
       if (pos[i] === "PUNCT") break;
-      if (pos[i] === "NOUN" || pos[i] === "PROPN") return foldEntity(values[i], lexicon);
+      if (blocked && blocked.has(pos[i])) break;
+      if (isNounish(i)) return entityRunAt(i);
     }
     return null;
   };
-  const tripleAt = (i, predicate) => {
-    const subject = nearestEntity(i, -1);
-    const object = nearestEntity(i, +1);
+  const tripleAt = (i, predicate, blocked = null) => {
+    const subject = nearestEntity(i, -1, blocked);
+    const object = nearestEntity(i, +1, blocked);
     return subject && object && subject !== object ? { subject, predicate, object } : null;
   };
+  // An isa needs a CLEAN copula frame: only determiners/adjectives/adverbs/
+  // numerals may sit between each entity and the copula. Crossing a verb or
+  // auxiliary means the noun belongs to another clause ("one reason life can
+  // exist here IS that earth …" is not "life is-a earth"); crossing a
+  // preposition or subordinator means locative/complement predication ("water
+  // is IN the oceans", "land is grouped INTO continents") — none of them
+  // class membership.
+  // An of-chain on the object reads through a classifier head to the real
+  // class ("a type of mammal" → mammal); a partitive container head states
+  // composition, never a class ("a large body of ice" — no isa at all).
+  const copulaObjectAt = (i) => {
+    for (let j = i + 1; j < values.length; j += 1) {
+      // A naming periphrasis ("… termed as …", "… known as …") keeps the
+      // frame copular: skip the participle and its "as" and read on.
+      if ((pos[j] === "VERB" || pos[j] === "AUX") && COPULA_NAMING_PARTICIPLES.has(values[j]?.toLowerCase())
+        && values[j + 1]?.toLowerCase() === "as") { j += 1; continue; }
+      if (pos[j] === "PUNCT" || COPULA_FRAME_BLOCKERS.has(pos[j])) {
+        if (values[j]?.toLowerCase() !== "of") return null;
+        return null;
+      }
+      if (!isNounish(j)) continue;
+      let hi = j;
+      while (hi + 1 < values.length && isNounish(hi + 1)) hi += 1;
+      const headWord = String(values[hi]).toLowerCase();
+      const nextIsOf = values[hi + 1]?.toLowerCase() === "of";
+      if (!nextIsOf) return entityRunAt(j);
+      if (COPULA_OF_READ_THROUGH.has(headWord)) { i = hi + 1; j = hi + 1; continue; }
+      if (COPULA_PARTITIVE_HEADS.has(headWord)) return null;
+      return entityRunAt(j);
+    }
+    return null;
+  };
+  // The copula's own modal chain ("can be", "may be") is part of one verb
+  // complex — the subject scan starts left of it, while a free-standing VERB
+  // on the way still voids the frame.
+  const copulaSubjectAt = (i) => {
+    let k = i - 1;
+    while (k >= 0 && pos[k] === "AUX") k -= 1;
+    return nearestEntity(k + 1, -1, COPULA_FRAME_BLOCKERS);
+  };
   for (let i = 1; i < values.length - 1; i += 1) {
     if (pos[i] === "AUX" && OPTIMISTIC_COPULAS.has(values[i].toLowerCase())) {
-      const t = tripleAt(i, "rdfs:subClassOf");
-      if (t) return [t];
+      const subject = copulaSubjectAt(i);
+      const object = copulaObjectAt(i);
+      if (subject && object && subject !== object) return [{ subject, predicate: "rdfs:subClassOf", object }];
     }
   }
   for (let i = 1; i < values.length - 1; i += 1) {

package/src/services/init.mjs

@@ -40,7 +40,13 @@ export function defaultConfig() {
   return {
     graphFile: join(".tmct", "graph.json"),
     corpus: { tier: "tier1" },
-    seed: { enabled: true },
+    // captureUnknownContext defaults ON: every shipped tier-1/tier-2 curated
+    // bundle maps cleanly (no ace="none" relation appears in any of them), so
+    // this is a no-op against the default persona — it only starts capturing
+    // once an operator also activates a raw bundle like conceptnet/seon that
+    // has genuinely dropped rows, and there the capture is bounded by
+    // unknownContextLimit.
+    seed: { enabled: true, captureUnknownContext: true },
   };
 }
 
@@ -114,6 +120,14 @@ enabled = ${seed.enabled ? "true" : "false"}
 # By default the WHOLE committed slice seeds (no cap — the operator's "seed all").
 # To cap it, uncomment and set a number (definitional band first):
 ${seed.limit != null ? `limit = ${Number(seed.limit)}` : "# limit = 500"}
+# Also capture a term that only ever appears in a relation the axiom graph
+# drops (e.g. DerivedFrom/HasContext) — tagged with the passage it was found
+# in, instead of vanishing. A no-op against every shipped bundle (none of
+# them carry a dropped relation); it starts capturing once a bundle that does
+# (conceptnet, seon, or a host-supplied one) is also active.
+capture_unknown_context = ${seed.captureUnknownContext ? "true" : "false"}
+# How many distinct terms one capture_unknown_context pass captures, at most:
+${seed.unknownContextLimit != null ? `unknown_context_limit = ${Number(seed.unknownContextLimit)}` : "# unknown_context_limit = 500"}
 `;
   // [memory] backend — only emitted when a caller actually supplies it.
   let out = base;
@@ -292,7 +306,10 @@ export async function initRepo(dir, { force = false, seed, env = process.env, pe
         if (config.seed?.limit != null && entries.has("conceptnet")) {
           entries.set("conceptnet", { ...entries.get("conceptnet"), limit: Number(config.seed.limit) });
         }
-        const { appended, skipped, total, perBundle } = await seedActiveCorpusEntries(memoryDir, entries);
+        const { appended, skipped, total, perBundle } = await seedActiveCorpusEntries(memoryDir, entries, {
+          captureUnknownContext: config.seed?.captureUnknownContext,
+          unknownContextLimit: config.seed?.unknownContextLimit,
+        });
         // If every active bundle failed, re-throw the first error so the outer catch
         // reports it, rather than claiming success with zero facts written.
         const bundleNames = Object.keys(perBundle);
@@ -363,6 +380,8 @@ async function readWrittenConfig(tomlPath, base) {
       cfg.seed = { ...cfg.seed };
       if (raw.seed.enabled !== undefined) cfg.seed.enabled = Boolean(raw.seed.enabled);
       if (raw.seed.limit !== undefined) cfg.seed.limit = Number(raw.seed.limit);
+      if (raw.seed.capture_unknown_context !== undefined) cfg.seed.captureUnknownContext = Boolean(raw.seed.capture_unknown_context);
+      if (raw.seed.unknown_context_limit !== undefined) cfg.seed.unknownContextLimit = Number(raw.seed.unknown_context_limit);
     }
     // Sparse pass-through — src/services/extensions.mjs validates; this layer just carries the
     // raw tables through unmodified.

package/src/services/ledger-viz.mjs

@@ -588,8 +588,7 @@ ${THEME_TOKENS_CSS}
   body { margin: 0; background: var(--bg); color: var(--ink); font-family: ${SERIF_STACK}; font-size: 16px; line-height: 1.5; }
   .mono { font-family: ${MONO_STACK}; }
   main { max-width: 1080px; margin: 0 auto; padding: 1.4rem 1.2rem 3rem; }
-  .eyebrow { font-family: ${MONO_STACK}; font-size: .7rem; letter-spacing: .08em; text-transform: uppercase; color: var(--muted); display: flex; flex-wrap: wrap; gap: .4em 1.2em; }
-  h1 { font-size: 1.4rem; margin: .3rem 0 .9rem; text-wrap: balance; }
+  .eyebrow { font-family: ${MONO_STACK}; font-size: .7rem; letter-spacing: .08em; text-transform: uppercase; color: var(--muted); display: flex; flex-wrap: wrap; gap: .4em 1.2em; margin-bottom: .9rem; }
   button { font: inherit; color: inherit; background: none; border: none; padding: 0; cursor: pointer; }
   button:focus-visible, input:focus-visible { outline: 2px solid var(--ink); outline-offset: 2px; border-radius: 4px; }
   .topbar { display: flex; flex-wrap: wrap; align-items: center; gap: .8rem; border-top: 1px solid var(--line); border-bottom: 1px solid var(--line); padding: .5rem 0; margin-bottom: 1.1rem; }
@@ -715,7 +714,6 @@ ${THEME_TOKENS_CSS}
 <body>
 <main>
   <div class="eyebrow"><span>tmct &middot; memory ledger</span><span id="counts"></span></div>
-  <h1>A graph you can read</h1>
   ${dashboardHtml(stats)}
   <div class="topbar">
     <nav class="crumbs" id="crumbs" aria-label="Focus trail"></nav>