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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polycode-projects/the-mechanical-code-talker",
-  "version": "6.0.13",
+  "version": "6.0.14",
   "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/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" };

package/src/services/chat.mjs

@@ -18487,14 +18487,15 @@ async function factRowSnapshot(memoryDir) {
   try { return readStoredFactRows(await loadMemoryStore(memoryDir)); } catch { return null; }
 }
 
-/** The Fact rows this turn wrote, diffed against the snapshot taken before it.
- *  Empty when the turn had no store to write to, or wrote nothing. */
+/** The Fact rows this turn wrote, diffed against the snapshot taken before it,
+ *  with the after-snapshot handed back beside them. Empty when the turn had no
+ *  store to write to, or wrote nothing. */
 async function factsTouchedSince(memoryDir, before) {
-  if (!before) return [];
+  if (!before) return { factsTouched: [], factRowsAfter: null };
   const after = await factRowSnapshot(memoryDir);
-  if (!after) return [];
+  if (!after) return { factsTouched: [], factRowsAfter: null };
   const { touchedFactRows } = await import("../domain/memory/touched-facts.mjs");
-  return touchedFactRows(before, after);
+  return { factsTouched: touchedFactRows(before, after), factRowsAfter: after };
 }
 
 /** A whole-line miss whose only problem is a closed filler clause in front of a
@@ -18519,12 +18520,19 @@ async function answerWithoutFillerPrefix(input, options, missed) {
 }
 
 /** Run one turn and report which Fact rows it wrote, as `factsTouched` beside
- *  the answer/record/logLines every caller already reads. The dispatch itself
- *  is dispatchTurn, below; this wrapper exists so the field lands on EVERY
- *  return path (dispatched, conversational, multi-sentence) from one place. */
+ *  the answer/record/logLines every caller already reads, with the after-fold
+ *  the diff was taken against as `factRowsAfter`. The dispatch itself is
+ *  dispatchTurn, below; this wrapper exists so the field lands on EVERY return
+ *  path (dispatched, conversational, multi-sentence) from one place.
+ *
+ *  `options.factRowsBefore` is the caller's own already-folded view of the
+ *  store, standing in for the before-snapshot. A caller running many turns over
+ *  one document folds once and threads it; folding a seed-sized graph again per
+ *  turn, to read back the rows the caller just handed over, is the most
+ *  expensive thing an ingest does. */
 export async function runTurn(input, options = {}) {
   const memoryDir = options?.memoryDir ?? null;
-  const before = await factRowSnapshot(memoryDir);
+  const before = options?.factRowsBefore || await factRowSnapshot(memoryDir);
   let result;
   try {
     result = await dispatchTurn(input, options);
@@ -18541,7 +18549,7 @@ export async function runTurn(input, options = {}) {
     });
   }
   if (!result || typeof result !== "object") return result;
