@polycode-projects/the-mechanical-code-talker 2.10.2 → 2.10.5

package/src/services/adventure.mjs

@@ -408,9 +408,21 @@ const BACKGROUND_FACT_PHRASES = {
   "mgx:atLocation": "is found in",
 };
 
+/** True when a fact row is provably owned by a NON-world source (a merged
+ *  corpus, a reference pack, a taught assert) rather than the loaded world. A
+ *  row with no provenance is not "non-world" — a hand-built digest view carries
+ *  none, and the room-look filter keeps those. World facts and their @turn
+ *  snapshots tag as `world:<name>[:turnN]`. */
+function isNonWorldSourced(row) {
+  const prov = String(row.provenance || "").trim();
+  return prov !== "" && !prov.startsWith("world:");
+}
+
 /** The digest's fact view: current placements (folded), exits, typing and
  *  every other surviving fact, with phrase predicates and sentence-cased
- *  subjects so the pipeline's sentence splitter sees real sentences. Pure. */
+ *  subjects so the pipeline's sentence splitter sees real sentences. Room text
+ *  is world-sourced only — a merged corpus's overlap on a room's own vocabulary
+ *  never leaks into the description. Pure. */
 export function worldDigestRows(rows, state) {
   const out = [];
   const seen = new Set();
@@ -440,6 +452,12 @@ export function worldDigestRows(rows, state) {
   }
   for (const row of rows || []) {
     if (SNAPSHOT_RE.test(row.subject)) continue;                 // folded above
+    // Room text comes from the world source only. A merged corpus overlaps a
+    // room's own vocabulary ("library rdfs:subClassOf literary study"), and
+    // without this those rows leak into the room description as stray sentences.
+    // A row with no provenance (a hand-built test view) is kept — the filter
+    // only drops rows a non-world source provably owns.
+    if (isNonWorldSourced(row)) continue;
     if (PLACEMENT_PREDICATES.has(row.predicate)) continue;       // folded above
     if (VIEW_EXCLUDED_PREDICATES.has(row.predicate)) continue;
     const exit = EXIT_PREDICATE_RE.exec(row.predicate);
@@ -909,6 +927,58 @@ async function worldOpennessAnswer(line, { memoryDir }) {
   );
 }
 
+// The in-game orientation asides — "where am I", "what can I do", "what is the
+// quest/goal". Without a world-state answer these fall through to the ordinary
+// lanes and misroute: "where am I" reads "I" as a module name, "what can I do"
+// walls, and "what is the goal" answers from corpus vocabulary about the word
+// "goal". A live world answers each from its own fold first.
+const WORLD_WHERE_AM_I_RE = /^where\s+am\s+i(?:\s+now)?[?.!\s]*$/i;
+const WORLD_OPTIONS_RE = /^(?:what\s+can\s+i\s+do(?:\s+(?:here|now))?|what\s+are\s+my\s+options|what\s+(?:should|do)\s+i\s+do(?:\s+(?:here|now))?|what\s+now)[?.!\s]*$/i;
+const WORLD_QUEST_RE = /^(?:what(?:'s|\s+is)\s+(?:the\s+|my\s+)?(?:quest|goal|objective|mission|aim)|what\s+am\s+i\s+(?:trying\s+to\s+do|(?:supposed|meant)\s+to\s+do)|what\s+do\s+i\s+do\s+here)[?.!\s]*$/i;
+
+/** The in-game orientation asides, answered from the world fold: the player's
+ *  room, the room's real affordances, and the world's objective. Null when the
+ *  line is none of them, so an ordinary question keeps its lane. */
+async function worldContextAnswer(line, { memoryDir }) {
+  const l = String(line).trim();
+  const asksWhere = WORLD_WHERE_AM_I_RE.test(l);
+  const asksOptions = WORLD_OPTIONS_RE.test(l);
+  const asksQuest = WORLD_QUEST_RE.test(l);
+  if (!asksWhere && !asksOptions && !asksQuest) return null;
+  let rows;
+  try { rows = readFactRows(await loadMemory(memoryDir)); } catch { return null; }
+  const state = foldWorldState(rows);
+  const here = state.placements.get("player")?.object ?? null;
+
+  if (asksWhere) {
+    return here
+      ? answer(`you are in the ${here}.`, "ADVENTURE — where-am-I aside: the player's own room from the current world fold", { goal: "check where you are" })
+      : answer("the world has no written player position yet.", "ADVENTURE — where-am-I aside: no player placement", { miss: true, goal: "check where you are" });
+  }
+
+  if (asksOptions) {
+    const actions = here ? roomAffordances(rows, state, here) : [];
+    return answer(
+      actions.length ? `you can: ${actions.join(", ")}.` : `nothing obvious here — say "look" to look around${here ? ` the ${here}` : ""}.`,
+      `ADVENTURE — options aside: the ${here}'s roomAffordances, the same list "look" appends`,
+      { goal: "see what you can do here" },
+    );
+  }
+
+  const objectiveId = rows.find((r) => r.predicate === "mgx:is-objective" && r.object === "true")?.subject ?? null;
+  return objectiveId
+    ? answer(
+        `your goal is to find the ${objectiveId} and pick it up.`,
+        `ADVENTURE — quest aside: the world's objective (${objectiveId}), named without spoiling where it is`,
+        { goal: `find the ${objectiveId}` },
+      )
+    : answer(
+        `this world sets no explicit goal — explore it, and say "look" to see your options.`,
+        "ADVENTURE — quest aside: no objective marker in this world",
+        { goal: "explore the world" },
+      );
+}
+
 async function inventoryAnswer({ memoryDir, graph }) {
   const memory = await loadMemory(memoryDir);
   const rows = readFactRows(memory);
@@ -1033,5 +1103,7 @@ export async function adventureTurn(line, { planHolder, memoryDir, sessionId = "
   if (whereAside) return whereAside;
   const opennessAside = await worldOpennessAnswer(line, { memoryDir });
   if (opennessAside) return opennessAside;
+  const contextAside = await worldContextAnswer(line, { memoryDir });
+  if (contextAside) return contextAside;
   return null; // a mid-game aside — the ordinary lanes answer, world untouched
 }

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

@@ -30,6 +30,7 @@
 // exist (both built earlier in that same script, for the embedded widget).
 import { THEME_TOKENS_CSS, SERIF_STACK, MONO_STACK, escapeHtml } from "./viz-theme.mjs";
 import { provBucketFor } from "./ledger-viz.mjs";
+import { sessionLogTimeOfDay, sessionLogHeaderMarkdown, sessionLogTurnMarkdown } from "./session-log-format.mjs";
 
 const DEFAULT_TITLE = "the-mechanical-code-talker — talk to it";
 
@@ -115,25 +116,37 @@ export function loadProgressLine(parts) {
 }
 
 /**
- * The exported transcript as one Markdown document: a title line naming the
- * site version and the export date, then every turn in order as
- * "**you:** ..." / "**tmct:** ...", with the provenance tier in parentheses
- * when the turn carried one. Reads the page's transcript MODEL (an array of
- * { role, text, chipTier }), never the DOM — the message column may
- * virtualize long chats someday, and an export must still carry every turn.
+ * 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,
+ * spliced in beside this function below): a title naming the version and a
+ * short session id, one heading per turn at millisecond time-of-day
+ * precision, the question as a verbatim blockquote, the answer in a fenced
+ * block. No closing session-end line — unlike a CLI session's close(), an
+ * export can happen mid-conversation, before anything has actually ended.
  *
- * Self-contained (no outer refs), `.toString()`-splice safe — the same
- * discipline provenanceChipFor/loadProgressLine above hold.
+ * Reads the page's transcript MODEL (an array alternating { role: "you" |
+ * "tmct", text, chipTier, ts }, one entry per submit and per settled
+ * reply), never the DOM — the message column may virtualize long chats
+ * someday, and an export must still carry every turn.
+ *
+ * `headerMd`/`turnMd` are the injected session-log-format.mjs builders
+ * (spliced in as their own consts alongside this function) — injected
+ * rather than imported so this function stays `.toString()`-splice safe,
+ * the same discipline provenanceChipFor's injected `bucketFor` holds.
  */
-export function transcriptMarkdown(turns, meta) {
+export function transcriptMarkdown(turns, meta, headerMd, turnMd) {
   const version = (meta && meta.version) || "dev";
-  const date = (meta && meta.date) || "";
-  const lines = ["# tmct chat — v" + version + (date ? " — " + date : ""), ""];
-  for (const turn of turns || []) {
-    const tier = turn.chipTier ? " (" + turn.chipTier + ")" : "";
-    lines.push("**" + turn.role + ":** " + turn.text + tier, "");
+  const sessionId = (meta && meta.sessionId) || "";
+  const list = turns || [];
+  let doc = headerMd({ version: version, sessionId: sessionId, startedAt: list.length ? list[0].ts : Date.now() });
+  let turnNumber = 0;
+  for (let i = 0; i < list.length; i += 1) {
+    if (list[i].role !== "you") continue;
+    turnNumber += 1;
+    const reply = list[i + 1] && list[i + 1].role === "tmct" ? list[i + 1] : null;
+    doc += turnMd({ startedAt: list[i].ts, turnNumber: turnNumber, query: list[i].text, answer: reply ? reply.text : "" });
   }
-  return lines.join("\n");
+  return doc;
 }
 
 /** The self-contained "talk to it" full-screen page. Pure — the same output
@@ -304,12 +317,14 @@ ${THEME_TOKENS_CSS}
         <button type="submit" id="composerSend" aria-label="Send" disabled>&#8594;</button>
       </div>
       <div class="composer-tools">
-        <label class="liveLabel" title="Off by default. When on, a question nothing local can answer also asks en.wikipedia.org — two small requests per lookup, and the answer is cited (CC BY-SA).">
+        <label class="liveLabel" title="Off by default. When on, a question nothing local can answer also asks en.wikipedia.org — two small requests per lookup, and the answer is cited (CC BY-SA). Type /wiki supplement to also add a cited Wikipedia read-out under every grounded answer.">
           <input type="checkbox" id="liveToggle" role="switch" aria-label="ask Wikipedia when I don't know">
           <span class="toggle-track" aria-hidden="true"><span class="toggle-knob"></span></span>
           <span>ask Wikipedia when I don&#8217;t know</span>
         </label>
         <span class="tool-cluster">
+          <button type="button" id="ingestFile" class="tool-btn" title="load a .txt/.md file and teach every fact it recognizes into this session">ingest file</button>
+          <input type="file" id="ingestInput" accept=".txt,.md,text/plain,text/markdown" hidden>
           <button type="button" id="exportMd" class="tool-btn" title="download this conversation as Markdown">export .md</button>
           <button type="button" id="exportFacts" class="tool-btn" title="download this session's facts as JSONL (the tmct extract shape, provenance included)">export facts</button>
           <button type="button" id="printChat" class="tool-btn" title="print the whole conversation">print</button>
@@ -329,6 +344,9 @@ ${THEME_TOKENS_CSS}
   const provBucketFor = ${provBucketFor.toString()};
   const provenanceChipFor = ${provenanceChipFor.toString()};
   const loadProgressLine = ${loadProgressLine.toString()};
+  const sessionLogTimeOfDay = ${sessionLogTimeOfDay.toString()};
+  const sessionLogHeaderMarkdown = ${sessionLogHeaderMarkdown.toString()};
+  const sessionLogTurnMarkdown = ${sessionLogTurnMarkdown.toString()};
   const transcriptMarkdown = ${transcriptMarkdown.toString()};
   const el = (id) => document.getElementById(id);
 
@@ -763,8 +781,14 @@ ${THEME_TOKENS_CSS}
     window.tmctChatSession.turn(q)
       .then((result) => {
         settleAssistantBubble(pendingRow, result.answer, result.record);
-        if (result.record && result.record.via === "assert") scheduleSave();
-        return renderStatsPanel(); // a teach turn just grew this session's memory; a plain ask leaves it unchanged either way
+        // Persist on ANY store write, not just a teach turn: a learn-on-miss
+        // load (a child pack, a reference or live-Wikipedia article) and its
+        // auto-synthesis also append facts, and those were lost on reload when
+        // only via==="assert" saved. Commands write nothing, so they stay out.
+        // The save is debounced, so a read-through that changed nothing costs
+        // at most one coalesced write.
+        if (result.record && result.record.via !== "command") scheduleSave();
+        return renderStatsPanel(); // a teach or learned-load turn grew this session's memory; a plain ask leaves it unchanged either way
       })
       .catch((err) => settleAssistantBubble(pendingRow,
         "something went wrong answering that (" + (err && err.message ? err.message : err) + ") \\u2014 try rephrasing",
@@ -791,7 +815,8 @@ ${THEME_TOKENS_CSS}
   // @media print stylesheet above to un-pin the message column so every
   // turn reaches paper.
   el("exportMd").addEventListener("click", () => {
-    const md = transcriptMarkdown(transcript, { version: siteVersion, date: new Date(Date.now()).toISOString().slice(0, 10) });
+    const sessionId = (window.tmctChatSession && window.tmctChatSession.sessionId) || "";
+    const md = transcriptMarkdown(transcript, { version: siteVersion, sessionId: sessionId }, sessionLogHeaderMarkdown, sessionLogTurnMarkdown);
     const blob = new Blob([md], { type: "text/markdown" });
     const url = URL.createObjectURL(blob);
     const link = document.createElement("a");
@@ -829,6 +854,49 @@ ${THEME_TOKENS_CSS}
     setTimeout(() => URL.revokeObjectURL(url), 1000);
   });
 
+  // "ingest file" feeds a whole .txt/.md through the SAME session, one
+  // sentence at a time (window.tmctChat.splitSentences, then session.turn),
+  // teaching every sentence the recognizer grounds and skipping the rest
+  // honestly — the same pipeline the ingest page runs, reaching the chat's own
+  // memory so the taught facts answer questions straight away.
+  el("ingestFile").addEventListener("click", () => el("ingestInput").click());
+  el("ingestInput").addEventListener("change", async (e) => {
+    const file = e.target.files && e.target.files[0];
+    e.target.value = "";
+    const session = window.tmctChatSession;
+    if (!file || busy || !session || !window.tmctChat.splitSentences) return;
+    let text;
+    try {
+      text = await file.text();
+    } catch (err) {
+      addSystemLine("couldn't read that file (" + (err && err.message ? err.message : err) + ").");
+      return;
+    }
+    const sentences = window.tmctChat.splitSentences(text);
+    if (!sentences.length) { addSystemLine("nothing to ingest in " + file.name + "."); return; }
+    setBusy(true);
+    statusEl.textContent = "ingesting " + file.name + "\\u2026";
+    let grounded = 0;
+    try {
+      for (const sentence of sentences) {
+        const result = await session.turn(sentence);
+        if (result.record && result.record.via === "assert" && !result.record.miss) grounded += 1;
+      }
+    } catch (err) {
+      addSystemLine("something went wrong ingesting " + file.name + " (" + (err && err.message ? err.message : err) + ").");
+    }
+    if (grounded) scheduleSave();
+    const skipped = sentences.length - grounded;
+    addSystemLine("ingested " + file.name + " \\u2014 " + sentences.length + " sentence"
+      + (sentences.length === 1 ? "" : "s") + " read, " + grounded + " fact"
+      + (grounded === 1 ? "" : "s") + " added"
+      + (skipped ? ", " + skipped + " skipped (not a recognized fact shape)" : "") + ".");
+    await renderStatsPanel();
+    renderStatus();
+    setBusy(false);
+    inputEl.focus();
+  });
+
   // "reset to seed" is the full re-initialisation: drop the persisted payload
   // outright and reload, so boot re-seeds from the page's shipped seed as if on
   // a first visit. Harder than "forget everything", which only swaps the live

package/src/services/chat-session.mjs

@@ -28,6 +28,7 @@ import * as defaultSource from "../adapters/source.mjs";
 import { resolveExtensions, mergedLexiconExtra } from "./extensions.mjs";
 import { runTurn, hasSeededVocabulary, vocabExampleHint } from "./chat.mjs";
 import { resolveGameConfig } from "../domain/game-config.mjs";
+import { sessionLogHeaderMarkdown, sessionLogTurnMarkdown, sessionLogEndMarkdown } from "./session-log-format.mjs";
 
 /** Where session logs live, relative to the target repo. `.tmct/` is the repo's
  *  one artifact directory (gitignored, machine-local) — flip this single constant
@@ -243,7 +244,7 @@ export async function createSession({
   const sessionsDir = join(repo, SESSIONS_DIR_REL);
   await mkdir(logDir, { recursive: true });
   await mkdir(sessionsDir, { recursive: true });
-  const logFile = join(logDir, `session-${sessionId}.log`);
+  const logFile = join(logDir, `session-${sessionId}.md`);
   const sidecarFile = join(sessionsDir, `session-${sessionId}.jsonl`);
   const stream = createWriteStream(logFile, { flags: "a" });
   const sidecar = createWriteStream(sidecarFile, { flags: "a" });
@@ -255,7 +256,7 @@ export async function createSession({
   const writeSidecar = (obj) => flush(sidecar, JSON.stringify(obj) + "\n");
 
   const startIso = new Date().toISOString();
-  await writeLog(`# tmct chat ${version} — session started ${startIso} — repo ${repo}\n\n`);
+  await writeLog(sessionLogHeaderMarkdown({ version, sessionId, startedAt: startIso, repo }));
   await writeSidecar({ type: "session", id: sessionId, started: startIso, repo, tmctVersion: version });
 
   // Read-time graph upsert (sessions.mjs): after every turn, the session becomes /
@@ -363,14 +364,14 @@ export async function createSession({
       } catch (e) {
         const ts = new Date().toISOString();
         const message = e instanceof Error ? e.message : String(e);
-        await writeLog(`${ts}\n> ${line}\nerror: ${message}\n`);
+        await writeLog(sessionLogTurnMarkdown({ startedAt: ts, turnNumber: turns + 1, query: line, answer: `error: ${message}` }));
         const errorRecord = { type: "error", ts, query: line, error: message };
         await writeSidecar(errorRecord);
         turnRecords.push(errorRecord);
         turns += 1;
         return { answer: `Something went wrong answering that (${message}). Try rephrasing, or /help.`, end: false, prompt: promptFor(focus) };
       }
-      const { answer, logLines, record, focus: nextFocus, last: nextLast, end, narrate: nextNarrate, liveReference: nextLiveReference } = result;
+      const { answer, record, focus: nextFocus, last: nextLast, end, narrate: nextNarrate, liveReference: nextLiveReference } = result;
       focus = nextFocus;
       last = nextLast;
       if ("planState" in result) planState = result.planState;
@@ -378,8 +379,10 @@ export async function createSession({
       // same way a focus update does — apply them to this handle's
       // session-scoped state.
       if (typeof nextNarrate === "boolean") narrateOn = nextNarrate;
-      if (typeof nextLiveReference === "boolean") liveReferenceOn = nextLiveReference;
-      await writeLog(logLines.join("\n") + "\n");
+      // tri-state: false (off), true (rescue on a miss), or "supplement" (also
+      // append a cited read-out under every grounded answer).
+      if (typeof nextLiveReference === "boolean" || nextLiveReference === "supplement") liveReferenceOn = nextLiveReference;
+      await writeLog(sessionLogTurnMarkdown({ startedAt: record.ts, turnNumber: turns + 1, query: line, answer }));
       await writeSidecar(record);
       turnRecords.push(record);
       // One telemetry line per dispatched turn (OFF by default → no-op). query.raw is
@@ -401,7 +404,9 @@ export async function createSession({
       if (closed) return;
       closed = true;
       const endIso = new Date().toISOString();
-      await writeLog(`${endIso}\n> /exit\nsession end ${endIso}\n`);
+      const closingTurnNumber = turns + 1;
+      await writeLog(sessionLogTurnMarkdown({ startedAt: endIso, turnNumber: closingTurnNumber, query: "/exit", answer: "" }));
+      await writeLog(sessionLogEndMarkdown({ endedAt: endIso, turnCount: closingTurnNumber }));
       await writeSidecar({ type: "end", ts: endIso });
       await upsertGraph(endIso);
       await new Promise((resolve) => stream.end(resolve));