@polycode-projects/the-mechanical-code-talker 6.0.18 → 6.0.20

package/src/domain/news-feed.mjs

@@ -6,10 +6,11 @@
 // sortFactIndividualsById holds for a CRDT-merged fact set.
 
 import { sha256Bytes, normFactTerm } from "./hash.mjs";
-import { FACT_PREDICATE_PHRASES, predicatePhrase, factSentence } from "./fact-phrase.mjs";
+import { FACT_PREDICATE_PHRASES, predicatePhrase, predicateVerb, factSentence } from "./fact-phrase.mjs";
 import { STOP_SET } from "./hub-terms.mjs";
 import { articleFor } from "./digest/words.mjs";
 import { provenanceTagToSource } from "./memory/trust.mjs";
+import { buildSenseScope } from "./sense-scope.mjs";
 
 export const NEWS_HUB_HOPS = 2; // fixed by design, not a knob
 
@@ -71,6 +72,72 @@ export function newsWindowRows(rows, { now, windowMs }) {
   });
 }
 
+// ---------------------------------------------------------------------------
+// Attributions: who a report said its claim came from.
+// ---------------------------------------------------------------------------
+
+// A reified attribution names its claim by that claim's own group id, so its
+// subject is "fact:" and sixteen hex — normFactTerm's own carve-out shape, and
+// nothing a source ever writes as a term.
+const FACT_REFERENCE_TERM_RE = /^fact:[0-9a-f]{16}$/;
+
+// A fact id is minted lowercase, and both the claim's own `id` and the
+// attribution's subject go through this before either is used as a key — a
+// speaker matched on one spelling and stored under another is a silent drop.
+const factIdKey = (term) => String(term ?? "").trim().toLowerCase();
+
+const namesAFactRow = (term) => FACT_REFERENCE_TERM_RE.test(factIdKey(term));
+
+/** The fact `row` is ABOUT, when either of its sides names one rather than a
+ *  thing, else "". */
+function referencedFactId(row) {
+  const subject = factIdKey(row?.subject);
+  if (namesAFactRow(subject)) return subject;
+  const object = factIdKey(row?.object);
+  return namesAFactRow(object) ? object : "";
+}
+
+/** True when `row` is about another row rather than about the world. Every card
+ *  lane scores, walks and prints terms, and `looksLikeEntityTerm` reads a bare
+ *  `fact:285cf1618315591b` as a perfectly good one-word name, so a row like this
+ *  loose in a lane can head a card with a hex id. */
+export function isFactReferenceRow(row) {
+  return Boolean(referencedFactId(row));
+}
+
+const ATTRIBUTED_TO_PREDICATE = "mgx:attributedTo";
+
+/** Splits a fact set once, at the door: the claims a card may read, and the
+ *  speakers each claim was attributed to (claim group id -> speaker[], sorted).
+ *  Everything downstream — the hub gate, the adjacency index, the walk, the
+ *  sentences, a card's own `factIds` — takes `claims`, so an attribution reaches
+ *  no lane at all and the suppression cannot be missed one lane at a time.
+ *
+ *  Pure and order-independent: one claim's speakers come back in the same sorted
+ *  order whichever order the attributions arrived in, and a claim the fact set
+ *  never names simply has no entry — an attribution can arrive before its claim,
+ *  after it, or without it. */
+export function partitionAttributions(rows) {
+  const claims = [];
+  const named = new Map();
+  for (const row of rows) {
+    if (!isFactReferenceRow(row)) {
+      claims.push(row);
+      continue;
+    }
+    if (row.predicate !== ATTRIBUTED_TO_PREDICATE) continue;
+    const claimId = factIdKey(row.subject);
+    const speaker = String(row.object ?? "").trim();
+    if (!claimId || !speaker) continue;
+    let speakers = named.get(claimId);
+    if (!speakers) named.set(claimId, (speakers = new Set()));
+    speakers.add(speaker);
+  }
+  const speakersByClaimId = new Map();
+  for (const [claimId, speakers] of named) speakersByClaimId.set(claimId, [...speakers].sort());
+  return { claims, speakersByClaimId };
+}
+
 // ---------------------------------------------------------------------------
 // Item identity: what makes two fetched snapshots the same newsworthy item.
 // ---------------------------------------------------------------------------
@@ -306,6 +373,27 @@ const ENTITY_TRAILING_AUXILIARY_WORDS = new Set([
   "is", "are", "was", "were", "be", "been", "being", "am", "has", "have", "had",
 ]);
 
