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

package/src/surfaces/web/chat-browser-entry.mjs

@@ -30,6 +30,7 @@ import { vocabExampleHint } from "../../services/chat.mjs";
 import { createInMemoryStore, normFactTerm, loadMemory, readFactRows, applySeedPayload } from "../../adapters/memory/core.mjs";
 import { splitSentencesPreservingPaths } from "../../services/sentences.mjs";
 import { parseEntities } from "../../domain/codegraph.mjs";
+import { memoryFactGraphPayload } from "../../domain/memory-facts.mjs";
 import { loadLexicon } from "../../domain/grammar/lexicon.mjs";
 import { registerWinkModel } from "../../adapters/wink-model.mjs";
 import { setDigestStructures } from "../../adapters/corpus/digest-bank.mjs";
@@ -72,9 +73,14 @@ import { graphAsk, enginePlan } from "./engine-surface.mjs";
  * is module-scope, last write wins, and every session created after this one
  * shares it.
  *
- * Returns { memoryDir, sessionId, graph, turn }. `turn(line)` resolves to
- * { answer, end, record, plan } and threads focus/last/planState between
- * calls exactly as the CLI session does.
+ * Returns { memoryDir, sessionId, graph, codeGraph, refreshGraph, turn }.
+ * `turn(line)` resolves to { answer, end, record, plan } and threads
+ * focus/last/planState between calls exactly as the CLI session does.
+ *
+ * The two graphs are separate on purpose. `codeGraph` is the known-empty index
+ * the turn engine reads, and `graph` is this session's memory store projected
+ * for `ask()` — a question about taught facts has a real graph to traverse
+ * while a code-structure question keeps its honest no-code-graph refusal.
  */
 export function createChatSession({ seedPayload = null, vocabSeeded = false, liveReference = false, onLiveLookup = null, synthesisBudget = 12, digestStructures = null } = {}) {
   setDigestStructures(digestStructures || []);
@@ -82,10 +88,24 @@ export function createChatSession({ seedPayload = null, vocabSeeded = false, liv
   applySeedPayload(memoryDir, seedPayload);
 
   // A known-empty code graph: code-structure questions get the same honest
-  // no-code-graph answer an un-pointed CLI session gives, never a crash.
-  const graph = parseEntities({ individuals: [], objectProperties: [] });
+  // no-code-graph answer an un-pointed CLI session gives, never a crash. The
+  // turn engine keeps reading THIS one, so the identity-led greeting, the teach
+  // pointer and the zero module counts a page earns from an empty index all
+  // stay exactly as they were.
+  const codeGraph = parseEntities({ individuals: [], objectProperties: [] });
+
+  // What `tmct.ask()` traverses is a different graph: this session's own memory
+  // store, projected through memoryFactGraphPayload. Rebuilt on demand rather
+  // than once at open, because every teach, ingest and research turn grows the
+  // store — the same reason spider-fly rebuilds its board before each turn.
+  let memoryGraph = parseEntities({ individuals: [], objectProperties: [] });
+  async function refreshGraph() {
+    memoryGraph = parseEntities(memoryFactGraphPayload(readFactRows(await loadMemory(memoryDir))));
+    return memoryGraph;
+  }
+
   const lexicon = loadLexicon();
-  const vocabHint = vocabExampleHint(vocabSeeded);
+  const vocabHint = vocabExampleHint(vocabSeeded, "browser");
   const sessionId = globalThis.crypto?.randomUUID?.() ?? String(Date.now());
 
   // Four-state, like the CLI: false (off), true (rescue on a miss),
@@ -99,10 +119,10 @@ export function createChatSession({ seedPayload = null, vocabSeeded = false, liv
   let synthesisBudgetOn = Number.isFinite(synthesisBudget) ? synthesisBudget : 12;
 
   const session = createTurnSession({
-    memoryDir, graph, lexicon, sessionId, vocabHint,
+    memoryDir, graph: codeGraph, lexicon, sessionId, vocabHint,
     buildExtraOptions: () => ({
       liveReference: liveReferenceOn, onLiveLookup,
-      uiContext: "browser", synthesisBudget: synthesisBudgetOn,
+      synthesisBudget: synthesisBudgetOn,
     }),
     // `result.liveReference` mirrors a `/wiki on|off|supplement|always`
     // command back into this session's own toggle state.
@@ -114,7 +134,9 @@ export function createChatSession({ seedPayload = null, vocabSeeded = false, liv
   return {
     memoryDir,
     sessionId,
-    graph,
+    get graph() { return memoryGraph; },
+    codeGraph,
+    refreshGraph,
     get liveReference() { return liveReferenceOn; },
     /** The page's toggle seam: set the live Wikipedia mode for every later turn
      *  (the `/wiki on|off|supplement|always` command sets the same state). */
@@ -155,7 +177,12 @@ export async function researchedFactRows(memoryDir) {
 // and paste-ingest controls run.
 publishTmctSurface({
   open: createChatSession,
-  ask: graphAsk,
+  // The memory projection is rebuilt first, so a direct tmct.ask() sees every
+  // fact taught, pasted or researched since the last one.
+  ask: async (request, options, session) => {
+    await session.refreshGraph();
+    return graphAsk(request, options, session);
+  },
   plan: enginePlan,
   page: {
     registerWinkModel, registerReferencePackProvider, registerLiveReferenceProvider,

package/src/surfaces/web/code-explorer-browser-entry.mjs

@@ -53,7 +53,7 @@ export function createCodeExplorerSession({ graphPayload, seedPayload = null, vo
   // the write path recounts — teach turns must work on any seed.
   if (seedPayload) memoryDir.payload = { ...memoryDir.payload, ...seedPayload };
   const lexicon = loadLexicon();
-  const vocabHint = vocabExampleHint(vocabSeeded);
+  const vocabHint = vocabExampleHint(vocabSeeded, "browser");
   const sessionId = globalThis.crypto?.randomUUID?.() ?? String(Date.now());
   // A stable virtual path: the provider answers every fetch, so no file is
   // ever read, but the code lanes still do path math (join/dirname) on it.
@@ -233,8 +233,9 @@ export function askRelatedFacts(graphPayload, term) {
 // `tmct.page` keeps the re-derivation helpers a graph swapped through the
 // desktop picker re-renders with, plus the wink and term-normalizing seams the
 // chat shares with the ledger page. `createCodeExplorerSession` sits there
-// too: this page's client script is still one raw-text block, and it reaches
-// its factory through the bag rather than through `tmct.open()`.
+// too: the page keeps its own session slot, created lazily on the first turn
+// once the general-knowledge seed has landed, rather than the one `tmct.open`
+// would install eagerly — so it calls the factory straight from the bag.
 publishTmctSurface({
   open: createCodeExplorerSession,
   ask: graphAsk,

package/src/surfaces/web/ingest-browser-entry.mjs

@@ -29,16 +29,24 @@ import { splitSentencesPreservingPaths, stripCitationResidue } from "../../servi
 import { clauseCandidates, optimisticTriples } from "../../services/extract-facts.mjs";
 import { touchedFactRows } from "../../domain/memory/touched-facts.mjs";
 import { loadLexicon } from "../../domain/grammar/lexicon.mjs";
+import { parseEntities } from "../../domain/codegraph.mjs";
+import { ingestFactGraphPayload, ingestedFactRows } from "../../domain/ingest-facts.mjs";
 import { registerWinkModel, winkInstance } from "../../adapters/wink-model.mjs";
 import { memoryStats, exportFactsJsonl } from "./memory-stats.mjs";
 import { openPersistedStore } from "./idb-persist.mjs";
+import { createTurnSession } from "./turn-session.mjs";
 import { publishTmctSurface } from "./tmct-surface.mjs";
+import { graphAsk, enginePlan } from "./engine-surface.mjs";
 
 // The pronoun subjects a bounded carry substitutes with the last unique
 // grounded subject in the SAME paragraph. Reset at every blank line, so a
 // fresh paragraph never resolves against a stale antecedent.
 const PRONOUN_LEAD_RE = /^(?:they|it|these|those|this)\b\s*/i;
 
+// The turn kinds that move the fact store, so the projected graph a later
+// question traverses has to be rebuilt before it answers.
+const STORE_WRITING_TURNS = new Set(["assert", "retract"]);
+
 /**
  * The single recognizer seam. Splits `text` into paragraphs (blank-line
  * separated, so the pronoun carry never bridges a topic break) and each
@@ -171,35 +179,88 @@ export async function groundTextToFacts(text, { memoryDir, sessionId, lexicon, v
  * the page can then export. `seedPayload` (optional) pre-loads a graph the
  * recognizer can recall and link against.
  *
- * Returns { memoryDir, sessionId, ingest }. `ingest(text, { onFact,
- * optimistic })` is the one call the page makes; it drives groundTextToFacts
- * against this session's store and returns its { sentences, recognized,
- * skipped, facts } summary.
+ * Returns { memoryDir, sessionId, graph, refreshGraph, askableClasses, ingest,
+ * turn }. `ingest(text, { onFact, optimistic })` is the call the ingest panes
+ * make; it drives groundTextToFacts against this session's store and returns
+ * its { sentences, recognized, skipped, facts } summary. `turn(line)` is the
+ * ask dock's own entry point — the FULL chat turn engine (the exact dispatch
+ * the CLI runs) over the same store, so a question it can't ground gets the
+ * same refusal the CLI gives.
+ *
+ * `graph` is what a question actually traverses: the ingested rows projected
+ * through ingest-facts.mjs, rebuilt by `refreshGraph()` whenever the store has
+ * moved since the last one. The rebuild is gated on a dirty flag rather than
+ * run per call because a seeded store holds tens of thousands of rows, and
+ * re-reading all of them to answer a second question about the same two
+ * sentences is the one cost this page has to avoid.
  */
 export function createIngestSession({ seedPayload = null, vocabSeeded = false } = {}) {
   const memoryDir = createInMemoryStore();
   applySeedPayload(memoryDir, seedPayload);
 
   const lexicon = loadLexicon();
-  const vocabHint = vocabExampleHint(vocabSeeded);
+  const vocabHint = vocabExampleHint(vocabSeeded, "browser");
   const sessionId = globalThis.crypto?.randomUUID?.() ?? String(Date.now());
 
+  let graph = parseEntities({ individuals: [], objectProperties: [] });
+  let storeMovedSinceGraph = true;
+  async function refreshGraph() {
+    if (!storeMovedSinceGraph) return graph;
+    const rows = ingestedFactRows(readFactRows(await loadMemory(memoryDir)));
+    graph = parseEntities(ingestFactGraphPayload(rows));
+    storeMovedSinceGraph = false;
+    return graph;
+  }
+
+  // An empty graph is not the same as no graph to runTurn: a non-null one
+  // makes it read an ordinary "the number of X" phrase as a graph count query
+  // instead of running the teach cascade, so before anything is ingested the
+  // dock keeps the plain conversational reading.
+  const graphForTurn = () => (graph.individuals.length ? graph : null);
+
+  const turnSession = createTurnSession({
+    memoryDir, lexicon, sessionId, vocabHint,
+    buildExtraOptions: () => ({ graph: graphForTurn() }),
+    captureExtraState: (result) => {
+      if (STORE_WRITING_TURNS.has(result?.record?.via) && !result.record.miss) storeMovedSinceGraph = true;
+    },
+  });
+
   return {
     memoryDir,
     sessionId,
-    ingest(text, { onFact = null, optimistic = false } = {}) {
-      return groundTextToFacts(text, { memoryDir, sessionId, lexicon, vocabHint, onFact, optimistic });
+    get graph() { return graph; },
+    refreshGraph,
+    /** The class nouns this graph can actually list, for a page building its
+     *  own "try asking" hint out of real data rather than invented examples. */
+    askableClasses() {
+      return [...new Set(graph.individuals.map((i) => i.class).filter(Boolean))].sort();
+    },
+    async ingest(text, { onFact = null, optimistic = false } = {}) {
+      const summary = await groundTextToFacts(text, { memoryDir, sessionId, lexicon, vocabHint, onFact, optimistic });
+      if (summary.recognized) storeMovedSinceGraph = true;
+      return summary;
+    },
+    async turn(line) {
+      await refreshGraph();
+      return turnSession.turn(line);
     },
   };
 }
 
-// This page grounds pasted prose into facts; it holds no conversation, so
-// `tmct.turn` is unwired and says so, and the one call the page makes is
-// `tmct.session.ingest(text)`. `tmct.page` keeps the recognizer entry point
-// the page also drives directly, the wink seam, the stats fold behind its
-// counters, its IndexedDB wrapper and its JSONL export.
+// The page's own two calls are `tmct.session.ingest(text)` and, from the ask
+// dock, `tmct.turn(line)`. `tmct.ask` puts one question straight to the graph
+// this session projects from what it has ingested, rebuilding it first so a
+// fact grounded a moment ago is already visible. `tmct.page` keeps the
+// recognizer entry point the page also drives directly, the wink seam, the
+// stats fold behind its counters, its IndexedDB wrapper and its JSONL export.
 publishTmctSurface({
   open: createIngestSession,
+  ask: async (request, options, session) => {
+    await session.refreshGraph();
+    return graphAsk(request, options, session);
+  },
+  plan: enginePlan,
   page: {
     groundTextToFacts, exportFactsJsonl, registerWinkModel, normFactTerm,
     memoryStats, openPersistedStore,

package/src/surfaces/web/ledger-browser-entry.mjs

@@ -17,9 +17,10 @@
 // never published — only the hosted demo site's public/ledger.html links to
 // it, as an optional sibling script the page degrades honestly without.
 import { vocabExampleHint } from "../../services/chat.mjs";
-import { createInMemoryStore, normFactTerm, applySeedPayload } from "../../adapters/memory/core.mjs";
+import { createInMemoryStore, normFactTerm, applySeedPayload, loadMemory, readFactRows } from "../../adapters/memory/core.mjs";
 import { splitSentencesPreservingPaths } from "../../services/sentences.mjs";
 import { parseEntities } from "../../domain/codegraph.mjs";
+import { memoryFactGraphPayload } from "../../domain/memory-facts.mjs";
 import { loadLexicon } from "../../domain/grammar/lexicon.mjs";
 import { registerWinkModel } from "../../adapters/wink-model.mjs";
 import { registerResearchProvider } from "../../adapters/corpus/wikipedia-live.mjs";
@@ -37,7 +38,12 @@ import { graphAsk, enginePlan } from "./engine-surface.mjs";
  * a fact taught through the dock extends the SAME graph the page renders
  * from, never a disconnected one.
  *
- * Returns { memoryDir, sessionId, graph, turn }, identical to createChatSession.
+ * Returns { memoryDir, sessionId, graph, codeGraph, refreshGraph, turn },
+ * identical to createChatSession — including the two-graph split: `codeGraph`
+ * is the known-empty index the turn engine reads, and `graph` is the ledger's
+ * own store projected for `ask()`, so a question about the facts on the page
+ * traverses those facts while a code-structure question still refuses honestly.
+ *
  * ledger-viz.mjs's own inline script calls computeLedgerDataFromPayload
  * (re-exported below) on `memoryDir.payload` after a turn whose record shows
  * a successful write (`via: "assert"` or `via: "retract"`, `miss: false`) to
@@ -48,13 +54,27 @@ export function createLedgerSession({ seedPayload = null, vocabSeeded = false }
   const memoryDir = createInMemoryStore();
   applySeedPayload(memoryDir, seedPayload);
 
-  const graph = parseEntities({ individuals: [], objectProperties: [] });
+  const codeGraph = parseEntities({ individuals: [], objectProperties: [] });
+
+  let memoryGraph = parseEntities({ individuals: [], objectProperties: [] });
+  async function refreshGraph() {
+    memoryGraph = parseEntities(memoryFactGraphPayload(readFactRows(await loadMemory(memoryDir))));
+    return memoryGraph;
+  }
+
   const lexicon = loadLexicon();
-  const vocabHint = vocabExampleHint(vocabSeeded);
+  const vocabHint = vocabExampleHint(vocabSeeded, "browser");
   const sessionId = globalThis.crypto?.randomUUID?.() ?? String(Date.now());
 
-  const session = createTurnSession({ memoryDir, graph, lexicon, sessionId, vocabHint });
-  return { memoryDir, sessionId, graph, turn: session.turn };
+  const session = createTurnSession({ memoryDir, graph: codeGraph, lexicon, sessionId, vocabHint });
+  return {
+    memoryDir,
+    sessionId,
+    get graph() { return memoryGraph; },
+    codeGraph,
+    refreshGraph,
+    turn: session.turn,
+  };
 }
 
 // `tmct.page` keeps what the page's own script renders with and the engine has
@@ -64,7 +84,12 @@ export function createLedgerSession({ seedPayload = null, vocabSeeded = false }
 // paste-ingest and JSONL export.
 publishTmctSurface({
   open: createLedgerSession,
-  ask: graphAsk,
+  // The memory projection is rebuilt first, so a direct tmct.ask() sees every
+  // fact the dock or the ingest panel has taught since the last one.
+  ask: async (request, options, session) => {
+    await session.refreshGraph();
+    return graphAsk(request, options, session);
+  },
   plan: enginePlan,
   page: {
     computeLedgerDataFromPayload, normFactTerm, registerWinkModel, registerResearchProvider,