@polycode-projects/the-mechanical-code-talker 6.0.19 → 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;
 }
 
@@ -531,35 +624,48 @@ export function hubSeedTerms(hub) {
  *
  *  `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. */
+ *  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,
+  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))
@@ -584,12 +690,12 @@ const ARTICLE_ENTITY_ROW_CAP = 24;
  *  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,
+  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,
+    hops: ARTICLE_ENTITY_HOPS, cap, adjacency, seedTerms, excludeIds, inSense,
   });
 }
 
@@ -648,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.
 // ---------------------------------------------------------------------------
@@ -753,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.
@@ -904,6 +1080,18 @@ 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.
@@ -911,7 +1099,7 @@ function predicatesInRenderOrder(rows) {
  *  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) {
+function groupedFactSentenceEntries(rows, speakersByClaimId = null) {
   const groups = new Map();
   for (const row of rows) {
     const key = `${row.subject}${row.predicate}`;
@@ -931,12 +1119,12 @@ function groupedFactSentenceEntries(rows) {
     const text = predicate === "rdf:type"
       ? `${subject} is ${joinObjects(sorted.map((object) => `${articleFor(object)} ${object}`))}`
       : `${subject} ${predicatePhrase(predicate, subject)} ${joinObjects(sorted)}`;
-    return { text, rows: groupRows };
+    return { text: `${text}${groupSpeakerClause(groupRows, sorted, speakersByClaimId)}`, rows: groupRows };
   });
 }
 
-function groupedFactSentences(rows) {
-  return groupedFactSentenceEntries(rows).map((entry) => entry.text);
+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
@@ -948,19 +1136,41 @@ function groupedFactSentences(rows) {
  *  `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 = [] } = {}) {
+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;
+    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({ text: `${hub} ${predicatePhrase(predicate, hub)} ${joinObjects(objects)}`, rows: groupRows });
+    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,
@@ -972,7 +1182,10 @@ function paragraphBlocks(hub, subgraphRows, { reportedIds = null, articleTerms =
       .sort(byId)
       .slice(0, OBJECTS_PER_SENTENCE);
     if (aboutHubRows.length) {
-      report.push({ text: aboutHubRows.map((r) => factSentence(r)).join("; "), rows: aboutHubRows });
+      report.push({
+        text: aboutHubRows.map((r) => attributedFactSentence(r, speakersByClaimId)).join("; "),
+        rows: aboutHubRows,
+      });
     }
   }
 
@@ -985,17 +1198,24 @@ function paragraphBlocks(hub, subgraphRows, { reportedIds = null, articleTerms =
   const identityObjects = identityRows.map((r) => r.object).sort();
   const identityIsSingleSense = identityObjects.length > 0 && identityObjects.length <= IDENTITY_MAX_CLASSES;
   if (identityIsSingleSense) {
+    const said = groupSpeakerClause(identityRows, identityObjects, speakersByClaimId);
     identity.push({
-      text: `${hub} is ${joinObjects(identityObjects.map((object) => `${articleFor(object)} ${object}`))}`,
+      text: `${hub} is ${joinObjects(identityObjects.map((object) => `${articleFor(object)} ${object}`))}${said}`,
       rows: identityRows,
     });
   }
 
-  const known = groupedFactSentenceEntries(knownFactRows(hub, subgraphRows, { reportedIds, articleTerms }));
+  const known = groupedFactSentenceEntries(
+    knownFactRows(hub, subgraphRows, { reportedIds, articleTerms }),
+    speakersByClaimId,
+  );
 
   const neighbours = neighbourRows(hub, subgraphRows, { reportedIds });
   const around = neighbours.length
-    ? [{ text: `Around it: ${neighbours.map((r) => factSentence(r)).join("; ")}`, rows: neighbours }]
+    ? [{
+      text: `Around it: ${neighbours.map((r) => attributedFactSentence(r, speakersByClaimId)).join("; ")}`,
+      rows: neighbours,
+    }]
     : [];
 
   return { report, identity, known, around };
@@ -1006,8 +1226,8 @@ function paragraphBlocks(hub, subgraphRows, { reportedIds = null, articleTerms =
  *  (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 });
+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),
@@ -1026,8 +1246,9 @@ function paragraphSentenceEntries(hub, subgraphRows, { reportedIds = null, artic
  *  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);
+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(". ")}.` : "";
 }
 
@@ -1037,8 +1258,9 @@ export function renderNewsParagraph(hub, subgraphRows, { reportedIds = null, art
  *  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);
+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
@@ -1046,11 +1268,98 @@ export function printedParagraphRows(hub, subgraphRows, { reportedIds = null, ar
  *  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 }));
+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.
 // ---------------------------------------------------------------------------
@@ -1328,7 +1637,12 @@ function cardArticleTerms(sources, articleEntityNames, { concepts, readsAsEntity
 }
 
 /** 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`
@@ -1359,38 +1673,64 @@ function cardArticleTerms(sources, articleEntityNames, { concepts, readsAsEntity
  *  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. */
+ *  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,
 } = {}) {
-  const reported = reportedRows(rows, { now, windowMs });
+  // 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 rowsByTerm = reportedRowsByTerm(reported);
-  const hubs = titledHubs(newsworthyHubs(rows, reported, hubOptions), rows, reported, rowsByTerm);
+  const hubs = titledHubs(newsworthyHubs(claimRows, reported, hubOptions), claimRows, reported, rowsByTerm);
   const coverage = storyCoverage(hubs, rowsByTerm);
-  const concepts = conceptTerms(rows);
+  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 hubRows = subgraphAround(rows, term, {
+    const seeds = hubSeedTerms(term);
+    const hubWalk = {
       adjacency,
       priorityIds: reportedIds,
-      seedTerms: hubSeedTerms(term),
+      seedTerms: seeds,
       excludeIds: coveredRowIds,
-    });
-    const sources = collectSources(hubReportRows(term, hubRows, { reportedIds }), sourcesByFactId);
+    };
+    // 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(rows, articleTerms, {
+      ? 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;
@@ -1401,15 +1741,18 @@ export function buildNewsItems(rows, {
       hub: term,
       factIds,
       changedCount: changed,
+      substance: cardSubstance(term, subgraphRows, {
+        reportedIds, articleTerms, headlines: sources.map((s) => s.title),
+      }),
       builtAt: now,
-      paragraph: renderNewsParagraph(term, subgraphRows, { reportedIds, articleTerms }),
+      paragraph: renderNewsParagraph(term, subgraphRows, { reportedIds, articleTerms, speakersByClaimId }),
       tier: tierOf(subgraphRows),
       sources,
       background: background.map((r) => r.id).sort(),
-      backgroundParagraph: renderKnownFactsParagraph(term, subgraphRows, { reportedIds, articleTerms }),
+      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
@@ -1422,19 +1765,42 @@ export function buildNewsItems(rows, {
 // 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;
 }