+// A name is one noun phrase, so a word that opens a new phrase or clause
+// BETWEEN a term's first and last word marks a headline a frame tore into
+// subject + predicate + remainder ("colombia as rescuers free quake victim").
+// Mirrors extract-facts.mjs's INTERIOR_CLAUSE_WORDS, for the same reason the
+// sets above mirror their originals. "of" stays out: real names are built with
+// it ("house of representatives").
+// A term the source itself wrapped in quotation marks is a title it quoted, and
+// a title is free to read as a clause. Mirrors extract-facts.mjs's own
+// QUOTED_TERM_RE, and exempts the interior rule alone.
+const ENTITY_QUOTED_TERM_RE = /^["“'‘].*["”'’]$/;
+const ENTITY_INTERIOR_CLAUSE_WORDS = new Set([
+  "a", "an", "the",
+  "and", "or", "but", "because", "since", "although", "though", "whereas", "while", "so",
+  "if", "when", "then", "however", "as", "that", "which", "who", "whom", "whose",
+  "is", "are", "was", "were", "be", "been", "being", "am", "has", "have", "had",
+  "do", "does", "did", "can", "could", "will", "would", "should", "may", "might", "must",
+  "in", "on", "at", "for", "to", "with", "from", "by", "into", "onto",
+  "over", "under", "after", "before", "between", "during", "about", "near", "through",
+  "against", "among", "within", "without", "per",
+]);
+
 /** Does `term` read as a thing's name rather than a clause fragment? Bounds
  *  the word count and rejects a leading conjunction, auxiliary or
  *  preposition (test E's condition 3, PLAN_NEWSWORTHINESS.md section 2), plus
@@ -321,6 +409,11 @@ function looksLikeEntityTerm(term) {
   if (ENTITY_PARTICLE_LEAD_WORDS.has(first)) return false;
   if (ENTITY_PRONOUN_LEAD_WORDS.has(first.replace(ENTITY_CLITIC_SUFFIX_RE, ""))) return false;
   if (ENTITY_TRAILING_AUXILIARY_WORDS.has(words[words.length - 1].toLowerCase())) return false;
+  if (!ENTITY_QUOTED_TERM_RE.test(`${words[0]} ${words[words.length - 1]}`)) {
+    for (let i = 1; i < words.length - 1; i += 1) {
+      if (ENTITY_INTERIOR_CLAUSE_WORDS.has(words[i].toLowerCase())) return false;
+    }
+  }
   return true;
 }
 
@@ -527,33 +620,52 @@ export function hubSeedTerms(hub) {
  *  `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. */
+ *  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.
+ *
+ *  `inSense` is the same-sense discipline (sense-scope.mjs): a `(term) =>
+ *  boolean` test the walk applies to every term that is not a seed. A term it
+ *  refuses collects no row and joins no frontier, so the walk stays inside the
+ *  seeds' own sense instead of climbing a shared class node and coming back
+ *  down another meaning of it. What a source actually REPORTED about a seed is
+ *  exempt: a card never drops its own news to keep a sense tidy. */
 export function subgraphAround(rows, hub, {
   hops = NEWS_HUB_HOPS, cap = 60, adjacency = null, priorityIds = null, seedTerms = null,
+  excludeIds = null, inSense = null,
 } = {}) {
   const adj = adjacency ?? buildTermAdjacency(rows);
   const hubTerm = normFactTerm(hub);
   const seeds = (seedTerms?.length ? seedTerms : [hubTerm]).map((t) => normFactTerm(t)).filter(Boolean);
   const visited = new Set(seeds);
+  const seedSet = 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;
+  const isPriority = (id) => (priorityIds instanceof Set ? priorityIds.has(id) : Boolean(priorityIds?.includes?.(id)));
+  const inScope = typeof inSense === "function" ? (term) => seedSet.has(term) || inSense(term) : () => true;
   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;
+        const [s, o] = adj.terms[idx];
+        const staysInSense = inScope(s) && inScope(o);
+        const isOwnReport = isPriority(row.id) && (seedSet.has(s) || seedSet.has(o));
+        if (!staysInSense && !isOwnReport) continue;
         collected.set(row.id, row);
         if (!hopOf.has(row.id)) hopOf.set(row.id, hop);
-        const [s, o] = adj.terms[idx];
-        if (!visited.has(s)) nextFrontier.add(s);
-        if (!visited.has(o)) nextFrontier.add(o);
+        if (!visited.has(s) && inScope(s)) nextFrontier.add(s);
+        if (!visited.has(o) && inScope(o)) nextFrontier.add(o);
       }
     }
     for (const term of nextFrontier) visited.add(term);
     frontier = [...nextFrontier].sort();
   }
