@polycode-projects/the-mechanical-code-talker 4.1.1 → 4.1.2

package/src/services/p2p-room.mjs

@@ -21,6 +21,7 @@ import { relabelForBroadcast } from "../domain/p2p/provenance-relabel.mjs";
 import {
   worldNameFact,
   nodeNameFact,
+  invitedByFact,
   waveFact,
   latestFact,
   latestProvenanceTimestamp,
@@ -28,7 +29,8 @@ import {
   NODE_NAME_PREDICATE,
   WAVED_PREDICATE,
 } from "../domain/p2p/facts.mjs";
-import { appendFacts, loadMemory, readFactRows, normFactTerm, FACT_CLASS } from "../adapters/memory/core.mjs";
+import { generateNodeId } from "../domain/p2p/peer-id.mjs";
+import { appendFacts, loadMemory, loadNodeId, saveNodeId, readFactRows, normFactTerm, FACT_CLASS } from "../adapters/memory/core.mjs";
 
 export const ROOM_IDLE = "idle";
 export const ROOM_SHARING = "sharing";
@@ -58,7 +60,7 @@ const INVITE_PROBLEM_MESSAGES = {
     "unsupported-version": "that reply came from a newer version of the page than this one",
     "wrong-kind": "that's an invite, not a reply — send it to the person you're inviting, or open it in a new tab to join their world",
     "no-pending-invite": "that reply matched an invite that's already been used — create a fresh link and send that instead",
-    "connect-failed": "your two machines can't reach each other directly; this works on the same network, or between machines that can already see each other",
+    "connect-failed": "your two machines couldn't find a path to each other — a public STUN server helps with most networks, but some firewalls or strict NATs still block it",
   },
 };
 
