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

package/src/services/chat-page-viz.mjs

@@ -117,6 +117,26 @@ export function loadProgressLine(parts) {
     : "loading the engine… " + mb(loaded) + " MB";
 }
 
+/**
+ * The "researched this session" panel's own reading of a settled research
+ * turn's answer — the passage it read and where it read it, straight off
+ * research.mjs's own `renderResearchAnswer` shape (`term — summary (source:
+ * research article "title", Simple English Wikipedia, CC BY-SA 4.0 — url)`),
+ * never a second fetch: the citation text is already the retrieved passage,
+ * this just pulls its pieces apart for display. Returns null on anything
+ * else (a miss, a status/stop reply, or text that doesn't open this way) —
+ * an honest "nothing to show" rather than a guessed passage.
+ *
+ * Self-contained, `.toString()`-splice safe — the same discipline every
+ * other pure export in this module holds.
+ */
+export function parseResearchAnswer(answer) {
+  const text = String(answer || "");
+  const m = /^(.*?) — ([\s\S]*?) \(source: research article "([^"]+)", Simple English Wikipedia, CC BY-SA 4\.0 — (\S+)\)/.exec(text);
+  if (!m) return null;
+  return { term: m[1], passage: m[2], title: m[3], url: m[4] };
+}
+
 /**
  * The exported transcript as ONE Markdown document, in the SAME shape the
  * Node CLI/TUI's own .tmct/session-<id>.md writes (session-log-format.mjs,
@@ -286,6 +306,24 @@ ${THEME_TOKENS_CSS}
   .statsPanel .forget-btn:hover { color: var(--ink); }
   .statsPanel .persist-note { color: var(--muted); font-size: .64rem; margin: .4rem 0 0; }
 
+  /* the "researched this session" panel: its own section under the memory
+     stats, filled from window.tmctChat.researchedFactRows() plus each
+     settled research turn's own answer text — the passage tmct actually
+     read, the article it read it from, and the facts that passage grounded.
+     A sibling section, not folded into #statsPanelStats — that div's own
+     re-render (renderStatsPanelInto) clears and rebuilds its children on
+     every turn, which would wipe this section's own history too if it lived
+     inside it. */
+  #researchedPanel:not(:empty) { margin-top: 1rem; padding-top: 1rem; border-top: 1px solid var(--line); }
+  .statsPanel .researched-item { margin: 0 0 .9rem; padding-bottom: .8rem; border-bottom: 1px dashed var(--line); }
+  .statsPanel .researched-item:last-child { border-bottom: none; padding-bottom: 0; margin-bottom: 0; }
+  .statsPanel .researched-title { display: block; color: var(--ink); font-weight: 600; }
+  .statsPanel .researched-passage { display: block; color: var(--muted); margin: .3rem 0; }
+  .statsPanel .researched-link { display: inline-block; margin: 0 0 .3rem; }
+  .statsPanel .researched-facts { margin: .3rem 0 0; padding-left: 1.1rem; }
+  .statsPanel .researched-facts li { margin: .12rem 0; }
+  .statsPanel .researched-none { color: var(--muted); font-style: italic; margin: .3rem 0 0; }
+
   @media (max-width: 860px) {
     .statsPanel { display: none; }
   }
@@ -361,8 +399,9 @@ ${THEME_TOKENS_CSS}
     </form>
     <div class="statusline" id="status">loading the engine&hellip;</div>
   </div>
-  <aside class="statsPanel" id="statsPanel" aria-label="This session's memory">
-    <p class="empty">loading memory stats&hellip;</p>
+  <aside class="statsPanel" id="statsPanel" aria-label="This session's memory and research">
+    <div id="statsPanelStats"><p class="empty">loading memory stats&hellip;</p></div>
+    <div id="researchedPanel"></div>
   </aside>
 <script src="./chat-browser.bundle.js"></script>
 <script>
@@ -371,6 +410,7 @@ ${THEME_TOKENS_CSS}
   const provBucketFor = ${provBucketFor.toString()};
   const provenanceChipFor = ${provenanceChipFor.toString()};
   const loadProgressLine = ${loadProgressLine.toString()};
+  const parseResearchAnswer = ${parseResearchAnswer.toString()};
   const sessionLogTimeOfDay = ${sessionLogTimeOfDay.toString()};
   const sessionLogHeaderMarkdown = ${sessionLogHeaderMarkdown.toString()};
   const sessionLogTurnMarkdown = ${sessionLogTurnMarkdown.toString()};
@@ -390,7 +430,8 @@ ${THEME_TOKENS_CSS}
   const inputEl = el("composerInput");
   const sendBtn = el("composerSend");
   const statusEl = el("status");
-  const statsPanelEl = el("statsPanel");
+  const statsPanelEl = el("statsPanelStats");
+  const researchedPanelEl = el("researchedPanel");
   const wikiModeFieldset = el("wikiMode");
   const wikiModeRadios = Array.prototype.slice.call(wikiModeFieldset.querySelectorAll('input[type="radio"]'));
   const synthSliderEl = el("synthSlider");
@@ -708,6 +749,98 @@ ${THEME_TOKENS_CSS}
     });
   }
 