-  const isPriority = (id) => (priorityIds instanceof Set ? priorityIds.has(id) : Boolean(priorityIds?.includes?.(id)));
   return [...collected.values()]
     .sort((a, b) => (isPriority(b.id) - isPriority(a.id))
       || (hopOf.get(a.id) - hopOf.get(b.id))
@@ -561,6 +673,32 @@ export function subgraphAround(rows, hub, {
     .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, inSense = null,
+} = {}) {
+  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, inSense,
+  });
+}
+
 /** 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. */
@@ -616,6 +754,50 @@ function joinWithAnd(items) {
   return `${items.slice(0, -1).join(", ")} and ${items[items.length - 1]}`;
 }
 
+/** The speakers `speakersByClaimId` attributes to `rows`, deduped and sorted.
+ *  Empty for rows nothing attributed, which is every row until a report stores
+ *  one. */
+function speakersFor(rows, speakersByClaimId) {
+  if (!(speakersByClaimId instanceof Map) || !speakersByClaimId.size) return [];
+  const named = new Set();
+  for (const row of rows) {
+    for (const speaker of speakersByClaimId.get(factIdKey(row.id)) ?? []) named.add(speaker);
+  }
+  return [...named].sort();
+}
+
+/** ", president trump said" — the article's own construction, folded onto the
+ *  end of the claim's own sentence rather than printed as apparatus beside it. */
+function speakerClause(speakers) {
+  return speakers.length ? `, ${joinWithAnd(speakers)} said` : "";
+}
+
+/** One row's whole sentence with its own speaker folded in. */
+function attributedFactSentence(row, speakersByClaimId) {
+  return `${factSentence(row)}${speakerClause(speakersFor([row], speakersByClaimId))}`;
+}
+
+/** The speaker clause a GROUPED sentence may carry. One sentence stands for
+ *  several rows, so the clause is only true where the attributed rows among them
+ *  already name every object the sentence prints. A group whose UNattributed row
+ *  brings an object of its own would put that object in a speaker's mouth, so
+ *  the clause drops whole rather than narrowing to a sentence it no longer
+ *  describes. */
+function groupSpeakerClause(rows, printedObjects, speakersByClaimId) {
+  if (!(speakersByClaimId instanceof Map) || !speakersByClaimId.size) return "";
+  const named = new Set();
+  const spokenObjects = new Set();
+  for (const row of rows) {
+    const speakers = speakersByClaimId.get(factIdKey(row.id));
+    if (!speakers?.length) continue;
+    for (const speaker of speakers) named.add(speaker);
+    spokenObjects.add(row.object);
+  }
+  if (!named.size) return "";
+  if (!printedObjects.every((object) => spokenObjects.has(object))) return "";
+  return speakerClause([...named].sort());
+}
+
 // ---------------------------------------------------------------------------
 // What one card reports, and whose neighbourhood it sits in.
 // ---------------------------------------------------------------------------
@@ -721,6 +903,32 @@ const KNOWN_FACT_SENTENCE_CAP = 2;
 // wall of text.
 const OBJECTS_PER_SENTENCE = 6;
 
+// Two report rows on one card can state ONE act under two words: a headline
+// says a prisoner was "freed", the description says "released", and the graph
+// is right to hold both edges because two different sentences really said so.
+// The card is the thing that should say it once.
+//
+// The fold is here, at assembly, and NOT at extraction, because only here is
+// the whole row set in view. Extraction reads one verb at a time, and folding
+// "free" onto "release" there turned "rescuers free quake victim" into a jail
+// delivery: the two senses of "free" split on the subject's kind, an open set,
+// and a headline carries nothing to tell them apart. A card folds only where
+// BOTH verbs already stand over the SAME subject naming the SAME people, which
+// is the evidence extraction never had. A rescue card carries "free" alone, so
+// nothing folds and it still reads as a rescue.
+//
+// The bar for a pair is that the two words name one act wherever a card can
+// hold both. Verbs that merely share a subject and an object stay apart,
+// opposites first among them: "russia detains X" and "russia releases X" are
+// two claims about one prisoner, they are in no group together, and each keeps
+// its own sentence.
+const ONE_ACT_VERB_GROUPS = [
+  ["free", "release"],
+];
+const ONE_ACT_CANONICAL_VERB = new Map(
+  ONE_ACT_VERB_GROUPS.flatMap((group) => group.map((verb) => [verb, group[0]])),
+);
+
 // 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.
