fix(temporal): keep unknown-validity sources eligible, add summary lineage

Ingested messages carry no valid-time assertion, so rejecting summary
lineage on UnknownSourceValidTime made every production summary node
permanently unavailable; that uncertainty already surfaces through the
occurrence-level coverage axis. Eligible summaries now also emit
Supports lineage edges to their source anchors so describes stay
traceable without a stored assertion row.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: ScriptedAlchemy

src/query/temporal/mod.rs

@@ -12,8 +12,8 @@ use std::fmt;
 use thiserror::Error;
 use tracedecay_domain::{
     CompactContextConflictV1, CompactContextLineageEdgeV1, CompactContextOmissionV1,
-    ContextOmissionReasonV1, HydrationStateV1, RetrievalAnchorId, SessionSummaryRecordV1,
-    TemporalAssertionKindV1, TemporalCoverageCountsV1, TemporalModeV1,
+    ContextOmissionReasonV1, HydrationStateV1, RetrievalAnchorId, SessionAuthorityClassV1,
+    SessionSummaryRecordV1, TemporalAssertionKindV1, TemporalCoverageCountsV1, TemporalModeV1,
 };
 use zeroize::Zeroizing;
 
@@ -311,6 +311,7 @@ pub async fn execute_temporal_kernel(
         &resolved,
         &resolved.lineage_edges,
         &hydration,
+        &records.summaries,
         &summary_eligibility,
     );
     let context = assemble_context_with_frames_controlled(
@@ -472,6 +473,7 @@ fn temporal_context_frames(
     resolved: &[ResolvedOccurrence],
     lineage_edges: &[ResolutionLineageEdge],
     hydration: &HydrationBatch,
+    summaries: &[SessionSummaryRecordV1],
     summary_eligibility: &SummaryLineageEligibility,
 ) -> TemporalContextFrames {
     let unknown_anchors = resolved
@@ -517,7 +519,31 @@ fn temporal_context_frames(
             supporting_anchor_ids: item.supporting_anchor_ids.clone(),
         })
         .collect();
-    let lineage = lineage_edges.iter().map(context_lineage_edge).collect();
+    let mut lineage: Vec<CompactContextLineageEdgeV1> =
+        lineage_edges.iter().map(context_lineage_edge).collect();
+    // Eligible summaries carry their own provenance: each summary anchor
+    // supports-derives from its source anchors. Surfacing that as Supports
+    // lineage keeps summary describes traceable without a stored assertion
+    // row per source.
+    for summary in summaries {
+        if !summary_eligibility
+            .eligible_anchor_ids
+            .contains(summary.summary_anchor_id())
+        {
+            continue;
+        }
+        for source_anchor in summary.source_anchors() {
+            lineage.push(CompactContextLineageEdgeV1 {
+                kind: TemporalAssertionKindV1::Supports,
+                subject_anchor_id: summary.summary_anchor_id().clone(),
+                object_anchor_id: source_anchor.clone(),
+                knowledge_at: summary.created_at(),
+                authority: SessionAuthorityClassV1::ImmutableSummary,
+                authorized: true,
+                supporting_anchor_ids: BTreeSet::new(),
+            });
+        }
+    }
     let summary_omissions = public_summary_omissions(summary_eligibility);
     let omissions = summary_omissions
         .iter()
@@ -811,6 +837,7 @@ mod scope_tests {
             &[],
             &[],
             &HydrationBatch::default(),
+            &[],
             &eligibility,
         );
 
@@ -885,6 +912,7 @@ mod scope_tests {
             &[],
             &[],
             &HydrationBatch::default(),
+            &[],
             &eligibility,
         );
 
@@ -958,6 +986,7 @@ mod scope_tests {
             &[],
             &[],
             &HydrationBatch::default(),
+            &[],
             &eligibility,
         );
 

src/query/temporal/resolution/summary.rs

@@ -195,11 +195,13 @@ fn summary_source_rejection(
                                 anchor_id: anchor_id.clone(),
                             })
                         }
-                        (TemporalValidityV1::Unknown, Some(_)) => {
-                            Some(SummaryLineageRejection::UnknownSourceValidTime {
-                                anchor_id: anchor_id.clone(),
-                            })
-                        }
+                        // Sources routinely carry no valid-time assertion (all
+                        // ingested messages today): that uncertainty is already
+                        // surfaced per-occurrence through the coverage
+                        // `unknown` axis, so it must not reject the summary's
+                        // whole lineage — only a provably out-of-horizon
+                        // source does.
+                        (TemporalValidityV1::Unknown, Some(_)) => None,
                         (_, None) => None,
                     }
                 }

src/query/temporal/resolution/tests.rs

@@ -1583,7 +1583,7 @@ fn non_current_summary_modes_retain_eligible_predecessors() {
 }
 
 #[test]
-fn missing_and_unknown_validity_sources_have_distinct_rejections() {
+fn unknown_validity_sources_stay_eligible_while_missing_sources_reject() {
     let session_id: SessionId = serde_json::from_str("\"session-1\"").expect("valid session id");
     let missing = summary("missing", "summary-missing", "missing-source", 7, 7);
     let unknown_valid = summary("unknown-valid", "summary-unknown", "unknown-source", 7, 7);
@@ -1614,12 +1614,20 @@ fn missing_and_unknown_validity_sources_have_distinct_rejections() {
             .get(&SessionSummaryIdV1::new("missing").expect("valid id")),
         Some(SummaryLineageRejection::MissingSource { .. })
     ));
-    assert!(matches!(
+    // Ingested messages carry no valid-time assertion today; that
+    // uncertainty surfaces through occurrence-level coverage, not by
+    // rejecting the summary's lineage outright.
+    assert!(
         eligibility
             .rejections
-            .get(&SessionSummaryIdV1::new("unknown-valid").expect("valid id")),
-        Some(SummaryLineageRejection::UnknownSourceValidTime { .. })
-    ));
+            .get(&SessionSummaryIdV1::new("unknown-valid").expect("valid id"))
+            .is_none()
+    );
+    assert!(
+        eligibility
+            .eligible_anchor_ids
+            .contains(&anchor("summary-unknown"))
+    );
 }
 
 #[test]