sourcecode 1.30.24__py3-none-any.whl → 1.30.26__py3-none-any.whl

sourcecode/__init__.py

@@ -1,3 +1,3 @@
 """sourcecode — Deterministic codebase context maps for AI coding agents."""
 
-__version__ = "1.30.24"
+__version__ = "1.30.26"

sourcecode/cli.py

@@ -2030,6 +2030,10 @@ def prepare_context_cmd(
             out["runtime_changes"] = output.runtime_changes
         if output.build_changes:
             out["build_changes"] = output.build_changes
+        if output.committed_changes:
+            out["committed_changes"] = output.committed_changes
+        if output.uncommitted_changes:
+            out["uncommitted_changes"] = output.uncommitted_changes
         if output.review_hotspots:
             out["review_hotspots"] = output.review_hotspots
         if output.suggested_review_order:
@@ -2047,6 +2051,27 @@ def prepare_context_cmd(
             "files": output.scope_files,
             "repo_root": output.repo_root or "",
         }
+        # analysis_limiter: consolidate missing graph signals into one field
+        _missing_signals: list[str] = []
+        _dgraph = output.dependency_graph_summary or {}
+        if not _dgraph.get("has_graph_evidence"):
+            _missing_signals.append("dependency_graph")
+        _has_import_ev = any(
+            (rc.get("role") or {}).get("has_annotation_signal") or
+            (rc.get("role") or {}).get("has_symbol_signal")
+            for rc in (output.runtime_changes or [])
+        )
+        if not _has_import_ev:
+            _missing_signals.append("import_graph")
+        if _missing_signals:
+            out["analysis_limiter"] = {"missing_signals": _missing_signals}
+        # classification_confidence: global note when all runtime files are low confidence
+        _all_low = bool(output.runtime_changes) and all(
+            (rc.get("change_effect") or {}).get("epistemic_level") == "INFERRED (LOW CONFIDENCE)"
+            for rc in output.runtime_changes
+        )
+        if _all_low:
+            out["classification_confidence"] = "low"
     if output.limitations:
         out["limitations"] = output.limitations
     if output.symptom:

sourcecode/confidence_analyzer.py

@@ -290,10 +290,18 @@ class ConfidenceAnalyzer:
         elif production_eps and all(ep.runtime_relevance == "low" for ep in production_eps):
             overall = _min_confidence([overall, "low"])
 
-        # Factor in architecture confidence when available
+        # Factor in architecture confidence when available.
+        # Key rule: if a pattern was detected (not None/"unknown"), arch.confidence="low"
+        # typically reflects missing documentation (no OpenAPI/ADR), not structural uncertainty.
+        # In that case, clamp the downgrade to "medium" so that high stack + high entry_points
+        # is not contradicted by a docs gap.
         arch = sm.architecture
         if arch is not None and arch.requested:
-            overall = _min_confidence([overall, arch.confidence])
+            arch_conf_for_overall = arch.confidence
+            if arch.confidence == "low" and arch.pattern not in (None, "unknown"):
+                # Pattern was detected — low is docs-only, not structural; cap downgrade at medium
+                arch_conf_for_overall = "medium"
+            overall = _min_confidence([overall, arch_conf_for_overall])
             if arch.pattern in (None, "unknown"):
                 # Architecture could not be inferred — don't let stack alone push to high
                 if overall == "high":

sourcecode/file_classifier.py

@@ -84,16 +84,17 @@ _JAVA_ANNOTATION_RE = re.compile(r'@(RestController|Controller|Service|Repositor
 # (annotation_set, category, relevance, why_template)
 # Checked in priority order; first match wins.
 _JAVA_STEREOTYPE_RULES: list[tuple[frozenset, str, float, str]] = [
-    (frozenset({"EnableWebSecurity"}),               "security",        0.85, "Spring Security configuration"),
-    (frozenset({"RestController"}),                  "api_endpoint",    0.90, "Spring REST controller — defines HTTP API surface"),
-    (frozenset({"Controller", "RequestMapping"}),    "api_endpoint",    0.80, "Spring MVC controller"),
-    (frozenset({"Service", "Transactional"}),        "business_logic",  0.75, "Transactional service — business logic boundary"),
-    (frozenset({"Service"}),                         "business_logic",  0.65, "Spring service component"),
-    (frozenset({"Repository"}),                      "data_access",     0.65, "Spring repository — data access layer"),
-    (frozenset({"Mapper"}),                          "data_access",     0.65, "MyBatis mapper — SQL data access"),
-    (frozenset({"Configuration"}),                   "configuration",   0.70, "Spring configuration class"),
-    (frozenset({"Entity"}),                          "domain_model",    0.50, "JPA entity — domain model"),
-    (frozenset({"Data"}),                            "dto",             0.40, "Lombok DTO"),
+    (frozenset({"EnableWebSecurity"}),               "security",          0.85, "Spring Security configuration"),
+    (frozenset({"RestController"}),                  "api_endpoint",      0.90, "Spring REST controller — defines HTTP API surface"),
+    (frozenset({"Controller", "RequestMapping"}),    "api_endpoint",      0.80, "Spring MVC controller"),
+    (frozenset({"ControllerAdvice"}),                "exception_handler", 0.75, "Spring @ControllerAdvice — cross-cutting exception handling"),
+    (frozenset({"Service", "Transactional"}),        "business_logic",    0.75, "Transactional service — business logic boundary"),
+    (frozenset({"Service"}),                         "business_logic",    0.65, "Spring service component"),
+    (frozenset({"Repository"}),                      "data_access",       0.65, "Spring repository — data access layer"),
+    (frozenset({"Mapper"}),                          "data_access",       0.65, "MyBatis mapper — SQL data access"),
+    (frozenset({"Configuration"}),                   "configuration",     0.70, "Spring configuration class"),
+    (frozenset({"Entity"}),                          "domain_model",      0.50, "JPA entity — domain model"),
+    (frozenset({"Data"}),                            "dto",               0.40, "Lombok DTO"),
 ]
 
 # Categories produced by Java stereotype detection — used downstream to apply direct relevance

sourcecode/pr_comment_renderer.py

@@ -171,13 +171,31 @@ def _section_priority_order(out: dict) -> str:
         lines.append("*No priority order available — diff scope too narrow to rank.*")
         return "\n".join(lines)
 
-    for i, path in enumerate(order[:_MAX_PRIORITY_FILES], 1):
+    visible = order[:_MAX_PRIORITY_FILES]
+    all_low = visible and all(
+        (cls_map.get(p, {}).get("change_effect") or {}).get("epistemic_level")
+        == "INFERRED (LOW CONFIDENCE)"
+        for p in visible
+    )
+
+    for i, path in enumerate(visible, 1):
         rc = cls_map.get(path, {})
         effect = rc.get("change_effect", {})
         stmt = effect.get("statement", "application source") if isinstance(effect, dict) else "application source"
-        ep = effect.get("epistemic_level", "STRUCTURAL SIGNAL") if isinstance(effect, dict) else "STRUCTURAL SIGNAL"
         atype = rc.get("artifact_type", "source")
-        lines.append(f"{i}. `{_short(path)}` — {_badge(ep)}: {atype} — {stmt}")
+        if all_low:
+            lines.append(f"{i}. `{_short(path)}` — {atype} — {stmt}")
+        else:
+            ep = effect.get("epistemic_level", "STRUCTURAL SIGNAL") if isinstance(effect, dict) else "STRUCTURAL SIGNAL"
+            lines.append(f"{i}. `{_short(path)}` — {_badge(ep)}: {atype} — {stmt}")
+
+    if all_low:
+        lines.append("")
+        lines.append(
+            f"*Classification confidence: low for all changed files "
+            f"{_badge('INFERRED (LOW CONFIDENCE)')} — "
+            "no annotation/import signals found in changed files.*"
+        )
 
     return "\n".join(lines)
 
@@ -269,50 +287,26 @@ def _section_signals(out: dict) -> str:
 def _section_guidance(out: dict) -> str:
     lines = ["### 5. Review Guidance", ""]
 
-    # Inspect first — top priority files
-    order: list[str] = out.get("suggested_review_order", []) or out.get("review_hotspots", [])
-    runtime: list[dict] = out.get("runtime_changes", [])
-    cls_map: dict[str, dict] = {rc["path"]: rc for rc in runtime}
-
-    if order:
-        lines.append("**Inspect first:**")
-        for path in order[:3]:
-            rc = cls_map.get(path, {})
-            effect = rc.get("change_effect", {})
-            stmt = effect.get("statement", "") if isinstance(effect, dict) else ""
-            ep = effect.get("epistemic_level", "STRUCTURAL SIGNAL") if isinstance(effect, dict) else "STRUCTURAL SIGNAL"
-            label = f" — {stmt}" if stmt else ""
-            lines.append(f"- `{_short(path)}`{label} {_badge(ep)}")
-        lines.append("")
-
-    # Uncertain — heuristic-only behavioral paths
-    behavioral: list[dict] = out.get("behavioral_impact", [])
-    weak_paths = [
-        bi for bi in behavioral
-        if bi.get("evidence_level", "none") == "heuristic_only"
-    ]
-    if weak_paths:
-        lines.append("**Uncertain (heuristic-only — verify manually):**")
-        for bi in weak_paths[:_MAX_UNCERTAIN]:
-            entry = bi.get("entry_point", "")
-            affected: list[str] = bi.get("affected_path", [])
-            path_str = " → ".join(affected) if affected else "unknown"
-            lines.append(
-                f"- `{entry}` → {path_str} "
-                f"{_badge('INFERRED (LOW CONFIDENCE)')}: class reference only, no injection/call proof"
-            )
-        lines.append("")
-
-    # Evidence gaps
+    # Evidence gaps ONLY — "Inspect first" covered by §3, "Uncertain" covered by §2
     gaps: list[str] = out.get("gaps", [])
     cov = out.get("test_coverage_risk", {})
     test_files: list[str] = cov.get("changed_files_without_tests", [])
     test_basis = cov.get("basis", "")
     cov_ep = cov.get("epistemic_level", "INFERRED (LOW CONFIDENCE)")
 
-    gap_items: list[str] = list(gaps)
+    # Skip graph-absence gaps already captured in analysis_limiter
+    missing_signals: set[str] = set(
+        (out.get("analysis_limiter") or {}).get("missing_signals", [])
+    )
+    gap_items: list[str] = [
+        g for g in gaps
+        if not missing_signals or not any(
+            sig.replace("_", " ") in g.lower() for sig in missing_signals
+        )
+    ]
+
     if test_files:
-        shown = test_files[:5]
+        shown = test_files[:3]
         omitted = len(test_files) - len(shown)
         names = ", ".join(f"`{_short(f)}`" for f in shown)
         suffix = f" +{omitted} more" if omitted else ""
@@ -323,12 +317,19 @@ def _section_guidance(out: dict) -> str:
         )
 
     if gap_items:
-        lines.append("**Evidence gaps / missing coverage:**")
-        for g in gap_items:
+        lines.append("**Evidence gaps:**")
+        for g in gap_items[:3]:
             lines.append(f"- {g}")
     else:
         lines.append("*No evidence gaps detected.*")
 
+    if missing_signals:
+        lines.append("")
+        lines.append(
+            f"{_badge('OMITTED')}: {', '.join(sorted(missing_signals))} — "
+            "graph-based impact analysis unavailable"
+        )
+
     return "\n".join(lines)
 
 

sourcecode/prepare_context.py

@@ -1271,9 +1271,9 @@ class TaskContextBuilder:
                     "evidence": _evidence,
                     "change_effect": {
                         "statement": _ARTIFACT_CHANGE_EFFECT.get(_f_atype, "application source file (role could not be confirmed)"),
-                        "classification_method": _f_cls.get("confidence", "low"),
+                        "classification_method": _role_basis,
                         "epistemic_level": (
-                            "STRUCTURAL SIGNAL" if _f_cls.get("confidence", "low") == "high"
+                            "STRUCTURAL SIGNAL" if _has_code_ev
                             else "INFERRED (LOW CONFIDENCE)"
                         ),
                     },
@@ -2054,10 +2054,18 @@ class TaskContextBuilder:
         if since is None and not committed_files and not uncommitted_files:
             head_ok = _run("git", "rev-parse", "--verify", "HEAD~1")
             if head_ok is not None:  # HEAD~1 exists
-                head_committed = _run("git", "diff", "--name-only", "--relative", "HEAD~1", "HEAD")
+                head_committed = _run("git", "diff", "--name-only", "--relative", "HEAD~1..HEAD")
                 if head_committed:
                     committed_files = head_committed
                     sources.append(DiffSourceType.HEAD_MINUS_1.value)
+            else:
+                # First commit — no HEAD~1; diff against git empty tree
+                _GIT_EMPTY_TREE = "4b825dc642cb6eb9a060e54bf8d69288fbee4904"
+                first_committed = _run("git", "diff", "--name-only", "--relative",
+                                       _GIT_EMPTY_TREE, "HEAD")
+                if first_committed:
+                    committed_files = first_committed
+                    sources.append("initial_commit")
 
         # ── Drop paths outside self.root ──────────────────────────────────────
         def _drop_outside(lst: list[str]) -> list[str]:
@@ -2588,6 +2596,10 @@ class TaskContextBuilder:
             # These are INFERRED (LOW CONFIDENCE) — stem match, not annotation evidence.
             if any(kw in stem_lower for kw in ("validator", "validation")):
                 return "validation_component"
+            if any(kw in stem_lower for kw in ("filter", "interceptor", "aspect")):
+                return "runtime_filter"
+            if any(kw in stem_lower for kw in ("advice", "advise", "exceptionhandler", "errorhandler")):
+                return "exception_handler"
             if any(kw in stem_lower for kw in ("controller", "resource", "endpoint", "rest")):
                 return "external_interface"
             if any(kw in stem_lower for kw in ("service", "svc", "usecase", "facade")):
@@ -3280,8 +3292,14 @@ class TaskContextBuilder:
                 files = _diff("HEAD~1")
                 if files is not None:
                     return _make(files or [], "HEAD~1", "head_minus_1_fallback")
+            else:
+                # First commit — no HEAD~1; diff against git empty tree
+                _GIT_EMPTY_TREE = "4b825dc642cb6eb9a060e54bf8d69288fbee4904"
+                files = _diff(_GIT_EMPTY_TREE)
+                if files is not None:
+                    return _make(files or [], _GIT_EMPTY_TREE, "initial_commit_fallback")
 
-            # Confirmed no changes: first commit or empty repo
+            # Confirmed no changes: empty repo
             return {
                 "files": [],
                 "resolved_ref": "HEAD",

sourcecode/serializer.py

@@ -660,6 +660,116 @@ def _jndi_datasources(sm: "SourceMap") -> "Optional[list[dict[str, Any]]]":
     return datasources
 
 
+def _tiered_display_score(
+    pre_bonus_combined: float,
+    file_class: Any,
+    path: str,
+    entry_paths: set,
+    has_structural_signals: bool = False,
+) -> float:
+    """Evidence-tiered display score [0.0, 1.0].
+
+    Tiers enforce: strong evidence > medium evidence > filesystem/path only.
+    M3 sort bonuses must NOT be included in pre_bonus_combined — they are for
+    ordering only and must not inflate the displayed score.
+
+    Tier ceilings:
+      T1  confirmed production entrypoint           0.92–1.00
+      T2  entrypoint (weaker category)              0.80–0.91
+      T3  annotation-confirmed stereotype           0.40–0.90  (table-calibrated)
+      T4  framework import evidence                 0.55–0.79
+      T5  code definitions + imports                0.38–0.54
+      T6  build manifest / tooling / test           0.25–0.45
+      T7  path/filesystem signal only               0.10–0.39
+    """
+    from sourcecode.file_classifier import JAVA_STEREOTYPE_CATEGORIES
+
+    cat = file_class.category if file_class else None
+    base_rel = file_class.relevance if file_class else 0.0
+
+    # T1: confirmed production entrypoint
+    if path in entry_paths and cat in ("runtime_core", "cli_entrypoint"):
+        return round(min(1.0, max(0.92, base_rel)), 3)
+
+    # T2: in entry_paths but weaker evidence category
+    if path in entry_paths:
+        return round(min(0.91, max(0.80, pre_bonus_combined / 2.0)), 3)
+
+    # T3: annotation-confirmed stereotype — table values are already calibrated
+    if file_class and cat in JAVA_STEREOTYPE_CATEGORIES:
+        return round(base_rel, 3)
+
+    # T4: framework import evidence (medium strength)
+    if cat in ("api_layer", "database_layer", "infrastructure"):
+        return round(min(0.79, max(0.55, pre_bonus_combined / 2.0)), 3)
+
+    # T5: code definitions with imports (medium-low)
+    if cat in ("application_logic", "domain_model"):
+        return round(min(0.54, max(0.38, pre_bonus_combined / 2.0)), 3)
+
+    # T6: build manifest / tooling / test
+    if cat == "build_system":
+        return round(min(0.45, base_rel), 3)
+    if cat in ("tests", "tooling"):
+        return round(min(0.35, base_rel), 3)
+
+    # T7: no content classification — filesystem/structural signals only
+    # has_structural_signals: fan_in, churn, export — allows up to 0.54
+    # pure path/filename only — hard cap 0.39
+    if has_structural_signals:
+        return round(min(0.54, max(0.10, pre_bonus_combined / 2.0)), 3)
+    return round(min(0.39, max(0.10, pre_bonus_combined / 2.0)), 3)
+
+
+def _build_file_signals(
+    file_class: Any,
+    path: str,
+    entry_paths: set,
+    fs_reasons: list,
+    sem_hub: float,
+) -> list[dict]:
+    """Minimal per-file signal breakdown: what contributed to this file's score."""
+    from sourcecode.file_classifier import JAVA_STEREOTYPE_CATEGORIES
+
+    signals: list[dict] = []
+
+    if path in entry_paths:
+        signals.append({"type": "runtime_entrypoint", "strength": "strong"})
+
+    if file_class:
+        cat = file_class.category
+        if cat in JAVA_STEREOTYPE_CATEGORIES:
+            signals.append({"type": "framework_annotation", "strength": "strong"})
+        elif cat in ("api_layer", "database_layer", "infrastructure"):
+            ev = [e for e in (file_class.evidence or [])[:2] if e]
+            signals.append({"type": "framework_import", "strength": "medium", "evidence": ev})
+        elif cat in ("application_logic",):
+            signals.append({"type": "code_definitions_with_imports", "strength": "medium"})
+        elif cat in ("domain_model",):
+            signals.append({"type": "domain_model_definitions", "strength": "medium"})
+        elif cat in ("build_system",):
+            signals.append({"type": "build_manifest", "strength": "medium"})
+
+    for r in fs_reasons:
+        r_lower = r.lower()
+        if "import centrality" in r_lower or "imported by" in r_lower:
+            signals.append({"type": "import_centrality", "strength": "medium"})
+        elif "hub module" in r_lower:
+            signals.append({"type": "hub_module", "strength": "medium"})
+        elif "recent churn" in r_lower:
+            signals.append({"type": "git_churn", "strength": "medium"})
+        elif "uncommitted" in r_lower:
+            signals.append({"type": "uncommitted_changes", "strength": "medium"})
+
+    if sem_hub >= 0.15:
+        signals.append({"type": "call_graph_hub", "strength": "strong"})
+
+    if not signals:
+        signals.append({"type": "filesystem_path", "strength": "weak"})
+
+    return signals
+
+
 def _file_relevance(sm: SourceMap, *, limit: int = _FILE_RELEVANCE_LIMIT) -> list[dict[str, Any]]:
     from sourcecode.ranking_engine import RankingEngine
 
@@ -714,40 +824,44 @@ def _file_relevance(sm: SourceMap, *, limit: int = _FILE_RELEVANCE_LIMIT) -> lis
         content_rel = file_class.relevance if file_class else 0.0
         # Semantic hub bonus: normalised call-graph centrality adds up to +0.30
         sem_hub = semantic_hub_scores.get(path, 0.0) * 0.30
-        combined = fs.score + content_rel + sem_hub
+        pre_bonus_combined = fs.score + content_rel + sem_hub
         # REST controller boost: surface above @Transactional service files
         if path in _rest_ctrl_paths:
-            combined += 2.0
+            pre_bonus_combined += 2.0
 
-        # M3: Structural importance scoring — priority over alphabetical ordering.
+        # M3: Structural importance scoring — SORT ORDER ONLY.
+        # These bonuses drive ranking but must NOT inflate the displayed score.
         stem = Path(path).stem
         stem_lower = stem.lower()
         path_lower = path.lower()
+        sort_bonus = 0.0
         # +10 application entry points
         if path in entry_paths and any(
             k in stem for k in ("Application", "Main", "Initializer", "Bootstrap", "Startup")
         ):
-            combined += 10.0
+            sort_bonus = 10.0
         # +8 known base/infrastructure classes
         elif any(k in stem for k in (
             "GenericRestController", "GenericCRUDRestController", "GenericController",
             "AkitaBaseService", "BaseService", "FilterConfig", "AbstractController",
         )):
-            combined += 8.0
+            sort_bonus = 8.0
         # +6 security configuration
         elif any(k in stem for k in (
             "SecurityConfig", "SecurityStrategy", "WebSecurityConfig", "SecurityFilter",
             "JwtFilter", "AuthConfig", "SecurityConfiguration",
         )):
-            combined += 6.0
+            sort_bonus = 6.0
         # +2 shared utilities
         elif any(k in path_lower for k in ("util", "shared", "common", "helper", "constant")):
-            combined += 2.0
+            sort_bonus = 2.0
+
+        sort_key = pre_bonus_combined + sort_bonus
 
         # Visibility threshold: require meaningful combined signal.
         # Exception: high/medium-confidence files with strong content relevance
         # can survive even if structural score is weak.
-        if combined < _FILE_RELEVANCE_MIN_COMBINED:
+        if sort_key < _FILE_RELEVANCE_MIN_COMBINED:
             if not (file_class
                     and file_class.relevance > 0.45
                     and file_class.confidence in {"high", "medium"}):
@@ -757,48 +871,64 @@ def _file_relevance(sm: SourceMap, *, limit: int = _FILE_RELEVANCE_LIMIT) -> lis
         if (file_class
                 and file_class.confidence == "low"
                 and file_class.category in {"config", "auxiliary"}
-                and combined < 0.45):
+                and sort_key < 0.45):
             continue
 
-        # For Java stereotype annotations use the table relevance directly —
-        # the combined/2 formula would dilute the stereotype signal.
-        from sourcecode.file_classifier import JAVA_STEREOTYPE_CATEGORIES
-        if file_class and file_class.category in JAVA_STEREOTYPE_CATEGORIES:
-            relevance_val = round(file_class.relevance, 3)
-        else:
-            relevance_val = round(max(0.0, min(1.0, combined / 2.0)), 3)
+        # Detect whether structural signals (fan_in, churn, etc.) are present
+        # beyond the base path-relevance reason — used by fallback tier.
+        structural_signal_reasons = [
+            r for r in fs.reasons
+            if r not in ("source file", "workspace source root", "runtime entrypoint")
+            and "path" not in r.lower()
+        ]
+        has_structural = bool(structural_signal_reasons)
+
+        # Tiered display score: evidence-gated, tier-capped.
+        # pre_bonus_combined is used (M3 sort_bonus excluded).
+        score_val = _tiered_display_score(
+            pre_bonus_combined, file_class, path, entry_paths, has_structural,
+        )
+        # relevance: raw evidence strength from FileClassifier (content signal only)
+        relevance_val = round(file_class.relevance, 3) if file_class else round(
+            min(0.39, max(0.10, pre_bonus_combined / 2.0)), 3
+        )
+
+        ranking_reasons = [r for r in fs.reasons if r != "source file"]
+        if sem_hub >= 0.15:
+            ranking_reasons.append("call graph hub")
+
+        signals = _build_file_signals(file_class, path, entry_paths, ranking_reasons, sem_hub)
 
         item: dict[str, Any] = {
             "path": path,
             "category": file_class.category if file_class else "source",
             "confidence": file_class.confidence if file_class else "low",
+            "score": score_val,
             "relevance": relevance_val,
-            "score": relevance_val,
             "reason": file_class.reason if file_class else (fs.reasons[0] if fs.reasons else "source file"),
             "evidence": file_class.evidence if file_class else [],
+            "signals": signals,
         }
 
-        ranking_reasons = [r for r in fs.reasons if r != "source file"]
-        if sem_hub >= 0.15:
-            ranking_reasons.append("call graph hub")
         if ranking_reasons:
             item["ranking_reasons"] = ranking_reasons
 
         # Override metadata for known M3 base controller classes
         if any(k in stem for k in ("GenericRestController", "GenericCRUDRestController")):
             item["category"] = "runtime_core"
-            item["relevance"] = 0.95
             item["score"] = 0.95
+            item["relevance"] = 0.95
             item["reason"] = (
                 "base class for all REST controllers — extends this to get "
                 "centralized exception handling via handlerException()"
             )
             item["evidence"] = ["base_rest_controller"]
             item["ranking_reasons"] = ["universal base class", "exception handling contract"]
+            item["signals"] = [{"type": "framework_annotation", "strength": "strong"}]
 
-        scored.append((combined, item))
+        scored.append((sort_key, item))
 
-    # Deterministic sort: score desc, then path asc
+    # Deterministic sort: sort_key desc, then path asc
     scored.sort(key=lambda x: (-x[0], x[1]["path"]))
 
     # Diversity cap: at most half the budget from any single category.

{sourcecode-1.30.24.dist-info → sourcecode-1.30.26.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sourcecode
-Version: 1.30.24
+Version: 1.30.26
 Summary: Deterministic codebase context for AI coding agents
 License:                                  Apache License
                                    Version 2.0, January 2004
@@ -221,7 +221,7 @@ Description-Content-Type: text/markdown
 
 **Deterministic, behavior-aware codebase context for AI agents and PR review.**
 
-![Version](https://img.shields.io/badge/version-1.30.24-blue)
+![Version](https://img.shields.io/badge/version-1.30.26-blue)
 ![Python](https://img.shields.io/badge/python-3.10%2B-green)
 
 ---
@@ -257,7 +257,7 @@ pipx install sourcecode
 
 ```bash
 sourcecode version
-# sourcecode 1.30.24
+# sourcecode 1.30.26
 ```
 
 ---

{sourcecode-1.30.24.dist-info → sourcecode-1.30.26.dist-info}/RECORD

@@ -1,12 +1,12 @@
-sourcecode/__init__.py,sha256=_G4L9dLoe-xZdbMh8lwWvEdlI0FXQlCazMjnG8FzJ7s,104
+sourcecode/__init__.py,sha256=a9rwjUy_I3zn65HxrEVjs67OAO8DAvBj0eb-iK1rvho,104
 sourcecode/adaptive_scanner.py,sha256=RTNExwWPXzjgLaRueT7UuxkPj5ZEToWjGbx1j0LSZ9E,10250
 sourcecode/architecture_analyzer.py,sha256=MyBa0Hf5HmkudZQDLKrjcWDKETXETXl0mQX1swtTwAA,39091
 sourcecode/architecture_summary.py,sha256=z34_6v7cSwy98cof2UVciGho7SCrZ93tiqMmq5WNzRQ,20405
 sourcecode/ast_extractor.py,sha256=XgrZg2DcWcUm9r87cRG3KGO7IK2TIL_N-CvhSbUmmh4,49901
 sourcecode/classifier.py,sha256=pYve2J1LqtYssU3lYLMDz18PT-CjN5c18QYE7R_IG1Q,7507
-sourcecode/cli.py,sha256=MhXLytfQdGp4L25c6gbhfJyeL5R11ox-wGo-wrO5Ph8,93201
+sourcecode/cli.py,sha256=xNbK_xwsqdhUbAJT4VieJDitGlhMu_O_Y5xzY8yrc9Q,94497
 sourcecode/code_notes_analyzer.py,sha256=y1MJBnPZHYp4i6cQCXUb9ATIyifS_qMQWjw_8lPkpsU,9215
-sourcecode/confidence_analyzer.py,sha256=xw_Jv8pAd0wd8t2vvQlorw8Ih0rSF3YCoFS8K-_4aXg,15762
+sourcecode/confidence_analyzer.py,sha256=H9VHYRzZhqMFlSCZffjtsMUGYLnDvrq1g5FjzyQ1hxE,16381
 sourcecode/context_scorer.py,sha256=QpChSpsmaAYz91rXA4Ue5xzQmNz_ZboZN09YOHScq1U,14679
 sourcecode/context_summarizer.py,sha256=CiQrfBEzun949bWvmLabWoj2HhPn6Lw62ofqnsy0FlQ,6503
 sourcecode/contract_model.py,sha256=nRxJKPMs1VHwFTa8AVXhGmaLjti3Lr2sjHDpWgv1bfE,3917
@@ -16,13 +16,13 @@ sourcecode/dependency_analyzer.py,sha256=p4ljXhkcGBbFlhaZuPrsjOVjDXaKLTg0Gor2p4q
 sourcecode/doc_analyzer.py,sha256=afA4uJFwXZ_uR2l4J0pQwbeTkRkGmKdN9KhRVYePBUw,24331
 sourcecode/entrypoint_classifier.py,sha256=gvKgl0f5T8ol1r4JMmkeqGHuZTfZJiOwFOWdc7EYwYw,4061
 sourcecode/env_analyzer.py,sha256=GxCidahAAIptTdDFIlVB6URd4HBnBlIX_SqUov3MBRQ,22076
-sourcecode/file_classifier.py,sha256=48ly5Z6exkzBy8lNy1AkdP4-oJqIA1zT3LZfffuTyDo,11572
+sourcecode/file_classifier.py,sha256=ur6xDjxIVOj2Or3Ic8LTD0nLguUXFWVRBhamWAKFKeU,11738
 sourcecode/flow_analyzer.py,sha256=dSiuY4w49k29jW_EPXUOND9B5uVbuCA7kjnuHi-pIWA,28781
 sourcecode/git_analyzer.py,sha256=0Gyj-vMpIIN4nfriKXVRouNYBeJ59s6pQDX2Xu9Pq-U,13177
 sourcecode/graph_analyzer.py,sha256=iUK-7pSV-cvGqqD2hENdYmhnm0wcXFEyK-xnu5ul8OU,62515
 sourcecode/metrics_analyzer.py,sha256=m0ENgtqKeBL17kUIK3fmGkgo7UfXBNHxCMj0H_Y5K7c,22750
-sourcecode/pr_comment_renderer.py,sha256=k5pCIP6iBNwy5UYPxu47CAq-62j4E9QZZOPyL3trH80,14799
-sourcecode/prepare_context.py,sha256=uCMZW2_e4yWolItpv_8YszDNA_R00gSIvy-2wz4jry4,165680
+sourcecode/pr_comment_renderer.py,sha256=smHslxiG14lrytCkq5nFrFu-qTHgA-t-LFYfdrfjz2o,14423
+sourcecode/prepare_context.py,sha256=4BwSEXUEuWiYaRZ8wPUcClSW5_Pl1BuUGe-VqM9MSPQ,166688
 sourcecode/progress.py,sha256=qn30sWaHOkjTgXsSBmiPkz7Rsbwc5oSlIe6JNEMYp_k,3149
 sourcecode/ranking_engine.py,sha256=virVglafZufioHpZpwktjMvUiL0TZELWQCQnQNV8dFo,9360
 sourcecode/redactor.py,sha256=xuGcadGEHaPw4qZXlMDvzMCsr4VOkdp3oBQptHyJk8c,2884
@@ -33,7 +33,7 @@ sourcecode/runtime_classifier.py,sha256=zWX3r3HCKHc-qtIobErOa8aKMmaoPYREtJKvPcBG
 sourcecode/scanner.py,sha256=aM3h9-DCQ3xKpeHpHYdo2vX6T5P95HA_YwZbkAVNwmo,8288
 sourcecode/schema.py,sha256=fj3BZ3IcnNV4j21BFIEvz8Qnw_vZoqIbzzRg-qQ-nd0,24530
 sourcecode/semantic_analyzer.py,sha256=12TwXYkYbDcBdu0heX_EmfPM2EkO8a_r5osf0SaeQbs,88956
-sourcecode/serializer.py,sha256=Kyw2Ny1QZeUM4AUsJiXL3Vz65TwDG1i_ySj1pTli9xA,99616
+sourcecode/serializer.py,sha256=bPpZKu9LxrBgpDlGX4qyyO2eQ0PJIFi8bSPb2oC5vhQ,105008
 sourcecode/summarizer.py,sha256=lPlKhMh28nueXkPo2xKeD3DUFYVGRlJMIdY-8TSM-ls,17486
 sourcecode/tree_utils.py,sha256=8GAkIfQAsvtEudIeW1l4ooH_oRtrWR8cpJQJsEa_Pfw,2093
 sourcecode/workspace.py,sha256=X_6NmNnitvT3_38V-JDChydo_sR68s249hLFlrQskU0,8271
@@ -64,8 +64,8 @@ sourcecode/telemetry/consent.py,sha256=wLMvGNJeSSyZoNkQXpoUioY6mMv4Qdvuw7S9jAEWn
 sourcecode/telemetry/events.py,sha256=oEvvulfsv5GIDWG2174gSS6tNB95w38AIYiYeifGKlE,2294
 sourcecode/telemetry/filters.py,sha256=Asa71oRl7q3Wt_FMwuufIZJFzSYdgRNKS8LHCIyFeYE,4805
 sourcecode/telemetry/transport.py,sha256=KJeIPCPWMdmbCP3ySGs2iUlia34U6vWne2dZsUezesw,1560
-sourcecode-1.30.24.dist-info/METADATA,sha256=kS8mWyMiWenuH5JumNncBGMFTYmATgv-K15-W9ZlVYI,28956
-sourcecode-1.30.24.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-sourcecode-1.30.24.dist-info/entry_points.txt,sha256=ex3F9rmbXeyDIoFQHtkEqTsKSaJow8F0LrVu8XfIktQ,57
-sourcecode-1.30.24.dist-info/licenses/LICENSE,sha256=7DdHrU9Z_3e7dSvq4ISijZNjnuHo5NIHNiHDouMQ9JU,10491
-sourcecode-1.30.24.dist-info/RECORD,,
+sourcecode-1.30.26.dist-info/METADATA,sha256=rSYUxd-EVgFu_xcd6eXXfarTlqmqAaMQeP5VlDKfqrU,28956
+sourcecode-1.30.26.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+sourcecode-1.30.26.dist-info/entry_points.txt,sha256=ex3F9rmbXeyDIoFQHtkEqTsKSaJow8F0LrVu8XfIktQ,57
+sourcecode-1.30.26.dist-info/licenses/LICENSE,sha256=7DdHrU9Z_3e7dSvq4ISijZNjnuHo5NIHNiHDouMQ9JU,10491
+sourcecode-1.30.26.dist-info/RECORD,,