@polycode-projects/the-mechanical-code-talker 5.0.2 → 5.0.4

package/src/domain/syllogise.mjs

@@ -1527,14 +1527,35 @@ function bestEnvironmentTrustOpts(provenance, environments, trustOfId) {
  * without it removal is still correct, the survivor's environments just stay
  * stale until the next syllogise pass.
  *
+ * `sourceTags` narrows the target removal to the INVOKING PARTY's own
+ * record(s) — a chat `/retract` names every provenance tag its own session
+ * could have asserted the triple under here (the free-form teach lane and
+ * the ACE-parsed assert lane both belong to one session, under two
+ * different tags), so two sources who independently asserted the same
+ * triple never let one's retraction erase the other's. Omitted (or empty),
+ * retraction stays group-wide (every source's record for the triple), which
+ * is what mud EDIT mode wants and what every pre-existing caller of this
+ * function already gets.
+ *
  * Returns { retracted, count, budget, depth, truncated, found } — `found` is
- * false when `subject ⊑ object` was never a stored fact.
+ * false when `subject ⊑ object` was never a stored fact. With `sourceTags`
+ * set, two more fields describe what the SCOPED removal actually did:
+ * `ownRecord` (false when the invoking party never asserted the triple
+ * itself, so nothing of theirs existed to retract) and `stillStands` (true
+ * when another source's record keeps the triple asserted after this one's
+ * record is gone — in which case nothing entailed from it is cascaded,
+ * because its premise never actually stopped holding).
  */
 export async function retractSubClassOf(repoDir, subject, object, {
-  budget = 50, depth = 32, maxEnvironments = DEFAULT_MAX_ENVIRONMENTS, store,
+  budget = 50, depth = 32, maxEnvironments = DEFAULT_MAX_ENVIRONMENTS, store, sourceTags = [],
 } = {}) {
   const { loadMemory, readFactRows, removeFacts } = requireStore(store, ["loadMemory", "readFactRows", "removeFacts"], "retractSubClassOf");
   const appendFactsFn = typeof store?.appendFacts === "function" ? store.appendFacts : null;
+  const factRecordIdForTag = typeof store?.factRecordIdForTag === "function" ? store.factRecordIdForTag : null;
+  const scoped = (sourceTags || []).filter(Boolean);
+  if (scoped.length && !factRecordIdForTag) {
+    throw new TypeError("retractSubClassOf needs a store option carrying factRecordIdForTag (memory/core.mjs's) to scope a retraction to sourceTags");
+  }
   const s = normFactTerm(subject);
   const o = normFactTerm(object);
   const targetId = factIdForTriple(s, SUBCLASS_PREDICATE, o);
@@ -1543,92 +1564,121 @@ export async function retractSubClassOf(repoDir, subject, object, {
   const byId = new Map(rows.map((r) => [r.id, r]));
   if (!byId.has(targetId)) return { retracted: [], count: 0, budget, depth, truncated: false, found: false };
 
-  // Only a purely-entailed fact ever carries a walkable justification —
-  // a fact later independently taught is never a cascade candidate at all.
-  const entailedRows = rows.filter((r) => environmentsOf(r).length && isPurelyEntailed(r.provenance));
-  // premise id -> the entailed fact ids whose environments cite it. Built
-  // ONCE; each round's candidate set reads it for the facts the newest
-  // removals could actually touch — backward relevance from the same
-  // structure a forward pass reads forward.
-  const citedBy = new Map();
-  for (const r of entailedRows) {
-    for (const env of environmentsOf(r)) {
-      for (const premiseId of env) {
-        if (!citedBy.has(premiseId)) citedBy.set(premiseId, new Set());
-        citedBy.get(premiseId).add(r.id);
-      }
-    }
+  // The invoking party's own record(s) for the target — one candidate source
+  // id per tag it could have asserted under — filtered down to whichever
+  // ones the triple is ACTUALLY recorded under. Zero of them means it was
+  // never this party's own assertion, whatever else stored it.
+  const targetSourceIds = byId.get(targetId).sourceIds || [];
+  const candidateSourceIds = scoped.map((tag) => factRecordIdForTag(targetId, tag).slice(targetId.length + 1));
+  const ownSourceIds = scoped.length ? targetSourceIds.filter((sid) => candidateSourceIds.includes(sid)) : [];
+  const ownsTarget = !scoped.length || ownSourceIds.length > 0;
+  if (scoped.length && !ownsTarget) {
+    return { retracted: [], count: 0, budget, depth, truncated: false, found: true, ownRecord: false, stillStands: true };
   }
+  // Another source's record keeps the triple standing even after this
+  // party's own record(s) go — the premise never actually broke, so no
+  // cascade runs.
+  const stillStands = scoped.length > 0 && ownSourceIds.length < targetSourceIds.length;
 
   const removed = new Set([targetId]);
   const order = [targetId]; // deterministic report order: target first, then removal order
   const reground = new Map(); // survivor fact id -> the environments to persist for it
   let truncated = false;
-  let round = 0;
-  let newlyRemoved = [targetId];
-  for (; round < depth; round += 1) {
-    const candidateIds = new Set();
-    for (const id of newlyRemoved) {
-      for (const cited of citedBy.get(id) || []) {
-        if (!removed.has(cited)) candidateIds.add(cited);
+
+  // A scoped retraction whose triple STILL STANDS through another source's
+  // record never runs the cascade at all — its premise never actually broke,
+  // so nothing entailed from it loses support.
+  if (!stillStands) {
+    // Only a purely-entailed fact ever carries a walkable justification —
+    // a fact later independently taught is never a cascade candidate at all.
+    const entailedRows = rows.filter((r) => environmentsOf(r).length && isPurelyEntailed(r.provenance));
+    // premise id -> the entailed fact ids whose environments cite it. Built
+    // ONCE; each round's candidate set reads it for the facts the newest
+    // removals could actually touch — backward relevance from the same
+    // structure a forward pass reads forward.
+    const citedBy = new Map();
+    for (const r of entailedRows) {
+      for (const env of environmentsOf(r)) {
+        for (const premiseId of env) {
+          if (!citedBy.has(premiseId)) citedBy.set(premiseId, new Set());
+          citedBy.get(premiseId).add(r.id);
+        }
       }
     }
-    const candidates = [...candidateIds].map((id) => byId.get(id))
-      .sort((a, b) => a.subject.localeCompare(b.subject) || a.predicate.localeCompare(b.predicate) || a.object.localeCompare(b.object));
-    if (!candidates.length) break; // fixpoint — nothing cites what just fell
-
-    // The surviving fact set for THIS round excludes every candidate's own
-    // row too, not just `removed` — otherwise a candidate could trivially
-    // "reach itself" through its own not-yet-deleted edge, or lean on a
-    // sibling candidate standing on the same broken premise.
-    const survivors = rows.filter((r) => !removed.has(r.id) && !candidateIds.has(r.id));
-    const survivorIds = new Set(survivors.map((r) => r.id));
-    const enumerateSupport = buildSupportEnumerator(survivors);
-    const stillDerivable = buildSurvivorDerivabilityCheck(survivors);
 
-    let progressed = false;
-    let hitBudget = false;
-    newlyRemoved = [];
-    for (const c of candidates) {
-      if (removed.size >= budget) { hitBudget = true; break; }
-      // FAST PATH: an environment whose every premise still stands keeps the
-      // fact — pure set membership, no re-derivation. When some environments
-      // broke, queue the pruned set so the next retraction still sees the
-      // survivor (the stale-justification fix).
-      const environments = environmentsOf(c);
-      const intact = environments.filter((env) => env.every((id) => survivorIds.has(id)));
-      if (intact.length) {
-        if (intact.length !== environments.length) reground.set(c.id, intact);
-        continue;
+    let round = 0;
+    let newlyRemoved = [targetId];
+    for (; round < depth; round += 1) {
+      const candidateIds = new Set();
+      for (const id of newlyRemoved) {
+        for (const cited of citedBy.get(id) || []) {
+          if (!removed.has(cited)) candidateIds.add(cited);
+        }
       }
-      // ENUMERATE: a fresh premise environment among the survivors re-grounds
-      // the fact under new citations.
-      const fresh = enumerateSupport(c, { maxEnvironments });
-      if (fresh.length) {
-        reground.set(c.id, fresh);
-        continue;
+      const candidates = [...candidateIds].map((id) => byId.get(id))
+        .sort((a, b) => a.subject.localeCompare(b.subject) || a.predicate.localeCompare(b.predicate) || a.object.localeCompare(b.object));
+      if (!candidates.length) break; // fixpoint — nothing cites what just fell
+
+      // The surviving fact set for THIS round excludes every candidate's own
+      // row too, not just `removed` — otherwise a candidate could trivially
+      // "reach itself" through its own not-yet-deleted edge, or lean on a
+      // sibling candidate standing on the same broken premise.
+      const survivors = rows.filter((r) => !removed.has(r.id) && !candidateIds.has(r.id));
+      const survivorIds = new Set(survivors.map((r) => r.id));
+      const enumerateSupport = buildSupportEnumerator(survivors);
+      const stillDerivable = buildSurvivorDerivabilityCheck(survivors);
+
+      let progressed = false;
+      let hitBudget = false;
+      newlyRemoved = [];
+      for (const c of candidates) {
+        if (removed.size >= budget) { hitBudget = true; break; }
+        // FAST PATH: an environment whose every premise still stands keeps the
+        // fact — pure set membership, no re-derivation. When some environments
+        // broke, queue the pruned set so the next retraction still sees the
+        // survivor (the stale-justification fix).
+        const environments = environmentsOf(c);
+        const intact = environments.filter((env) => env.every((id) => survivorIds.has(id)));
+        if (intact.length) {
+          if (intact.length !== environments.length) reground.set(c.id, intact);
+          continue;
+        }
+        // ENUMERATE: a fresh premise environment among the survivors re-grounds
+        // the fact under new citations.
+        const fresh = enumerateSupport(c, { maxEnvironments });
+        if (fresh.length) {
+          reground.set(c.id, fresh);
+          continue;
+        }
+        // BOOLEAN BACKSTOP: the closure walk is the final authority — it sees
+        // multi-hop support with no materialised direct edge to cite, so a
+        // still-derivable fact is never removed on a stale citation alone (its
+        // environments stay as they were).
+        if (stillDerivable(c)) continue;
+        removed.add(c.id);
+        order.push(c.id);
+        newlyRemoved.push(c.id);
+        progressed = true;
       }
-      // BOOLEAN BACKSTOP: the closure walk is the final authority — it sees
-      // multi-hop support with no materialised direct edge to cite, so a
-      // still-derivable fact is never removed on a stale citation alone (its
-      // environments stay as they were).
-      if (stillDerivable(c)) continue;
-      removed.add(c.id);
-      order.push(c.id);
-      newlyRemoved.push(c.id);
-      progressed = true;
+      if (hitBudget) { truncated = true; break; }
+      if (!progressed) break; // every candidate this round survived — fixpoint
+    }
+    if (!truncated && round >= depth) {
+      // depth exhausted, not a natural fixpoint — honestly flag it if a pending
+      // candidate (any surviving fact whose environment union still cites a
+      // removed id) would have been checked next round.
+      truncated = entailedRows.some((r) => !removed.has(r.id) && r.justification.some((j) => removed.has(j)));
     }
-    if (hitBudget) { truncated = true; break; }
-    if (!progressed) break; // every candidate this round survived — fixpoint
-  }
-  if (!truncated && round >= depth) {
-    // depth exhausted, not a natural fixpoint — honestly flag it if a pending
-    // candidate (any surviving fact whose environment union still cites a
-    // removed id) would have been checked next round.
-    truncated = entailedRows.some((r) => !removed.has(r.id) && r.justification.some((j) => removed.has(j)));
   }
 
-  const { removed: actuallyRemoved } = await removeFacts(repoDir, order);
+  // The target's own position in `order` narrows to the invoking party's
+  // record(s) when scoped; every cascade id stays group-wide — an entailed
+  // fact is never itself "the invoking party's own", so there is no
+  // per-source record to narrow it to.
+  const removalIds = scoped.length
+    ? [...ownSourceIds.map((sid) => `${targetId}@${sid}`), ...order.slice(1)]
+    : order;
+  const { removed: actuallyRemoved } = await removeFacts(repoDir, removalIds);
   if (appendFactsFn) {
     const regroundWrites = [...reground.entries()]
       .filter(([id]) => !removed.has(id))
@@ -1644,7 +1694,10 @@ export async function retractSubClassOf(repoDir, subject, object, {
       });
     if (regroundWrites.length) await appendFactsFn(repoDir, regroundWrites);
   }
-  return { retracted: actuallyRemoved, count: actuallyRemoved.length, budget, depth, truncated, found: true };
+  return {
+    retracted: actuallyRemoved, count: actuallyRemoved.length, budget, depth, truncated, found: true,
+    ...(scoped.length ? { ownRecord: true, stillStands } : {}),
+  };
 }
 
 /**

package/src/services/adventure-autoplay.mjs

@@ -11,7 +11,7 @@
 // actually seen. `exposedRoomIds` is the set of rooms this auto-play run has
 // itself moved into (the opening room included from turn 0) — it is the sole
 // caller making every move, so it always knows this, and threads the set
-// forward turn to turn exactly like spider-fly.mjs threads its own agents
+// forward turn to turn exactly like predator-prey.mjs threads its own agents
 // shape. `exposedFacts` turns that set into the actual filtered view: a fact
 // is exposed when its subject's CURRENT placement resolves into an exposed
 // room, when the subject is the player, or when the fact IS the world's
@@ -130,7 +130,7 @@ async function stepTowardThenAct({
  * and execute exactly the one move that goal implies through `adventureTurn`
  * — the same public entry point a real chat turn calls. Returns
  * `{ turn, goal, plan, done, stalled, exposedRoomIds }`, mirroring
- * spider-fly.mjs's own tick shape: `plan` is the remaining multi-step route a
+ * predator-prey.mjs's own tick shape: `plan` is the remaining multi-step route a
  * `findActionPath` search found this tick (or null when the move was a
  * single, immediate step — an adjacent unexposed exit, or a take), `goal` is
  * a short line describing what this tick did, `done` means the objective is

package/src/services/adventure-viz.mjs

@@ -944,6 +944,8 @@ ${THEME_TOKENS_CSS}
      onto further lines, staying right-anchored rather than dropping the
      whole pill row under the heading. */
   .command-head .pills { flex: 1 1 auto; min-width: 0; justify-content: flex-end; margin-bottom: 0; }
+  .teach-toggle { display: flex; align-items: center; gap: .35rem; font-family: ${MONO_STACK}; font-size: .72rem; color: var(--muted); margin: 0 0 .4rem; cursor: pointer; }
+  .teach-toggle input { accent-color: var(--gilt); }
   .chatask { display: flex; align-items: center; gap: .5rem; border-top: 1px solid var(--line); padding-top: .5rem; }
   .chatask .prompt { color: var(--taught); font-size: .78rem; font-family: ${MONO_STACK}; }
   .chatask input { flex: 1; font-family: ${MONO_STACK}; font-size: .78rem; background: var(--bg); color: var(--ink); border: 1px solid var(--line); padding: .32rem .55rem; min-width: 0; }
@@ -1042,6 +1044,10 @@ ${scenarioList.map((s, i) => `          <option value="${i}"${i === 0 ? " select
           <h2>What would you like to do</h2>
           <div class="pills" id="pills"></div>
         </div>
+        <label class="teach-toggle" title="With this on, a sentence like &quot;Candle is in the study.&quot; writes a fact into the world instead of running as a command.">
+          <input type="checkbox" id="teachToggle">
+          teach mode
+        </label>
         <form class="chatask" id="chatform">
           <span class="prompt mono">tmct&gt;</span>
           <input id="chatq" type="text" placeholder="go north" aria-label="Type a command, or ask a question" disabled>
@@ -1151,6 +1157,7 @@ ${engineBundleJs ? `<script>\n${embedScriptText(engineBundleJs)}\n</script>` : `
   const pillsEl = el("pills");
   const chatformEl = el("chatform");
   const chatqEl = el("chatq");
+  const teachToggleEl = el("teachToggle");
   const carryListEl = el("carryList");
   const mapWrapEl = el("mapWrap");
   const mapViewportEl = el("mapViewport");
@@ -1525,7 +1532,7 @@ ${engineBundleJs ? `<script>\n${embedScriptText(engineBundleJs)}\n</script>` : `
   }
   function renderPills(rows, state, here) {
     const actions = pillsFor(rows, state, here).filter((a) => a.indexOf("go ") !== 0);
-    pillsEl.innerHTML = actions.map((a) => '<button type="button" class="pill">' + esc(a) + "</button>").join("");
+    pillsEl.innerHTML = actions.map((a) => '<button type="button" class="pill" data-command="' + esc(a) + '">' + esc(a) + "</button>").join("");
     // The empty input teaches the grounded noun form off the same affordance
     // list the pills read — real props from THIS room, so a first-time player
     // types "examine lamp", not a pronoun with nothing to bind to yet.
@@ -1822,12 +1829,10 @@ ${engineBundleJs ? `<script>\n${embedScriptText(engineBundleJs)}\n</script>` : `
 
   async function boot({ fresh = false } = {}) {
     const saved = !fresh && persist ? await persist.load() : null;
-    session = await tmct.open(
-      world(),
-      saved && saved.payload && saved.payload.memoryPayload
-        ? { restoredPayload: saved.payload.memoryPayload, restoredVisitedRoomIds: saved.payload.visitedRoomIds }
-        : {},
-    );
+    const restoreOptions = saved && saved.payload && saved.payload.memoryPayload
+      ? { restoredPayload: saved.payload.memoryPayload, restoredVisitedRoomIds: saved.payload.visitedRoomIds }
+      : {};
+    session = await tmct.open(world(), { ...restoreOptions, getTeachEnabled: () => teachToggleEl.checked });
     lastTicks = 0;
     const snap = await session.snapshot();
     redraw(snap);

package/src/services/chat.mjs

@@ -40,7 +40,7 @@ import {
   stripTrailingScopeFiller, stripTrailingDiscourseTag, EDGE_NOUN_TO_METRIC, RELATIONS, LIST_TRIGGERS,
   locativePreposition,
 } from "../domain/ask-vocab.mjs";
-import { COUNTERFACTUAL_RE, correctMisspellings, applyPreambleFrames, expandContractions, normalizeQuery, stripFillerWords, escapeRegex, kindNounAnaphoraHint, datedTeachSuffix } from "../domain/interpret/normalize.mjs";
+import { COUNTERFACTUAL_RE, correctMisspellings, applyPreambleFrames, expandContractions, normalizeQuery, stripFillerWords, escapeRegex, kindNounAnaphoraHint, datedTeachSuffix, QUESTION_LEAD_RE } from "../domain/interpret/normalize.mjs";
 import { setDefaultNlpAdapter } from "../domain/interpret/nlp-registry.mjs";
 import { setConstructionBanks } from "../domain/interpret/strategies/constructions.mjs";
 import { nlpAdapter } from "../adapters/ask-nlp.mjs";
@@ -2366,9 +2366,6 @@ const COMPARATIVE_ASK_RE = new RegExp(`^(?:is|are)\\s+(.+?)\\s+(${COMPARATIVE_SR
  *  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;
 /** A plain declarative "X is a kind of Y" / "X is a Y" shape (subject-first, no
  *  question lead — paired with QUESTION_LEAD_RE at every call site), tolerating
  *  an infix "kind of"/"type of" (teachLane's own stripKindOf handles this same
@@ -4794,23 +4791,54 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
 
     // RETRACTION — "forget that X is a Y": wires the data-layer retraction
     // primitive (retractSubClassOf, src/domain/syllogise.mjs) up to chat-level
-    // phrasing.
+    // phrasing. Scoped to THIS session's own assertion (sourceTags below) —
+    // the same tags teachFact/assertSentence write under — so retracting
+    // never erases a fact another source taught, only this session's own copy.
     //
     // TRIGGER, never itself the authority: RETRACT_FORGET_RE only recognizes
     // the SHAPE of a retraction sentence — it says nothing about whether
-    // subject⊑object was ever actually taught. retractSubClassOf is asked for
-    // real and is the only thing that decides:
-    //   - found:true  → a real stored (or entailed) fact existed and was
-    //     retracted (with its dependency-directed cascade) — confirmed here.
-    //   - found:false → subject⊑object was never a stored fact, and this falls
-    //     through to the rest of teachLane's ordinary cascade below rather than
-    //     claiming a specific, possibly-wrong reason.
+    // subject⊑object was ever actually taught, or taught by THIS session.
+    // retractSubClassOf is asked for real and is the only thing that decides:
+    //   - found:false  → subject⊑object was never a stored fact, and this
+    //     falls through to the rest of teachLane's ordinary cascade below
+    //     rather than claiming a specific, possibly-wrong reason.
+    //   - found:true, ownRecord:false → some OTHER source taught it; this
+    //     session has nothing of its own to withdraw.
+    //   - found:true, stillStands:true → this session's own record is gone,
+    //     but another source's record keeps the fact standing (no cascade —
+    //     its premise never actually broke).
+    //   - found:true, stillStands:false → this session held the only record;
+    //     the fact and its dependency-directed cascade are both gone.
     if (retractForgetMatch) {
       const { retractSubClassOf } = await import("../domain/syllogise.mjs");
-      const { loadMemory: loadMemForRetract, readFactRows: readRowsForRetract, removeFacts, appendFacts: appendFactsForRetract } = await import("../adapters/memory/core.mjs");
+      const { provenanceTag: aceProvenanceTag } = await import("../domain/grammar/assert.mjs");
+      const {
+        loadMemory: loadMemForRetract, readFactRows: readRowsForRetract, removeFacts,
+        appendFacts: appendFactsForRetract, factRecordIdForTag,
+      } = await import("../adapters/memory/core.mjs");
       const result = await retractSubClassOf(memoryDir, retractSubject, retractObject, {
-        store: { loadMemory: loadMemForRetract, readFactRows: readRowsForRetract, removeFacts, appendFacts: appendFactsForRetract },
+        // A session's own positive assertion of subject⊑object can have
+        // landed under either lane: the free-form teach lane (teachFact) or
+        // the ACE-parsed assert lane (assertSentence) — both tags name here.
+        sourceTags: [teachProvenanceTag(sessionId), aceProvenanceTag({ sessionId })],
+        store: {
+          loadMemory: loadMemForRetract, readFactRows: readRowsForRetract, removeFacts,
+          appendFacts: appendFactsForRetract, factRecordIdForTag,
+        },
       });
+      if (result.found && !result.ownRecord) {
+        return {
+          text: `"${retractSubject} is a kind of ${retractObject}" isn't something you taught me — it's on record from elsewhere, so there's nothing of yours to forget.`,
+          via: "retract", miss: false,
+        };
+      }
+      if (result.found && result.stillStands) {
+        return {
+          text: `noted — forgotten your own record of "${retractSubject} is a kind of ${retractObject}", `
+            + "but it's still stored, told to me by someone else.",
+          via: "retract", miss: false,
+        };
+      }
       if (result.found) {
         const extra = result.count - 1; // beyond the target fact itself
         return {

package/src/services/mud-turn.mjs

@@ -1,7 +1,7 @@
 // mud-turn.mjs — one acting character's whole turn in a mud world: investigate
 // the room it stands in, walk toward food it actually knows about, roll for
 // digging out of the room's frontier, and (when none of that came to anything)
-// set off for a room it has never stood in. The split mirrors spider-fly.mjs /
+// set off for a room it has never stood in. The split mirrors predator-prey.mjs /
 // spider-fly-turn.mjs: adventure.mjs owns the read/fold/write primitives, this
 // file owns the per-tick decisions that drive them. Nothing here writes a fact
 // of its own — every change goes out through runWorldCommand, recordTold,

package/src/services/mud-viz.mjs

@@ -411,6 +411,10 @@ ${scenarioList.length > 1 ? `        <select id="scenarioSelect" class="deck-sel
 ${scenarioList.map((s, i) => `          <option value="${i}"${i === 0 ? " selected" : ""}>${escapeHtml(s.label || scenarioLabel(s.worldPayload?.name))}</option>`).join("\n")}
         </select>` : ""}
         <button type="button" id="editModeBtn" aria-pressed="false">edit</button>
+        <label class="deck-teach" title="With this on, a sentence like &quot;Candle is in the study.&quot; writes a fact into the world instead of running as a command.">
+          <input type="checkbox" id="teachToggle">
+          teach
+        </label>
         <button type="button" class="deck-info-btn" id="deckInfoBtn" aria-expanded="false" aria-controls="deckInfoPopup" aria-label="about this demo">?</button>
         <span class="mono deck-turns" id="globalTurnCount">turns: 0</span>
       </div>
@@ -634,6 +638,8 @@ const MUD_STYLE = `
     background: rgba(255,255,255,.5); color: var(--mud-ink);
   }
   .deck-select:hover { border-color: var(--burrow-glow); }
+  .deck-teach { display: flex; align-items: center; gap: .3rem; font-family: ${MONO_STACK}; font-size: .72rem; text-transform: uppercase; letter-spacing: .05em; color: var(--soil-mid); cursor: pointer; }
+  .deck-teach input[type="checkbox"] { accent-color: var(--burrow-glow); }
   .deck-play { background: var(--mud-ink) !important; color: var(--parchment); border-color: var(--mud-ink) !important; padding: .38rem 1.1rem !important; }
   .deck-play[aria-pressed="true"] { background: var(--burrow-glow) !important; border-color: var(--burrow-glow) !important; color: var(--mud-ink); }
   .deck-turns { margin-left: auto; font-size: .74rem; color: var(--soil-mid); }
@@ -1006,7 +1012,7 @@ const MUD_STYLE = `
     --lem-readout: var(--burrow-glow); --lem-readout-bg: var(--soil-deep);
     --lem-chalk: var(--soil-mid);
   }
-  .deck-slider, .deck h3 { color: var(--lem-chalk); }
+  .deck-slider, .deck h3, .deck-teach { color: var(--lem-chalk); }
   .deck-slider input[type="range"] { accent-color: var(--burrow-glow); }
   .deck button, .pane-controls button {
     background: var(--lem-face); color: var(--mud-ink); border: 1px solid var(--soil-mid); border-radius: 3px;
@@ -3052,7 +3058,10 @@ function pageScript() {
     // scenario's cast paired with the LAST scenario's pane ids, which is what
     // a null pane-element lookup in renderAll means when it happens.
     for (let i = 0; i < cast.length; i += 1) slotOf[cast[i]] = slots[i];
-    const opened = await window.tmct.open(scenario().worldPayload, { characters: everyone(), epoch: nextEpoch });
+    const opened = await window.tmct.open(scenario().worldPayload, {
+      characters: everyone(), epoch: nextEpoch,
+      getTeachEnabled: function () { return el("teachToggle").checked; },
+    });
     if (seq !== bootSeq) return;
     session = opened;
     if (liveRoom) {