+  // ---- researched this session: what "research <topic>" has actually read
+  // and grounded so far — each entry pairs the passage a settled research
+  // turn's own answer cites (parseResearchAnswer, off the SAME "(source:
+  // research article ...)" text the chat bubble already shows) with the real
+  // facts that turn stored, read back through window.tmctChat.
+  // researchedFactRows(memoryDir) rather than re-deriving them from the
+  // answer text — the citation names WHERE tmct read, the fact rows name
+  // WHAT it kept, and this panel never invents either from the other.
+  const researchedEntries = [];
+  const researchedFactKeysSeen = new Set();
+
+  function renderResearchedPanel() {
+    researchedPanelEl.textContent = "";
+    researchedPanelEl.appendChild(Object.assign(document.createElement("h2"), { textContent: "researched this session" }));
+    if (!researchedEntries.length) {
+      const empty = document.createElement("p");
+      empty.className = "empty";
+      empty.textContent = 'nothing yet — ask it to "research <a topic>" and what it reads, with the passage and the facts it grounded, lands here.';
+      researchedPanelEl.appendChild(empty);
+      return;
+    }
+    for (const entry of researchedEntries.slice(-8).reverse()) {
+      const item = document.createElement("div");
+      item.className = "researched-item";
+      const title = document.createElement("span");
+      title.className = "researched-title";
+      title.textContent = entry.title || "(untitled)";
+      item.appendChild(title);
+      if (entry.passage) {
+        const passage = document.createElement("span");
+        passage.className = "researched-passage";
+        passage.textContent = entry.passage;
+        item.appendChild(passage);
+      }
+      if (entry.url) {
+        const link = document.createElement("a");
+        link.className = "researched-link";
+        link.href = entry.url;
+        link.target = "_blank";
+        link.rel = "noopener noreferrer";
+        link.textContent = "source \\u2197";
+        item.appendChild(link);
+      }
+      if (entry.facts.length) {
+        const list = document.createElement("ul");
+        list.className = "researched-facts";
+        for (const fact of entry.facts) {
+          const li = document.createElement("li");
+          li.textContent = fact.subject + " " + fact.predicate + " " + fact.object;
+          list.appendChild(li);
+        }
+        item.appendChild(list);
+      } else {
+        const none = document.createElement("p");
+        none.className = "researched-none";
+        none.textContent = "no new fact grounded from this passage.";
+        item.appendChild(none);
+      }
+      researchedPanelEl.appendChild(item);
+    }
+  }
+
+  /** After a settled, non-miss research turn: read back the facts that turn
+   *  actually stored (a set-diff against every research fact seen so far, so
+   *  a later step never re-lists an earlier one's facts) and pair them with
+   *  this turn's own cited passage. A turn that grounded nothing new (an
+   *  empty article, or a re-fetch of an already-known one) still gets its
+   *  own entry — the passage was still read, even where nothing new stuck. */
+  async function noteResearchLearned(result) {
+    if (result.research === undefined || !result.record || result.record.miss) return;
+    if (!window.tmctChat.researchedFactRows || !window.tmctChatSession) return;
+    let rows;
+    try { rows = await window.tmctChat.researchedFactRows(window.tmctChatSession.memoryDir); }
+    catch { return; }
+    const newFacts = [];
+    for (const row of rows) {
+      const key = row.subject + "|" + row.predicate + "|" + row.object;
+      if (researchedFactKeysSeen.has(key)) continue;
+      researchedFactKeysSeen.add(key);
+      newFacts.push(row);
+    }
+    const parsed = parseResearchAnswer(result.answer);
+    if (!parsed && !newFacts.length) return;
+    researchedEntries.push({
+      title: parsed ? parsed.title : "",
+      passage: parsed ? parsed.passage : "",
+      url: parsed ? parsed.url : "",
+      facts: newFacts,
+    });
+    renderResearchedPanel();
+  }
+
   // "supplement" (typed /wiki supplement only) has no radio; the statusline
   // still names it, read straight off the session's own liveReference getter
   // rather than the last radio the page itself set.
@@ -791,6 +924,7 @@ ${THEME_TOKENS_CSS}
       // that changed nothing costs at most one coalesced write.
       if (result.record && result.record.via !== "command") scheduleSave();
       await renderStatsPanel(); // a teach or learned-load turn grew this session's memory; a plain ask leaves it unchanged either way
+      await noteResearchLearned(result);
     } catch (err) {
       settleAssistantBubble(pendingRow,
         "something went wrong answering that (" + (err && err.message ? err.message : err) + ") \\u2014 try rephrasing",
@@ -1018,6 +1152,18 @@ ${THEME_TOKENS_CSS}
     addSystemLine("tmct \\u2014 the real engine, running in this page \\u2014 " + statsSummaryLine(stats, bandLabelFor)
       + "." + restoredNote + " Ask it something, or teach it a fact of your own.");
     await renderStatsPanel(stats);
+    // A restored session may already carry earlier research facts (they
+    // persist with everything else this session taught) — seed the
+    // seen-set from them so a later research turn only reports what's
+    // actually new, without fabricating passages for a visit this page
+    // was never open to read.
+    if (window.tmctChat.researchedFactRows) {
+      try {
+        const existingResearch = await window.tmctChat.researchedFactRows(window.tmctChatSession.memoryDir);
+        for (const row of existingResearch) researchedFactKeysSeen.add(row.subject + "|" + row.predicate + "|" + row.object);
+      } catch { /* best-effort seeding only — a fresh session has none to seed */ }
+    }
+    renderResearchedPanel();
     inputEl.placeholder = seedPayload ? 'try "what is a dog" or "list facts"' : window.tmctChat.vocabExampleHint(false);
     renderStatus();
     setBusy(false);

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;