@polycode-projects/the-mechanical-code-talker 6.0.17 → 6.0.19

package/src/domain/news-feed.mjs

@@ -150,16 +150,24 @@ const hasNonEmptyArray = (value) => Array.isArray(value) && value.length > 0;
 // after it.
 const provenanceHead = (provenance) => String(provenance || "").trim().split(/\s+/)[0] || "";
 
+/** True when the graph reasoned this row out for itself rather than reading it
+ *  somewhere — an entailment head, an environment, or a justification chain.
+ *  A card never speaks from one: the subClassOf closure gives a common noun
+ *  every parent class of every sense it has ("earthquake is a kind of
+ *  cognition, a tentacle, a christians"), which is sound as inference and
+ *  useless as a sentence about today's quake. */
+export function isDerivedRow(row) {
+  return provenanceHead(row?.provenance).startsWith("entailed:")
+    || hasNonEmptyArray(row?.environments) || hasNonEmptyArray(row?.justification);
+}
+
 /** "derived" | "background" | "reported" for one row, pure over the row plus
  *  `now` (PLAN_NEWS_FEED.md section 17.3, step one). Rules apply in order,
  *  first hit wins: a syllogised row is derived; an identity, universal or
  *  non-news-provenance row is background; a news/news-fixture row with no
  *  readable or in-window stamp is background; everything else is reported. */
 export function classifyNewsRow(row, { now, windowMs }) {
-  if (provenanceHead(row.provenance).startsWith("entailed:")
-    || hasNonEmptyArray(row.environments) || hasNonEmptyArray(row.justification)) {
-    return "derived";
-  }
+  if (isDerivedRow(row)) return "derived";
   if (GATE_IDENTITY_PREDICATES.has(row.predicate)) return "background";
   if (UNIVERSAL_QUANTIFIERS.has(String(row.quantifier || "").toLowerCase())) return "background";
   if (!REPORT_PROVENANCE_RE.test(String(row.provenance || ""))) return "background";
@@ -485,6 +493,26 @@ export function buildTermAdjacency(rows) {
   return { byTerm, terms };
 }
 
+// A source names a place by settlement and region at once — "mina, nevada",
+// "pedro bay, alaska", "san juan, puerto rico". The region is the trailing
+// part, and it is the half the graph plausibly already holds facts about,
+// while the joined term is new. So the walk seeds from the region as well as
+// the whole name. The leading part stays out: "mina" the town and "mina" the
+// myna bird are one string to a graph keyed on words, and the settlement half
+// is exactly where that collision lands. Comma-separated only — splitting on
+// spaces would turn "public investments fund" into three terms that name
+// nothing.
+export function hubSeedTerms(hub) {
+  const whole = normFactTerm(hub);
+  const seeds = [whole];
+  if (!whole.includes(",")) return seeds;
+  const region = normFactTerm(whole.split(",").pop());
+  if (!region || region === whole) return seeds;
+  if (STOP_SET.has(region) || isQuantityTerm(region) || !looksLikeEntityTerm(region)) return seeds;
+  seeds.push(region);
+  return seeds;
+}
+
 /** Breadth-first over subject/object adjacency from `hub`, exactly `hops`
  *  levels deep, then capped: a `priorityIds` row first, then the nearer hop,
  *  then content-addressed id. The cap never depends on `rows`' own order, only
@@ -494,19 +522,33 @@ export function buildTermAdjacency(rows) {
  *  `priorityIds` is what keeps a card about a term the graph already knows
  *  thousands of things about from being built out of an arbitrary slice of
  *  them: a hub like "france" reaches far more rows than the cap, and the one
- *  report that made it news would otherwise be the row that fell out. */
-export function subgraphAround(rows, hub, { hops = NEWS_HUB_HOPS, cap = 60, adjacency = null, priorityIds = null } = {}) {
+ *  report that made it news would otherwise be the row that fell out.
+ *
+ *  `seedTerms` starts the walk from more than the hub itself (hubSeedTerms).
+ *  Everything downstream that asks "is this the hub" — the report sentences,
+ *  the sources, the neighbourhood — still reads the hub term alone, so a seed
+ *  widens only what the card can draw background from.
+ *
+ *  `excludeIds` drops rows before the cap rather than after it, so a card that
+ *  gives a report away to another card (storyCoverage) spends the freed budget
+ *  on rows it will actually show. */
+export function subgraphAround(rows, hub, {
+  hops = NEWS_HUB_HOPS, cap = 60, adjacency = null, priorityIds = null, seedTerms = null, excludeIds = null,
+} = {}) {
   const adj = adjacency ?? buildTermAdjacency(rows);
   const hubTerm = normFactTerm(hub);
-  const visited = new Set([hubTerm]);
-  let frontier = [hubTerm];
+  const seeds = (seedTerms?.length ? seedTerms : [hubTerm]).map((t) => normFactTerm(t)).filter(Boolean);
+  const visited = new Set(seeds);
+  let frontier = [...new Set(seeds)].sort();
   const collected = new Map();
   const hopOf = new Map();
+  const isExcluded = excludeIds instanceof Set ? (id) => excludeIds.has(id) : () => false;
   for (let hop = 0; hop < hops; hop += 1) {
     const nextFrontier = new Set();
     for (const term of [...frontier].sort()) {
       for (const idx of adj.byTerm.get(term) ?? []) {
         const row = rows[idx];
+        if (isExcluded(row.id)) continue;
         collected.set(row.id, row);
         if (!hopOf.has(row.id)) hopOf.set(row.id, hop);
         const [s, o] = adj.terms[idx];
@@ -525,6 +567,32 @@ export function subgraphAround(rows, hub, { hops = NEWS_HUB_HOPS, cap = 60, adja
     .slice(0, cap);
 }
 
+// How far the walk goes from an entity the ARTICLE names rather than a fact,
+// and how many rows it may bring back. One hop: what the graph says about that
+// entity itself, never what it says about everything that entity touches. The
+// hub's own two-hop walk is unchanged; this one runs beside it.
+const ARTICLE_ENTITY_HOPS = 1;
+const ARTICLE_ENTITY_ROW_CAP = 24;
+
+/** The rows sitting one hop from an entity the card's article names. Seeded
+ *  from `terms` rather than the hub, so a definition the graph holds about a
+ *  name inside the headline reaches the card even when no fact of the card's
+ *  own touches that name — "amigados is a disk operating system" beside a
+ *  report whose only fact is that a site discussed the headline.
+ *
+ *  `excludeIds` carries the card's reported rows as well as the ones another
+ *  card claimed, so this walk returns background and nothing else: what a
+ *  source reported is the hub walk's business. */
+export function articleEntityRows(rows, terms, {
+  adjacency = null, excludeIds = null, cap = ARTICLE_ENTITY_ROW_CAP,
+} = {}) {
+  const seedTerms = (terms || []).map((term) => normFactTerm(term)).filter(Boolean);
+  if (!seedTerms.length) return [];
+  return subgraphAround(rows, seedTerms[0], {
+    hops: ARTICLE_ENTITY_HOPS, cap, adjacency, seedTerms, excludeIds,
+  });
+}
+
 /** The strongest prior kind among `rows`, for the item's trust chip — read
  *  off each row's own `trust` (a number) and `sourceTypes` (the kind array
  *  readFactRows already computes), never a re-derivation of SOURCE_PRIOR. */
@@ -538,20 +606,37 @@ function tierOf(rows) {
   return kinds[0] || "";
 }
 
-function collectSources(subgraphRows, sourcesByFactId) {
+// How much of an item's own summary a card carries. A wire description runs
+// about a line; an encyclopaedia extract runs several paragraphs, and a feed
+// of fifty cards has a byte budget to keep (MAX_FEED_DOCUMENT_BYTES). Cut at
+// the last word boundary inside the bound so the quote ends on a word.
+const SOURCE_SUMMARY_MAX_CHARS = 400;
+
+function clampSummary(summary) {
+  const text = String(summary || "").trim();
+  if (text.length <= SOURCE_SUMMARY_MAX_CHARS) return text;
+  const cut = text.slice(0, SOURCE_SUMMARY_MAX_CHARS);
+  const lastSpace = cut.lastIndexOf(" ");
+  return `${(lastSpace > 0 ? cut.slice(0, lastSpace) : cut).trimEnd()}…`;
+}
+
+function collectSources(citedRows, sourcesByFactId) {
   const get = (id) => (sourcesByFactId instanceof Map ? sourcesByFactId.get(id) : sourcesByFactId?.[id]);
   const seen = new Set();
   const sources = [];
-  for (const row of subgraphRows) {
+  for (const row of citedRows) {
     const src = get(row.id);
     if (!src) continue;
     const key = src.url || src.title || "";
     if (!key || seen.has(key)) continue;
     seen.add(key);
     const entry = { title: src.title || "", url: src.url || "", name: src.name || "" };
-    // Carried through only when the source snapshot actually has one — a
-    // card for an undated snapshot shows no date rather than a blank field.
+    // Both of these ride along only when the snapshot actually has one — a
+    // card for an undated or summary-less snapshot shows nothing there rather
+    // than a blank field.
     if (src.publishedAt) entry.publishedAt = src.publishedAt;
+    const summary = clampSummary(src.summary);
+    if (summary) entry.summary = summary;
     sources.push(entry);
   }
   return sources;
@@ -563,14 +648,245 @@ function joinWithAnd(items) {
   return `${items.slice(0, -1).join(", ")} and ${items[items.length - 1]}`;
 }
 
+// ---------------------------------------------------------------------------
+// What one card reports, and whose neighbourhood it sits in.
+// ---------------------------------------------------------------------------
+
+/** An id membership test over a Set, an array, or null — null meaning "every
+ *  row counts", which is what a caller with no reported-row set of its own
+ *  (the background paragraph, a direct render call) needs. */
+function idMembership(ids) {
+  if (ids === null || ids === undefined) return () => true;
+  if (ids instanceof Set) return (id) => ids.has(id);
+  return (id) => ids.includes(id);
+}
+
+const rowObservedRank = (row) => {
+  const t = rowObservedMs(row);
+  return Number.isFinite(t) ? t : 0;
+};
+
+/** The reported rows of `subgraphRows` that touch `hub` directly — what this
+ *  card actually reports, and so what it may attribute a source to. A row
+ *  further out in the two-hop walk was reached through a term the hub merely
+ *  shares; it belongs to some other card's report. */
+export function hubReportRows(hub, subgraphRows, { reportedIds = null } = {}) {
+  const hubTerm = normFactTerm(hub);
+  const isReported = idMembership(reportedIds);
+  return subgraphRows.filter((row) => isReported(row.id)
+    && (normFactTerm(row.subject) === hubTerm || normFactTerm(row.object) === hubTerm));
+}
+
+/** Every term sitting one edge from `hub` inside this card's own sub-graph. */
+function hubLinkTerms(subgraphRows, hubTerm) {
+  const terms = new Set();
+  for (const row of subgraphRows) {
+    const s = normFactTerm(row.subject);
+    const o = normFactTerm(row.object);
+    if (s === hubTerm && o) terms.add(o);
+    else if (o === hubTerm && s) terms.add(s);
+  }
+  terms.delete(hubTerm);
+  return terms;
+}
+
+const NEIGHBOUR_ROW_LIMIT = 3;
+
+/** This hub's own neighbourhood: the reported rows one further edge out,
+ *  reached only through a link term specific enough to name a neighbourhood.
+ *  A link term the clause cannot name in full — one reaching more rows than
+ *  the sentence prints — is a category node, not a neighbour: "earthquake"
+ *  sits between all 44 quakes of a day, so every quake card walked through it
+ *  and printed the same arbitrary three. Naming a slice of a category is what
+ *  made sibling cards identical, so a term over the clause's own capacity
+ *  contributes nothing and a card with no specific link prints no "Around it"
+ *  at all.
+ *
+ *  Survivors rank by a predicate the hub's own report also used, then by
+ *  observation time, then by id — this hub's choice, and a pure function of
+ *  the fact set either way. */
+export function neighbourRows(hub, subgraphRows, { reportedIds = null, limit = NEIGHBOUR_ROW_LIMIT } = {}) {
+  const hubTerm = normFactTerm(hub);
+  const isReported = idMembership(reportedIds);
+  const linkTerms = hubLinkTerms(subgraphRows, hubTerm);
+
+  const reachedByLinkTerm = new Map();
+  for (const row of subgraphRows) {
+    const s = normFactTerm(row.subject);
+    const o = normFactTerm(row.object);
+    if (s === hubTerm || o === hubTerm || !isReported(row.id)) continue;
+    for (const term of new Set([s, o])) {
+      if (!term || !linkTerms.has(term)) continue;
+      let reached = reachedByLinkTerm.get(term);
+      if (!reached) reachedByLinkTerm.set(term, (reached = []));
+      reached.push(row);
+    }
+  }
+
+  const candidates = new Map();
+  for (const [, reached] of reachedByLinkTerm) {
+    if (reached.length > limit) continue;
+    for (const row of reached) candidates.set(row.id, row);
+  }
+
+  const hubPredicates = new Set(hubReportRows(hub, subgraphRows, { reportedIds }).map((r) => r.predicate));
+  return [...candidates.values()]
+    .sort((a, b) => (Number(hubPredicates.has(b.predicate)) - Number(hubPredicates.has(a.predicate)))
+      || (rowObservedRank(b) - rowObservedRank(a))
+      || byId(a, b))
+    .slice(0, limit);
+}
+
 const IDENTITY_PREDICATES = new Set(["rdf:type", "rdfs:subClassOf"]);
-const SENTENCE_CAP = 5;
+const SENTENCE_CAP = 6;
+// The four blocks a card's paragraph is built from, in the order they read:
+// what was reported, then what the thing is, then what the graph already knew
+// about it, then its neighbourhood. Their caps add up past SENTENCE_CAP on
+// purpose — the paragraph fills from the front, so a news-rich card spends its
+// budget on the news and a quiet one spends it on background.
+const REPORT_SENTENCE_CAP = 4;
+const IDENTITY_SENTENCE_CAP = 1;
+const KNOWN_FACT_SENTENCE_CAP = 2;
 // How many objects one sentence names before it counts the rest. A live source
 // reports the same relation over and over inside one window — every quake of
 // the day strikes near somewhere — and an unbounded list turns a card into a
 // wall of text.
 const OBJECTS_PER_SENTENCE = 6;
 
+// A term the graph says is more than this many things is read across senses:
+// "earthquake" is a natural event, a cognition, a social station and nine more,
+// so no single class line about it is trustworthy on a card about one quake.
+// Same discipline as the neighbourhood's own category-node test — a node too
+// wide for one clause to name in full says nothing — applied to senses instead
+// of edges.
+const IDENTITY_MAX_CLASSES = 2;
+// A background line's far side, when this many terms in the sub-graph already
+// fall under it, names a category rather than anything about this card:
+// "france is related to place" is true of most of the graph. The hub's own
+// identity clause is exempt — a crowded class is still this thing's own kind,
+// and "france is a country" is the most useful line a card can carry.
+const CATEGORY_FAN_MAX = 3;
+// How many background rows the "what the graph already knew" disclosure names.
+// The paragraph itself shows the first KNOWN_FACT_SENTENCE_CAP groups of these.
+const KNOWN_FACT_ROW_LIMIT = 6;
+
+/** Three fan-out readings of the identity rows inside one card's sub-graph.
+ *  `senseFan` counts every class a term is said to BE, the entailment closure
+ *  included — high means the graph reads the term across senses, which is what
+ *  makes a common noun a poor subject for a card about one event.
+ *  `sourcedSenseFan` counts only the classes something actually stated, which
+ *  is what a printed "X is a Y" clause may draw on. `categoryFan` counts the
+ *  distinct terms said to fall UNDER a term — high means a category node, the
+ *  same reading the neighbourhood's own link-term test makes. All three are
+ *  pure counts over the rows handed in, so a card's own sub-graph decides and
+ *  no global blocklist is involved. */
+function identityFans(subgraphRows) {
+  const senseFan = new Map();
+  const sourcedSenseFan = new Map();
+  const membersByClass = new Map();
+  for (const row of subgraphRows) {
+    if (!IDENTITY_PREDICATES.has(row.predicate)) continue;
+    const s = normFactTerm(row.subject);
+    const o = normFactTerm(row.object);
+    if (!s || !o) continue;
+    senseFan.set(s, (senseFan.get(s) || 0) + 1);
+    if (!isDerivedRow(row)) sourcedSenseFan.set(s, (sourcedSenseFan.get(s) || 0) + 1);
+    let members = membersByClass.get(o);
+    if (!members) membersByClass.set(o, (members = new Set()));
+    members.add(s);
+  }
+  const categoryFan = new Map();
+  for (const [term, members] of membersByClass) categoryFan.set(term, members.size);
+  return { senseFan, sourcedSenseFan, categoryFan };
+}
+
+// Where a background row's anchor term came from, and so which rows the
+// disclosure names first: the card's own hub, then a term its report names,
+// then an entity its article names that no fact of the card's own touches.
+const ANCHOR_RANK_HUB = 0;
+const ANCHOR_RANK_REPORT = 1;
+const ANCHOR_RANK_ARTICLE = 2;
+
+/** What this card is ABOUT, each term mapped to its anchor rank: its hub, the
+ *  region of a hub the source spelled "settlement, region", the other terms its
+ *  own report sentences name, and the entities its article names (`articleTerms`)
+ *  — minus any of those that reads across senses. A quake card's report
+ *  names "earthquake" and a place; the class term is where the graph's
+ *  knowledge is thinnest and its senses widest, so background drawn through it
+ *  is background about earthquakes in general, never about this quake. The hub
+ *  itself is always in, whatever its sense count — the card is about it.
+ *
+ *  An article entity earns the same reading a report term gets, one rank
+ *  behind it: the story's own words name it, but no fact the card reports
+ *  does. */
+function cardSubjectTerms(hub, subgraphRows, { reportedIds = null, senseFan, articleTerms = [] }) {
+  const hubTerm = normFactTerm(hub);
+  const isReported = idMembership(reportedIds);
+  const terms = new Map();
+  for (const seed of hubSeedTerms(hubTerm)) terms.set(seed, ANCHOR_RANK_HUB);
+  const admit = (raw, rank) => {
+    const term = normFactTerm(raw);
+    if (!term || terms.has(term) || STOP_SET.has(term)) return;
+    if ((senseFan.get(term) || 0) > IDENTITY_MAX_CLASSES) return;
+    terms.set(term, rank);
+  };
+  for (const row of hubReportRows(hubTerm, subgraphRows, { reportedIds })) {
+    if (!isReported(row.id)) continue;
+    for (const raw of [row.subject, row.object]) admit(raw, ANCHOR_RANK_REPORT);
+  }
+  for (const raw of articleTerms) admit(raw, ANCHOR_RANK_ARTICLE);
+  return terms;
+}
+
+/** The background rows worth telling a reader about, ranked: a row touching
+ *  one of this card's own subject terms, whose other side is not a category
+ *  node, and — for an identity row — whose subject is not read across senses.
+ *  Ranks the hub's own rows first, then the ones its report names, then the
+ *  ones an entity in its article names, then by how specific the other side
+ *  is, then by content-addressed id, so the same fact set always yields the
+ *  same lines in the same order. */
+export function knownFactRows(hub, subgraphRows, {
+  reportedIds = null, limit = KNOWN_FACT_ROW_LIMIT, articleTerms = [],
+} = {}) {
+  const hubTerm = normFactTerm(hub);
+  const isReported = idMembership(reportedIds);
+  const { senseFan, sourcedSenseFan, categoryFan } = identityFans(subgraphRows);
+  const subjects = cardSubjectTerms(hub, subgraphRows, { reportedIds, senseFan, articleTerms });
+  const neighbourIds = new Set(neighbourRows(hub, subgraphRows, { reportedIds }).map((r) => r.id));
+
+  const scored = [];
+  for (const row of subgraphRows) {
+    if (isReported(row.id) || neighbourIds.has(row.id) || isDerivedRow(row)) continue;
+    const s = normFactTerm(row.subject);
+    const o = normFactTerm(row.object);
+    if (!s || !o || s === o) continue;
+    const anchorIsSubject = subjects.has(s);
+    if (!anchorIsSubject && !subjects.has(o)) continue;
+    const anchor = anchorIsSubject ? s : o;
+    const other = anchorIsSubject ? o : s;
+    if (IDENTITY_PREDICATES.has(row.predicate)) {
+      // What the hub itself IS belongs to the identity clause and is said once.
+      if (s === hubTerm) continue;
+      if ((sourcedSenseFan.get(s) || 0) > IDENTITY_MAX_CLASSES) continue;
+    }
+    if ((categoryFan.get(other) || 0) > CATEGORY_FAN_MAX) continue;
+    scored.push({
+      row,
+      anchorRank: subjects.get(anchor),
+      otherCategoryFan: categoryFan.get(other) || 0,
+      otherSenseFan: senseFan.get(other) || 0,
+    });
+  }
+
+  return scored
+    .sort((a, b) => (a.anchorRank - b.anchorRank)
+      || (a.otherCategoryFan - b.otherCategoryFan)
+      || (a.otherSenseFan - b.otherSenseFan)
+      || byId(a.row, b.row))
+    .slice(0, limit)
+    .map((entry) => entry.row);
+}
+
 function joinObjects(objects) {
   if (objects.length <= OBJECTS_PER_SENTENCE) return joinWithAnd(objects);
   const shown = objects.slice(0, OBJECTS_PER_SENTENCE);
@@ -588,75 +904,427 @@ function predicatesInRenderOrder(rows) {
   return [...curated, ...rest];
 }
 
-/** The fixed five-sentence paraphrase template (PLAN_NEWS_FEED.md section
- *  8.3): identity first, then the hub's own relations grouped by predicate in
- *  FACT_PREDICATE_PHRASES table order, then one closing sentence naming up to
- *  three second-hop facts. Every sentence shown is a grounded fact, never a
- *  paraphrase of prose the grammar could not read.
- *
- *  `reportedIds` (PLAN_NEWS_FEED.md section 17.4), when given, restricts the
- *  relation sentences and the closing "Around it" sentence to rows in that
- *  set — the identity sentence keeps drawing from every row it's handed,
- *  since "what is this thing" is the first question a reader has regardless
- *  of who reported it. Defaults to null, meaning every row renders, so every
- *  existing caller and pin is unaffected. */
-export function renderNewsParagraph(hub, subgraphRows, { reportedIds = null } = {}) {
+/** One sentence per (subject, predicate) group over `rows`, in the order the
+ *  rows arrive — the same shape the hub's own relation sentences take, so a
+ *  background line reads like the rest of the paragraph rather than a dump.
+ *  Each entry carries the group's own rows alongside its text, so a caller
+ *  that needs to know which facts a sentence came from (the bench's noisy-
+ *  line scoring) reads them off the same grouping the sentence itself used,
+ *  never a second derivation of it. */
+function groupedFactSentenceEntries(rows) {
+  const groups = new Map();
+  for (const row of rows) {
+    const key = `${row.subject}${row.predicate}`;
+    let group = groups.get(key);
+    if (!group) groups.set(key, (group = { subject: row.subject, predicate: row.predicate, objects: [], rows: [] }));
+    group.objects.push(row.object);
+    group.rows.push(row);
+  }
+  return [...groups.values()].map(({ subject, predicate, objects, rows: groupRows }) => {
+    const sorted = [...objects].sort();
+    // "rdf:type" reads "is a" from the curated phrase table, which is the wrong
+    // article before a vowel and a second one in front of an object articleFor
+    // has already spelled. The identity clause the paragraph opens with says a
+    // bare "is" and lets articleFor choose; a background line says it the same
+    // way. Every other predicate, "is a kind of" included, carries whatever
+    // article it needs inside its own phrase and takes the object bare.
+    const text = predicate === "rdf:type"
+      ? `${subject} is ${joinObjects(sorted.map((object) => `${articleFor(object)} ${object}`))}`
+      : `${subject} ${predicatePhrase(predicate, subject)} ${joinObjects(sorted)}`;
+    return { text, rows: groupRows };
+  });
+}
+
+function groupedFactSentences(rows) {
+  return groupedFactSentenceEntries(rows).map((entry) => entry.text);
+}
+
+/** The sentences a card's paragraph is made of, as four ordered blocks: the
+ *  report (what a source said inside the window), the identity clause, the
+ *  related facts the graph already held, and the neighbourhood. Each entry is
+ *  `{ text, rows }` — the rendered sentence and the fact row(s) it came from
+ *  — so a caller that needs to know which facts actually reached the printed
+ *  text (the bench's noisy-line scoring) reads them off the same blocks
+ *  `renderNewsParagraph` itself slices, never a second derivation of it.
+ *  Callers that render only one block — the "what the graph already knew"
+ *  disclosure — read the block they want instead of re-deriving it. */
+function paragraphBlocks(hub, subgraphRows, { reportedIds = null, articleTerms = [] } = {}) {
   const hubTerm = normFactTerm(hub);
-  const isReported = reportedIds === null
-    ? () => true
-    : (id) => (reportedIds instanceof Set ? reportedIds.has(id) : reportedIds.includes(id));
+  const isReported = idMembership(reportedIds);
   const hubRows = subgraphRows.filter((r) => normFactTerm(r.subject) === hubTerm);
   const reportedHubRows = hubRows.filter((r) => isReported(r.id));
-  const secondHopRows = subgraphRows.filter(
-    (r) => normFactTerm(r.subject) !== hubTerm && normFactTerm(r.object) !== hubTerm && isReported(r.id),
-  );
-
-  const sentences = [];
-
-  const identityObjects = hubRows
-    .filter((r) => IDENTITY_PREDICATES.has(r.predicate))
-    .map((r) => r.object)
-    .sort();
-  if (identityObjects.length) {
-    const withArticles = identityObjects.map((object) => `${articleFor(object)} ${object}`);
-    sentences.push(`${hub} is ${joinObjects(withArticles)}`);
-  }
-
+  const report = [];
   for (const predicate of predicatesInRenderOrder(reportedHubRows)) {
-    if (IDENTITY_PREDICATES.has(predicate) || sentences.length >= SENTENCE_CAP) continue;
-    const objects = reportedHubRows
-      .filter((r) => r.predicate === predicate)
-      .map((r) => r.object)
-      .sort();
+    if (IDENTITY_PREDICATES.has(predicate) || report.length >= REPORT_SENTENCE_CAP) continue;
+    const groupRows = reportedHubRows.filter((r) => r.predicate === predicate);
+    const objects = groupRows.map((r) => r.object).sort();
     if (!objects.length) continue;
-    sentences.push(`${hub} ${predicatePhrase(predicate, hub)} ${joinObjects(objects)}`);
+    report.push({ text: `${hub} ${predicatePhrase(predicate, hub)} ${joinObjects(objects)}`, rows: groupRows });
   }
 
   // A hub that only ever appears as an OBJECT — the place a quake struck, the
   // story a site discussed — has no subject-side row to build a sentence from,
   // and its card came out blank. What was reported about it still says
   // something, so those rows render whole, subject and all.
-  if (!sentences.length) {
-    const aboutHub = subgraphRows
+  if (!report.length) {
+    const aboutHubRows = subgraphRows
       .filter((r) => normFactTerm(r.object) === hubTerm && normFactTerm(r.subject) !== hubTerm && isReported(r.id))
       .sort(byId)
-      .slice(0, OBJECTS_PER_SENTENCE)
-      .map((r) => factSentence(r));
-    if (aboutHub.length) sentences.push(aboutHub.join("; "));
+      .slice(0, OBJECTS_PER_SENTENCE);
+    if (aboutHubRows.length) {
+      report.push({ text: aboutHubRows.map((r) => factSentence(r)).join("; "), rows: aboutHubRows });
+    }
   }
 
-  if (sentences.length < SENTENCE_CAP && secondHopRows.length) {
-    const around = secondHopRows
-      .slice()
-      .sort(byId)
-      .slice(0, 3)
-      .map((r) => factSentence(r))
-      .join("; ");
-    sentences.push(`Around it: ${around}`);
+  // The identity clause follows the news, never leads it, and only when
+  // something actually stated the hub's kind in one sense. The entailment
+  // closure names thirteen classes for "france" — a list nobody asked for,
+  // most of it the wrong sense — so it opens no card.
+  const identity = [];
+  const identityRows = hubRows.filter((r) => IDENTITY_PREDICATES.has(r.predicate) && !isDerivedRow(r));
+  const identityObjects = identityRows.map((r) => r.object).sort();
+  const identityIsSingleSense = identityObjects.length > 0 && identityObjects.length <= IDENTITY_MAX_CLASSES;
+  if (identityIsSingleSense) {
+    identity.push({
+      text: `${hub} is ${joinObjects(identityObjects.map((object) => `${articleFor(object)} ${object}`))}`,
+      rows: identityRows,
+    });
+  }
+
+  const known = groupedFactSentenceEntries(knownFactRows(hub, subgraphRows, { reportedIds, articleTerms }));
+
+  const neighbours = neighbourRows(hub, subgraphRows, { reportedIds });
+  const around = neighbours.length
+    ? [{ text: `Around it: ${neighbours.map((r) => factSentence(r)).join("; ")}`, rows: neighbours }]
+    : [];
+
+  return { report, identity, known, around };
+}
+
+/** The paragraph's own sentence entries (`{ text, rows }`), in print order and
+ *  sliced to exactly what `renderNewsParagraph` shows — the per-block caps
+ *  (identity, known) and the paragraph-wide `SENTENCE_CAP` both applied.
+ *  Shared by `renderNewsParagraph` and `printedParagraphRows` so the two can
+ *  never drift: one reads `.text`, the other reads `.rows`. */
+function paragraphSentenceEntries(hub, subgraphRows, { reportedIds = null, articleTerms = [] } = {}) {
+  const { report, identity, known, around } = paragraphBlocks(hub, subgraphRows, { reportedIds, articleTerms });
+  return [
+    ...report,
+    ...identity.slice(0, IDENTITY_SENTENCE_CAP),
+    ...known.slice(0, KNOWN_FACT_SENTENCE_CAP),
+    ...around,
+  ].slice(0, SENTENCE_CAP);
+}
+
+/** A card's paragraph: what a source reported, then what the thing is, then
+ *  the related facts the graph already held about it, then its own
+ *  neighbourhood (neighbourRows). Every sentence shown is a grounded fact,
+ *  never a paraphrase of prose the grammar could not read, and the news always
+ *  leads.
+ *
+ *  `reportedIds` (PLAN_NEWS_FEED.md section 17.4), when given, splits the rows
+ *  into what was reported (the lead sentences) and what the graph already held
+ *  (the background ones). Defaults to null, meaning every row counts as
+ *  reported. */
+export function renderNewsParagraph(hub, subgraphRows, { reportedIds = null, articleTerms = [] } = {}) {
+  const sentences = paragraphSentenceEntries(hub, subgraphRows, { reportedIds, articleTerms }).map((entry) => entry.text);
+  return sentences.length ? `${sentences.join(". ")}.` : "";
+}
+
+/** Every fact row that survives into the card's rendered main paragraph —
+ *  the same rows `renderNewsParagraph` drew its sentences from, after every
+ *  cap it applies (per-block and the paragraph-wide `SENTENCE_CAP`). A row
+ *  computed but sliced away before render (an "Around it" clause cut by the
+ *  overall cap, an identity class beyond `IDENTITY_MAX_CLASSES`) never
+ *  appears here, because it never appears on the card either. */
+export function printedParagraphRows(hub, subgraphRows, { reportedIds = null, articleTerms = [] } = {}) {
+  return paragraphSentenceEntries(hub, subgraphRows, { reportedIds, articleTerms }).flatMap((entry) => entry.rows);
+}
+
+/** The "what the graph already knew" disclosure: the same related facts the
+ *  paragraph leads with, at the disclosure's own fuller depth, and nothing the
+ *  card already reported. Empty when the graph held nothing about this card's
+ *  own subjects — a card with no background says so rather than filling the
+ *  space with whatever the two-hop walk happened to reach. */
+export function renderKnownFactsParagraph(hub, subgraphRows, { reportedIds = null, articleTerms = [] } = {}) {
+  const sentences = groupedFactSentences(knownFactRows(hub, subgraphRows, { reportedIds, articleTerms }));
+  return sentences.length ? `${sentences.join(". ")}.` : "";
+}
+
+// ---------------------------------------------------------------------------
+// Which story a card tells, and what it is called.
+// ---------------------------------------------------------------------------
+
+// The item tag a news row carries, at whatever depth the ingest wrapper
+// nested it ("news:<sourceId>@<itemId>", "optimistic-extract:news:…"), plus
+// the fixture replay's own twin. Every sentence a card prints comes from a
+// row, so which story a card is telling is readable from the fact set alone —
+// no source map, no arrival order, no clock.
+const NEWS_STORY_TAG_RE = /(?:^|:)news(?:-fixture)?:([^\s|]+)/;
+
+/** The newsworthy item one row reported, or "" when its provenance names
+ *  none. Pure. */
+export function newsStoryKey(row) {
+  return NEWS_STORY_TAG_RE.exec(String(row?.provenance || ""))?.[1] || "";
+}
+
+/** Every reported row touching each term, subject side or object side. Built
+ *  once per feed assembly and shared, for the same reason buildTermAdjacency
+ *  is. */
+function reportedRowsByTerm(reported) {
+  const byTerm = new Map();
+  for (const row of reported) {
+    for (const term of new Set([normFactTerm(row.subject), normFactTerm(row.object)])) {
+      if (!term) continue;
+      let rowsFor = byTerm.get(term);
+      if (!rowsFor) byTerm.set(term, (rowsFor = []));
+      rowsFor.push(row);
+    }
+  }
+  return byTerm;
+}
+
+// How many stories a term's own reports must span before it stops being one
+// story's subject. Two is enough: a term the day's second story also names is
+// a publication, a wire desk or a class every item shares, and a card headed
+// by one repeats whatever the per-story cards already said.
+const PUBLICATION_STORY_MIN = 2;
+
+/** How many distinct newsworthy items each term's own reports came from. */
+function storyCountsByTerm(rowsByTerm) {
+  const counts = new Map();
+  for (const [term, rowsFor] of rowsByTerm) {
+    const keys = new Set();
+    for (const row of rowsFor) {
+      const key = newsStoryKey(row);
+      if (key) keys.add(key);
+    }
+    counts.set(term, keys.size);
   }
+  return counts;
+}
+
+// The classes the graph's own identity rows use to say a thing is a place or
+// a person. The same closed set the bench's entity-preservation metric reads
+// off the seed, duplicated here (not imported) because the domain layer never
+// imports a script.
+const PLACE_OR_PERSON_CLASS_TERMS = new Set([
+  "place", "person", "city", "country", "location", "nation", "continent",
+  "capital", "state", "province", "town", "region",
+]);
 
-  const capped = sentences.slice(0, SENTENCE_CAP);
-  return capped.length ? `${capped.join(". ")}.` : "";
+/** Every term the graph itself types as a place or a person, whoever stated
+ *  the identity. A card prefers one of these for its own title: it is the
+ *  thing the story is about, where a clause the same report threw off is only
+ *  something that happened to it. Pure over `rows`. */
+export function placeAndPersonTerms(rows) {
+  const grounded = new Set();
+  for (const row of rows) {
+    if (row.predicate !== "rdf:type" && row.predicate !== "rdfs:subClassOf") continue;
+    if (!PLACE_OR_PERSON_CLASS_TERMS.has(normFactTerm(row.object))) continue;
+    const subject = normFactTerm(row.subject);
+    if (subject) grounded.add(subject);
+  }
+  return grounded;
+}
+
+// A predicate minted from a source's own verb, lemma only: "mgx:hit",
+// "mgx:discuss". The curated table's entries carry a capital ("mgx:partOf")
+// and a folded preposition carries a hyphen ("mgx:strike-near"), and neither
+// can be a single word inside a term, so neither belongs in the verb set.
+const MINTED_VERB_PREDICATE_RE = /^mgx:([a-z]+)$/;
+
+/** The verbs this window's own reports minted a predicate from. A term
+ *  carrying one of them is a clause the extraction cut in half, and the graph
+ *  says so itself rather than a hand-written verb list saying it. */
+export function reportedVerbWords(reported) {
+  const verbs = new Set();
+  for (const row of reported) {
+    const lemma = MINTED_VERB_PREDICATE_RE.exec(String(row.predicate || ""))?.[1];
+    if (lemma) verbs.add(lemma);
+  }
+  return verbs;
+}
+
+// How many words a name runs to before it reads as a sentence about a thing
+// rather than the thing's name. "south sandwich islands region" is a place;
+// "boats hit by mystery attackers" is what happened to some.
+const CLAUSE_TITLE_MAX_WORDS = 4;
+const CLAUSE_WORD_EDGE_RE = /^[^a-z0-9]+|[^a-z0-9]+$/g;
+
+/** Does `term` read as a clause rather than a name — longer than a name runs,
+ *  or carrying one of the verbs the window's own reports minted? A clause
+ *  never takes a card's title from a grounded entity term. */
+export function readsAsClauseTerm(term, verbWords) {
+  const words = String(term ?? "").trim().toLowerCase().split(/\s+/).filter(Boolean);
+  if (!words.length) return false;
+  if (words.length > CLAUSE_TITLE_MAX_WORDS) return true;
+  const verbs = verbWords instanceof Set ? verbWords : new Set(verbWords || []);
+  return words.some((word) => verbs.has(word.replace(CLAUSE_WORD_EDGE_RE, "")));
+}
+
+/** The term a card is titled and keyed by, given the hub the gate chose and
+ *  the reported rows that hub sits in. In order:
+ *
+ *  1. the hub itself, when the graph already types it as a place or a person;
+ *  2. a place/person term the hub's own reports name — "bali" over "sacred
+ *     glow", "clacton" over "election";
+ *  3. the subject those reports share, but only when the hub reads as a clause
+ *     and only when that subject tells one story of its own — the publication
+ *     every headline hangs off is never a card's name;
+ *  4. the hub, unchanged.
+ *
+ *  Ties inside a step go to the term the reports name most, then alphabetical,
+ *  so the same fact set always titles a card the same way. Nothing here invents
+ *  a term: every candidate is already on one of the card's own rows. */
+export function hubTitleTerm(hubTerm, hubRows, { placeOrPerson, verbWords, storyCountByTerm }) {
+  if (placeOrPerson.has(hubTerm)) return hubTerm;
+
+  const namesAThing = (term) => Boolean(term) && term !== hubTerm && !STOP_SET.has(term)
+    && !isQuantityTerm(term) && looksLikeEntityTerm(term) && !readsAsClauseTerm(term, verbWords);
+
+  const groundedCounts = new Map();
+  const subjectCounts = new Map();
+  for (const row of hubRows) {
+    const subject = normFactTerm(row.subject);
+    const object = normFactTerm(row.object);
+    for (const term of new Set([subject, object])) {
+      if (namesAThing(term) && placeOrPerson.has(term)) groundedCounts.set(term, (groundedCounts.get(term) || 0) + 1);
+    }
+    if (object !== hubTerm || !namesAThing(subject)) continue;
+    if ((storyCountByTerm.get(subject) || 0) >= PUBLICATION_STORY_MIN) continue;
+    subjectCounts.set(subject, (subjectCounts.get(subject) || 0) + 1);
+  }
+
+  const mostNamed = (counts) => [...counts.entries()]
+    .sort((a, b) => b[1] - a[1] || (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0))[0]?.[0] || "";
+
+  return mostNamed(groundedCounts)
+    || (readsAsClauseTerm(hubTerm, verbWords) ? mostNamed(subjectCounts) : "")
+    || hubTerm;
+}
+
+/** True when a source spelled this term as a settlement and its region at once
+ *  — "wana, pakistan", "mina, nevada". The source has already said which of a
+ *  report's terms is the thing that happened somewhere, so the term reads as a
+ *  place even where no identity row types it as one. hubSeedTerms holds the
+ *  same reading for the walk. */
+const namesASettlementAndRegion = (term) => hubSeedTerms(term).length > 1;
+
+/** The gate's hubs retitled by hubTitleTerm, with two hubs that answer to the
+ *  same name merged into one. Each keeps the two readings storyCoverage ranks
+ *  cards by, taken on the title the card will actually wear. Keeps the gate's
+ *  own sort — changed count desc, then term asc. */
+function titledHubs(hubs, rows, reported, rowsByTerm) {
+  const placeOrPerson = placeAndPersonTerms(rows);
+  const verbWords = reportedVerbWords(reported);
+  const storyCountByTerm = storyCountsByTerm(rowsByTerm);
+  const changedByTitle = new Map();
+  for (const { term, changed } of hubs) {
+    const title = hubTitleTerm(term, rowsByTerm.get(term) || [], { placeOrPerson, verbWords, storyCountByTerm });
+    const held = changedByTitle.get(title);
+    if (held === undefined || changed > held) changedByTitle.set(title, changed);
+  }
+  return [...changedByTitle.entries()]
+    .map(([term, changed]) => ({
+      term,
+      changed,
+      namesAnEntity: placeOrPerson.has(term) || namesASettlementAndRegion(term),
+      clauseShaped: readsAsClauseTerm(term, verbWords),
+      reportSubject: (rowsByTerm.get(term) || []).some((row) => normFactTerm(row.subject) === term),
+    }))
+    .sort((a, b) => b.changed - a.changed || (a.term < b.term ? -1 : a.term > b.term ? 1 : 0));
+}
+
+/** How a story picks between the cards that want to tell it. In order: the
+ *  hub whose own reports span fewest stories, since a card about one story
+ *  beats a publication's roundup of it; then the hub that names a place or a
+ *  person, since that is what the story is about; then the hub that
+ *  reads as a name rather than a clause; then the one the report puts on the
+ *  subject side, the story's actor where the object is what happened to it;
+ *  then the gate's own changed count; then the term itself, so the answer never
+ *  comes down to arrival order. */
+function byCardClaim(a, b) {
+  return a.storyCount - b.storyCount
+    || (Number(b.namesAnEntity) - Number(a.namesAnEntity))
+    || (Number(a.clauseShaped) - Number(b.clauseShaped))
+    || (Number(b.reportSubject) - Number(a.reportSubject))
+    || (b.changed - a.changed)
+    || (a.term < b.term ? -1 : a.term > b.term ? 1 : 0);
+}
+
+/** Which stories each hub gets to tell, and which of its reports belong to
+ *  another card. One story mints one card: the hubs bid for it in byCardClaim
+ *  order and the first takes it, so a report that threw off both a subject hub
+ *  and an object hub ("ukraine" beside "air war", "london" beside "glass")
+ *  stops minting a card each. A hub left with no story of its own does not
+ *  mint, and one that keeps some carries only those — the "hackernews" card
+ *  that repeated both of the day's Hacker News cards wholesale is gone, and one
+ *  that repeated three of four carries the fourth alone.
+ *
+ *  A row whose provenance names no story is never claimed and never dropped, so
+ *  a hub built only from those still mints.
+ *
+ *  Returns hub term -> `{ mints, coveredRowIds }`. */
+export function storyCoverage(hubs, rowsByTerm) {
+  const rowIdsByStory = new Map();
+  for (const { term } of hubs) {
+    const byStory = new Map();
+    for (const row of rowsByTerm.get(term) || []) {
+      const key = newsStoryKey(row);
+      if (!key) continue;
+      let ids = byStory.get(key);
+      if (!ids) byStory.set(key, (ids = []));
+      ids.push(row.id);
+    }
+    rowIdsByStory.set(term, byStory);
+  }
+
+  const bidders = hubs
+    .map((hub) => ({ ...hub, storyCount: rowIdsByStory.get(hub.term).size }))
+    .sort(byCardClaim);
+
+  const claimed = new Set();
+  const coverage = new Map();
+  for (const { term, storyCount } of bidders) {
+    const stories = rowIdsByStory.get(term);
+    const coveredRowIds = new Set();
+    let ownStories = 0;
+    for (const key of [...stories.keys()].sort()) {
+      if (claimed.has(key)) {
+        for (const id of stories.get(key)) coveredRowIds.add(id);
+        continue;
+      }
+      claimed.add(key);
+      ownStories += 1;
+    }
+    coverage.set(term, { mints: storyCount === 0 || ownStories > 0, coveredRowIds });
+  }
+  return coverage;
+}
+
+/** The entities this card's own article names, as terms the graph could hold
+ *  facts about. `articleEntityNames` reads them out of the text the card
+ *  already shows — each source's headline and the description beneath it — and
+ *  the same discipline the hub gate applies then filters them: no stop word, no
+ *  quantity, no class the graph's own identity rows name, nothing that reads as
+ *  a clause rather than a name. Sorted, so a card's background never depends on
+ *  the order the names came back in. */
+function cardArticleTerms(sources, articleEntityNames, { concepts, readsAsEntityTerm }) {
+  const texts = [];
+  for (const source of sources) {
+    if (source.title) texts.push(source.title);
+    if (source.summary) texts.push(source.summary);
+  }
+  if (!texts.length) return [];
+  const terms = new Set();
+  for (const name of articleEntityNames(texts) || []) {
+    const term = normFactTerm(name);
+    if (!term || STOP_SET.has(term) || isQuantityTerm(term) || concepts.has(term)) continue;
+    if (!readsAsEntityTerm(term)) continue;
+    terms.add(term);
+  }
+  return [...terms].sort();
 }
 
 /** newsworthyHubs -> one item per hub (PLAN_NEWS_FEED.md section 6.6),
@@ -666,19 +1334,66 @@ export function renderNewsParagraph(hub, subgraphRows, { reportedIds = null } =
  *  The gate (PLAN_NEWS_FEED.md section 17): `reportedRows` replaces `newsWindowRows`
  *  and `newsworthyHubs` replaces `scoreHubs` as this function's own inputs —
  *  both keep their prior behaviour for every other caller. Each item's
- *  two-hop sub-graph then splits into its own `reported`/`background` rows,
- *  so a card's paragraph draws from what was reported and its collapsed
- *  `backgroundParagraph` draws from what the graph already knew. */
-export function buildNewsItems(rows, { now, windowMs, limit = 6, sourcesByFactId = new Map(), readsAsEntityTerm } = {}) {
+ *  two-hop sub-graph then splits into its own `reported`/`background` rows:
+ *  the report leads the paragraph, the related background follows it, and
+ *  `backgroundParagraph` names that background at its own fuller depth for the
+ *  card's disclosure.
+ *
+ *  A card attributes a source to the rows it reports (hubReportRows) and to
+ *  nothing else. The two-hop walk reaches every row a shared class node
+ *  touches, so attributing the whole sub-graph gave one quake's card all 44 of
+ *  the day's quake headlines. An "Around it" neighbour is context the card
+ *  borrows, and it carries its own citation on its own card.
+ *
+ *  Between the gate and the render sit two more reads over the same reported
+ *  rows: `titledHubs` names each card after the entity its own report grounds
+ *  rather than a clause the report threw off, and `storyCoverage` leaves a
+ *  publication with only the stories no other card tells. Both are pure over
+ *  the fact set, so a feed built from the same rows in two orders still comes
+ *  back byte for byte.
+ *
+ *  `articleEntityNames`, when the caller supplies one, reads the entity names
+ *  out of the text of the sources a card shows (news.mjs wires the services
+ *  layer's own capture, the same one the enrichment ledger admits terms by).
+ *  Those entities widen the card's background: what the graph holds about a
+ *  name inside the headline now reaches the card, where before only the
+ *  endpoints of its own facts did. They never widen its report — the walk they
+ *  seed excludes every reported row — so what a card claims a source said is
+ *  untouched. */
+export function buildNewsItems(rows, {
+  now, windowMs, limit = 6, sourcesByFactId = new Map(), readsAsEntityTerm, articleEntityNames = null,
+} = {}) {
   const reported = reportedRows(rows, { now, windowMs });
   const reportedIds = new Set(reported.map((r) => r.id));
   const adjacency = buildTermAdjacency(rows);
   const prior = priorTerms(rows);
   const hubOptions = { now, windowMs, limit, adjacency, prior };
   if (readsAsEntityTerm) hubOptions.readsAsEntityTerm = readsAsEntityTerm;
-  const hubs = newsworthyHubs(rows, reported, hubOptions);
-  const items = hubs.map(({ term, changed }) => {
-    const subgraphRows = subgraphAround(rows, term, { adjacency, priorityIds: reportedIds });
+  const rowsByTerm = reportedRowsByTerm(reported);
+  const hubs = titledHubs(newsworthyHubs(rows, reported, hubOptions), rows, reported, rowsByTerm);
+  const coverage = storyCoverage(hubs, rowsByTerm);
+  const concepts = conceptTerms(rows);
+  const namesEntities = readsAsEntityTerm || looksLikeEntityTerm;
+  const items = hubs.filter(({ term }) => coverage.get(term).mints).map(({ term, changed }) => {
+    const coveredRowIds = coverage.get(term).coveredRowIds;
+    const hubRows = subgraphAround(rows, term, {
+      adjacency,
+      priorityIds: reportedIds,
+      seedTerms: hubSeedTerms(term),
+      excludeIds: coveredRowIds,
+    });
+    const sources = collectSources(hubReportRows(term, hubRows, { reportedIds }), sourcesByFactId);
+    const articleTerms = articleEntityNames
+      ? cardArticleTerms(sources, articleEntityNames, { concepts, readsAsEntityTerm: namesEntities })
+      : [];
+    const heldIds = new Set(hubRows.map((r) => r.id));
+    const articleRows = articleTerms.length
+      ? articleEntityRows(rows, articleTerms, {
+        adjacency,
+        excludeIds: new Set([...coveredRowIds, ...reportedIds]),
+      }).filter((r) => !heldIds.has(r.id))
+      : [];
+    const subgraphRows = articleRows.length ? [...hubRows, ...articleRows] : hubRows;
     const factIds = subgraphRows.map((r) => r.id).sort();
     const { background } = splitCardRows(subgraphRows, reportedIds);
     return {
@@ -687,11 +1402,11 @@ export function buildNewsItems(rows, { now, windowMs, limit = 6, sourcesByFactId
       factIds,
       changedCount: changed,
       builtAt: now,
-      paragraph: renderNewsParagraph(term, subgraphRows, { reportedIds }),
+      paragraph: renderNewsParagraph(term, subgraphRows, { reportedIds, articleTerms }),
       tier: tierOf(subgraphRows),
-      sources: collectSources(subgraphRows, sourcesByFactId),
+      sources,
       background: background.map((r) => r.id).sort(),
-      backgroundParagraph: renderNewsParagraph(term, background),
+      backgroundParagraph: renderKnownFactsParagraph(term, subgraphRows, { reportedIds, articleTerms }),
     };
   });
   return items.sort((a, b) => (toMs(b.builtAt) - toMs(a.builtAt)) || byId(a, b));