@polycode-projects/the-mechanical-code-talker 3.0.5 → 3.0.6

package/data/templates/constructions/digest-sentence-structures.toml

@@ -10,19 +10,30 @@
 # reads only [[relation]] and [[construction]] tables, so it ignores this file's
 # [[structure]] rows; the digest layer reads them through its own path.
 #
-# Each row is one (family, form) pairing:
+# Each row is one wording for a (family, form) pairing. A key may hold several
+# rows: the renderer collects them all and picks one by a deterministic hash of
+# term|family|form|variantSeed, so a key with one wording always renders that
+# wording, while a key with several gives natural variety that stays stable
+# across runs. An exact-string duplicate under a key is folded; a second, truly
+# different wording is kept as another variant.
 #   family  one of the digest families (isa | location | partOf | capableOf |
 #           usedFor) — the closed set stage 1 groups predicates under. Each is
 #           verb-coherent: every predicate in it shares this frame's verb.
 #   form    single   — one fact of the family
 #           several  — two or more facts of the family, merged into one clause
 #           chained  — one isa fact plus its rendered ancestry chain
+#           group    — one body sentence of the multi-sentence isa digest: the
+#                      facts that share an immediate parent class, named together
+#           closer   — the closing sentence of the multi-sentence isa digest:
+#                      the highest-level ontology roots the term sits under
 #   template  the skeleton. Placeholders the renderer fills (words.mjs supplies
 #             the article, plural and casing):
 #               {TERM} {TERM_CAP}          the term, lower / sentence-leading
 #               {A_TERM} {A_TERM_CAP}      "an aardvark" / "An aardvark"
 #               {TERMS} {TERMS_CAP}        "aardvarks" / "Aardvarks"
 #               {PRONOUN} {PRONOUN_CAP}    "it" / "It" (after first mention)
+#               {PARENT} {A_PARENT}        the shared immediate parent of a group
+#                                          — "mammal" / "a mammal"
 #               {OBJECT}                   the first object, raw
 #               {A_OBJECT}                 "a mammal" (article chosen per word)
 #               {OBJECTS_A}                "a mammal, a burrowing animal, and …"
@@ -48,6 +59,50 @@ family = "isa"
 form = "chained"
 template = "{A_TERM_CAP} is {CHAIN}."
 
+# ---- isa group: one body sentence for facts under a shared parent class -----
+
+[[structure]]
+family = "isa"
+form = "group"
+template = "As a kind of {PARENT}, {PRONOUN} is also {OBJECTS_A}."
+
+[[structure]]
+family = "isa"
+form = "group"
+template = "Being {A_PARENT}, {PRONOUN} is {OBJECTS_A} too."
+
+[[structure]]
+family = "isa"
+form = "group"
+template = "Within the {PARENT} family, {PRONOUN} counts as {OBJECTS_A}."
+
+[[structure]]
+family = "isa"
+form = "group"
+template = "As {A_PARENT}, {PRONOUN} is {OBJECTS_A}."
+
+# ---- isa closer: the highest-level roots the term sits under ----------------
+
+[[structure]]
+family = "isa"
+form = "closer"
+template = "More broadly, {TERMS} sit within {OBJECTS_A} in the wider hierarchy."
+
+[[structure]]
+family = "isa"
+form = "closer"
+template = "More generally, {TERMS} fall under {OBJECTS_A}."
+
+[[structure]]
+family = "isa"
+form = "closer"
+template = "Higher up, {TERMS} are kinds of {OBJECTS_PLURAL}."
+
+[[structure]]
+family = "isa"
+form = "closer"
+template = "Zooming out, {TERMS} belong among {OBJECTS_PLURAL}."
+
 # ---- location: where it is found (atLocation / locatedNear) ----------------
 
 [[structure]]
@@ -60,6 +115,21 @@ family = "location"
 form = "several"
 template = "{PRONOUN_CAP} is found in {OBJECTS_RAW}."
 
