stratagate-dsh 0.2.75 → 0.2.76

package/dist/plugin.js

@@ -385,6 +385,155 @@ function rrfRank(rankings) {
 // packages/core/src/graph.ts
 var NODE_TYPES = /* @__PURE__ */ new Set(["person", "project", "organization", "tool", "place"]);
 var STATUSES = /* @__PURE__ */ new Set(["active", "superseded", "disputed", "archived"]);
+var GRAPH_PROVENANCE_LIMIT = 6;
+function unique(values) {
+  return [...new Set(values)];
+}
+function factText(fact) {
+  return `${fact.key}: ${Array.isArray(fact.value) ? fact.value.join("\u3001") : fact.value}`;
+}
+function renderCurrentState(facts) {
+  return facts.map((fact) => `${factText(fact)}${fact.status === "disputed" ? " [disputed]" : ""}`).join("\n");
+}
+var EXPOSED_EVENT_STATUSES = /* @__PURE__ */ new Set(["active", "superseded"]);
+function exposedSources(ids, eventById) {
+  return unique((ids ?? []).filter((id) => EXPOSED_EVENT_STATUSES.has(eventById.get(id)?.status ?? "forgotten")));
+}
+function metadataEntries(entries, allowedValues, eventById) {
+  const allowed = new Set(allowedValues.map((value) => normalizeSearchText(value)));
+  return (entries ?? []).flatMap((entry) => {
+    const value = typeof entry.value === "string" ? entry.value.trim() : "";
+    const sourceEventIds = exposedSources(entry.sourceEventIds, eventById);
+    return value && allowed.has(normalizeSearchText(value)) && sourceEventIds.length > 0 ? [{ value, sourceEventIds }] : [];
+  });
+}
+function effectiveMetadata(node, eventById) {
+  if (!node.metadataProvenance) {
+    const potentialSources = unique(node.sourceEventIds ?? []);
+    const allSourcesExposed = potentialSources.length > 0 && potentialSources.every((id) => EXPOSED_EVENT_STATUSES.has(eventById.get(id)?.status ?? "forgotten"));
+    return allSourcesExposed ? { name: node.name, aliases: [...node.aliases], ...node.tags ? { tags: [...node.tags] } : {} } : { name: "", aliases: [] };
+  }
+  const nameSources = exposedSources(node.metadataProvenance.name, eventById);
+  const aliases = metadataEntries(node.metadataProvenance.aliases, node.aliases, eventById);
+  const tags = metadataEntries(node.metadataProvenance.tags, node.tags ?? [], eventById);
+  const metadataProvenance = {
+    ...nameSources.length > 0 ? { name: nameSources } : {},
+    ...aliases.length > 0 ? { aliases } : {},
+    ...tags.length > 0 ? { tags } : {}
+  };
+  return {
+    name: nameSources.length > 0 ? node.name : "",
+    aliases: aliases.map(({ value }) => value),
+    ...tags.length > 0 ? { tags: tags.map(({ value }) => value) } : {},
+    metadataProvenance
+  };
+}
+function effectiveGraphNodeView(node, edges, events) {
+  if (node.status !== "active" && node.status !== "disputed") return null;
+  const eventById = new Map(events.map((event) => [event.id, event]));
+  const sources2 = (ids, statuses) => unique((ids ?? []).filter((id) => {
+    const event = eventById.get(id);
+    return event !== void 0 && statuses.has(event.status);
+  }));
+  const activeStatuses = /* @__PURE__ */ new Set(["active"]);
+  const visibleStatuses = /* @__PURE__ */ new Set(["active", "superseded"]);
+  const splitRecord = (record2) => {
+    if (record2.status === "archived") return {};
+    const activeSources = sources2(record2.sourceEventIds, activeStatuses);
+    const visibleSources = sources2(record2.sourceEventIds, visibleStatuses);
+    if ((record2.status === "active" || record2.status === "disputed") && activeSources.length > 0) {
+      return { current: { ...record2, sourceEventIds: activeSources } };
+    }
+    if (visibleSources.length > 0 && record2.status === "superseded") {
+      return { historical: { ...record2, sourceEventIds: visibleSources } };
+    }
+    return {};
+  };
+  const currentFacts = [];
+  const historicalFacts = [];
+  for (const fact of node.facts ?? []) {
+    const split = splitRecord(fact);
+    if (split.current) currentFacts.push(split.current);
+    if (split.historical) historicalFacts.push(split.historical);
+  }
+  const currentEdges = [];
+  const historicalEdges = [];
+  for (const edge of edges.filter(({ fromNodeId, toNodeId }) => fromNodeId === node.id || toNodeId === node.id)) {
+    const split = splitRecord(edge);
+    if (split.current) currentEdges.push(split.current);
+    if (split.historical) historicalEdges.push(split.historical);
+  }
+  const currentNodeEventIds = sources2(node.sourceEventIds, activeStatuses);
+  const historicalNodeEventIds = sources2(node.sourceEventIds, /* @__PURE__ */ new Set(["superseded"]));
+  if (currentFacts.length === 0 && historicalFacts.length === 0 && currentEdges.length === 0 && historicalEdges.length === 0 && currentNodeEventIds.length === 0 && historicalNodeEventIds.length === 0) return null;
+  const visibleNodeSources = unique([...currentNodeEventIds, ...historicalNodeEventIds]);
+  const metadata = effectiveMetadata(node, eventById);
+  const effectiveNode = { ...node, ...metadata };
+  if (!Object.prototype.hasOwnProperty.call(metadata, "tags")) delete effectiveNode.tags;
+  return {
+    node: { ...effectiveNode, currentState: renderCurrentState(currentFacts), facts: currentFacts, sourceEventIds: visibleNodeSources },
+    currentFacts,
+    historicalFacts,
+    currentEdges,
+    historicalEdges,
+    currentNodeEventIds,
+    historicalNodeEventIds
+  };
+}
+function boundEffectiveGraphNodeView(view, eventIds, options = {}) {
+  const boundRecord = (record2) => {
+    const sourceEventIds = record2.sourceEventIds.filter((id) => eventIds.has(id));
+    return sourceEventIds.length > 0 ? { ...record2, sourceEventIds } : null;
+  };
+  const currentFacts = view.currentFacts.flatMap((record2) => boundRecord(record2) ?? []);
+  const historicalFacts = view.historicalFacts.flatMap((record2) => boundRecord(record2) ?? []);
+  const currentEdges = view.currentEdges.flatMap((record2) => boundRecord(record2) ?? []);
+  const historicalEdges = view.historicalEdges.flatMap((record2) => boundRecord(record2) ?? []);
+  const metadata = view.node.metadataProvenance ? (() => {
+    const name2 = (view.node.metadataProvenance?.name ?? []).filter((id) => eventIds.has(id));
+    const aliases = (view.node.metadataProvenance?.aliases ?? []).flatMap((entry) => {
+      const sourceEventIds = entry.sourceEventIds.filter((id) => eventIds.has(id));
+      return sourceEventIds.length > 0 ? [{ ...entry, sourceEventIds }] : [];
+    });
+    const tags = (view.node.metadataProvenance?.tags ?? []).flatMap((entry) => {
+      const sourceEventIds = entry.sourceEventIds.filter((id) => eventIds.has(id));
+      return sourceEventIds.length > 0 ? [{ ...entry, sourceEventIds }] : [];
+    });
+    return {
+      name: name2.length > 0 ? view.node.name : "",
+      aliases: aliases.map(({ value }) => value),
+      ...tags.length > 0 ? { tags: tags.map(({ value }) => value) } : {},
+      metadataProvenance: {
+        ...name2.length > 0 ? { name: name2 } : {},
+        ...aliases.length > 0 ? { aliases } : {},
+        ...tags.length > 0 ? { tags } : {}
+      }
+    };
+  })() : view.node.sourceEventIds.length > 0 && view.node.sourceEventIds.every((id) => eventIds.has(id)) || options.preserveLegacyMetadata ? { name: view.node.name, aliases: [...view.node.aliases], ...view.node.tags ? { tags: [...view.node.tags] } : {} } : { name: "", aliases: [] };
+  const currentNodeEventIds = view.currentNodeEventIds.filter((id) => eventIds.has(id));
+  const historicalNodeEventIds = view.historicalNodeEventIds.filter((id) => eventIds.has(id));
+  const boundedNode = { ...view.node, ...metadata };
+  if (!Object.prototype.hasOwnProperty.call(metadata, "tags")) delete boundedNode.tags;
+  return {
+    node: { ...boundedNode, currentState: renderCurrentState(currentFacts), facts: currentFacts, sourceEventIds: unique([...currentNodeEventIds, ...historicalNodeEventIds]) },
+    currentFacts,
+    historicalFacts,
+    currentEdges,
+    historicalEdges,
+    currentNodeEventIds,
+    historicalNodeEventIds
+  };
+}
+function graphTimeline(eventIds, events, limit = GRAPH_PROVENANCE_LIMIT) {
+  const order = new Map(eventIds.map((id, index) => [id, index]));
+  return events.filter((event) => order.has(event.id) && event.status !== "forgotten" && event.status !== "archived").sort((left, right) => (order.get(left.id) ?? 0) - (order.get(right.id) ?? 0)).slice(0, Math.max(0, limit)).map((event) => ({
+    id: event.id,
+    title: event.title,
+    summary: event.summary,
+    status: event.status,
+    ...event.temporal.happenedStart ? { time: event.temporal.happenedStart } : {}
+  }));
+}
 function text(value, limit = 240) {
   return typeof value === "string" ? value.trim().replace(/\s+/g, " ").slice(0, limit) : "";
 }
@@ -397,20 +546,48 @@ function confidence(value) {
 function chronology(events, ids, fallback) {
   return ids.flatMap((id) => events.find((event) => event.id === id) ?? []).map((event) => event.temporal.happenedStart ?? event.temporal.happenedEnd ?? event.temporal.mentionedAt ?? event.createdAt).sort().at(-1) ?? fallback;
 }
-function sameEntity(node, proposal) {
-  if (node.type !== proposal.type) return false;
+function entityMatchKind(node, proposal, eventById) {
+  if (node.type !== proposal.type) return null;
   const key = (value) => normalizeSearchText(value).replace(/[\s_-]+/g, "");
-  const names = new Set([proposal.name, ...proposal.aliases ?? []].map(key));
-  return [node.name, ...node.aliases].some((name2) => names.has(key(name2)));
+  const metadata = effectiveMetadata(node, eventById);
+  const proposalNames = new Set([proposal.name, ...proposal.aliases ?? []].map(key));
+  if (proposalNames.has(key(metadata.name))) return "canonical-name";
+  if (metadata.aliases.some((value) => proposalNames.has(key(value)))) return "alias";
+  return null;
 }
 function applyGraphProjection(options) {
   const refs = /* @__PURE__ */ new Map();
   const touchedNodes = /* @__PURE__ */ new Set();
   const touchedEdges = /* @__PURE__ */ new Set();
+  const warnings = [];
+  const eventById = new Map(options.events.map((event) => [event.id, event]));
   const validSources = (value) => {
     const requested = strings(value, 64);
-    return requested.length > 0 && requested.every((id) => options.allowedEventIds.has(id)) ? requested : [];
+    return requested.length > 0 && requested.every((id) => options.allowedEventIds.has(id) && EXPOSED_EVENT_STATUSES.has(eventById.get(id)?.status ?? "forgotten")) ? requested : [];
+  };
+  const activeSources = (ids) => ids.filter((id) => eventById.get(id)?.status === "active");
+  const metadataEntriesFromProjection = (entries, fallbackValues) => {
+    const byValue = new Map((entries ?? []).map((entry) => [normalizeSearchText(entry.value), entry]));
+    return fallbackValues.flatMap((value) => {
+      const entry = byValue.get(normalizeSearchText(value));
+      const sourceEventIds = validSources(entry?.sourceEventIds);
+      if (sourceEventIds.length > 0) return [{ value, sourceEventIds }];
+      warnings.push(`Dropped metadata value "${value}" because it lacks matching valid field provenance.`);
+      return [];
+    });
   };
+  for (const proposal of Array.isArray(options.result.nodes) ? options.result.nodes : []) {
+    const ref = text(proposal.ref, 120);
+    const name2 = text(proposal.name, 160);
+    const sources2 = validSources(proposal.sourceEventIds);
+    if (!ref || !name2 || !NODE_TYPES.has(proposal.type)) continue;
+    if (sources2.length === 0) {
+      throw new Error(`Graph projection validation failed: node "${ref}" has no valid exposable source Event.`);
+    }
+    if (validSources(proposal.metadataProvenance?.name).length === 0) {
+      throw new Error(`Graph projection validation failed: node "${ref}" name "${name2}" lacks valid metadata provenance.`);
+    }
+  }
   for (const proposal of Array.isArray(options.result.nodes) ? options.result.nodes : []) {
     const ref = text(proposal.ref, 120);
     const name2 = text(proposal.name, 160);
@@ -418,7 +595,15 @@ function applyGraphProjection(options) {
     if (!ref || !name2 || !NODE_TYPES.has(proposal.type) || sources2.length === 0) continue;
     const aliases = strings(proposal.aliases, 20).filter((alias) => normalizeSearchText(alias) !== normalizeSearchText(name2));
     const tags = strings(proposal.tags, 12);
-    let node = options.nodes.find((candidate) => sameEntity(candidate, { ...proposal, name: name2, aliases }));
+    const projectedNameSources = validSources(proposal.metadataProvenance?.name);
+    if (projectedNameSources.length === 0) continue;
+    const projectedMetadata = {
+      name: projectedNameSources,
+      aliases: metadataEntriesFromProjection(proposal.metadataProvenance?.aliases, aliases),
+      tags: metadataEntriesFromProjection(proposal.metadataProvenance?.tags, tags)
+    };
+    const provenAliases = projectedMetadata.aliases.map(({ value }) => value);
+    let node = options.nodes.find((candidate) => entityMatchKind(candidate, { name: name2, aliases: provenAliases, type: proposal.type }, eventById));
     if (!node) {
       node = {
         id: options.idFactory("node"),
@@ -435,8 +620,37 @@ function applyGraphProjection(options) {
       };
       options.nodes.push(node);
     }
-    node.aliases = [.../* @__PURE__ */ new Set([...node.aliases, ...aliases])];
-    if (tags.length > 0) node.tags = [.../* @__PURE__ */ new Set([...node.tags ?? [], ...tags])].slice(0, 12);
+    const canonicalKey = normalizeSearchText(node.name);
+    const canonicalNameSources = [
+      ...normalizeSearchText(name2) === canonicalKey ? projectedMetadata.name : [],
+      ...projectedMetadata.aliases.filter(({ value }) => normalizeSearchText(value) === canonicalKey).flatMap(({ sourceEventIds }) => sourceEventIds),
+      ...node.metadataProvenance?.name ?? []
+    ];
+    const projectedAliasEntries = [
+      ...projectedMetadata.aliases.filter(({ value }) => normalizeSearchText(value) !== canonicalKey),
+      ...normalizeSearchText(name2) !== canonicalKey ? [{ value: name2, sourceEventIds: projectedMetadata.name }] : [],
+      ...aliases.filter((alias) => normalizeSearchText(alias) !== canonicalKey && !projectedMetadata.aliases.some((entry) => normalizeSearchText(entry.value) === normalizeSearchText(alias))).map((value) => ({ value, sourceEventIds: projectedMetadata.aliases.find((entry) => normalizeSearchText(entry.value) === normalizeSearchText(value))?.sourceEventIds ?? [] })).filter(({ sourceEventIds }) => sourceEventIds.length > 0)
+    ];
+    node.aliases = [.../* @__PURE__ */ new Set([...node.aliases, ...projectedAliasEntries.map(({ value }) => value)])];
+    if (tags.length > 0) node.tags = [.../* @__PURE__ */ new Set([...node.tags ?? [], ...projectedMetadata.tags.map(({ value }) => value)])].slice(0, 12);
+    const previousMetadata = node.metadataProvenance;
+    const aliasEntries = [...previousMetadata?.aliases ?? []];
+    for (const entry of projectedAliasEntries) {
+      const existing = aliasEntries.find((candidate) => normalizeSearchText(candidate.value) === normalizeSearchText(entry.value));
+      if (existing) existing.sourceEventIds = [.../* @__PURE__ */ new Set([...existing.sourceEventIds, ...entry.sourceEventIds])];
+      else aliasEntries.push(entry);
+    }
+    const tagEntries = [...previousMetadata?.tags ?? []];
+    for (const entry of projectedMetadata.tags) {
+      const existing = tagEntries.find((candidate) => normalizeSearchText(candidate.value) === normalizeSearchText(entry.value));
+      if (existing) existing.sourceEventIds = [.../* @__PURE__ */ new Set([...existing.sourceEventIds, ...entry.sourceEventIds])];
+      else tagEntries.push(entry);
+    }
+    node.metadataProvenance = {
+      ...canonicalNameSources.length > 0 ? { name: [...new Set(canonicalNameSources)] } : previousMetadata?.name ? { name: [...previousMetadata.name] } : {},
+      ...aliasEntries.length > 0 ? { aliases: aliasEntries } : {},
+      ...tagEntries.length > 0 ? { tags: tagEntries } : {}
+    };
     node.status = STATUSES.has(proposal.status ?? "active") ? proposal.status ?? "active" : "active";
     node.confidence = confidence(proposal.confidence);
     node.sourceEventIds = [.../* @__PURE__ */ new Set([...node.sourceEventIds, ...sources2])];
@@ -451,7 +665,14 @@ function applyGraphProjection(options) {
       const value = Array.isArray(rawFact.value) ? strings(rawFact.value, 40) : text(rawFact.value, 1200);
       if (!key || (Array.isArray(value) ? value.length === 0 : !value)) continue;
       const factSources = "sourceEventIds" in rawFact ? validSources(rawFact.sourceEventIds) : sources2;
-      if (factSources.length === 0) continue;
+      if (factSources.length === 0) {
+        warnings.push(`Dropped fact "${key}" because it lacks valid exposable Event provenance.`);
+        continue;
+      }
+      if ((node.status === "active" || node.status === "disputed") && activeSources(factSources).length === 0) {
+        warnings.push(`Dropped current fact "${key}" because it has no active Event provenance.`);
+        continue;
+      }
       for (const old of node.facts.filter((fact2) => fact2.status === "active" && fact2.key === key)) {
         old.status = "superseded";
         if (!old.validTo) old.validTo = validFrom;
@@ -485,6 +706,10 @@ function applyGraphProjection(options) {
     const status = STATUSES.has(proposal.status ?? "active") ? proposal.status ?? "active" : "active";
     const validFrom = text(proposal.validFrom, 80) || chronology(options.events, sources2, options.now);
     const validTo = text(proposal.validTo, 80) || void 0;
+    if ((status === "active" || status === "disputed") && activeSources(sources2).length === 0) {
+      warnings.push(`Dropped current edge "${relation}" because it has no active Event provenance.`);
+      continue;
+    }
     for (const old of options.edges.filter((edge2) => edge2.status === "active" && edge2.fromNodeId === from.id && edge2.relation === relation && edge2.toNodeId !== to.id)) {
       old.status = "superseded";
       if (!old.validTo) old.validTo = validFrom;
@@ -517,7 +742,7 @@ function applyGraphProjection(options) {
     const participantNodeIds = options.nodes.filter((node) => node.sourceEventIds.includes(event.id)).map(({ id }) => id);
     event.temporal.participantNodeIds = [.../* @__PURE__ */ new Set([...event.temporal.participantNodeIds ?? [], ...participantNodeIds])];
   }
-  return { nodeIds: [...touchedNodes], edgeIds: [...touchedEdges] };
+  return { nodeIds: [...touchedNodes], edgeIds: [...touchedEdges], warnings: unique(warnings) };
 }
 
 // packages/core/src/events.ts
@@ -3930,15 +4155,21 @@ var StrataGate = class _StrataGate {
         event.tags.join(" "),
         (event.temporal.participants ?? []).join(" ")
       ].join(" ")).join(" "));
-      const relevantNodes = this.graphNodes.filter((node) => [node.name, ...node.aliases].some((name2) => eventText.includes(normalizeSearchText(name2)))).concat([...this.graphNodes].sort((left, right) => right.updatedAt.localeCompare(left.updatedAt)).slice(0, 24));
+      const effectiveViews = this.graphNodes.flatMap((node) => effectiveGraphNodeView(node, this.graphEdges, this.events) ?? []);
+      const effectiveNodes = effectiveViews.map(({ node }) => node);
+      const relevantNodes = effectiveNodes.filter((node) => [node.name, ...node.aliases].some((name2) => name2 && eventText.includes(normalizeSearchText(name2)))).concat([...effectiveNodes].sort((left, right) => right.updatedAt.localeCompare(left.updatedAt)).slice(0, 24));
       const existingNodes = [...new Map(relevantNodes.map((node) => [node.id, node])).values()].slice(0, 32);
       const nodeIds = new Set(existingNodes.map(({ id }) => id));
+      const visibleEdgeIds = new Set(effectiveViews.flatMap(({ currentEdges, historicalEdges }) => [
+        ...currentEdges,
+        ...historicalEdges
+      ]).map(({ id }) => id));
       return {
         jobId: job.id,
         projectorVersion: job.projectorVersion,
         events: structuredClone(events),
         existingNodes: structuredClone(existingNodes),
-        existingEdges: structuredClone(this.graphEdges.filter(({ fromNodeId, toNodeId }) => nodeIds.has(fromNodeId) && nodeIds.has(toNodeId)).slice(-60))
+        existingEdges: structuredClone(this.graphEdges.filter(({ id, fromNodeId, toNodeId }) => visibleEdgeIds.has(id) && nodeIds.has(fromNodeId) && nodeIds.has(toNodeId)).slice(-60))
       };
     });
   }
@@ -3962,11 +4193,13 @@ var StrataGate = class _StrataGate {
       job.status = "completed";
       job.nodeIds = touched.nodeIds;
       job.edgeIds = touched.edgeIds;
-      job.reason = typeof result.reason === "string" ? result.reason.trim().replace(/\s+/g, " ").slice(0, 500) || null : null;
+      const normalizedReason = typeof result.reason === "string" ? result.reason.trim().replace(/\s+/g, " ") : "";
+      const warning = touched.warnings.length > 0 ? `Validation: ${touched.warnings.join(" ")}` : "";
+      job.reason = [warning, normalizedReason].filter(Boolean).join(" ").slice(0, 500) || null;
       job.lastError = null;
       job.nextRetryAt = null;
       job.updatedAt = toUtc8Iso(this.now());
-      return touched;
+      return { nodeIds: touched.nodeIds, edgeIds: touched.edgeIds };
     });
   }
   async failGraphProjection(jobId, error) {
@@ -4313,45 +4546,179 @@ var StrataGate = class _StrataGate {
     return job;
   }
   async searchGraphNodes(query, limit = 8) {
-    const candidates = this.graphNodes.filter((node) => node.status === "active" || node.status === "disputed");
     const queryTokens = [...new Set(searchTokens(query))];
-    const fieldValues = (node) => [
-      ["name", node.name],
-      ["aliases", node.aliases.join(" ")],
-      ["tags", (node.tags ?? []).join(" ")],
-      ["type", node.type],
-      ["currentState", node.currentState],
-      ["facts", node.facts.map((fact) => `${fact.key} ${Array.isArray(fact.value) ? fact.value.join(" ") : fact.value}`).join(" ")],
-      ["relations", this.graphEdges.filter((edge) => edge.fromNodeId === node.id || edge.toNodeId === node.id).map(({ relation }) => relation).join(" ")]
-    ];
-    const ranked = bm25Rank(candidates, query, (node) => weightedSearchTokens([
-      [node.name, 6],
-      [node.aliases.join(" "), 5],
-      [(node.tags ?? []).join(" "), 5],
-      [node.type, 2],
-      [node.currentState, 4],
-      [node.facts.map((fact) => `${fact.key} ${Array.isArray(fact.value) ? fact.value.join(" ") : fact.value}`).join(" "), 4],
-      [this.graphEdges.filter((edge) => edge.fromNodeId === node.id || edge.toNodeId === node.id).map(({ relation }) => relation).join(" "), 3]
-    ])).filter(({ item }) => {
-      const fields = fieldValues(item);
-      const matches = fields.filter(([, value]) => {
-        const haystack = new Set(searchTokens(value));
-        return queryTokens.some((token) => haystack.has(token));
-      }).map(([field]) => field);
-      if (!matches.some((field) => field !== "relations")) return false;
-      return matches.some((field) => field !== "relations");
+    if (queryTokens.length === 0) return [];
+    const views = this.graphNodes.flatMap((node) => effectiveGraphNodeView(node, this.graphEdges, this.events) ?? []);
+    const viewById = new Map(views.map((view) => [view.node.id, view]));
+    const dedupe = (values) => [...new Set(values)];
+    const factValue = (fact) => Array.isArray(fact.value) ? fact.value.join(" ") : fact.value;
+    const endpoint = (nodeId, edge) => {
+      const otherId = edge.fromNodeId === nodeId ? edge.toNodeId : edge.fromNodeId;
+      const other = viewById.get(otherId)?.node;
+      return other ? `${other.name} ${other.aliases.join(" ")}` : "";
+    };
+    const tokenSet = (value) => new Set(searchTokens(value));
+    const hasAny = (value, tokens) => {
+      const available = tokenSet(value);
+      return tokens.some((token) => available.has(token));
+    };
+    const matchDetails = (node) => {
+      const view = viewById.get(node.id);
+      const queryParts = normalizeSearchText(query).split(/[^\p{Letter}\p{Number}_]+/gu).filter(Boolean);
+      const explicitFactKeys = dedupe([...view.currentFacts, ...view.historicalFacts].map(({ key }) => key)).filter((key) => queryParts.includes(normalizeSearchText(key)));
+      const knownFactKeyTokens = new Set(explicitFactKeys.flatMap((key) => [...tokenSet(key)]));
+      const queryKeyTokens = queryTokens.filter((token) => knownFactKeyTokens.has(token));
+      const valueQueryTokens = queryTokens.filter((token) => !queryKeyTokens.includes(token));
+      const meaningfulTokens = queryTokens;
+      const factMatchesFor = (facts) => {
+        if (queryKeyTokens.length === 0) return facts.filter((fact) => hasAny(`${fact.key} ${factValue(fact)}`, meaningfulTokens));
+        const keyFacts = facts.filter((fact) => queryKeyTokens.some((token) => tokenSet(fact.key).has(token)));
+        const directMatches = keyFacts.filter((fact) => valueQueryTokens.length === 0 || valueQueryTokens.some((token) => tokenSet(factValue(fact)).has(token)));
+        return directMatches;
+      };
+      let currentFacts = factMatchesFor(view.currentFacts);
+      let historicalFacts = factMatchesFor(view.historicalFacts);
+      const edgeMatches = (edge, supportingFacts) => {
+        if (queryKeyTokens.length === 0) return hasAny(endpoint(node.id, edge), meaningfulTokens);
+        return supportingFacts.length > 0 && hasAny(endpoint(node.id, edge), valueQueryTokens.length > 0 ? valueQueryTokens : queryTokens);
+      };
+      let currentEdges = view.currentEdges.filter((edge) => edgeMatches(edge, currentFacts));
+      let historicalEdges = view.historicalEdges.filter((edge) => edgeMatches(edge, historicalFacts));
+      if (queryKeyTokens.length === 0) {
+        const overlap = (value) => {
+          const available = tokenSet(value);
+          return meaningfulTokens.filter((token) => available.has(token)).length;
+        };
+        const scoredFacts = [...currentFacts, ...historicalFacts].map((fact) => [fact.id, overlap(`${fact.key} ${factValue(fact)}`)]);
+        const scoredEdges = [...currentEdges, ...historicalEdges].map((edge) => [edge.id, overlap(endpoint(node.id, edge))]);
+        const best = Math.max(0, ...scoredFacts.map(([, score]) => score), ...scoredEdges.map(([, score]) => score));
+        const bestFacts = new Set(scoredFacts.filter(([, score]) => score === best).map(([id]) => id));
+        const bestEdges = new Set(scoredEdges.filter(([, score]) => score === best).map(([id]) => id));
+        currentFacts = currentFacts.filter(({ id }) => bestFacts.has(id));
+        historicalFacts = historicalFacts.filter(({ id }) => bestFacts.has(id));
+        currentEdges = currentEdges.filter(({ id }) => bestEdges.has(id));
+        historicalEdges = historicalEdges.filter(({ id }) => bestEdges.has(id));
+      }
+      const metadataFields = [
+        ["name", node.name],
+        ["aliases", node.aliases.join(" ")],
+        ["tags", (node.tags ?? []).join(" ")],
+        ["type", node.type]
+      ];
+      const metadataMatches = metadataFields.filter(([, value]) => hasAny(value, queryTokens)).map(([field]) => field);
+      const matchedMetadataEventIds = node.metadataProvenance ? dedupe([
+        ...metadataMatches.includes("name") ? node.metadataProvenance.name ?? [] : [],
+        ...(node.metadataProvenance.aliases ?? []).filter(({ value }) => hasAny(value, queryTokens)).flatMap(({ sourceEventIds }) => sourceEventIds),
+        ...(node.metadataProvenance.tags ?? []).filter(({ value }) => hasAny(value, queryTokens)).flatMap(({ sourceEventIds }) => sourceEventIds),
+        ...metadataMatches.includes("type") ? [...view.currentNodeEventIds, ...view.historicalNodeEventIds] : []
+      ]) : metadataMatches.length > 0 ? dedupe([...view.currentNodeEventIds, ...view.historicalNodeEventIds]) : [];
+      const eventStatus = new Map(this.events.map((event) => [event.id, event.status]));
+      const metadataCurrentHit = matchedMetadataEventIds.some((id) => eventStatus.get(id) === "active");
+      const metadataHistoricalHit = matchedMetadataEventIds.some((id) => eventStatus.get(id) === "superseded");
+      const currentRecordHit = currentFacts.length > 0 || currentEdges.length > 0;
+      const historicalRecordHit = historicalFacts.length > 0 || historicalEdges.length > 0;
+      const hasRecordHit = currentRecordHit || historicalRecordHit;
+      const currentHit = currentRecordHit || !hasRecordHit && metadataMatches.length > 0 && metadataCurrentHit;
+      const historicalHit = historicalRecordHit || !hasRecordHit && metadataMatches.length > 0 && metadataHistoricalHit;
+      const relationMatches = [...view.currentEdges, ...view.historicalEdges].some((edge) => hasAny(edge.relation, queryTokens));
+      const matchedFields = [
+        ...metadataMatches,
+        ...currentFacts.length > 0 ? ["currentFacts"] : [],
+        ...historicalFacts.length > 0 ? ["historicalFacts"] : [],
+        ...currentEdges.length > 0 ? ["currentEdgeEndpoints"] : [],
+        ...historicalEdges.length > 0 ? ["historicalEdgeEndpoints"] : [],
+        ...relationMatches ? ["relations"] : []
+      ];
+      return {
+        view,
+        currentFacts,
+        historicalFacts,
+        currentEdges,
+        historicalEdges,
+        metadataMatches,
+        matchedMetadataEventIds,
+        currentHit,
+        historicalHit,
+        matchedFields
+      };
+    };
+    const candidates = views.map(({ node }) => node);
+    const ranked = bm25Rank(candidates, query, (node) => {
+      const view = viewById.get(node.id);
+      return weightedSearchTokens([
+        [node.name, 6],
+        [node.aliases.join(" "), 5],
+        [(node.tags ?? []).join(" "), 5],
+        [node.type, 2],
+        [view.currentFacts.map((fact) => `${fact.key} ${factValue(fact)}`).join(" "), 4],
+        [view.historicalFacts.map((fact) => `${fact.key} ${factValue(fact)}`).join(" "), 2],
+        [view.currentEdges.map((edge) => endpoint(node.id, edge)).join(" "), 4],
+        [view.historicalEdges.map((edge) => endpoint(node.id, edge)).join(" "), 2],
+        [[...view.currentEdges, ...view.historicalEdges].map(({ relation }) => relation).join(" "), 1]
+      ]);
+    }).filter(({ item }) => {
+      const details = matchDetails(item);
+      return details.currentHit || details.historicalHit;
     }).slice(0, Math.max(1, Math.min(20, limit)));
-    if (searchTokens(query).length > 0 && ranked.length === 0) return [];
     return ranked.map(({ item: node, score }) => {
-      const matchedFields = fieldValues(node).filter(([, value]) => {
-        const haystack = new Set(searchTokens(value));
-        return queryTokens.some((token) => haystack.has(token));
-      }).map(([field]) => field);
+      const details = matchDetails(node);
+      const matchedEventIds = dedupe([
+        ...details.currentFacts.flatMap(({ sourceEventIds }) => sourceEventIds),
+        ...details.historicalFacts.flatMap(({ sourceEventIds }) => sourceEventIds),
+        ...details.currentEdges.flatMap(({ sourceEventIds }) => sourceEventIds),
+        ...details.historicalEdges.flatMap(({ sourceEventIds }) => sourceEventIds)
+      ]);
+      const historicalKeys = new Set(details.historicalFacts.map(({ key }) => key));
+      const historicalRelations = new Set(details.historicalEdges.map(({ relation }) => relation));
+      const currentContextEventIds = dedupe([
+        ...details.view.currentFacts.filter(({ key }) => historicalKeys.has(key)).flatMap(({ sourceEventIds }) => sourceEventIds),
+        ...details.view.currentEdges.filter(({ relation }) => historicalRelations.has(relation)).flatMap(({ sourceEventIds }) => sourceEventIds)
+      ]);
+      const currentContextFacts = details.view.currentFacts.filter(({ key }) => historicalKeys.has(key));
+      const currentContextEdges = details.view.currentEdges.filter(({ relation }) => historicalRelations.has(relation));
+      const nameEventIds = node.metadataProvenance?.name ?? [];
+      const metadataCandidates = dedupe([...details.matchedMetadataEventIds, ...nameEventIds]);
+      const metadataOnly = matchedEventIds.length === 0 && details.metadataMatches.length > 0;
+      const hasVisibleLegacyMetadata = !node.metadataProvenance && Boolean(node.name || node.aliases.length > 0 || (node.tags?.length ?? 0) > 0);
+      const legacyMetadataEventIds = hasVisibleLegacyMetadata ? dedupe([...details.view.currentNodeEventIds, ...details.view.historicalNodeEventIds]) : [];
+      const recordPriority = dedupe([
+        ...matchedEventIds,
+        ...currentContextEventIds
+      ]);
+      const legacyMetadataFits = node.metadataProvenance !== void 0 || !hasVisibleLegacyMetadata || dedupe([...recordPriority, ...legacyMetadataEventIds]).length <= GRAPH_PROVENANCE_LIMIT;
+      const legacyMetadataNotExpanded = hasVisibleLegacyMetadata && !legacyMetadataFits;
+      const prioritized = node.metadataProvenance ? dedupe([
+        ...matchedEventIds,
+        ...metadataOnly ? metadataCandidates : [],
+        ...currentContextEventIds,
+        ...!metadataOnly ? metadataCandidates : []
+      ]) : recordPriority;
+      const provenanceEventIds = dedupe([
+        ...prioritized,
+        ...legacyMetadataFits ? legacyMetadataEventIds : []
+      ]).slice(0, GRAPH_PROVENANCE_LIMIT);
+      const evidenceIds = new Set(provenanceEventIds);
+      const boundedView = boundEffectiveGraphNodeView(details.view, evidenceIds, {
+        preserveLegacyMetadata: legacyMetadataNotExpanded
+      });
+      const bounded = (record2) => {
+        const sourceEventIds = record2.sourceEventIds.filter((id) => evidenceIds.has(id));
+        return sourceEventIds.length > 0 ? { ...record2, sourceEventIds } : null;
+      };
+      const matchType = details.currentHit && details.historicalHit ? "both" : details.historicalHit ? "historical" : "current";
       return {
-        node,
+        node: boundedView.node,
         score,
-        matchedFields,
-        matchReason: `Lexical match in ${matchedFields.join(", ") || "indexed fields"}; score is ranking-only.`
+        matchedFields: details.matchedFields,
+        matchReason: `Meaningful ${matchType} match in ${details.matchedFields.join(", ")}; relation text is ranking-only.`,
+        matchType,
+        currentFacts: dedupe([...details.currentFacts, ...currentContextFacts]).flatMap((record2) => bounded(record2) ?? []),
+        historicalFacts: details.historicalFacts.flatMap((record2) => bounded(record2) ?? []),
+        currentEdges: dedupe([...details.currentEdges, ...currentContextEdges]).flatMap((record2) => bounded(record2) ?? []),
+        historicalEdges: details.historicalEdges.flatMap((record2) => bounded(record2) ?? []),
+        provenanceEventIds,
+        ...legacyMetadataNotExpanded ? { metadataEvidenceStatus: "not_expanded" } : {},
+        timeline: graphTimeline(provenanceEventIds, this.events)
       };
     });
   }
@@ -5148,6 +5515,20 @@ var GRAPH_FACT = {
   additionalProperties: false,
   properties: { key: { type: "string", required: true }, value: { ...VALUE, required: true }, sourceEventIds: { ...STRING_ARRAY, required: true } }
 };
+var GRAPH_METADATA_ENTRY = {
+  type: "object",
+  additionalProperties: false,
+  properties: { value: { type: "string", required: true }, sourceEventIds: { ...STRING_ARRAY, required: true } }
+};
+var GRAPH_METADATA_PROVENANCE = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    name: { ...STRING_ARRAY, required: true },
+    aliases: { type: "array", items: GRAPH_METADATA_ENTRY },
+    tags: { type: "array", items: GRAPH_METADATA_ENTRY }
+  }
+};
 var GRAPH_NODE = {
   type: "object",
   additionalProperties: false,
@@ -5157,6 +5538,7 @@ var GRAPH_NODE = {
     type: { type: "string", enum: ["person", "project", "organization", "tool", "place"], required: true },
     aliases: STRING_ARRAY,
     tags: { ...STRING_ARRAY, required: true },
+    metadataProvenance: { ...GRAPH_METADATA_PROVENANCE, required: true },
     state: { type: "string" },
     facts: { type: "array", items: GRAPH_FACT },
     status: { type: "string", enum: ["active", "superseded", "disputed", "archived"] },
@@ -5263,6 +5645,7 @@ function compactGraphProjectionContext(context) {
       type: node.type,
       aliases: node.aliases.slice(0, 12),
       tags: node.tags?.slice(0, 12),
+      metadataProvenance: node.metadataProvenance,
       currentState: node.currentState.slice(0, 600),
       facts: node.facts.filter(({ status }) => status === "active" || status === "disputed").slice(-12).map((fact) => ({
         key: fact.key,
@@ -5395,7 +5778,7 @@ var DshModelBridge = class {
     const eventIds = new Set(context.events.map((event) => event.id));
     const raw = object(await this.callStructured(
       "graphProjector",
-      `Project the supplied Events into the current Knowledge Graph, then call ${STRUCTURED_TOOLS.graphProjector.name} exactly once. Events are the sole source of truth; never use legacy Element data. Return only nodes and edges touched by the supplied Events; never echo unchanged historical graph records. Return at most 24 nodes and 32 edges. Use stable entity nodes for people, projects, organizations, tools, and places. Use aliases to merge spelling/case/separator variants. Give every returned node 1-6 concise semantic role tags such as benchmark, evaluation, memory-plugin, parser, or development-tool; tags describe the node's specific role and never replace its person/project/organization/tool/place type. Reuse stable tag wording when possible. Put attributes in node facts and every relationship in a directed edge using fromRef/toRef\u2014never encode a relationship as a fact string. Prefer concise canonical Chinese relation labels such as \u4F7F\u7528\u3001\u5C5E\u4E8E\u3001\u521B\u5EFA\u3001\u53C2\u4E0E\u3001\u8D21\u732E\u3001\u4F9D\u8D56\u3001\u4F4D\u4E8E\u3001\u76F8\u5173. Every node, fact, and edge must cite only supplied Event ids. Do not return text.`,
+      `Project the supplied Events into the current Knowledge Graph, then call ${STRUCTURED_TOOLS.graphProjector.name} exactly once. Events are the sole source of truth; never use legacy Element data. Return only nodes and edges touched by the supplied Events; never echo unchanged historical graph records. Return at most 24 nodes and 32 edges. Use stable entity nodes for people, projects, organizations, tools, and places. Use aliases to merge spelling/case/separator variants. Give every returned node 1-6 concise semantic role tags such as benchmark, evaluation, memory-plugin, parser, or development-tool; tags describe the node's specific role and never replace its person/project/organization/tool/place type. Reuse stable tag wording when possible. For every node name, alias, and tag, include metadataProvenance with the exact supplied Event ids that support that individual value; never use an unrelated active Event as a substitute. Put attributes in node facts and every relationship in a directed edge using fromRef/toRef\u2014never encode a relationship as a fact string. Prefer concise canonical Chinese relation labels such as \u4F7F\u7528\u3001\u5C5E\u4E8E\u3001\u521B\u5EFA\u3001\u53C2\u4E0E\u3001\u8D21\u732E\u3001\u4F9D\u8D56\u3001\u4F4D\u4E8E\u3001\u76F8\u5173. Every node, fact, edge, and metadata provenance id must cite only supplied Event ids. Do not return text.`,
       compactGraphProjectionContext(context)
     ));
     const nodes = (Array.isArray(raw.nodes) ? raw.nodes : []).flatMap((candidate) => {
@@ -5411,12 +5794,31 @@ var DshModelBridge = class {
         if (sourceEventIds2.length === 0) return [];
         return [{ key: text2(fact.key), value, sourceEventIds: sourceEventIds2 }];
       });
+      const rawMetadata = object(item.metadataProvenance);
+      const metadataEntries2 = (value) => (Array.isArray(value) ? value : []).flatMap((candidate2) => {
+        const entry = object(candidate2);
+        const value2 = text2(entry.value);
+        const sourceEventIds2 = strings2(entry.sourceEventIds).filter((id) => eventIds.has(id));
+        return value2 && sourceEventIds2.length > 0 ? [{ value: value2, sourceEventIds: sourceEventIds2 }] : [];
+      });
+      const metadataName = strings2(rawMetadata.name).filter((id) => eventIds.has(id));
+      if (metadataName.length === 0) {
+        throw new Error(`Graph projection validation failed: node "${text2(item.ref)}" name "${text2(item.name)}" lacks valid metadata provenance.`);
+      }
+      const metadataAliases = metadataEntries2(rawMetadata.aliases);
+      const metadataTags = metadataEntries2(rawMetadata.tags);
+      const metadataProvenance = {
+        ...metadataName.length > 0 ? { name: metadataName } : {},
+        ...metadataAliases.length > 0 ? { aliases: metadataAliases } : {},
+        ...metadataTags.length > 0 ? { tags: metadataTags } : {}
+      };
       return [{
         ref: text2(item.ref),
         name: text2(item.name),
         type,
         aliases: strings2(item.aliases),
         tags: strings2(item.tags).slice(0, 12),
+        ...Object.keys(metadataProvenance).length > 0 ? { metadataProvenance } : {},
         ...text2(item.state) ? { state: text2(item.state) } : {},
         facts,
         ...typeof item.status === "string" ? { status: item.status } : {},
@@ -5605,8 +6007,9 @@ ${JSON_RETRY_INSTRUCTION}`,
         }
       }
     }
+    const validationDetail = lastError?.message ? `: ${lastError.message}` : "";
     throw new ModelJsonResponseError(
-      `StrataGate model did not produce a valid ${STRUCTURED_TOOLS[kind].name} call after ${attemptsUsed} attempt${attemptsUsed === 1 ? "" : "s"}`,
+      `StrataGate model did not produce a valid ${STRUCTURED_TOOLS[kind].name} call after ${attemptsUsed} attempt${attemptsUsed === 1 ? "" : "s"}${validationDetail}`,
       { cause: lastError, response: lastResponse }
     );
   }
@@ -6618,31 +7021,36 @@ var StrataGateRuntime = class {
     const openTail = memory.listOpenTail(threadId);
     const activationQuery = [currentUserMessage(session), renderMessages(recentTurns(openTail, 2))].filter(Boolean).join("\n\n");
     const eventHits = activationQuery ? await memory.searchEvents(activationQuery, { limit: 20 }) : [];
-    let graphNodes = [];
+    let graphResults = [];
     if (activationQuery && typeof memory.searchGraphNodes === "function") {
-      graphNodes = (await memory.searchGraphNodes(activationQuery, 12)).map(({ node }) => node);
+      graphResults = await memory.searchGraphNodes(activationQuery, 12);
     } else if (activationQuery) {
       const legacy = activatedElements(memory, await memory.searchElements(activationQuery, { limit: 12 }));
-      graphNodes = legacy.map((item) => ({
-        id: item.elementId,
-        name: item.name,
-        type: item.type,
-        aliases: [],
-        currentState: "",
-        status: "active",
-        confidence: item.fact.confidence ?? 0.8,
-        sourceEventIds: item.fact.sourceEventIds,
-        facts: [{ ...item.fact, confidence: item.fact.confidence ?? 0.8, status: item.fact.status === "disputed" ? "disputed" : item.fact.status === "superseded" ? "superseded" : "active" }],
-        createdAt: item.fact.createdAt,
-        updatedAt: item.fact.updatedAt
+      graphResults = legacy.map((item) => ({
+        node: {
+          id: item.elementId,
+          name: item.name,
+          type: item.type,
+          aliases: [],
+          currentState: "",
+          status: "active",
+          confidence: item.fact.confidence ?? 0.8,
+          sourceEventIds: item.fact.sourceEventIds,
+          facts: [{ ...item.fact, confidence: item.fact.confidence ?? 0.8, status: item.fact.status === "disputed" ? "disputed" : item.fact.status === "superseded" ? "superseded" : "active" }],
+          createdAt: item.fact.createdAt,
+          updatedAt: item.fact.updatedAt
+        },
+        score: item.score,
+        matchType: item.fact.status === "superseded" ? "historical" : "current",
+        provenanceEventIds: item.fact.sourceEventIds
       }));
     }
     const events = activatedEvents(memory, eventHits);
     const currentBlockIds = new Set(memory.listBlocks().filter((block) => block.threadId === threadId).map(({ id }) => id));
     const currentEventIds = new Set(memory.listEvents().filter((event) => currentBlockIds.has(event.sourceBlockId)).map(({ id }) => id));
     const longTermEvents = events.filter((event) => !currentEventIds.has(event.id)).slice(0, AUTO_EVENT_LIMIT);
-    graphNodes = graphNodes.filter((node) => !node.sourceEventIds.some((id) => currentEventIds.has(id))).slice(0, AUTO_ELEMENT_LIMIT);
-    return renderActivatedMemory(longTermEvents, graphNodes);
+    graphResults = graphResults.filter((result) => !(result.provenanceEventIds ?? result.node.sourceEventIds).some((id) => currentEventIds.has(id))).slice(0, AUTO_ELEMENT_LIMIT);
+    return renderActivatedMemory(longTermEvents, graphResults);
   }
   /**
    * Replace the just-sealed DSH turns with one native surface message. The raw
@@ -7428,29 +7836,56 @@ var StrataGateRuntime = class {
   async searchGraph(session, query, limit = 8) {
     await this.flush();
     const results = await (await this.space(session)).searchGraphNodes(query, limit);
-    return this.batch(session, results.map(({ node }) => ({
+    return this.batch(session, results.map(({ node, provenanceEventIds }) => ({
       ref: `graph-node:${node.id}`,
       target: {
-        eventIds: node.sourceEventIds,
+        eventIds: (provenanceEventIds ?? []).slice(0, GRAPH_PROVENANCE_LIMIT),
         elementIds: [],
         citation: citation("graph", node.id, node.name, `graph-node:${node.id}`, "nodeId")
       }
-    })), results.map(({ node, score, matchedFields, matchReason }) => compactGraphNode(node, score, matchedFields, matchReason)));
+    })), results.map(compactGraphNode));
   }
   async expandGraphNode(session, id) {
     await this.flush();
     const memory = await this.space(session);
     const node = memory.listGraphNodes().find((candidate) => candidate.id === id);
     if (!node) throw new Error(`Unknown graph node: ${id}`);
-    const edges = memory.listGraphEdges().filter(({ fromNodeId, toNodeId }) => fromNodeId === id || toNodeId === id);
+    const view = effectiveGraphNodeView(node, memory.listGraphEdges(), memory.listEvents());
+    if (!view) throw new Error(`Graph node ${id} has no retrievable Event evidence`);
+    const provenanceEventIds = [.../* @__PURE__ */ new Set([
+      ...view.currentFacts.flatMap(({ sourceEventIds }) => sourceEventIds),
+      ...view.currentEdges.flatMap(({ sourceEventIds }) => sourceEventIds),
+      ...view.historicalFacts.flatMap(({ sourceEventIds }) => sourceEventIds),
+      ...view.historicalEdges.flatMap(({ sourceEventIds }) => sourceEventIds),
+      ...view.currentNodeEventIds,
+      ...view.historicalNodeEventIds
+    ])].slice(0, GRAPH_PROVENANCE_LIMIT);
+    const legacyMetadataOverflow = !view.node.metadataProvenance && view.node.sourceEventIds.length > GRAPH_PROVENANCE_LIMIT;
+    const boundedView = boundEffectiveGraphNodeView(view, new Set(provenanceEventIds), {
+      preserveLegacyMetadata: legacyMetadataOverflow
+    });
+    const currentFacts = boundedView.currentFacts;
+    const historicalFacts = boundedView.historicalFacts;
+    const currentEdges = boundedView.currentEdges;
+    const historicalEdges = boundedView.historicalEdges;
     return this.batch(session, [{
       ref: `graph-node:${node.id}:expanded`,
       target: {
-        eventIds: [.../* @__PURE__ */ new Set([...node.sourceEventIds, ...edges.flatMap(({ sourceEventIds }) => sourceEventIds)])],
+        eventIds: provenanceEventIds,
         elementIds: [],
-        citation: citation("graph", node.id, node.name, `graph-node:${node.id}:expanded`, "nodeId", { expanded: true })
+        citation: citation("graph", node.id, boundedView.node.name, `graph-node:${node.id}:expanded`, "nodeId", { expanded: true })
       }
-    }], { node, edges });
+    }], {
+      node: boundedView.node,
+      edges: [...currentEdges, ...historicalEdges],
+      currentFacts,
+      historicalFacts,
+      currentEdges,
+      historicalEdges,
+      provenanceEventIds,
+      ...legacyMetadataOverflow ? { metadataEvidenceStatus: "not_expanded" } : {},
+      timeline: graphTimeline(provenanceEventIds, memory.listEvents())
+    });
   }
   scheduleBlockDerivation(session, memory) {
     const threadId = String(session.id);
@@ -7762,18 +8197,27 @@ function compactEvent(event, score) {
     scoreMeaning: "Ranking-only BM25/RRF score; not confidence, probability, or factual accuracy."
   };
 }
-function compactGraphNode(node, score, matchedFields, matchReason) {
+function compactGraphNode(result) {
+  const { node, score, matchedFields, matchReason } = result;
   return {
     id: node.id,
     name: node.name,
     type: node.type,
     aliases: node.aliases.map((alias) => compactText2(alias, 160)),
+    ...node.tags ? { tags: node.tags.map((tag) => compactText2(tag, 120)) } : {},
     currentState: compactText2(node.currentState, 500),
     status: node.status,
     rankScore: score,
     ...matchedFields ? { matchedFields } : {},
     ...matchReason ? { matchReason } : {},
-    scoreMeaning: "Ranking-only BM25/RRF score; not confidence, probability, or factual accuracy."
+    ...result.metadataEvidenceStatus ? { metadataEvidenceStatus: result.metadataEvidenceStatus } : {},
+    scoreMeaning: "Ranking-only BM25/RRF score; not confidence, probability, or factual accuracy.",
+    ...result.matchType ? { matchType: result.matchType } : {},
+    ...result.currentFacts ? { currentMatches: result.currentFacts } : {},
+    ...result.historicalFacts ? { historicalMatches: result.historicalFacts } : {},
+    ...result.currentEdges ? { currentRelations: result.currentEdges } : {},
+    ...result.historicalEdges ? { historicalRelations: result.historicalEdges } : {},
+    ...result.timeline ? { timeline: result.timeline } : {}
   };
 }
 function compactRawHit(result) {
@@ -7848,7 +8292,7 @@ function activatedElements(memory, relevance) {
     weight
   ]).map(({ item }) => item);
 }
-function renderActivatedMemory(events, graphNodes) {
+function renderActivatedMemory(events, graphResults) {
   const heading = [
     "[Activated long-term memory]",
     "Historical memory context.",
@@ -7877,13 +8321,23 @@ Events:
     tokens += cost;
     eventCount += 1;
   }
-  for (const node of graphNodes) {
+  for (const result of graphResults) {
+    const node = result.node;
     const rendered = JSON.stringify({
       nodeId: node.id,
       name: node.name,
       type: node.type,
+      aliases: node.aliases,
+      tags: node.tags,
+      status: node.status,
+      metadataEvidenceStatus: result.metadataEvidenceStatus,
+      matchType: result.matchType,
       currentState: node.currentState,
-      facts: node.facts.filter(({ status }) => status === "active").map(({ key, value, validFrom, validTo }) => ({ key, value, validFrom, validTo }))
+      facts: node.facts.map(({ key, value, status, validFrom, validTo }) => ({ key, value, status, validFrom, validTo })),
+      currentRelations: result.currentEdges?.map(({ relation, status }) => ({ relation, status })),
+      historicalMatches: result.historicalFacts?.map(({ key, value, status, validFrom, validTo }) => ({ key, value, status, validFrom, validTo })),
+      historicalRelations: result.historicalEdges?.map(({ relation, status, validFrom, validTo }) => ({ relation, status, validFrom, validTo })),
+      timeline: result.timeline
     });
     const cost = estimateTokens(`
 KnowledgeGraph:
@@ -7961,7 +8415,7 @@ function registerMemoryTools(ctx, runtime) {
   }));
   ctx.tools.register(defineTool({
     name: "memory_search_graph",
-    description: "Search the current Event-backed Knowledge Graph for people, projects, organizations, tools, places, facts, and relations. Returns compact node cards with matchedFields/matchReason; call memory_expand_graph_node for complete facts and edges. rankScore is BM25/RRF ordering only, never confidence or factual accuracy. Results are independently assessable.",
+    description: "Search the Event-backed Knowledge Graph for current state and query-relevant history. Results explicitly label current, historical, or both; historical matches never imply current truth, disputed records remain marked, and Event evidence is bounded to the match. Endpoint names and aliases can match relations, while relation text alone is ranking context. rankScore is ranking-only, never confidence or factual accuracy.",
     parameters: {
       query: { type: "string", required: true },
       limit: { type: "integer", description: "Maximum results, 1-20." }
@@ -7971,7 +8425,7 @@ function registerMemoryTools(ctx, runtime) {
   }));
   ctx.tools.register(defineTool({
     name: "memory_expand_graph_node",
-    description: "Expand one Knowledge Graph node with its current facts, directed edges, and supporting Event evidence.",
+    description: "Expand one Knowledge Graph node through the same Event-authoritative view as search: dynamic current state, marked disputed records, retrievable history, and bounded supporting Event evidence. Forgotten or archived Event provenance is never exposed.",
     parameters: { id: { type: "string", required: true } },
     output: jsonOutput,
     execute: async (args, exec) => runtime.expandGraphNode(sessionOf(exec), args.id)
@@ -9095,17 +9549,36 @@ async function sources(runtime, url) {
     events = [event];
     ids = new Set(event.sourceMessageIds);
   } else if (nodeId) {
-    const node = snapshot.graphNodes.find(({ id }) => id === nodeId);
-    if (!node) throw new AdminHttpError(404, `Unknown graph node: ${nodeId}`);
-    events = snapshot.events.filter(({ id }) => node.sourceEventIds.includes(id));
+    const rawNode = snapshot.graphNodes.find(({ id }) => id === nodeId);
+    if (!rawNode) throw new AdminHttpError(404, `Unknown graph node: ${nodeId}`);
+    const view = effectiveGraphNodeView(rawNode, snapshot.graphEdges, snapshot.events);
+    if (!view) throw new AdminHttpError(404, `Graph node has no retrievable Event evidence: ${nodeId}`);
+    const edges = [...view.currentEdges, ...view.historicalEdges];
+    const relatedNodeIds = /* @__PURE__ */ new Set([rawNode.id, ...edges.flatMap(({ fromNodeId, toNodeId }) => [fromNodeId, toNodeId])]);
+    const nodes = snapshot.graphNodes.filter(({ id }) => relatedNodeIds.has(id)).flatMap((candidate) => effectiveGraphNodeView(candidate, snapshot.graphEdges, snapshot.events)?.node ?? []);
+    const metadataEventIds = [
+      ...view.node.metadataProvenance?.name ?? [],
+      ...(view.node.metadataProvenance?.aliases ?? []).flatMap(({ sourceEventIds }) => sourceEventIds),
+      ...(view.node.metadataProvenance?.tags ?? []).flatMap(({ sourceEventIds }) => sourceEventIds)
+    ];
+    const eventIds = /* @__PURE__ */ new Set([
+      ...view.node.sourceEventIds,
+      ...metadataEventIds,
+      ...view.currentFacts.flatMap(({ sourceEventIds }) => sourceEventIds),
+      ...view.historicalFacts.flatMap(({ sourceEventIds }) => sourceEventIds),
+      ...edges.flatMap(({ sourceEventIds }) => sourceEventIds)
+    ]);
+    events = snapshot.events.filter(({ id }) => eventIds.has(id));
     ids = new Set(events.flatMap(({ sourceMessageIds }) => sourceMessageIds));
-    const edges = snapshot.graphEdges.filter(({ fromNodeId, toNodeId }) => fromNodeId === node.id || toNodeId === node.id);
-    const relatedNodeIds = /* @__PURE__ */ new Set([node.id, ...edges.flatMap(({ fromNodeId, toNodeId }) => [fromNodeId, toNodeId])]);
     return {
       namespace,
-      node,
-      nodes: snapshot.graphNodes.filter(({ id }) => relatedNodeIds.has(id)),
+      node: view.node,
+      nodes,
       edges,
+      currentFacts: view.currentFacts,
+      historicalFacts: view.historicalFacts,
+      currentEdges: view.currentEdges,
+      historicalEdges: view.historicalEdges,
       events: events.map((event) => eventSummary(event)),
       messages: sourceMessages(snapshot, ids)
     };
@@ -9139,7 +9612,7 @@ async function sources(runtime, url) {
     namespace,
     events: events.map((event) => eventSummary(event, eventId ? snapshot : void 0)),
     ...eventId ? {
-      relatedNodes: snapshot.graphNodes.filter(({ id }) => events[0]?.temporal.participantNodeIds?.includes(id)).map(({ id, name: name2, type, aliases }) => ({ id, name: name2, type, aliases }))
+      relatedNodes: snapshot.graphNodes.filter(({ id }) => events[0]?.temporal.participantNodeIds?.includes(id)).flatMap((candidate) => effectiveGraphNodeView(candidate, snapshot.graphEdges, snapshot.events)?.node ?? []).map(({ id, name: name2, type, aliases }) => ({ id, name: name2, type, aliases }))
     } : {},
     elements: elements.map(elementSummary),
     blocks: events.map((event) => snapshot.blocks.find(({ id }) => id === event.sourceBlockId)).filter((block) => Boolean(block)).map((block) => ({ id: block.id, title: block.l0Title, createdAt: block.createdAt })),