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

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
@@ -51,8 +52,8 @@
 //
 // The extractor also says HOW it read a sentence, as named structural findings
 // with their own detectors — never a score. A candidate the detectors show was
-// mis-read is declined by name (`relative-clause-verb`, `fragment-term`), and a
-// definitional frame ("X is the name for Y") declines the false isa and mints
+// mis-read is declined by name (`relative-clause-verb`, `fragment-term`,
+// `phrasal-particle`), and a definitional frame ("X is the name for Y") declines the false isa and mints
 // the edge the sentence actually states (`mgx:nameFor`, `definitional-frame`).
 // The ingest result reports both as `declined` and `minted`.
 
@@ -67,8 +68,9 @@ import { loadMemory, readFactRows, appendFacts, removeFacts } from "../adapters/
 import { loadConfig } from "../adapters/config.mjs";
 import { touchedFactRows } from "../domain/memory/touched-facts.mjs";
 import { INGEST_SESSION_MARKER } from "../domain/memory/trust.mjs";
-import { normFactTerm } from "../domain/hash.mjs";
+import { normFactTerm, factIdForTriple } from "../domain/hash.mjs";
 import { splitIdentifierWords } from "../domain/prose.mjs";
+import { baseVerbSurface } from "../domain/fact-phrase.mjs";
 import { winkInstance } from "../adapters/wink-model.mjs";
 import {
   loadLexicon, lookupNoun, lookupVerb, lookupAdjective, lookupProperName, predicateOf,
@@ -156,6 +158,14 @@ const COPULA_NAMING_PARTICIPLES = new Set(["termed", "known", "defined", "descri
 // subject: "a mountain that has lava" is a fact about the volcano, so the
 // relative clause's verb binds to the copula's own subject, not to its object.
 const RELATIVE_PRONOUNS = new Set(["that", "which", "who", "whom", "whose"]);
+// A pronoun standing between a copula and the nearest noun on its left IS that
+// copula's subject: "many say it is just a matter of time" predicates about
+// "it", and a scan that walks through the pronoun lands on whatever noun sits
+// further left and stores a claim the sentence never made. A pronoun names
+// nothing a fact can hold, so the subject side stops there and the frame
+// abstains — the same answer the strict recognizer already gives a
+// pronoun-subject claim.
+const COPULA_SUBJECT_BLOCKERS = new Set([...COPULA_FRAME_BLOCKERS, "PRON"]);
 // The copula-object heads that define a subject rather than classify it. "X is
 // the name for Y" says what X names; it does not put X under the class "name".
 // Followed by "for" or "of", one of these declines the isa and mints the edge
@@ -174,12 +184,178 @@ 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",
+]);
+// Two verbs the band already holds can report ONE event: a report wounds the
+// people its next sentence says were injured, and the card then states the
+// same act twice. Each pair below is one act under two words, so the left
+// lemma reads as the right one and both sentences land on a single edge —
+// the vocabulary-level form of the rule that already puts "releases" and
+// "released" on one edge.
+//
+// The bar for a pair is that the two words mean one thing wherever the band
+// reads them. A pair that merely overlaps keeps its own edge, and it fails the
+// bar in either of two ways. It can name two different acts on the same people
+// ("detain"/"jail", "oust"/"overthrow"). Or one word can carry a second sense
+// the other does not: "free" is "release from custody" for a prisoner and
+// "pull out of the rubble" for a rescue, so folding it onto "release" turns
+// "rescuers free quake victim" into a jail delivery. Nothing in the sentence
+// tells those two senses apart, so the pair stays out.
+const NEWSWIRE_VERB_SYNONYMS = new Map([
+  ["wound", "injure"],
+  ["uncover", "discover"],
+  ["bar", "ban"],
+]);
+
+// The particles a phrasal verb carries. A frame that drops one states a
+// different event ("Frenzy … Takes Over London" → "takes London"), and one
+// that reads it as the thing the event touched states nonsense ("stocks sell
+// out" → sell "out"), so the pair below is read whole or not at all.
+const PHRASAL_PARTICLES = new Set([
+  "over", "out", "up", "down", "off", "in", "on", "away", "back", "aside", "through",
+]);
+// The closed verb+particle pairs read as one predicate. Each is a phrasal verb
+// whose meaning is not its bare verb's — "take over" is not "take", "sell out"
+// is not "sell" — so the pair mints `mgx:<lemma>-<particle>`, which
+// fact-phrase.mjs already reads back as "takes over". A verb+particle the list
+// doesn't hold is left to the tiers it already went through.
+const PHRASAL_VERB_PAIRS = new Set([
+  "take over", "take out", "take up", "take on", "take down", "take back",
+  "sell out", "sell off",
+  "carry out",
+  "step down", "step up", "step aside", "step in",
+  "call off", "call up", "call out",
+  "hand over", "hand out", "hand down",
+  "rule out",
+  "pull out", "pull off", "pull down", "pull back",
+  "set out", "set up", "set off", "set aside",
+  "break out", "break up", "break down", "break off",
+  "lay off", "lay out",
+  "shut down", "shut off",
+  "turn out", "turn down", "turn over", "turn away", "turn back",
+  "give up", "give back", "give in",
+  "bring down", "bring back", "bring in",
+  "roll out", "roll back",
+  "hold back", "hold up", "hold off",
+  "back down", "scale back", "push back", "push through",
+  "knock out", "knock down", "wipe out", "shoot down", "strike down",
+  "head off", "fend off",
+  "point out", "speak out",
+  "close down", "open up",
+  "drop out", "walk out", "walk back",
+  "wind down", "phase out", "sign off",
+  "fall back", "move on",
+]);
+// The prepositions a subject run climbs OUT of to the head that governs it.
+// "Frenzy for solar eclipse glasses takes over London" is about the frenzy;
+// the run beside the verb is the preposition's object, never the subject.
+// Deliberately without the temporal ones (after/before/during/since): a
+// fronted temporal phrase is adverbial, so the noun the climb would reach for
+// heads nothing.
+const SUBJECT_CHAIN_PREPOSITIONS = new Set([
+  "of", "for", "in", "on", "at", "from", "with", "about", "over",
+  "against", "between", "among", "across", "near", "behind", "around",
+  "under", "inside", "outside", "amid",
+]);
+// The counting words that head an of-frame the reader has to look through to
+// find what the sentence is about. "triggers hundreds of evacuations" is a fact
+// about the evacuations, and "discovers hundreds of ancient amphorae" about the
+// amphorae. Every relation frame here reads through these; the newswire event
+// frame widens the same climb to the container heads (OF_PARTITIVE_HEADS) and
+// the classifier ones, so "charged a group of Cuban men" is about the men.
+// Anything outside those sets names its own head, so "restore the sacred glow
+// of fireflies" restores the glow, not the fireflies, and "a piece of cake" is
+// about the piece.
+const OF_COUNT_HEADS = new Set(["hundred", "hundreds", "thousand", "thousands", "million", "millions", "dozen", "dozens", "score", "scores", "handful"]);
+// The count phrases newswire writes in front of what an event touched. Closed
+// by list, and each has to close on the number itself, so a bare preposition
+// ("attacked at dawn") is never mistaken for one.
+const COUNT_PHRASE_RE = /^(?:more than|at least|at most|as many as|up to|fewer than|less than|nearly|almost|about|around|over|roughly)\s+\d[\d,.]*$/i;
+const COUNT_PHRASE_MAX_TOKENS = 4;
+// 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"]);
+// The prepositions an agentless passive states its subject's own condition
+// with: "banned FROM parliament elections", "deported TO Mexico", "detained AT
+// the border". Each says where the subject ended up, so the pair reads back as
+// one predicate about the subject. Deliberately narrow — "charged WITH
+// smuggling people" and "convicted OF fraud" take a whole clause or an
+// abstraction after them, not a place a fact can hold, and "of" would collide
+// with the of-chain climbs above.
+const PASSIVE_STATE_PREPOSITIONS = new Set([
+  "from", "to", "in", "at", "into", "on", "near", "under", "over", "across", "off",
+]);
+
+// 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;
+};
+
+/** The closed-band lemma a word spells, or null. A Title Case headline carries
+ *  no tag a reader can trust, so the band's own vocabulary is what identifies
+ *  its verb: the word itself, or its -s fold ("Halts" → halt). */
+function newswireVerbLemma(word) {
+  const surface = stripSentenceFinalStop(String(word ?? "")).toLowerCase();
+  if (NEWSWIRE_RELATION_VERBS.has(surface)) return surface;
+  const bare = surface.endsWith("s") ? surface.slice(0, -1) : "";
+  return bare && NEWSWIRE_RELATION_VERBS.has(bare) ? bare : null;
+}
+
 /** 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);
+function foldEntity(word, lexicon, taggedLemma = "") {
+  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 : singularHead(surface, taggedLemma));
+}
+
+/** The singular a head noun folds to when the lexicon carries no entry for it:
+ *  the tagger's own lemma, and only where that lemma is the surface with an -s
+ *  or -es taken off. A lemma that respells the word further ("analyses" →
+ *  "analyzes") is not a singular, and a proper noun keeps its own spelling
+ *  ("Wales", "Netherlands"), which is what a tagger returns for one anyway. */
+function singularHead(surface, taggedLemma) {
+  const word = String(surface ?? "");
+  const lemma = String(taggedLemma ?? "");
+  if (!lemma || lemma === word) return word;
+  const lower = word.toLowerCase();
+  const base = lemma.toLowerCase();
+  return lower === `${base}s` || lower === `${base}es` ? lemma : word;
 }
 
 // The shortest word ingestText's fact-degree scan treats as a content-noun
