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

package/src/services/extract-facts.mjs

@@ -18,10 +18,11 @@
 // full NLU: nothing here ever paraphrases or invents a fact the recognizer
 // itself didn't produce.
 //
-// --optimistic  ALSO run a bounded, lexicon-gated fuzzy tier over the sentences
-//               the strict recognizer skipped (optimisticTriples below): a
-//               copula or a known relation verb flanked by two resolvable
-//               entities becomes a candidate triple, stored under its OWN
+// --optimistic  ALSO run a bounded fuzzy tier over the sentences the strict
+//               recognizer skipped (optimisticTriples below): a copula, a
+//               lexicon relation verb, or one of the closed newswire event
+//               verbs read in a tighter frame, flanked by two resolvable
+//               entities, becomes a candidate triple, stored under its OWN
 //               low-trust source kind (optimistic-extract:<source>, prior 0.35 —
 //               below every curated pack, memory/trust.mjs) with NO operator or
 //               teach tag riding alongside, so a fuzzy candidate can never
@@ -174,12 +175,66 @@ const MAX_TRIPLES_PER_SENTENCE = 4;
 // abstains rather than guess, so a long noun pile never mints a stray class.
 const ATTRIBUTIVE_CHAIN_MAX_HOPS = 8;
 
+// The verbs a news report states an event with. The relation arm above reads a
+// verb only when the lexicon declares one, and the lexicon's verb list is a
+// software vocabulary — so a whole newswire paragraph ("the moon will
+// completely block the sun") carries no relation under it at all. This closed
+// band sits beside it: transitive event verbs, each of which takes a direct
+// object naming the thing the event happened to, so the frame below can demand
+// an adjacent noun on each side and get the actor and the affected thing.
+//
+// Verbs of speech and attribution are deliberately absent — "say", "tell",
+// "add", "report", "accuse", "claim" each open a reported clause, and the noun
+// after one is the subject of what was said, never the object of the saying.
+// So are verbs whose everyday reading swamps their news one ("hold", "face",
+// "follow", "lead", "reach", "back", "pass", "cut"): a band that admits those
+// buys a handful of events and pays for it in nonsense.
+const NEWSWIRE_RELATION_VERBS = new Set([
+  "hit", "strike", "kill", "injure", "wound", "damage", "destroy", "devastate",
+  "ban", "halt", "block", "bar", "suspend", "impose",
+  "arrest", "detain", "jail", "charge", "convict", "sentence", "deport", "release", "free",
+  "elect", "appoint", "oust", "overthrow",
+  "sign", "adopt", "approve", "reject", "veto",
+  "launch", "unveil", "seize", "capture", "invade", "attack", "bomb", "target",
+  "discover", "uncover", "rescue", "evacuate",
+  "spark", "trigger", "cause", "force", "deploy", "restore", "expand",
+]);
+// The of-frame heads a newswire event reads THROUGH to what it really touched:
+// "discovers hundreds of ancient amphorae" is a fact about the amphorae, and
+// "charged a group of Cuban men" about the men. Only counting and container
+// heads qualify (OF_PARTITIVE_HEADS and the bare numerals below, plus the
+// classifier heads a class rewrite already reads through) — every other of-
+// chain names its own head, so "restore the sacred glow of fireflies" restores
+// the glow, not the fireflies.
+const OF_COUNT_HEADS = new Set(["hundred", "hundreds", "thousand", "thousands", "million", "millions", "dozen", "dozens", "score", "scores", "handful"]);
+// A verb whose own auxiliary is a be-form heads a passive or a progressive
+// ("was arrested by ICE", "are disappearing"), and there the noun on the
+// subject side is what the event happened TO, not who did it — an active read
+// of one states the reverse of the sentence. The scan crosses adverbs only, so
+// a modal chain that is still active ("will completely block") reads on.
+const BE_AUXILIARIES = new Set(["is", "are", "was", "were", "be", "been", "being", "am"]);
+
+// wink's tokenizer keeps a sentence-final full stop glued to the word before
+// it when that word ends the text ("… block the sun." tokenizes as one PROPN
+// "sun."), so a term read off the last token would otherwise be stored with
+// the sentence's own punctuation in its key. Only a LONE trailing stop comes
+// off: an abbreviation carries interior stops too ("U.S.", "P.K.K.") and keeps
+// every one of them.
+const stripSentenceFinalStop = (word) => {
+  const text = String(word ?? "");
+  return text.endsWith(".") && !text.slice(0, -1).includes(".") ? text.slice(0, -1) : text;
+};
+
 /** Fold an entity surface to its stored key: a lexicon noun's lemma, else the
  *  word's own normFactTerm (the optimistic tier mints unlisted content nouns
  *  the way the strict teach lane already mints "redis"). */
 function foldEntity(word, lexicon) {
-  const noun = lookupNoun(lexicon, String(word).toLowerCase());
-  return normFactTerm(noun ? noun.lemma : word);
+  const surface = stripSentenceFinalStop(word);
+  // A multi-word name is stored exactly as it reads. "United States" is the
+  // name; "united state" is a lemma fold of a word that was never on its own.
+  if (surface.includes(" ")) return normFactTerm(surface);
+  const noun = lookupNoun(lexicon, surface.toLowerCase());
+  return normFactTerm(noun ? noun.lemma : surface);
 }
 
 // The shortest word ingestText's fact-degree scan treats as a content-noun