@@ -768,40 +976,58 @@ function identityFans(subgraphRows) {
   return { senseFan, sourcedSenseFan, categoryFan };
 }
 
-/** What this card is ABOUT: its hub, the region of a hub the source spelled
- *  "settlement, region", and the other terms its own report sentences name —
- *  minus any of those that reads across senses. A quake card's report
+// 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. */
-function cardSubjectTerms(hub, subgraphRows, { reportedIds = null, senseFan }) {
+ *  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 Set(hubSeedTerms(hubTerm));
+  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]) {
-      const term = normFactTerm(raw);
-      if (!term || terms.has(term) || STOP_SET.has(term)) continue;
-      if ((senseFan.get(term) || 0) > IDENTITY_MAX_CLASSES) continue;
-      terms.add(term);
-    }
+    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 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 } = {}) {
+ *  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 });
+  const subjects = cardSubjectTerms(hub, subgraphRows, { reportedIds, senseFan, articleTerms });
   const neighbourIds = new Set(neighbourRows(hub, subgraphRows, { reportedIds }).map((r) => r.id));
 
   const scored = [];
@@ -822,14 +1048,14 @@ export function knownFactRows(hub, subgraphRows, { reportedIds = null, limit = K
     if ((categoryFan.get(other) || 0) > CATEGORY_FAN_MAX) continue;
     scored.push({
       row,
-      anchorIsHub: anchor === hubTerm,
+      anchorRank: subjects.get(anchor),
       otherCategoryFan: categoryFan.get(other) || 0,
       otherSenseFan: senseFan.get(other) || 0,
     });
   }
 
   return scored
-    .sort((a, b) => (Number(b.anchorIsHub) - Number(a.anchorIsHub))
+    .sort((a, b) => (a.anchorRank - b.anchorRank)
       || (a.otherCategoryFan - b.otherCategoryFan)
       || (a.otherSenseFan - b.otherSenseFan)
       || byId(a.row, b.row))
@@ -854,58 +1080,113 @@ function predicatesInRenderOrder(rows) {
   return [...curated, ...rest];
 }
 
+/** The act a report predicate states, as the key two predicates share when
+ *  they say it in one word: the predicate's verb lemma folded onto its group's
+ *  canonical verb, with any particle beside it, so `tmct:releases` and
+ *  `mgx:free` both read "release" while `mgx:strike-near` stays apart from
+ *  `mgx:strike`. Empty for a predicate that states no act at all (an identity
+ *  row, a comparative, a passive participle), which folds with nothing. */
+function oneActKey(predicate) {
+  const verb = predicateVerb(predicate);
+  if (!verb) return "";
+  return `${ONE_ACT_CANONICAL_VERB.get(verb.lemma) ?? verb.lemma} ${verb.particle}`;
+}
+
 /** 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. */
-function groupedFactSentences(rows) {
+ *  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, speakersByClaimId = null) {
   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: [] }));
+    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 }) => {
+  return [...groups.values()].map(({ subject, predicate, objects, rows: groupRows }) => {
     const sorted = [...objects].sort();
-    const rendered = IDENTITY_PREDICATES.has(predicate)
-      ? sorted.map((object) => `${articleFor(object)} ${object}`)
-      : sorted;
-    return `${subject} ${predicatePhrase(predicate, subject)} ${joinObjects(rendered)}`;
+    // "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: `${text}${groupSpeakerClause(groupRows, sorted, speakersByClaimId)}`, rows: groupRows };
   });
 }
 