@@ -69,7 +71,10 @@ const problem = (context, code) => ({
 
 // A tag this shape has already been rewritten for the wire by whichever peer
 // authored it. Relabeling it again would overwrite their node name with ours
-// and lose the attribution the receiving page renders as "taught by X".
+// and lose the attribution the receiving page renders as "taught by X". The
+// prefix is all this needs to match: everything a relabel adds after it — the
+// display name, the `#node:<id>` origin segment, the timestamp — is that
+// peer's, so a relayed tag stays byte-identical however much it carries.
 const ALREADY_PEER_LABELED = /^teach:peer:/;
 
 /** One outgoing tag per stored tag, each relabeled under the timestamp it
@@ -78,17 +83,40 @@ const ALREADY_PEER_LABELED = /^teach:peer:/;
  *  wave replayed inside a sync response reading as freshly waved, and it makes
  *  the rewrite idempotent: a peer that relays a tag it received produces the
  *  same tag again, so the union stops growing once every peer has seen it. */
-function wireProvenanceTags(provenance, myDisplayName, fallbackTimestamp) {
+/** `observedAtBySegment` maps a STORED (pre-relabel) tag to the observedAt its
+ *  own record carries, when it has one — the dated-teach frame's own
+ *  `mgx:observedAt`, threaded onto the wire fact each tag becomes. Returns
+ *  `{ tag, observedAt }` pairs, deduped by the RELABELED tag (the first
+ *  observedAt seen for a given output tag wins, matching the prior de-dup by
+ *  tag string alone). */
+function wireProvenanceTags(provenance, identity, fallbackTimestamp, observedAtBySegment) {
   const stored = String(provenance || "").split(" | ").filter(Boolean);
-  if (!stored.length) return [""];
-  const tags = new Set();
+  if (!stored.length) return [{ tag: "", observedAt: undefined }];
+  const byTag = new Map();
   for (const segment of stored) {
-    if (ALREADY_PEER_LABELED.test(segment)) { tags.add(segment); continue; }
-    const assertedAt = latestProvenanceTimestamp(segment);
-    const timestamp = assertedAt === null ? fallbackTimestamp : new Date(assertedAt).toISOString();
-    tags.add(relabelForBroadcast(segment, myDisplayName, timestamp));
+    const observedAt = observedAtBySegment?.get(segment);
+    const tag = ALREADY_PEER_LABELED.test(segment) ? segment : (() => {
+      const assertedAt = latestProvenanceTimestamp(segment);
+      const timestamp = assertedAt === null ? fallbackTimestamp : new Date(assertedAt).toISOString();
+      return relabelForBroadcast(segment, identity.displayName, timestamp, identity.nodeId);
+    })();
+    if (!byTag.has(tag)) byTag.set(tag, observedAt);
   }
-  return [...tags];
+  return [...byTag].map(([tag, observedAt]) => ({ tag, observedAt }));
+}
+
+/** This store's own node id, minted on first use and never regenerated: it
+ *  keys every assertion the node broadcasts, so re-minting one would split a
+ *  single node's history into two apparent origins that then corroborate each
+ *  other. An id already on the store always wins over `preferred` (what a
+ *  browser page carries across reloads) for exactly that reason — `preferred`
+ *  only seeds a store that has never joined a room. */
+export async function resolveStoreNodeId(memoryDir, preferred = "") {
+  const stored = await loadNodeId(memoryDir);
+  if (stored) return stored;
+  const minted = preferred || generateNodeId();
+  await saveNodeId(memoryDir, minted);
+  return minted;
 }
 
 const isFactShaped = (f) => !!f
@@ -101,14 +129,32 @@ const isFactShaped = (f) => !!f
  *  already stores, and a joined union arrives as one opaque string that matches
  *  none of them — so a fact whose provenance had grown would union again on
  *  every hop and never settle. Sending each tag on its own row keeps the merge
- *  idempotent, and a repeated triple inside one batch unions correctly. */
-const toWireFacts = (row, myDisplayName, fallbackTimestamp) =>
-  wireProvenanceTags(row.provenance, myDisplayName, fallbackTimestamp).map((provenance) => ({
-    subject: row.subject,
-    predicate: row.predicate,
-    object: row.object,
-    provenance,
-  }));
+ *  idempotent, and a repeated triple inside one batch unions correctly.
+ *
+ *  `mgx:observedAt` is record content the same way the tag is: each of
+ *  row.assertions is one live head, and its own `provenance` (that head's own
+ *  tags) is the join key back to which outgoing wire fact carries its
+ *  observedAt. A dated taught fact's broadcast carries the date, so a peer
+ *  that receives it can resolve it against a fresher OR staler claim the same
+ *  way the local store already does (memory/resolution.mjs's
+ *  effectiveObservedAt chain). */
+const toWireFacts = (row, identity, fallbackTimestamp) => {
+  const observedAtBySegment = new Map();
+  for (const a of row.assertions || []) {
+    if (!a.observedAt) continue;
+    for (const segment of String(a.provenance || "").split(" | ").filter(Boolean)) {
+      observedAtBySegment.set(segment, a.observedAt);
+    }
+  }
+  return wireProvenanceTags(row.provenance, identity, fallbackTimestamp, observedAtBySegment)
+    .map(({ tag, observedAt }) => ({
+      subject: row.subject,
+      predicate: row.predicate,
+      object: row.object,
+      provenance: tag,
+      ...(observedAt ? { observedAt } : {}),
+    }));
+};
 
 /** A room: one shared world, one local fact store, and however many direct
  *  peer connections have been made into it.
@@ -122,6 +168,11 @@ export function createP2pRoom({
   memoryDir,
   myPeerId,
   myDisplayName,
+  // Optional. A browser page carries its node id across reloads itself (the
+  // in-memory store it rebuilds each visit cannot), so it passes the id it
+  // kept; a store that already holds one keeps that instead. Omitted, the
+  // room mints one onto the store the first time it joins a room.
+  myNodeId = "",
   worldId,
   worldName,
   transportFactory,
@@ -144,6 +195,11 @@ export function createP2pRoom({
     return new Date(nudged).toISOString();
   };
   let displayName = myDisplayName;
+  let nodeId = myNodeId;
+  // What this node's own assertions go out under: the name people read, and
+  // the stable id that keys them. Read fresh per broadcast — a rename or a
+  // recast can move either between one turn and the next.
+  const wireIdentity = () => ({ displayName, nodeId });
   let state = ROOM_IDLE;
   let lastError = null;
   let started = false;
@@ -242,6 +298,9 @@ export function createP2pRoom({
   async function ensureStarted() {
     if (started) return;
     started = true;
+    // Joining a room is the first moment this store needs an identity other
+    // peers can key on, so it is where the node id is minted.
+    nodeId = await resolveStoreNodeId(memoryDir, myNodeId);
     // Every fact already on disk is history, not something this session
     // authored, so it is baselined as seen. A joiner gets it through sync
     // instead, which is what the sync filter exists to size down.
@@ -273,7 +332,7 @@ export function createP2pRoom({
     const targets = connectedPeers();
     if (!targets.length) return { broadcast: 0 };
     const timestamp = now();
-    const facts = changed.flatMap((row) => toWireFacts(row, displayName, timestamp));
+    const facts = changed.flatMap((row) => toWireFacts(row, wireIdentity(), timestamp));
     broadcast(opMessage({ from: myPeerId, facts }));
     return { broadcast: changed.length };
   }
@@ -289,6 +348,11 @@ export function createP2pRoom({
       predicate: f.predicate,
       object: f.object,
       provenance: typeof f.provenance === "string" ? f.provenance : "",
+      // Presence-wins on an id collision with equal assertion timestamps is
+      // already the join appendFacts' own supersedesPriorAssertion performs —
+      // this is the passthrough that lets a dated taught fact's wire fact
+      // reach it at all.
+      ...(typeof f.observedAt === "string" && f.observedAt ? { observedAt: f.observedAt } : {}),
     })));
     await sortFactIndividualsById();
     await refreshRows();
@@ -373,7 +437,7 @@ export function createP2pRoom({
         const facts = await withStore(async () => {
           await refreshRows();
           const timestamp = now();
-          return syncableFacts(cachedRows).flatMap((row) => toWireFacts(row, displayName, timestamp));
+          return syncableFacts(cachedRows).flatMap((row) => toWireFacts(row, wireIdentity(), timestamp));
         });
         send(transport, syncResponseMessage({ facts }));
         return;
@@ -434,7 +498,7 @@ export function createP2pRoom({
     lastError = null;
     const sdp = await transport.createOffer();
     setState(ROOM_SHARING);
-    return { blob: encodeInviteBlob({ kind: "offer", sdp, world: worldId, worldName }) };
+    return { blob: encodeInviteBlob({ kind: "offer", sdp, world: worldId, worldName, node: nodeId }) };
   }
 
   /** Decode someone's invite and answer it. Returns the reply blob to send
@@ -457,6 +521,7 @@ export function createP2pRoom({
     const transport = attachTransport(transportFactory());
     lastError = null;
     const sdp = await transport.createAnswerFor(decoded.value.sdp);
+    await recordInviteEdge(decoded.value.node);
     setState(ROOM_ANSWERING);
     return {
       blob: encodeInviteBlob({ kind: "reply", sdp }),
@@ -465,6 +530,22 @@ export function createP2pRoom({
     };
   }
 
+  /** Write the admission edge for the invite this node just answered. Only the
+   *  joiner can: the inviter does not learn the joining node's id until the
+   *  channel is already open, and by then the edge would be indistinguishable
+   *  from any other fact that arrived over it. An invite from a build that
+   *  predates the node field carries no inviter to record, and an invite a node
+   *  answers with its own id is no admission at all. */
+  async function recordInviteEdge(inviterNodeId) {
+    if (typeof inviterNodeId !== "string" || !inviterNodeId) return;
+    if (!nodeId || inviterNodeId === nodeId) return;
+    await withStore(async () => {
+      await appendFacts(memoryDir, [invitedByFact(nodeId, inviterNodeId, now())]);
+      await sortFactIndividualsById();
+      await refreshRows();
+    });
+  }
+
   /** Feed the joiner's reply back into the invite it answers, completing the
    *  connection. */
   async function completeInvite(replyBlob) {
@@ -557,6 +638,11 @@ export function createP2pRoom({
       if (nextWorldName) worldName = nextWorldName;
       if (nextDisplayName) displayName = nextDisplayName;
       started = true;
+      // The store changed, so the node id is re-resolved against the new one.
+      // A recast store that has never joined a room adopts the id this node
+      // has been broadcasting under all along, which is what keeps a recast
+      // from reading to every peer as a brand-new node.
+      nodeId = await resolveStoreNodeId(memoryDir, nodeId || myNodeId);
       seenProvenanceById.clear();
       cachedRows = [];
       const timestamp = now();
@@ -573,7 +659,7 @@ export function createP2pRoom({
       let pushed = 0;
       if (targets.length) {
         const wireTimestamp = now();
-        const facts = syncableFacts(cachedRows).flatMap((row) => toWireFacts(row, displayName, wireTimestamp));
+        const facts = syncableFacts(cachedRows).flatMap((row) => toWireFacts(row, wireIdentity(), wireTimestamp));
         pushed = facts.length;
         if (facts.length) broadcast(opMessage({ from: myPeerId, facts }));
         broadcast(syncRequestMessage());
@@ -602,6 +688,7 @@ export function createP2pRoom({
     worldId,
     get worldName() { return worldName; },
     get displayName() { return displayName; },
+    get nodeId() { return nodeId; },
     get state() { return state; },
     get lastError() { return lastError; },
     get droppedMessages() { return droppedMessages; },

package/src/services/plan-viz.mjs

@@ -406,6 +406,8 @@ h1 { font-family: ${SERIF_STACK}; font-size: 1.2rem; font-weight: 600; margin: 0
 .chatlog:empty { display: none; margin-bottom: 0; }
 .chatlog .u { font-family: ${MONO_STACK}; font-size: .74rem; color: var(--muted); }
 .chatlog .u::before { content: "tmct> "; color: var(--taught); }
+.chatlog .b { font-family: ${MONO_STACK}; font-size: .74rem; color: var(--muted); }
+.chatlog .b::before { content: "board> "; color: var(--corpus); }
 .chatlog .a { font-family: ${SERIF_STACK}; font-size: .87rem; line-height: 1.45; white-space: pre-wrap; color: var(--ink); }
 .chatask { display: flex; align-items: center; gap: .5rem; border-top: 1px solid var(--line); padding-top: .5rem; }
 .chatlog:empty + .chatask { border-top: none; padding-top: 0; }
@@ -413,6 +415,12 @@ h1 { font-family: ${SERIF_STACK}; font-size: 1.2rem; font-weight: 600; margin: 0
 .chatask input { flex: 1; font-family: ${MONO_STACK}; font-size: .78rem; background: var(--well); color: var(--ink); border: 1px solid var(--line); border-radius: 4px; padding: .34rem .55rem; min-width: 0; }
 .chatask input:focus-visible { outline: 2px solid var(--taught); outline-offset: 2px; }
 .chatpills { display: flex; flex-wrap: wrap; gap: .3rem; margin-top: .5rem; }
+.boardask { margin-top: .75rem; border-top: 1px dashed var(--line); padding-top: .55rem; }
+.boardask h3 { font-family: ${MONO_STACK}; font-size: .6rem; letter-spacing: .1em; text-transform: uppercase; color: var(--muted); font-weight: 400; margin: 0 0 .45rem; }
+.boardask .chatask { border-top: none; padding-top: 0; }
+.boardask .prompt { color: var(--corpus); }
+.boardask input:focus-visible { outline-color: var(--corpus); }
+.boardask .pill:hover { border-color: var(--corpus); color: var(--corpus); }
 .pill { font-family: ${MONO_STACK}; font-size: .66rem; padding: .22rem .6rem; border: 1px solid var(--line); border-radius: 99px; background: var(--well); color: var(--ink); cursor: pointer; white-space: nowrap; }
 .pill:hover { border-color: var(--taught); color: var(--taught); }
 .pill:focus-visible { outline: 2px solid var(--taught); outline-offset: 2px; }
@@ -467,6 +475,18 @@ h1 { font-family: ${SERIF_STACK}; font-size: 1.2rem; font-weight: 600; margin: 0
         <button type="button" class="pill" data-fill="solve it.">solve it</button>
         <button type="button" class="pill" data-fill="what moves are legal now?">what moves are legal now?</button>
       </div>
+      <div class="boardask">
+        <h3>ask the board at this step</h3>
+        <form class="chatask" id="boardform">
+          <span class="prompt">board&gt;</span>
+          <input id="boardq" type="text" placeholder="list the locations of disks" aria-label="Ask a question about the board at the current step">
+        </form>
+        <div class="chatpills" id="boardpills" role="group" aria-label="quick phrases to fill the board question input">
+          <button type="button" class="pill" data-fill="list the locations of disks">list the locations of disks</button>
+          <button type="button" class="pill" data-fill="how many moves are there?">how many moves are there?</button>
+          <button type="button" class="pill" data-fill="list the pegs">list the pegs</button>
+        </div>
+      </div>
     </div>
     <div class="pddlpanel">
       <h2>PDDL + OWL/RDF plan artifact</h2>
@@ -677,12 +697,21 @@ const PLAN = ${embedded};
   const chatformEl = document.getElementById("chatform");
   const chatqEl = document.getElementById("chatq");
   const chatpillsEl = document.getElementById("chatpills");
+  const boardformEl = document.getElementById("boardform");
+  const boardqEl = document.getElementById("boardq");
+  const boardpillsEl = document.getElementById("boardpills");
 
   const liveAvailable = typeof tmct !== "undefined" && typeof tmct.open === "function";
   if (!liveAvailable) {
     liveStatusEl.textContent = "live re-solve unavailable here — showing the baked-in replay only.";
     liveStatusEl.classList.add("isError");
     resolveBtn.disabled = true;
+    // Neither dock has a submit handler without the live engine, and a form
+    // that submits with no handler navigates away — so the inputs are shut
+    // off rather than left to reload the page on Enter.
+    chatqEl.disabled = true;
+    boardqEl.disabled = true;
+    boardqEl.placeholder = "needs the live engine — the replay above still works.";
   } else {
     let session = null;
     // Every engine-touching call (a resolve click and a chat submit) shares
@@ -731,6 +760,12 @@ const PLAN = ${embedded};
       if (!freshPlan) return;
       const { rendersAs, sizeOrder } = tmct.page.renderInputsFromPlan(freshPlan);
       mountPlan(tmct.page.planToPageData({ plan: freshPlan, rendersAs, sizeOrder }));
+      // The board tmct.ask() traverses is projected from a plan and a step.
+      // mountPlan rewinds the transport to step 0, so the graph is moved to
+      // the same position rather than left pointing at the previous puzzle.
+      if (typeof tmct.session?.showBoard === "function") {
+        tmct.session.showBoard({ plan: freshPlan, step: 0 });
+      }
       if (pddlEl) pddlEl.textContent = tmct.page.planToPddl(freshPlan);
       // The <title>/<h1> were baked from the INITIAL plan's own goal text —
       // a live re-solve toward a different goal (a fresh puzzle, or a
@@ -746,6 +781,11 @@ const PLAN = ${embedded};
         diskCount: Math.max(1, Math.min(7, parseInt(diskCountEl.value, 10) || 3)),
         maxDepth: Math.max(1, parseInt(maxDepthEl.value, 10) || 300),
       });
+      // The board on screen is the server-rendered embed until the first
+      // session opens, and the disk-count control may have moved since. A
+      // session solving a different puzzle would answer about a board nobody
+      // is looking at, so mount its own plan instead.
+      if (session.plan && session.plan.actions.length !== N) applyPlan(session.plan);
       return session;
     }
 
@@ -783,11 +823,30 @@ const PLAN = ${embedded};
       });
     });
 
-    for (const pill of chatpillsEl.querySelectorAll(".pill")) {
-      pill.addEventListener("click", () => {
-        chatqEl.value = pill.dataset.fill || "";
-        chatqEl.focus();
+    // A board question goes to tmct.ask(), not tmct.turn(): ask() traverses
+    // the puzzle projected as a graph at the step the transport is showing,
+    // so "list the locations of disks" reads the board in front of you. A
+    // question that graph can't ground gets the engine's own refusal.
+    boardformEl.addEventListener("submit", (e) => {
+      e.preventDefault();
+      const q = boardqEl.value.trim();
+      if (!q) return;
+      boardqEl.value = "";
+      addChatLine("b", q + " (step " + step + ")");
+      withLock(async () => {
+        await ensureSession();
+        const result = await tmct.ask(q, { step });
+        addChatLine("a", result.answer);
       });
+    });
+
+    for (const [pills, input] of [[chatpillsEl, chatqEl], [boardpillsEl, boardqEl]]) {
+      for (const pill of pills.querySelectorAll(".pill")) {
+        pill.addEventListener("click", () => {
+          input.value = pill.dataset.fill || "";
+          input.focus();
+        });
+      }
     }
   }
 })();

package/src/services/research-viz.mjs

@@ -396,14 +396,25 @@ ${DASH_DARK_CHROME_CSS}
 
   let seedPayload = null;
   let seedFacts = 0;
+  // One retry with a cache-busting query param: a CDN edge can serve a
+  // corrupted or truncated precompressed response (a transient bad cache
+  // entry, not a code defect — real bytes decompress fine, and the same URL
+  // fetched moments later is clean), and JSON.parse throwing is the only
+  // signal of that. The bust param forces a fresh fetch past that one entry.
   async function fetchSeed() {
-    try {
-      const blob = await fetchWithProgress("./chat-seed.json" + SEED_QUERY, (loaded, total) => noteProgress("seed", loaded, total));
-      seedPayload = JSON.parse(await blob.text());
-      seedFacts = (seedPayload.individuals || []).filter((i) => i.class === "Fact").length;
-    } catch (err) {
-      seedPayload = null;
-      console.warn("tmct research: chat-seed.json unavailable — starting unseeded", err);
+    for (let attempt = 1; attempt <= 2; attempt++) {
+      try {
+        const bust = attempt === 1 ? "" : (SEED_QUERY ? "&" : "?") + "retry=1";
+        const blob = await fetchWithProgress("./chat-seed.json" + SEED_QUERY + bust, (loaded, total) => noteProgress("seed", loaded, total));
+        seedPayload = JSON.parse(await blob.text());
+        seedFacts = (seedPayload.individuals || []).filter((i) => i.class === "Fact").length;
+        return;
+      } catch (err) {
+        if (attempt === 2) {
+          seedPayload = null;
+          console.warn("tmct research: chat-seed.json unavailable — starting unseeded", err);
+        }
+      }
     }
   }
   async function newSession() {