+[[structure]]
+family = "location"
+form = "several"
+template = "{PRONOUN_CAP} lives in {OBJECTS_RAW}."
+
+[[structure]]
+family = "location"
+form = "several"
+template = "You'll find {PRONOUN} in {OBJECTS_RAW}."
+
+[[structure]]
+family = "location"
+form = "several"
+template = "{PRONOUN_CAP} turns up in {OBJECTS_RAW}."
+
 # ---- partOf: what it belongs to -------------------------------------------
 
 [[structure]]
@@ -67,11 +137,41 @@ family = "partOf"
 form = "single"
 template = "{PRONOUN_CAP} is part of {A_OBJECT}."
 
+[[structure]]
+family = "partOf"
+form = "single"
+template = "{PRONOUN_CAP} belongs to {A_OBJECT}."
+
+[[structure]]
+family = "partOf"
+form = "single"
+template = "{PRONOUN_CAP} forms part of {A_OBJECT}."
+
+[[structure]]
+family = "partOf"
+form = "single"
+template = "{PRONOUN_CAP} makes up part of {A_OBJECT}."
+
 [[structure]]
 family = "partOf"
 form = "several"
 template = "{PRONOUN_CAP} is part of {OBJECTS_A}."
 
+[[structure]]
+family = "partOf"
+form = "several"
+template = "{PRONOUN_CAP} belongs to {OBJECTS_A}."
+
+[[structure]]
+family = "partOf"
+form = "several"
+template = "{PRONOUN_CAP} forms part of {OBJECTS_A}."
+
+[[structure]]
+family = "partOf"
+form = "several"
+template = "{PRONOUN_CAP} is one part of {OBJECTS_A}."
+
 # ---- capableOf: what it can do --------------------------------------------
 
 [[structure]]
@@ -84,6 +184,21 @@ family = "capableOf"
 form = "several"
 template = "{PRONOUN_CAP} can {OBJECTS_RAW}."
 
+[[structure]]
+family = "capableOf"
+form = "several"
+template = "{PRONOUN_CAP} is able to {OBJECTS_RAW}."
+
+[[structure]]
+family = "capableOf"
+form = "several"
+template = "{PRONOUN_CAP} knows how to {OBJECTS_RAW}."
+
+[[structure]]
+family = "capableOf"
+form = "several"
+template = "{PRONOUN_CAP} tends to {OBJECTS_RAW}."
+
 # ---- usedFor: what it is used for -----------------------------------------
 
 [[structure]]
@@ -91,7 +206,37 @@ family = "usedFor"
 form = "single"
 template = "{PRONOUN_CAP} is used for {OBJECT}."
 
+[[structure]]
+family = "usedFor"
+form = "single"
+template = "{PRONOUN_CAP} helps with {OBJECT}."
+
+[[structure]]
+family = "usedFor"
+form = "single"
+template = "People use {PRONOUN} for {OBJECT}."
+
+[[structure]]
+family = "usedFor"
+form = "single"
+template = "{PRONOUN_CAP} works for {OBJECT}."
+
 [[structure]]
 family = "usedFor"
 form = "several"
 template = "{PRONOUN_CAP} is used for {OBJECTS_RAW}."
+
+[[structure]]
+family = "usedFor"
+form = "several"
+template = "{PRONOUN_CAP} helps with {OBJECTS_RAW}."
+
+[[structure]]
+family = "usedFor"
+form = "several"
+template = "People use {PRONOUN} for {OBJECTS_RAW}."
+
+[[structure]]
+family = "usedFor"
+form = "several"
+template = "{PRONOUN_CAP} works for {OBJECTS_RAW}."

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polycode-projects/the-mechanical-code-talker",
-  "version": "3.0.5",
+  "version": "3.0.6",
   "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; indexes a repo on request (tmct index) or reads any producer's graph.",

package/src/adapters/corpus/digest-bank.mjs

@@ -5,9 +5,15 @@
 // in src/domain/digest; only the TOML read lives here, so every node surface
 // (chat, `tmct digest`, the page generators) shares one seam.
 //