+function groupedFactSentences(rows, speakersByClaimId = null) {
+  return groupedFactSentenceEntries(rows, speakersByClaimId).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. 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 } = {}) {
+ *  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 = [], speakersByClaimId = null } = {}) {
   const hubTerm = normFactTerm(hub);
   const isReported = idMembership(reportedIds);
   const hubRows = subgraphRows.filter((r) => normFactTerm(r.subject) === hubTerm);
   const reportedHubRows = hubRows.filter((r) => isReported(r.id));
-  const report = [];
+  // Every sentence here shares the one subject, so the act key and the objects
+  // are all that separate two of them. A predicate whose act a sentence above
+  // it has already stated, over people that sentence already names, adds no
+  // word a reader has not read — its rows join the sentence that says their
+  // act, so a fact still counts as printed and the fold can lose nothing. A
+  // predicate that brings a new name to the act keeps its own sentence.
+  const reportGroups = [];
+  const statedActs = new Map();
   for (const predicate of predicatesInRenderOrder(reportedHubRows)) {
-    if (IDENTITY_PREDICATES.has(predicate) || report.length >= REPORT_SENTENCE_CAP) continue;
-    const objects = reportedHubRows
-      .filter((r) => r.predicate === predicate)
-      .map((r) => r.object)
-      .sort();
+    if (IDENTITY_PREDICATES.has(predicate) || reportGroups.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;
-    report.push(`${hub} ${predicatePhrase(predicate, hub)} ${joinObjects(objects)}`);
+    const actKey = oneActKey(predicate);
+    const stated = actKey ? statedActs.get(actKey) : null;
+    if (stated && objects.every((object) => stated.objects.has(object))) {
+      stated.group.rows.push(...groupRows);
+      continue;
+    }
+    const group = { text: `${hub} ${predicatePhrase(predicate, hub)} ${joinObjects(objects)}`, rows: groupRows, objects };
+    reportGroups.push(group);
+    if (actKey && !stated) statedActs.set(actKey, { group, objects: new Set(objects) });
   }
+  // The speaker is read off the whole group, once the fold above has finished
+  // moving rows into it — the row an article attributed is often the FOLDED one,
+  // not the row whose words the sentence ended up wearing.
+  const report = reportGroups.map(({ text, rows: groupRows, objects }) => ({
+    text: `${text}${groupSpeakerClause(groupRows, objects, speakersByClaimId)}`,
+    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 (!report.length) {
-    const aboutHub = subgraphRows
+    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) report.push(aboutHub.join("; "));
+      .slice(0, OBJECTS_PER_SENTENCE);
+    if (aboutHubRows.length) {
+      report.push({
+        text: aboutHubRows.map((r) => attributedFactSentence(r, speakersByClaimId)).join("; "),
+        rows: aboutHubRows,
+      });
+    }
   }
 
   // The identity clause follows the news, never leads it, and only when
@@ -913,23 +1194,48 @@ function paragraphBlocks(hub, subgraphRows, { reportedIds = null } = {}) {
   // 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 identityObjects = hubRows
-    .filter((r) => IDENTITY_PREDICATES.has(r.predicate) && !isDerivedRow(r))
-    .map((r) => r.object)
-    .sort();
+  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(`${hub} is ${joinObjects(identityObjects.map((object) => `${articleFor(object)} ${object}`))}`);
+    const said = groupSpeakerClause(identityRows, identityObjects, speakersByClaimId);
+    identity.push({
+      text: `${hub} is ${joinObjects(identityObjects.map((object) => `${articleFor(object)} ${object}`))}${said}`,
+      rows: identityRows,
+    });
   }
 
-  const known = groupedFactSentences(knownFactRows(hub, subgraphRows, { reportedIds }));
+  const known = groupedFactSentenceEntries(
+    knownFactRows(hub, subgraphRows, { reportedIds, articleTerms }),
+    speakersByClaimId,
+  );
 
   const neighbours = neighbourRows(hub, subgraphRows, { reportedIds });
-  const around = neighbours.length ? [`Around it: ${neighbours.map((r) => factSentence(r)).join("; ")}`] : [];
+  const around = neighbours.length
+    ? [{
+      text: `Around it: ${neighbours.map((r) => attributedFactSentence(r, speakersByClaimId)).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 = [], speakersByClaimId = null } = {}) {
+  const { report, identity, known, around } = paragraphBlocks(hub, subgraphRows, { reportedIds, articleTerms, speakersByClaimId });
+  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,
@@ -940,29 +1246,403 @@ function paragraphBlocks(hub, subgraphRows, { reportedIds = null } = {}) {
  *  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 } = {}) {
-  const { report, identity, known, around } = paragraphBlocks(hub, subgraphRows, { reportedIds });
-  const sentences = [
-    ...report,
-    ...identity.slice(0, IDENTITY_SENTENCE_CAP),
-    ...known.slice(0, KNOWN_FACT_SENTENCE_CAP),
-    ...around,
-  ].slice(0, SENTENCE_CAP);
+export function renderNewsParagraph(hub, subgraphRows, { reportedIds = null, articleTerms = [], speakersByClaimId = null } = {}) {
+  const sentences = paragraphSentenceEntries(hub, subgraphRows, { reportedIds, articleTerms, speakersByClaimId })
+    .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 = [], speakersByClaimId = null } = {}) {
+  return paragraphSentenceEntries(hub, subgraphRows, { reportedIds, articleTerms, speakersByClaimId })
+    .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 } = {}) {
-  const sentences = groupedFactSentences(knownFactRows(hub, subgraphRows, { reportedIds }));
+export function renderKnownFactsParagraph(hub, subgraphRows, { reportedIds = null, articleTerms = [], speakersByClaimId = null } = {}) {
+  const sentences = groupedFactSentences(
+    knownFactRows(hub, subgraphRows, { reportedIds, articleTerms }),
+    speakersByClaimId,
+  );
   return sentences.length ? `${sentences.join(". ")}.` : "";
 }
 
+// ---------------------------------------------------------------------------
+// What a card says beyond its own headline.
+// ---------------------------------------------------------------------------
+
+// Two spellings of one headline — the source's own capitals and punctuation,
+// and the quoted, lower-cased form a fact's object carries — fold to the same
+// key, so the comparison answers to the words alone.
+const HEADLINE_NOISE_RE = /[^a-z0-9]+/g;
+
+const headlineKey = (text) => String(text ?? "").toLowerCase().replace(HEADLINE_NOISE_RE, " ").trim();
+
+/** Every term this card is about: its hub, whatever its own reports name, and
+ *  the entities its article names. Deliberately looser than
+ *  `cardSubjectTerms` — that one picks what a SENTENCE may draw on, and drops
+ *  a term the graph reads across senses; this one asks the plainer question of
+ *  what the card is about at all, which is what a count of held background
+ *  answers to. */
+function cardAboutTerms(hub, reports, articleTerms) {
+  const terms = new Set(hubSeedTerms(normFactTerm(hub)));
+  for (const row of reports) {
+    for (const raw of [row.subject, row.object]) {
+      const term = normFactTerm(raw);
+      if (term) terms.add(term);
+    }
+  }
+  for (const raw of articleTerms) {
+    const term = normFactTerm(raw);
+    if (term) terms.add(term);
+  }
+  return terms;
+}
+
+/** What one card is carrying, and the reason a feed puts one card above
+ *  another.
+ *
+ *  `claims` are the card's own reports (`hubReportRows`) that say something
+ *  about the world. `headlineMentions` are its own reports whose object IS one
+ *  of its headlines — "hackernews discuss <that headline>", a true fact that
+ *  tells a reader nothing the card's own quoted report already prints.
+ *  `background` is what the graph holds about the terms the card is about:
+ *  the rows behind its "what the graph already knew" lines, counted before the
+ *  paragraph's own caps cut them, and never another card's report.
+ *
+ *  A source whose wire format carries no body can only ever mint headline
+ *  mentions, so a card off one lands at zero on both counts unless a lookup
+ *  attached something to a name in its headline. Those cards read last. They
+ *  still build, still cite their source, and `thin` marks them so a reader or
+ *  a bench run can count how many there were.
+ *
+ *  Pure over the rows and the headline strings. A card with no headlines to
+ *  compare against (a caller that wired no sources) counts every report as a
+ *  claim: nothing is demoted without the evidence to demote it. */
+export function cardSubstance(hub, subgraphRows, { reportedIds = null, articleTerms = [], headlines = [] } = {}) {
+  const isReported = idMembership(reportedIds);
+  const ownHeadlines = new Set(headlines.map(headlineKey).filter(Boolean));
+
+  const reports = hubReportRows(hub, subgraphRows, { reportedIds });
+  let claims = 0;
+  let headlineMentions = 0;
+  for (const row of reports) {
+    if (ownHeadlines.has(headlineKey(row.object))) headlineMentions += 1;
+    else claims += 1;
+  }
+
+  const about = cardAboutTerms(hub, reports, articleTerms);
+  let background = 0;
+  for (const row of subgraphRows) {
+    if (isReported(row.id) || isDerivedRow(row)) continue;
+    if (about.has(normFactTerm(row.subject)) || about.has(normFactTerm(row.object))) background += 1;
+  }
+
+  return { claims, background, headlineMentions, thin: claims === 0 && background === 0 };
+}
+
+/** How a feed orders two cards once their build moment is equal: the one that
+ *  reports more about the world first, then the one the graph holds more
+ *  around, then id. Reports outrank background on purpose — a card leads with
+ *  what a source said, and a hub whose common-noun object the seed graph
+ *  happens to know hundreds of edges about does not outrank a card carrying
+ *  more news. */
+function bySubstance(a, b) {
+  return (b.substance.claims - a.substance.claims) || (b.substance.background - a.substance.background);
+}
+
+// ---------------------------------------------------------------------------
+// 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",
+]);
+
+/** 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),
- *  paragraph included, sorted builtAt desc then id asc. `sourcesByFactId`
+ *  paragraph included, sorted builtAt desc, then by what the card carries
+ *  (`cardSubstance` through `bySubstance`), then id asc — every card of one
+ *  build shares a `builtAt`, so substance is what actually orders a feed, and
+ *  a card whose only fact restates its own headline reads after every card
+ *  with something to say. Nothing is dropped for being thin: each item carries
+ *  its own `substance` count instead. `sourcesByFactId`
  *  maps fact ids to snapshot source links ({ title, url, name, publishedAt?
  *  }); publishedAt is present only when the source snapshot carried one.
  *  The gate (PLAN_NEWS_FEED.md section 17): `reportedRows` replaces `newsWindowRows`
@@ -977,19 +1657,83 @@ export function renderKnownFactsParagraph(hub, subgraphRows, { reportedIds = nul
  *  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. */
-export function buildNewsItems(rows, { now, windowMs, limit = 6, sourcesByFactId = new Map(), readsAsEntityTerm } = {}) {
-  const reported = reportedRows(rows, { now, windowMs });
+ *  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. They also carry the card's sense when its hub is a phrase the
+ *  bands never place: the hub walk then keeps to the senses of the names the
+ *  article uses, where before it kept to nothing. */
+export function buildNewsItems(rows, {
+  now, windowMs, limit = 6, sourcesByFactId = new Map(), readsAsEntityTerm, articleEntityNames = null,
+} = {}) {
+  // Every lane below reads `claimRows`, never `rows`: the hub gate, the
+  // adjacency index both walks share, the prior/concept/sense reads, the
+  // sentences, and each card's own `factIds`. An attribution says something
+  // about a row rather than about the world, and a lane handed one can score it
+  // as a hub and head a card with a hex id.
+  const { claims: claimRows, speakersByClaimId } = partitionAttributions(rows);
+  const reported = reportedRows(claimRows, { now, windowMs });
   const reportedIds = new Set(reported.map((r) => r.id));
-  const adjacency = buildTermAdjacency(rows);
-  const prior = priorTerms(rows);
+  const adjacency = buildTermAdjacency(claimRows);
+  const prior = priorTerms(claimRows);
   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, seedTerms: hubSeedTerms(term),
-    });
+  const rowsByTerm = reportedRowsByTerm(reported);
+  const hubs = titledHubs(newsworthyHubs(claimRows, reported, hubOptions), claimRows, reported, rowsByTerm);
+  const coverage = storyCoverage(hubs, rowsByTerm);
+  const concepts = conceptTerms(claimRows);
+  const namesEntities = readsAsEntityTerm || looksLikeEntityTerm;
+  const senseScope = buildSenseScope(claimRows);
+  const items = hubs.filter(({ term }) => coverage.get(term).mints).map(({ term, changed }) => {
+    const coveredRowIds = coverage.get(term).coveredRowIds;
+    const seeds = hubSeedTerms(term);
+    const hubWalk = {
+      adjacency,
+      priorityIds: reportedIds,
+      seedTerms: seeds,
+      excludeIds: coveredRowIds,
+    };
+    // The card's sources have to be read before its sense can be chosen, and a
+    // walk that admits no background at all is enough to read them: a report on
+    // the hub sits on a seed, and every scope admits those. So this pass and
+    // the real one below hand `hubReportRows` the same rows.
+    const reportedRowsOnly = subgraphAround(claimRows, term, { ...hubWalk, inSense: () => false });
+    const sources = collectSources(hubReportRows(term, reportedRowsOnly, { reportedIds }), sourcesByFactId);
+    const articleTerms = articleEntityNames
+      ? cardArticleTerms(sources, articleEntityNames, { concepts, readsAsEntityTerm: namesEntities })
+      : [];
+    // A hub the bands never place has no sense of its own, so a scope anchored
+    // on it refuses nothing and the walk fills the card with whatever it meets.
+    // The entities the article names carry the card's sense instead, so its
+    // background stays tied to its own text. When the bands place none of those
+    // names either, the card keeps to the unplaced and reads sparse, which is
+    // the price of not filling a card about a coined phrase with strays.
+    const hubSense = senseScope.hasPlacedSense(seeds)
+      ? senseScope.sameSenseAs(seeds)
+      : senseScope.sameSenseAs([...seeds, ...articleTerms], { admitAllWhenUnplaced: false });
+    const hubRows = subgraphAround(claimRows, term, { ...hubWalk, inSense: hubSense });
+    const heldIds = new Set(hubRows.map((r) => r.id));
+    const articleRows = articleTerms.length
+      ? articleEntityRows(claimRows, articleTerms, {
+        adjacency,
+        excludeIds: new Set([...coveredRowIds, ...reportedIds]),
+        inSense: senseScope.sameSenseAs(articleTerms),
+      }).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 {
@@ -997,15 +1741,18 @@ export function buildNewsItems(rows, { now, windowMs, limit = 6, sourcesByFactId
       hub: term,
       factIds,
       changedCount: changed,
+      substance: cardSubstance(term, subgraphRows, {
+        reportedIds, articleTerms, headlines: sources.map((s) => s.title),
+      }),
       builtAt: now,
-      paragraph: renderNewsParagraph(term, subgraphRows, { reportedIds }),
+      paragraph: renderNewsParagraph(term, subgraphRows, { reportedIds, articleTerms, speakersByClaimId }),
       tier: tierOf(subgraphRows),
-      sources: collectSources(hubReportRows(term, subgraphRows, { reportedIds }), sourcesByFactId),
+      sources,
       background: background.map((r) => r.id).sort(),
-      backgroundParagraph: renderKnownFactsParagraph(term, subgraphRows, { reportedIds }),
+      backgroundParagraph: renderKnownFactsParagraph(term, subgraphRows, { reportedIds, articleTerms, speakersByClaimId }),
     };
   });
-  return items.sort((a, b) => (toMs(b.builtAt) - toMs(a.builtAt)) || byId(a, b));
+  return items.sort((a, b) => (toMs(b.builtAt) - toMs(a.builtAt)) || bySubstance(a, b) || byId(a, b));
 }
 
 // A `news:` tag, matched wherever it sits in a fact's provenance — bare
@@ -1018,19 +1765,42 @@ export function buildNewsItems(rows, { now, windowMs, limit = 6, sourcesByFactId
 // is the deliberate exclusion the fixture-replay rows need.
 const NEWS_PROVENANCE_RE = /(?:^|[:|]\s*)news:/;
 
-/** News-tagged fact ids to retract, oldest observedAt first, ties by id —
- *  the eviction the service applies at ingest time so the graph cannot grow
- *  past `cap` unattended. Never selects a seed/taught/research/fixture-
- *  replay row. */
+/** News-tagged fact ids to retract, oldest observation first, ties by id — the
+ *  eviction the service applies at ingest time so the graph cannot grow past
+ *  `cap` unattended. Never selects a seed/taught/research/fixture-replay row.
+ *
+ *  A claim and the attributions naming it evict as ONE unit. They carry the same
+ *  news tag and the same stamp but not the same id, so choosing row by row
+ *  routinely kept one half and dropped the other, leaving a speaker with no
+ *  claim or a claim whose surface can no longer say who said it. A unit that
+ *  straddles the cap goes whole: the graph lands under `cap`, never on half a
+ *  pair.
+ *
+ *  The stamp comes from `rowObservedMs`, which is where a read row actually
+ *  carries it — `readFactRows` keeps observedAt on the assertion records, so
+ *  reading `row.observedAt` scored every real news row 0 and left the cap
+ *  evicting by id order. */
 export function evictNewsFacts(rows, { cap }) {
   const newsRows = rows.filter((r) => NEWS_PROVENANCE_RE.test(String(r.provenance || "")));
   if (newsRows.length <= cap) return [];
-  const sorted = newsRows.slice().sort((a, b) => {
-    const at = toMs(a.observedAt || "");
-    const bt = toMs(b.observedAt || "");
-    const an = Number.isFinite(at) ? at : 0;
-    const bn = Number.isFinite(bt) ? bt : 0;
-    return an - bn || byId(a, b);
-  });
-  return sorted.slice(0, newsRows.length - cap).map((r) => r.id);
+
+  const units = new Map();
+  for (const row of newsRows) {
+    const key = referencedFactId(row) || row.id;
+    let unit = units.get(key);
+    if (!unit) units.set(key, (unit = { key, ids: [], observedMs: Infinity }));
+    unit.ids.push(row.id);
+    const t = rowObservedMs(row);
+    unit.observedMs = Math.min(unit.observedMs, Number.isFinite(t) ? t : 0);
+  }
+
+  const target = newsRows.length - cap;
+  const evicted = [];
+  const oldestFirst = [...units.values()]
+    .sort((a, b) => a.observedMs - b.observedMs || (a.key < b.key ? -1 : a.key > b.key ? 1 : 0));
+  for (const unit of oldestFirst) {
+    if (evicted.length >= target) break;
+    evicted.push(...unit.ids.slice().sort());
+  }
+  return evicted;
 }