@@ -187,36 +363,254 @@ 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);
+}
+
+// A headline is set in Title Case AND carries no sentence-final stop. Both
+// halves matter, and they buy different things — see headlineReadPos.
+const SENTENCE_FINAL_STOPS = new Set([".", "!", "?"]);
+const readsAsHeadline = (values) => readsAsTitleCase(values)
+  && !SENTENCE_FINAL_STOPS.has(String(values[values.length - 1] ?? ""));
+
+/**
+ * How a sentence's parts of speech read once Title Case is allowed for. A
+ * tagger given a headline has no lowercase to work from and comes back wrong in
+ * both directions: the line's verb reads PROPN ("Thailand/PROPN Halts/PROPN
+ * New/PROPN Gun/PROPN"), while its plainest noun reads VERB ("Permits/VERB",
+ * "Shooting/VERB"). Two corrections, on two different conditions.
+ *
+ * In ANY Title Case sentence, a word the event band or the lexicon spells as a
+ * verb IS the verb (and a `lemmas` array passed in is corrected to match): no
+ * name run holds one of those, so promoting it can only split a run the
+ * capitals glued together.
+ *
+ * Demoting an unlisted VERB to a noun takes the stricter test — a real
+ * sentence can pass the capitalization test on its own ("The delegation met
+ * Prime Minister Keir Starmer."), and demoting its verb would cost every tag
+ * it already had right. The missing sentence-final stop is what tells a
+ * headline from that.
+ *
+ * Never the first token either way: a headline opens on its subject, and "Bar
+ * Refaeli" opens on a name the band also spells. Never a band word straight
+ * after a determiner ("The Free Press"). Any other sentence gets its tags back
+ * untouched.
+ */
+function headlineReadPos(values, pos, lemmas, lexicon) {
+  if (!readsAsTitleCase(values)) return pos;
+  const demoteUnlistedVerbs = readsAsHeadline(values);
+  const read = [...pos];
+  for (let i = 1; i < values.length; i += 1) {
+    const banded = read[i - 1] === "DET" ? null : newswireVerbLemma(values[i]);
+    // The tagger's own lemma still counts where it reaches a band verb the
+    // surface fold cannot ("Freed" → free), so a headline's past participle
+    // keeps the tag it had.
+    const taggedBandVerb = read[i] === "VERB" && NEWSWIRE_RELATION_VERBS.has(String(lemmas?.[i] ?? "").toLowerCase());
+    if (banded) {
+      read[i] = "VERB";
+      if (lemmas) lemmas[i] = banded;
+    } else if (taggedBandVerb || lookupVerb(lexicon, stripSentenceFinalStop(String(values[i])).toLowerCase())) {
+      read[i] = "VERB";
+    } else if (read[i] === "VERB" && demoteUnlistedVerbs) {
+      read[i] = "NOUN";
+    }
+  }
+  return read;
+}
+
 /** 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;
     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 { continue; }
+    const headline = readsAsHeadline(values);
+    const taggedPos = pos;
+    pos = headlineReadPos(values, pos, lemmas, lexicon);
+    // A headline read demotes an unlisted verb to a noun so a run can span it
+    // ("Mass Shooting"). That much is right for a run, and wrong for a term of
+    // its own: "Arrives" belongs inside no name and names nothing on its own.
+    const namesOnlyInsideARun = (k) => taggedPos[k] === "VERB" && pos[k] !== "VERB";
+    // A headline's capitals say nothing about which words spell a name, so its
+    // runs read over every noun; ordinary prose keeps the capital as the tell
+    // and runs over proper nouns alone.
+    const runsWith = (k) => (headline ? pos[k] === "NOUN" || pos[k] === "PROPN" : pos[k] === "PROPN");
+    // A role noun standing in front of a name is a title on that name, not a
+    // term of its own — "President Trump" is one lookup, while "president" and
+    // "trump" are two half ones. Only a common noun the lexicon knows opens a
+    // run this way, and a headline's own capitals carry no such distinction.
+    const opensRoleTitledName = (k) => !headline && pos[k] === "NOUN" && pos[k + 1] === "PROPN"
+      && Boolean(lookupNoun(lexicon, stripSentenceFinalStop(String(values[k])).toLowerCase()));
     for (let i = 0; i < values.length; i += 1) {
       if (pos[i] !== "NOUN" && pos[i] !== "PROPN") continue;
+      let hi = i;
+      if (runsWith(i) || opensRoleTitledName(i)) {
+        while (hi + 1 < values.length && runsWith(hi + 1)) hi += 1;
+      }
+      if (hi > i) {
+        const name = trimNameRun(values.slice(i, hi + 1), lexicon).join(" ");
+        counts.set(name, (counts.get(name) || 0) + 1);
+        i = hi;
+        continue;
+      }
+      if (namesOnlyInsideARun(i)) continue;
       counts.set(values[i], (counts.get(values[i]) || 0) + 1);
     }
   }
   return counts;
 }
 
+// The tags a noun phrase opens with. One of these in front of a token settles
+// that the token heads a noun phrase of its own, whatever follows it — a
+// determiner ("the day it happened"), a possessive, a numeral, or the
+// preposition that governs the phrase ("immigrants to countries they have no
+// connection to").
+const NOUN_PHRASE_OPENERS = new Set(["DET", "PRON", "PART", "NUM", "ADP"]);
+
+/** Does the token at `i` stand where only a clause's own verb can, despite its
+ *  NOUN tag? A tagger reads "many say it is just a matter of time" as a noun on
+ *  the very word the clause turns on, and a term scan then offers "say" as
+ *  something to look up. One closed frame says otherwise: a subject pronoun and
+ *  its own verb right behind the token. The pronoun has to be a subject one, so
+ *  a relative clause hanging off a real noun ("a camera that would cost …")
+ *  keeps its reading. */
+function readsAsClauseVerb(values, pos, i) {
+  if (i > 0 && NOUN_PHRASE_OPENERS.has(pos[i - 1])) return false;
+  if (pos[i + 1] !== "PRON" || RELATIVE_PRONOUNS.has(String(values[i + 1] ?? "").toLowerCase())) return false;
+  return pos[i + 2] === "VERB" || pos[i + 2] === "AUX";
+}
+
+/** The same question for the other frame a newswire sentence hides a verb in:
+ *  an infinitive right behind the token, with a finished noun phrase in front
+ *  of it — "the central government moves to assert control". The noun phrase is
+ *  what makes the reading safe, because an infinitive alone follows nouns
+ *  constantly ("rapid development to cater to tourists", "the only person to
+ *  break the sound barrier"): those all carry an adjective, a determiner or a
+ *  preposition on the token itself, and only a token whose own left neighbour
+ *  is a common noun reads as the verb that noun phrase governs. */
+function readsAsInfinitiveClauseVerb(values, pos, i) {
+  if (i === 0 || pos[i - 1] !== "NOUN") return false;
+  if (String(values[i + 1] ?? "").toLowerCase() !== "to") return false;
+  return pos[i + 2] === "VERB";
+}
+
+/** The stored term keys `sentences` only ever uses as a clause's verb. Folded
+ *  the same way `ungroundedTermOccurrences` folds its own counts, so a caller
+ *  can subtract this set from those keys directly. A term the text also uses as
+ *  a plain noun somewhere ("the peace talks" beside "he talks to them") stays
+ *  out of the set — one verb reading never disqualifies a word that names
+ *  something elsewhere in the same article.
+ *
+ *  `nlp` follows this module's own convention: absent means the shared wink
+ *  instance, and an explicit null (no model) returns an empty set, since the
+ *  frames below are read off part-of-speech tags. */
+export function termsUsedOnlyAsVerbs(sentences, { lexicon = loadLexicon(), nlp } = {}) {
+  const engine = nlp === undefined ? winkInstance() : nlp;
+  const asVerb = new Map();
+  const total = new Map();
+  if (!engine) return new Set();
+  for (const sentence of sentences) {
+    let values;
+    let pos;
+    let lemmas;
+    try {
+      const doc = engine.readDoc(String(sentence || ""));
+      values = doc.tokens().out(engine.its.value);
+      pos = doc.tokens().out(engine.its.pos);
+      lemmas = doc.tokens().out(engine.its.lemma);
+    } catch { continue; }
+    pos = headlineReadPos(values, pos, lemmas, lexicon);
+    for (let i = 0; i < values.length; i += 1) {
+      if (pos[i] !== "NOUN" && pos[i] !== "PROPN") continue;
+      const term = foldEntity(values[i], lexicon);
+      if (!term) continue;
+      total.set(term, (total.get(term) || 0) + 1);
+      if (readsAsClauseVerb(values, pos, i) || readsAsInfinitiveClauseVerb(values, pos, i)) {
+        asVerb.set(term, (asVerb.get(term) || 0) + 1);
+      }
+    }
+  }
+  const verbs = new Set();
+  for (const [term, count] of asVerb) if (count === total.get(term)) verbs.add(term);
+  return verbs;
+}
+
+/** 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 +621,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 +670,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,11 +688,14 @@ 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: [] }; }
+  pos = headlineReadPos(values, pos, lemmas, lexicon);
   // A found noun is read as its whole contiguous NOUN/PROPN run, head-lemma
   // folded — "a string instrument" is the class "string instrument", never
   // its modifier "string"; a single-word run keeps the plain lemma fold.
@@ -272,32 +706,61 @@ function optimisticTriplesPos(sentence, lexicon, nlp, { mintDefinitional = false
     let hi = i;
     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(" "));
+    if (lo === hi) return foldEntity(values[i], lexicon, lemmas?.[i]);
+    // A run of proper nouns spells a name, and a name sheds the honorific or
+    // role word stacked in front of it — "Ex-Marine Robert Gilman" is Robert
+    // Gilman. A run holding any common noun is a compound, not a name, and
+    // keeps every word ("disk operating system").
+    let words = values.slice(lo, hi + 1);
+    if (words.every((_, k) => pos[lo + k] === "PROPN")) words = trimNameRun(words, lexicon);
+    const last = stripSentenceFinalStop(words[words.length - 1]);
+    const head = lookupNoun(lexicon, last.toLowerCase());
+    if (words.length === 1) return normFactTerm(head ? head.lemma : singularHead(last, lemmas?.[hi]));
+    return normFactTerm([...words.slice(0, -1), head ? head.lemma : singularHead(last, lemmas?.[hi])].join(" "));
+  };
+  // Where a leftward scan resumes when it meets a comma, or -1 when the comma
+  // stands between it and another clause. A news sentence names its subject
+  // first and then interrupts itself — "Yabloko, the Russian antiwar party, is
+  // banned …", "Robert Gilman, Freed by Russia, Arrives …" — so a scan that
+  // stops dead on a comma never reaches the subject at all. It may cross when
+  // nothing between the comma and either an earlier comma or the sentence start
+  // predicates: a relative clause ("the quake, which killed 100 people,
+  // damaged …") holds a verb, and that keeps the scan out.
+  const commaCrossingFrom = (close) => {
+    for (let k = close - 1; k >= 0; k -= 1) {
+      if (values[k] === ",") return k;
+      if (pos[k] === "VERB" || pos[k] === "AUX" || pos[k] === "PUNCT") return -1;
+    }
+    return close;
   };
   const nearestEntityIndex = (idx, step, blocked = null) => {
+    let mayCrossComma = step < 0;
     for (let i = idx + step; i >= 0 && i < values.length; i += step) {
-      if (pos[i] === "PUNCT") break;
+      if (pos[i] === "PUNCT") {
+        if (!mayCrossComma || values[i] !== ",") break;
+        const resume = commaCrossingFrom(i);
+        if (resume < 0) break;
+        mayCrossComma = false;
+        i = resume;
+        continue;
+      }
       if (blocked && blocked.has(pos[i])) break;
       if (isNounish(i)) return i;
     }
     return null;
   };
-  const nearestEntity = (idx, step, blocked = null) => {
-    const i = nearestEntityIndex(idx, step, blocked);
-    return i === null ? null : entityRunAt(i);
-  };
   // The subject-side mirror of the copula-object of-chain rule: when a found
-  // subject run is the inner noun of an of-chain ("the weight of all of the
-  // snow …"), climb to the outer run's nominal head ("weight"), bounded to two
-  // hops. A classifier head (type/kind/sort/…) reads THROUGH — a "kind of X"
-  // outer never becomes the subject, so the inner noun is kept. When the run is
-  // governed by "of" but no readable noun heads the chain (a mis-tagged head,
-  // e.g. "the top of the mountain …"), return null: an honest abstain, never the
-  // inner-noun confusion ("mountain", "snow"). A run not governed by "of" is
-  // returned unchanged. Returns a run-lo index to fold, or null to abstain.
-  const ofChainSkip = (k) => {
+  // subject run is the object of a preposition ("the weight of all of the
+  // snow …", "frenzy for eclipse glasses …"), climb to the head that governs
+  // the phrase ("weight", "frenzy"), bounded to two hops. A classifier head
+  // (type/kind/sort/…) or a counting one (hundreds/dozens/…) reads THROUGH —
+  // "a kind of X" and "hundreds of X" are both about X — so the inner noun is
+  // kept. When the run is governed by a preposition but no readable noun heads
+  // the phrase (a mis-tagged head, e.g. "the top of the mountain …"), return
+  // null: an honest abstain, never the inner-noun confusion ("mountain",
+  // "snow"). An ungoverned run is returned unchanged. Returns a run-lo index
+  // to fold, or null to abstain.
+  const prepositionChainSkip = (k) => {
     const p = pos[k];
     return p === "DET" || p === "ADJ" || p === "ADV" || p === "NUM";
   };
@@ -305,12 +768,14 @@ function optimisticTriplesPos(sentence, lexicon, nlp, { mintDefinitional = false
     let lo = runLoOf(found);
     for (let hop = 0; hop < 2; hop += 1) {
       let g = lo - 1;
-      while (g >= 0 && ofChainSkip(g)) g -= 1;
-      if (g < 0 || values[g]?.toLowerCase() !== "of") return lo; // not an of-chain object
+      while (g >= 0 && prepositionChainSkip(g)) g -= 1;
+      if (g < 0 || !SUBJECT_CHAIN_PREPOSITIONS.has(values[g]?.toLowerCase())) return lo; // ungoverned run
       let k = g - 1;
-      while (k >= 0 && !isNounish(k) && (ofChainSkip(k) || values[k]?.toLowerCase() === "of")) k -= 1;
+      while (k >= 0 && !isNounish(k)
+        && (prepositionChainSkip(k) || SUBJECT_CHAIN_PREPOSITIONS.has(values[k]?.toLowerCase()))) k -= 1;
       if (k < 0 || !isNounish(k)) return null; // no readable head — abstain
-      if (OF_CLASSIFIER_HEADS.has(String(values[k]).toLowerCase())) return lo; // classifier reads through
+      const head = String(values[k]).toLowerCase();
+      if (OF_CLASSIFIER_HEADS.has(head) || OF_COUNT_HEADS.has(head)) return lo; // reads through to the inner noun
       lo = runLoOf(k);
     }
     return lo;
@@ -343,10 +808,13 @@ function optimisticTriplesPos(sentence, lexicon, nlp, { mintDefinitional = false
   // is IN the oceans", "land is grouped INTO continents") — none of them
   // class membership.
   // An of-chain on the object reads through a classifier head to the real
-  // class ("a type of mammal" → mammal); a partitive container head states
-  // composition, never a class ("a large body of ice" — no isa at all).
+  // class ("a type of mammal" → mammal). A container or counting head states
+  // quantity instead ("a large body of ice", "dozens of wolves"), and quantity
+  // is no class at all, so both decline the isa.
   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 +846,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
@@ -392,7 +866,7 @@ function optimisticTriplesPos(sentence, lexicon, nlp, { mintDefinitional = false
       const nextIsOf = nextWord === "of";
       if (!nextIsOf) return { label: entityRunAt(j), hi };
       if (OF_CLASSIFIER_HEADS.has(headWord)) { i = hi + 1; j = hi + 1; continue; }
-      if (OF_PARTITIVE_HEADS.has(headWord)) return null;
+      if (OF_PARTITIVE_HEADS.has(headWord) || OF_COUNT_HEADS.has(headWord)) return null;
       return { label: entityRunAt(j), hi };
     }
     return null;
@@ -409,7 +883,7 @@ function optimisticTriplesPos(sentence, lexicon, nlp, { mintDefinitional = false
   const copulaSubjectAt = (i) => {
     let k = i - 1;
     while (k >= 0 && pos[k] === "AUX") k -= 1;
-    const found = nearestEntityIndex(k + 1, -1, COPULA_FRAME_BLOCKERS);
+    const found = nearestEntityIndex(k + 1, -1, COPULA_SUBJECT_BLOCKERS);
     if (found === null) return null;
     const climbed = climbSubjectRun(found);
     if (climbed === null) return null;
@@ -418,6 +892,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 +918,182 @@ 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. A verb the LEXICON already declares is
+  //     skipped by surface, because the lexicon arm read that sentence first
+  //     and this frame would mint the same act a second time;
+  //   - a verb followed by one of the closed phrasal pairs is admitted on the
+  //     pair instead, whichever vocabulary the bare verb belongs to: "take
+  //     over" is a different relation from "take", so the lexicon's entry for
+  //     the verb has nothing to say about it;
+  //   - it must not sit in a relative clause, which has no subject of its own
+  //     here;
+  //   - a be-form auxiliary heads a passive or a progressive rather than
+  //     declining the sentence: the -ing form marks the progressive and is
+  //     skipped, a "by" complement mints the ACTIVE edge with the actor as
+  //     subject, and an agentless passive states the patient's own condition;
+  //   - 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,
+  //     and climbs out of any preposition that governs it ("a fire AT the
+  //     hospital killed …" is about the fire). 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 —
+  // and NEWSWIRE_VERB_SYNONYMS folds the band's own interchangeable pairs onto
+  // that same edge before the lookup, so "freed" lands there too.
+  const verbComplexStart = (i) => {
+    let k = i - 1;
+    while (k >= 0 && (pos[k] === "ADV" || pos[k] === "AUX" || pos[k] === "PART")) k -= 1;
+    return k + 1;
+  };
+  // A counting word alone. The lexicon arm reads through these and no others:
+  // a container head states what the thing is made of or held in, and a
+  // classifier rewrites a class, so neither one moves what a relation verb
+  // touched.
+  const readsThroughCountOf = (word) => OF_COUNT_HEADS.has(String(word ?? "").toLowerCase());
+  // The newswire event frame's wider read-through: the counting words, plus the
+  // container and classifier heads a headline writes its patient behind.
+  const readsThroughOf = (word) => {
+    const w = String(word ?? "").toLowerCase();
+    return readsThroughCountOf(w) || OF_PARTITIVE_HEADS.has(w) || OF_CLASSIFIER_HEADS.has(w);
+  };
+  // Walk a found run's of-chain to the noun the phrase is really about, at most
+  // two hops so a chain of prepositions can never wander into another clause.
+  // `readsThrough` says which heads qualify; a head outside that set stops the
+  // climb and keeps its own run.
+  const ofChainEntityIndex = (at, readsThrough) => {
+    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" || !readsThrough(values[hi])) break;
+      const inner = nearestEntityIndex(hi + 1, +1);
+      if (inner === null) break;
+      at = inner;
+    }
+    return at;
+  };
+  const countChainEntityIndex = (idx, step) =>
+    ofChainEntityIndex(nearestEntityIndex(idx, step, COPULA_FRAME_BLOCKERS), readsThroughOf);
+  const countChainEntity = (idx, step) => {
+    const at = countChainEntityIndex(idx, step);
+    return at === null ? null : entityRunAt(at);
+  };
+  // The object a lexicon relation verb takes: the nearest run rightward, on the
+  // arm's own blocker-free scan ("relies ON redis" has to read past the
+  // preposition), then climbed through a counting of-chain so the fact lands on
+  // what was counted rather than on the count word.
+  const relationVerbObject = (i) => {
+    const at = ofChainEntityIndex(nearestEntityIndex(i, +1), readsThroughCountOf);
+    return at === null ? null : entityRunAt(at);
+  };
+  // The noun an event predicates about: the nearest run leftward, climbed out
+  // of any preposition it is the object of, so a phrase-headed subject reads as
+  // its own head rather than as the noun that happens to sit beside the verb.
+  const newswireSubject = (idx) => {
+    const at = countChainEntityIndex(idx, -1);
+    if (at === null) return null;
+    const climbed = climbSubjectRun(at);
+    return climbed === null ? null : entityRunAt(climbed);
+  };
+  // The phrasal verb headed at `i`, when the closed table holds the pair: its
+  // own minted predicate, and the particle's index, so an object scan reads
+  // past the particle to what the event touched.
+  const phrasalVerbAt = (i) => {
+    const particle = stripSentenceFinalStop(String(values[i + 1] ?? "")).toLowerCase();
+    if (!PHRASAL_PARTICLES.has(particle)) return null;
+    const lemma = String(lemmas?.[i] ?? values[i]).toLowerCase();
+    if (!PHRASAL_VERB_PAIRS.has(`${lemma} ${particle}`)) return null;
+    return { predicate: `mgx:${lemma}-${particle}`, particleAt: i + 1 };
+  };
+  // The first token of the complement a verb takes, adverbs crossed. A passive
+  // reads its own frame off this one word: "by" names the actor, a locative or
+  // directional preposition names where the subject ended up.
+  const complementHead = (i) => {
+    for (let k = i + 1; k < values.length; k += 1) {
+      if (pos[k] === "ADV") continue;
+      return k;
+    }
+    return -1;
+  };
+  // Newswire writes the count before the thing counted — "killed more than 100
+  // people", "injured at least 30 workers" — and the preposition inside the
+  // count phrase stops an object scan dead. Each lead below is skipped whole,
+  // and only where the number itself closes the phrase, so "attacked at dawn"
+  // (no number, no count) is untouched.
+  const skipCountPhrase = (idx) => {
+    for (let n = COUNT_PHRASE_MAX_TOKENS; n >= 2; n -= 1) {
+      const span = values.slice(idx + 1, idx + 1 + n);
+      if (span.length === n && COUNT_PHRASE_RE.test(span.join(" "))) return idx + n;
+    }
+    return idx;
+  };
+  const readNewswireFrame = () => {
+    for (let i = 1; i < values.length - 1; i += 1) {
+      if (pos[i] !== "VERB") continue;
+      const lemma = String(lemmas?.[i] ?? values[i]).toLowerCase();
+      const phrasal = phrasalVerbAt(i);
+      if (!phrasal) {
+        if (lookupVerb(lexicon, String(values[i]).toLowerCase())) continue;
+        if (!NEWSWIRE_RELATION_VERBS.has(lemma)) continue;
+      }
+      if (relativePronounBefore(i) >= 0) continue;
+      const canonical = NEWSWIRE_VERB_SYNONYMS.get(lemma) || lemma;
+      const declared = lookupVerb(lexicon, canonical);
+      const predicate = phrasal
+        ? phrasal.predicate
+        : (declared ? predicateOf(declared) : `mgx:${canonical}`);
+      const surface = stripSentenceFinalStop(String(values[i])).toLowerCase();
+      // A phrasal verb's own complement starts past the particle, so the frame
+      // below reads "was taken over BY Google" the same way it reads a bare
+      // participle's "by".
+      const head = complementHead(phrasal ? phrasal.particleAt : i);
+      const headWord = head === -1 ? "" : String(values[head]).toLowerCase();
+      const beAuxiliary = beAuxiliaryBefore(i);
+      // A progressive is not an event that happened, and its -ing form is the
+      // one thing that tells it apart from the past participle a passive takes.
+      if (beAuxiliary && surface.endsWith("ing")) continue;
+      // "<patient> (was) <participle> by <actor>" — the sentence names both
+      // roles, so it mints the ACTIVE edge with the actor on the subject side.
+      // A reduced passive carries no auxiliary at all ("Boats Hit by Mystery
+      // Attackers"), so the "by" is what identifies the frame.
+      if (headWord === "by") {
+        const actor = countChainEntity(head, +1);
+        const patient = newswireSubject(verbComplexStart(i));
+        if (actor && patient) push(actor, predicate, patient);
+        continue;
+      }
+      if (beAuxiliary) {
+        // "<patient> is <participle> <prep> <complement>" — no actor is named,
+        // so nothing can take the subject side of an active edge. The claim the
+        // sentence DOES make is about the patient's own condition, and that is
+        // what the participle predicate states. A phrasal pair already carries
+        // its particle as that condition, and no second preposition can restate
+        // it, so an agentless phrasal passive abstains.
+        if (phrasal || !PASSIVE_STATE_PREPOSITIONS.has(headWord)) continue;
+        const patient = newswireSubject(verbComplexStart(i));
+        const complement = countChainEntity(head, +1);
+        if (patient && complement) push(patient, `mgx:${surface}-${headWord}`, complement);
+        continue;
+      }
+      const subject = newswireSubject(verbComplexStart(i));
+      const object = countChainEntity(phrasal ? phrasal.particleAt : skipCountPhrase(i), +1);
+      if (!subject || !object) continue;
+      push(subject, predicate, 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;
@@ -485,15 +1146,17 @@ function optimisticTriplesPos(sentence, lexicon, nlp, { mintDefinitional = false
       if (OPTIMISTIC_COPULAS.has(word)) continue;
       const verb = lookupVerb(lexicon, word);
       if (!verb) continue;
+      if (phrasalVerbAt(i)) continue; // the phrasal frame reads the pair whole
       const relative = relativePronounBefore(i);
       if (relative >= 0 && relative - 1 !== copulaObjHi) {
-        decline("relative-clause-verb", { subject: copulaSubject, predicate: predicateOf(verb), object: nearestEntity(i, +1) });
+        decline("relative-clause-verb", { subject: copulaSubject, predicate: predicateOf(verb), object: relationVerbObject(i) });
         continue;
       }
       const subject = relative >= 0 ? copulaSubject : climbedSubjectAt(i);
       if (subject === null) continue;
-      push(subject, predicateOf(verb), nearestEntity(i, +1));
+      push(subject, predicateOf(verb), relationVerbObject(i));
     }
+    readNewswireFrame();
     return { triples, declined, minted };
   }
 
@@ -508,14 +1171,16 @@ function optimisticTriplesPos(sentence, lexicon, nlp, { mintDefinitional = false
     if (pos[i] !== "VERB") continue;
     const verb = lookupVerb(lexicon, values[i].toLowerCase());
     if (!verb) continue;
+    if (phrasalVerbAt(i)) continue; // the phrasal frame reads the pair whole
     const subject = climbedSubjectAt(i);
     if (relativePronounBefore(i) >= 0) {
-      decline("relative-clause-verb", { subject, predicate: predicateOf(verb), object: nearestEntity(i, +1) });
+      decline("relative-clause-verb", { subject, predicate: predicateOf(verb), object: relationVerbObject(i) });
       continue;
     }
     if (subject === null) continue;
-    push(subject, predicateOf(verb), nearestEntity(i, +1));
+    push(subject, predicateOf(verb), relationVerbObject(i));
   }
+  readNewswireFrame();
   return { triples, declined, minted };
 }
 
@@ -559,8 +1224,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; []
@@ -643,6 +1309,53 @@ export function clauseCandidates(sentence, { nlp } = {}) {
   return out;
 }
 
+// The verbs a report attributes a claim with. Closed and deliberately short:
+// each of these carries the claim through unchanged, so the clause beside one
+// is what the article states. Hedging and reversing verbs stay out — "denied",
+// "alleged", "claimed" and "suggested" each change what the sentence says
+// about the clause, and a frame that unwrapped them would store the opposite of
+// the report.
+const REPORTED_SPEECH_VERB_SRC = "said|says|told|reported|reports|announced|announces|stated|states|confirmed|confirms|added|wrote|writes";
+// "<claim>, President Trump said." — the attribution rides the tail after a
+// comma and closes the sentence. A closing quote mark may sit between them.
+// Group 1 is the speaker.
+const TRAILING_ATTRIBUTION_RE = new RegExp(
+  `,\\s*["'“”‘’]?\\s*([\\w.'’-]+(?:\\s+[\\w.'’-]+){0,3})\\s+(?:${REPORTED_SPEECH_VERB_SRC})\\s*[.!?]?\\s*$`,
+  "i",
+);
+// "President Trump said (that) <claim>", "Mr. Gilman's family had said <claim>"
+// — the attribution leads and the claim is everything past it. Group 1 is the
+// speaker, group 2 the claim.
+const LEADING_ATTRIBUTION_RE = new RegExp(
+  `^\\s*([\\w.'’-]+(?:\\s+[\\w.'’-]+){0,4})\\s+(?:has\\s+|had\\s+|have\\s+)?(?:${REPORTED_SPEECH_VERB_SRC})\\s+(?:that\\s+)?(\\S.*)$`,
+  "i",
+);
+
+/**
+ * The claim a sentence attributes to a speaker, and the speaker it names. A
+ * report states most of what it knows this way, and the recognizer reading the
+ * WHOLE sentence reads the attribution as the claim: "Officials said the quake
+ * killed more than 100 people." came back as `officials mgx:say quake killed
+ * more than 100 people`, a whole clause stored as a term. Stripping the
+ * attribution leaves the claim the article is making, which is the thing worth
+ * grounding.
+ *
+ * Returns { claim, speaker }. `speaker` is "" when no attribution frame fired,
+ * or when the claim left behind is too short to be one — the sentence comes
+ * back whole in that case, so there is nothing the speaker would hang off.
+ * Where both frames fire ("Officials said X, police reported."), the LEADING
+ * speaker wins: it is the one attached to the clause that survived.
+ */
+export function reportedClauseOf(sentence) {
+  const text = String(sentence ?? "").trim();
+  const trailing = TRAILING_ATTRIBUTION_RE.exec(text);
+  const trailingStripped = trailing ? text.replace(TRAILING_ATTRIBUTION_RE, ".") : text;
+  const leading = LEADING_ATTRIBUTION_RE.exec(trailingStripped);
+  const claim = leading ? leading[2].trim() : trailingStripped;
+  if (claim.split(/\s+/).length < 3) return { claim: text, speaker: "" };
+  return { claim, speaker: (leading?.[1] ?? trailing?.[1] ?? "").trim() };
+}
+
 // A stored term names a thing. These words open a predicate remainder or a new
 // clause, so a term that STARTS with one is the tail of a sentence a recognizer
 // frame over-read, never an entity — "has a population of 1,683,115" and "and