@@ -187,10 +242,40 @@ function foldEntity(word, lexicon) {
 // lexical fallback's stopword set doesn't already carry.
 const CANDIDATE_TERM_MIN_LENGTH = 3;
 
+// An abbreviated personal title carries a trailing stop, which is why wink
+// tags it PROPN and glues it to the surname ("Mr./PROPN Gilman/PROPN"). A
+// title addresses a person; it never names one, so it comes off the front of a
+// name run however short the run is.
+const HONORIFIC_NAME_PREFIXES = new Set([
+  "mr", "mrs", "ms", "mx", "dr", "prof", "rev",
+  "sen", "rep", "gov", "gen", "capt", "col", "lt", "sgt", "maj",
+]);
+
+/** The name a run of capitalized tokens states, front-trimmed. A run of three
+ *  or more sheds a leading role noun the lexicon knows ("Prime Minister Keir
+ *  Starmer" → "Keir Starmer") or a hyphenated compound that only Title Case
+ *  lifted to a proper noun ("Ex-Marine Robert Gilman" → "Robert Gilman"). The
+ *  trim stops at two tokens, so "Count Binface" and "Lake Kariba" keep the word
+ *  that belongs to the name. An honorific comes off at any length. */
+function trimNameRun(words, lexicon) {
+  const bare = (word) => stripSentenceFinalStop(word).toLowerCase();
+  let start = 0;
+  while (start < words.length - 1 && HONORIFIC_NAME_PREFIXES.has(bare(words[start]))) start += 1;
+  while (words.length - start >= 3) {
+    const first = bare(words[start]);
+    if (!first.includes("-") && !lookupNoun(lexicon, first)) break;
+    start += 1;
+  }
+  return words.slice(start);
+}
+
 /** Every NOUN/PROPN token `sentences` names, surface-form occurrence-counted —
  *  a POS tagger reads unknown words by context, so an unlisted noun ("wombat")
- *  counts exactly like a lexicon-known one. */
-function candidateTermOccurrencesPos(sentences, nlp) {
+ *  counts exactly like a lexicon-known one. A contiguous run of two or more
+ *  PROPN tokens counts ONCE, as the whole name it spells ("Robert Gilman",
+ *  "United States"); the run's own words never count beside it, because half a
+ *  name is half a lookup. */
+function candidateTermOccurrencesPos(sentences, nlp, lexicon) {
   const counts = new Map();
   for (const sentence of sentences) {
     let values;
@@ -202,21 +287,77 @@ function candidateTermOccurrencesPos(sentences, nlp) {
     } catch { continue; }
     for (let i = 0; i < values.length; i += 1) {
       if (pos[i] !== "NOUN" && pos[i] !== "PROPN") continue;
+      let hi = i;
+      if (pos[i] === "PROPN") while (hi + 1 < values.length && pos[hi + 1] === "PROPN") hi += 1;
+      if (hi > i) {
+        // A Title Case headline lifts its verbs to PROPN too ("Thailand Halts
+        // New Gun Licenses…"), gluing a clause into one run. A token the verb
+        // tables know splits the run: what stands before it is the name.
+        const verbShaped = (w) => {
+          const word = stripSentenceFinalStop(String(w)).toLowerCase();
+          const lemma = word.endsWith("s") ? word.slice(0, -1) : word;
+          return NEWSWIRE_RELATION_VERBS.has(word) || NEWSWIRE_RELATION_VERBS.has(lemma)
+            || Boolean(lookupVerb(lexicon, word));
+        };
+        let cut = -1;
+        for (let k = i + 1; k <= hi; k += 1) if (verbShaped(values[k])) { cut = k; break; }
+        const runEnd = cut === -1 ? hi : cut - 1;
+        if (runEnd > i) {
+          const name = trimNameRun(values.slice(i, runEnd + 1), lexicon).join(" ");
+          counts.set(name, (counts.get(name) || 0) + 1);
+        } else {
+          counts.set(values[i], (counts.get(values[i]) || 0) + 1);
+        }
+        i = cut === -1 ? hi : cut;
+        continue;
+      }
       counts.set(values[i], (counts.get(values[i]) || 0) + 1);
     }
   }
   return counts;
 }
 
+/** A sentence whose substantial words are nearly all capitalized is a headline
+ *  set in Title Case, where a capital says nothing about which words spell a
+ *  name. The POS tier reads such a sentence by tag and is unaffected; the
+ *  lexical fallback has only the capitals, so it reads no name runs there. */
+function readsAsTitleCase(words) {
+  const substantial = words.filter((word) => word.length >= 4);
+  if (substantial.length < 4) return false;
+  const capitalized = substantial.filter((word) => /^[A-Z]/.test(word)).length;
+  return capitalized / substantial.length >= 0.8;
+}
+
 /** The no-wink-model fallback: every word that is neither a closed-class
  *  scaffolding token nor a lexicon-known verb/adjective counts as a candidate
  *  noun — narrower than the POS tier (no context to lean on), but the same
- *  "an unlisted word can still be a content noun" posture. */
+ *  "an unlisted word can still be a content noun" posture. Capitalization
+ *  stands in for the missing tags when it carries information: two or more
+ *  capitalized words separated by nothing but spaces count once, as one name. */
 function candidateTermOccurrencesLexical(sentences, lexicon) {
   const counts = new Map();
   for (const sentence of sentences) {
-    const words = String(sentence || "").match(/[A-Za-z][A-Za-z'-]*/g) || [];
-    for (const word of words) {
+    const text = String(sentence || "");
+    const matches = [...text.matchAll(/[A-Za-z][A-Za-z'-]*/g)];
+    const words = matches.map((match) => match[0]);
+    const titleCase = readsAsTitleCase(words);
+    const spacedRunEnd = (start) => {
+      let hi = start;
+      while (hi + 1 < matches.length && /^[A-Z]/.test(words[hi + 1])
+        && !text.slice(matches[hi].index + words[hi].length, matches[hi + 1].index).trim()) hi += 1;
+      return hi;
+    };
+    for (let i = 0; i < words.length; i += 1) {
+      const word = words[i];
+      if (!titleCase && /^[A-Z]/.test(word)) {
+        const hi = spacedRunEnd(i);
+        if (hi > i) {
+          const name = trimNameRun(words.slice(i, hi + 1), lexicon).join(" ");
+          counts.set(name, (counts.get(name) || 0) + 1);
+          i = hi;
+          continue;
+        }
+      }
       const lower = word.toLowerCase();
       if (lower.length < CANDIDATE_TERM_MIN_LENGTH) continue;
       if (OPTIMISTIC_SKIP.has(lower)) continue;
@@ -227,14 +368,47 @@ function candidateTermOccurrencesLexical(sentences, lexicon) {
   return counts;
 }
 
+/** A single-word term that is one word of exactly one multi-word name the same
+ *  text captured is that name's fragment, not a term of its own: "Gilman"
+ *  beside "Robert Gilman" is the same person, and only the whole name is a
+ *  question a reference lookup can answer. Its occurrences move onto the name.
+ *  A word no captured name holds ("Russia", standing alone) is left where it
+ *  is, and a word two names share is dropped rather than guessed onto one. */
+function foldNameFragments(counts) {
+  const namesByWord = new Map();
+  for (const term of counts.keys()) {
+    if (!term.includes(" ")) continue;
+    for (const word of term.split(" ")) {
+      if (!namesByWord.has(word)) namesByWord.set(word, new Set());
+      namesByWord.get(word).add(term);
+    }
+  }
+  for (const [term, occurrences] of [...counts]) {
+    if (term.includes(" ")) continue;
+    const names = namesByWord.get(term);
+    if (!names) continue;
+    counts.delete(term);
+    if (names.size !== 1) continue;
+    const [name] = names;
+    counts.set(name, (counts.get(name) || 0) + occurrences);
+  }
+  return counts;
+}
+
 /** Every fact-ungrounded term `sentences` names: a candidate noun folded to
  *  its stored term key (`foldEntity`, so a ledger entry and a stored fact key
  *  the same term identically) that `rows` holds zero fact rows for — the
  *  fact-degree rule an ungrounded-term ledger admits by, independent of
  *  whether the lexicon happens to know the word. Occurrence-counted, so a
- *  term named three times outranks one named once. */
-function ungroundedTermOccurrences(sentences, rows, { lexicon, nlp }) {
-  const raw = nlp ? candidateTermOccurrencesPos(sentences, nlp) : candidateTermOccurrencesLexical(sentences, lexicon);
+ *  term named three times outranks one named once.
+ *
+ *  `nlp` follows this module's own convention: absent means the shared wink
+ *  instance, and an explicit null forces the lexical fallback. */
+export function ungroundedTermOccurrences(sentences, rows, { lexicon = loadLexicon(), nlp } = {}) {
+  const engine = nlp === undefined ? winkInstance() : nlp;
+  const raw = engine
+    ? candidateTermOccurrencesPos(sentences, engine, lexicon)
+    : candidateTermOccurrencesLexical(sentences, lexicon);
   const grounded = new Set();
   for (const row of rows) {
     grounded.add(normFactTerm(row.subject));
@@ -243,9 +417,13 @@ function ungroundedTermOccurrences(sentences, rows, { lexicon, nlp }) {
   const counts = new Map();
   for (const [word, n] of raw) {
     const term = foldEntity(word, lexicon);
-    if (!term || grounded.has(term)) continue;
+    if (!term) continue;
     counts.set(term, (counts.get(term) || 0) + n);
   }
+  // Fragments fold onto their whole name BEFORE the fact-degree filter, so a
+  // name a fact already grounds takes its own fragments out with it.
+  foldNameFragments(counts);
+  for (const term of [...counts.keys()]) if (grounded.has(term)) counts.delete(term);
   return counts;
 }
 
@@ -257,10 +435,12 @@ function ungroundedTermOccurrences(sentences, rows, { lexicon, nlp }) {
 function optimisticTriplesPos(sentence, lexicon, nlp, { mintDefinitional = false } = {}) {
   let values;
   let pos;
+  let lemmas;
   try {
     const doc = nlp.readDoc(String(sentence || ""));
     values = doc.tokens().out(nlp.its.value);
     pos = doc.tokens().out(nlp.its.pos);
+    lemmas = doc.tokens().out(nlp.its.lemma);
   } catch { return { triples: [], declined: [], minted: [] }; }
   // A found noun is read as its whole contiguous NOUN/PROPN run, head-lemma
   // folded — "a string instrument" is the class "string instrument", never
@@ -273,8 +453,9 @@ function optimisticTriplesPos(sentence, lexicon, nlp, { mintDefinitional = false
     while (lo - 1 >= 0 && isNounish(lo - 1)) lo -= 1;
     while (hi + 1 < values.length && isNounish(hi + 1)) hi += 1;
     if (lo === hi) return foldEntity(values[i], lexicon);
-    const head = lookupNoun(lexicon, String(values[hi]).toLowerCase());
-    return normFactTerm([...values.slice(lo, hi), head ? head.lemma : values[hi]].join(" "));
+    const last = stripSentenceFinalStop(values[hi]);
+    const head = lookupNoun(lexicon, last.toLowerCase());
+    return normFactTerm([...values.slice(lo, hi), head ? head.lemma : last].join(" "));
   };
   const nearestEntityIndex = (idx, step, blocked = null) => {
     for (let i = idx + step; i >= 0 && i < values.length; i += step) {
@@ -346,7 +527,9 @@ function optimisticTriplesPos(sentence, lexicon, nlp, { mintDefinitional = false
   // class ("a type of mammal" → mammal); a partitive container head states
   // composition, never a class ("a large body of ice" — no isa at all).
   const copulaObjectAt = (i) => {
+    let sawDeterminer = false;
     for (let j = i + 1; j < values.length; j += 1) {
+      if (pos[j] === "DET" || pos[j] === "NUM") sawDeterminer = true;
       // A naming periphrasis ("… termed as …", "… known as …") keeps the
       // frame copular: skip the participle and its "as" and read on.
       if ((pos[j] === "VERB" || pos[j] === "AUX") && COPULA_NAMING_PARTICIPLES.has(values[j]?.toLowerCase())
@@ -378,6 +561,12 @@ function optimisticTriplesPos(sentence, lexicon, nlp, { mintDefinitional = false
         while (hi + 1 < values.length && isNounish(hi + 1)) hi += 1;
       }
       const headWord = String(values[hi]).toLowerCase();
+      // A bare "-ed" complement straight after the copula is a predicative
+      // participle the tagger mis-read as a noun ("dozens have been rescued"),
+      // never a class: a real class complement carries a determiner or number
+      // ("has been a doctor"). Short true nouns in -ed (bed, seed, need) stay
+      // under the length bound.
+      if (!sawDeterminer && headWord.length >= 5 && headWord.endsWith("ed")) return null;
       const nextWord = values[hi + 1]?.toLowerCase();
       // "latency is the name for the time period …" defines latency; it does not
       // put latency under the class "name". The isa is declined and the object
@@ -418,6 +607,17 @@ function optimisticTriplesPos(sentence, lexicon, nlp, { mintDefinitional = false
     return { label: entityRunAt(climbed), hi };
   };
 
+  // Does the verb complex headed at `i` open with a be-form auxiliary? Adverbs
+  // in between are crossed; anything else ends the complex.
+  const beAuxiliaryBefore = (i) => {
+    for (let k = i - 1; k >= 0; k -= 1) {
+      if (pos[k] === "ADV" || pos[k] === "PART") continue;
+      if (pos[k] !== "AUX") return false;
+      if (BE_AUXILIARIES.has(String(values[k]).toLowerCase())) return true;
+    }
+    return false;
+  };
+
   const triples = [];
   const declined = [];
   const minted = [];
@@ -433,6 +633,65 @@ function optimisticTriplesPos(sentence, lexicon, nlp, { mintDefinitional = false
   };
   const decline = (finding, candidate) => { declined.push({ finding, candidate }); };
 
+  // The newswire event frame — a closed band of transitive event verbs
+  // (NEWSWIRE_RELATION_VERBS) read in a much tighter frame than the lexicon
+  // arm's. The lexicon's own verbs keep their loose scans; a verb only this
+  // band knows has to earn its triple:
+  //
+  //   - wink must have tagged the token VERB, and its LEMMA must be in the
+  //     band, so a past tense ("released", "adopted") reads where the
+  //     lexicon's -s-only fold cannot;
+  //   - the verb complex must not open with a be-form, so a passive or a
+  //     progressive never mints its own reverse;
+  //   - it must not sit in a relative clause, which has no subject of its own
+  //     here;
+  //   - subject and object are each the NEAREST noun run on their side with
+  //     the copula frame's blockers applied, so neither scan crosses a verb, a
+  //     preposition or a conjunction into another clause. "resigned from
+  //     Cambridge" yields no object at all rather than "resign Cambridge".
+  //     The subject scan starts left of the verb's OWN modal chain ("will
+  //     completely block"), which is one verb complex rather than a crossing.
+  //     A counting of-chain on either side reads through to what the event
+  //     really touched ("hundreds of ancient amphorae" → amphorae).
+  //
+  // A lemma the lexicon itself declares keeps the lexicon's predicate, so
+  // "releases" (the lexicon arm) and "released" (this one) land on one edge.
+  const verbComplexStart = (i) => {
+    let k = i - 1;
+    while (k >= 0 && (pos[k] === "ADV" || pos[k] === "AUX" || pos[k] === "PART")) k -= 1;
+    return k + 1;
+  };
+  const readsThroughOf = (word) => {
+    const w = String(word ?? "").toLowerCase();
+    return OF_COUNT_HEADS.has(w) || OF_PARTITIVE_HEADS.has(w) || OF_CLASSIFIER_HEADS.has(w);
+  };
+  const countChainEntity = (idx, step) => {
+    let at = nearestEntityIndex(idx, step, COPULA_FRAME_BLOCKERS);
+    for (let hop = 0; at !== null && hop < 2; hop += 1) {
+      let hi = at;
+      while (hi + 1 < values.length && isNounish(hi + 1)) hi += 1;
+      if (values[hi + 1]?.toLowerCase() !== "of" || !readsThroughOf(values[hi])) break;
+      const inner = nearestEntityIndex(hi + 1, +1);
+      if (inner === null) break;
+      at = inner;
+    }
+    return at === null ? null : entityRunAt(at);
+  };
+  const readNewswireFrame = () => {
+    for (let i = 1; i < values.length - 1; i += 1) {
+      if (pos[i] !== "VERB") continue;
+      if (lookupVerb(lexicon, String(values[i]).toLowerCase())) continue;
+      const lemma = String(lemmas?.[i] ?? values[i]).toLowerCase();
+      if (!NEWSWIRE_RELATION_VERBS.has(lemma)) continue;
+      if (beAuxiliaryBefore(i) || relativePronounBefore(i) >= 0) continue;
+      const subject = countChainEntity(verbComplexStart(i), -1);
+      const object = countChainEntity(i, +1);
+      if (!subject || !object) continue;
+      const declared = lookupVerb(lexicon, lemma);
+      push(subject, declared ? predicateOf(declared) : `mgx:${lemma}`, object);
+    }
+  };
+
   // Pass 1 — the first clean copula frame yields the isa (all guards unchanged);
   // its subject and object-run end anchor the relative-clause continuation.
   let copulaSubject = null;
@@ -494,6 +753,7 @@ function optimisticTriplesPos(sentence, lexicon, nlp, { mintDefinitional = false
       if (subject === null) continue;
       push(subject, predicateOf(verb), nearestEntity(i, +1));
     }
+    readNewswireFrame();
     return { triples, declined, minted };
   }
 
@@ -516,6 +776,7 @@ function optimisticTriplesPos(sentence, lexicon, nlp, { mintDefinitional = false
     if (subject === null) continue;
     push(subject, predicateOf(verb), nearestEntity(i, +1));
   }
+  readNewswireFrame();
   return { triples, declined, minted };
 }
 
@@ -559,8 +820,9 @@ function optimisticTriplesLexical(sentence, lexicon) {
 
 /**
  * The bounded triple candidates from a sentence the strict recognizer skipped:
- * a copula (→ rdfs:subClassOf) and, past its object, the relation verbs it
- * grounds (→ their predicates), so one sentence contributes every fact it holds
+ * a copula (→ rdfs:subClassOf), past its object the relation verbs it grounds
+ * (→ their predicates), and the closed newswire event band in its own tighter
+ * frame, so one sentence contributes every fact it holds
  * ("a volcano is a mountain that has lava" → volcano ⊑ mountain AND volcano has
  * lava). Every triple passes the same entity/guard checks on its own, deduped,
  * capped at MAX_TRIPLES_PER_SENTENCE so a run-on never shatters into noise; []
@@ -1093,6 +1355,9 @@ export async function ingestText(text, {
       const key = normFactTerm(term);
       if (key && !ungroundedCounts.has(key)) ungroundedCounts.set(key, 1);
     }
+    // A decline names the word it tripped over, so the legacy set carries name
+    // fragments too ("Gilman" out of "Robert Gilman"). Same fold, same reason.
+    foldNameFragments(ungroundedCounts);
 
     const result = {
       sentences: sentenceCount,

package/src/services/news.mjs

@@ -60,7 +60,7 @@ import {
 import { DEFAULT_MIN_INTERVAL_MS } from "../adapters/corpus/courtesy.mjs";
 import { researchFacts } from "../adapters/corpus/research-source.mjs";
 import { throughSourceBreaker, sourceSkipStatusLine } from "../domain/source-breaker.mjs";
-import { ingestText, readsAsEntityTerm } from "./extract-facts.mjs";
+import { ingestText, readsAsEntityTerm, ungroundedTermOccurrences } from "./extract-facts.mjs";
 
 export { NEWS_SOURCE_RECORDS, DEFAULT_NEWS_SOURCE_IDS, DEFAULT_NEWS_KB_IDS };
 
@@ -77,6 +77,9 @@ export const NEWS_DEFAULTS = Object.freeze({
   enrichTermsPerCycle: 3,
   negativeCacheTtlHours: 24,
   syllogismsPerIngest: 12,
+  // Per source, not across the whole poll: each enabled source keeps its own
+  // window of up to this many snapshots, so one prolific source can never
+  // crowd another out of the window before either has been read.
   itemCap: 30,
   newsFactCap: 4000,
   feedTop: 3,
@@ -246,18 +249,19 @@ function abortSignalOf(ctx) {
   return typeof ctx?.shouldAbort === "function" ? ctx.shouldAbort : () => false;
 }
 
-// A feed title rarely carries its own terminal punctuation ("Scientists
-// Discover New Species"); a fixture built from a full sentence ("A module is
-// a component.") already does. Joining unconditionally with ". " doubles the
-// period in the second case and corrupts sentence splitting downstream — so
-// the separator is a bare space when the title already ends the sentence.
-const SENTENCE_END_RE = /[.!?]["')\]]*$/;
+// The headline and the item's own description are two separate texts, so they
+// reach the ingest as two PARAGRAPHS. Run together on one line they merge into
+// one sentence whenever the headline ends on something the sentence splitter
+// will not break after — an abbreviation ("… Arrives in the U.S." + "Russia
+// released …" reads as one 26-word sentence, and the fact that falls out of it
+// has "u.s. russia" for a subject) or a description that opens on a quotation.
+// A blank line between them is the boundary ingestText already splits on.
 function joinTitleAndSummary(title, summary) {
   const t = String(title || "").trim();
   const s = String(summary || "").trim();
   if (!t) return s;
   if (!s) return t;
-  return `${t}${SENTENCE_END_RE.test(t) ? " " : ". "}${s}`;
+  return `${t}\n\n${s}`;
 }
 
 function toMs(value) {
@@ -305,6 +309,23 @@ function buildSourcesByFactId(items) {
   return map;
 }
 
+/** The entity names a card's own article text carries, read through the same
+ *  capture the enrichment queue is fed from (`ungroundedTermOccurrences`), so a
+ *  name reaches a card's background under exactly the key enrichment stored it
+ *  under. The fact set handed in is empty on purpose: that call's own filter
+ *  drops a term the graph already holds facts about, and a card wants precisely
+ *  those. A single word the lexicon reads as an everyday noun drops out here —
+ *  "developer" names nothing a lookup could define — while a name run keeps its
+ *  whole spelling, "tim king" and "amigados" alike. */
+export function articleEntityNames(texts, { lexicon } = {}) {
+  const lex = lexicon || loadLexicon();
+  const names = [];
+  for (const term of ungroundedTermOccurrences(texts, [], { lexicon: lex }).keys()) {
+    if (term.includes(" ") || !isVocabGroundedTerm(lex, term)) names.push(term);
+  }
+  return names.sort();
+}
+
 // ---------------------------------------------------------------------------
 // grounding definitions (10.2)
 // ---------------------------------------------------------------------------
@@ -639,10 +660,15 @@ export async function pollNewsSources(ctx) {
       recordSuccess(health, nowVal, "not-modified");
     } else {
       recordSuccess(health, nowVal, "ok");
-      const merged = mergeSnapshots(state.items, result.items, {
+      // itemCap bounds THIS source's own window: mergeSnapshots sees only
+      // sourceId's existing snapshots, so one prolific source's window
+      // never crowds out another's before either has been read.
+      const ownItems = (state.items || []).filter((snap) => snap?.sourceId === sourceId);
+      const otherItems = (state.items || []).filter((snap) => snap?.sourceId !== sourceId);
+      const merged = mergeSnapshots(ownItems, result.items, {
         cap: config.itemCap, seen: state.seenItemKeys,
       });
-      state.items = merged.items;
+      state.items = [...otherItems, ...merged.items].sort(byFetchedAtThenId);
       added = merged.added;
       newItemsTotal += added.length;
     }
@@ -875,7 +901,15 @@ export async function enrichTopTerms(ctx, { limit } = {}) {
  *
  *  `newName` is a display-only badge (never a gate): true when the lexicon
  *  has no everyday-noun reading for the hub, computed here rather than in
- *  buildNewsItems because the domain layer carries no lexicon. */
+ *  buildNewsItems because the domain layer carries no lexicon.
+ *
+ *  `articleEntityNames` is wired in for the same reason: reading the entity
+ *  names out of a card's own article text takes the lexicon and the wink
+ *  tagger, so the domain asks for them through a seam and this layer answers
+ *  with the capture the enrichment queue already uses. It is what puts a
+ *  definition and the card that needed it on the same page — a lookup on
+ *  "amigados" reaches a card whose only fact is that a site discussed the
+ *  headline the name sits inside. */
 export async function buildFeed(ctx) {
   const { memoryDir, store, config, state, now, lexicon } = ctx;
   const nowVal = resolveNow(now);
@@ -886,7 +920,12 @@ export async function buildFeed(ctx) {
 
   const lex = lexicon || loadLexicon();
   const items = buildNewsItems(rows, {
-    now: nowVal, windowMs, limit: config.itemCap, sourcesByFactId, readsAsEntityTerm,
+    now: nowVal,
+    windowMs,
+    limit: config.itemCap,
+    sourcesByFactId,
+    readsAsEntityTerm,
+    articleEntityNames: (texts) => articleEntityNames(texts, { lexicon: lex }),
   }).map((item) => ({ ...item, newName: !isVocabGroundedTerm(lex, item.hub) }));
   return { items, seedFallback: false, builtAt: nowVal };
 }