-// A browser bundle stubs this module out (the ask/chat dock never digests
-// in-page — the pages digest client-side from a table embedded at build time),
-// so every consumer treats a null article as "fall back to the flat fact list".
+// build-chat-bundle.mjs swaps this module for a live in-memory twin (the
+// chat dock DOES digest in-page there — chat-browser-entry.mjs feeds it the
+// build-time-embedded [[structure]] rows via setDigestStructures); every
+// other browser bundle (ask, ledger's static render) still stubs it out to
+// null, so those consumers keep treating a null article as "fall back to the
+// flat fact list". setDigestStructures below is a no-op on THIS, the real
+// node-side module — kept only for interface parity with the live bundle
+// twin, so a file that imports both under plain Node (as a chat-engine
+// contract test does) resolves the same export set either way.
 
 import { readFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
@@ -19,6 +25,12 @@ import { digestStoreStats, chainsForObjects, isaObjectsOf } from "../../domain/d
 const HERE = dirname(fileURLToPath(import.meta.url));
 const BANK_FILE = join(HERE, "..", "..", "..", "data", "templates", "constructions", "digest-sentence-structures.toml");
 
+/** No-op here — the node-side adapter always reads its structures from the
+ *  committed TOML bank (below), never from an externally-supplied table. Only
+ *  the browser bundle's live twin (build-chat-bundle.mjs's stub) actually
+ *  holds state behind this setter. */
+export function setDigestStructures() {}
+
 /** The raw [[structure]] rows parsed from the committed bank, once. A missing or
  *  unparseable bank yields an empty list — the digest degrades to the caller's
  *  flat fallback rather than throwing, the same posture the construction-bank

package/src/domain/digest/compose.mjs

@@ -8,6 +8,7 @@
 import { renderStructure } from "./structures.mjs";
 import { FAMILY_PRIORITY } from "./select.mjs";
 import { articleFor, capitalizeFirst } from "./words.mjs";
+import DEFAULT_CONFIG from "./config.json" with { type: "json" };
 
 const DESCRIPTION_FAMILIES = FAMILY_PRIORITY.filter((f) => f !== "isa" && f !== "other");
 
@@ -22,6 +23,137 @@ function rowsByFamily(selected) {
   return by;
 }
 
+/** Split `rows` into runs of at most `size`, keeping order. Never returns an
+ *  empty run; a size below 1 is treated as 1. */
+export function chunk(rows, size) {
+  const n = Math.max(1, Math.trunc(size) || 1);
+  const out = [];
+  for (let i = 0; i < (rows || []).length; i += n) out.push(rows.slice(i, i + n));
+  return out;
+}
+
+/** Bucket isa rows by their object's immediate ancestor (`chains[object][1]`),
+ *  so facts that share a parent class can be named in one coherent sentence.
+ *  A parent with two or more rows is a real group; a parent with only one row,
+ *  and any row whose object has no recorded ancestry, fold into one shared
+ *  leftover pool. Groups come first in the order their earliest member ranked;
+ *  the leftover pool, in rank order, comes last. Returns
+ *  `[{ parent, rows }, …]` where `parent` is null for the leftover pool. */
+export function groupIsaByParent(rows, chains) {
+  const parentOf = (row) => (chains?.[row.object] || [])[1] || null;
+  const counts = new Map();
+  for (const row of rows || []) {
+    const p = parentOf(row);
+    if (p) counts.set(p, (counts.get(p) || 0) + 1);
+  }
+  const groupRows = new Map();
+  const order = [];
+  const leftover = [];
+  for (const row of rows || []) {
+    const p = parentOf(row);
+    if (p && counts.get(p) >= 2) {
+      if (!groupRows.has(p)) { groupRows.set(p, []); order.push(p); }
+      groupRows.get(p).push(row);
+    } else {
+      leftover.push(row);
+    }
+  }
+  const groups = order.map((parent) => ({ parent, rows: groupRows.get(parent) }));
+  if (leftover.length) groups.push({ parent: null, rows: leftover });
+  return groups;
+}
+
+/** The highest-level ontology roots the spoken isa objects reach: for each row,
+ *  the last (most general) node its ancestry chain walked. Roots rank by how
+ *  many chains reach them (ties broken alphabetically for determinism); the top
+ *  `count` are kept. Returns `{ roots, rows }` — `roots` names the concepts a
+ *  closer sentence renders, `rows` are the real backing isa facts so the closer
+ *  keeps its provenance without ever synthesising a row. */
+export function closerRootsFor(chains, usedRows, count) {
+  const rootCount = new Map();
+  const rootRows = new Map();
+  for (const row of usedRows || []) {
+    const chain = chains?.[row.object];
+    if (!Array.isArray(chain) || chain.length < 2) continue;
+    const root = chain[chain.length - 1];
+    if (!root || root === row.object) continue;
+    rootCount.set(root, (rootCount.get(root) || 0) + 1);
+    if (!rootRows.has(root)) rootRows.set(root, []);
+    rootRows.get(root).push(row);
+  }
+  const roots = [...rootCount.keys()]
+    .sort((a, b) => (rootCount.get(b) - rootCount.get(a)) || a.localeCompare(b))
+    .slice(0, Math.max(0, count));
+  const rows = [];
+  const seen = new Set();
+  for (const root of roots) for (const r of rootRows.get(root) || []) {
+    if (!seen.has(r.id)) { seen.add(r.id); rows.push(r); }
+  }
+  return { roots, rows };
+}
+
+/** Compose the isa (definition) sentences. Gated purely on how many isa facts
+ *  survived selection: none says nothing; one renders the single or chained
+ *  form; a handful (up to the split threshold) merges into one clause. Past the
+ *  threshold the run-on breaks apart — an opener names the top concepts, body
+ *  sentences group the rest by shared parent, and a closer names the roots they
+ *  all sit under. Returns tagged sentence objects, or an empty list. */
+function composeIsaSection(isaRows, chains, term, table, config) {
+  const out = [];
+  if (!isaRows.length) return out;
+
+  if (isaRows.length === 1) {
+    const chain = chains[isaRows[0].object];
+    const form = chain && chain.length > 1 ? "chained" : "single";
+    const s = renderStructure(table, "isa", isaRows, { term, form, chain });
+    if (s) out.push({ ...s, role: "names-term", paragraph: "definition" });
+    return out;
+  }
+
+  if (isaRows.length <= config.groupSplitThreshold) {
+    const s = renderStructure(table, "isa", isaRows, { term, form: "several" });
+    if (s) out.push({ ...s, role: "names-term", paragraph: "definition" });
+    return out;
+  }
+
+  const openerRows = isaRows.slice(0, config.openerConceptCount);
+  const restRows = isaRows.slice(config.openerConceptCount);
+  const opener = renderStructure(table, "isa", openerRows, {
+    term, form: openerRows.length > 1 ? "several" : "single", variantSeed: term,
+  });
+  if (opener) out.push({ ...opener, role: "names-term", paragraph: "definition" });
+
+  let units = [];
+  for (const g of groupIsaByParent(restRows, chains)) {
+    for (const c of chunk(g.rows, config.maxObjectsPerBodySentence)) units.push({ parent: g.parent, rows: c });
+  }
+  // Cap the sentence count. Overflow folds into the last sentence rather than
+  // drop a selected fact — the merged sentence loses its single-parent coherence,
+  // so it renders as a plain "several" clause.
+  if (units.length > config.maxBodySentences) {
+    const kept = units.slice(0, config.maxBodySentences);
+    const last = kept[kept.length - 1];
+    for (const o of units.slice(config.maxBodySentences)) last.rows = last.rows.concat(o.rows);
+    last.parent = null;
+    units = kept;
+  }
+  for (const u of units) {
+    const s = u.parent
+      ? renderStructure(table, "isa", u.rows, { term, form: "group", parent: u.parent, variantSeed: u.parent })
+      : renderStructure(table, "isa", u.rows, { term, form: "several", variantSeed: term });
+    if (s) out.push({ ...s, role: "describes-isa", paragraph: "definition" });
+  }
+
+  const { roots, rows: closerRows } = closerRootsFor(chains, isaRows, config.closerRootCount);
+  if (roots.length) {
+    const s = renderStructure(table, "isa", closerRows.length ? closerRows : isaRows, {
+      term, form: "closer", objectsOverride: roots, variantSeed: term,
+    });
+    if (s) out.push({ ...s, role: "closes-isa", paragraph: "definition" });
+  }
+  return out;
+}
+
 /** The first sentence must introduce the term. When no isa fact led (so the
  *  first sentence opens with a bare "It"), rewrite that pronoun into the term's
  *  own noun phrase so the pronoun has an antecedent. */
@@ -59,8 +191,11 @@ function paragraphsFrom(sentences, cap) {
  *
  * opts:
  *   - chains: { object -> [object, parent, …] } ancestry chains, so a lone isa
- *     fact can render as a chain ("a mammal, and so an animal") when one exists.
+ *     fact can render as a chain ("a mammal, and so an animal") when one exists,
+ *     and a many-fact term can split into opener, grouped body and closer.
  *   - maxSentencesPerParagraph: the sentence cap (default 3).
+ *   - config: digest tuning overrides (the group split threshold and the
+ *     per-sentence / per-digest caps), defaulting to config.json.
  *
  * Returns { term, sentences, paragraphs, provenanceRows }. Every sentence in
  * `sentences` carries { text, rows, family, role, paragraph }; `paragraphs`
@@ -71,22 +206,19 @@ export function composeTermDigest(selection, table, opts = {}) {
   const term = selection?.term || "";
   const cap = Number.isInteger(opts.maxSentencesPerParagraph) ? opts.maxSentencesPerParagraph : 3;
   const chains = opts.chains || {};
+  const config = { ...DEFAULT_CONFIG, ...(opts.config || {}) };
   const byFamily = rowsByFamily(selection?.selected || []);
   const sentences = [];
 
-  const isaRows = byFamily.get("isa") || [];
-  if (isaRows.length) {
-    const chain = isaRows.length === 1 ? chains[isaRows[0].object] : null;
-    const form = chain && chain.length > 1 ? "chained" : (isaRows.length > 1 ? "several" : "single");
-    const s = renderStructure(table, "isa", isaRows, { term, form, chain });
-    if (s) sentences.push({ ...s, role: "names-term", paragraph: "definition" });
-  }
+  for (const s of composeIsaSection(byFamily.get("isa") || [], chains, term, table, config)) sentences.push(s);
 
   for (const family of DESCRIPTION_FAMILIES) {
     const rows = byFamily.get(family);
     if (!rows || !rows.length) continue;
-    const s = renderStructure(table, family, rows, { term });
-    if (s) sentences.push({ ...s, role: "describes", paragraph: "description" });
+    for (const c of chunk(rows, config.maxObjectsPerBodySentence)) {
+      const s = renderStructure(table, family, c, { term });
+      if (s) sentences.push({ ...s, role: "describes", paragraph: "description" });
+    }
   }
 
   ensureFirstNamesTerm(sentences, term);

package/src/domain/digest/config.json

@@ -4,6 +4,11 @@
   "entailedDepthPenalty": 0.2,
   "minoritySensePenalty": 0.5,
   "minScore": 0.05,
+  "groupSplitThreshold": 4,
+  "openerConceptCount": 2,
+  "maxObjectsPerBodySentence": 4,
+  "maxBodySentences": 4,
+  "closerRootCount": 2,
   "budget": {
     "chatReply": 5,
     "researchPanel": 10,

package/src/domain/digest/structures.mjs

@@ -6,9 +6,10 @@
 // sibling word helpers.
 
 import { articleFor, pluralOf, capitalizeFirst, series } from "./words.mjs";
+import { fnv1a32 } from "../hash.mjs";
 
 const VALID_FAMILIES = new Set(["isa", "location", "partOf", "capableOf", "usedFor"]);
-const VALID_FORMS = new Set(["single", "several", "chained"]);
+const VALID_FORMS = new Set(["single", "several", "chained", "group", "closer"]);
 
 const keyFor = (family, form) => `${family}:${form}`;
 
@@ -16,8 +17,10 @@ const keyFor = (family, form) => `${family}:${form}`;
  * Validate and index the raw [[structure]] rows into a Map keyed by
  * `family:form`. Closed-vocabulary discipline, same as the construction banks:
  * an unknown family or form, or a missing template, drops the row rather than
- * coercing it. First occurrence of a (family, form) wins; a later duplicate is
- * ignored.
+ * coercing it. Every valid row for a (family, form) is collected into that
+ * key's `templates` list, so the renderer can pick one deterministically from
+ * the pool; an exact-string duplicate is folded, but a second distinct wording
+ * is kept as another variant.
  */
 export function buildStructureTable(structures) {
   const table = new Map();
@@ -26,8 +29,9 @@ export function buildStructureTable(structures) {
     if (typeof s.form !== "string" || !VALID_FORMS.has(s.form)) continue;
     if (typeof s.template !== "string" || !s.template.trim()) continue;
     const key = keyFor(s.family, s.form);
-    if (table.has(key)) continue;
-    table.set(key, { family: s.family, form: s.form, template: s.template });
+    if (!table.has(key)) table.set(key, { family: s.family, form: s.form, templates: [] });
+    const entry = table.get(key);
+    if (!entry.templates.includes(s.template)) entry.templates.push(s.template);
   }
   return table;
 }
@@ -44,12 +48,15 @@ function renderChain(chain) {
   return `${head}, and so ${series(rest.map(withArticle))}`;
 }
 
-/** The slot values for one render, derived from the term, its objects and an
- *  optional ancestry chain. A placeholder with no derived value renders empty. */
-function slotsFor(term, objects, chain) {
+/** The slot values for one render, derived from the term, its objects, an
+ *  optional ancestry chain and an optional parent class (the shared immediate
+ *  ancestor a `group` sentence hangs off). A placeholder with no derived value
+ *  renders empty. */
+function slotsFor(term, objects, chain, parent) {
   const t = String(term || "").trim();
   const objs = (objects || []).map((o) => String(o || "").trim()).filter(Boolean);
   const first = objs[0] || "";
+  const p = String(parent || "").trim();
   return {
     TERM: t,
     TERM_CAP: capitalizeFirst(t),
@@ -59,6 +66,8 @@ function slotsFor(term, objects, chain) {
     TERMS_CAP: capitalizeFirst(pluralOf(t)),
     PRONOUN: "it",
     PRONOUN_CAP: "It",
+    PARENT: p,
+    A_PARENT: p ? withArticle(p) : "",
     OBJECT: first,
     A_OBJECT: first ? withArticle(first) : "",
     OBJECTS_A: series(objs.map(withArticle)),
@@ -82,9 +91,22 @@ function fill(template, slots) {
  * Render one clause for `facts` (all of one family) using the structure the
  * table holds for (family, form). `form` defaults by fact count — one fact is
  * "single", more is "several" — unless the caller names a form (e.g. "chained"
- * with an ancestry chain). Returns { text, rows, family, form } so the sentence
- * traces to the exact fact rows behind it, or null when no structure matches or
- * there are no facts.
+ * with an ancestry chain, or "group"/"closer" for the multi-sentence isa body).
+ *
+ * When a key holds more than one wording, the one that renders is picked by a
+ * deterministic FNV-1a hash of `term|family|form|variantSeed` — the same
+ * paraphrase-pool tool answer-variants.mjs uses — so the choice is stable across
+ * runs but varies by term (and by `variantSeed`, e.g. the shared parent, so two
+ * group sentences under one term can read differently). A single-wording key
+ * always resolves to that one wording.
+ *
+ * `opts.objectsOverride` renders words other than the raw fact objects (a closer
+ * sentence names root concepts, not the facts) while the returned `rows` stays
+ * the real backing facts, so provenance survives. `opts.parent` fills the
+ * `{PARENT}`/`{A_PARENT}` slots a group sentence hangs off.
+ *
+ * Returns { text, rows, family, form } so the sentence traces to the exact fact
+ * rows behind it, or null when no structure matches or there are no facts.
  */
 export function renderStructure(table, family, facts, opts = {}) {
   const rows = (facts || []).filter(Boolean);
@@ -92,9 +114,12 @@ export function renderStructure(table, family, facts, opts = {}) {
   const term = opts.term ?? rows[0].subject ?? "";
   const form = opts.form || (rows.length > 1 ? "several" : "single");
   const entry = table instanceof Map ? table.get(keyFor(family, form)) : null;
-  if (!entry) return null;
-  const objects = rows.map((r) => r.object);
-  const text = fill(entry.template, slotsFor(term, objects, opts.chain));
+  const templates = entry ? entry.templates : null;
+  if (!templates || !templates.length) return null;
+  const variantSeed = opts.variantSeed ?? "";
+  const idx = fnv1a32(`${term}|${family}|${form}|${variantSeed}`) % templates.length;
+  const objects = opts.objectsOverride || rows.map((r) => r.object);
+  const text = fill(templates[idx], slotsFor(term, objects, opts.chain, opts.parent));
   if (!text) return null;
   return { text, rows, family, form };
 }

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

@@ -172,10 +172,18 @@ export function transcriptMarkdown(turns, meta, headerMd, turnMd) {
 }
 
 /** The self-contained "talk to it" full-screen page. Pure — the same output
- *  for the same `title` every time; every other piece of state (the session,
- *  every message, every chip) is computed live in the browser once the
- *  sibling chat bundle loads, exactly as the embedded widget already works. */
-export function renderChatHtml({ title = DEFAULT_TITLE } = {}) {
+ *  for the same `title`/`digestStructures` every time; every other piece of
+ *  state (the session, every message, every chip) is computed live in the
+ *  browser once the sibling chat bundle loads, exactly as the embedded widget
+ *  already works. `digestStructures` are the pre-parsed [[structure]] rows of
+ *  the digest sentence-structure bank, embedded so a long answer can lead
+ *  with a composed digest instead of the flat fact list — the same table
+ *  research.html/ledger.html already embed, fed here to the chat bundle's own
+ *  live digest-bank twin (see chat-browser-entry.mjs) rather than to a
+ *  client-side digest panel of this page's own; an empty list degrades to the
+ *  flat list exactly as before this page could digest at all. */
+export function renderChatHtml({ title = DEFAULT_TITLE, digestStructures = [] } = {}) {
+  const digestStructuresJson = JSON.stringify(Array.isArray(digestStructures) ? digestStructures : []);
   const legendHtml = PROV_LEGEND.map(
     ([key, label]) => `<span class="legend-item"><i class="dot dot-${provKey(key)}"></i>${escapeHtml(label)}</span>`,
   ).join("");
@@ -421,6 +429,7 @@ ${THEME_TOKENS_CSS}
   const renderStatsPanelInto = ${renderStatsPanelInto.toString()};
   const createTicker = ${createTicker.toString()};
   const prefersReducedMotion = ${prefersReducedMotion.toString()};
+  const DIGEST_STRUCTURES = ${digestStructuresJson};
   const el = (id) => document.getElementById(id);
 
   if ("serviceWorker" in navigator) navigator.serviceWorker.register("./tmct-sw.js").catch(() => {});
@@ -655,6 +664,7 @@ ${THEME_TOKENS_CSS}
       liveReference: liveReferenceForMode(checkedWikiMode()),
       synthesisBudget: readSynthBudget(),
       onLiveLookup: function () { statusEl.textContent = "searching wikipedia\\u2026"; },
+      digestStructures: DIGEST_STRUCTURES,
     });
   }
 
@@ -1139,6 +1149,7 @@ ${THEME_TOKENS_CSS}
         liveReference: liveReferenceForMode(initialMode),
         synthesisBudget: readSynthBudget(),
         onLiveLookup: function () { statusEl.textContent = "searching wikipedia\\u2026"; },
+        digestStructures: DIGEST_STRUCTURES,
       });
     } else {
       window.tmctChatSession = newSession();