@@ -699,6 +1412,50 @@ const COMPASS_LEAD_WORDS = new Set([
   "northeast", "northwest", "southeast", "southwest",
   "northern", "southern", "eastern", "western",
 ]);
+// A name is one noun phrase. These words open a new phrase or a new clause, so
+// a term carrying one BETWEEN its first and last word is a headline a frame
+// tore into subject + predicate + remainder: "colombia as rescuers free quake
+// victim", "keir starmer faces a vote", "new gun licenses after mass shooting",
+// "boats hit by mystery attackers" — all four reach the graph as a card's own
+// hub or object otherwise.
+//
+// "of" is deliberately absent: it is the one preposition real names are built
+// with ("house of representatives", "united states of america", "isle of man").
+// The rule reads STRICTLY interior positions for the same reason the lead and
+// trailing rules read the edges separately — "may" and "will" end real surnames
+// ("theresa may", "brian may") and open nothing there.
+const 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",
+]);
+
+// Past participles that open a real name. Read on the lowercased stored key,
+// wink tags each of these VERB, so the POS rule below turns down "united
+// states" — the name world news reports most often — and every sibling built
+// the same way.
+const PARTICIPIAL_NAME_LEAD_WORDS = new Set(["united", "allied", "combined", "armed", "organized", "associated"]);
+
+// A term the source itself wrapped in quotation marks is a title it quoted, and
+// a title is free to read as a clause — "Hackernews discusses \"Tim King,
+// AmigaDOS developer, has died\"" states a true fact about a whole headline.
+// The quotes are the tell, so they exempt the interior rule and nothing else.
+const QUOTED_TERM_RE = /^["“'‘].*["”'’]$/;
+
+/** Does `term` carry a clause- or phrase-opening word strictly between its
+ *  first and last word? */
+export function carriesInteriorClauseWord(words) {
+  if (words.length >= 2 && QUOTED_TERM_RE.test(`${words[0]} ${words[words.length - 1]}`)) return false;
+  for (let i = 1; i < words.length - 1; i += 1) {
+    if (INTERIOR_CLAUSE_WORDS.has(String(words[i]).toLowerCase())) return true;
+  }
+  return false;
+}
 
 /** Does `term` read as a thing's name rather than a clause fragment? Bounds
  *  the word count and rejects a leading conjunction, auxiliary, preposition,
@@ -717,7 +1474,9 @@ export function readsAsEntityTerm(term, nlp) {
   if (PARTICLE_LEAD_WORDS.has(first)) return false;
   if (PRONOUN_LEAD_WORDS.has(first.replace(CLITIC_SUFFIX_RE, ""))) return false;
   if (TRAILING_AUXILIARY_WORDS.has(words[words.length - 1].toLowerCase())) return false;
+  if (carriesInteriorClauseWord(words)) return false;
   if (COMPASS_LEAD_WORDS.has(first) && words[1].toLowerCase() !== "of") return true;
+  if (PARTICIPIAL_NAME_LEAD_WORDS.has(first)) return true;
   const engine = nlp === undefined ? winkInstance() : nlp;
   if (!engine) return true;
   try {
@@ -729,6 +1488,27 @@ export function readsAsEntityTerm(term, nlp) {
 
 const readsAsEntityFact = (fact, nlp) => readsAsEntityTerm(fact.subject, nlp) && readsAsEntityTerm(fact.object, nlp);
 
+/** Did the frame that read this row cut a phrasal verb in half? "as prices
+ *  surge and stocks sell out" names no object at all, so a row pairing the
+ *  bare verb with its own particle ("stocks mgx:sell out") states nothing —
+ *  the particle belongs to the verb. Read off the same closed pair table the
+ *  optimistic tier reads a phrasal verb whole by, so only a particle that verb
+ *  really takes declines the row. */
+export function splitsPhrasalVerb(fact) {
+  const particle = String(fact?.object ?? "").trim().toLowerCase();
+  if (!PHRASAL_PARTICLES.has(particle)) return false;
+  const surface = String(fact?.predicate ?? "").split(":").pop().toLowerCase();
+  return PHRASAL_VERB_PAIRS.has(`${surface} ${particle}`)
+    || PHRASAL_VERB_PAIRS.has(`${baseVerbSurface(surface)} ${particle}`);
+}
+
+/** Why a candidate row is turned down, or null when it stands: the phrasal
+ *  split first (it names the row's real problem), then the entity-term rule. */
+const declineFindingFor = (fact, nlp) => {
+  if (splitsPhrasalVerb(fact)) return "phrasal-particle";
+  return readsAsEntityFact(fact, nlp) ? null : "fragment-term";
+};
+
 /** Does one raw token read as a code identifier rather than a word? camelCase
  *  and snake_case split into several words, and a dot between letters or a path
  *  separator names a module or a file. Read on the sentence's own surface,
@@ -772,6 +1552,24 @@ function findingsForRow(fact, readingFindings, identifierTerms) {
   return named;
 }
 
+const REPORTED_SPEECH_FINDING = "reported-speech";
+const ATTRIBUTED_TO_PREDICATE = "mgx:attributedTo";
+
+/** The reified attribution beside a claim row: `fact:<claimHash> |
+ *  mgx:attributedTo | <speaker>`. A fact is content-addressed by its own
+ *  triple, so naming the claim's group id costs no read back. Null when the
+ *  sentence attributed nothing. */
+function attributionRowFor(fact, { speaker, tag, observedAt }) {
+  if (!speaker) return null;
+  return {
+    subject: factIdForTriple(fact.subject, fact.predicate, fact.object),
+    predicate: ATTRIBUTED_TO_PREDICATE,
+    object: speaker,
+    provenance: tag,
+    observedAt,
+  };
+}
+
 // A host that shares one thread with a UI hands the thread back through this;
 // a Node run leaves it unset and pays nothing.
 let ingestYield = null;
@@ -826,6 +1624,15 @@ function canonicalLines(facts, storeRows) {
  * ingestText — the single ingest seam. Grounds `text` into facts and returns a
  * structured result; the CLI, the browser and the tool layer all drive this.
  *
+ * A sentence that attributes its claim to a speaker is handed to the recognizer
+ * as the claim alone (`reportedClauseOf`); the ungrounded-term scan still reads
+ * the sentence as written, so the speaker keeps reaching the enrichment queue.
+ * Under `findings` the speaker is also stored, twice over: the claim carries the
+ * `reported-speech` finding, and a reified `fact:<claimId> | mgx:attributedTo |
+ * <speaker>` row goes into the same batch. The finding is the half that must
+ * survive — a reader that loses the attribution still sees the claim say which
+ * reading it came from, so the two are written together or not at all.
+ *
  *   text     the raw string to ground.
  *   options:
  *     memoryDir   write grounded facts here (a real .tmct memory dir). Omit for
@@ -848,13 +1655,15 @@ function canonicalLines(facts, storeRows) {
  *     lexicon     a loaded lexicon; the core vocabulary when absent.
  *     findings    record how each sentence read: mint the edge a definitional
  *                 frame states (`mgx:nameFor`) where the false isa was
- *                 declined, and attach the kept findings (`identifier-token`,
- *                 `clause-fallback`, `pronoun-carry`, `definitional-frame`) to
- *                 the assertions this call writes. Off by default; the declines
- *                 themselves are reported either way.
+ *                 declined, attach the kept findings (`identifier-token`,
+ *                 `clause-fallback`, `pronoun-carry`, `definitional-frame`,
+ *                 `reported-speech`) to the assertions this call writes, and
+ *                 write the attribution row beside each reported-speech claim.
+ *                 Off by default; the declines themselves are reported either
+ *                 way.
  *
- * Returns { sentences, recognized, extracted, optimistic, skipped, declined,
- * minted, canonical? }.
+ * Returns { sentences, recognized, extracted, optimistic, attributions, skipped,
+ * declined, minted, canonical? }.
  *   recognized — strict-recognized sentence count.
  *   extracted  — strict fact rows ({subject, predicate, object, provenance,
  *                quantifier, sentence}), plus `extraction` when the row was
@@ -862,6 +1671,11 @@ function canonicalLines(facts, storeRows) {
  *   optimistic — fuzzy candidate rows ({subject, predicate, object, provenance,
  *                sentence}, same optional `extraction`); always [] unless
  *                options.optimistic.
+ *   attributions
+ *              — the attribution rows written beside the two arrays above, in
+ *                the same shape. Reported apart from them because they are not
+ *                facts the article stated, so nothing counting what an article
+ *                taught should count them.
  *   skipped    — sentences neither tier grounded.
  *   declined   — every candidate a detector turned down, as
  *                { sentence, finding, candidate }.
@@ -907,6 +1721,12 @@ export async function ingestText(text, {
 
   const extracted = [];
   const optimisticFacts = [];
+  // The reified attributions written beside the claim rows above. Kept out of
+  // `extracted`/`optimistic` on purpose: those two arrays are what the article
+  // stated, and they feed a snapshot's fact ids and the bench's own score. An
+  // attribution says who said one of them, which is not another fact the
+  // article stated.
+  const attributions = [];
   // How each sentence read: the candidates a detector turned down, and the
   // edges minted where one was declined.
   const declined = [];
@@ -951,13 +1771,13 @@ export async function ingestText(text, {
     currentRows = afterRows;
     if (!recognized) { lastDecline = decline || lastDecline; return null; }
     const fresh = rows.filter((row) => !taggedIds.has(row.id));
-    const kept = fresh.filter((row) => readsAsEntityFact(row, termNlp));
+    const kept = fresh.filter((row) => !declineFindingFor(row, termNlp));
     if (kept.length !== fresh.length) {
       for (const row of fresh) {
         if (kept.includes(row)) continue;
         declined.push({
           sentence: currentSentence,
-          finding: "fragment-term",
+          finding: declineFindingFor(row, termNlp),
           candidate: { subject: row.subject, predicate: row.predicate, object: row.object },
         });
       }
@@ -981,23 +1801,33 @@ export async function ingestText(text, {
         sentenceCount += 1;
         lastDecline = "";
         currentSentence = sentence;
-        const cleaned = stripCitationResidue(sentence);
-        cleanedSentences.push(cleaned);
+        const asWritten = stripCitationResidue(sentence);
+        // The ungrounded-term scan reads the sentence AS WRITTEN, so a speaker
+        // the article named still reaches the enrichment queue; only the
+        // recognizer reads the claim on its own.
+        cleanedSentences.push(asWritten);
+        const { claim: cleaned, speaker } = reportedClauseOf(asWritten);
         // The stored term keys this sentence names with an identifier-shaped
         // token, read off the surface before normFactTerm folds the shape away.
         // Null when this run records no findings.
         const identifierTerms = findings ? identifierTermsIn(cleaned) : null;
+        // The finding every row off this sentence carries, and the speaker each
+        // one is attributed to. Both halves ride the same switch: the finding is
+        // what a reader falls back on when the attribution is gone, so writing
+        // one without the other would invert the fallback.
+        const attributedTo = identifierTerms && speaker ? speaker : "";
+        const speechFindings = attributedTo ? [REPORTED_SPEECH_FINDING] : [];
         // How the strict tier reached its rows, when it did: the whole sentence
         // carries nothing, a later candidate is a clause fragment, and the
         // pronoun retry carried its subject in from an earlier sentence.
-        let readingFindings = [];
+        let readingFindings = [...speechFindings];
         // Whole sentence first, then each closed-marker clause as a fallback.
         let rows = null;
         const candidates = clauseCandidates(cleaned, { nlp });
         for (let i = 0; i < candidates.length; i += 1) {
           rows = await strictRows(candidates[i]);
           if (!rows) continue;
-          if (i > 0) readingFindings = ["clause-fallback"];
+          if (i > 0) readingFindings = [...speechFindings, "clause-fallback"];
           break;
         }
         // Bounded pronoun carry: a "they/it/these/those/this …" sentence the
@@ -1010,7 +1840,7 @@ export async function ingestText(text, {
         const threaded = stripLeadingDiscourseAdverb(cleaned);
         if (!rows && carrySubject && PRONOUN_LEAD_RE.test(threaded)) {
           rows = await strictRows(threaded.replace(PRONOUN_LEAD_RE, `${articledSubject(carrySubject)} `));
-          if (rows) readingFindings = ["pronoun-carry"];
+          if (rows) readingFindings = [...speechFindings, "pronoun-carry"];
         }
         if (rows) {
           recognizedSentences += 1;
@@ -1035,6 +1865,8 @@ export async function ingestText(text, {
               ...(extraction.length ? { extraction } : {}),
             });
             taggedIds.add(row.id);
+            const attribution = attributionRowFor(row, { speaker: attributedTo, tag, observedAt });
+            if (attribution) { writes.push(attribution); attributions.push({ ...attribution, sentence }); }
           }
           await appendFacts(dir, writes);
           continue;
@@ -1046,8 +1878,9 @@ export async function ingestText(text, {
         for (const { finding, candidate } of reading.declined) declined.push({ sentence, finding, candidate });
         const keptCandidates = [];
         for (const t of reading.triples) {
-          if (readsAsEntityFact(t, termNlp)) keptCandidates.push(t);
-          else declined.push({ sentence, finding: "fragment-term", candidate: t });
+          const finding = declineFindingFor(t, termNlp);
+          if (finding) declined.push({ sentence, finding, candidate: t });
+          else keptCandidates.push(t);
         }
         // A minted edge rides its own finding: minted[].fact is the very object
         // the candidate list holds, so the mint and its row match by identity
@@ -1063,12 +1896,15 @@ export async function ingestText(text, {
         const tag = `optimistic-extract:${sourceTag}`;
         const candidateWrites = [];
         for (const t of keptCandidates) {
-          const extraction = findingsForRow(t, mintFindings.has(t) ? [mintFindings.get(t)] : [], identifierTerms);
+          const mintFinding = mintFindings.has(t) ? [mintFindings.get(t)] : [];
+          const extraction = findingsForRow(t, [...speechFindings, ...mintFinding], identifierTerms);
           candidateWrites.push({
             subject: t.subject, predicate: t.predicate, object: t.object, provenance: tag, observedAt,
             ...(extraction.length ? { extraction } : {}),
           });
           optimisticFacts.push({ ...t, provenance: tag, sentence, ...(extraction.length ? { extraction } : {}) });
+          const attribution = attributionRowFor(t, { speaker: attributedTo, tag, observedAt });
+          if (attribution) { candidateWrites.push(attribution); attributions.push({ ...attribution, sentence }); }
         }
         const { ids } = await appendFacts(dir, candidateWrites);
         for (const id of ids) taggedIds.add(id);
@@ -1093,12 +1929,16 @@ 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,
       recognized: recognizedSentences,
       extracted,
       optimistic: optimisticFacts,
+      attributions,
       skipped: sentenceCount - recognizedSentences - optimisticSentences,
       ungroundedTerms: [...ungroundedTerms],
       ungroundedCounts,