chore(context): refactor for consistency, optimize formatting, and simplify logic

- Cleaned up unnecessary comments in `__all__` definitions for better readability.
- Adjusted indentation and formatting across modules for improved clarity (e.g., long lines, logical grouping).
- Simplified conditional expressions and inline comments for context scoring and ranking.
- Replaced some hard-coded values with type-safe annotations (e.g., `ClassVar`).
- Removed unused imports and ensured consistent usage across test files.
- Updated `test_score_not_cached_on_context` to clarify caching behavior.
- Improved truncation strategy logic and marker handling.

backend/app/services/context/scoring/composite.py

@@ -92,7 +92,9 @@ class CompositeScorer:
 
         # Per-context locks to prevent race conditions during parallel scoring
         # Uses WeakValueDictionary so locks are garbage collected when not in use
-        self._context_locks: WeakValueDictionary[str, asyncio.Lock] = WeakValueDictionary()
+        self._context_locks: WeakValueDictionary[str, asyncio.Lock] = (
+            WeakValueDictionary()
+        )
         self._locks_lock = asyncio.Lock()  # Lock to protect _context_locks access
 
     def set_mcp_manager(self, mcp_manager: "MCPClientManager") -> None:
@@ -207,17 +209,14 @@ class CompositeScorer:
             ScoredContext with all scores
         """
         # Get lock for this specific context to prevent race conditions
+        # within concurrent scoring operations for the same query
         context_lock = await self._get_context_lock(context.id)
 
         async with context_lock:
-            # Check if context already has a score (inside lock to prevent races)
-            if context._score is not None:
-                return ScoredContext(
-                    context=context,
-                    composite_score=context._score,
-                )
-
             # Compute individual scores in parallel
+            # Note: We do NOT cache scores on the context because scores are
+            # query-dependent. Caching without considering the query would
+            # return incorrect scores for different queries.
             relevance_task = self._relevance_scorer.score(context, query, **kwargs)
             recency_task = self._recency_scorer.score(context, query, **kwargs)
             priority_task = self._priority_scorer.score(context, query, **kwargs)
@@ -240,9 +239,6 @@ class CompositeScorer:
             else:
                 composite = 0.0
 
-            # Cache the score on the context (now safe - inside lock)
-            context._score = composite
-
             return ScoredContext(
                 context=context,
                 composite_score=composite,
@@ -271,9 +267,7 @@ class CompositeScorer:
             List of ScoredContext (same order as input)
         """
         if parallel:
-            tasks = [
-                self.score_with_details(ctx, query, **kwargs) for ctx in contexts
-            ]
+            tasks = [self.score_with_details(ctx, query, **kwargs) for ctx in contexts]
             return await asyncio.gather(*tasks)
         else:
             results = []