feat(timeline): collect and render full discussion threads

Implements the downstream consumption of matched discussions from the seed
phase, completing the discussion thread feature across collect, CLI, and
integration tests.

Collect phase (timeline_collect.rs):
- New collect_discussion_threads() function assembles full threads by
  querying notes for each matched discussion_id, filtering out system notes
  (is_system = 0), ordering chronologically, and capping at THREAD_MAX_NOTES
  with a synthetic "[N more notes not shown]" summary note
- build_entity_lookup() creates a (type, id) -> (iid, path) map from seed
  and expanded entities to provide display metadata for thread events
- Thread timestamp is set to the first note's created_at for correct
  chronological interleaving with other timeline events
- collect_events() gains a matched_discussions parameter; threads are
  collected after entity events and before evidence note merging

CLI rendering (cli/commands/timeline.rs):
- Human mode: threads render with box-drawing borders, bold @author tags,
  date-stamped notes, and word-wrapped bodies (60 char width)
- Robot mode: DiscussionThread serializes as discussion_thread kind with
  note_count, full notes array (note_id, author, body, ISO created_at)
- THREAD tag in yellow for human event tag styling
- TimelineMeta gains discussion_threads_included count

Tests:
- 8 new collect tests: basic thread assembly, system note filtering, empty
  thread skipping, body truncation to THREAD_NOTE_MAX_CHARS, note cap with
  synthetic summary, timestamp from first note, chronological sort position,
  and deduplication of duplicate discussion_ids
- Integration tests updated for new collect_events signature

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

src/core/timeline_collect.rs

@@ -1,20 +1,27 @@
 use rusqlite::Connection;
 
+use std::collections::HashSet;
+
 use crate::core::error::{LoreError, Result};
-use crate::core::timeline::{EntityRef, ExpandedEntityRef, TimelineEvent, TimelineEventType};
+use crate::core::timeline::{
+    EntityRef, ExpandedEntityRef, MatchedDiscussion, THREAD_MAX_NOTES, THREAD_NOTE_MAX_CHARS,
+    ThreadNote, TimelineEvent, TimelineEventType, truncate_to_chars,
+};
 
 /// Collect all events for seed and expanded entities, interleave chronologically.
 ///
 /// Steps 4-5 of the timeline pipeline:
 /// 1. For each entity, collect Created, StateChanged, Label, Milestone, Merged events
-/// 2. Merge in evidence notes from the seed phase
-/// 3. Sort chronologically with stable tiebreak
-/// 4. Apply --since filter and --limit
+/// 2. Collect discussion threads from matched discussions
+/// 3. Merge in evidence notes from the seed phase
+/// 4. Sort chronologically with stable tiebreak
+/// 5. Apply --since filter and --limit
 pub fn collect_events(
     conn: &Connection,
     seed_entities: &[EntityRef],
     expanded_entities: &[ExpandedEntityRef],
     evidence_notes: &[TimelineEvent],
+    matched_discussions: &[MatchedDiscussion],
     since_ms: Option<i64>,
     limit: usize,
 ) -> Result<(Vec<TimelineEvent>, usize)> {
@@ -30,6 +37,10 @@ pub fn collect_events(
         collect_entity_events(conn, &expanded.entity_ref, false, &mut all_events)?;
     }
 
+    // Collect discussion threads
+    let entity_lookup = build_entity_lookup(seed_entities, expanded_entities);
+    collect_discussion_threads(conn, matched_discussions, &entity_lookup, &mut all_events)?;
+
     // Add evidence notes from seed phase
     all_events.extend(evidence_notes.iter().cloned());
 
@@ -369,6 +380,117 @@ fn entity_id_column(entity: &EntityRef) -> Result<(&'static str, i64)> {
     }
 }
 
+/// Lookup key: (entity_type, entity_id) -> (iid, project_path)
+type EntityLookup = std::collections::HashMap<(String, i64), (i64, String)>;
+
+fn build_entity_lookup(seeds: &[EntityRef], expanded: &[ExpandedEntityRef]) -> EntityLookup {
+    let mut lookup = EntityLookup::new();
+    for e in seeds {
+        lookup.insert(
+            (e.entity_type.clone(), e.entity_id),
+            (e.entity_iid, e.project_path.clone()),
+        );
+    }
+    for exp in expanded {
+        let e = &exp.entity_ref;
+        lookup.insert(
+            (e.entity_type.clone(), e.entity_id),
+            (e.entity_iid, e.project_path.clone()),
+        );
+    }
+    lookup
+}
+
+/// Collect full discussion threads for matched discussions.
+fn collect_discussion_threads(
+    conn: &Connection,
+    matched_discussions: &[MatchedDiscussion],
+    entity_lookup: &EntityLookup,
+    events: &mut Vec<TimelineEvent>,
+) -> Result<()> {
+    // Deduplicate by discussion_id
+    let mut seen = HashSet::new();
+
+    for disc in matched_discussions {
+        if !seen.insert(disc.discussion_id) {
+            continue;
+        }
+
+        let (iid, project_path) =
+            match entity_lookup.get(&(disc.entity_type.clone(), disc.entity_id)) {
+                Some(val) => val.clone(),
+                None => continue, // entity not in seed or expanded set
+            };
+
+        let mut stmt = conn.prepare(
+            "SELECT id, author_username, body, created_at FROM notes
+             WHERE discussion_id = ?1 AND is_system = 0
+             ORDER BY created_at ASC",
+        )?;
+
+        let rows = stmt.query_map(rusqlite::params![disc.discussion_id], |row| {
+            Ok((
+                row.get::<_, i64>(0)?,            // id
+                row.get::<_, Option<String>>(1)?, // author_username
+                row.get::<_, Option<String>>(2)?, // body
+                row.get::<_, i64>(3)?,            // created_at
+            ))
+        })?;
+
+        let mut notes = Vec::new();
+        for row_result in rows {
+            let (note_id, author, body, created_at) = row_result?;
+            let body = truncate_to_chars(body.as_deref().unwrap_or(""), THREAD_NOTE_MAX_CHARS);
+            notes.push(ThreadNote {
+                note_id,
+                author,
+                body,
+                created_at,
+            });
+        }
+
+        // Skip empty threads (all notes were system notes)
+        if notes.is_empty() {
+            continue;
+        }
+
+        let first_created_at = notes[0].created_at;
+
+        // Cap notes per thread
+        let total_notes = notes.len();
+        if total_notes > THREAD_MAX_NOTES {
+            notes.truncate(THREAD_MAX_NOTES);
+            notes.push(ThreadNote {
+                note_id: -1,
+                author: None,
+                body: format!("[{} more notes not shown]", total_notes - THREAD_MAX_NOTES),
+                created_at: notes.last().map_or(first_created_at, |n| n.created_at),
+            });
+        }
+
+        let note_count = notes.len();
+        let actor = notes.first().and_then(|n| n.author.clone());
+
+        events.push(TimelineEvent {
+            timestamp: first_created_at,
+            entity_type: disc.entity_type.clone(),
+            entity_id: disc.entity_id,
+            entity_iid: iid,
+            project_path,
+            event_type: TimelineEventType::DiscussionThread {
+                discussion_id: disc.discussion_id,
+                notes,
+            },
+            summary: format!("Discussion ({note_count} notes)"),
+            actor,
+            url: None,
+            is_seed: true,
+        });
+    }
+
+    Ok(())
+}
+
 #[cfg(test)]
 #[path = "timeline_collect_tests.rs"]
 mod tests;