-  return { ...result, factsTouched: await factsTouchedSince(memoryDir, before) };
+  return { ...result, ...(await factsTouchedSince(memoryDir, before)) };
 }
 
 async function dispatchTurn(input, { config, source = defaultSource, graph = null, focus = null, last = null, memoryDir = null, sessionId = "", env = process.env, lexicon = null, narrate = false, liveReference = false, researchSource = null, onLiveLookup = null, vocabHint = null, tel = null, biasByBundle = {}, factRowsCache: injectedFactRowsCache = null, planState = null, gameConfig = null, uiContext = "cli", synthesisBudget = AUTO_SYNTHESIS_BUDGET, researchState = null, researchConfig = null, newsState = null, newsConfig = null, newsProviders = null, discourse = null, _noSplit = false, actingSubject = "player", codeDomainActive = null, laneVocab = null, domainPacks = null, retrieval = null } = {}) {

package/src/services/extract-facts.mjs

@@ -66,6 +66,7 @@ import { splitSentencesPreservingPaths, stripCitationResidue } from "./sentences
 import { loadMemory, readFactRows, appendFacts, removeFacts } from "../adapters/memory/core.mjs";
 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 { splitIdentifierWords } from "../domain/prose.mjs";
 import { winkInstance } from "../adapters/wink-model.mjs";
@@ -104,18 +105,22 @@ export function parseArgs(argv) {
  * on a browser-sized graph — so the caller threads one fold from sentence to
  * sentence instead of paying a fresh one per candidate.
  */
-async function runSentence(sentence, { config, memoryDir, env, beforeRows }) {
+async function runSentence(sentence, { config, memoryDir, env, beforeRows, sessionId = "" }) {
   const before = beforeRows || readFactRows(await loadMemory(memoryDir));
   if (ingestYield) await ingestYield();
-  const { record, answer } = await runTurn(sentence, { config, memoryDir, sessionId: uuidv7(), env });
+  // The turn takes the caller's fold as its own before-view and hands back the
+  // after-fold it already had to take, so one sentence costs one fold rather
+  // than three of the same graph.
+  const { record, answer, factsTouched, factRowsAfter } = await runTurn(sentence, {
+    config, memoryDir, sessionId: sessionId || uuidv7(), env, factRowsBefore: before,
+  });
+  const after = factRowsAfter || before;
   // Only an assert turn can have written a Fact, so only an assert turn earns
-  // the post-turn fold; every other turn hands the caller's own view straight
-  // back untouched.
+  // a fresh view; every other turn hands the caller's own straight back.
   if (record?.via !== "assert") return { recognized: false, rows: [], afterRows: before, decline: String(answer || "") };
   if (ingestYield) await ingestYield();
-  const after = readFactRows(await loadMemory(memoryDir));
   if (record?.miss) return { recognized: false, rows: [], afterRows: after, decline: String(answer || "") };
-  return { recognized: true, rows: touchedFactRows(before, after), afterRows: after };
+  return { recognized: true, rows: factsTouched || touchedFactRows(before, after), afterRows: after };
 }
 
 /** The recognizer's own words for why it turned a sentence down, when it named
@@ -800,6 +805,13 @@ function canonicalLines(facts, storeRows) {
  *                 are the only output.
  *     sourceTag   the label the audit provenance carries (extracted:<tag> /
  *                 optimistic-extract:<tag>). Default "text".
+ *     attributeToSource
+ *                 file the recognizer's own assertion under `sourceTag`'s
+ *                 publication instead of a fresh chat session per sentence.
+ *                 Off by default: an operator running `tmct extract` over their
+ *                 own notes IS the asserting party, so that lane keeps minting
+ *                 a session. A feed or a reference work is not, and one
+ *                 publication's sentences must never corroborate each other.
  *     optimistic  also run the fuzzy tier over strict-skipped sentences.
  *     canonical   include a `canonical` array: one enriched triple line per
  *                 ingested fact.
@@ -830,7 +842,12 @@ function canonicalLines(facts, storeRows) {
 export async function ingestText(text, {
   memoryDir = null, sourceTag = "text", optimistic = false,
   canonical = false, config = null, lexicon = null, observedAt = "", findings = false,
+  attributeToSource = false,
 } = {}) {
+  // The session id every sentence's recognizer turn runs under. Stable and
+  // derived from the publication when the caller attributes to it, so the whole
+  // run lands on one Source; a fresh uuid per sentence otherwise (runSentence).
+  const recognizerSessionId = attributeToSource ? `${INGEST_SESSION_MARKER}${sourceTag.split("@")[0]}` : "";
   // Paragraphs first (blank-line separated), so the pronoun carry never bridges
   // a topic break: a fresh paragraph clears the last-subject it would resolve
   // "they"/"it" against. Each paragraph then splits into sentences the shared
@@ -900,7 +917,7 @@ export async function ingestText(text, {
     if (ingestYield) await ingestYield();
     const knownIds = new Set(currentRows.map((r) => r.id));
     const { recognized, rows, afterRows, decline } = await runSentence(form, {
-      config: cfg, memoryDir: dir, env: runEnv, beforeRows: currentRows,
+      config: cfg, memoryDir: dir, env: runEnv, beforeRows: currentRows, sessionId: recognizerSessionId,
     });
     currentRows = afterRows;
     if (!recognized) { lastDecline = decline || lastDecline; return null; }

package/src/services/news.mjs

@@ -338,6 +338,7 @@ async function ingestSnapshotFacts(ctx, snapshot) {
   const sourceTag = `news:${snapshot.sourceId}@${snapshot.id}`;
   const result = await ingestText(text, {
     memoryDir, sourceTag, optimistic: true, lexicon: lex, observedAt: nowVal, findings: true,
+    attributeToSource: true,
   });
   invalidateCache(cache);
 
@@ -662,6 +663,7 @@ async function ingestResearchArticle(ctx, term, provider, article) {
     ingested = await ingestText(prose, {
       memoryDir, sourceTag: provenance, optimistic: true,
       lexicon: lexicon || loadLexicon(), observedAt: resolveNow(now), findings: true,
+      attributeToSource: true,
     });
     invalidateCache(ctx.cache);
   }