@polycode-projects/the-mechanical-code-talker 6.0.13 → 6.0.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polycode-projects/the-mechanical-code-talker",
-  "version": "6.0.13",
+  "version": "6.0.15",
   "private": false,
   "type": "module",
   "description": "The Mechanical Code Talker (tmct) — a tolerant, offline, $0 chat surface that guides you toward precision queries about a software repository. ELIZA/PARRY-style but domain-obsessed with code. No model calls; indexes a repo on request (tmct index) or reads any producer's graph.",

package/src/adapters/corpus/news-sources.mjs

@@ -298,6 +298,30 @@ async function fetchWikimediaFeed(record, gate, { now }) {
   return { items, bytes: jsonByteLength(body) };
 }
 
+// A Hacker News item is a headline and nothing else — the API carries no
+// summary field to fetch — and a headline is rarely a sentence, so nothing in
+// the item grounds on its own. The fixed sentence below states what the site
+// itself did with the story, and it names the headline IN QUOTES: quoted, the
+// headline's own words can never be re-read as a claim of their own, so "Let's
+// take apart your phone" stays a story Hacker News discusses instead of
+// becoming a fact about Hacker News taking a phone apart.
+//
+// "Hackernews" is one word here on purpose. A two-word proper name in subject
+// position reads as noun + verb ("Hacker" doing "News"), and the fact that
+// falls out of that is nonsense.
+const HACKER_NEWS_TITLE_PREFIX_RE = /^(?:show|ask|tell)\s+hn:\s*/i;
+// Past this many words the stored term is a clause, not a name, and the
+// recognizer turns it down — so the sentence is not built at all rather than
+// stored half-read.
+const HACKER_NEWS_HEADLINE_MAX_WORDS = 6;
+
+function hackerNewsSummary(title) {
+  const headline = String(title || "").replace(HACKER_NEWS_TITLE_PREFIX_RE, "").trim();
+  if (!headline || headline.includes(":")) return "";
+  if (headline.split(/\s+/).length > HACKER_NEWS_HEADLINE_MAX_WORDS) return "";
+  return `Hackernews discusses "${headline}".`;
+}
+
 /** topstories.json, then item/<id>.json for the first ten ids, through the
  *  same gate — each item fetch takes its own slot, so the ten round trips
  *  are genuinely paced by the gate's minIntervalMs rather than firing back
@@ -311,11 +335,12 @@ async function fetchHackerNews(record, gate, { now }) {
     const item = await pacedFetchJson(gate, `${record.url}/item/${id}.json`);
     if (!item) continue;
     bytes += jsonByteLength(item);
+    const title = stripMarkup(item.title || "");
     raw.push({
       guid: String(item.id ?? id),
-      title: stripMarkup(item.title || ""),
+      title,
       url: item.url || `https://news.ycombinator.com/item?id=${item.id ?? id}`,
-      summary: "",
+      summary: hackerNewsSummary(title),
       publishedAt: Number.isFinite(item.time) ? new Date(item.time * 1000).toISOString() : "",
     });
   }
@@ -323,6 +348,32 @@ async function fetchHackerNews(record, gate, { now }) {
   return { items, bytes };
 }
 
+// A USGS place names a point by its distance and bearing from a settlement
+// ("25 km ENE of Wana, Pakistan"), or by an offshore bearing ("off the west
+// coast of Vancouver Island, Canada"), or outright ("Western Australia"). The
+// distance and the bearing are a measurement, not a name, so they come off
+// before the place reaches the sentence below: a number-led term can never
+// head a feed card, and "near" already covers the few kilometres dropped.
+const USGS_DISTANCE_PREFIX_RE = /^\s*\d+(?:\.\d+)?\s*km\s+[NSEW]{1,3}\s+of\s+/i;
+const USGS_OFFSHORE_PREFIX_RE = /^\s*off\s+(?:the\s+)?[a-z\s]*?coast\s+of\s+/i;
+
+function usgsPlaceName(place) {
+  return String(place || "")
+    .replace(USGS_DISTANCE_PREFIX_RE, "")
+    .replace(USGS_OFFSHORE_PREFIX_RE, "")
+    .trim();
+}
+
+// One fixed sentence per quake: a bare-noun subject, the verb the event did,
+// and the named place. The magnitude stays where USGS itself put it, in the
+// item's title — a stored fact's subject here is the CLASS "earthquake", so
+// writing the number into this sentence would say something about earthquakes
+// in general rather than about this one.
+function usgsSummary(place) {
+  const name = usgsPlaceName(place);
+  return name ? `An earthquake struck near ${name}.` : "";
+}
+
 async function fetchUsgs(record, gate, { now }) {
   const body = await pacedFetchJson(gate, record.url);
   if (body === null) return null;
@@ -332,7 +383,7 @@ async function fetchUsgs(record, gate, { now }) {
     guid: String(f?.id ?? f?.properties?.detail ?? f?.properties?.url ?? ""),
     title: stripMarkup(f?.properties?.title || ""),
     url: f?.properties?.url || "",
-    summary: stripMarkup(`magnitude ${f?.properties?.mag ?? "unknown"} earthquake near ${f?.properties?.place || "an unreported location"}`),
+    summary: stripMarkup(usgsSummary(f?.properties?.place)),
     publishedAt: Number.isFinite(f?.properties?.time) ? new Date(f.properties.time).toISOString() : "",
   }));
   const items = normalizeFeedItems(record.id, raw, { now });
@@ -347,7 +398,11 @@ function wikinewsArticleOrigin(apiUrl) {
  *  recentchanges list — the smallest query that names what is new without a
  *  category to maintain by hand. */
 async function fetchWikinews(record, gate, { now }) {
-  const url = `${record.url}?action=query&list=recentchanges&rcnamespace=0&rcnewonly=1&rclimit=20&format=json&formatversion=2&origin=*`;
+  // `rctype=new` is the action API's own name for "page creations only". An
+  // earlier `rcnewonly` is not a parameter the API has: it answers with an
+  // "Unrecognized parameter" warning and lists every edit, so a re-edited old
+  // article read as a new story.
+  const url = `${record.url}?action=query&list=recentchanges&rcnamespace=0&rctype=new&rclimit=20&format=json&formatversion=2&origin=*`;
   const body = await pacedFetchJson(gate, url);
   if (body === null) return null;
   if (isNotModified(body)) return { items: [], bytes: 0, notModified: true };

package/src/adapters/memory/core.mjs

@@ -2421,12 +2421,14 @@ function sourceIdFor(desc) {
     case "provider": return { id: `src:provider:${desc.name}`, type: "provider" };
     case "corpus": return { id: `src:corpus:${desc.name}`, type: "corpus" };
     case "corpusWeak": return { id: `src:corpus-weak:${desc.name}`, type: "corpusWeak" };
-    // One Source per pack article (the @revid stays in the article segment),
-    // so two facts from the same article corroborate nothing extra.
-    case "reference": return { id: `src:reference:${desc.pack}:${desc.article}`, type: "reference" };
-    // The live-Wikipedia pack: same per-article Source id, but a lower trust
+    // One Source per reference WORK, not per article: Simple English Wikipedia
+    // is one party however many of its pages get read, so two of its articles
+    // stating the same triple corroborate nothing. Which article said it stays
+    // on the fact's own provenance tag, where the audit trail belongs.
+    case "reference": return { id: `src:reference:${desc.pack}`, type: "reference" };
+    // The live-Wikipedia pack: same per-work Source id, but a lower trust
     // type so a live lookup ranks below the curated revision-pinned pack.
-    case "referenceLive": return { id: `src:reference:${desc.pack}:${desc.article}`, type: "referenceLive" };
+    case "referenceLive": return { id: `src:reference:${desc.pack}`, type: "referenceLive" };
     // One Source per source-file basename, not per extraction run.
     case "extracted": return { id: `src:extracted:${desc.name}`, type: "extracted" };
     // The fuzzy tier's candidates: one low-trust Source per source label.
@@ -2600,6 +2602,49 @@ const isSessionScopedSourceId = (id) =>
     || id.startsWith(`${TEACH_SOURCE_ID}:`)
     || id.startsWith(`${TEACH_NODE_SOURCE_ID}:`));
 
+/**
+ * The slice of the graph a reliability pass can possibly read: the triples a
+ * session-scoped Source stated, and every (subject, predicate) those triples
+ * sit under so each one's disagreeing siblings come along. Null when nothing
+ * in the store has a track record to keep, which is the whole of what a
+ * seed-only graph or a store whose writers are all documents ever needs.
+ *
+ * A pure narrowing, not a cache: the answer is still folded from the fact set
+ * on every call, and every group left out is one whose row could not have
+ * changed a number in the tally. A Source nobody stated anything for keeps no
+ * reliability attribute either way, so leaving it out is what the whole-graph
+ * pass does too.
+ */
+function sessionScopedFoldScope(payload) {
+  // The Source list is a handful of individuals where the edge list is one per
+  // fact record, so "is there an actor here at all" is asked of the Sources.
+  const idx = memoryIndexOf(payload);
+  if (idx) {
+    let anyActor = false;
+    for (const id of idx.sourcesById.keys()) if (isSessionScopedSourceId(id)) { anyActor = true; break; }
+    if (!anyActor) return null;
+  }
+  const statedGroup = payload.objectProperties.find((g) => g?.prop === STATED_BY_PROP);
+  const statedRecordIds = new Set();
+  for (const e of statedGroup?.examples || []) {
+    if (isSessionScopedSourceId(e?.object)) statedRecordIds.add(e.subject);
+  }
+  const scopedGroups = new Set();
+  const pairs = new Set();
+  for (const ind of payload.individuals) {
+    if (ind?.class !== FACT_CLASS) continue;
+    // A summary that absorbed an actor's record still votes for it, so the
+    // group it stands in is in scope exactly as the record itself would be.
+    const stated = statedRecordIds.has(ind.id)
+      || (isHeadRollupId(ind.id) && absorbedSourceIds(ind).some(isSessionScopedSourceId));
+    if (!stated) continue;
+    scopedGroups.add(factGroupId(ind.id));
+    const subject = individualKey(ind, "subject");
+    if (subject) pairs.add(subjectPredicateKey(subject, individualKey(ind, "predicate")));
+  }
+  return scopedGroups.size ? { pairs, scopedGroups } : null;
+}
+
 /**
  * Recompute + materialise mgx:sourceReliability on every session-scoped
  * operator/teach Source: count facts stated vs. contradicted
@@ -2610,11 +2655,17 @@ const isSessionScopedSourceId = (id) =>
  */
 function recomputeSourceReliability(payload) {
   if (!Array.isArray(payload?.individuals) || !Array.isArray(payload?.objectProperties)) return;
-  const rows = readFactRows(payload); // Fact-only — contradiction accounting is inherently Fact-shaped
+  const scope = sessionScopedFoldScope(payload);
+  if (!scope) return;
+
+  // Fact-only — contradiction accounting is inherently Fact-shaped. Scoped to
+  // the triples a scorable actor actually stated, plus every sibling object
+  // those triples could be contradicted by: no other group can put a number in
+  // the tally below, so folding the rest of the graph only costs time.
+  const rows = foldFactRows(payload, factFoldContext(payload, scope));
   const contradictedFactIds = new Set();
   // The fold above is the same one findContradictions would take for itself,
-  // and over a seed-sized graph it is half a second. Nothing changes the
-  // payload between the two, so it goes across.
+  // and nothing changes the payload between the two, so it goes across.
   for (const group of findContradictions(payload, { factRows: rows })) for (const r of group) contradictedFactIds.add(r.id);
 
   const bySource = new Map(); // sessionSourceId -> { factsAsserted, factsContradicted }
@@ -3813,7 +3864,14 @@ export async function resolveRelationChaseReverse(memory, name, objectTerm, help
  * answers "what did this source used to say", never "what do I trust now".
  */
 export function readFactRows(memory, opts = {}) {
-  const ctx = factFoldContext(memory);
+  return foldFactRows(memory, factFoldContext(memory), opts);
+}
+
+/** The fold itself, over whatever slice of the graph a context was built for.
+ *  `readFactRows` hands it the whole graph; a caller that only needs certain
+ *  (subject, predicate) pairs hands it a scoped context and gets exactly the
+ *  rows a whole-graph fold would have produced for those pairs. */
+function foldFactRows(memory, ctx, opts = {}) {
   // A materialised head, when the backend keeps one, replaces the group's own
   // fold with the audit trail that fold was last built from — the same records,
   // read back instead of re-derived. It carries no recency by construction, so
@@ -3840,17 +3898,47 @@ export function readFactRows(memory, opts = {}) {
  *  Shared by the read fold and by the head materialisation below, deliberately:
  *  a stored aggregate and a computed one folded from different inputs is the
  *  failure a materialised table invites, and one shared builder is what keeps
- *  the two from ever drifting apart. */
-function factFoldContext(memory) {
+ *  the two from ever drifting apart.
+ *
+ *  `pairs` narrows the context to the groups a given set of (subject,
+ *  predicate) keys carries, with `scopedGroups` naming groups to keep outright
+ *  whatever their records read as. Every group of a kept pair is kept, whoever
+ *  stated it, so a scoped fold reads each of those triples exactly as a
+ *  whole-graph fold does — and a caller asking about one party's facts still
+ *  sees every sibling object that party's claim could be contradicted by. */
+function factFoldContext(memory, { pairs = null, scopedGroups = new Set() } = {}) {
   const individuals = memory?.individuals || [];
-  const sourcesById = new Map(individuals.filter((i) => i?.class === SOURCE_CLASS).map((i) => [i.id, i]));
-  const statedGroup = (memory?.objectProperties || []).find((g) => g?.prop === STATED_BY_PROP);
-  const statedByRecord = new Map();
-  for (const e of statedGroup?.examples || []) {
-    if (!statedByRecord.has(e.subject)) statedByRecord.set(e.subject, []);
-    statedByRecord.get(e.subject).push(e.object);
+  const idx = memoryIndexOf(memory);
+  const sourcesById = idx
+    ? idx.sourcesById
+    : new Map(individuals.filter((i) => i?.class === SOURCE_CLASS).map((i) => [i.id, i]));
+  // The live index already keeps this map, edge for edge, and rebuilding it
+  // allocates one array per fact record over the whole graph.
+  let statedByRecord = idx?.statedByBySubject;
+  if (!statedByRecord) {
+    const statedGroup = (memory?.objectProperties || []).find((g) => g?.prop === STATED_BY_PROP);
+    statedByRecord = new Map();
+    for (const e of statedGroup?.examples || []) {
+      if (!statedByRecord.has(e.subject)) statedByRecord.set(e.subject, []);
+      statedByRecord.get(e.subject).push(e.object);
+    }
   }
 
+  // Subject first, predicate only on a subject hit: reading both attributes off
+  // every fact record in the graph is the whole cost of a scoped pass, and the
+  // subject rules out nearly all of them on one lookup.
+  const wantedSubjects = pairs ? new Set([...pairs].map((key) => key.slice(0, key.indexOf("")))) : null;
+  const outsideScope = (ind) => {
+    if (!pairs) return false;
+    // A group the caller named outright is in whatever its records read as —
+    // a summary standing for absorbed records carries only a copied template,
+    // so its own attributes are not what places it.
+    if (scopedGroups.has(factGroupId(ind.id))) return false;
+    const subject = individualKey(ind, "subject");
+    if (!wantedSubjects.has(subject)) return true;
+    return !pairs.has(subjectPredicateKey(subject, individualKey(ind, "predicate")));
+  };
+
   const groups = new Map();
   const retractionsByGroup = new Map();
   for (const ind of individuals) {
@@ -3864,6 +3952,7 @@ function factFoldContext(memory) {
     if (ind?.class !== FACT_CLASS) continue;
     if ((ind.attributes || []).some((a) => a?.prop === SUPERSEDED_BY_PROP)) continue; // a demoted leaf, not a head
     if (isChainRollupId(ind.id)) continue; // a summary of one source's demoted history, which was never a vote
+    if (outsideScope(ind)) continue;
     const groupId = factGroupId(ind.id);
     const group = groups.get(groupId);
     if (group) group.push(ind);
@@ -3888,26 +3977,89 @@ function factFoldContext(memory) {
     else groups.delete(groupId);
   }
 
-  const groupsByPair = new Map();
-  for (const [groupId, members] of groups) {
-    // Codepoint order on the record id, which sorts by source key — the same
-    // locale-free determinism the P2P layer's own sort insists on, so two peers
-    // holding the same records read the same row.
-    members.sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
-    const key = subjectPredicateKey(individualKey(members[0], "subject"), individualKey(members[0], "predicate"));
-    const held = groupsByPair.get(key);
-    if (held) held.push(groupId);
-    else groupsByPair.set(key, [groupId]);
-  }
+  // Codepoint order on the record id, which sorts by source key — the same
+  // locale-free determinism the P2P layer's own sort insists on, so two peers
+  // holding the same records read the same row.
+  for (const members of groups.values()) members.sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+
+  // One entry per distinct Source, not one attribute scan per record: a seed's
+  // 60,000 facts name a handful of Sources between them.
+  const typeBySource = new Map();
+  const sourceTypeOf = (id) => {
+    let type = typeBySource.get(id);
+    if (type === undefined) {
+      type = (sourcesById.get(id)?.attributes || []).find((a) => a?.prop === "mgx:sourceType")?.value || "";
+      typeBySource.set(id, type);
+    }
+    return type;
+  };
+
+  // Likewise for the timestamp a provenance string embeds: a corpus band writes
+  // one tag over tens of thousands of records, and parsing it is the same
+  // answer every time.
+  const embeddedBySource = new Map();
+  const embeddedTimestampOf = (provenance) => {
+    let ts = embeddedBySource.get(provenance);
+    if (ts === undefined) {
+      ts = embeddedTagTimestamp(provenance.split(" | ").filter(Boolean));
+      embeddedBySource.set(provenance, ts);
+    }
+    return ts;
+  };
+
+  // Only the sqlite head materialisation walks siblings by pair, and building
+  // the index costs two attribute reads per group — so it is built when asked
+  // for and not before.
+  let groupsByPair = null;
 
   return {
     groups,
-    groupsByPair,
+    get groupsByPair() {
+      if (groupsByPair) return groupsByPair;
+      groupsByPair = new Map();
+      for (const [groupId, members] of groups) {
+        const key = subjectPredicateKey(individualKey(members[0], "subject"), individualKey(members[0], "predicate"));
+        const held = groupsByPair.get(key);
+        if (held) held.push(groupId);
+        else groupsByPair.set(key, [groupId]);
+      }
+      return groupsByPair;
+    },
     statedByRecord,
-    sourceTypeOf: (id) => (sourcesById.get(id)?.attributes || []).find((a) => a?.prop === "mgx:sourceType")?.value || "",
+    sourceTypeOf,
+    embeddedTimestampOf,
   };
 }
 
+/** Everything the fold reads off one live head, gathered in ONE walk of its
+ *  attributes. Ten `.find()` scans of the same short array, once per record, is
+ *  the single most expensive thing a whole-graph fold does — the work is all in
+ *  the scanning, not in the reading. */
+function foldHeadFields(head) {
+  let provenance = "";
+  let createdAt = "";
+  let observedAt = "";
+  let extraction = "";
+  let trustScore = "";
+  let sourceId = "";
+  let quantifier = "";
+  let justification = "";
+  for (const a of head?.attributes || []) {
+    switch (a?.prop) {
+      case "mgx:factProvenance": provenance = a.value || ""; continue;
+      case CREATED_AT_PROP: createdAt = a.value || ""; continue;
+      case OBSERVED_AT_PROP: observedAt = a.value || ""; continue;
+      case EXTRACTION_FINDING_PROP: extraction = a.value || ""; continue;
+      case TRUST_SCORE_PROP: trustScore = a.value || ""; continue;
+      case SOURCE_ID_PROP: sourceId = a.value || ""; continue;
+      default: break;
+    }
+    if (a?.key === "quantifier") quantifier = a.value || "";
+    else if (a?.key === "justification") justification = a.value || "";
+  }
+  return { provenance, createdAt, observedAt, extraction, trustScore, sourceId, quantifier, justification };
+}
+
 /** One triple group folded into its row, minus the aggregate trust — that is
  *  the caller's, because it is the only part that depends on when you ask. */
 function foldFactGroup(id, heads, ctx) {
@@ -3953,10 +4105,11 @@ function foldFactGroup(id, heads, ctx) {
       });
       continue;
     }
-    const headTags = attrOf(head, "mgx:factProvenance").split(" | ").filter(Boolean);
+    const field = foldHeadFields(head);
+    const headTags = field.provenance.split(" | ").filter(Boolean);
     for (const tag of headTags) tags.add(tag);
     const [statedBy] = statedByRecord.get(head.id) || [];
-    const sourceId = statedBy || attrOf(head, SOURCE_ID_PROP);
+    const sourceId = statedBy || field.sourceId;
     const sourceType = sourceTypeOf(sourceId);
     // src:none stands for "no Source at all", so it stays out of the union a
     // reader renders and out of the corroboration count, exactly as an
@@ -3965,9 +4118,9 @@ function foldFactGroup(id, heads, ctx) {
       sourceIds.push(statedBy);
       if (sourceType) sourceTypes.push(sourceType);
     }
-    const createdAt = attrOf(head, CREATED_AT_PROP);
-    const observedAt = attrOf(head, OBSERVED_AT_PROP);
-    const extraction = attrOf(head, EXTRACTION_FINDING_PROP).split(" ").filter(Boolean);
+    const createdAt = field.createdAt;
+    const observedAt = field.observedAt;
+    const extraction = field.extraction ? field.extraction.split(" ").filter(Boolean) : [];
     for (const finding of extraction) findings.add(finding);
     assertions.push({
       id: head.id, sourceId, sourceType,
@@ -3975,13 +4128,13 @@ function foldFactGroup(id, heads, ctx) {
       createdAt,
       ...(observedAt ? { observedAt } : {}),
       ...(extraction.length ? { extraction } : {}),
-      ownTrust: Number(attrOf(head, TRUST_SCORE_PROP)) || 0,
-      assertedAt: assertionTimestampFor(headTags, createdAt),
+      ownTrust: Number(field.trustScore) || 0,
+      assertedAt: ctx.embeddedTimestampOf(field.provenance) || (Number.isFinite(Date.parse(createdAt)) ? createdAt : ""),
     });
-    quantifier = quantifier || keyOf(head, "quantifier");
+    quantifier = quantifier || field.quantifier;
     // ' | '-separated environments, one premise-id list per independent
     // derivation; a legacy value with no ' | ' parses as one environment.
-    for (const chunk of keyOf(head, "justification").split(" | ")) {
+    for (const chunk of field.justification.split(" | ")) {
       const env = chunk.split(" ").filter(Boolean);
       if (!env.length) continue;
       const key = env.join(" ");

package/src/adapters/memory/shacl.mjs

@@ -59,8 +59,8 @@ const SPANS_A_SENTENCE_BOUNDARY_RE = /[.!?]\s+\w/;
 // never for the group part: a hand-built individual with a short opaque id is a
 // legitimate sparse write, and rejecting it is exactly the false positive this
 // gate must never produce. The source suffix is matched loosely on purpose — a
-// Source id legitimately carries colons, spaces and an `@revid` of its own
-// ("src:reference:simplewiki:Polar bear@912").
+// Source id legitimately carries colons and spaces of its own
+// ("src:corpus:mud:amber fox").
 const FACT_RECORD_ID_RE = /^[^@]+@(.+?)(#v[1-9][0-9]*)?$/;
 const looksLikeFactRecordId = (id) => id.includes("@") || /#v\d/.test(id);
 

package/src/domain/memory/trust.mjs

@@ -107,6 +107,60 @@ function parsePeerNodeTagRest(rest) {
 const LIVE_REFERENCE_PACK = "wikipedia-live";
 const referenceKindFor = (pack) => (pack === LIVE_REFERENCE_PACK ? "referenceLive" : "reference");
 
+/** The part of a tag that names WHICH publication it came from, with the
+ *  per-item tail cut off: `news:nyt-world@item-91` names the NYT world feed,
+ *  and the item id beside it says which article, not which publisher. One feed
+ *  is one asserting party however many articles it runs, so the tail stays on
+ *  the tag for audit and out of the Source identity — the same split
+ *  `world:<name>:turnN` and `mud:<character>:turnN` already make. */
+const publicationKeyOf = (rest) => String(rest || "").split("@")[0];
+
+/** The same cut for a tag the fuzzy tier labels its own Source with: the feed
+ *  or the reference work, never the article. `news:nyt-world@item-91` folds to
+ *  `news:nyt-world`, `research:wikidata:otter` to `research:wikidata`, and the
+ *  research lane's `research:otter@2` to `research`. */
+function publicationSourceLabel(rest) {
+  if (rest.startsWith("news:")) return publicationKeyOf(rest);
+  const { pack } = researchTagToSource(rest.slice("research:".length));
+  return `research:${pack}`;
+}
+
+/** `teach:chat:ingest#<tag>@<ts>` — the ingest seam driving the chat teach lane
+ *  as a RECOGNIZER over a document. The party asserting is the document's own
+ *  publisher, which the embedded `<tag>` names, so the record lands on that
+ *  publisher's Source rather than on a chat session. Without it an ingest mints
+ *  a throwaway teach Source per SENTENCE, and one publication's sentences
+ *  corroborate each other for free. */
+export const INGEST_SESSION_MARKER = "ingest#";
+
+/** The two `research:` tag shapes, both live-fetched at query time and both
+ *  scored at the referenceLive prior, below every curated pack:
+ *    research:<source>:<term>   one KB adapter's own lookup (researchSourceTag)
+ *    research:<topic>@<depth>   the research lane's fan-out, which records how
+ *                               far it reached rather than which adapter answered
+ *  The `@` is what tells them apart — a folded term never carries one. Either
+ *  way the PACK names the reference work and the article segment names the page
+ *  inside it, so `sourceIdFor` can key one Source per work. */
+function researchTagToSource(rest) {
+  const at = rest.lastIndexOf("@");
+  if (at >= 0) return { kind: "referenceLive", pack: "research", article: rest.slice(0, at).trim() || "unknown" };
+  const colon = rest.indexOf(":");
+  if (colon < 0) return { kind: "referenceLive", pack: "research", article: rest.trim() || "unknown" };
+  return { kind: "referenceLive", pack: rest.slice(0, colon) || "research", article: rest.slice(colon + 1).trim() };
+}
+
+/** The publisher a chat-shaped tag stands in for, when its session slot carries
+ *  the ingest marker; null for an ordinary session, which is every tag a person
+ *  actually typed. One level only — an embedded chat tag is refused rather than
+ *  followed, so a hand-written tag cannot nest its way anywhere. */
+function ingestPublisherOf(chat) {
+  if (!chat.sessionId?.startsWith(INGEST_SESSION_MARKER)) return null;
+  const embedded = chat.sessionId.slice(INGEST_SESSION_MARKER.length);
+  if (embedded.startsWith("teach:") || embedded.startsWith("ace:")) return null;
+  const publisher = provenanceTagToSource(embedded);
+  return publisher ? { ...publisher, ...(chat.createdAt ? { createdAt: chat.createdAt } : {}) } : null;
+}
+
 export function provenanceTagToSource(tag) {
   const t = String(tag || "").trim();
   if (!t) return null;
@@ -119,17 +173,7 @@ export function provenanceTagToSource(tag) {
     const pack = rest.slice(0, colon) || "unknown";
     return { kind: referenceKindFor(pack), pack, article: rest.slice(colon + 1) };
   }
-  // research:<topic>@<depth> — the research lane's Simple English Wikipedia
-  // loads. Live-fetched at query time like the wikipedia-live pack, so it
-  // scores at the same referenceLive prior, below every curated pack. Parsed
-  // from the FULL tag (a topic may contain spaces); the depth segment records
-  // how far the fan-out reached and is not part of the Source identity.
-  if (t.startsWith("research:")) {
-    const rest = t.slice("research:".length);
-    const at = rest.lastIndexOf("@");
-    const topic = (at >= 0 ? rest.slice(0, at) : rest).trim();
-    return { kind: "referenceLive", pack: "research", article: topic || "unknown" };
-  }
+  if (t.startsWith("research:")) return researchTagToSource(t.slice("research:".length));
   const head = t.split(/\s+/)[0]; // drop trailing " /r/IsA" etc.
   if (head.startsWith("corpus-weak:")) return { kind: "corpusWeak", name: head.slice("corpus-weak:".length) || "unknown" };
   if (head.startsWith("corpus:")) return { kind: "corpus", name: head.slice("corpus:".length) || "unknown" };
@@ -148,7 +192,10 @@ export function provenanceTagToSource(tag) {
   // `mud:` prefix so `src:corpus:mud:<character>` can never collide with a
   // `world:<name>` Source that happens to share the literal name.
   if (head.startsWith("mud:")) return { kind: "corpus", name: `mud:${head.slice("mud:".length).split(":")[0] || "unknown"}` };
-  if (head.startsWith("ace:")) return { kind: "operator", ...parseChatTagRest(head.slice("ace:".length)) };
+  if (head.startsWith("ace:")) {
+    const chat = parseChatTagRest(head.slice("ace:".length));
+    return ingestPublisherOf(chat) || { kind: "operator", ...chat };
+  }
   if (head.startsWith("teach:")) {
     const rest = head.slice("teach:".length);
     // teach:peer:<name>#node:<id>@<ts> — a peer's own relabeled tag off the
@@ -156,7 +203,8 @@ export function provenanceTagToSource(tag) {
     const peerNode = parsePeerNodeTagRest(rest);
     if (peerNode) return peerNode;
     // the chat teach lane's natural frames — chat.mjs's teachProvenanceTag
-    return { kind: "teach", ...parseChatTagRest(rest) };
+    const chat = parseChatTagRest(rest);
+    return ingestPublisherOf(chat) || { kind: "teach", ...chat };
   }
   if (head.startsWith("web:")) return { kind: "web", url: head.slice("web:".length) };
   if (head.startsWith("url:")) return { kind: "web", url: head.slice("url:".length) };
@@ -172,10 +220,23 @@ export function provenanceTagToSource(tag) {
   // the bare extracted: fallback below, which still catches every other
   // extracted: caller unchanged. A bare news:<sourceId>@<itemId> tag (a
   // future caller that writes it directly, with no extracted: wrapper)
-  // scores the same way.
-  if (head.startsWith("extracted:news:")) return { kind: "web", url: head.slice("extracted:".length) };
-  if (head.startsWith("news:")) return { kind: "web", url: head };
-  if (head.startsWith("optimistic-extract:")) return { kind: "optimisticExtract", name: head.slice("optimistic-extract:".length) || "unknown" };
+  // scores the same way. One Source per FEED: the item id rides the tag for
+  // audit and stays out of the identity.
+  if (head.startsWith("extracted:news:")) return { kind: "web", url: publicationKeyOf(head.slice("extracted:".length)) };
+  if (head.startsWith("news:")) return { kind: "web", url: publicationKeyOf(head) };
+  // The same wrapper over a KB lookup's own tag: the reference work that
+  // answered is the asserting party, not the ingest run that read it.
+  if (head.startsWith("extracted:research:")) return researchTagToSource(head.slice("extracted:research:".length));
+  // The fuzzy tier keeps a Source of its OWN — a candidate the strict
+  // recognizer skipped must never corroborate a curated fact — but one per
+  // publication, not one per article.
+  if (head.startsWith("optimistic-extract:")) {
+    const rest = head.slice("optimistic-extract:".length);
+    const publication = rest.startsWith("news:") || rest.startsWith("research:")
+      ? publicationSourceLabel(rest)
+      : rest;
+    return { kind: "optimisticExtract", name: publication || "unknown" };
+  }
   if (head.startsWith("extracted:")) return { kind: "extracted", name: head.slice("extracted:".length) || "unknown" };
   if (head.startsWith("entailed:")) return { kind: "entailed", rule: head.slice("entailed:".length) };
   if (head.startsWith("chat:") || head.startsWith("session:") || head.startsWith("operator")) return { kind: "operator" };