Implement RAG summarization and context pipeline

- Add ContextPipeline for async RAG lookups
- Implement RAG result summarization via LLMProcessor
- Add CLI flag for PDF ingestion
- Strip markdown code blocks from LLM responses
- Update TUI context display to use ListItems

src/pipeline/context_pipeline.py

@@ -0,0 +1,67 @@
+import asyncio
+import logging
+from typing import Tuple
+
+from src.llm.models import ContextUpdate
+from src.rag.manager import RAGManager
+
+logger = logging.getLogger(__name__)
+
+
+class ContextPipeline:
+    def __init__(self, rag_manager: RAGManager):
+        self.rag_manager = rag_manager
+
+    async def process_message(
+        self, speaker: str, text: str, context_queue: asyncio.Queue
+    ):
+        """
+        Processes a single message and pushes summarized insights to the context queue.
+        """
+        try:
+            # Use RAGManager.retrieve with summarize=True to get concise insights
+            # Run in a thread to avoid blocking the event loop
+            insights = await asyncio.to_thread(
+                self.rag_manager.retrieve, text, summarize=True
+            )
+
+            if insights:
+                logger.info(
+                    f"ContextPipeline: Found {len(insights)} insights for text: {text}"
+                )
+                for insight in insights:
+                    await context_queue.put(insight)
+            else:
+                logger.debug(f"ContextPipeline: No insights found for text: {text}")
+
+        except Exception as e:
+            logger.error(f"ContextPipeline error processing message: {e}")
+
+    async def run(
+        self,
+        transcript_queue: asyncio.Queue,
+        context_queue: asyncio.Queue,
+        stop_event: asyncio.Event,
+    ):
+        """
+        Main loop that listens to the transcript queue and triggers RAG lookups.
+        """
+        logger.info("Context Pipeline started.")
+        while not stop_event.is_set():
+            try:
+                # Get raw text from transcript queue (speaker, text)
+                speaker, text = await transcript_queue.get()
+
+                # For now, implement the basic flow: every message triggers a lookup.
+                # If performance becomes an issue, a filter can be added here.
+                await self.process_message(speaker, text, context_queue)
+
+                # Mark the task as done
+                transcript_queue.task_done()
+            except Exception as e:
+                logger.error(f"Context Pipeline loop error: {e}")
+
+            # Small sleep to avoid tight loop
+            await asyncio.sleep(0.1)
+
+        logger.info("Context Pipeline stopped.")