@polycode-projects/the-mechanical-code-talker 2.9.6 → 2.10.1

package/README.md

@@ -157,6 +157,32 @@ npx tmct chat --prompt 'disk-1 rests on disk-2. disk-2 rests on disk-3.
 
 More on the game file and the planner under "Teach it a game" below.
 
+### The code explorer (desktop)
+
+The same ledger UI, refocused on a code graph, also runs as a desktop app. It
+reads a `graph.json` (or a repo's `.tmct/` folder), shows every import, call and
+`contains` edge as a plain sentence around a focus symbol, and docks a live chat
+over the same graph. A hint rail suggests the next question from what the graph
+actually holds — "what does X import", "which functions call Y", "list
+functions" — so every suggestion resolves to a real answer.
+
+Electron is a dev-only dependency and never ships in the npm package. Because
+`.npmrc` sets `ignore-scripts=true`, installing it does not fetch the runtime
+binary; fetch it once, then build and launch:
+
+```bash skip=network
+npm i -D electron
+node node_modules/electron/install.js   # fetch the Electron binary (ignore-scripts skips this)
+npm run build:electron                  # render electron/renderer/ from the demo graph
+npm run electron                        # open the code explorer on the demo graph
+```
+
+Open a graph or a repo from the window's title bar to explore your own code.
+The UI is channel-agnostic — only the Electron shell (`electron/main.mjs` +
+`electron/preload.cjs`) is desktop-specific; the same page stays servable as a
+plain web page. `npm run test:electron` runs the shell smoke via Playwright and
+skips cleanly when the binary is absent.
+
 ## How it interprets you
 
 Every message runs through **multiple concurrent interpretation strategies**:
@@ -498,6 +524,13 @@ nudges you to ground one side first. Quantified teaching stores the
 quantifier ("some functions are risky" … "how many functions are risky" →
 "A few."), and "how many facts are there" counts the store back.
 
+The store answers about its own contents directly. "list facts" and "list
+utterances" enumerate what it holds; "how many sessions are there", "how many
+sources", and "how many rules" count the store's own book-keeping classes
+rather than the code graph. A taught class answers both shapes too: after
+"dog is a kind of animal", "how many animals are there" counts its members and
+"list all animals" reads them back, each cited to where it came from.
+
 Teaching doesn't have to be typed, either. `tmct extract` runs a plain text
 file through the same recognizer the chat's teach lane uses. Sentences the
 recognizer grounds become fact rows; everything else is skipped and counted,
@@ -616,6 +649,9 @@ Usage:
   tmct memory [--repo <abs>]   what tmct remembers: facts, utterances, sessions,
        [--config <path>]       folded blocks (the /memory chat command, from the shell)
        [--verbose]
+       [--export <file.jsonl>]  write every stored fact as JSONL (subject/predicate/object/
+                               provenance) to a file and exit — the shape `tmct extract`
+                               emits, for audit or backup
 ```
 
 `tmct init` sets up a repo for the first time: `.tmct/`, `tmct.toml`, a seed, and a
@@ -657,9 +693,10 @@ already set up. Its `--graph` flag works differently from the others: it appends
        [--ontology <name|path>]  DIFFERENT operation from the others: it APPENDS to
        [--lexicon <name|path>]  tmct.toml's graph_files array (multi-graph growth),
        [--graph <path>]        never an extensions-bundle activation.
-       [--file <definition.txt>]  teach a plain-text definition file sentence by
-                               sentence (# lines are comments); any declined
-                               sentence exits non-zero with the sentence named
+       [--file <defs.txt|facts.jsonl>]  teach a definition file: a .txt taught sentence by
+                               sentence (# lines are comments; a declined sentence exits
+                               non-zero, named), or a .jsonl triple dump loaded fact by
+                               fact, keeping each line's own provenance
        [--memory-backend <default|memory|sqlite>]  same knob as `tmct init`
        [--config <path>]
 ```
@@ -972,7 +1009,7 @@ loads a repo's graph into a `{ dispatch, resolve, graph }` context,
 
 ## The tool surface
 
-Everything above runs on the same 23 tools. Each one is read-only, answers one question in a single call, and returns bounded output. None of them calls a model. A tool that cannot ground an answer says so — the same honest miss you get everywhere else in tmct.
+Everything above runs on the same 24 tools. Each one is read-only, answers one question in a single call, and returns bounded output. None of them calls a model. A tool that cannot ground an answer says so — the same honest miss you get everywhere else in tmct.
 
 Three of them are **hot**: their schemas stay resident, so an agent driving tmct sees them every turn and reaches for one call instead of a Read/Grep loop.
 
@@ -1044,6 +1081,7 @@ The remaining tools are **cold**: still served, but not billed to an agent every
 | `tmct_calls` | The in-repo symbols a function calls (fn→fn), each with file:line. | `symbol` (required) |
 | `tmct_cochanges` | Modules that historically change in the same commit as a symbol's module (git co-change). | `symbol` (required) |
 | `tmct_context_more` | The bundle sections a lean tmct_context omitted (siblings / tests / cochange / class members / re-exports). | `symbol` (required) |
+| `tmct_export` | Every stored memory fact as JSONL (subject/predicate/object/provenance) — the shape `tmct extract` emits, for backup or audit. | none |
 
 Add `repo_path` to any of them to point at a repository other than the working directory. `tmct init` also writes this catalog, with a worked invocation per tool, to `.tmct/TOOLS.md` inside the repo it indexed.
 

package/bin/tmct.mjs

@@ -729,10 +729,11 @@ async function main() {
     // with every other subcommand. No `--graph`: memory reads no code graph.
     const rest = process.argv.slice(3);
     const verbose = rest.includes("--verbose") || rest.includes("-v");
-    const { resolveRuntimeConfig } = await import("../src/services/cli-args.mjs");
+    const { resolveRuntimeConfig, strFlag } = await import("../src/services/cli-args.mjs");
     const { renderMemory } = await import("../src/adapters/memory/inspect.mjs");
     const { loadMemory, openMemoryBackend } = await import("../src/adapters/memory/core.mjs");
     const { loadBlockIndex } = await import("../src/adapters/memory/blocks.mjs");
+    const exportPath = strFlag(rest, ["--export"]);
     const { repo, toml } = await resolveRuntimeConfig({ argv: rest });
     // Same backend resolution as chat's createSession, minus the (nonexistent
     // here) CLI-flag tier: env > tmct.toml > the sqlite default — so this verb
@@ -741,6 +742,20 @@ async function main() {
     const { dir: memoryDir, close: closeMemoryStore } = await openMemoryBackend(repo, backendChoice);
     try {
       const memory = await loadMemory(memoryDir);
+      // `--export <file.jsonl>` dumps every stored fact in the extract shape and
+      // exits — a backup/audit trail of the same store the tool layer and the
+      // browser pages serialize, one serializer for all three.
+      if (exportPath) {
+        const { serializeFactsJsonl } = await import("../src/adapters/memory/export-jsonl.mjs");
+        const { writeFile } = await import("node:fs/promises");
+        const { resolve } = await import("node:path");
+        const jsonl = serializeFactsJsonl(memory);
+        const out = resolve(process.cwd(), exportPath);
+        await writeFile(out, jsonl, "utf8");
+        const count = jsonl ? jsonl.trimEnd().split("\n").length : 0;
+        process.stderr.write(`wrote ${count} fact${count === 1 ? "" : "s"} to ${exportPath}\n`);
+        return;
+      }
       // The folded-block index is file-backed beside the session logs, not part
       // of the memory store — read it off the repo path directly.
       const blocks = await loadBlockIndex(repo);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polycode-projects/the-mechanical-code-talker",
-  "version": "2.9.6",
+  "version": "2.10.1",
   "private": false,
   "type": "module",
   "description": "The Mechanical Code Talker (tmct) — a tolerant, offline, $0 chat surface that guides you toward precision queries about a software repository. ELIZA/PARRY-style but domain-obsessed with code. No model calls; no codebase index of its own.",
@@ -139,6 +139,10 @@
     "build:spider-fly-bundle": "node scripts/build-spider-fly-bundle.mjs",
     "build:plan-bundle": "node scripts/build-plan-bundle.mjs",
     "build:ledger-bundle": "node scripts/build-ledger-bundle.mjs",
+    "build:code-explorer-bundle": "node scripts/build-code-explorer-bundle.mjs",
+    "build:electron": "node scripts/build-electron-app.mjs",
+    "electron": "electron electron/main.mjs",
+    "test:electron": "node --test electron/smoke.test.mjs",
     "build:sprites-bundle": "node scripts/build-sprites-bundle.mjs",
     "build:wink-vendor": "node scripts/build-wink-vendor.mjs",
     "build:chat-seed": "node scripts/build-chat-seed.mjs",
@@ -159,6 +163,7 @@
     "extract:facts": "node --disable-warning=ExperimentalWarning bin/tmct.mjs extract"
   },
   "devDependencies": {
+    "electron": "^43.2.0",
     "esbuild": "0.28.1",
     "ink-testing-library": "4.0.0",
     "playwright": "1.61.1",

package/src/adapters/memory/export-jsonl.mjs

@@ -0,0 +1,38 @@
+// export-jsonl.mjs — serialize a memory store's Facts to JSONL in the same
+// shape `tmct extract` emits: one JSON object per line, each carrying
+// { subject, predicate, object, provenance } (and `quantifier` when a plural
+// class-membership teach set one). Provenance is the store's own legacy compat
+// string, verbatim — so an exported line names where the fact came from, and a
+// re-import through the recognizer or a fact loader lands it back.
+//
+// Pure: no I/O. The CLI (`tmct memory --export`), the tool layer
+// (`tmct_export`) and the browser pages all read a loaded memory (or its fact
+// rows) and call one of these — one serializer, one shape, everywhere.
+
+import { readFactRows } from "./core.mjs";
+
+/** One export record from a readFactRows row — the fields a re-import needs,
+ *  and nothing the store computed internally (id, trust, justification). */
+export function factRowToExportRecord(row) {
+  const record = {
+    subject: row.subject,
+    predicate: row.predicate,
+    object: row.object,
+    provenance: row.provenance || "",
+  };
+  if (row.quantifier) record.quantifier = row.quantifier;
+  return record;
+}
+
+/** JSONL for an array of readFactRows rows — one object per line, a trailing
+ *  newline when there is at least one row, the empty string for none. */
+export function factRowsToJsonl(rows) {
+  const records = (rows || []).map(factRowToExportRecord);
+  return records.map((r) => JSON.stringify(r)).join("\n") + (records.length ? "\n" : "");
+}
+
+/** JSONL for a loaded memory (loadMemory's result, or a Backend-B payload) —
+ *  every stored Fact, in the extract shape. */
+export function serializeFactsJsonl(memory) {
+  return factRowsToJsonl(readFactRows(memory));
+}

package/src/domain/ask.mjs

@@ -4074,7 +4074,7 @@ const DYNAMIC_LIST_TRIGGER_RE = /^(?:list|show(?:\s+me)?)\s+(?:all\s+|the\s+)?([
 const DYNAMIC_COUNT_TRIGGER_RE = /^(?:how\s+many|number\s+of|count(?:\s+the)?)\s+([a-z][a-z'-]*)\s*(.*)$/i;
 // A closed set of harmless trailing fillers; anything else (a real
 // restrictor like "that mention X") is left alone.
-const DYNAMIC_TAIL_OK_RE = /^(?:are there(?:\s+in\s+total)?|is there|do you know(?:\s+about)?|do you have|exist(?:s)?|are known|in (?:the |a )?(?:graph|memory)|you know(?:\s+about)?)?[?.!\s]*$/i;
+export const DYNAMIC_TAIL_OK_RE = /^(?:are there(?:\s+in\s+total)?|is there|do you know(?:\s+about)?|do you have|exist(?:s)?|are known|in (?:the |a )?(?:graph|memory)|you know(?:\s+about)?)?[?.!\s]*$/i;
 
 /** Compile "list/how many <memory-class-noun>" into the same count/list AST
  *  every code-graph count/list query already builds, or null when this isn't

package/src/domain/cli-verbs.mjs

@@ -47,6 +47,7 @@ export const CLI_VERBS = [
     flags: [
       { flag: "[--config <path>]", prose: ["folded blocks (the /memory chat command, from the shell)"] },
       { flag: "[--verbose]", prose: [] },
+      { flag: "[--export <file.jsonl>]", prose: ["write every stored fact as JSONL (subject/predicate/object/", "provenance) to a file and exit — the shape `tmct extract`", "emits, for audit or backup"] },
     ],
   },
   {
@@ -77,7 +78,7 @@ export const CLI_VERBS = [
       { flag: "[--ontology <name|path>]", prose: ["DIFFERENT operation from the others: it APPENDS to"] },
       { flag: "[--lexicon <name|path>]", prose: ["tmct.toml's graph_files array (multi-graph growth),"] },
       { flag: "[--graph <path>]", prose: ["never an extensions-bundle activation."] },
-      { flag: "[--file <definition.txt>]", prose: ["teach a plain-text definition file sentence by", "sentence (# lines are comments); any declined", "sentence exits non-zero with the sentence named"] },
+      { flag: "[--file <defs.txt|facts.jsonl>]", prose: ["teach a definition file: a .txt taught sentence by", "sentence (# lines are comments; a declined sentence exits", "non-zero, named), or a .jsonl triple dump loaded fact by", "fact, keeping each line's own provenance"] },
       { flag: "[--memory-backend <default|memory|sqlite>]", prose: ["same knob as `tmct init`"] },
       { flag: "[--config <path>]", prose: [] },
     ],

package/src/domain/code-explorer-hints.mjs

@@ -0,0 +1,176 @@
+// code-explorer-hints.mjs — suggested next queries drawn from what a loaded
+// CODE graph actually holds. Pure over the entities payload (individuals +
+// objectProperties), so the desktop shell and any future plain page share one
+// tested generator and neither hand-writes prompt strings.
+//
+// The shapes are exactly the ones ask.mjs already answers, phrased from its own
+// closed vocabulary (ask-vocab.mjs's RELATIONS/EDGE_NOUN_TO_METRIC): a relation
+// only appears in a hint when the graph carries an edge of that kind, and a
+// focus symbol only fills a slot when it actually sits at that end of an edge —
+// so every suggestion resolves to a real answer, never a guess.
+
+import { RELATIONS, EDGE_NOUN_TO_METRIC } from "./ask-vocab.mjs";
+
+// Node classes this explorer reads as code, with the singular/plural nouns
+// ask.mjs's own list and count lanes accept (ENTITY_TO_TYPE's inverse). Schema
+// documentation individuals (SchemaClass/SchemaPredicate) and anything else are
+// left out — they are not what a reader explores.
+const CODE_CLASS_NOUN = Object.freeze({
+  Module: ["module", "modules"],
+  Class: ["class", "classes"],
+  Function: ["function", "functions"],
+  Method: ["method", "methods"],
+  Attribute: ["attribute", "attributes"],
+  GlobalVariable: ["variable", "variables"],
+  Commit: ["commit", "commits"],
+});
+
+// The classes a focus symbol is drawn from — the things a reader centres on.
+const FOCUSABLE_CLASSES = new Set(["Module", "Class", "Function", "Method"]);
+
+// Fine, symbol-grain predicates fold onto their coarse sibling for phrasing:
+// "what does X call" covers callsSymbol too, exactly as ask.mjs's
+// SYMBOL_GRAIN_SIBLING pairs them.
+const GRAIN_BASE = Object.freeze({ callsSymbol: "calls", touchesSymbol: "touches" });
+const baseKind = (predicate) => GRAIN_BASE[predicate] || predicate;
+
+// Forward reading (focus is the subject): "what does <focus> <bare>". The bare
+// verb form is ask-vocab's own, so the phrasing tracks the vocabulary.
+const FORWARD_TEMPLATE = Object.freeze({
+  imports: (f) => `what does ${f} import`,
+  calls: (f) => `what does ${f} call`,
+  contains: (f) => `what is in ${f}`,
+  defines: (f) => `what does ${f} define`,
+  inherits: (f) => `what does ${f} inherit from`,
+});
+
+// Reverse reading (focus is the object): "what <kind> <focus>".
+const REVERSE_TEMPLATE = Object.freeze({
+  imports: (f) => `what imports ${f}`,
+  calls: (f) => `what calls ${f}`,
+  tests: (f) => `what tests ${f}`,
+  inherits: (f) => `what inherits from ${f}`,
+  contains: (f) => `what contains ${f}`,
+});
+
+/** Index a payload into the counts and adjacency the hints read: class →
+ *  count, base relation kind → { count, subjects, objects }, and a label →
+ *  { class, degree } term table over every example edge. */
+function indexGraph(payload) {
+  const individuals = Array.isArray(payload?.individuals) ? payload.individuals : [];
+  const classOfLabel = new Map();
+  const classCounts = new Map();
+  for (const ind of individuals) {
+    if (!ind || !ind.label) continue;
+    if (CODE_CLASS_NOUN[ind.class]) classCounts.set(ind.class, (classCounts.get(ind.class) || 0) + 1);
+    if (!classOfLabel.has(ind.label)) classOfLabel.set(ind.label, ind.class);
+  }
+
+  const groups = Array.isArray(payload?.objectProperties) ? payload.objectProperties : [];
+  const kinds = new Map(); // base kind -> { count, subjects:Set, objects:Set }
+  const degree = new Map(); // label -> degree over example edges
+  const bumpKind = (k) => kinds.get(k) || kinds.set(k, { count: 0, subjects: new Set(), objects: new Set() }).get(k);
+  for (const g of groups) {
+    if (!g || !g.predicate) continue;
+    const k = baseKind(String(g.predicate));
+    const entry = bumpKind(k);
+    entry.count += Number(g.count) || (Array.isArray(g.examples) ? g.examples.length : 0);
+    for (const e of Array.isArray(g.examples) ? g.examples : []) {
+      const s = e?.subjectLabel || e?.subject;
+      const o = e?.objectLabel || e?.object;
+      if (s) { entry.subjects.add(s); degree.set(s, (degree.get(s) || 0) + 1); }
+      if (o) { entry.objects.add(o); degree.set(o, (degree.get(o) || 0) + 1); }
+    }
+  }
+  return { classCounts, classOfLabel, kinds, degree };
+}
+
+/** Pick the focus symbol: the caller's choice when it is a real term, else the
+ *  highest-degree focusable-class label, else the highest-degree label at all,
+ *  else null. Ties break on label for determinism. */
+function pickFocus(index, requested) {
+  if (requested && index.degree.has(requested)) return requested;
+  const ranked = [...index.degree.entries()]
+    .sort((a, b) => b[1] - a[1] || String(a[0]).localeCompare(String(b[0])));
+  const focusable = ranked.find(([label]) => FOCUSABLE_CLASSES.has(index.classOfLabel.get(label)));
+  if (focusable) return focusable[0];
+  return ranked.length ? ranked[0][0] : null;
+}
+
+/**
+ * Suggested queries for a loaded code graph.
+ *
+ * @param {object} payload  the entities payload (individuals + objectProperties).
+ * @param {object} [opts]
+ * @param {string} [opts.focus]  centre the neighbourhood on this symbol.
+ * @param {number} [opts.limit]  cap the returned hints (default 12).
+ * @returns {{ focus: (string|null), hints: Array<{text,group,rationale}> }}
+ *          `hints` is ordered neighbourhood → compositional → explore; empty
+ *          when the graph holds nothing to explore.
+ */
+export function generateCodeHints(payload, { focus: requestedFocus = null, limit = 12 } = {}) {
+  const index = indexGraph(payload);
+  const focus = pickFocus(index, requestedFocus);
+  const hints = [];
+  const add = (text, group, rationale) => hints.push({ text, group, rationale });
+  const kindPresent = (k) => (index.kinds.get(k)?.count || 0) > 0;
+
+  if (focus) {
+    for (const [kind, template] of Object.entries(FORWARD_TEMPLATE)) {
+      if (index.kinds.get(kind)?.subjects.has(focus)) {
+        add(template(focus), "neighbourhood", `${focus} ${verbBare(kind)} other symbols in this graph`);
+      }
+    }
+    for (const [kind, template] of Object.entries(REVERSE_TEMPLATE)) {
+      if (index.kinds.get(kind)?.objects.has(focus)) {
+        add(template(focus), "neighbourhood", `other symbols ${kind} ${focus}`);
+      }
+    }
+  }
+
+  // Compositional shapes over the graph's own edges and classes.
+  const calls = index.kinds.get("calls");
+  if (calls && index.classCounts.has("Function") && calls.objects.size) {
+    const target = [...calls.objects].sort()[0];
+    add(`which functions call ${target}`, "compositional", `${target} is called somewhere in this graph`);
+  }
+  const contains = index.kinds.get("contains");
+  if (contains && index.classCounts.has("Method")) {
+    const owner = [...contains.subjects].sort().find((s) => index.classOfLabel.get(s) === "Class");
+    if (owner) add(`public methods of ${owner}`, "compositional", `${owner} contains members`);
+  }
+
+  // Explore-the-whole-graph shapes. The rankings and the coverage filter come
+  // first — they are the more useful whole-graph questions — then a list and a
+  // count per present class. EDGE_NOUN_TO_METRIC names the nouns ask.mjs's
+  // superlative lane accepts, so a hint only offers a ranking the graph can
+  // actually compute.
+  const superlatives = [
+    { noun: "imports", entity: "module", filter: "Module" },
+    { noun: "callers", entity: "function", filter: "Function" },
+  ];
+  for (const s of superlatives) {
+    const metric = EDGE_NOUN_TO_METRIC[s.noun];
+    if (metric && kindPresent(metric.kind) && index.classCounts.has(s.filter)) {
+      add(`which ${s.entity} has the most ${s.noun}`, "explore", `rank ${s.entity}s by ${s.noun}`);
+    }
+  }
+  if (kindPresent("tests")) {
+    add("which of those are tested", "explore", "filter a listing by test coverage");
+  }
+  const classesByCount = [...index.classCounts.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]));
+  for (const [cls, count] of classesByCount) {
+    const [, plural] = CODE_CLASS_NOUN[cls];
+    add(`list ${plural}`, "explore", `${count} ${plural} in this graph`);
+    add(`how many ${plural}`, "explore", `count the ${plural}`);
+  }
+
+  return { focus, hints: hints.slice(0, limit) };
+}
+
+// The infinitive ask-vocab curates for each relation, used in rationales.
+function verbBare(kind) {
+  return RELATIONS[kind]?.bare || kind;
+}
+
+export { CODE_CLASS_NOUN, indexGraph };

package/src/services/adventure-viz.mjs

@@ -430,13 +430,19 @@ ${THEME_TOKENS_CSS}
   .stage { display: grid; grid-template-columns: minmax(0, 1fr) 280px; gap: 1rem; align-items: start; }
   @media (max-width: 760px) { .stage { grid-template-columns: 1fr; } }
 
+  /* the left column: quest and satchel as full-width strips above the room,
+     the room itself, then the reset/play/step/turn strip pinned directly
+     below it — everything in this column shares the room's own width, so
+     the column's total height tracks the side column instead of leaving a
+     gap under a lone, short room panel. */
+  .stage-left { display: flex; flex-direction: column; gap: 1rem; min-width: 0; }
+
   /* the room view — a 90s-RPG interior cutaway, all CSS gradients, no
      external asset: a striped papered wall over a gilt dado rail over a
      diagonal-plank floor, framed by the same ornate double rule as before.
      The sprite tiles sit on the floor band (align-items flex-end), so
      furniture and people read as standing IN the room, against its wall,
      rather than floating in a chip strip. */
-  #playStage .room-frame { align-self: start; position: sticky; top: 1rem; }
   .room-frame {
     position: relative; min-height: 250px;
     background:
@@ -557,7 +563,7 @@ ${THEME_TOKENS_CSS}
   .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; }
   .chatask input:disabled { opacity: .5; }
-  .controls-row { display: flex; align-items: center; gap: .6rem; margin-top: 1rem; flex-wrap: wrap; }
+  .controls-row { display: flex; align-items: center; gap: .6rem; flex-wrap: wrap; }
   .controls-row button { font-family: ${MONO_STACK}; font-size: .72rem; letter-spacing: .05em; text-transform: uppercase; padding: .38rem .85rem; border: 1px solid var(--gilt); background: var(--parchment); color: var(--ink); }
   .controls-row button:hover:not(:disabled) { background: var(--parchment-strong); }
   .controls-row button:disabled { opacity: .4; cursor: default; }
@@ -567,7 +573,7 @@ ${THEME_TOKENS_CSS}
 
   /* edit mode */
   body:not(.editing) #editStage { display: none; }
-  body.editing #playStage, body.editing #playControls { display: none; }
+  body.editing #playStage { display: none; }
   /* .stage's inherited align-items: start (kept for #playStage's own fixed-
      size room panel) would otherwise top-align .edittext against the
      manor-map/room-detail/legend column and leave a dead gap below the
@@ -583,7 +589,7 @@ ${THEME_TOKENS_CSS}
   .roomdetail .sprite-row { min-height: 3.2rem; }
   #legendList { display: flex; flex-wrap: wrap; gap: .5rem .3rem; }
 
-  body.preview .side, body.preview .controls-row, body.preview .status { display: none; }
+  body.preview .side, body.preview .stage-left > .panel, body.preview .controls-row, body.preview .status { display: none; }
   body.preview main { padding: 0; max-width: none; }
   body.preview .stage { display: block; }
   body.preview .eyebrow, body.preview h1, body.preview .mode-toggle, body.preview #editStage { display: none; }
@@ -597,9 +603,25 @@ ${THEME_TOKENS_CSS}
     <button id="editModeBtn" type="button" class="mode-toggle" disabled>edit the world</button>
   </div>
   <div class="stage" id="playStage">
-    <div class="room-frame" id="roomFrame">
-      <div class="room-plaque mono" id="roomName"></div>
-      <div class="sprite-row" id="spriteRow"></div>
+    <div class="stage-left">
+      <div class="panel goals">
+        <h2>quest</h2>
+        <div id="goalList"></div>
+      </div>
+      <div class="panel carrying">
+        <h2>satchel</h2>
+        <div class="chips" id="carryList"></div>
+      </div>
+      <div class="room-frame" id="roomFrame">
+        <div class="room-plaque mono" id="roomName"></div>
+        <div class="sprite-row" id="spriteRow"></div>
+      </div>
+      <div class="controls-row" id="playControls">
+        <button id="resetBtn" type="button" disabled>reset</button>
+        <button id="playBtn" type="button" disabled>&#9654; play</button>
+        <button id="stepBtn" type="button" disabled>step</button>
+        <span class="turn mono" id="turnLabel">turn: 0</span>
+      </div>
     </div>
     <aside class="side" aria-label="The adventure's log and chat">
       <div class="chat">
@@ -612,18 +634,10 @@ ${THEME_TOKENS_CSS}
           <input id="chatq" type="text" placeholder="go north" aria-label="Type a command, or ask a question" disabled>
         </form>
       </div>
-      <div class="panel carrying">
-        <h2>satchel</h2>
-        <div class="chips" id="carryList"></div>
-      </div>
       <div class="panel roommap">
         <h2>the manor, so far</h2>
         <div class="map-viewport"><div id="mapWrap"></div></div>
       </div>
-      <div class="panel goals">
-        <h2>quest</h2>
-        <div id="goalList"></div>
-      </div>
     </aside>
   </div>
 
@@ -652,12 +666,6 @@ ${THEME_TOKENS_CSS}
   </div>
 
   <div class="goal-line" id="goalLine"></div>
-  <div class="controls-row" id="playControls">
-    <button id="resetBtn" type="button" disabled>reset</button>
-    <button id="playBtn" type="button" disabled>&#9654; play</button>
-    <button id="stepBtn" type="button" disabled>step</button>
-    <span class="turn mono" id="turnLabel">turn: 0</span>
-  </div>
   <div class="status" id="status">loading the engine&hellip;</div>
 </main>
 <script>

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

@@ -311,7 +311,9 @@ ${THEME_TOKENS_CSS}
         </label>
         <span class="tool-cluster">
           <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>
+          <button type="button" id="reinitStore" class="tool-btn" title="drop everything saved on this device and reload from the shipped seed">reset to seed</button>
         </span>
       </div>
     </form>
@@ -802,6 +804,42 @@ ${THEME_TOKENS_CSS}
   });
   el("printChat").addEventListener("click", () => window.print());
 
+  // ---- store controls: export the triple store, or reset it whole ----------
+  // "export facts" downloads the session's whole memory as JSONL (the same
+  // subject/predicate/object/provenance shape the extract and memory-export
+  // CLI paths emit), so what you taught leaves in the standard shape.
+  el("exportFacts").addEventListener("click", async () => {
+    const session = window.tmctChatSession;
+    if (!session || !window.tmctChat.exportFactsJsonl) return;
+    let jsonl;
+    try {
+      jsonl = await window.tmctChat.exportFactsJsonl(session.memoryDir);
+    } catch (err) {
+      statusEl.textContent = "couldn't export the facts (" + (err && err.message ? err.message : err) + ")";
+      return;
+    }
+    const blob = new Blob([jsonl], { type: "application/x-ndjson" });
+    const url = URL.createObjectURL(blob);
+    const link = document.createElement("a");
+    link.href = url;
+    link.download = "tmct-facts.jsonl";
+    document.body.appendChild(link);
+    link.click();
+    link.remove();
+    setTimeout(() => URL.revokeObjectURL(url), 1000);
+  });
+
+  // "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
+  // session — this trusts nothing in memory and re-fetches the seed asset.
+  el("reinitStore").addEventListener("click", async () => {
+    clearTimeout(saveTimer);
+    saveTimer = null;
+    if (persist) await persist.clear();
+    window.location.reload();
+  });
+
   async function boot() {
     if (!window.tmctChat) {
       statusEl.textContent = "the chat engine didn't load \\u2014 this page needs its build step (npm run demo:build)";
@@ -836,7 +874,7 @@ ${THEME_TOKENS_CSS}
     addSystemLine("tmct \\u2014 the real engine, running in this page \\u2014 " + statsSummaryLine(stats)
       + "." + restoredNote + " Ask it something, or teach it a fact of your own.");
     await renderStatsPanel(stats);
-    inputEl.placeholder = seedPayload ? 'try "what is a dog"' : window.tmctChat.vocabExampleHint(false);
+    inputEl.placeholder = seedPayload ? 'try "what is a dog" or "list facts"' : window.tmctChat.vocabExampleHint(false);
     renderStatus();
     setBusy(false);
     inputEl.focus();